Make.com shipped its MCP server in early 2026, becoming one of the first no-code automation platforms to support the Model Context Protocol. The implication: you can now expose your existing Make.com scenarios as tools callable by Claude Desktop, Cursor, ChatGPT, and any other MCP-compatible AI client.

This guide walks you through the entire integration, end-to-end. We'll use a real example — exposing a Make.com scenario that searches a HubSpot CRM as an MCP tool. By the end, you'll have a working setup where Claude Desktop can autonomously call your Make scenarios when relevant.

This is the most accessible path to building AI-augmented workflows. No Python, no TypeScript, no infrastructure — just Make.com's visual builder plus a few minutes of configuration.

What you'll need

  • Make.com account — any paid plan works. The free tier has limited operations, which makes this difficult to use in practice.
  • Claude Desktop installed on your machine
  • An existing Make scenario with a clear input/output (we'll build one if you don't have one)
  • ~30 minutes for the full walkthrough

Understanding what Make.com MCP does

Make.com's MCP server is a service hosted by Make. It exposes your scenarios as MCP tools, handling all the protocol details — JSON-RPC, capability negotiation, tool discovery — without you writing any code.

The architecture:

  1. You build a scenario in Make.com normally
  2. You enable MCP exposure on that scenario
  3. Make generates an MCP server URL specific to your account
  4. You configure your AI client (Claude Desktop, etc.) to connect to that URL
  5. Your scenario becomes a tool the AI can invoke

The scenario's trigger module is what gets exposed. The rest of the scenario (the actions, filters, routers) executes normally when the AI invokes the tool. The scenario's final output (or webhook response) becomes the tool's return value.

Step 1: design the scenario

The best MCP-exposed scenarios are read-oriented queries with clear inputs and outputs. Good candidates:

  • "Search the CRM for contacts matching a query"
  • "Get the status of an order by order number"
  • "Look up the latest support tickets for a customer"
  • "Search the knowledge base for articles on a topic"

