n8n vs Zapier vs Make: The Billing Unit Decides Which One Survives Agents

Compare n8n vs Zapier vs Make on features and you get three near-identical lists. Compare them on the billing unit and they stop being the same product. Zapier bills agent work in activities, capped at 40 per run. n8n bills one execution however many steps run inside it. Make bills credits, then bills tokens on top of the credits.

What actually changed when a workflow became an agent

Short answer. n8n is cheapest of the three for deep agent loops, Zapier is cheapest when agents fail often, and Make sits between them while charging for tokens as well as steps. The reason is the billing unit, not the feature set. Agents make the step count unpredictable, and only n8n prices a run independently of how deep it goes.

A conventional Zap or scenario has a step count you can read off the canvas. Trigger, filter, two actions, done. You could forecast next month's bill on an envelope and be right.

An agent does not work like that. It calls a model, the model picks a tool, the tool returns something, and the model decides whether another call is needed. The loop runs until the agent judges the job finished. Step count used to be a design-time property. It is now a runtime property that varies with the input.

Per-step budgeting breaks at that point. You stop buying a known quantity of work at a known unit price. You start buying an unknown quantity at a known unit price, which is a different contract to sign.

My position, stated up front so you can discount it: pricing a variable-depth process by the step was correct for 2015 and is wrong for 2026. The vendors that keep it will keep it for revenue reasons, not customer reasons.

How each platform counts, in its own words

Every figure below comes from the vendor's own pricing page or help centre, opened on 26 August 2026. None of it comes from a comparison roundup, and the reason for that discipline appears later.

n8n counts executions, and only production ones

n8n's pricing page states the rule directly. Every cloud tier is sold as a number of workflow executions with unlimited steps, with unlimited users and every integration on all plans.

Two documented details matter more than the headline price. Manual runs from the editor do not count against the quota, so building and testing is free. And when a workflow calls another with the Execute Sub-workflow node, only the parent execution counts.

So an agent that reasons through 40 tool calls and delegates twice registers as one billable unit. Whether that is generous, or simply a different way of recovering the same money, is answered by the concurrency limits further down.

Zapier counts tasks, then counts activities separately

Zapier's task rules are unusually well documented. Its help centre states that triggers never use tasks, that Filter and Paths steps are not billable, and that all action steps which error or halt are free. Formatter, Delay, Looping, Digest and Storage are free too.

What does bill: every successful action step, every successful step inside an error handler path, and every previously successful step that runs again on a full replay. Sub-Zaps bill each internal action plus the call step and the return step.

Agents run on a separate meter. An activity is any billable action the agent takes. Zapier lists six: using a trigger, answering from a knowledge source, running an action, browsing or scraping a page, running a web search, and receiving a message through the Chrome extension.

Make counts credits, then counts tokens

Make replaced operations with credits as its billing unit on 27 August 2025, converting balances one to one. The default rate stayed the same. One operation equals one credit for standard apps.

The exceptions are where agents live. Some modules consume 2 or 10 credits per operation rather than one. Running an agent through the Make AI Agent app costs one credit per operation plus credits derived from AI tokens. In chat mode, each tool the agent calls costs another credit per operation.

Using a third-party model is easier to reason about. You pay Make one credit per operation, and pay OpenAI or Anthropic separately for tokens. That split makes the bill legible, which is the subject of the piece on why credits and tokens are not the same unit.

The fourth column is the whole comparison. Three of these four rows scale with how deeply an agent reasons. One does not.

The arithmetic on one agent workflow

Abstractions are easy to argue with, so here is a specific workflow costed under all three rule sets.

The worked example, and its assumptions

The workflow is a support triage agent. A ticket arrives. The agent reads the customer record from a knowledge source, then runs one web search to check a status page. It then takes three actions: look up the account, draft a reply, post a summary to Slack. That is six billable units under Zapier's activity definition.

Assumptions, stated so you can disagree with them. 500 triggering events a month, six billable units per run, no retries and no test runs. List prices as published on 26 August 2026. Make's own AI provider is excluded from the credit count. Change the depth and the ranking changes with it, which is the point rather than a caveat.

At 500 events a month the totals separate quickly. n8n bills 500 executions, inside the 2,500 that Starter includes for 20 euro. Zapier bills 3,000 activities against 1,500 included on Pro, so the agent allowance runs out mid-month. Make bills 3,000 credits before tokens, inside the 5,000 the entry paid plan includes for 9 dollars.

The harsher number is the ceiling. Zapier limits a single agent run to 40 activities on Pro and 10 on the free plan. An agent reasoning to full depth every time consumes the monthly allowance in about 37 runs.

Thirty-seven runs a month is not a production workload. It is a demo. Zapier does allow agents to accrue extra activities to finish a run without charging for them, which is decent design, but the pool still stops refilling until the next billing date.

Zapier Agents allowances sit outside the task figures above: 400 activities a month on Free, 1,500 on Pro. Currencies are as each vendor publishes them, unconverted.

Where the cheap unit stops being cheap

An execution meter looks like a gift until you read the second column of the pricing table. n8n does not sell unlimited work for 20 euro. It sells unlimited depth and meters something else.

