Make.com pricing looks simple on the surface — plans from free to ~$38/month — but the real cost of Make.com is determined by one formula almost nobody runs before signing up: trigger volume × module count = credits consumed. Get that math right and Make is the cheapest hosted automation platform on the market. Get it wrong and your scenarios stop mid-month.
This guide covers every plan, how credits actually burn, and the 2026 changes most older articles miss.
Key Takeaways
- One credit = one module execution — triggers, filters, routers, and each loop iteration all count
- Core (~$9-12/mo annual) includes 10,000 credits — roughly 13x the automation volume of Zapier's $19.99 plan with 750 tasks
- In 2026 Make renamed “operations” to “credits” — older guides mean the same thing
- Since November 2025, add-on credit packs carry a ~25% markup — chronic overage means you should upgrade tiers instead
How Make.com Credits Actually Work
Every module that executes costs one credit, every time the scenario runs. That includes things competitors give away:
- Triggers count. A polling trigger checking for new data burns a credit per check — even when nothing new exists.
- Filters count. Zapier filters are free; Make filters cost a credit per evaluation.
- Iterators multiply. Loop through 20 line items across 5 modules and that's 100 credits for one “run.”
- Routers fan out. Each active branch executes its modules — branchy logic is exactly where usage multiplies.
- Make Code modules (JavaScript/Python) bill at 2 credits per second of execution.
Worked example — a 5-module scenario triggered 500 times/month consumes 2,500 credits. The same scenario polling every minute instead of using a webhook adds ~43,000 trigger checks monthly. Polling frequency, not workflow count, is what blows up bills.
Every Make.com Plan in 2026
| Plan | Annual price | Credits | What it adds |
|---|---|---|---|
| Free | $0 | 1,000/mo | 2 active scenarios, 15-min minimum interval |
| Core | ~$9-12/mo | 10,000/mo | Unlimited scenarios, 1-min interval, webhooks, Make API |
| Pro | ~$19-21/mo | 10,000/mo | Priority execution, full-text log search, custom variables |
| Teams | ~$34-38/mo | 10,000/mo | Roles, shared scenario templates |
| Enterprise | Custom | Custom | SSO, SCIM, audit logs, 24/7 support |
(Sources publish slightly different figures depending on billing cycle and region — Core appears as $9, $10.59, or $12 across current guides. Annual billing saves ~15-17% versus monthly everywhere.)
Notice the pattern: Core, Pro, and Teams all start at the same 10,000 credits. Higher credit tiers (20k, 40k, 80k…) are purchased within each plan. So the plan question and the volume question are separate decisions.
Honest tier advice:
- Core covers ~90% of freelancer and SMB use cases. Best price-to-credit ratio on the hosted market (~$0.001/credit).
- Pro is worth it only if you debug complex scenarios regularly — full-text log search turns a 20-minute error trace into two minutes. If your workflows just run on schedule, skip it.
- Teams is an ~80% price jump over Pro for admin features. Justifiable at 3+ people building automations; skippable below that.
- Enterprise is a governance conversation (SSO, audit, compliance), not a feature one.
The 2026 Changes Older Guides Miss
1. Operations became credits. Make renamed its billing unit in 2026. The accounting is essentially identical — you're charged per module call — but the rename unified how AI features and add-ons are metered. When an older article says “operations,” substitute “credits.”
2. Add-on packs got a markup. Since November 2025, extra-credit packs cost roughly 25% more per credit than your plan's included allocation (a 10k pack runs ~$9-11). If you're buying 3+ packs monthly, upgrading your credit tier is strictly cheaper.
3. AI Agents consume credits too. The next-gen agents (shipped February 11, 2026) call modules as tools, so agentic scenarios budget like any multi-module flow — sometimes an unpredictable one, since the agent decides its own steps.
4. Data transfer limits exist: roughly 5 GB per 10,000 credits. File-heavy workflows should check this before the credit ceiling.
What Happens When You Run Out
On the free plan, scenarios pause until the monthly reset. On paid plans, you choose: enable automatic top-ups, pre-purchase add-on packs, or upgrade. Set usage alerts on day one — a single misconfigured iterator ate 1,900 of our credits in one afternoon.
Before you pay for more volume, though, most accounts can cut consumption 30-50% with configuration changes alone — filter placement, interval tuning, webhook conversion. We documented all nine tactics in how to reduce Make.com credit usage.
Try Make free first — measure your real credit burn before payingMake.com Pricing vs Zapier
The headline: Core's 10,000 credits at ~$9-12 versus Zapier's 750 tasks at $19.99 — but the units differ. Make bills triggers and filters; Zapier doesn't. A workflow that costs 2 Zapier tasks costs 4 Make credits. Even at that 2x unit ratio, Make lands 3-5x cheaper for equivalent multi-step volume. The complete head-to-head, with our 90-day parallel test data, is in Make.com vs Zapier.
A Worked Example: Estimating a Real Account
Theory into practice — here's the estimation method applied to a hypothetical (but typical) freelancer account with three scenarios:
Scenario A — Lead capture: webhook trigger + filter + CRM write + Slack alert = 4 modules. At 200 leads/month: 800 credits. (Webhook triggers only fire on real events — no idle polling cost.)
Scenario B — Daily reporting digest: schedule trigger + 3 data fetches + compile + email = 6 modules, once daily: ~180 credits/month.
Scenario C — Invoice filing: Gmail polling trigger (15-min interval) + filter + Drive upload + Sheets log = 1 trigger check × 2,880 polls + 3 modules × ~40 actual invoices = ~3,000 credits/month — and notice the polling trigger alone is 96% of that cost.
Account total: ~4,000 credits/month → Core's 10,000 fits with comfortable headroom. But the exercise reveals the optimization instantly: converting Scenario C's polling to a webhook (or slowing it to hourly) would drop the account under 1,500 credits.
That's the entire skill of Make budgeting in one example: polling frequency dominates everything else, module counts matter second, and run volume matters third. Estimate in that order and your first invoice will hold no surprises.
Estimate free, then commit — Make's free tier reveals your real burn rateWhich Credit Tier Should You Actually Buy?
The plan picker shows credit tiers from 10,000 up to 800,000, and the right answer comes from one number: your busiest scenario's monthly execution count times its module count, summed across scenarios.
A worked shortcut for common profiles:
- Solo operator, 5–10 light scenarios (forms, notifications, syncs): 10k credits covers you with room to spare. Start here; the upgrade path is instant.
- Small team with polling triggers: watch the interval math. One scenario polling every minute consumes ~43,000 credits monthly before doing any work. Switch to webhooks or 15-minute intervals and the same team fits in 20k.
- Agency running client workloads: separate organizations per client beats one giant account — cleaner billing, cleaner blast radius, and you can right-size each tier independently.
Two settings worth enabling on day one: usage alerts at 75% and 90% of your allocation, and a decision in advance about auto-purchase. Auto top-ups keep production running but at the ~25% add-on markup; leaving them off means scenarios pause at the cap. Pick based on whether a stopped workflow or a surprise line item hurts more — for revenue-touching automations, take the markup.
FAQ
Is Make.com worth the cost? If your workflows run at predictable volumes, yes — the per-credit price is the best among hosted platforms. Costs spike when loops, high-frequency polling, or agent workflows run unmonitored. Our full Make.com review covers where it earns its price and where it bites.
What's the difference between credits and operations? Nothing practical — Make renamed operations to credits in 2026. One credit still equals one module execution.
Can I just stay on the free plan? For learning, yes. For production, rarely — 1,000 credits with a 15-minute interval exhausts fast. See exactly what fits in our Make.com free plan limits breakdown.
How do I estimate my monthly cost? For each scenario: (runs per month) × (modules per run, counting trigger and filters). Sum across scenarios, add 20% headroom, pick the credit tier above that number.
The bottom line on Make.com pricing: multiply before you subscribe — trigger volume times module count — and Core's 10,000 credits will either look enormous or obviously insufficient, with no surprises either way.
