How to Connect AI Agents to Make.com with an MCP Server

Make.com's MCP server is a cloud-hosted gateway that exposes your automation scenarios as tools AI agents can discover and execute. Instead of writing custom API integrations, you generate a token, paste a URL into your AI client, and your agent can immediately see which scenarios are available, what inputs they need, and what outputs they produce.

This is different from building a webhook-based integration from scratch. With a traditional approach, you would create a webhook trigger in Make, write the tool definition manually in your agent's config, handle input validation, and parse the response. The MCP server handles all of that through the Model Context Protocol standard.

Make's MCP server supports three transport methods:

• Stateless Streamable HTTP (the default, recommended for most setups)
• Streamable HTTP for clients that need persistent connections
• Server-Sent Events (SSE) for legacy MCP clients

Authentication works through either OAuth (for clients like Claude Desktop that support it natively) or MCP tokens that you generate in your Make account settings. Both approaches give agents access to scenario execution, and paid plans unlock management tools for modifying scenarios, connections, and data stores.

Make is trusted by over 350,000 organizations and connects to more than 3,000 apps. When you expose a scenario as an MCP tool, every app integration in that scenario becomes accessible to your agent. An agent that triggers a scenario connecting Slack, Google Sheets, and Salesforce gets the combined power of all three without needing separate integrations for each.

Getting your AI agent connected to Make takes about five minutes. The process has two paths depending on whether your AI client supports OAuth or needs a direct token URL.

OAuth Path (Claude Desktop, ChatGPT)

For clients that support OAuth natively, the setup is straightforward:

1. Open your AI client's settings and find the connectors or integrations section
2. Search for "Make" in the available connectors
3. Click to add it, and you will see a Make OAuth consent screen
4. Select your organization and choose permission scopes
5. On Make's free plan, you can select "run your scenarios only," while paid plans offer broader management access
6. Approve the connection

Your agent can now discover and run any active, on-demand scenario in your Make account.

MCP Token Path (Cursor, Windsurf, Custom Agents)

For clients that need a direct URL, generate an MCP token:

1. Log into Make.com and go to your user profile
2. Navigate to the API/MCP access section
3. Click "Add token" and select "MCP Token" as the type
4. Give it a descriptive label (like "Claude Agent - Production")
5. Copy the generated token URL

The token URL follows this pattern depending on your Make zone:

https://<MAKE_ZONE>/mcp/u/<MCP_TOKEN>/stateless

Paste this URL into your MCP client's configuration. For Claude Code, add it to your MCP server config:

{
  "mcpServers": {
    "make": {
      "url": "https://us1.make.com/mcp/u/YOUR_TOKEN/stateless"
    }
  }
}

For clients that do not support Streamable HTTP directly, append /sse to the URL for the SSE transport, or use Cloudflare's mcp-remote proxy.

Timeout Considerations

Make's MCP server enforces timeouts on tool calls. Scenario execution has a 25-second timeout via OAuth and 40 seconds via MCP token. If your scenario takes longer to complete, it keeps running in the background for up to 40 minutes. The server returns an executionId you can use to poll for results.

For time-sensitive workflows, keep your MCP-triggered scenarios lightweight. Offload heavy processing to separate scenarios triggered by webhooks or schedules.

Give Your Agents a Workspace for Make Automation Outputs

Fastio provides generous storage with built-in AI indexing. Agents store Make scenario results, search them by meaning, and share with clients through branded links. No credit card, no trial period.

Start 14-Day Trial

Not every Make scenario automatically shows up as an MCP tool. Your scenario needs specific configuration to be discoverable and callable by AI agents.

Requirements for MCP-Exposed Scenarios

Your scenario must be:

• Active with scheduling set to on demand (click the clock icon on the trigger module and select "on demand")
• Configured with defined inputs and outputs so the agent knows what data to send and what to expect back

Without the on-demand scheduling setting, the MCP server will not expose the scenario to connected clients.

Defining Inputs and Outputs

Click the scenario inputs/outputs icon in the Make toolbar to define what your scenario accepts and returns:

Inputs tell the agent what parameters to provide. For an email search scenario, you might define an input called "search_query" of type text. For a CRM lookup, you might accept a "company_name" string. Be specific with input names and descriptions because the AI agent reads these to understand how to call your tool.

Outputs define the data structure that comes back. Use the "Return Output" module at the end of your scenario to map processed data back to the defined output schema. For structured data, an Array Aggregator module before the Return Output module consolidates multiple items into a single response bundle.

Writing Good Scenario Descriptions

Make strongly recommends adding descriptions to every MCP-exposed scenario. The description is what the AI agent uses to decide which tool fits a request. A scenario described as "Gets unread emails from Gmail and returns sender, subject, and date" gives the agent much better context than one with no description at all.

Keep descriptions factual and specific. State what the scenario does, what inputs it needs, and what format the output takes.

Practical Scenario Patterns

Here are patterns that work well as MCP tools:

• Data retrieval: Pull records from a CRM, database, or spreadsheet based on search criteria
• Content processing: Take raw text input, transform it through multiple modules, return formatted output
• Notification dispatch: Accept a message and recipient, send via Slack, email, or SMS, return delivery confirmation
• File operations: Upload to cloud storage, generate documents, or convert file formats
• Multi-step lookups: Chain API calls across services, aggregate results, return a unified response

