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 create an authentication token or request an OAuth 2.0 connection and start making calls to the API.

The API allows you to interact with multiple Make resources.

The Make API follows the REST API design. Make API is organized into resource-oriented URLs which also set the sections in the API Reference part of the documentation.

To get yourself familiar with the basics of working with the Make API, continue reading to the Getting started section or jump directly into making your first API request.

All requests to the Make API require authentication with the user authentication token with the relevant scopes enabled. To learn more about authentication in the Make API, go to the Authentication section. You can also learn about the various API scopes in the scopes overview.

If you are experiencing issues with the Make API, go to the Troubleshooting section for tips about what could go wrong and how to fix it.

To ensure security and support proper token rotation, the tokens issued during the OAuth flow have the following defined expiration periods:

Access token: 5 minutes

The Access token has a short lifespan and is intended for immediate use. It is recommended to refresh the token to obtain a new access token when the current one expires.

Refresh token: 6 months

The Refresh token provides long-term access without requiring the user to re-authorize frequently. The Refresh token should be securely stored and used to acquire new access tokens. In case of a token leak or compromise, the Refresh token can be immediately revoked by from your user profile in the API access section.

Authorization code: 5 minutes

The Authorization code is intended for single-use and must be exchanged for an Access token and Refresh token within it's expiration window.

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:

Read more about Make .

The Make API requires authentication of the API requests with your API tokens or your OAuth 2.0 connection. If your requests are not authenticated, the Make API will return an authentication error.

Authentication token

To authenticate your API request, send your API token in the following HTTP header parameter:

Authorization: Token 12345678-12ef-abcd-1234-1234567890ab

The authentication token always contains information about the access to the API resources. The authentication token access is defined with API scopes. If you want to learn about Make API scopes, continue to the Make API scopes overview.

To learn how to create and manage your API token, go to the creating and management sections.

OAuth 2.0 connection

As an alternative to using an authentication token, you can request an OAuth 2.0 connection to access resources on the Make platform. OAuth 2.0 access is defined with API scopes. To learn more about this connection type and to request access, continue to the section.

The URL of the Make API consists of three parts:

for example:

Base URL

Base URL is the core part of an API URL. API endpoint URLs are always relative to the base URL.

The {zone_url}/api/{version} form the base URL of the Make API. For example, the URL https://eu1.make.com/api/v2 is a base URL for the Make API for organizations in the EU1 zone.

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.

This guide explains how to integrate Make into your application using OAuth 2.0 authorization. For general OAuth 2.0 concepts, refer to the .

Before implementing OAuth 2.0, you must with Make's authorization server to obtain:

• Client ID (required for all clients)

• Client Secret (only for confidential clients)

After you 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:

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.

Make's API uses OAuth 2.0 authorization protocol to enable secure third-party access. This standard security framework allows applications to interact with Make's resources while protecting sensitive credentials.

To be able to start using OAuth 2.0, your app has to request a client on our side.

How to submit a registration request

Our team will review your request within 10 business days. Upon approval, you'll receive the necessary credentials to integrate your application with the Make platform.

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

Example: 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:

'Authorization: Token {Your authentication token}'

Use this flow when: Your application can securely store a Client Secret (server-side applications).

Benefits: Provides both access tokens and refresh tokens for long-term access.

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

Each endpoint resource contains the following details:

Methods and endpoints

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

Use this flow when: Your application cannot securely store secrets (SPAs, mobile apps).

Note: This flow typically does not provide refresh tokens for security reasons.

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.

pg[limit]

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

pg[offset]

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.

pg[sortBy]

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

pg[sortDir]

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

Example:

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

The Make API uses standard HTTP error codes in combination with custom Make error codes.

In general:

• a response status code 2xx means succesfull request

• a response status code 4xx means error on the client side

• a response status code 5xx means error on the server side (internal error in Make)

For more information, check detailed overview of error types and their possible causes in the .

For general troubleshooting tips, check out the section.

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.

The following endpoints allow you to get the organization and team audit logs and their details.

You can read more about audit logs in our Help Center.

The following endpoints allow you to get analytics data for your organization. Make uses the analytics data to create analytics dashboards.

The following endpoints allow you to get, create, and delete Context for AI Agents. These endpoints are available in open beta to all users. As beta endpoints, both functionality and availability may change.

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 manage items in a custom property structure.

To use custom properties, you have to:

1. Create a custom properties structure.

2. Create custom properties structure items.

3. Fill the items with data.

Read more about custom properties in the ."

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

In Make, you need to create a connection for most apps. Make then uses this connection to communicate with the third-party service and to authenticate your requests to the third-party service. The following endpoints allow you to create and manage connections.

The following endpoints allow you to inspect supported AI Providers connections and retrieve the list of supported models. These endpoints are available in open beta to all users. As beta endpoints, both functionality and availability may change.

The following endpoints allow you to manage scenarios blueprints.

The following endpoints allow you to get, create, update, delete, and run AI Agents. These endpoints are available in open beta to all users. As beta endpoints, both functionality and availability may change.

The following endpoints allow you to manage and retrieve metadata for authentication keys in your custom keychain. You can use these keys to manage your authentication in the HTTP or encryptor apps similarly to other connections.

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

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 .

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.

Scenario consumption refers to information about the number of centicredits, operations, and data transfer used by a scenario. The following endpoints retrieve information about your scenario consumption during your current restart period. You can view the end of your current restart period in your dashboard under the Usage reset field.

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. .

The following endpoints allow you to retrieve webhook logs.

Custom functions are functions you or your team members create that you can use in a scenario. The following API endpoints allow you to:

• list

• evaluate

• create

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

The following endpoints allow you to manage tools.

The following endpoints retrieve data about the currently authenticated user.

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.

The following endpoints allow you to manage custom scenario properties data.

To use custom properties, you have to:

1. Create a custom properties structure.

2. Create custom properties structure items.

3. Fill the items with data.

Read more about custom properties in the

The Make Typescript SDK provides full support for type definitions and a majority of Make API endpoints, built-in error handling, and response typing. It is fully compatible with pure JavaScript projects.

TypeScript is a syntactic superset of JavaScript. It features additional capabilities like optional static typing, interfaces, and advanced OOP features like classes and inheritance. TypeScript allows for the specification of types of variables, function parameters, and return values, enabling the detection of type-related errors during development rather than at runtime.

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 manage and retrieve data about the API tokens assigned to the currently authenticated user.

The following endpoints update and retrieve data about user team roles of a user in a team. Check out the .

Security best practices

• Validate the state parameter to prevent CSRF attacks

• Store secrets securely (confidential clients only)

• Implement proper error handling for expired or invalid tokens

Common scopes

• openid: Required for OpenID Connect authentication

• Add other Make-specific scopes as needed for your application

Error handling

Common error responses from the token endpoint:

Always check the response status and handle errors appropriately in your application.

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.

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.

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.

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.

The following endpoints allow you to create and list custom property structures.

To use custom properties, you have to:

1. Create a custom properties structure.

2. Create custom properties structure items.

3. Fill the items with data.

Read more about custom properties in the custom properties feature documentation.

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

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.

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 error codes 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 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.

• 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 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.

Managing of SSO certificates.

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

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

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.

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.

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.

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

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

The following endpoints allow you to manage scenarios logs.

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. .

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:

Example:

Standard HTTP error statuses

Custom Make error codes

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.

Administration scopes (only for administrators of Make White Label platforms)

Standard user scopes (for all users of Make platforms)