n8n vs Zapier vs Make: An Honest Comparison

Short version: Zapier is the safe default for non-technical teams running a few simple flows, Make is the value pick when the Zapier bill starts to sting, and self-hosted n8n wins the moment you have an engineer, real volume, custom logic, or data that can't leave your servers. None of them is "best." They're priced and built for different problems.

I've shipped production automations on all three for paying clients over the last two years. Not demos. Workflows that route leads, sync CRMs, generate ad creative, and process orders. This is the comparison I wanted when I started, updated with the depth the thin version was missing.

Quick answer

If you have an engineer, the answer is almost always n8n self-hosted. If you don't, pay Zapier and stop overthinking it. Everything below is the reasoning behind that line.

How much does each one actually cost at scale?

This is where the three tools diverge hardest, and where the marketing pages are least honest. The trap is that they count usage differently, so "task," "operation," and "execution" are not the same unit.

Take one realistic workflow: a trigger plus four action steps (fetch, transform, enrich, write), firing 10,000 times a month.

• Zapier bills per task, and every action step is a task. Four actions times 10,000 runs is 40,000 tasks.
• Make bills per operation, and most modules cost an operation each. Five modules times 10,000 runs is 50,000 operations.
• n8n counts one execution per run regardless of how many nodes fire. That's 10,000 executions, and on self-hosted there is no per-execution charge at all.

Here's the same 50,000-unit month priced out. Treat these as representative bands, not quotes.

The pattern holds at every scale: Make undercuts Zapier per unit, and self-hosted n8n flattens the cost curve entirely because you're paying for a box, not for volume. That flat line is the whole reason teams migrate. Per-task pricing is fine at 2,000 tasks and brutal at 200,000.

To estimate your own bill before you commit:

1. List every workflow you plan to run and how often each fires per month.
2. Count the action steps in each, since triggers are usually free but actions are not.
3. Multiply steps by runs to get Zapier tasks, and steps-plus-trigger by runs to get Make operations.
4. Match that total against each tool's current published tiers.
5. Compare it to a $10 to $20 VPS running self-hosted n8n, then weigh the difference against the cost of someone maintaining that server.

What can you build: logic, branching, loops, and merges

Simple automation is a straight line: trigger, do a thing, done. Real automation forks, loops, and rejoins, and this is where the tools separate.

Zapier handles filters and Paths, which let a zap branch into a few conditional routes. It's enough for "if the deal is over $10k, notify sales, otherwise tag it." What Zapier does not do gracefully is loop over an array of items and merge the results back together. You end up chaining zaps or reaching for Sub-Zaps, and it gets awkward fast.

Make is genuinely strong here. Routers split a scenario into branches, iterators loop over arrays, and aggregators collapse many items back into one bundle. For fan-out and fan-in work on a budget, Make often beats n8n on ergonomics.

n8n gives you IF and Switch nodes for branching, native looping over items (every node processes a list by default), and a Merge node with multiple combine modes to rejoin branches. Because a workflow is just a directed graph, you can build genuinely complex topologies: parallel branches, conditional merges, and loops with a hard iteration cap. If your logic looks less like a checklist and more like a flowchart with exceptions, this is the tier you want. When that logic includes a genuinely ambiguous decision, that's where an AI step inside the workflow earns its place, and n8n makes that step a node like any other.

How much real code can you write?

Every tool claims a "code step." The gap between them is large.

Code by Zapier runs in a sandboxed Node or Python environment with a very short list of available packages, tight execution limits, and no way to npm install what you need. It's fine for reshaping a payload or a quick calculation. It is not a place to run a real library.

Make lets you drop small JavaScript into some modules and build custom app modules against its SDK, but you're working inside its structure, not writing free-form code.

n8n runs actual JavaScript or Python in the Code node, and on self-hosted you can install npm packages and call any internal API. It feels like code because it is. Here's a Code node that dedupes and normalizes incoming leads before anything downstream touches them, the kind of thing Code by Zapier makes painful:

// n8n Code node: runs once, over all incoming items
const seen = new Set();
const clean = [];
 
for (const item of $input.all()) {
  const email = (item.json.email || '').trim().toLowerCase();
  if (!email || seen.has(email)) continue; // skip blanks and duplicates
  seen.add(email);
 
  clean.push({
    json: {
      email,
      firstName: (item.json.first_name || '').trim(),
      source: item.json.utm_source || 'direct',
      receivedAt: new Date().toISOString(),
    },
  });
}
 
return clean;

That's plain, readable JavaScript with full control over the batch. On Zapier you'd be fighting the sandbox to get halfway there.

Who can actually self-host, and who controls the data?

This section is short because the answer is binary. Zapier and Make are cloud-only. There is no self-hosted edition. Your data flows through their servers, under their terms, in their regions. For most businesses that's completely fine.

n8n self-hosts with a single Docker command, which means the workflow engine and every byte it touches live on infrastructure you own.

