Skip to content

Connect Make to Claude: Manage Blueprints and Data Stores

Learn how to connect Make to Claude using a managed MCP server. Automate scenario execution, manage blueprints, and query data stores using AI agents.

Uday Gajavalli Uday Gajavalli · · 8 min read
Connect Make to Claude: Manage Blueprints and Data Stores

If you need to connect Make to Claude to automate scenario execution, manage complex blueprints, or oversee internal data stores, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Make's REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on /connect-make-to-chatgpt-automate-scenarios-and-team-roles/ or explore our broader architectural overview on /connect-make-to-ai-agents-orchestrate-scenarios-and-hooks/.

Giving a Large Language Model (LLM) read and write access to an automation powerhouse like Make is a significant engineering challenge. You have to handle API token lifecycles, map deeply nested blueprint JSON schemas to MCP tool definitions, and navigate Make's strict team-level permissions. Every time Make updates an endpoint or changes how Dead Letter Queues (DLQs) behave, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Make, connect it natively to Claude Desktop, and execute complex scenario management workflows using natural language.

The Engineering Reality of the Make API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Make's API is painful. Make is designed to execute logic, meaning its API surface area covers everything from user permissions to execution logs and complex routing trees.

If you decide to build a custom MCP server for Make, you own the entire API lifecycle. Here are the specific challenges you will face:

Massive Blueprint JSON Payloads A Make scenario blueprint is not a flat schema. It is a deeply nested, graph-based representation of modules, connections, iterators, and routing logic. Passing an entire production blueprint to an LLM directly will rapidly consume the context window. Your MCP layer must know how to request specific blueprint versions and potentially strip out non-essential metadata before returning the payload to Claude.

Incomplete Executions and DLQ Logic Make handles errors via Dead Letter Queues (DLQs), referred to in the API as incomplete executions. Interacting with these via API requires a precise sequence of operations. You cannot just "retry a scenario." You must fetch the DLQ ID, optionally fetch the failed bundles or blueprint that caused the error, and then explicitly call the retry endpoint for that specific execution ID. An LLM needs strictly defined tools to navigate this multi-step resolution process.

Strict Organization and Team Scoping Make's API relies heavily on hierarchical scoping. Many endpoints require either an organizationId or a teamId, but strictly forbid providing both simultaneously. If your agent guesses the wrong parameter combination based on generic documentation, the API will reject the request. Your MCP tool definitions must clearly define these mutually exclusive parameters.

Rate Limits and Retries Make enforces strict API quotas based on your pricing tier. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the Make API returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller - your MCP client or agent framework - is entirely responsible for detecting these headers and implementing its own retry or backoff logic.

Creating the Make MCP Server

Truto dynamically generates MCP tools based on the available resources and documentation for the connected Make account. You can create the MCP server URL in two ways.

Method 1: Via the Truto UI

For teams who want a zero-code setup:

  1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Make account.
  2. Click the MCP Servers tab.
  3. Click Create MCP Server.
  4. Select your desired configuration (e.g., restrict to read methods only, or filter by specific tags).
  5. Copy the generated MCP server URL. This URL contains a secure, hashed token.

Method 2: Via the API

For platform engineers automating agent provisioning, you can generate the MCP server programmatically. The endpoint validates the configuration, generates a secure token, stores it in a distributed key-value store with an optional expiration, and returns the ready-to-use URL.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Make Scenario Debugger",
    "config": {
      "methods": ["read", "write"],
      "tags": ["scenarios", "logs", "data_stores"]
    }
  }'

The response includes the server URL:

