Zapier vs Make Pricing: Which Is Cheaper at Real Volumes?

This article is for anyone who got a Zapier bill that made them flinch, or who’s comparing Zapier and Make on price and suspects — correctly — that the headline plan prices are not the whole story.

I’ve migrated client workloads in both directions, and the single most important thing I can tell you is this: you cannot compare these platforms by plan price, because they don’t count work the same way. A “task” and an “operation” sound interchangeable. They are not, and the difference can swing your effective cost by 5x in either direction depending on workflow shape.

All prices below are approximate as of mid-2026 — both companies tweak tiers and quotas regularly, so check current pricing pages before committing. For the broader feature comparison, see the full three-way breakdown.

How each platform counts work

Zapier tasks

A task is one action step that successfully executes. Key rules:

• Triggers are free. A Zap that polls Gmail every few minutes and finds nothing consumes zero tasks.
• Every action step counts: a 6-step Zap (1 trigger + 5 actions) consumes 5 tasks per run.
• Filters and some built-in steps (Paths evaluation, Filter by Zapier) don’t count as tasks; Formatter steps do.
• Loops multiply: a Looping by Zapier step that iterates 30 items runs the subsequent steps 30 times, consuming tasks each time.

Make operations

An operation is one module execution. Key rules:

• The trigger counts. Every scenario run starts at 1 operation minimum.
• Polling counts even when nothing happens. A scenario scheduled every 15 minutes burns ~2,880 operations/month just checking — before doing any work. This is the most common Make billing surprise.
• Iterators multiply everything downstream. An iterator splitting 50 rows means every module after it runs 50 times: 50 × downstream modules in operations.
• Routers and filters are cheap (the router itself isn’t an operation; each module on a taken route is).

The asymmetry in one sentence

Zapier charges you only when work happens but charges heavily per step; Make charges you a tiny amount for everything that moves, including checking, including the trigger, including every item in a loop.

Where costs explode on each platform

Zapier cost bombs:

• Long zaps. A 10-step Zap costs 9 tasks per run. At 1,000 runs/month that’s 9,000 tasks — pushing you into the ~$130+/month range alone.
• Formatter chains. Date reformatting, text splitting, lookups — each is a billed task. I’ve seen Zaps where 60% of the task spend was formatting glue.
• Loops. Looping over 100 line items in an order × 3 steps inside the loop = 300 tasks per order.

Make cost bombs:

• Aggressive polling. Ten scenarios polling every 5 minutes = ~86,400 operations/month of pure checking. Fix: use webhooks (instant triggers) wherever possible — they only fire when something happens.
• Iterators over large arrays. Processing a 500-row spreadsheet through 4 modules = 2,000+ operations per run.
• Data transfer limits. Make also meters data volume (GB/month per plan). Workflows moving large files can hit this before they hit the operations cap.

Headline pricing (approximate, mid-2026)

Plan	Zapier	Make
Free	100 tasks/mo, 2-step zaps	1,000 ops/mo
Entry paid	Professional ~$19.99/mo annual (750 tasks)	Core ~$9–11/mo (10,000 ops)
Mid	Professional ~$49/mo (2,000 tasks)	Pro ~$16–19/mo (10,000 ops, priority execution)
Higher volume	~$130–340/mo (10K–50K tasks)	Teams ~$29–35/mo (10,000 ops, +ops purchasable cheaply)

Hedge repeated deliberately: these numbers drift — verify on the live pricing pages. Zapier in particular uses a volume slider, so the per-task rate falls as you commit to more.

The raw unit economics: Zapier works out to roughly 1.3–2.7¢ per task depending on tier; Make is roughly 0.1¢ per operation. Even accounting for Make needing ~1.5–2× more units for the same workflow (trigger counted, glue modules), Make’s per-workflow cost is typically 3–8× lower.

Three worked examples

Example 1: Lead capture — simple and webhook-friendly

