From Aryan Vatsa | Product & Market Analysis

Make Automation Review: 1 Credit Per Operation, Until an AI Agent Joins

On this page

Make automation still charges 1 credit for almost every operation, so a plain scenario can be priced from the canvas before it runs. Agents end that. In our model of one agent run with 20 tool calls, the same work costs 37 credits on GPT-5 nano and 637 on Claude Sonnet 5. The rates are published. The depth is decided at run time.

Key takeaways

  • Non-AI Make modules cost 1 credit per operation regardless of data size. Routers and error handlers cost nothing, so a plain scenario's monthly bill is arithmetic you can do in advance.
  • Polling is the hidden line on a plain Make bill. One trigger checking every 5 minutes uses 8,640 credits in a 30-day month, which is 86% of a 10,000-credit plan before any work happens.
  • Make's token conversion sits at provider list price. Across 7 models we checked, 1 credit buys about $0.0009 of tokens at list, which equals the credit price on Make's $9 example plan.
  • Make's auto-purchase caps the bill and leaves the outage risk. Automatic top-ups stop at your plan's credit amount per monthly cycle, and scenarios then stop until credits return.
179xSpread in token credits for the same 2,000-token step, Make's Medium tier against Claude Fable 5. Computed from Make Help Centre rates, 2026.
$0.0009Price of 1 credit in Make's own worked example of a $9 plan with 10,000 credits. Source: Make Help Centre, 2026.
2.25xMost that auto-purchase can lift a monthly bill over the plan price. Computed from Make's extra credit rules, 2026.

Make automation review: predictable until the model decides

Short answer. Make is a strong buy for deterministic scenarios, where 1 credit per operation can be priced from the canvas. It is a conditional buy for AI agents, because tool-call depth and model choice set the bill at run time. Run production agents on your own provider key so token spikes stay outside the credit pool.

This review is written for the person who owns delivery and answers for the automation bill. It takes one narrow question: can you state next month's Make cost before next month happens? For most of the product the answer is yes, and for the newest part it is no.

Every rate below comes from Make's help centre, opened on 9 November 2026. I did not run these scenarios in a live account, so the scenario totals are arithmetic on published rules rather than measured invoices. The agent figures rest on a usage model whose assumptions are stated in full, because the assumptions move the answer.

The side-by-side question is already answered in the comparison of n8n, Zapier and Make billing units. This piece stays inside Make and goes deeper on its meter, including the token repricing that took effect on 25 August 2026 and the agent controls added since.

How Make credits work after the switch from operations

Make credits replaced operations as the billing unit on 27 August 2025, converting at one to one with plan prices unchanged. For non-AI work nothing moved. The change gave Make a unit that could carry token costs, and Make said at the time that usage of its own AI Provider could rise as billing aligned with actual AI costs.

The one-credit rule and what sits outside it

Make defines an operation as a single module run to process data or check for new data. A non-AI operation costs 1 credit regardless of data size, so uploading a large file to Google Drive costs the same as uploading a small one. That is more generous than it sounds, although data transfer is separately allowanced at 5 GB per 10,000 credits.

Make credit cost by module type, from Make documentation, 9 November 2026
What runsCredit basisPredictable before the run
Non-AI app module1 credit per operation, any data sizeYes
Router and error handlers (Rollback, Break, Resume, Commit, Ignore)No creditsYes
Third-party AI module on your own connection1 credit per operation, tokens billed by your providerCredits yes, provider bill no
Make AI Toolkit on Make's AI ProviderOperations plus tokens at the model's rateWithin a range
Make AI Web Search and Content ExtractorTokens, operations and other usage factors. Some extractor modules cost 2 or 10 credits per operation.Partly
Make AI Agent, each run1 credit per operation, plus tokens on Make's AI ProviderOperation yes, tokens no
Agent tools1 credit per operation, plus tokens on Make's AI ProviderNo. The model picks how many
Knowledge file upload1 credit per operation, plus embedding tokens. PDF and DOCX add a per-page chargeYes, once, at upload

The third column is my judgement, not Make's. The credit bases in the second column are Make's. Make also tags some modules as billing on file size, per page or run time.

Why the bundle count matters more than the module count

Each bundle gets its own module run, so a trigger returning many items multiplies everything after it. Make's own example has a trigger returning 10 bundles and three further modules, for 31 operations in a single run. Count bundles first, modules second, or your estimate will be wrong by the size of the batch.

Make pricing: what one credit actually costs

