Make.com Pricing 2026: The Credit Math Nobody Explains

Make.com costs $0 for 1,000 credits a month, $9 for the Core plan’s 10,000 credits, $16 for Pro and $29 for Teams — all at the 10,000-credit tier. Those numbers are easy. What almost nobody explains is how a credit gets consumed, and that is the part that decides your actual bill.

Here is the rule that catches people: a trigger pulling 100 records costs one credit, but every module after it runs once per record. Get that wrong and a scenario you budgeted at 300 credits a month burns 30,000. This guide walks the arithmetic, shows where it explodes, and covers the one design change that cuts consumption most.

What Does Make.com Cost in 2026?

Make has four public tiers plus Enterprise. Prices below are the 10,000-credit versions of each paid plan, read off Make’s own pricing page on 26 July 2026; every paid tier can be scaled up to higher credit allowances at higher prices.

Note what the Free plan’s real limit is. Everyone fixates on the 1,000 credits; the 15-minute minimum interval is the harder wall. If you need a scenario to react within seconds — a lead alert, a support ticket routing — the free plan cannot do it at any credit volume. That alone pushes most real use onto Core.

Note also what does not change between Core, Pro and Teams: the credit allowance. You pay $9, $16 or $29 for the same 10,000 credits. You are buying features, not capacity. Most solo operators and small teams never need what Pro adds.

How Does Make Count Credits?

A credit is consumed every time a module runs to process or check data. Make’s own documentation defines an operation as “a single module run to process data or check for new data” — so a scenario with five modules costs at least five credits every time it executes.

That “at least” is doing heavy lifting, and it comes down to bundles.

The trigger exception

Triggers are metered differently from everything else. Per Make’s documentation, they “only run once to check for or retrieve data, regardless of the number of bundles returned.” A trigger that finds 100 new emails costs one credit, not 100.

This is genuinely generous, and it is why people assume Make is cheap. Then they add a second module.

The multiplication effect

Every non-trigger module runs once per bundle. Make’s documentation is explicit: “modules process each bundle separately, meaning each bundle triggers its own module run,” and the example given is direct — “the gmail > send an email module sends 5 emails = 5 operations (one per email).”

So bundles cascade. If a trigger returns 10 bundles, the next module runs 10 times, and the module after that runs 10 times too. Make’s docs put it plainly: if a trigger returns 10 bundles, “the next modules run once for each bundle > that many operations.”

The formula: credits per execution ≈ 1 (trigger) + (bundles × number of downstream modules). The second term is the one that grows without you noticing.

What Does a Real Scenario Actually Cost?

Below are three scenarios of increasing bundle exposure, all built on the same four modules. The only variable is how many records the trigger returns — and it changes the monthly bill by a factor of 50.

The third row is the one that surprises people. Same four modules, same once-a-day schedule — but 4,530 credits a month, nearly half of a Core plan, for one scenario. Add three more like it and you are over the limit.

Two things this table leaves out, both of which push the number up. Retries consume credits, so budget 10–15% above your arithmetic. And iterators multiply deliberately — that is their job — so any scenario that splits an array into items is a bundle amplifier by design.

How Do You Cut Credit Consumption?

Collapse bundles before they reach expensive modules. Make’s own guidance points at this directly: you can optimise operation costs “by using aggregators to combine data, reducing module runs and overall operation consumption.”

Four changes, in order of how much they save:

• Aggregate early. If 50 rows need to end up in one summary email, aggregate them into a single bundle first, then send once. That is 50 credits saved on the send module alone.
• Filter before you branch, not after. A filter that drops 80% of bundles at position two saves those bundles from every module that follows. Filters placed late save nothing.
• Cut module count, not scenario count. Ten small scenarios cost less than one bloated scenario with the same bundles, because each module in the chain multiplies. Merging scenarios to “tidy up” often increases cost.
• Batch schedules instead of polling frequently. Running hourly instead of every 15 minutes cuts trigger credits by 75% — and if nothing changed, all downstream modules skip too.

