Trigger and manage your automation scenarios.

Make

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

scenarios_list

Get scenario (scenarios): Get a scenario and its blueprint by ID.

scenarios_get

Create scenario (scenarios): Create a new scenario.

scenarios_create

Update scenario (scenarios): Update a scenario.

scenarios_update

Delete scenario (scenarios): Delete a scenario.

scenarios_delete

Activate scenario (scenarios): Activate a scenario.

scenarios_activate

Deactivate scenario (scenarios): Deactivate a scenario.

scenarios_deactivate

Run scenario (scenarios): Execute a scenario with optional input data.

scenarios_run

Get scenario interface (scenarios): Get the interface for a scenario.

scenarios_interface

Set scenario interface (scenarios): Update the interface for a scenario.

scenarios_set-interface

List executions (executions): List executions for a scenario.

executions_list

Get execution detail (executions): Get detailed result of a specific execution.

executions_get-detail

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

executions_get

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

folders_list

Create folder (folders): Create a new folder.

folders_create

Update folder (folders): Update an existing folder.

folders_update

Delete folder (folders): Delete a folder.

folders_delete

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

hooks_list

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

hooks_get

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

hooks_create

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

hooks_update

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

hooks_delete

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

data-structures_list

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

data-structures_get

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

data-structures_create

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

data-structures_update

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

data-structures_delete

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

connections_list

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

connections_get

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

keys_list

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

keys_get

keys_delete

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.

credential-requests_list

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.

credential-requests_get

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.

credential-requests_delete

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.

credential-requests_credential-decline

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.

credential-requests_credential-delete

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.

credential-requests_create

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.

credential-requests_create-by-credentials

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.

credential-requests_extend-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`).

credential-requests_list-app-modules-with-creden

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

data-stores_list

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

data-stores_get

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

data-stores_create

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

data-stores_update

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

data-stores_delete

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

data-store-records_list

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

data-store-records_create

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

data-store-records_update

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

data-store-records_replace

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

data-store-records_delete

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

teams_list

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

teams_get

teams_create

teams_delete

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

organizations_list

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

organizations_get

Create organization (organizations): Create a new organization.

organizations_create

Update organization (organizations): Update an existing organization.

organizations_update

Delete organization (organizations): Delete an organization.

organizations_delete

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

users_me

List countries (enums): List all available countries.

enums_countries

List regions (enums): List all available regions.

enums_regions

List timezones (enums): List all available timezones.

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

public-templates_list

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.

public-templates_get

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.

public-templates_get-blueprint

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

apps_list

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

app-modules_list

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

app-module_get

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.

hook-config_get

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

connection-metadata_get

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

hook-metadata_get

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

key-metadata_get

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.

rpc_execute

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.

apps_recommend

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.

tools_create

Retrieves details of a specific Tool by its ID.

tools_get

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.

tools_update

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.

validate_module_configuration

Validates the Epoch Configuration of particular Trigger Module.

validate_epoch_configuration

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

validate_blueprint_schema

Validates the Scheduling of the Scenario against the Schema.

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

app_documentation_get

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.

validate_hook_configuration

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.

validate_scenario_interface

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.

extract_blueprint_components

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.

extract_module_components

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

Make

MCP server URL

Works with

Tools 89