Each pattern follows the same structure: defined inputs, processing modules in the middle, Array Aggregator if needed, and a Return Output module at the end.

When an AI agent triggers a Make scenario, the processed data comes back to the agent as structured output. But for many workflows, the real value is what happens next: storing, sharing, and acting on those results.

The Storage Problem

Make excels at moving data between apps, but it is not designed for persistent file storage. If your agent generates a report, transforms a dataset, or collects documents through a Make scenario, that output needs to land somewhere accessible to both the agent and the humans who will use it.

Common approaches include sending files to Google Drive, Dropbox, or S3. These work, but they treat storage as a passive dump. The agent writes a file and moves on. Finding that file later, understanding what it contains, or sharing it with a client requires manual effort.

Using Fastio as the Output Workspace

Fastio approaches this differently. It is built as a workspace for agentic teams, where files uploaded by agents are automatically indexed and searchable. When your Make scenario produces output that an agent stores in a Fastio workspace, that content becomes immediately queryable through natural language.

The practical workflow looks like this:

1. Your AI agent calls a Make scenario that collects data from multiple sources
2. Make processes and formats the data, returning it to the agent
3. The agent uploads the result to a Fastio workspace using the Fastio MCP server
4. Intelligence Mode indexes the content automatically
5. Team members can search, ask questions about, and share the output through the Fastio dashboard or API

Fastio's MCP server exposes tools for workspace management, file upload, AI-powered search, and sharing. An agent can upload a file, enable Intelligence Mode on the workspace, and create a branded share link for a client, all through MCP tool calls without touching a browser.

The Business Trial includes 50 GB of storage, included credits, and five workspaces, with no credit card required. For workflows where Make handles the automation and an agent handles the reasoning, Fastio becomes the place where results accumulate and stay accessible.

Make's scenario-based architecture opens up patterns that go beyond single-agent tool calls. When you combine Make's MCP server with other MCP-connected services, agents can orchestrate complex workflows across multiple platforms.

Agent as Orchestrator

In this pattern, one agent acts as the coordinator. It receives a request, breaks it into steps, and calls different Make scenarios for each step. A research agent might:

1. Call a Make scenario that searches a CRM for company data
2. Call another scenario that pulls recent news articles about that company
3. Call a third scenario that checks internal documents for past interactions
4. Synthesize all three results into a briefing document

Each scenario is a discrete, testable unit in Make. The agent decides the order and handles the logic between steps.

Webhook-Triggered Agent Workflows

Make scenarios can also initiate agent work through webhooks. When a new lead enters your CRM, a Make scenario fires a webhook that triggers an agent to research the lead, draft a personalized outreach email, and store the draft in a shared workspace for human review.

This inverts the typical pattern. Instead of the agent calling Make, Make calls the agent. The Fastio webhook system supports this reactive model, notifying agents when files change so they can respond without polling.

Handling Concurrent Access

When multiple agents share the same Make account, scenario execution can overlap. Make handles this at the scenario level since each execution runs independently. But if agents write results to the same storage location, you need coordination.

Fastio addresses this with file locks. An agent can acquire a lock before writing, preventing other agents from overwriting the same file. This matters in multi-agent setups where two agents might finish their Make scenarios at the same time and both try to update a shared report.

Connecting Make to Other MCP Servers

Your agent is not limited to one MCP server. A typical production setup might connect to:

• Make MCP for triggering automations across 3,000+ app integrations
• Fastio MCP at /storage-for-agents/ for persistent storage, RAG search, and sharing
• Domain-specific MCP servers for services like Calendly, GitHub, or Stripe

The agent sees all connected MCP tools in a unified interface and picks the right tool for each step. Make handles the automation layer, Fastio handles the storage and intelligence layer, and the agent handles the reasoning.

Setting up MCP connections is generally smooth, but a few issues come up regularly.

Scenario Not Appearing as a Tool

If your agent cannot find a scenario after connecting, check three things:

• The scenario must be active (not paused or in draft)
• Scheduling must be set to on demand (not interval or webhook)
• If using an MCP token, confirm the token has not expired and is associated with the correct organization

After making changes, disconnect and reconnect the MCP server in your client. Most clients cache the tool list and need a refresh to pick up new scenarios.

Timeout Errors on Long Scenarios

If you see timeout errors, your scenario is exceeding the MCP server's response window (25 seconds for OAuth, 40 seconds for MCP tokens). Two approaches to fix this:

• Simplify the scenario: reduce the number of modules, remove unnecessary data transformations, or use parallel execution paths in Make where possible
• Use the executionId pattern: let the scenario timeout, capture the returned executionId, and have the agent poll for the result. This works well for scenarios that need to call slow external APIs

Authentication Failures

OAuth connections can break when tokens expire or when your Make subscription changes. If an agent suddenly cannot authenticate:

• Re-authorize the connection through your AI client's connector settings
• For MCP tokens, generate a new token in your Make profile and update the URL in your client config
• Check that the scopes you selected during setup still match your Make plan. Free plans only support scenario execution, not management tools

Input/Output Mismatches

When an agent sends the wrong data format to a scenario, Make returns an error. This usually happens because the scenario description is too vague or the input definitions are missing type constraints. Add explicit types (text, number, boolean) to your input definitions and keep descriptions specific about expected formats. If a field expects an email address, say so in the description rather than just labeling it "input."