The counterintuitive one is the third. On per-execution platforms, consolidating workflows saves money. On Make, it usually doesn’t, because the meter runs on modules and bundles rather than on executions.

Is Make Cheaper Than Zapier and n8n?

For most small-business workflows, yes — often by a wide margin. But the answer depends entirely on the shape of your automation, because all three platforms meter completely different things.

Take one trigger plus two actions running 1,000 times a month. Zapier bills 2,000 tasks, which needs the $49/month Professional tier. Make bills 3,000 credits, comfortably inside Core at $9. n8n bills 1,000 executions, inside Starter at €20. Same automation, and Make is roughly five times cheaper than Zapier.

Now change one thing: make the trigger return 50 rows each run. Make’s bill jumps to about 151,000 credits — far beyond any reasonable plan — while n8n still bills 1,000 executions, because n8n counts the whole workflow once regardless of what happens inside it. High-bundle work is exactly where Make stops being the cheap option and n8n becomes it.

Our full breakdown of all three billing models is in the comparison of the best AI automation tools for small business, and there’s a dedicated Zapier pricing explainer if per-step billing is what you’re weighing.

When Is Make the Wrong Choice?

Make is the wrong choice in four specific situations, and it is worth checking these before you commit, because migrating scenarios later is genuinely painful.

One more honest limitation. Make’s execution log is excellent for debugging a single run, but full-text log search is a Pro feature. If you are running dozens of scenarios and need to answer “when did this last fail?”, budget the $16 tier rather than the $9 one.

Frequently Asked Questions

What is a credit in Make.com?

One credit is one module run. Make defines an operation as “a single module run to process data or check for new data.” A five-module scenario therefore costs at least five credits each time it executes, and more if the trigger returns multiple records.

Do Make triggers use credits?

Yes, but only one per check, regardless of how much data comes back. A trigger returning 100 records costs one credit. The cost arrives afterwards: every module downstream then runs once per record.

Is the Make free plan enough for a small business?

Rarely, and the reason isn’t the credits. The free plan enforces a 15-minute minimum interval between runs, so anything needing a fast reaction — lead alerts, ticket routing — can’t work on it. Core at $9 removes that limit.

How much is Make.com per month?

Free is $0 for 1,000 credits. Core is $9, Pro $16 and Teams $29, all for 10,000 credits at the entry tier, with annual billing saving 15% or more. Higher credit allowances cost more within each plan.

Why is my Make credit usage higher than expected?

Almost always bundle multiplication. Check whether a trigger or iterator is returning multiple records — every module after it runs once per record. Add an aggregator before your expensive modules and re-check.

Is Make cheaper than Zapier?

For typical low-bundle workflows, substantially — a one-trigger, two-action automation running 1,000 times a month costs $9 on Make against $49 on Zapier. For high-bundle batch work, Make can become the more expensive option and n8n the cheapest.

The Bottom Line

Make Core at $9 a month for 10,000 credits is the best value in mainstream automation, and it stays that way as long as your scenarios process a few records at a time. The moment you start moving batches — 50 rows, 200 rows — the per-module meter turns against you, and that is a design problem, not a plan problem.

So build with the formula in mind from the start: one credit for the trigger, plus bundles times downstream modules. Aggregate before the expensive steps, filter early, and check your usage after the first week rather than after the first invoice. Do that and $9 covers more automation than most small businesses will ever build.

If you haven’t built a scenario yet, start with our beginner’s workflow automation guide, then come back and cost it properly. And if you’re weighing whether to automate at all, the business automation playbook has the payback arithmetic.

Want one practical automation you can set up in 15 minutes, delivered twice a month? Join the free AI automation newsletter.

Sources

• Make — Pricing plans
• Make Help Centre — Operations and how they are counted
• Zapier — Pricing plans
• n8n — Pricing plans
• SBE Council — 2026 Small Business Tech Use Survey

All sources retrieved 26 July 2026. Credit tables are worked arithmetic from Make’s documented counting rules; vendor pricing changes often, so the pricing page is the authority.