Make MCP: We Had Claude Code Build a Scenario (Free Plan)

This article contains affiliate links: we may earn a commission. Learn more

We gave Claude Code the Make MCP server on a free account and one job: build a scenario, run it once and report what it cost. The first API token got 4 refused calls in 32 seconds. The second built and ran a three-module scenario 37 seconds after launch, for 7 operations. We ran it on November 14, 2026, and one schedule setting would have emptied the free plan in under 6 days.

This is a test of cost and limits, not a connection tutorial. Every figure below comes from our agent’s logs, and how we test explains why our agents do the testing. The account is Make’s free plan: 1,000 credits a month, and our whole test, rehearsal included, used 21.

What is the Make MCP server?

It’s a server hosted by Make that lets an AI agent run your scenarios and manage your account. MCP (Model Context Protocol) is the open standard for plugging tools into an agent, described on modelcontextprotocol.io. Make’s documentation lists what the tools do: run active and on-demand scenarios, view and modify scenarios, connections, webhooks and data stores, view and modify teams and organizations.

In Make, a scenario is a chain of modules, and each module that runs uses operations. On our account, tools/list returned 141 tools on November 14, 2026. Across our three takes the agent made 34 MCP calls and used 19 of those tools.

What is the Make MCP server URL for Claude Code?

The URL depends on your zone: ours was https://eu1.make.com/mcp/v2, with an API token in an Authorization: Bearer header. Make also offers OAuth, which we didn’t test. To create the token, the API key page of the docs gives the path: Profile, API access tab, Tokens, ”+ API token”, then the scopes, “including the mcp:use scope”.

For Claude Code, the server goes in an MCP config file:

{
  "mcpServers": {
    "make": {
      "type": "http",
      "url": "https://eu1.make.com/mcp/v2",
      "headers": { "Authorization": "Bearer YOUR_MAKE_API_TOKEN" }
    }
  }
}

We ran the agent headless with claude -p "<prompt>" --mcp-config make.json. Replace eu1 with your own zone, and keep the token out of your repo and off screen: whoever holds it can change your account. We deleted both of our tokens after the test.

Round one: what does a token with too few scopes do?

It gets refused, and each refusal names the missing scope. Our first token had 6 scopes: mcp:use, scenarios:read, scenarios:write, scenarios:run, datastores:read and datastores:write. That looked like enough to build a scenario that writes to a data store. It wasn’t.

The prompt, condensed:

Build a scenario named "HKPA channel feed" that reads the public YouTube
RSS feed of our channel and writes one record per video (title, link,
published date) into a Make data store named "hkpa_feed". Use the cheapest
modules, no third-party connection. Set the scenario to run on demand,
activate it, run it once, then read the execution and the data store
records. Tell me how many operations the run used. At the end, tell me
honestly what failed, what the free plan blocked, and what you had to
retry. Do not delete anything.

In 32 seconds and 8 MCP calls, 4 came back with SC403 Permission denied:

data_store_create did work: an empty 1 MB store named hkpa_feed. Then the agent stopped and listed the scopes to add. Its report: “I didn’t try to get around the missing scopes by other means, such as calling the Make REST API directly. The token’s limits look deliberate, and that is your call.” It also wrote that every refusal was a missing token scope, not a plan limit.

Round two: how fast does Claude Code build a Make scenario?

37 seconds from launch to scenario_run, with 0 errors. The second token had 14 scopes: the first 6 plus apps:read, hooks:read, hooks:write, teams:read, udts:read, udts:write, organizations:read and connections:read. Same prompt. The whole take lasted 51 seconds and 18 MCP calls.

The sequence, with the timestamps of the log:

1. app_find, three times, then module_spec (22 s). The catalog search never listed the RSS app. The agent guessed the module name rss:ActionReadArticles, and module_spec confirmed it.
2. data_structure_create (28 s) and data_store_update (30 s). A structure with title, link and published date, linked to the store left by round one.
3. scenario_create (34 s). Three modules, set to on-demand: Start scenario, RSS “Retrieve RSS feed items” (max 15), Data store “Add/replace a record”.
4. scenario_activate (35 s) and scenario_run (37 s). Status “success” in 638 ms.

The agent then read its own work back with scenario_execution_get and data_store_record_list. Six records, one per video in the feed, each with a title, a link and a date. The date is stored as text, not as a date type, and the agent said so.

The cost: 7 operations and 7 credits, according to scenario_execution_get. The module-by-module inspection shows 8 module calls (1 start, 1 RSS read, 6 writes), so one of them isn’t counted. We didn’t find out which.

Why isn’t “success” proof?

Because in our rehearsal Make also said “success”, and all 6 records were empty. The take above was the second time we ran this prompt. The first time, the agent put the fields outside the record’s data object. Make ran the scenario, counted 7 operations and returned “success”. The agent caught it only because it listed the records afterwards.

The fix hit a wall too. scenario_patch answered “Too Many Requests” three times in a row. The agent waited 60 seconds, the fourth attempt passed, and the rerun wrote 6 complete records for another 7 operations. So ask your agent to read the data back, every time.

Does the Make MCP server work on the free plan?

In our test, yes, including tools the docs reserve for paid plans. Make’s documentation says: “Scenario run tools are available to all plans, and management tools are available to paid plans.” On November 14, 2026, our account on the Free plan created a data store, a data structure and a scenario through MCP, then activated and ran it. No call was refused for a plan reason.

We can’t tell whether the docs or the account is behind. Check it on your own account before you plan around it.

How many operations would a schedule cost on the free plan?

At 7 operations a run, an hourly schedule uses 5,040 operations a month: five times the free plan. We asked the agent for the bill in a third take, read-only: 29 seconds, 8 calls. organization_get returned 21 operations used and 979 left, for a period running from November 10 to December 10, 2026. The agent found one run of 7. The other 14 are our rehearsal: two runs of 7.

The 979 operations we had left would last 5.8 days on the hourly schedule and 1.5 days at 15 minutes. Make’s pricing page listed 15 minutes as the free plan’s shortest interval on November 14, 2026.

Why 7? The agent chose “Add/replace a record” keyed on the video link, so each run rewrites all 6 videos. A scenario that writes only new videos would cost less, and we didn’t test that one through MCP. In our Make, Zapier and n8n comparison, a Make scenario built that way in the editor used 1 credit on a run with no new video. At 1 credit a check, an hourly schedule is 720 a month plus 1 per new video. That fits.

So ask the agent what one run costs before you give it a schedule.

Our verdict

Make’s MCP server does what the docs say, and on our free account a bit more. Claude Code built and ran a real scenario in under a minute, for 7 operations. But it’s a builder, not a supervisor. You choose the scopes. You check that the data is really there. You watch the schedule.

If you already use Make, it’s a fast way to get a first draft of a scenario. If you don’t, the free plan is enough to repeat this test: create a token with the scopes your job needs, give your agent the same prompt, and ask for the cost of a run. We ran the same kind of test on two other servers: the Apify MCP server, a lead list for about 17 cents, and the systeme.io MCP server, a funnel in 100 seconds.

Not verified: scheduled runs (ours was on demand), OAuth, paid plans, scenarios that need a third-party connection, and the Make Skills the docs mention. Our figures come from one account, on one day.