Make.com Pricing 2026: What Operations Actually Cost (and the Math Most Guides Skip)

— Make.com Core starts at $10.59/mo for 10,000 operations, roughly 3–5× cheaper than Zapier at the same volume. The trap nobody tells you: triggers, filters, and iterators all count as separate operations. A "3-step" workflow on the canvas easily burns 8–15 ops per run, and a 1-minute polling trigger eats ~43,000 ops/month doing nothing. Here's the math you actually need before committing.

I've been migrating clients between Zapier, Make, and n8n for the past year. Make is genuinely the cheapest hosted option for most SMB workloads — but only if you understand how operations are counted. Here's the dev-honest version of what each tier really costs.

What an "operation" actually is

One operation = one module execution. Every module that runs counts, every time the scenario fires.

Take this seemingly simple workflow:

Trigger: New email in Gmail
  ↓
Filter: Subject contains "invoice"
  ↓
Action: Save attachment to Drive
  ↓
Action: Notify Slack

Looks like 4 steps, right? It's 4 operations per qualifying email. But here's where most people miscalculate:

• Triggers count as operations. Polling triggers eat ops on every poll, regardless of whether anything changed.
• Filters count as operations. Yes, the filter step itself burns 1 op even if it stops the flow. Zapier filters are free; Make's are not.
• Routers and iterators multiply. An iterator looping through 10 line items = 10 operations for that step alone.

The polling trap is the killer. If your Gmail trigger polls every 1 minute (Pro plan minimum), that's 43,200 trigger checks per month before any action runs. On Core ($10.59/mo for 10k ops), you've already overshot 4× on the trigger alone.

The fix: use webhooks wherever the source app supports them. A webhook trigger uses 1 op per actual event, not per check. If you're new to wiring up webhooks, here's a practical webhook primer covering testing.

All Make.com plans 2026 (annual billing)

Monthly billing is ~30% more. Numbers below are headline annual rates.

Plan	Price	Operations	Active scenarios	Min interval
Free	$0	1,000/mo	2	15 min
Core	$10.59/mo	10,000/mo	Unlimited	1 min
Pro	$18.82/mo	10,000/mo	Unlimited	1 min
Teams	$34.12/mo	10,000/mo	Unlimited	1 min
Enterprise	Custom	Custom	Unlimited	1 min

Notice anything? The operation count is identical across Core, Pro, and Teams. What changes:

• Pro adds priority execution + full-text execution log search. Worth it if you're debugging complex scenarios regularly. Skip it if your workflows run on schedule.
• Teams adds team roles and shared scenario templates. The 81% price jump from Pro is for admin functionality only. Solo and 2-person teams should skip.
• Enterprise adds SSO, SCIM, audit logs, 24/7 support. Almost no SMB needs it.

The November 2025 update: extra-operation packs now carry a 25% markup over included credits. A 10k-op pack costs ~$11. If you're consistently buying 3+ packs/month, just upgrade tier.

Real cost for typical SMB workloads

All scenarios assume webhook triggers wherever possible.

Solo freelancer, 5 client workflows

5 scenarios × 4 modules × ~50 runs/month = ~1,000 ops/month. Free tier blocks at 2 active scenarios, so you're on Core at $10.59/mo ($127/year). Plenty of headroom.

E-commerce store, 1,000 orders/month

Shopify webhook → enrich → CRM → confirmation email → analytics → Slack

6 modules × 1,000 orders = 6,000 ops. Add abandoned-cart recovery (~3,000 ops) and weekly reports (~200 ops) = ~9,200 ops/month. Core fits, but a 15% volume spike forces an extra-pack purchase. Budget $130–145/year.

Marketing agency, 8 clients

~25 scenarios, varied frequency, average 5 modules each. Realistic: 30,000–40,000 ops/month. Plan: Teams ($34.12/mo) for collaboration + 2–3 extra packs ($22–33). Total: $670–800/year. Equivalent Zapier setup: $250–400/month. Make wins by ~$2,500/year.

Lead capture pipeline (CRM + Telegram)

