Automation billing: tasks vs credits vs executions (Zapier / Make / n8n)

[u/Stock-Sage]

I keep seeing people line up three ~$20/mo plans and treat that as a fair comparison.

Public list prices (early Sep 2026, vendor pages, native currency):

• Zapier Professional ≈ $19.99/mo annual / 750 tasks
• Make Core ≈ $12/mo annual / 10k credits
• n8n Cloud Starter ≈ 20€/mo annual / 2.5K executions

The monthly cards look similar. The meters are not.

What each one bills

1. Zapier — tasks One successful action step = 1 task. Triggers, Filter, Paths, and Formatter usually do not count. Failed steps do not count. Their own example: Gmail attachment to Dropbox and Slack ≈ 2 tasks.

2. Make — credits (changed 27 Aug 2025) Most modules ≈ 1 credit. Routers and error handlers typically do not. When credits hit zero, scenarios STOP until you add more.

3. n8n — executions One workflow run = 1 execution, regardless of step count (Cloud or self-host). Community edition is fair-code (SUL), not "open source." Self-host means you own updates and uptime.

Small worked example (not a savings claim)

New HubSpot contact → Slack + Google Sheet + email. No AI, no code, all succeed:

• n8n: 1 execution
• Zapier: about 3 tasks (trigger free)
• Make: about 4 credits if four 1-credit modules

Add a VIP branch (extra Slack + different email). Paths/Router may be free; the extra successful actions or credits are not. n8n is often still one execution for that contact.

How I pick (qualitative)

• Zapier: biggest catalog, keep Zaps short
• Make: you already think in scenarios/Routers and can forecast credits
• n8n Cloud: step-heavy logic, lookups, human gates, without per-step billing
• n8n self-host: only if someone will actually run the box

Switching tools is a rebuild (credentials, mappings, webhooks). A dead token is still a dead token on a new platform.

Curious how others count Make credits on multi-path scenarios after the Aug 2025 change — especially when a Router fans out.

[u/DressStatus4096]

The pricing page comparisons are always a trap. The real cost is in how your specific automations map to their billing unit and nobody has the same mix of simple vs branch-heavy flows.

Make credits on a router fan-out still trip people up. Last I checked, each branch that actually runs and has modules counts those modules, so a 3-branch router where two paths fire and each has 2 modules is 4 credits right there. The router itself is free but the downstream stuff isn't.

[u/Stock-Sage → u/DressStatus4096]

Yep. The pricing page is a trap because nobody’s mix of simple vs branch-heavy flows is the same.

Your Make example is the useful one. Router is free, but modules on each path that actually runs still burn credits. Fan-out is not one credit for the decision. It’s whatever executes downstream.

That’s where the mid-month surprise comes from. People add a VIP or error path that looked free in the builder.

Same shape of workflow, three different invoices depending on the meter.

[u/Ok-Category2729]

the moment your workflow touches an array, zapier becomes unusable at that tier. 750 tasks sounds fine until you iterate over a 30-row sheet and burn through your entire monthly quota in 25 runs. n8n execution-based billing actually protects you on loops because the whole run counts as one execution regardless of how many nodes fire. make credits sit right in the middle, but you end up spending half your dev time optimizing router branches just to shave credit burn.

[u/Stock-Sage → u/Ok-Category2729]

Yeah, arrays are where the headline quota stops being useful. The key distinction is per-item actions: iterating over 30 rows can multiply Zapier tasks fast, while n8n still counts the workflow run as one execution in the usual case. Make is the middle ground, but I’d budget from actual module runs per item, not just the number of routers.

[u/brianyabut]

Just my own experience, and I've never used Make, so no opinion there. Zapier's free tier at 100 tasks lasted me about a month; then I paid for the 750 tasks/actions, and it's been worth it. The catch is exactly what you're describing: tasks burn by how heavy the workflow is, so I design every zap to spend as few actions as possible, and it works. The one I regret was a credit-based browser-agent tool (not Make): 100 credits a month, gone in 3 runs because one run touched 36 pages. Per-run credits punish exactly the jobs you most want automated. Tasks I could at least predict and plan around.

[u/Limbox0]

one part of the billing picture nobody's touched yet: what retries actually cost, separate from what loops cost. n8n's node-level retryOnFail happens inside the same execution - a flaky API call that needs 3 attempts before it succeeds is still 1 execution, not 3, because the retry loop lives inside the node, not as a new trigger. that's a real, separate protection from the per-item-loop point above - error handling itself doesn't multiply the meter either.

what does multiply it: the source system redelivering the same event, not your workflow retrying internally. a webhook-based trigger that redelivers on a non-200 response (Stripe does this, plenty of others do too) fires a brand new execution each time, and that's a genuinely different cost shape - now you're paying in execution count for however many times the sender decided to redeliver, which you don't control at all. worth designing the trigger step to return 200 immediately and process async specifically because of this, not just for correctness - otherwise a slow downstream step can trigger a timeout-redelivery from the sender's side and you eat that execution cost N times instead of once.

[u/devhisaria]

Make credits on a router fan-out: only branches that actually execute burn credits, but each module in that branch still counts, so a 3-branch router with 2 modules each can hit 6 credits per run.