A Make credit costs about $0.0009 at the entry point, and less as the tier rises. Make's Extra credits page uses a $9 plan with 10,000 credits as its example. Its November 2025 pricing notice cites $338.13 a month for 500,000 credits, which works out at about $0.00068. That is a 25% fall in unit cost for 50 times the volume.

Extra credits reverse that discount. Since 6 November 2025 they cost 25% more than included credits, for manual and automatic purchases alike. On the $9 example, 10,000 extra credits cost $11.25. Buy manually in units of 1,000, or enable auto-purchase in units of 10,000.

Credits do not roll over. Monthly-plan extras expire at the end of the billing cycle, and on annual Pro and Teams plans at the end of the billing year. Annual Pro and Teams plans receive the full year's credits up front, which absorbs seasonal spikes. Core does not, because it always allocates monthly, even when billed annually.

My recommendation is direct. If your usage is lumpy and you can commit, annual Pro beats monthly anything, because the annual pool is what turns a bad month into an average one.

Make credits on plain scenarios: four costings

Plain scenarios price cleanly once you count trigger checks and bundles. The four below use 30-day months and a 10,000-credit plan as the yardstick. They are worked examples of my own design, costed under Make's published rules, and none is a measured customer workload.

Four Make scenarios costed in credits per 30-day month
ScenarioWorkingCreditsShare of 10,000
A. Webhook lead routing, 1,500 leads, router, 3 actions1,500 x (1 trigger + 0 router + 3 actions)6,00060%
B. CRM sync, polling every 15 minutes, 1,000 new records, 3 actions each2,880 checks + 3,000 actions5,88059%
C. Nightly batch, 200 rows, 3 actions each30 x (1 + 600)18,030180%
D. Scenario B with one AI classify step per record, Medium tier5,880 + 1,000 operations + 155 token credits7,03570%
D2. Same step on Claude Sonnet 55,880 + 1,000 operations + 5,536 token credits12,416124%

AI steps assume 2,000 input and 100 output tokens. Token credits are the published per-credit rates applied to those counts: 0.155 credits per step on Medium and 5.536 on Sonnet 5.

Polling is billed even when nothing arrives

A scheduled trigger that finds nothing has still run, and Make's definition includes checking for new data. By that definition, frequency is a cost decision. Every 15 minutes is 2,880 credits a month for a single scenario doing no work. Move that scenario to a webhook and the checks disappear.

One polling trigger, finding nothing, for 30 days Credits used by trigger checks alone, at 1 credit per check. 10,000-credit plan Every 15 minutes2,880 Every 5 minutes8,640 Every 1 minute43,200 Source: Zan Digital arithmetic on Make's documented definition of an operation, November 2026.
Read the 1-minute row before you shorten an interval. One setting on one scenario consumes more than four 10,000-credit plans, and the scenario has done no work.

The batch that outgrows the plan

Scenario C is the costing that surprises people, because a modest-looking nightly job crosses the plan by 80%. Make's removal of the Cycles per run setting on 1 October 2026 may add a little to this type of job. My inference, not Make's statement: work once split across cycles now needs more runs, and each run starts with a trigger check.

Make AI pricing is list price in a different unit

Make's token conversion is not an obvious markup. Dividing each published token-per-credit rate into the model maker's list price gives the same number every time, about $0.0009 of tokens per credit. That is an original calculation, and I would treat it as the most useful fact in Make's documentation that Make does not itself point out.

What one Make credit buys at provider list price, November 2026
ModelTokens per credit (input / output)List price per 1M (input / output)Implied credit value
GPT-5 nano18,080 / 2,260$0.05 / $0.40$0.00090
GPT-5 mini3,616 / 452$0.25 / $2.00$0.00090
GPT-5.4 mini1,205 / 200$0.75 / $4.50$0.00090
Claude Haiku 4.5904 / 181$1 / $5$0.00090
Claude Sonnet 5452 / 90$2 / $10$0.00090
Claude Opus 5180 / 36$5 / $25$0.00090
Claude Fable 590 / 18$10 / $50$0.00090

Implied value is tokens per credit times list price per token, computed for input and output separately. All 14 results fall between $0.000900 and $0.000905. List prices are from the OpenAI and Anthropic pricing pages, accessed 9 November 2026.

The consequence is that the provider choice inside Make is not mainly a token-price decision. On the $9 example, Make's tokens cost about what the model maker charges. At extra-credit prices of $0.001125, the same tokens cost about 24% over list. At the $0.00068 tier, they cost about 25% under it, if the peg still holds at that volume.

So the case for a custom provider connection, available on all paid plans since November 2025, rests on something else. It separates two pools. Token spend lands on your provider's invoice, and only operations touch your credits. The analysis of why credits and tokens are different units covers the wider problem of pricing in one and consuming the other.