Avoid exposing scenarios that:

  • Take destructive actions (deletions, billing changes) without confirmation
  • Send messages to customers (the AI shouldn't decide when to email)
  • Have unclear or unbounded operations costs
  • Depend on shared state from previous scenario runs

For our example, we'll build "search HubSpot contacts" — a clean read-only query.

Step 2: build the scenario in Make.com

Create a new scenario with this structure:

  1. Trigger: Custom Webhook (this is what gets exposed as the MCP tool)
  2. Action 1: HubSpot — Search CRM Contacts
  3. Action 2: Tools — Set Variable (format the results for AI consumption)
  4. Response: Webhook Response (returns formatted JSON)

Configure the webhook

Click the webhook module, click "Add", give it a name like "MCP - Search Contacts". Copy the generated webhook URL — you'll need it later.

Send a test request to the webhook so Make can detect the data structure:

curl -X POST 'YOUR_WEBHOOK_URL' \
  -H 'Content-Type: application/json' \
  -d '{"query": "Acme Corp"}'

Make will detect the JSON structure and make query available as a variable downstream.

Configure HubSpot search

Add the HubSpot "Search CRM Object" module. Configure it:

  • Object type: Contact
  • Query: {{1.query}} (the value from the webhook)
  • Limit: 10
  • Properties to return: firstname, lastname, email, company, lastmodifieddate

Format the output

The Webhook Response module needs a JSON-formatted string. Use a Tools > Set Multiple Variables module to build it, then return:

{
  "contacts": [
    {{#each 2.results}}
    {
      "name": "{{this.properties.firstname}} {{this.properties.lastname}}",
      "email": "{{this.properties.email}}",
      "company": "{{this.properties.company}}",
      "last_activity": "{{this.properties.lastmodifieddate}}"
    }{{#unless @last}},{{/unless}}
    {{/each}}
  ],
  "total_found": {{2.total}}
}

This formatting matters — the AI will parse this response, so clean structured JSON makes its job easier than raw HubSpot API output.

Step 3: enable MCP on the scenario

In your scenario settings, look for the "MCP" tab (added in Make's early-2026 release). You'll see a configuration form:

  • Tool name: search_hubspot_contacts (snake_case, no spaces)
  • Description: "Searches the HubSpot CRM for contacts matching a name or company. Returns up to 10 matches with name, email, company, and last activity date."
  • Input schema: auto-detected from your webhook data, but verify query is marked as required string
  • Output schema: describes the JSON structure you return

The description matters a lot. Claude uses it to decide whether to invoke this tool. "Searches HubSpot for stuff" is bad. "Searches HubSpot CRM for contacts matching a name or company; returns up to 10 with email and last activity" is good. Be specific about both what it does AND what it returns.

Save and activate the scenario. Make will give you an MCP server URL and an authentication token.

Step 4: configure Claude Desktop

Make.com exposes its MCP server over HTTP, which Claude Desktop can connect to via the remote MCP support.

In Claude Desktop:

  1. Click your profile name in the bottom-left sidebar
  2. Open Settings
  3. Navigate to "Connectors"
  4. Click "Add custom connector"
  5. Fill in:
    • Name: "Make.com"
    • URL: the MCP server URL Make gave you
    • Authentication: paste the token from Make
  6. Click Add

Claude Desktop will validate the connection. If it works, you'll see "Make.com" in your connectors list with your search_hubspot_contacts tool available.

Step 5: test it

Open a new Claude Desktop conversation and ask:

"Can you search my HubSpot for contacts at Acme Corp?"

What should happen:

  1. Claude recognizes the available search_hubspot_contacts tool from its description
  2. It calls the tool with {"query": "Acme Corp"}
  3. The Make.com scenario executes: receives the webhook, queries HubSpot, formats the response
  4. The formatted JSON returns to Claude
  5. Claude synthesizes a natural-language answer summarizing the contacts

The first call may take 2-3 seconds while Make warms up. Subsequent calls are typically under 1 second.

Step 6: handle common issues

"Tool not found" — restart Claude Desktop. Connectors are loaded at startup.

"401 Unauthorized" — token mismatch. Regenerate the token in Make and update Claude Desktop.

Tool calls fail intermittently — likely Make.com operations quota. Check your Make billing page. AI-invoked tool calls consume operations like any other scenario execution.

Output doesn't make sense to Claude — your output format is unclear. Improve the JSON structure in your Tools > Set Variable module. Test with the MCP Inspector before going through Claude.

Claude doesn't invoke the tool even when relevant — your tool description isn't specific enough. Rewrite it. Include keywords the AI would naturally consider when matching user intent.

Step 7: expand the pattern

Once you have one working tool, the pattern scales. Build additional scenarios for common operations:

  • create_hubspot_note — log a note to a contact (write operation, low-risk)
  • search_intercom_conversations — find recent support threads
  • get_deal_status — check the status of a specific Pipedrive deal
  • list_overdue_invoices — pull from your accounting tool

Each is a separate Make scenario, each exposed as its own MCP tool. Claude Desktop will see them all and choose the right one based on the user's question.

Operations cost reality

Important reality check: every AI-invoked tool call consumes Make.com operations. A typical scenario with 5 modules costs 5+ operations per invocation. If you put a popular tool in production and 20 team members hit it 10 times per day, that's 1,000 operations daily — 30,000/month.

For the Make.com Core plan (10,000 operations/month), you'd blow through quota in less than a week. The Pro plan ($18.82/month for 10,000+) is similar. You'll likely need the Teams plan ($34.12/month) or higher to run MCP integrations at meaningful scale.

Track operations consumption from day one. Set quotas if your scenarios call expensive APIs (HubSpot has API rate limits separate from Make's operations).

Production considerations

If you're moving beyond personal use into team or production deployments:

Access control. Make.com's MCP token grants access to your scenarios. Don't share tokens loosely. For team setups, create dedicated Make.com workspaces per team.

Audit logging. Make.com logs every scenario execution. Periodically review the logs to see which AI-invoked tool calls happened and verify they make sense.

Cost monitoring. Set up alerts in Make.com for unusual operations spikes. AI tools that run away can burn through quota fast.

Tool description maintenance. As your business processes evolve, update tool descriptions to match. Stale descriptions lead to incorrect AI behavior.

When NOT to use Make.com MCP

Make.com MCP is the right answer for many use cases, but not all. Skip it when:

  • You need sub-second latency. Make.com adds 500-2000ms per invocation. A custom MCP server in Python is faster.
  • You're building developer tools. Code-oriented MCP servers (GitHub access, file system, build tools) belong in Python/TypeScript, not Make.com.
  • You need fine-grained per-user permissions. Make's permission model is workspace-level, not per-tool.
  • You're at very high volume. Beyond 50,000 tool calls/month, custom infrastructure is cheaper than Make.com operations.

For everyone else — and that's most SMBs and operations teams — Make.com MCP is the easiest path to production-grade AI tool integration.

Next steps

Where to go from here:

If you want hands-on help designing and deploying MCP-enabled Make.com workflows for your business, our custom integration service covers exactly this scope.

Frequently asked questions

Can I expose multiple Make.com scenarios as MCP tools simultaneously?

Yes. Each scenario you enable MCP on becomes its own tool. Claude Desktop sees all of them in one connector and chooses which to invoke based on the user's request.

Does this work with ChatGPT and other AI clients?

Yes. Make.com's MCP server is protocol-compliant, so any MCP client works. ChatGPT added MCP support in Q1 2026. Cursor, VS Code Copilot, and other MCP-capable hosts also work.

What's the typical latency for a Make.com MCP tool call?

Roughly 1-3 seconds end-to-end. The first call may be slower (cold start). For high-volume production use, expect average latency around 1.5 seconds, dominated by the scenario's underlying API calls.

Can the AI break my scenarios?

If you expose write operations, yes — the AI could call delete_record with the wrong ID. Best practices: expose read operations first, add confirmation prompts for destructive actions, and start with low-stakes test environments.

How much does this cost vs building a custom MCP server?

Make.com costs roughly $0.001-$0.005 per AI invocation depending on plan. A custom server costs developer time (1-2 weeks to build) plus hosting (~$20/month). For under 50,000 calls/month, Make.com is cheaper. Beyond that, custom infrastructure wins.

Can I use Make.com's MCP with my own custom apps?

Yes. As long as your custom app integrates with Make.com (via HTTP module or custom app), you can expose it through MCP. Make.com becomes the AI-friendly layer over your custom infrastructure.

Related guides

MCP Complete Guide

The pillar covering all aspects of MCP.

Claude Desktop Setup

How to configure Claude Desktop.

Build an MCP server

When you need more control than Make.com offers.

Make.com Complete Guide

Our 15,000-word reference if you are new to Make.com.