Make API documentation



The Make REST API allows using HTTP requests to access Make data and control the Make platform without opening its graphical interface. This allows you to embed Make features into your software, add features on top of the platform, and automate your tasks that you perform in Make. To use the Make API, you need an Make account. Once logged in, you can generate an authentication token and start making calls to the API.

The API allows you to interact with multiple Make resources. This documentation covers the following API resources:

The following API resources are fully functional, but are not covered in this documentation yet:

  • Custom apps
  • Devices
  • Keys

Make API structure

The root URL of the Make API consists of three parts and looks as follows:

Environment URL
The environment of Make you work in. This can be the link to your private instance of Make, for example,, or the link to Make (with or without the zone, depending on a specific endpoint), for example,

Always use HTTPS in your API requests.

API version
The version of the API preceded by /api/

Endpoint (with or without parameters)
Each endpoint represents a resource that you can work with. Endpoints contain required and/or optional parameters. The resources are described in detail in Make resources.

HTTP methods

Make API uses standard HTTP methods to interact with endpoints. The following table lists the available HTTP methods and shows examples of endpoints these methods can be used with.

HTTP method Description

Retrieves a resource representation without modifying it.

returns all available Make scenarios

Creates a resource.

creates a scenario

Updates a resource. If the resource does not exist yet, this method creates it.

sets module data for a scenario with a given ID

Makes a partial update on a resource. Does not replace the entire resource.

updates properties (for example, scheduling or blueprint) of the scenario with a given ID

Removes a resource.

deletes the scenario with a given ID

Rate limiting

Make API limits the number of requests you can send to the Make API. Make sets the rate limits based on your organization plan:

  • Core: 60 per minute
  • Pro: 120 per minute
  • Teams: 240 per minute
  • Enterprise: 1 000 per minute

If you exceed your rate limit, you get error 429 with the message: Requests limit for organization exceeded, please try again later.

Read more about Make pricing.

You can check your organization API rate limit with the API call GET {base-url}/organizations/{organizationId}. In the API call response, the license object contains the property apiLimit with your organization's rate limit.

Check the organization detail API endpoint documentation.

Getting started

This start guide will take you through making your first request to the Make API.

Let's imagine that you would like to list all data stores available in your team. Your team ID is 35. Returned data should be ordered in descending order.

To make your first API call, you need to perform the following actions:

How to:
  1. Create an authentication token. The token gives you access to Make API resources depending on your Make role and assigned scopes. You must include the token in the Authorization header of all requests. Add the word Token and a space before the token itself:
    'Authorization: Token {Your authentication token}'

  2. Choose the endpoint that corresponds to the resource you want to interact with. For this example, you need the /data-stores endpoint. The endpoint requires the teamId query parameter. Place the parameter after the question mark in the endpoint URL. To filter results, you also need the parameter for ordering datapg[sortDir]:

    The environment URL refers to the Make platform you interact with.
  3. Prepare the full request and send it. In this case, use cURL to making the request. You want to retrieve data without modifying it—use the GET method. Let’s put elements from the previous steps together.

    The following request example contains a sample authentication token. Don't use it in your requests. Generate your own token.

    Always include a request body in POST, PUT, or PATCH requests.

  4. Evaluate the response. The API returns 200 OK and a list of all data stores for the specified team. If your request failed, you receive an error code. Refer to Troubleshooting and error handling to troubleshoot the issue.