The 25 August 2026 repricing helped most input-heavy steps. Make split Small, Medium and Large into separate input and output rates, and its own example of 2,000 input and 100 output tokens on Medium fell from about 0.6 to about 0.16 credits. Short prompts with long outputs can cost more than before, and Make warns of exactly that.

Make AI agents: where the cost stops being predictable

Make AI agents break the canvas-reading method, because the model decides how many times to act. Make's help centre dates the current Make AI Agent app to February 2026, and the introduction page I read still labels it open beta. Its tools can be modules, scenarios, MCP server tools or other agents, with sub-agents added on 27 July 2026.

The model behind these figures

Make publishes the rates, not a typical run. So here is a model, and every input is my assumption rather than a measurement. A 3,000-token system prompt and tool list. Each tool returns 800 tokens. Each model turn writes 150 tokens. The conversation is re-sent each turn, and one final turn writes the answer. Tools are plain modules at 1 credit each, with no prompt caching.

Modelled credits per Make AI agent run, by tool calls and model
Tool callsOwn provider keyMedium (GPT-5 nano)Haiku 4.5Sonnet 5
233.8518.5934.22
568.1846.6587.35
101116.45114.42217.94
202136.91328.78636.75
Runs per 10,000 credits at 20 calls4762703015

Illustrative model, not measured usage. The own-key column excludes what your provider bills you for tokens. Total input for 20 tool calls is 262,500 tokens across 21 model turns.

The same agent, 4 times the tool calls, 7 times the credits on Sonnet 5 Modelled credits per run. Illustrative, based on stated token assumptions and Make's published rates. 5 tool calls Own provider key6 Medium (GPT-5 nano)8 Haiku 4.547 Sonnet 587 20 tool calls Own provider key21 Medium (GPT-5 nano)37 Haiku 4.5329 Sonnet 5637 Source: Zan Digital model on Make Help Centre rates, November 2026. Own-key bars exclude provider token bills.
Depth compounds because each turn re-sends the conversation. Going from 5 to 20 tool calls costs 4 times more on the operations alone and about 7 times more on Sonnet 5.

What moves the number, and what you cannot see

Model choice is the largest lever you control. Depth is the largest lever you do not, since a December 2025 Make community reply said credits from tools cannot be predicted accurately and vary with inputs, and advised sampling at least 50 runs. That thread concerned the previous agent app. The poster's handle carries a Make suffix, and the page does not confirm their role.

The real spread in depth is the subject of the analysis of token variance across identical agent tasks, and it is why a single test run tells you little. Two features announced on Make's October 2026 release note and the July sub-agent release can narrow it: prompt caching and tool output filtering. Make says caching reduces credit usage, and publishes no cached-token credit rate I could find. The comparison of caching and batch discounts shows why that missing rate matters.

Make limits that matter more than the meter

The serious Make risk is a stopped scenario, not an unbounded invoice. Make's pricing FAQ says scenarios will not continue to run until credits are added again. Webhooks queue up to the storage limit, about 667 per 10,000 credits with a maximum of 10,000, and polling scenarios resume from the last successful run. A busy queue can overflow while you are out.

Auto-purchase is a ceiling, and a shared pool

Auto-purchase buys 10,000 extra credits at a time, up to your plan's credit amount per monthly cycle. An 80,000-credit plan gets at most 8 purchases. On a 10,000-credit plan, that means one purchase and a maximum bill of about 2.25 times the plan price. Then the account stops, invoices and lead routing included.

In the pages I read, I found no per-scenario or per-agent credit cap and no credit usage alert. The nearest documented controls are the account-level auto-purchase limit and a timeout on the older agent app, which defaults to 300 seconds and tops out at 600. Neither caps credits for one agent. For comparison, HubSpot's AI spend caps show what a vendor ceiling on AI usage looks like.

I would not put a customer-facing agent on Make's AI Provider inside the same pool as billing or fulfilment scenarios. A custom connection keeps the token side out. Check the fallback setting too: Make's October 2026 note names its AI Provider as the default fallback connection, so a retried run could land tokens in the pool you meant to protect.

Where this Make review is weakest

The largest weakness is method. I priced published rules and did not meter live runs, so the agent table is only as good as five assumptions about prompt size, tool output and turn structure. Real agents may call fewer tools, cache their prompts or return far larger payloads. Treat the ratios as more reliable than the absolute credit counts.