200 leads/mo through form → enrich → CRM deal → Telegram → ESP tag → Sheets log = 7 modules × 200 = 1,400 ops/month. Comfortably on Core. Implementation walkthrough for the underlying flow: website-to-CRM-to-Telegram integration — the architecture transfers to Make 1:1.

Make vs Zapier vs n8n at 10k ops/month

Criterion	Make.com	Zapier	n8n
Price	$10.59/mo	~$73/mo (Pro)	$0 self-hosted
Triggers count?	Yes	No	Yes (executions)
Filters count?	Yes	No	Yes (per node)
Self-hosting	No	No	Yes
Best fit	Cost-conscious SMB	Reliability-first	Devs, high volume

Math on equivalent workloads: Make is 3–5× cheaper than Zapier at any realistic SMB volume. n8n self-hosted wins above ~50,000 ops/mo if you've got the DevOps capacity. Deeper feature comparison: n8n vs Make breakdown.

7 ways to actually save money on Make

1. Replace polling with webhooks. Single biggest lever. A 1-minute polling trigger burns 43,200 ops/mo doing nothing. Webhook = 1 op per real event.
2. Place filters early in the scenario. A filter costs 1 op but can save 5+ ops in stopped runs. Net positive at any scale.
3. Use aggregators for batch operations. 50 individual row inserts = 50 ops. One bulk insert via aggregator = a handful of ops.
4. Pick the longest acceptable polling interval. If you can tolerate 15-min lag, use 15-min polling. 1-min → 15-min cuts trigger cost by 15×.
5. Audit the top 3 scenarios monthly. They usually account for 60–80% of total ops. The Pro plan's full-text log search makes this trivial.
6. Switch to annual billing. Saves ~30% if you're staying past 4 months.
7. Refactor large scenarios into reusable sub-scenarios. Easier to disable, audit, and they fail more gracefully.

For the technical reader: log webhook events properly so you debug without re-running entire scenarios on real data. Here's the pattern I use: how to log webhooks correctly.

Quick example of a defensive HTTP module call inside Make — wrapping an outbound webhook with structured logging:

// In a Make HTTP/Tools "Set variable" module:
{
  "request_id": "{{1.uuid}}",
  "timestamp": "{{formatDate(now; 'YYYY-MM-DDTHH:mm:ss')}}",
  "scenario_id": "{{scenario.id}}",
  "execution_id": "{{execution.id}}",
  "payload": {
    "event": "lead.created",
    "source": "webform",
    "data": {{1.body}}
  }
}

Pipe that to a Google Sheet or Loki/Logflare endpoint and you get traceable execution without burning extra ops on test runs.

When Make stops being the right answer

Make is the cost leader up to a clear threshold. After that, the math flips:

• Above 80,000–100,000 ops/month consistently. Core ($10.59) + 9 extra packs ($99) = ~$109/mo. n8n self-hosted on a $20 VPS pays back in DevOps time within 3 months.
• Polling-heavy use cases you can't switch to webhooks. If the source forces polling, n8n's no-per-execution model wins fast.
• Real-time critical workflows where Pro priority isn't enough. Pro still queues during platform peaks. Move to self-hosted or pay the Zapier reliability premium.
• Strict compliance (HIPAA, SOC 2 Type II). Make Enterprise covers it but climbs sharply. Self-hosted n8n is often easier to certify on your own infrastructure.

Verdict

Pay for Make if you: are a freelancer, solo operator, or SMB doing 5,000–30,000 ops/month, want a polished visual builder, value the 3,000+ app catalog, and don't want to run your own infrastructure. Core at $10.59/mo is the best price-to-power ratio in hosted automation today.

Look elsewhere if you: burn 80k+ ops/month consistently (n8n self-hosted), need bulletproof real-time execution (Zapier reliability tier), or have 5+ scenario editors making Teams economics painful.

Honest take: start with the free plan, build one or two real scenarios you'd otherwise pay for, watch operation usage for a week. That single data point tells you which tier to commit to better than any pricing calculator.

---

Originally published on TrackStack — practical write-ups on automation, tracking, and infrastructure for SMBs. If your migration math came out differently, drop a comment — I read all of them.