curl --location \
--request GET '' \
--header 'Content-Type: application/json' \
--header 'Authorization: Token 93dc8837-2911-4711-a766-59c1167a974d'
  "dataStores": [
      "id": 15043,
      "name": "Old data store",
      "records": 10,
      "size": "620",
      "maxSize": "1048576",
      "teamId": 35
      "id": 13433,
      "name": "New data store",
      "records": 1,
      "size": "48",
      "maxSize": "1048576",
      "teamId": 35
  "pg": {
    "sortBy": "name",
    "limit": 10000,
    "sortDir": "asc",
    "offset": 0


Make roles and API scopes

Accessibility of Make API endpoints differs depending on the Make platform you use. On Make and our hosted cloud version, regular users cannot access the administration interface. Administration API resources are meant only for internal Make administrators.

In the on-premise version, any user with a platform administration role assigned can access the administration interface. These users can also access API endpoints that are meant for administrators.

Access to the Make API resources depends also on the scopes assigned to the authentication token. Some resources require more than one scope. There are two types of scopes-read and write.

Read scope :read
Allows you to use the GET method with endpoints, usually to get a list of resources or a resource detail. No modification is allowed.

Write scope :write
Allows you to use the POST, PUT, PATCH, or DELETE methods with endpoints to create, modify, or remove resources.

Even if you are not the administrator, you can assign to your token the scopes meant for administrators. However, if you try to access the admin resources as a regular user, you will receive the 403 Access denied error in response.
Administration scopes (only for administrators of on-premise Make platforms)

  • admin:read
    • Allows getting all resources and information available only to administrators — all resources that are available in the administration interface, such as collections of all created users, templates, scenarios, and custom and native apps for the whole platform and all their details.
  • admin:write
    • Allows performing all actions available only to administrators — all actions that can be performed in the administration interface, such as creating organizations, deleting approved templates, reviewing custom apps, creating and deleting new users, overwriting scenarios and templates settings.

  • apps:read
    • Allows getting a collection of all native apps.
    • Allows getting details of a native app.
  • apps:write
    • Allows updating a native app.
    • Allows deleting a native app.

  • system:read
    • Allows reading the Make platform settings.
  • system:write
    • Allows modifying the Make platform settings.
Standard user scopes (for all users of Make platforms)

  • connections:read
    • Allows retrieving connections for a given team.
    • Allows getting details of a connection.
  • connections:write
    • Allows creating new connections.
    • Allows updating connections.
    • Allows deleting connections.
    • Allows setting data for connections.
    • Allows verifying connections.
    • Allows checking if a connection scope is limited.

  • datastores:read
    • Allows getting all data stores for a given team.
    • Allows getting records from a data store.
  • datastores:write
    • Allows creating new data store.
    • Allows updating data stores.
    • Allows deleting data store.
    • Allows modifying the records of a data store.

  • devices:read
    • Allows retrieving all devices for a given team.
    • Allows getting details of a device.
  • devices:write
    • Allows creating new devices.
    • Allows updating devices.
    • Allows deleting devices.

  • dlqs:read
    • Allows getting all incomplete executions of a given scenario.
    • Allows getting details of an incomplete execution.
    • Allows getting bundles, blueprints, and logs of an incomplete execution.
  • dlqs:write
    • Allows updating incomplete executions.
    • Allows deleting incomplete executions.

  • hooks:read
    • Allows getting all hooks (mailhooks and webhooks) for a given team.
    • Allows getting hook requests.
    • Allows checking if a hook is active.
  • hooks:write
    • Allows creating new hooks.
    • Allows updating hooks.
    • Allows deleting hooks.
    • Allows enabling or disabling hooks.
    • Allows starting or stopping the automatic determination of a data structure for a hook.
    • Allows setting data for hooks.

  • keys:read
    • Allows getting all keys for a given team.
    • Allows getting key types.
  • keys:write
    • Allows creating new keys.
    • Allows updating keys.
    • Allows deleting keys.

  • notifications:read
    • Allows getting all notifications for a given user.
    • Allows getting details of a notification.
  • notifications:write
    • Allows marking notifications as read.
    • Allows deleting notifications.

  • organizations:read
    • Allows getting all organizations to which the authenticated user belongs.
    • Allows getting installed apps, invitations, user roles, and basic details of organizations.
  • organizations:write
    • Allows creating new organizations (only for admins).
    • Allows updating organizations.
    • Allows deleting organizations.
    • Allows accepting invitations to organizations.
    • Allows adding members to organizations.
  • organizations-variables:read
    • Allows getting data of organization variables to which the authenticated user belongs.
    • Allows getting the history of updates of custom organization variables.
  • organizations-variables:write
    • Allows creating custom organization variables.
    • Allows updating custom organization variables.
    • Allows deleting custom organization variables.

  • scenarios:read
    • Allows getting all scenarios for a given team or organization.
    • Allows getting details of a scenario.
    • Allows getting properties of triggers included in scenarios.
    • Allows getting scenario blueprints.
    • Allows getting blueprint versions.
    • Allows getting scenario logs.
    • Allows getting scenario folders.
  • scenarios:write
    • Allows creating new scenarios and scenario folders.
    • Allows updating scenarios and scenario folder.
    • Allows cloning scenarios.
    • Allows publishing scenario drafts.
    • Allows configuring module settings in a scenario.
    • Allows verifying whether module settings are set or not.
    • Allows starting and stopping scenarios.
    • Allows deleting scenarios and scenario folders.
  • scenarios:run
    • Allows executing a scenario.

  • sdk-apps:read
    • Allows getting all custom apps for the authenticated user.
    • Allows getting information from specific configuration sections of a custom app.
    • Allows getting invitation details for an app.
  • sdk-apps:write
    • Allows creating custom apps.
    • Allows managing configuration of custom apps.
    • Allows cloning custom apps.
    • Allows requesting review of custom apps.
    • Allows rolling back changes made in custom apps.
    • Allows uninstalling custom apps from organizations.
    • Allows deleting custom apps.

  • teams:read
    • Allows getting all teams that belong to a given organization.
    • Allows getting details of a team.
    • Allows getting all team roles.
    • Allows getting details of a team role.
  • teams:write
    • Allows creating new teams.
    • Allows updating teams.
    • Allows deleting teams.
  • teams-variables:read
    • Allows getting data of team variables to which the authenticated user belongs.
    • Allows getting the history of updates of custom team variables.
  • team-variables:write
    • Allows creating custom team variables.
    • Allows updating custom team variables.
    • Allows deleting custom team variables.

  • templates:read
    • Allows retrieving all private templates for a given team.
    • Allows getting all public templates.
    • Allows getting private or public template details.
    • Allows getting private or public template blueprints.
  • templates:write
    • Allows creating new templates.
    • Allows updating templates.
    • Allows deleting templates.
    • Allows publishing private templates.
    • Allows requesting approval of published templates.

  • udts:read
    • Allows retrieving all data structures for a given team.
  • udts:write
    • Allows creating new data structures.
    • Allows updating data structures.
    • Allows deleting data structures.
    • Allows cloning data structures.

  • user:read
    • Allows getting all users who belong to a given team or organization.
    • Allows getting API authentication tokens assigned to the currently authenticated user.
    • Allows getting organization invitations assigned to the currently authenticated user.
    • Allows getting organization invitations assigned to a user.
    • Allows getting organization and team roles that can be assigned to any user.
    • Allows getting a number of unread notifications for the currently authenticated user.
    • Allows getting organizations invitations for a user.
    • Allows getting details of an invitation to an organization for a user.
    • Allows getting details of a notification assigned to a user in a given team.
    • Allows getting team roles of a user.
  • user:write
    • Allows setting a user role for a given team.
    • Allows setting a user role in a given organization.
    • Allows transferring organization ownership to a user.
    • Allows updating a notification for a user in a given team.
    • Allows creating a new API authentication token for a currently authenticated user.
    • Allows deleting an API authentication token identified by timestamp for a currently authenticated user.
    • Allows deleting an account of a currently authenticated user.
    • Allows updating details of a user.

Generating authentication token

Make API uses authentication tokens to authenticate requests. You must include your authentication token in the headers of all requests that you send to the API.

Generate and manage API tokens from your profile in the Make interface.

If you have access to multiple Make environments, generate separate tokens for each of them.
How to:
  1. Sign in to Make and click your avatar at the bottom-left corner of the page.
  2. Click Profile.
  3. Open the API tab.
    Choose API
  4. Click Add token.
    Add token
  5. In the Add token dialog, do the following:
    Label — type a custom name for your token that will help you recognize what the token is used for
    Scopes — select the scopes you need for working with API resources. For more information about scopes, refer to Make roles and API scopes.
  6. Click Save.

Make generates your token. Copy it and store it in a safe place.

Do not share your token with anyone!

Once you leave the Profile section, parts of your token will be hidden for security reasons. You won't be able to see or copy your token again.

With an active token, you are ready to make API calls. For more details, refer to the Getting started section.

Managing authentication token

After you generate your authentication token and open the API tab in your profile again, you can no longer change the token or the scopes assigned to the token. You can only view the initial part of the token value and view the scopes.

To manage your tokens:

How to:
  1. Sign in to Make Make click your avatar at the bottom-left corner of the page.
  2. Click Profile.
  3. Open the API tab.
  4. Click one of the following buttons:
    Show scopes — to see scopes that are assigned to the token.
    Delete — to permanently remove the token.
  5. Click Save.

Since editing the token is not possible, you can always delete the old token and replace it with a new one. You will need to do this if you decide to add or remove scopes from your authentication token.

Pagination, sorting and filtering

The majority of responses containing a collection of resources are paginated. Pagination limits the number of returned results per request to avoid delays in receiving a response and prevent overloading with results. Thanks to pagination, the API can run at its best performance.

You set pagination, sorting, and filtering parameters in query parameters. Separate multiple query parameters using the & symbol. The order of the parameters does not matter.

Pagination and filtering parameters contain square brackets - [ and ]. Always encode them in URLs.

Pagination and sorting

Defines the maximum number of results to return. For example, pg[limit]=100. The default value varies with different resources.

Defines the number of results you want to skip before getting the results you need. For example, pg[offset]=10. The default value for most endpoints is 0.

Defines the property by which to sort results. For example, pg[sortBy]=id. By default, results are usually sorted by name or id.

Defines the sorting order. Use asc for ascending order, use desc for descending order. The default ordering direction is usually ascending.

Let’s say we want to retrieve data stores that belong to the team with ID 212.

How to:
  1. The request URL with the default pagination settings looks as follows:
  2. Add the pagination parameters
    In this case, we want to skip the first 10 results, limit the results to 50 data stores and sort them in ascending order. Use the following query parameters:
  3. The full request URL looks like this:


Use the cols[] parameter to select values you want in the response. You can also use the cols[] parameter to get values that the endpoint does not return by default. The set of available filtering values is different for each endpoint. Check the example API call responses to see what data you can get from the API call.

Specify the cols[] parameter multiple times in the API call to get multiple values from the endpoint. You can put numbers in the brackets to specify order in which you want to list the values in the API call response.

Example: Get only the name, id and teams in the specified organization. List the data in order: name, id, teams.

How to:
  1. The request URL snippet to get the `name`, `id` and `teams` values of the specified organization, in the specified order, looks like this: /organizations/{organizationId}?cols[1]=id&cols[2]=name&cols[3]=teams
  2. After encoding the square brackets you get the following request URL. The `organizationId` in our test case is 8013:
  3. The full request looks like this:
    GET {base-url}/organizations/8013?cols%5B1%5D=id&cols%5B2%5D=name&cols%5B3%5D=teams

Some endpoints have specific filtering parameters. For example, in the /templates endpoint you can use the usedApps[] parameter. The usedApps[] parameter allows you to get only the templates containing specific apps.

Troubleshooting and error handling

HTTP status codes of errors

This article describes the most frequent error codes returned by the Make API. If you need help resolving common issues related to the Make API, refer to the Troubleshooting section. If your request is incorrect, in the response, you can find the details of the error that should help you to troubleshoot. All Make API errors have the same schema. Below you can see the example of a response for the request with the incorrect parameter. This can happen, for example, when you request a resource you do not have access to:


  "detail": "Access denied.",
  "message": "Permission denied",
  "code": "SC403",
Standard error responses
HTTP status Explanation

Bad request

The server could not understand the request due to invalid syntax. This could happen, for example, due to the invalid data type and prohibited data duplication. Below you can find examples of more specific error messages related to some features:


  • Invalid connection type
  • Invalid scope
  • Common data must be a collection

Data stores and data structures

  • teamId validation failed


  • Unknown identifier format
  • Some of the incoming messages could not be deleted because they are being processed right now
  • Some of the outgoing messages could not be deleted because they are being processed right now
  • Some of the executions could not be deleted because they are being processed right now


  • Some of the executions could not be deleted because they are being processed right now


  • Missing value of required parameter


  • Invalid input file
  • File is too big
  • File is not a valid primary key
  • File is not a valid certificate


  • User has no organization in the zone


  • teamId and organizationId cannot be used together
  • Missing required parameter teamId or organizationId
  • Invalid key, not parsable to integer


  • Validation failed for templateUrl unknown format


  • Invalid response from the repository
  • Failed to attach to the pap installation
  • Failed to finish installation
  • App uninstallation failed
  • Invalid install specification
  • Install file of the pap is not valid


You do not have access rights to the content which means that your request was unauthorized.

Not Found

The server cannot find the requested resource (probably it does not exist) even if the endpoint is valid. Servers may also send this response instead of 403 to hide the existence of a resource from an unauthorized client.

This code may appear, for example, when you try to get details of the nonexistent/removed scenario, team, template, user, organization or app.

Payload Too Large

The request entity exceeded the limits set on the server. Below you can find examples of more specific error messages related to the Apps feature:


  • Failed to save image. Invalid upload
  • Failed to save image. Image is too big
  • Commit message is too big

Failed Dependency

The request failed due to failure of a previous request. Below you can find examples of more specific error messages related to the Connections and Apps features:


  • Connection action crashed
  • Connection action timed out


  • Failed to load manifest for app
  • Remote procedure crashed
  • Remote procedure timed out

Too many requests

You have exceeded the rate limit of API requests for your organization. Wait for one minute for the limit period to reset. Check the API rate limiting section for more information.

Service Unavailable

A dependency is currently unavailable. This error code may appear, for example, in relation to unavailable dependencies for DLQs, scenarios or teams.

Account Does Not Exist

This error appears when the account does not exist or it was not found.

Custom error codes
HTTP status Explanation


Access Denied

This error code indicates the lack of rights to perform specific actions. Below you can find examples of more specific error messages related to the Apps feature:


  • The user cannot change the password
  • The user cannot change the email


  • Cannot disapprove app

Insufficient Rights

This error appears when you do not have sufficient rights to interact with the resource.

Storage Not Enough Space

This error appears when limit of data stores storage is exceeded.

Confirmation Required

This error appears when the removal process of the key in the data stores is not confirmed.

Invalid Input Parameters

This error appears when you use invalid parameters in a request. Below you can find examples of more specific error messages related to some features:


  • Invalid hook type


  • There is nothing to configure in this connection


  • The user cannot be part of any organization

Entity Limit Exceeded

This error appears when you exceed the limit for password change attempts.

Action is not possible due to dependencies

This error appears when you don't fulfill requirements to execute the API call. For example:

Scenario inputs

  • If you have required scenario inputs you have to set the scenario scheduling to On demand.

Invalid Credentials

This error appears when you use the invalid password.


This section describes most common mistakes that result in API-related problems, such as receiving Access denied or Not found errors. You can also refer to the HTTP status codes of errors for more details.

Using HTTP instead of HTTPS in the URL
Use HTTPS at the beginning of the URL in your request. This is required for security reasons.
Using an incorrect environment
If you have access to more than one Make environment, ensure that you use the correct environment in the URL and that you use a valid authentication token generated for this specific environment.
Using an incorrect endpoint
Ensure there are no empty or white spaces in the endpoint URL and that there are no backslash symbols at the end of the URL after the endpoint name.
Missing authentication details or using incorrect authentication details
Ensure that you are using the correct authentication details. To make a successful request, you need to have the correct authentication token with the correct scopes assigned to it.
Note that you need a separate token for each Make environment.
Missing access to the requested resource
Ensure that scopes assigned to your authentication token correspond to the requested resource.
Note that you cannot access administrator resources if you are a regular Make user.
Missing required parameters or using invalid or improperly formatted parameters
Many endpoints require at least one mandatory parameter. Often it is the teamId or an ID of the specific resource. Do not forget to add the required parameters to the request. Also, note that query, path, and pagination parameters need to be properly formatted. The first query parameter should start with a question mark. Separate parameters with the ampersand symbol. Some special characters, for example, in the pagination parameters, need to be encoded when used in URLs.
Sending an invalid or improperly formatted request body
The structure of the API request body must conform to the JSON schema standard. You can use JSON validators available on the internet to validate your request body before sending it.
If your issue is not mentioned in the table above and the error code and message do not indicate how to resolve the issue, please contact us via the help form at Make Help center. Include a detailed description of the problem, the full request, and the error code and error message that you received.


API resources are grouped into sections corresponding with Make features and components.

Each endpoint resource contains the following details:

Methods and endpoints

Methods define the allowed interaction and endpoints define how to access the resource — what URI should be used to interact with a resource.
Example: GET /data-stores

Required scopes

Defines what resources you are allowed to interact with based on scopes you selected when generating your API access token.
Example: datastores:write

Resource description

Describes the expected outcome when using an endpoint, and what Make features the resource relates to.


These are options you can include with a request to modify the response. Each parameter specifies whether it is required or not. Parameters are divided into two main groups:

  • Path parameters — path parameters are always required. They are used to identify or specify the resource (usually by indicating its ID) and they should be placed inside the endpoint URI. Example: /data-stores/54

  • Query parameters — query parameters are often optional. They can be used to specify the resource but they are usually used as parameters to sort or filter resources. They are placed at the end of the endpoint URI, after a question mark. Separate multiple parameters with an ampersand symbol. If a parameter contains square brackets, encode them. Example: /data-stores?teamId=123&pg%5Boffset%5D=10

  • Request body — for some endpoints (mainly connected with the POST, PUT, or PATCH HTTP methods), you can also see the Request body section in the endpoint details. This section contains the description of the payload properties that are needed to modify the resource.


      "name": "Customers",
      "teamId": 123,
      "datastructureId": 178,
      "maxSizeMB": 1

Request examples

These are request samples that show how to make a request to the endpoint. They consist of the request URL and authentication token (if needed) and other elements required to make a request in the selected language. Example of request for creating a data store:

Response examples

These are response samples you would receive when calling the request in real life. The outcome strictly depends on the request sample. The response schema contains all possible elements available in the response. Each response has its status code. Example of created data store:

curl -X POST \
--header 'Content-Type: application/json' \
--header 'Authorization: Token 93dc8837-2911-4711-a766-59c1167a974d' \
-d '{"name":"Customers","teamId":123,"datastructureId":1234,"maxSizeMB":1}'
  "dataStore": {
    "id": 20024,
    "name": "Customers",
    "teamId": "123",
    "datastructureId": 1234,
    "records": 0,
    "size": "0",
    "maxSize": "1048576"



For most apps included in Make, it is necessary to create a connection, through which Make will communicate with the given third-party service according to the settings of a specific scenario. The following endpoints allow you to create and manage connections.

List connections

Create connection

Get connection details

Update connection

Delete connection

Verify connection

Verify if connection is scoped

Set connection data

List updatable connection parameters

Data stores

Data stores are used to store data from scenarios or for transferring data in between individual scenarios or scenario runs. The following endpoints allow you to create and manage data stores.


The following endpoints allow you to create and manage records in data stores.

List data store records

Create data store record

Delete data store records

Update entire data store record

Update data store record details

List data stores

Create data store

Delete data stores

Get data store details

Update data store

Data structures

Data structures define the format of the data being transferred to the Make platform. For example, they are widely used by the Data stores component. The following endpoints allow you to create and manage data structures.

List data structures

Create data structure

Update data structure

Delete data structure

Clone data structure

Incomplete executions

If a scenario terminates unexpectedly because of an error, then the scenario run is discarded. You can set the scenario to store the failed scenario run as an incomplete execution. With that, if an error occurs in your scenario, you can resolve it manually and avoid losing data. Read more about the [incomplete executions](

List scenario incomplete executions

Delete scenario incomplete executions

Incomplete execution detail

Update incomplete execution

Get failed scenario blueprint

Get incomplete execution bundles

List incomplete executions logs

Incomplete execution log detail


The parameters with a predefined set of values are called \"enums.\" The enums endpoints list the mappings of a possible parameter values and the IDs of those values. For example, the endpoint `/enums/timezones` lists the timezone `name` and `code`, such as `Europe/Berlin`, and the `timezoneId`.

List timezones

List countries

List locales

List languages

List email notification settings

List API token scopes

List Make regions

List Make zones

List variable types


This section contains endpoints that provide general functionality for the Make API.



Hooks refer to the webhooks and mailhooks available in the various apps in the Make interface. They notify you whenever a certain change occurs in the connected app or service, such as sending an HTTP request or an email. The following endpoints allow you to create and manage hooks.


When data arrive to a scheduled webhook, Make places the data in the webhook processing queue. Webhooks process data in the same order as they arrive. The following endpoints allow you to inspect and update the webhook processing queue.

Get webhook queue

Delete items from webhook queue

Get webhook queue item detail

Get webhook queue stats


Make stores a log of every webhook execution. Make stores webhook logs for 3 days. The webhook logs for organizations with the Enterprise plan are stored for 30 days. [Read more about webhook logs]( The following endpoints allow you to retrieve webhook logs.

Get webhook logs

Get webhook execution detail

List hooks

Create hook

Get hook details

Delete hook

Update hook

Ping hook

Learn start

Learn stop

Enable hook

Disable hook

Set hook details


The **Notifications** feature keeps you informed about problems in your scenarios and keep you up to date when it comes to the new features and improvements in Make. The following endpoints allow you to manage the notifications.

List notifications

Delete notifications

Get notification detail

Mark all notifications as read


Organizations are main containers that contain all teams, scenarios, and users. The API endpoints discussed further allow you to manage organizations. [Read more about organizations](

User organization roles

User organization roles define user permissions in the organization. The endpoints discussed further retrieve information about user roles in the organization. Use the `/users/{userId}/user-organization-roles/{organizationIdId}` to manage user organization roles. Check out the [overview of user organization roles and the associated user permissions](

List user roles

Get user organization role details

Transfer organization ownership

List user organizations

Create an organization

Get organization details

Update organization information

Delete an organization

Get a list of custom apps

Invite a user to the organization

List organization variables

Create organization variable

Update organization variable

Delete organization variable

History of custom variable updates


**Scenarios** allow you to create and run automation tasks. A scenario consists of a series of modules that indicate how data should be transferred and transformed between apps or services. The following endpoints allow you to create, manage and execute scenarios and also inspect and manage [scenario inputs](


The following endpoints allow you to manage scenarios logs.

List scenario logs

Get execution log


The following endpoints allow you to manage scenarios blueprints.

Get scenario blueprint

Get blueprint versions


Scenario consumption is the information about the number of operations and data transfer used by a scenario. The following endpoints retrieve information about your scenarios consumptions in your current restart period. You can view the end of your current restart period in your dashboard in the **Usage reset** field.

List scenario consumptions

List scenarios

Create scenario

Get scenario details

Update scenario

Delete scenario

Get trigger details

Clone scenario

Set module data

Check module data

Activate scenario

Deactivate scenario

Execute scenario

Publish scenario

Get scenario interface

Update scenario interface

Scenarios folders

Scenarios can be grouped into folders for better organization. The following endpoints allow you to create and manage scenarios folders.

List scenario folders

Create scenario folder

Update scenario folder

Delete scenario folder


Teams are containers that contain scenarios and data accessible only by the members of the team. The API endpoints discussed further allow you to manage teams. [Read more about teams](

User team roles

User team roles define user permissions in the team. The endpoints discussed further retrieve information about user roles in the team. Use the `/users/{userId}/user-team-roles/{userId}` endpoint to manage user team roles. Check out the [overview of user team roles and the associated permissions](

List user roles in the team

Get user team role details

List teams

Create a team

Get team details

List team variables

Create team variable

Update team variable

Delete team variable

History of custom variable updates


The **Templates** feature allows you to create and use templates as a starting point for your Make scenarios. By default, Make offers hundreds of templates containing the scenarios of most-used apps. The following endpoints allow you to create and manage templates.


The following endpoints focus on the public (approved) templates that are available to every user regardless of the organization and team.

List public (approved) templates

Get public (approved) template details

Get public (approved) template blueprint

List templates

Create template

Get template details

Update template

Delete template

Get template blueprint

Publish template

Request approval


The following main user endpoints allow you to get a list of existing users and manage their basic details such as password change.


The following endpoints retrieve data about the currently authenticated user.

Current user data

User Organization invitations

Me > API Tokens

The following endpoints manage and retrieve data about the API tokens assigned to the currently authenticated user.

List users API tokens

Create new API token

Delete API token

User team roles

The following endpoints update and retrieve data about user team roles of a user in a team. Check out the [overview of user team roles and the associated permissions](

List user roles

Get user team role detail

Update user role

User team notifications

The following endpoints update and retrieve data about user team notifications settings of a user in a team. [Read more about user team notifications](

List user team notification settings

Check user's notification settings

Update user's notification settings

User organization roles

The following endpoints update and retrieve data about user organization roles of a user in an organization. Check out the [overview of user organization roles and the associated permissions](

List user roles in an organization

Get user organization role details

Update user role

Transfer organization ownership


The following endpoint retrieves the mapping of a `userRoleId` parameter and user role name.

User role definitions

Unread notifications

The following endpoint retrieves the number of unread notifications of the currently authenticated user.

Unread notifications

List users

Update user

Update user email

Update user password

Send password reset demand

Set session for resetting lost password

Reset lost password