The price evidence is thin in one place. Make's pricing page did not render its plan grid in the text I could retrieve, so this review uses only the $9 and $338.13 figures Make states in its help pages. The $338.13 example does not state its billing term and dates from 2025, so the 25% unit-cost fall is directional.

The case against my recommendation

A custom provider connection is not free of cost. It adds a second vendor, a second invoice and a second set of rate limits. For a small team running a few hundred cheap Medium-tier steps a month, tokens are a rounding error: 155 credits of 7,035 in Scenario D. There, Make's AI Provider is the simpler and better answer, and adding a key would solve a problem you do not have.

The peg finding also has a shelf life. Make says its rates change as newer models arrive, and 7 models out of the list it publishes is a sample. If Make moves any rate, the $0.0009 result must be recomputed for that model. The polling figures depend on Make's stated definition of an operation, which I did not test against a real invoice.

Frequently asked questions

How much does Make cost per credit?

Make's Extra credits page works an example on a $9 plan with 10,000 credits, which is $0.0009 per credit. Extra credits carry a 25% surcharge, so the same example prices 10,000 extra credits at $11.25. Higher tiers cost less per credit. Make's November 2025 notice cites $338.13 a month for 500,000 credits, about $0.00068 each.

How many credits does a Make AI agent use?

Each Run an agent operation costs 1 credit, and each tool the agent calls costs at least 1 more. On Make's AI Provider, tokens are added at the rate for the chosen model. With your own provider connection, only the operations use credits. Because the model decides how many tools it calls, a Make community reply advises sampling real runs to find the range.

Do Make scenarios use credits when there is no new data?

Yes, by Make's definition. An operation is a single module run to process data or check for new data, so a scheduled trigger that finds nothing still consumes 1 credit. A trigger polling every 15 minutes uses 2,880 credits in a 30-day month before doing any work. Instant webhook triggers avoid empty checks because they only run when data arrives.

What happens when Make runs out of credits?

Scenarios stop until credits are added. Make's pricing FAQ says they will not continue to run, and webhooks queue up to the storage limit for processing once credits return. Auto-purchase can buy 10,000 extra credits at a 25% surcharge, but it is capped at your plan's credit amount per monthly cycle, so it delays the stop rather than removing it.

Is it cheaper to use your own API key in Make?

Not on token price at the entry rate. Make's conversion values a credit at about $0.0009 of provider list price, which matches the $9 plan's credit cost, so tokens bill at roughly list through either route. Your own key still uses 1 credit per operation. Its advantage is separation, because a token spike cannot drain the credits your other scenarios need.

Where to start with your Make bill

Open your Scenarios list and sort by credits used. For any scenario with a polling trigger, multiply its checks per day by 30 and compare the result with the credits it spends on real work. Anything where the checks win should move to a webhook or a longer interval this week, and that needs no new tooling.

If you run or plan an agent, sample 50 real runs before you size the plan, and record tool calls per run alongside credits. Then use the highest run you saw, not the average, to set your auto-purchase and your alerting. The average tells you the bill. The worst run tells you when the account stops.

One number to find

Write down the share of your Make credits spent on checks that returned nothing. If it is above 20%, the cheapest upgrade you can buy is a webhook.

References

  1. Make Help Centre, Credits, accessed 9 November 2026. Used for credit rules by module type and all token-per-credit rates.
  2. Make Help Centre, Credit usage for AI agents, accessed 9 November 2026. Used for agent, tool and Knowledge billing.
  3. Make Help Centre, Extra credits, accessed 9 November 2026. Used for the $9 example, surcharge, expiry and auto-purchase limit.
  4. Make Help Centre, Updated Make's AI Provider token pricing model, effective 25 August 2026. Used for the input and output rate split.
  5. Make Help Centre, Adjustments to plans and pricing, 6 November 2025. Used for the 25% surcharge date, custom connections and the $338.13 example.
  6. Make, Pricing and FAQ, accessed 9 November 2026. Used for run-out behaviour, free modules and usage allowances.
  7. Make Help Centre, Operations and October 2026 release note, accessed 9 November 2026. Used for the operation definition, the 31-operation example, caching and fallback.
  8. OpenAI, API pricing, and Anthropic, Claude pricing, accessed 9 November 2026. Used for the list prices in the peg calculation.

Last verified 9 November 2026. The weakest thing about this source base is that it is almost entirely Make's own documentation, read without a live account to confirm how invoices behave. Agent figures are an illustrative model. Refresh token rates at each Make pricing notice.

AV
Aryan Vatsa
Contributing Analyst, Zan Digital. Founding product designer, writing here on how AI products are priced, packaged and measured against each other.

Related reading