The advertised price is never the real price
Make's homepage says "$9/month." n8n's cloud tier starts at "$20/month."
Neither number tells you what you'll actually pay when you're running 10,000 operations a month across a five-person team.
One counts every webhook ping. The other counts every node execution inside a workflow. One forces you into annual contracts for decent limits. The other locks features behind self-hosting — which means you're paying AWS or DigitalOcean instead.
Below is the real cost breakdown: monthly bills, ops-counting rules, hidden fees, and the math that decides which platform is cheaper for your volume.
How Make counts operations (and why it adds up fast)
Make calls them "operations." Every action step in a scenario — a row lookup, a Slack message, an HTTP call — consumes one op.
Internal steps like routers, filters, and iterators are free. But anything that talks to an API or manipulates data counts.
Here's Make's 2025 pricing ladder:
| Plan | Ops/month | Price/month (annual) | Price/month (monthly) | |------------|-----------|----------------------|-----------------------| | Free | 1,000 | $0 | $0 | | Core | 10,000 | $9 | $10.59 | | Pro | 10,000 | $16 | $18.82 | | Teams | 10,000 | $29 | $34.12 | | Enterprise | Custom | Custom | Custom |
The Core plan gives you 10,000 ops but only 2 seats and no premium apps (Salesforce, HubSpot, etc.).
Pro unlocks premium connectors and raises the seat count to 5, but you're still at 10,000 ops base. If you need more, you buy top-up packs: 10,000 extra ops cost $9/month on annual billing.
So a five-person team running 10,000 ops per month pays $16/month on the Pro annual plan — or $18.82/month if you go month-to-month.
If you spike to 15,000 ops one month, you'll pay $16 + $9 = $25 that month (annual pricing). Make doesn't auto-scale gracefully; you add packs manually or pause scenarios when you hit the limit.
Make's op counter is generous with free internal steps, but every API call adds up faster than you expect.
The biggest gotcha: premium app access. If you're connecting Make.com HubSpot Automation or Salesforce, you must be on Pro or higher — no exceptions. The $9 Core plan can't touch them.
How n8n counts executions (cloud vs self-host split)
n8n calls them "workflow executions." One run of a workflow = one execution, regardless of how many nodes fire inside it.
That's the theory. In practice, if you use sub-workflows or loops that trigger separate workflow runs, each of those counts separately.
n8n cloud pricing (2025):
| Plan | Executions/month | Price/month | Seats | |------------|------------------|-------------|---------| | Starter | 2,500 | $20 | 1 | | Pro | 10,000 | $50 | 5 | | Enterprise | Custom | Custom | Custom |
The Starter plan is useless for a team: one seat, 2,500 executions.
Pro gives you 10,000 executions, 5 seats, priority support, and access to all integrations. No artificial connector gates like Make's premium-app wall.
If you need more than 10,000 executions, you jump to custom Enterprise pricing — or you self-host.
Self-hosting n8n is free (MIT-licensed), but you pay infrastructure and maintenance:
- DigitalOcean droplet (4 GB RAM, 2 vCPU): ~$24/month
- Postgres database (managed): ~$15/month
- Backups + monitoring: ~$5–10/month
- Your time to maintain, update, troubleshoot: 2–4 hours/month at $50/hour loaded cost = $100–200/month
Total self-host cost for a small team: $144–249/month when you count operator time.
That makes cloud cheaper until you cross ~25,000 executions per month or you already have in-house DevOps capacity.
The big win with n8n: no connector paywalls. Every integration is available on every paid plan. You're only gated by execution volume.
Side-by-side: 10,000 tasks per month, 5 seats
Here's the apples-to-apples comparison for a team running 10,000 operations (Make) or executions (n8n) per month, needing 5 seats and premium app access:
| Platform | Plan | Monthly cost (annual billing) | Monthly cost (month-to-month) | Notes | |----------------|------------|-------------------------------|-------------------------------|--------------------------------------------| | Make | Pro | $16 | $18.82 | 10k ops base, 5 seats, premium apps | | n8n cloud | Pro | $50 | $50 | 10k executions, 5 seats, all integrations | | n8n self-host | Open-source | ~$39 (infra only) | ~$39 | Excludes your maintenance time (~$100–200) |
Make is cheaper by a 3× margin if your volume stays under 10,000 ops and you're comparing cloud-to-cloud.
But three caveats flip the math:
-
Execution vs operation counting. A Make scenario that fetches 10 rows from Airtable, loops over them, and posts each to Slack = 21 operations (1 fetch + 10 iterator steps free + 10 Slack posts). The same logic in n8n = 1 execution if it's inside a single workflow. Loops, splits, and merges don't increment the counter.
-
Overage costs. Make sells 10k op packs for $9 each. n8n cloud jumps to custom Enterprise pricing past 10k executions — no public add-on rate. If you're spiking to 15k one month, Make is predictable; n8n forces a sales call.
-
Self-host escape hatch. Once you cross ~15,000 executions per month, self-hosting n8n becomes cost-competitive if you already have someone who can manage a Dockerised app and Postgres. Make has no self-host option.
If you want to see what your current manual workflows cost before you pick a platform, try the Repetitive Task Cost Calculator — it converts hours-per-week into annualised dollar waste, which frames the automation ROI and the ceiling you can afford to pay.
Hidden costs both platforms skip in the brochure
Make
- Annual lock-in for the good price. Month-to-month pricing is ~18% more expensive. Most teams pick annual, then regret it six months in when requirements shift.
- Scenario limits. The Pro plan caps you at 50 active scenarios. If you're automating per-client workflows or per-product pipelines, you hit that ceiling fast.
- Data transfer overage. Make counts data volume separately from ops on Enterprise plans. The public docs don't spell out the threshold, but heavy file-sync or image-processing scenarios can trigger surprise invoices.
n8n cloud
- No published overage rate. Once you cross 10,000 executions, you're in "contact sales" territory. That's fine for a 50-person company; it's annoying for a 5-person team that just wants to add 2,000 more executions.
- Credential limits. n8n Pro allows 50 saved credentials (API keys, OAuth tokens). If you're connecting ten clients × five services each, you're at the ceiling. Self-host has no limit.
n8n self-host
- Update cadence. n8n ships a new release every 2–3 weeks. If you want the latest nodes and bug fixes, you're committing to a bi-weekly deploy cycle — or you fall behind and face a painful catch-up six months later.
- Support is community-only. No SLA. The forum is excellent, but if a workflow breaks at 9 PM on Friday, you're Googling.
If you're weighing custom AI automation builds on either platform, self-host n8n gives us more control over versioning and deployment, but Make's cloud stability is lower-touch for teams without a DevOps budget.
When Make is cheaper (and when it isn't)
Make wins when:
- Your workflows are linear (few loops, few branching paths) so operation counts stay low.
- You're under 10,000 ops/month and don't expect spikes.
- You want a visual builder with zero infrastructure overhead.
- You can commit to annual billing.
n8n cloud wins when:
- Your workflows loop heavily (parsing lists, iterating API pages) — one execution can replace 50 Make operations.
- You're already above 15,000 ops/month and self-hosting isn't scary.
- You need connectors Make paywalls (or connectors Make doesn't have — n8n's community node library is larger).
- You want the option to self-host later without rebuilding everything.
n8n self-host wins when:
- You're above 25,000 executions/month.
- You already run Docker services in-house (n8n is one
docker-compose.yml). - You need to store credentials or workflow logic inside your VPC for compliance.
A concrete example: a five-person team running a daily lead-scoring workflow that fetches 200 HubSpot contacts, scores each with a custom function, and updates a field.
- Make: 1 HubSpot fetch + 200 iterator loops (free) + 200 HubSpot update operations = 201 ops per run × 30 days = 6,030 ops/month. Fits in the $16 Pro plan.
- n8n: 1 workflow execution per day × 30 = 30 executions/month. Fits in the $20 Starter plan (but you'd need Pro for 5 seats, so $50/month).
In that scenario, Make is cheaper.
Flip the script: same team, same workflow, but now running every hour (24 × 30 = 720 runs/month).
- Make: 201 ops/run × 720 = 144,720 ops/month. That's $16 base + 14 extra 10k packs × $9 = $142/month.
- n8n cloud: 720 executions/month. Still fits in the $50 Pro plan with room to spare.
Execution-based pricing scales better when your workflows are frequent and data-heavy.
What the math actually says
If you're running under 10,000 operations per month and your workflows are simple (few loops, mostly linear), Make is cheaper and easier: $16/month on annual Pro.
If you're running 10,000+ operations or your workflows involve iteration, pagination, or complex branching, n8n cloud will cost less per unit of work: $50/month for 10,000 executions that can each do the work of 20–50 Make operations.
If you're above 20,000 operations/month and you have someone who can wrangle Docker, self-hosted n8n is the lowest long-term cost — but only if you count infrastructure dollars and ignore your own time.
Before you commit to either, map your top three automation ideas and count the steps. Use the Automation Opportunity Scanner to see which workflows deliver the highest ROI per build hour — that determines your ops or execution budget faster than any pricing page.
Need the workflow built without spending a week in documentation? We ship custom automation builds on n8n or Make in 2–3 weeks, fixed scope, one operator. No handoffs, no project managers, no surprise invoices when you cross an ops threshold three months in.
Start with a free scoping call — we'll count your ops, map your workflows, and tell you which platform makes sense before you sign an annual contract.