That something else is concurrency. Starter allows 5 concurrent executions, Pro 20, Business 30, and Enterprise starts at 200. Agent runs are slow because model calls are slow. A run holding a slot for 90 seconds only has to arrive faster than one every 18 seconds to saturate a limit of 5, long before 2,500 executions are spent.

The pattern is familiar across the AI stack. Vendors advertise the meter customers watch and constrain the one they do not. That is the manoeuvre examined in the piece on bundling against metering and in the account of usage limits tightening without a price change.

Self-hosting is the usual escape. The community edition of n8n is free software with no execution cap, which is where most comparisons stop. It is true and incomplete. Running it yourself means owning the upgrade path, the queue configuration, the Postgres instance, the encryption key, the backups and the on-call rota.

Self-hosting substitutes labour for licence. For a team with a platform function that trade is often good. For a five-person company it converts a 20 euro line item into an unbudgeted engineering commitment, and the platform economics that follow are covered in the piece on where the orchestration layer actually sits.

The licence question, answered by n8n itself

The phrase open source appears in almost every n8n comparison written this year. n8n does not use it, and says why.

Its documentation states that according to the Open Source Initiative, open source licences cannot include limitations on use, so the company does not call itself open source. The code ships under the Sustainable Use License version 1.0, which n8n describes as fair-code. The operative clause is short. You may use or modify the software only for internal business purposes or personal use, and distribute it only free of charge for non-commercial purposes.

For most readers this changes nothing, because automating your own company is explicitly permitted. It matters if you plan to host n8n for clients as a paid service. That is not internal business use. n8n has separately lifted the restriction on charging for consulting and support, so building workflows for clients is fine. Reselling the platform is the line, and an agency that finds this out after launching has a commercial problem rather than a technical one.

Failure is where the meters really differ

Agents fail more often than deterministic workflows, because they take more steps and each step can go wrong. So the interesting question is not what a successful run costs. It is what a failed one costs.

Zapier does not bill a step that errors

This is the strongest thing in Zapier's rulebook and it goes almost unmentioned in comparisons. The documentation is explicit that all action steps which error or halt, and all steps that do not run, are free.

Under agents that carve-out is worth more than it used to be. An agent looping against a broken API burns your model budget, but not your Zapier allowance. Set against that, replaying a whole Zap run bills the previously successful steps again, so debugging a nine-step Zap is not free.

I would still take the execution meter for deep workloads. But any version of this comparison that treats Zapier as simply the expensive option has not read the task rules.

Make stores incomplete runs only if you switch it on

Make's incomplete executions feature holds unfinished scenario runs so they can be retried rather than lost. It is disabled by default and has to be enabled in scenario settings, and the number stored depends on your usage allowance.

A default that loses failed work is defensible for simple scenarios and poor for agents. If you run agents on Make, turning this on is the first configuration change to make. The recovery patterns worth building around it appear in the breakdown of how agent pilots actually fail.

n8n takes a third approach. You designate an error workflow in workflow settings, and it runs whenever an execution fails, starting from an Error Trigger node that receives the execution ID, the error message and the failing node. That is more capable than either alternative, and it is also a workflow somebody has to build and maintain.

Where this argument is weakest

Three things undercut what you have just read, and none of them is small.

Nobody here ran the benchmark

The strongest version of this post would deploy one identical agent workflow on all three platforms, run it a thousand times against the same inputs, and report measured cost, latency and failure rate. That is the comparison the market lacks, and the one that would settle the question.

This post is not that. It is arithmetic applied to published billing rules, with assumptions stated so you can substitute your own. Vendor pricing pages describe the meter. They do not describe how often an agent reasons to depth 6 rather than depth 2, and that variable moves every conclusion here.

List price is not the price, and the roundups are unreliable

Everything above is list. All three sell enterprise agreements with negotiated allowances, and both n8n and Zapier replace monthly resets with custom terms at that tier. A committed annual number changes the ranking, and none of those numbers are public.

The secondary literature is the second problem. Several 2026 pricing guides state that Zapier draws AI, code, MCP and agent calls from the same task pool. Zapier's own help centre says the opposite: using activities does not affect task usage. Repetition is not corroboration, and this one is an error a buyer would have carried into a purchase decision.

What to check before you commit

Feature comparison is close to worthless here, because all three connect to whatever you need. These five questions separate them.

The first row is the one most teams cannot answer, and it decides the other four. Measure it before signing anything longer than a month.

One structural point worth adding. n8n and Make include unlimited users on every tier, while Zapier's Pro plan is a single seat and Team is 25. For an automation platform that is reasonable, since automations run without anyone watching. It is also a live case of the shift traced in the autopsy of per-seat pricing, and free tiers are converging the same way, as set out in the piece on free tiers metered by compute.

Frequently asked questions

Where to start this week

Two steps, both cheap.

Export the last 30 days of runs from whatever you use today. Count two things: the median number of billable steps per run, and the share of runs that failed. Those two numbers convert this whole comparison into a single figure for your business, and almost nobody has them written down.

Then take your three heaviest workflows and price each one under all three rule sets by hand. It takes an afternoon. If the answers land within 20% of each other, pick on operational fit and stop reading comparison posts. If one is triple the others, you have found the decision.

Related reading