Make

Get execution (executions): Get details of a specific execution.

List folders (folders): List folders for a team.

Create folder (folders): Create a new folder.

Update folder (folders): Update an existing folder.

Delete folder (folders): Delete a folder.

List webhooks/mailhooks (hooks): List webhooks/mailhooks for a specific team.

Get webhook/mailhook (hooks): Get details of a specific webhook/mailhook.

Create webhook/mailhook (hooks): Create a new webhook/mailhook.

Update webhook/mailhook (hooks): Update an existing webhook/mailhook.

Delete webhook/mailhook (hooks): Delete a webhook/mailhook.

List data structures (data-structures): List data structures for a team.

Get data structure (data-structures): Get details of a specific data structure.

Create data structure (data-structures): Create a new data structure.

Update data structure (data-structures): Update an existing data structure.

Delete data structure (data-structures): Delete a data structure.

List connections (connections): List connections for a team.

Get connection (connections): Get details of a specific connection.

List keys (keys): List all keys for a team.

Get key (keys): Get details of a specific key.

Delete key (keys): Delete a key.

List credential requests (credential-requests): Retrieve a list of credential requests. Each request can contain multiple credentials (connections and API keys). Filter by team, user, provider, status, or name to find specific requests.

Get credential request details (credential-requests): Retrieve detailed information about a specific credential request by its ID. Returns all associated credentials with their authorization status, provider configuration, user details, and authorization URLs for pending credentials. Use this to check the state of credentials within a request.

Delete credential request (credential-requests): Permanently delete a credential request and all associated credentials (connections and API keys) by ID. Any scenarios using connections from this request will lose access to the corresponding services. This action cannot be undone.

Decline credential (credential-requests): Decline a credential authorization request by ID, setting its status to "declined" and preventing it from being authorized. An optional reason can be provided to explain the decision. This operation is idempotent - declining an already-declined credential has no additional effect.

Delete credential (credential-requests): Delete a credential (e.g., revoke OAuth tokens or remove stored API keys) and reset its state to pending. Use this when a credential needs re-authorization with updated permissions, tokens have become stale, or you want to force re-authentication. After deletion, the credential can be authorized again through the normal flow.

Create credential request (credential-requests): Create a credential request for the currently authenticated user to set up connections and keys. This will return a URL where the user can authorize the credentials, so that they can be used in scenarios.

Create credential request by connection/key types (credential-requests): Create a credential request for one or more connections (OAuth) and/or keys (API keys) by their type identifiers (e.g. "google", "slack", "apikeyauth"). Use this when you know the exact connection or key types needed. The response includes the created request, an array of credentials associated with the request, and a publicUri where the end-user must go to authorize the requested credentials. At least one connection or one key must be provided.

Extend connection OAuth scopes (credential-requests): Add new OAuth scopes to an existing connection. Use this when a connection exists but lacks the permissions (scopes) needed for a specific operation. Creates a credential request that the end-user must authorize via the returned publicUri to grant the additional scopes. Fails if all requested scopes are already present on the connection.

List app modules with credentials (credential-requests): List all modules of a given Make app (and version) that require credentials, along with the required credential type and OAuth scopes. Use this to discover which modules exist for an app before constructing a credential request — the returned `id` values are what you pass in `credentials[].appModules` for `credential-requests_create`. For custom/SDK apps, prefix the app name with `app#` (e.g. `app#my-custom-app`).

List data stores (data-stores): List all data stores for a team.

Get data store (data-stores): Get data store details by ID.

Create data store (data-stores): Create a new data store.

Update data store (data-stores): Update a data store.

Delete data store (data-stores): Delete a data store.

List data store records (data-store-records): List all records in a data store.

Create data store record (data-store-records): Create a new record in a data store.

Update data store record (data-store-records): Update an existing record in a data store.

Replace data store record (data-store-records): Replace an existing record in a data store or create if it doesn't exist.

Delete data store records (data-store-records): Delete specific records from a data store by keys.

List teams (teams): List teams for the current user.

Get team (teams): Get details of a specific team.

Create team (teams): Create a new team.

Delete team (teams): Delete a team.

List organizations (organizations): List organizations for the current user.

Get organization (organizations): Get details of a specific organization.

Create organization (organizations): Create a new organization.

Update organization (organizations): Update an existing organization.

Delete organization (organizations): Delete an organization.

Get current user (users): Get details of the current user.

List countries (enums): List all available countries.

List regions (enums): List all available regions.

List timezones (enums): List all available timezones.