{
  "id": "mcp_abc123",
  "name": "Make Scenario Debugger",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the MCP Server to Claude

Once you have the URL, you must configure your client to point to it. All tool execution is routed through Truto's proxy handlers, which manage the underlying Make authentication.

Method A: Via the Claude UI

If you are using the Claude desktop app or web interface (or ChatGPT's equivalent custom connector UI):

  1. Go to Settings -> Integrations (or Connectors).
  2. Click Add MCP Server.
  3. Paste the Truto MCP URL.
  4. Click Add. Claude will immediately handshake with the server and list the available Make tools.

Method B: Via Manual Config File

For headless deployments or local AI development, configure your MCP client manually. Truto provides a Server-Sent Events (SSE) bridge for clients that expect standard stdio/SSE transports.

Add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "make-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}

Restart Claude, and the agent will dynamically load the Make tool definitions.

Hero Tools for Make

Exposing an entire automation platform to an LLM requires high-leverage tools. Below are 6 hero tools generated by Truto for Make, complete with the contextual prompts that trigger them.

List All Make Scenarios

Retrieves a list of scenarios within a specific team. This is the starting point for almost any diagnostic workflow, allowing the agent to map names to scenario IDs.

"Fetch all scenarios for team ID 123456 and show me which ones are currently active vs inactive."

Run a Scenario

Triggers an active scenario. If the scenario requires specific inputs (via webhooks or scenario inputs), the agent passes those in the request body.

"Trigger a run for the 'Lead Routing' scenario (ID 9876). Pass in the required input payload with the source set to 'inbound_web'."

Get Scenario Blueprint

Retrieves the underlying JSON blueprint of a scenario. This is critical for auditing how a scenario is constructed, checking which app versions are used, or verifying routing paths.

"Get the blueprint for scenario ID 9876. I need to know which specific modules are connected after the webhook trigger."

List Incomplete Executions

Queries the Dead Letter Queue (DLQ) for a given scenario to find executions that failed and are waiting for manual resolution.

"Check for any incomplete executions on the 'Stripe to NetSuite' scenario. List the error types and timestamps."

Retry Incomplete Execution

Triggers a retry of a specific incomplete execution. The scenario will run using the blueprint state from when the error originally occurred.

"Retry the incomplete execution ID 45678 that failed on the CRM sync scenario earlier today."

List Data Store Records

Fetches records from a Make internal data store. Useful for querying state, lookup tables, or custom variables maintained directly within Make.

"Query the 'Processed Leads' data store (ID 112233) and retrieve the last 50 records added to the database."

To view the complete inventory of Make tools, schemas, and required parameters, visit the Make integration page.

Workflows in Action

Providing an LLM with individual endpoints is only the first step. The true power of an MCP server is enabling the agent to string these tools together into autonomous workflows.

1. Automated Scenario Error Recovery

When a critical integration breaks, DevOps teams often have to manually hunt down the error in Make. An AI agent can diagnose and attempt recovery autonomously.

"Check the 'Shopify Orders' scenario for any incomplete executions today. If you find failures related to rate limits, retry them immediately. If they failed due to validation errors, pull the failed blueprint and explain what went wrong."

  1. list_all_make_incomplete_executions: The agent queries the DLQ for the specified scenario ID.
  2. make_incomplete_executions_incomplete_log: If failures exist, the agent fetches the specific execution logs to determine the error cause.
  3. make_incomplete_executions_retry: For transient errors (like 429s), the agent triggers a retry on the DLQ IDs.
  4. make_incomplete_executions_get_failed_scenario_blueprint: For validation errors, the agent fetches the blueprint to analyze the faulty mapping.
sequenceDiagram
    participant Agent as Claude Agent
    participant Truto as Truto MCP Server
    participant Make as Make API

    Agent->>Truto: call tools/list_all_make_incomplete_executions
    Truto->>Make: GET /scenarios/{id}/dlqs
    Make-->>Truto: Return DLQ array
    Truto-->>Agent: JSON results
    Agent->>Truto: call tools/make_incomplete_executions_retry
    Truto->>Make: POST /dlqs/{dlqId}/retry
    Make-->>Truto: 200 OK
    Truto-->>Agent: Success confirmation

2. Auditing Blueprint Dependencies

IT admins frequently need to audit Make accounts to find scenarios using deprecated modules or unauthorized applications.

"Audit all scenarios in Team ID 5555. Fetch their blueprints and give me a list of any scenarios that are using the legacy Slack V1 modules or raw HTTP requests."

  1. list_all_make_scenarios: The agent fetches the list of all scenarios in the team.
  2. list_all_make_scenario_blueprints: The agent loops through the returned IDs, fetching the blueprint for each.
  3. The agent parses the deeply nested JSON blueprints in-memory, searching the module definitions for unauthorized apps, and outputs a formatted markdown report.

3. Data Store Maintenance

Integration builders often use Make data stores to hold state (e.g., last processed timestamp, deduplication IDs). An agent can act as a DBA for these internal stores.

"Look up the 'Sync Timestamps' data store. Fetch all the records, and delete any records that were created before October 1st."

  1. list_all_make_data_stores: The agent finds the ID for the "Sync Timestamps" store.
  2. list_all_make_data_store_records: The agent pulls down the keys and data payloads.
  3. make_data_store_records_bulk_delete: The agent compiles an array of old keys and issues a bulk delete command to clean up the store.

Security and Access Control

Exposing an automation platform like Make to an LLM requires strict guardrails. Truto MCP servers provide multiple layers of access control built directly into the server URL:

  • Method Filtering (config.methods): Restrict the MCP server to specific HTTP verbs. You can create a read-only server by passing methods: ["read"], entirely preventing the agent from running scenarios or deleting data stores.
  • Tag Filtering (config.tags): Scope the server to specific functional areas. If you only want the agent to manage templates, pass tags: ["templates"] to exclude scenario execution and data store tools.
  • Secondary Authentication (require_api_token_auth): By default, the MCP URL acts as a bearer token. If you enable this flag, the client must also pass a valid Truto API token in the Authorization header, preventing leaked URLs from being abused.
  • Ephemeral Servers (expires_at): Generate time-bound servers for contractors or temporary AI sessions. The server is backed by scheduled cleanup routines that automatically invalidate the access token and destroy the configuration once the timestamp passes.

Moving Beyond Point-to-Point Integration

Connecting Make to Claude via a custom MCP server forces your engineering team to absorb the maintenance burden of the Make API. You have to handle OAuth refreshes, normalize rate limit errors, map complex blueprint schemas into JSON Schema for the LLM, and update your code every time Make alters its DLQ routing.

Using a managed MCP layer like Truto shifts that burden. Truto dynamically generates the tool definitions straight from Make's API documentation, handles the underlying authentication, and surfaces standard rate limit headers so your agent can back off gracefully. You get secure, scoped AI access to your automation workflows without writing a single line of integration code.

FAQ

How do I handle Make API rate limits with Truto?
Truto does not retry or apply backoff for rate limits. When Make returns an HTTP 429, Truto passes the error back with standardized IETF rate limit headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). Your MCP client or agent must handle the backoff.
Can I prevent Claude from deleting Make scenarios or data stores?
Yes. When creating the Truto MCP server, you can use method filtering (e.g., methods: ["read"]) to generate a read-only server, preventing the LLM from executing any write, create, or delete operations.
How does Truto handle Make's deeply nested blueprint JSONs?
Truto dynamically translates Make's API documentation into JSON schemas that Claude can understand. When you request a blueprint via the MCP tool, Truto delegates the request to its proxy layer, fetching the exact payload structure required by the Make API.

More from our Blog