Comparison
n8n vs Make (2026): A Practical Comparison
n8n vs Make (ex-Integromat), compared honestly: operations-based pricing vs flat self-hosting, visual builders, code, AI agents, and data control.
Make (the tool formerly known as Integromat) is the comparison n8n users should take seriously. Zapier vs n8n is a study in contrasts — we wrote that one too — but Make actually competes on n8n’s home turf: visual complexity, branching, iteration, data transformation, all at prices that undercut Zapier dramatically. Plenty of technically-minded people are happily automating on Make and wondering what the n8n fuss is about.
The short answer to “what’s the fuss”: self-hosting and where the ceiling sits. The long answer is this article.
The 30-second version
- Make: hosted visual automation with real power — routers, iterators, aggregators, error handlers. Priced per operation (every module execution counts). Free tier around 1,000 ops/month; paid tiers start cheap (~€9–10/month for 10,000 ops) and scale with volume.
- n8n: comparable visual power plus first-class code and AI agents. Runs hosted (n8n Cloud) or on your own infrastructure with no meter at all — a €5 VPS runs unlimited operations.
| Make | n8n (self-hosted) | |
|---|---|---|
| Pricing meter | Per operation (module run) | None — flat server cost |
| Entry price | Free tier; ~€9/mo for 10k ops | ~€4–12/mo VPS, unlimited |
| Visual power (branches, loops, merge) | Strong | Strong |
| Custom code | Limited (restricted JS, add-ons) | Full JS/Python Code node |
| AI agents | Basic AI steps | Native agents, tools, memory |
| Self-hosting | Not available | The whole point |
| Data location | Make’s cloud (EU regions available) | Your server |
| Learning curve | Moderate | Moderate |
| Ops burden | Zero | Yours (or managed) |
Pricing: operations math, honestly done
Make’s meter is finer-grained than Zapier’s and cheaper per unit — credit where due. But understand what it counts: every module that fires is an operation. A scenario watching new rows, filtering them, iterating over 20 items and posting each to Slack doesn’t consume 4 operations — it consumes 1 + 1 + 20 + 20ish, per run.
Three shapes of workflow decide the economics:
- Low volume, any complexity: Make’s free tier and ~€9 tier are genuinely excellent. Running a handful of scenarios a few times daily? Make is arguably the best-value hosted automation product on the market. No spin: at this scale, Make wins on pure convenience-per-euro.
- Iteration-heavy workflows: the meter compounds. Processing 500 items through a 3-module loop = ~1,500 operations in a single run. Do that hourly and you’re at ~1M operations/month — deep into serious subscription territory.
- Polling and always-on automation: a scenario checking every 5 minutes burns ~8,600 runs/month before doing any work. Metered pricing taxes vigilance itself.
Self-hosted n8n makes all three shapes cost the same thing: whatever your server costs. The full three-way breakdown (including n8n Cloud, which is metered) has the detailed arithmetic.
Building: two capable canvases, different philosophies
Both tools let you build things Zapier can’t. The differences are of flavour and ceiling.
Make’s canvas is genuinely pleasant — circular modules, animated data flow, routers for branching, iterators/aggregators for array work, and a built-in visual debugger that non-developers find intuitive. For pure no-code visual building, Make’s UX is arguably the most polished in the industry.
n8n’s canvas is more utilitarian but goes deeper:
- Code is first-class, not a workaround. A Code node runs real JavaScript (or Python) on your data; expressions embed logic anywhere. In Make, custom code is constrained — when visual modules run out, you hit the ceiling harder.
- Data is transparent. n8n shows you the actual JSON at every node, pinnable and mockable while you build. Make shows data too, but n8n’s model (everything is an array of items flowing between nodes) maps more directly onto how developers think.
- Sub-workflows, error workflows and versioning feel engineered for automation-as-software — the thing you graduate into when scenarios become infrastructure.
Where n8n runs away with it: AI. n8n’s agent nodes — LLM + tools + memory, model-agnostic — make agentic workflows a native building block. Make offers AI modules (call OpenAI, transform text), which is fine for AI steps, but composing actual agents is not what it’s built for. And note the pricing interaction: agents are chatty, multi-call things — exactly the pattern an operations meter penalizes.
The structural difference: hosted-only vs yours
Make does not have a self-hosted option. That single fact carries several consequences that no feature comparison captures:
- Data custody. Your workflow data transits Make’s infrastructure, full stop. EU data residency options help with compliance geography, but “our data doesn’t leave our infrastructure” is not something Make can ever offer. Self-hosted n8n makes it the default.
- No meter anxiety. Beyond cost, metering shapes behaviour — you catch yourself designing scenarios to consume fewer operations rather than to work better. A flat-cost server removes that tax on your design thinking.
- Longevity. Open-source n8n on your server keeps running regardless of pricing changes, acquisitions, or product pivots. Hosted-only tools reprice, and their history — including this one’s — includes repricing events users did not enjoy.
- The trade: you own updates, backups, and security. We’ve turned each into a boring checklist (updates, backups), and Railway-style managed hosting exists for those who want the economics without the server. But it’s never zero, and Make’s zero is real.
Who should pick what
Pick Make when:
- Your volume sits comfortably inside the free or ~€9 tier and you want zero infrastructure, ever.
- The builders are power-users rather than developers — Make’s visual polish genuinely lowers the barrier for complex logic.
- You need its particular integration catalog (both catalogs are strong; check your critical apps in each).
Pick n8n when:
- Volume is real or growing — iterators, polling, and busy webhooks make the meter math one-sided.
- You want code as an escape hatch instead of a wall.
- You’re building AI agents rather than sprinkling AI steps.
- Self-hosting is a requirement (compliance, data custody) — Make simply isn’t in this race.
Our take: Make is the strongest hosted competitor to n8n and the right choice for genuinely small, no-infrastructure automation. But the moment automation becomes infrastructure for you — volume, agents, sensitive data — the ceiling and the meter both argue the same direction. That’s the moment to set up your own instance; it takes about 40 minutes.