List public templates (public-templates): Search and list public (approved) templates available for anyone. Supports name-based search for template discovery. Results are sorted by usage by default.

Get public template (public-templates): Get details of a public template by its URL slug (e.g. "12289-add-webhook-data-to-a-google-sheet"). Use this for templates discovered via public-templates_list.

Get public template blueprint (public-templates): Get the full blueprint of a public template including scenario flow, controller configuration, scheduling, and metadata. Use this for templates discovered via public-templates_list.

Retrieves a list of Apps available for Scenario Building in the given Organization and Team.

Retrieves a list of Modules available for the given App in the given Organization and Team.

Retrieves a single Module from the given App in the given Organization.

Retrieves the manifest and form configuration of a hook of the given type. Use this to understand what fields are required when configuring a hook.

Retrieves metadata of the given connection, or returns an error when the connection type doesn't exist.

Retrieves metadata of the given hook, or returns an error when the hook type doesn't exist.

Retrieves metadata of the given key, or returns an error when the key type doesn't exist.

Executes a Make Remote Procedure Call (RPC) with the provided input. Before executing an RPC, be sure you know its input parameters that should be passed to the 'data' field. If you're unsure, try listing the RPCs of the given app or module first. You can also use RPCs to provide answers for simple "read" or "list" queries, if the corresponding RPC is available, so it's not needed to create a full Tool to achieve such a thing.

Based on the user's intention, recommend applications that can assist in achieving their goals. This tool should provide a list of applications that are relevant to the user's needs, including their names and versions.

This tool creates a new Tool in the system based on provided parameters. It allows users to define custom tools that can be used in various scenarios. Use it to add new functionalities to the platform by specifying tool details. Use this tool also when you're tasked to perform a simple action. It's easier to configure a tool rather than a whole Scenario. Important! Before creating a tool, use a different tool to check how the module should actually be mapped, then create the mapping, and only then create the tool with this mapping. Even more important is to call the tool with 'instructions' format requested. That way, you'll get perfect instructions for how to fill in the module's configuration. Don't create unnecessary inputs. Create them only for values that should be dynamic, hardcode everything else in the module parameters. When the Module requires a Credential (Connection or Key) to be set, list the existing connections or keys of the corresponding type to see if there are any available. If there are available connections or keys for the Module, ask the user whether they want to use one of the available connections or keys. When asking this question, also provide the user with an option to not use available connections, and to create a new connection or key instead. In case user chooses an option to create a new connection or key, you should request the User to provide you with a new Connection or Key, for that, use the Credential Request Create Tool. In case there are no available connections or keys of the corresponding type for the Module you are creating, you should also request the User to provide you with a new Connection or Key, for that, use the Credential Request Create Tool. If you need to run the Tool, use the "Scenario Run" tool, using the Tool ID as Scenario ID.

Retrieves details of a specific Tool by its ID.

This tool updates an existing Tool's details based on provided parameters. It allows users to modify the properties of a Tool to keep it up-to-date with changing requirements. Use it to refine or correct Tool information as needed.

This tool validates that parameters and mapper collection are correctly configured for a given module in a given app. Use this tool before creating a new Make Tool or Make Scenario to verify that the configuration of modules is correct. Use this tool to iterate towards a successful validation result. Before generating parameters and mapper objects for the module, learn instructions for filling them in by getting the module detail in the "instructions" format.

Validates the Epoch Configuration of particular Trigger Module.

Validates the overall structure of the Scenario Blueprint against the Schema.

Validates the Scheduling of the Scenario against the Schema.

Retrieves markdown documentation for the specific Make App. Use when configuring Make Apps and Modules and when you need to learn more about the available capabilities.

This tool validates that hook configuration values are correctly set for a given hook type. Use this tool before creating a hook to verify that the configuration is correct. Use this tool to iterate towards a successful validation result. Before generating values, learn instructions by getting the hook config in the "instructions" format.

Use this tool to validate a typed Scenario Interface before applying changes. Either side (`input`, `output`) may be omitted; only the side(s) supplied are validated.

This tool analyzes a given Blueprint and extracts a list of various Connections, Keys, Hooks and other components that are required to be provided in order to map the Blueprint properly. Use this tool to identify all necessary components to collect before creating a new Make Scenario based on the Blueprint. The output will help in preparing the Scenario by ensuring all required resources are available.

Extracts the list of Components required by the particular Module. Use to identify what Connections, Keys, Hooks and other resources are needed to work with the Module.

Generates Data Structure Definition in Make Parameters Format from the sample data provided as input.