Form submission → enrich → create CRM contact → Slack notification. 1 trigger + 3 actions, 600 leads/month. (This is the workflow from our lead capture tutorial.)

	Zapier	Make
Units per run	3 tasks	4 ops (webhook trigger)
Monthly units	1,800 tasks	2,400 ops
Plan needed	Professional ~$49/mo (2,000 tasks)	Core ~$9–11/mo
Effective monthly cost	~$49	~$10

Make is ~5× cheaper, and you’re using a quarter of its quota.

Example 2: E-commerce order processing — the iterator trap

New Shopify order → loop over line items (avg 4 items) → check inventory + update sheet per item → send confirmation. 500 orders/month.

	Zapier	Make
Units per run	1 + (4 items × 2 steps) + 1 = 10 tasks	1 trigger + 1 iterator + (4 × 2) + 1 = 11 ops
Monthly units	5,000 tasks	5,500 ops
Plan needed	~$73–105/mo (5,000-task tier)	Core ~$9–11/mo
Effective monthly cost	~$90	~$10

Loops hurt both platforms in units, but Make’s units cost so much less that it shrugs this off.

Example 3: Low-volume polling — Zapier’s quiet win

Five simple 2-step zaps (trigger + 1 action) on apps with no webhook support, polling every 15 minutes, each firing ~30 times/month.

	Zapier	Make
Trigger polling cost	0 tasks	5 scenarios × 2,880 checks = 14,400 ops
Work units	150 tasks	~300 ops
Monthly units	150 tasks	~14,700 ops
Plan needed	Free–Professional ~$19.99	Pro tier or extra ops ~$16–25/mo
Effective monthly cost	~$0–20	~$16–25

This is the usage shape where Zapier genuinely wins on price: lots of low-frequency polling triggers doing almost nothing. Zapier’s free triggers absorb it; Make bleeds operations around the clock. (The Make fix — lengthen intervals to 1 hour, cutting checks to ~720/scenario — works if latency tolerance allows.)

Hidden costs checklist

Zapier:

• Premium apps (e.g., Salesforce, Shopify on some tiers) require paid plans regardless of volume.
• Multi-step zaps require a paid plan — the free tier is 2 steps only.
• Update frequency: cheaper plans poll less often (up to 15 min); faster polling costs more.
• Autoreplay of failed tasks: paid feature, and replayed tasks bill again.

Make:

• Data transfer caps per plan (GB/month) — file-heavy workflows hit these.
• Minimum scheduling interval on Free is 15 minutes; faster needs paid tiers.
• Full-text execution log retention is shorter on cheap plans, which matters when debugging.
• Custom apps & advanced features (custom functions, on-prem agent) gate behind higher tiers.

Neither platform charges for the LLM tokens your AI steps consume via your own API keys — but Zapier’s built-in AI steps and Chatbots have their own metering. Factor that in if AI is central to your stack (full comparison in best automation tool for AI workflows).

Which is cheaper for which usage shape?

Your usage shape	Cheaper choice
Few simple zaps, < 750 tasks/mo	Zapier (free/entry tier covers it)
Many polling triggers, tiny action volume	Zapier (free triggers)
Multi-step workflows, moderate–high volume	Make, decisively
Loops/iterators over line items, rows, attendees	Make
Webhook-driven, event-heavy workloads	Make
Anything over ~5,000 tasks/month equivalent	Make, usually by 4–8×

Plug your own workflow shapes into our automation cost calculator — it models tasks vs operations side by side so you don’t have to spreadsheet this yourself.

The honest caveat

Price isn’t the only line on the ledger. Zapier’s larger app catalog and simpler editor mean some teams ship and maintain automations meaningfully faster on it. If switching to Make saves you $80/month but costs your ops person four extra hours of fiddling per month, you’ve lost money. The cost advantage of Make is real and large — but it accrues fastest to teams who climb its learning curve once and then run high volumes for years.

Bottom line: model your three biggest workflows in units before you commit. Twenty minutes of arithmetic now beats a 5× bill surprise in month four.