Table of Contents
Make MCP Server: Setup Guide and Comparison with Zapier MCP and n8n (June 2026)
You have Claude Desktop open. Or Cursor, or ChatGPT. You want the agent to do real work in your stack: pull a customer record, drop a row in a sheet, kick off a five-step workflow that ends with an email. The model can reason about all of it. It just can't touch any of it.
That gap is what Make's MCP Server closes. It turns your Make scenarios into tools any Model Context Protocol client can call, across the 3,000-plus apps Make already integrates (per Make's MCP product page). The part that surprised us: it ships on every plan, including the $0 Free tier (per Make's pricing page). No upsell, no "MCP add-on."
Below is the setup, the config you paste, the three things we'd wire up first, and the call on whether Make beats Zapier MCP or n8n as your tool layer. We pulled the current pricing and read the developer docs to get the config shapes exact.
What Make MCP Server actually does
Think of MCP as a USB port for AI agents. Make is the device you plug in. Your agent (the MCP client) speaks one protocol; Make exposes a set of callable tools on the other end, and each tool is one of your Make scenarios.
Here's the mechanism one level down. When you connect, Make's server advertises two tool families to the client (per the Make MCP developer docs):
- Scenario run tools. Each of your active and on-demand scenarios becomes a callable function. The agent calls it, Make runs the scenario, the output comes back.
- Management tools. The agent can view and modify scenarios, connections, webhooks, data stores, teams, and organizations. You decide via scopes which of these the agent is allowed to touch.
You control which parameters the AI gets to fill in and which stay locked as constants (per Make). That is the quiet superpower here. A scenario that posts to Slack can let the agent choose the message text while you hard-pin the channel, so a confused agent can't suddenly DM your CEO.
What you can reach
The same 3,000-plus apps Make connects in its normal builder, exposed through MCP (Make lists "over +3,000 pre-built apps" on its integrations page, and 30,000-plus actions on the MCP page). Slack, Google Sheets, BambooHR, Salesforce, HubSpot, Zendesk, Shopify, QuickBooks, Notion, the long tail. If Make has a connector, your agent can drive it once you've built a scenario around it.
Which AI clients work
Claude (Desktop and Code), ChatGPT, Cursor, and any MCP-compatible client (per Make's MCP page). The connection is remote, so there's no local server process to babysit. Make's docs name Claude and ChatGPT explicitly as the reference clients (per the developer docs).
Pricing: it's genuinely included
Make's Free plan is $0/month with 1,000 credits, where one credit is one module action like adding a sheet row (per Make's pricing page). Paid tiers run Core, then Pro at $16/month and Teams at $29/month (both priced at the 10,000-credit point), then custom Enterprise (same pricing page). MCP server access sits in the "Make + AI" feature row that spans the whole plan grid, not gated behind a higher tier. The cost you pay for agent activity is credits burned by the scenarios it runs, not a separate MCP fee.
Setup: connecting Claude to Make MCP
Two connection methods exist, and the choice matters for both setup friction and timeouts. We'll do OAuth first because it's the cleaner path.
Method 1: OAuth (recommended for Claude Desktop and Cursor)
The OAuth server URL is a single endpoint (per the Make developer docs):
https://mcp.make.comIf your client supports remote MCP servers natively (Claude Desktop's custom-connector UI does), you paste that URL and run through Make's sign-in. Done. For clients that still expect a stdio command in a JSON config, Make routes you through the mcp-remote bridge:
{
"mcpServers": {
"make": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://mcp.make.com/sse"]
}
}
}Drop that into claude_desktop_config.json (Claude Desktop) or your Cursor MCP settings, restart the client, and the first call triggers Make's OAuth consent. You authorize once, scoped to what you allow.
Method 2: MCP token (when you want a fixed credential)
If you'd rather hand the client a long-lived token than run an OAuth dance, Make generates an MCP token. In your Make dashboard, open the MCP server settings to create the token and copy your zone-specific server URL. The URL shape is (per the developer docs):
https://<MAKE_ZONE>/mcp/u/<MCP_TOKEN>/stateless<MAKE_ZONE> is your account's region host, something like eu2.make.com or us1.make.com, and <MCP_TOKEN> is the token you just generated. The matching JSON config:
{
"mcpServers": {
"make": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://<MAKE_ZONE>/mcp/u/<MCP_TOKEN>/sse"]
}
}
}The catch worth knowing up front: the two methods have different timeout ceilings on scenario-run calls. OAuth caps at 25 seconds, the MCP-token path at 40 seconds (per the Make developer docs). If you run long scenarios, that 15-second gap decides which method you pick. More on what happens when you blow past it in the production section.
Testing the connection
Build a throwaway scenario first. One module: a "create row" in a Google Sheet you don't care about. Set it to active or on-demand so MCP exposes it. Then in Claude, ask it to run the scenario with a test value. Watch for two things: the tool shows up in the client's tool list (config worked), and the row lands in the sheet (auth and scopes worked). Tool missing? The scenario isn't active. Listed but erroring? Almost always a scope you didn't grant.
Setup: connecting Cursor to Make MCP
Cursor takes the same two methods. In Cursor, open Settings, then Tools and Integrations, then the MCP section, and add Make as a server. Paste the OAuth URL (https://mcp.make.com) or the token URL, and Cursor handles the rest the same way Claude does.
Once connected, Cursor's Agent can call your Make tools mid-task. We like this when you're heads-down in code and want the agent to log a deploy to a Notion database without leaving the editor. The Make tool shows up alongside Cursor's native tools, and the agent picks it when the task calls for it.
What we'd wire up first: three worked examples
Tool access is only useful if you know what to point it at. Here are three patterns straight off Make's own MCP examples, written out as you'd actually build them.
1. Agent updates a Google Sheet from Cursor
The scenario: a single Google Sheets "Add a Row" module. Lock the spreadsheet and sheet name as constants; leave the row values open for the agent to fill. Connect Google Sheets once via Make's OAuth (this is the per-app auth, and you do it inside Make, not the client).
From Cursor: "Log this bug to the tracker sheet: title, severity high, assigned to me." The agent calls the Make tool, fills the open fields, Make writes the row. Input is your sentence, the command is the agent's tool call, the expected output is one new row with your three values and the constants you pinned.
2. Agent posts to Slack when Claude finishes a task
Scenario: a Slack "Create a Message" module, channel pinned, message text left open. Now Claude can close the loop on long-running work. "When you're done refactoring, post a summary to the engineering channel." Claude does the work, then calls the Make tool with its own summary as the message body. The channel can't be changed by the model because you locked it.
3. Agent triggers a multi-step lead workflow
This is where Make's scenario model earns its keep. Build one scenario that chains: add the lead to your CRM, send a welcome email, append a row to a tracking sheet. Three modules, one scenario, one MCP tool. The agent calls it with the lead's name and email; Make runs all three steps and reports back.
Why one scenario rather than three separate tool calls: the agent makes one decision, not three, so there's less room to half-complete the flow. You also get Make's visual execution log, so when something breaks you see exactly which module failed and replay it.
Make MCP vs Zapier MCP vs n8n: the comparison that matters
Three realistic ways to give an agent a tool layer. The decision usually comes down to app coverage, whether the tool layer costs extra on top of what you pay, and how much control you want over where it runs.
| Make MCP | Zapier MCP | n8n (MCP server) | |
|---|---|---|---|
| App coverage | 3,000+ apps, 30,000+ actions (per Make) | 8,000+ apps, large action library (per our Zapier MCP guide) | Whatever you build or self-host nodes for |
| Included in base plan | Yes, every tier from Free up (per Make pricing) | Usage-metered; consumes tasks above your base plan, check current Zapier pricing | Free if self-hosted; you pay for hosting |
| Per-app OAuth handled | Yes, Make holds the connections | Yes, Zapier holds the connections | You wire the credentials yourself |
| Visual execution log | Yes, scenario canvas plus run log | Yes, Zap history | Yes, in the n8n editor |
| Self-host option | No, Make is cloud-only | No, Zapier is cloud-only | Yes, full self-host |
| Best for | You're on Make already, or want visual debugging | Widest app catalog, you live in Zapier | Dev teams who want to own the runtime |
A few notes the table can't carry. Zapier's MCP endpoint reaches the widest app catalog of the three, and it's the path we cover in our Zapier MCP setup guide. The cost shape differs though: Zapier meters by task, so agent activity eats into your task allowance, the opposite of Make folding MCP into a flat plan. Run the math against your expected call volume first.
n8n is the pick when you want the runtime under your own roof. Open source, self-hostable, no per-task meter, no vendor holding your credentials. The trade is setup cost: you stand up and maintain the server. We walk through it in our n8n MCP guide, and you can read n8n's own framing on n8n's site. For a team with a platform engineer to spare, the control is worth it. For everyone else, managed wins on time.
Production considerations
A dev demo and a production agent are different animals. Here's what bites once real traffic hits it.
MCP enterprise auth is arriving, and Make is positioned for it
The big June development: the MCP project's "Enterprise-Managed Authorization" extension is now stable, letting enterprises control which MCP servers a client can reach centrally through their existing identity provider (per The New Stack, Jun 18 2026). Anthropic and Microsoft are among the first to support it in Claude, Claude Code, and VS Code, with Okta as the first identity provider, per the same report. The mechanism uses a new OAuth extension, the Identity Assertion JWT Authorization Grant, so an admin sets policy once and employees sign in with the corporate identity they already have, no per-server consent click.
Why this helps Make users: Make already runs per-app OAuth flows across its 3,000-plus integrations and advertises GDPR and SOC 2 compliance (per Make's MCP page). The auth posture enterprises now mandate is one Make built around years ago. A DIY MCP server adds that layer from scratch. If you're standing up agent access for a regulated team, that head start is real. For how the 2026 spec is shifting, see our MCP spec migration guide.
Your Make plan's limits carry straight over
MCP doesn't get you a separate quota. Every scenario the agent runs burns credits from your plan, and the Free tier's 1,000 monthly credits go fast under an active agent (per Make's pricing page). The Free plan also enforces a 15-minute minimum interval between scheduled runs. On-demand MCP calls are the path you want for agent work, but watch the credit burn. An agent in a retry loop can drain a month of credits in an afternoon.
What breaks when a scenario times out mid-run
This is the gotcha that'll cost you a debugging hour if nobody warns you. Scenario-run tool calls have hard timeouts: 25 seconds over OAuth, 40 seconds over the MCP token path (per the Make developer docs). Here's the part that matters: when the call times out, the scenario keeps running on Make's side. The agent gets a timeout, but your workflow still executes to completion in the background.
That's a double-edged thing. Good, because a slow scenario still finishes its work. Bad, because the agent thinks it failed and might retry, firing the whole scenario twice. For anything non-idempotent, like charging a card or sending an email, design the scenario so a duplicate call doesn't double-act. A dedup check on the first module is cheap insurance.
Which one to pick
The decision splits cleanly by who you are.
| If you're... | Pick | Why |
|---|---|---|
| A solo builder already on Make Free | Make MCP | Zero extra cost, you know the canvas, and the visual log makes agent debugging sane |
| An ops team needing Salesforce and HubSpot | Make MCP or Zapier MCP | Both cover those apps; pick the one you already pay for and don't run two tool layers |
| A dev team that wants to own the runtime | n8n | Self-hostable, no per-task meter, credentials stay yours; you pay in setup time |
| An enterprise standing up audited agent access | Make MCP | Per-app OAuth and SOC 2 posture already in place, ready for the new managed-auth extension |
For most readers wiring up their first agent tool layer, Make is the lowest-friction start: it's free to try, the config is two lines, and you can build the connection on a throwaway scenario in under ten minutes. If that's you, start a free Make account and build the test scenario from the setup section above before you commit to anything.
The one situation where we'd steer you elsewhere: if you genuinely need the runtime self-hosted for compliance or cost-at-scale reasons, Make can't do that, and n8n is the answer. Everyone else, the managed path saves you the platform-engineering tax.
FAQ
Is Make MCP free? The MCP server is included on every Make plan, including the $0 Free tier (per Make's pricing page). You don't pay for MCP itself. You pay in credits for the scenarios your agent runs, and Free gives you 1,000 credits a month.
Does Make MCP work with ChatGPT? Yes. Make names ChatGPT, Claude, and Cursor as supported clients on its MCP page, alongside any MCP-compatible client (per Make).
Can I use Make MCP with Claude Code or Cline?
Yes for Claude Code, which Make's docs list explicitly. Any client that supports remote MCP servers or the mcp-remote bridge can connect, so Cline-style clients work the same way once you add the server URL to their MCP config.
How many tools does Make expose? As many as you build. Each active or on-demand scenario becomes one callable tool, plus the management tools for viewing and modifying scenarios, connections, and teams (per the developer docs). Scope control decides which management tools the agent actually sees.
What happens if I hit my Make credit limit mid-agent-run? The scenario won't run once you're out of credits, so the agent's tool call fails the way any out-of-quota call does. Watch credit burn on the Free tier especially; an agent stuck in a retry loop can chew through 1,000 credits fast (Free includes 1,000 credits/month per Make's pricing page). Upgrade or cap the agent's retry behavior before you ship it to production.