docker run -it --rm --name n8n -p 5678:5678 \
  -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

That distinction only matters in one situation, and when it matters it is absolute: data that legally or contractually cannot leave your environment. Healthcare records, certain financial data, EU personal data under a strict processing agreement, or a client whose contract forbids third-party processors. If that's you, Zapier and Make are off the table by definition, and self-hosted n8n is the only one of the three that qualifies. If it's not you, don't take on server ops for a compliance problem you don't have.

What happens when a step fails?

Automations fail. The question is what the tool does about it.

On Zapier, when a step errors the zap stops and you get an email. There's no native "if this fails, do that instead," so recovery is manual: you open the task history and replay it by hand. For low-stakes flows that's acceptable. For anything that loses money when it silently breaks, it's a liability.

Make is better. Scenarios support error handlers per module, automatic retries, and rollback behavior, so you can catch a failed HTTP call and route around it inside the same scenario.

n8n is the most complete. Every node has continueOnFail, configurable retry counts with backoff, and error output branches, and you can attach a dedicated Error Trigger workflow that fires the instant any execution fails. The pattern I ship on every build is: retry the flaky external call a few times, and if it still fails, push the bad payload to a Slack or Telegram alert and quarantine it instead of losing it. A workflow that fails loudly is worth ten that fail silently. If yours is failing silently right now, I wrote a separate walkthrough on why n8n workflows stop triggering.

How many integrations, and does breadth beat depth?

Zapier's biggest genuine advantage is breadth. It lists thousands of prebuilt app integrations. n8n has a few hundred native nodes plus community-built ones, and Make sits in between with a few hundred well-made ones.

If your obscure SaaS only ships a Zapier integration, that can decide the whole thing. But raw count hides a trade-off. A huge integration catalog means many connectors are thin, maintained by the app vendor at varying quality, and occasionally break on API changes. n8n's generic HTTP Request node closes most of the gap because it can call any REST API directly, which means "no native integration" rarely means "impossible," it means "one more configuration step." The honest read: Zapier wins on time-to-first-connection, n8n wins on never being blocked by a missing connector, and Make is respectable on both.

How steep is the learning curve, and who maintains it?

Zapier is genuinely easy. A non-technical person can build a working zap in minutes, and there is nothing to maintain because Zapier runs it for you. Make is a step up: the visual canvas is more powerful and slightly more to learn, but it's still fully managed.

n8n asks more of you on both counts. The canvas rewards people who think in data structures, and self-hosting means you own updates, backups, and the 11pm "it's down" moment. That maintenance burden is real and it is the single most underestimated cost of choosing n8n. The escape hatch is n8n Cloud: the same product with the ops handled for you, metered but still cheaper than Zapier at most volumes. Choose self-hosted for control and flat cost, choose Cloud to skip the server, and choose Zapier or Make if you'd rather never see infrastructure at all.

Which one should you pick?

The right tool depends on your situation, not your taste. Four common ones:

Solo founder wiring two apps together. Use Zapier. You need "new Typeform response creates a CRM contact" to work today, and setting up a server for one automation is a waste of your time. Pay the small bill, move on, build your business.

Growing team watching the task bill climb. This is the migration moment. When Zapier crosses a few hundred dollars a month and the flows are becoming genuinely complex, moving to self-hosted n8n turns a metered bill into a flat one and unlocks the branching and code you're probably starting to want. This is the exact situation I built a Zapier alternative service around: rebuild the workflows on n8n so the cost stops scaling with your growth. If you're not ready to self-host, try Make first, since it's often a cheaper stopgap than a full re-platform.

Agency running many client accounts. Self-hosted n8n, almost every time. One server can host isolated workflows for dozens of clients with no per-account task fees, version control through git, and full ownership of the setups you build. Per-task pricing across many accounts is death by a thousand cuts. There's a live n8n build on the site that automated ad-campaign work and cut the manual optimization by around 40%, which is the shape of what a client account looks like at scale. I do this kind of custom n8n automation as the core of the work.

Regulated data that can't leave your server. Self-hosted n8n is the only option of the three. Zapier and Make will route your data through their cloud, full stop. If a contract or a regulator says no, the decision is made for you.

The honest bottom line

• n8n is what I reach for first when there's custom logic, real scale, or a compliance line. Self-hosted for control and flat cost, Cloud when you'd rather not run a server.
• Zapier is the correct answer for non-technical teams on simple flows. The premium buys you never thinking about infrastructure, and that's worth real money.
• Make is the underrated middle. If your Zapier bill is climbing and you can't self-host, try it before you re-platform anything.

If you're staring at a Zapier invoice that grows every month and wondering whether n8n is worth the switch, that's a 15-minute conversation, not a leap of faith. Bring your task counts and your workflow list, and we can work out whether migrating pays off or whether you should stay put. The migration path and what it costs is spelled out, and so is the pricing for the build itself. No pressure to move if the numbers say don't.