TL;DR: Make bills per module execution, n8n bills per workflow execution regardless of how many steps are in it. That single difference decides most cost comparisons: deep workflows favour n8n, shallow high-frequency ones favour Make. Choose Make if a non-developer maintains it. Choose n8n if you have a developer, need self-hosting, or run deep workflows at volume.
Once you have ruled out Zapier on price or power, these are the two serious options. Both are far more capable than Zapier, both cost less to run, and they are not interchangeable. Picking the wrong one is recoverable but not free, so it is worth twenty minutes now.
The difference that decides everything else
They do not bill the same unit, and almost every comparison you will read glosses over this.
Make charges a credit per module execution. A scenario with twelve modules that runs once costs roughly twelve credits. n8n charges one workflow execution per run, no matter how many nodes are inside it. A twelve-node workflow running once costs one execution.
So the cost question is not really 'how much volume do you have'. It is 'how deep are your workflows'. A shallow three-step flow running constantly is comparatively cheap on Make. A twenty-step document pipeline running a few thousand times a month is dramatically cheaper on n8n, because you pay once per run rather than twenty times.
Do this maths before you choose
Count the billable steps in your typical workflow and the runs per month. On Make, multiply the two. On n8n, take the runs alone. Then price each against the tables below. If your workflows are short, the numbers will land close together and the decision comes down to team and compliance. If your workflows are long, the numbers will not be close.
Verified prices, September 2026
Taken from each vendor's own pricing page rather than repeated from other articles, several of which are quoting tiers that no longer exist.
Make, per credit (a module execution; the trigger is free):
Free: $0, 1,000 credits/month, 15-minute minimum interval between runs
Core: $9/month for 10,000 credits, unlimited active scenarios, Make API
Pro: $16/month for 10,000 credits, priority execution, full-text log search
Teams: $29/month for 10,000 credits, team roles and shared templates
All paid tiers scale on a slider from 10,000 credits up past 8 million a month
n8n cloud, per workflow execution regardless of step count (billed annually):
Starter: 20 EUR/month, 2,500 executions, 5 concurrent, 2,300 AI credits
Pro: 50 EUR/month, 10,000 executions, 20 concurrent, workflow history and execution search
Business: 667 EUR/month, 40,000 executions, plus a self-hosted option, SSO and Git version control
Enterprise: custom, with log streaming and extended retention
Self-hosted n8n is the other branch entirely. The community edition costs nothing to license; you pay for a server, realistically $5-50/month on a VPS depending on load, and there is no execution limit at all. That is where the large cost gaps appear, and it is also where you take on uptime, updates and backups as your own problem.
Note the version-control line on the Business tier. If you want your automations in Git, reviewed like code, that is a paid n8n tier or self-hosting. It is a genuine differentiator and it rarely shows up in comparisons.
Where Make wins
Make's advantage is not technical, it is organisational, and that makes it more valuable than it sounds.
A non-developer can open a scenario built six months ago and understand it. This matters more than any feature on either list.
Setup is fast, and the module library covers 1,000+ apps with authentication that mostly just works
Error handling, retries and error routes are solid out of the box rather than configured
Nothing to host, patch or monitor
Predictable small bills at moderate volume, typically $9-29/month
And where it stops
It is cloud only, so your data passes through their infrastructure, which ends the conversation for some compliance requirements. Custom code is possible but awkward. Deep workflows get expensive because every module bills. And some logic that is three lines in code becomes an uncomfortable arrangement of modules on a canvas.
Where n8n wins
n8n's advantages are the ones that matter when the system becomes infrastructure rather than convenience.
Self-hosting, so data never leaves your infrastructure. This is the decisive factor for GDPR-sensitive, healthcare and finance work.
No per-step billing, which is what makes deep pipelines affordable
A code node that lets you write JavaScript inline, so anything you could script, you can do
Complex branching and sub-workflows that compose more naturally
Version control and real environments on the paid or self-hosted routes
No vendor lock-in in the meaningful sense: you can take the whole thing with you
And where it costs you
A steeper curve, and a real one: the interface is powerful and less forgiving. Self-hosting means you own uptime, updates and backups, and a production workflow needs monitoring you have set up yourself. The native integration library is smaller than Make's, though the HTTP node covers anything with an API at the price of more configuration. And n8n cloud, which removes the ops burden, also removes the cost advantage that made self-hosting attractive.
Integrations, honestly
Make has 1,000+ native connectors, n8n has several hundred plus generic HTTP. In practice both connect to anything with an API and the real difference is how much manual configuration a less common tool takes. For Shopify, HubSpot, Salesforce, Airtable, Notion, Slack and Google Workspace, both are fine and this should not drive your decision.
What we actually use
Roughly 70% of our client builds run on Make. It handles standard requirements efficiently and, crucially, the client can understand what we built and change it without us. We reach for n8n on compliance-bound work, on high-volume document processing where Make credits would scale badly, and on anything needing real code inside the workflow.
A fair number of systems use both. Make orchestrates the shallow, frequently-modified, business-facing flows; n8n does the deep processing behind a webhook. The handoff is clean and each tool does what it is good at. If that sounds like over-engineering, it is, right up until the month a single pipeline's credit usage exceeds the server bill several times over.
A decision procedure, in order
Answer these in sequence and stop at the first one that applies.
Does data residency or self-hosting compliance apply? Then n8n. Nothing else in this article outranks that.
Will a non-developer own and modify this? Then Make, even if n8n is cheaper on paper. An automation nobody can safely edit becomes a liability.
Are your workflows deep, more than about ten billable steps, and running at real volume? Then run the maths above; n8n usually wins by a lot.
Do you need the logic in Git, reviewed like code? Then n8n, on a paid tier or self-hosted.
None of the above? Make. Start there, and know that migrating to n8n later is a normal, survivable project.
If you are choosing between these two and Zapier is still in the conversation, our three-way comparison covers that ground with the same numbers.
Want the maths run on your actual workflows before you commit to either? That is a short job and we will do it. Start with the audit at 2pizza.team/audit, two minutes, no call.
Originally published at 2pizza.team. We build AI and automation systems for small teams - fixed price, two to six weeks. See the work.
Top comments (0)