n8n vs Make.com vs Zapier: The 2026 Comparison
Pick n8n if you need self-hosting, code nodes, or cheap data-heavy runs (it bills per workflow execution). Pick Make.com for visual multi-path branching and the most step-by-step Apify integration. Pick Zapier for the largest app catalog (10,000+) and the simplest setup. All three connect to Apify natively.
The three tools bill differently, and that's the decision. Zapier charges per task (one module action = one task). Make.com charges per operation (one module processing one bundle). n8n charges per workflow execution (one run = one execution, regardless of how many steps or items flow through it). For data-heavy Apify work, where one scrape produces hundreds of items you then fan out, n8n's execution model is dramatically cheaper, Make is a clear second, and Zapier becomes untenable at volume.
Pricing, app counts and plan limits below verified live against n8n.io, make.com and zapier.com on 2026-09-09 — see the source links inline.
Why don't n8n, Make and Zapier bill the same way?
The platforms look similar on a canvas. They don't bill similarly. Understand this before comparing anything else.
| Model | What counts | Impact on scraping |
|---|---|---|
| Zapier: tasks | Every successful action performed by any step, per item | A 500-row Apify dataset run through "filter → Slack → Sheets" ≈ 1,000 tasks (the filter step itself is free, and rows it drops cost nothing downstream) |
| Make.com: operations | Every module run against every bundle | Same workflow ≈ 1,000 operations: filters are route conditions, not modules, so the arithmetic matches — at a lower unit price |
| n8n: executions | One full workflow run, regardless of items or steps | Same workflow = 1 execution, whether it processes 5 or 50,000 rows |
n8n bills per workflow execution, not per step. n8n's own pricing page calls this out explicitly: "An execution is a single run of your entire workflow. It doesn't matter how many steps are in the workflow or how much data it processes."
For Apify pipelines that scrape hundreds or thousands of rows per run, this is the biggest single cost lever among the three tools.
What do n8n, Make and Zapier actually cost?
| n8n Cloud Starter | Make.com Core | Zapier Professional | |
|---|---|---|---|
| Entry paid price | €20/mo (annual) | $9/mo (annual) | $19.99/mo (annual, 750 tasks) |
| Included usage | 2,500 workflow executions | 10,000 credits (1 credit = 1 operation for standard apps) | 750 tasks (base tier) |
| Concurrent runs | 5 | Varies by plan | Plan-dependent |
| Self-hosted free | Yes (Community Edition, no execution cap) | No | No |
| Free tier | No perpetual free Cloud plan — no-card trial on Starter/Pro; self-hosted Community Edition is free forever | 1,000 credits/mo, 2 active scenarios, no credit card required | 100 tasks/mo perpetual |
Those units aren't interchangeable, so here's what the same 10,000 monthly runs actually cost on each platform:
| Platform | Plan at 10,000 monthly runs | Price |
|---|---|---|
| n8n Cloud | Pro (10,000 executions included) | €50/mo, annual |
| n8n self-hosted | Community Edition, no execution cap | $0 + your own VPS (~$6–12/mo) |
| Make | Core (10,000 credits included) | $9/mo, annual |
| Zapier Professional | 10,000 tasks, billed annually | $129/mo |
| Zapier Team | 10,000 tasks, billed annually | $169/mo ($253.50/mo month-to-month) |
The "$249/mo at 10k tasks" figure that floats around older comparisons is not the current number either way. Zapier's Professional plan at 10,000 tasks runs $129/mo billed annually or $193.50/mo billed monthly; Team at the same volume is $169/mo annually or $253.50/mo monthly. Verified live against zapier.com/pricing on 2026-09-09 — task tiers and add-on prices change, so check before budgeting.
n8n self-hosted (Community Edition) is still free under the Sustainable Use License for internal business automation. You pay for infra only: a $6–12/mo VPS handles most small-team workloads. Business features (SSO, version control, multi-environment) require a paid license starting at €667/mo for 40,000 executions, confirmed live at n8n.io/pricing on 2026-09-09.
How do n8n, Make and Zapier compare feature by feature?
| n8n | Make.com | Zapier | |
|---|---|---|---|
| Billing unit | Workflow execution | Operation (module × bundle) | Task (module × item) |
| Self-hosting | Yes (Community Edition, Enterprise license) | No | No |
| AI nodes | Native AI Agent node, 100+ dedicated AI integrations, code nodes | Native Claude, OpenAI, Mistral, Gemini modules | Growing AI actions; less granular |
| Apify compatibility | Native Apify node | Separate modules: Run Actor, Wait, Get Dataset Items | Native app; fewer discrete steps |
| Code steps | JavaScript and Python code nodes | Inline functions + HTTP module | Code by Zapier (JS/Python, limited) |
| Learning curve | Steepest (JSON data flow, node wiring) | Middle (visual but with routers/iterators/aggregators) | Shallowest (linear Zaps) |
| Integrations | 2,000+ | 3,000+ apps | 10,000+ apps |
| Best for | Data-heavy flows, self-hosting, AI orchestration | Multi-path branching with routers and filters | Maximum app coverage, simple linear flows |
Integration counts checked on 2026-09-09 at n8n.io/integrations, n8n.io/integrations/categories/ai and zapier.com/apps. All three are rolling counters that move most weeks — n8n's total rose by 14 in the day after this check — so the table rounds them and this page does not quote an exact figure that would be wrong by the time you read it. n8n's AI category was around 100 at the time of checking.
Which tool is best for Apify workflows?
Apify's execution model is async: you start a run, the Actor works, you poll or await completion, then you read structured rows from a dataset. Tools that expose those three phases as distinct steps integrate cleanly; tools that wrap them into one black-box action hit friction fast.
Make.com is the strongest default for complex Apify pipelines. Its Apify app exposes Run an Actor, Wait for an Actor Run to Finish, and Get Dataset Items as separate modules, letting you insert filters, error handlers, iterators, and routers between phases. This maps one-to-one to how Apify's API actually works.
n8n wins when you need self-hosting, code nodes, or many items per run. The native Apify node covers core operations; execution-based billing makes n8n significantly cheaper than Make when your workflows process hundreds or thousands of rows per run. The tradeoff is a JSON-flow mental model that non-developers find harder than Make's canvas.
Zapier fits simple, event-driven Apify use: form submission → run Actor → notify Slack with the first result. For multi-step Apify lifecycles with wait states, dataset pagination, and per-bundle retries, Make or n8n will feel less like fighting the tool.
When should you pick n8n?
n8n's value is control plus economics. Self-hosted deployments keep data on your network, which matters for regulated industries, EU data residency, and anything involving PII you can't ship to a US cloud. Code nodes (JavaScript and Python) let you transform payloads without leaving the workflow, and the AI Agent node plus 100+ dedicated AI integrations make it a strong hub for LLM chains alongside Apify-sourced web data.
The cost model is the headline feature for Apify-heavy workloads. A nightly Apify scrape that produces 5,000 product rows, runs three transformations, and writes to Postgres is one execution on n8n. On Make, the same flow is about 20,000 operations. On Zapier it is one task per row for every billable action step — Formatter and Filter steps are free, code and app actions are not. At scale, the math is not subtle.
The tradeoff is ramp-up time: expect a week of wiring JSON between nodes before it feels natural. For teams that already think in APIs and repositories, that investment pays back quickly. See the Apify n8n integration guide to wire the native Apify node into a workflow.
When should you pick Make.com?
Make.com (formerly Integromat) is built around a canvas with first-class routers, iterators, aggregators, and filters. Branching logic stays readable as workflows grow, which matters when you have "if product dropped >10%, notify Slack; if new SKU, enrich and push to HubSpot; else, just log" kinds of paths.
The Apify integration is the most step-oriented of the three major no-code platforms, a real, quantifiable advantage when you're orchestrating async Actor runs. If your workflow needs explicit wait states, dataset paging, and error recovery between steps, Make expresses those naturally without workarounds.
Per-operation billing rewards efficient scenario design (use aggregators to batch writes) and punishes naive ones (iterating the same dataset twice doubles your ops). Scenarios that move thousands of rows per run should be cost-modeled before deployment. The Apify Make.com integration guide walks through the Run Actor, Wait, and Get Dataset Items modules.
When should you pick Zapier?
Zapier's moat is app coverage and time-to-first-automation. 10,000+ apps, minimal jargon, and a Zap runs within minutes of signing up. For one-to-one, event-driven Apify use ("row added to Airtable → run Actor → post to Slack"), it works and it's fast.
Be honest about the limits:
- Apify lifecycle granularity is narrower than Make's. Expect to wrap multi-step async Actor work in an intermediate webhook.
- Task-based billing punishes fan-out. A scrape that produces 500 rows and runs each through three billable action steps is 1,500 tasks — filters and Formatter steps are free — so Zapier's 2K-task Professional tier ($49/mo billed annually, verified 2026-09-09) is gone in a single daily run.
- Retries and conditional routing exist but are less expressive than Make's routers or n8n's branch logic.
If you're evaluating Zapier purely for Apify pipelines at any meaningful volume, Make or n8n will almost always be a better fit. Zapier earns its slot when the Apify job is a small step inside a larger Zap that spans apps Make and n8n don't yet support as well. The Apify Zapier integration guide shows how to trigger an Actor from a Zap.
So which one should you actually pick?
Pick n8n if you want to self-host (data residency, PII, EU compliance), need JavaScript or Python code nodes, run AI agent chains, or push hundreds to thousands of items per run where per-execution billing slashes cost. Best for engineering teams comfortable with API-shaped data.
Pick Make.com if your workflows branch (routers, iterators, aggregators, filters) and you want the most step-by-step Apify integration with explicit Run Actor, Wait, and Get Dataset Items modules. Best for operators who want visual control without writing code.
Pick Zapier if you need the broadest app catalog (10,000+), the fastest time-to-first-automation, and your Apify job is one simple event-driven step inside a larger linear Zap. Best for non-technical users and one-to-one triggers.
Make.com's free plan gives you 1,000 credits a month and two active scenarios without a credit card, which is enough to build a full Apify scrape-and-route pipeline before you commit to anything.
Can you migrate between them?
Yes, but manually. None of the three offers a direct importer for another's workflows.
Zapier → Make. Export your Zap configuration where the option exists, then rebuild in Make. Audit your task usage first. Tasks and operations count almost identically (a 500-row workflow through two billable actions runs about 1,000 of either), but Make's unit price is lower, so the saving shows up in the bill rather than in the counter.
Make → n8n. Rebuild scenarios as workflows. Use HTTP Request nodes for any API n8n lacks a native node for.
n8n ↔ Make. Both use a visual canvas, so the logic translates readably, but the modules and their parameters differ enough that it is a rewrite rather than a port.
Whichever direction you go, budget more time for re-testing than for rebuilding. Changing the billing and execution model changes where the workflow breaks.
Zapier holds the connection open synchronously and cuts it at 30 seconds. A long Apify crawl exceeds that. Make and n8n both handle this with async webhooks: start the run, close the connection, and let Apify POST back on completion.
Manually. Export your Zap configuration where possible and rebuild it in Make. Audit your usage first. A task and an operation count almost the same way, so the row count does not change much; what changes is the unit price, which is lower on Make.
No. Make.com is cloud-only. If you need a self-hosted automation stack, n8n (Community Edition, free under the Sustainable Use License) is the standard alternative.
Self-hosted Community Edition is free with no execution cap (you pay for your VPS). n8n Cloud has no permanent free tier: Starter and Pro get a no-card free trial, and only the Business plan's trial is time-boxed, at 14 days and requiring a card. Starter Cloud is €20/mo with 2,500 workflow executions; Pro is €50/mo with 10,000.
For simple trigger-and-deliver patterns, yes. For multi-step workflows where you trigger an Actor, wait for completion, and process dataset items with retries and routing between steps, Make.com or n8n fit Apify's async model more naturally.
Make.com has a gentler curve for non-developers thanks to its canvas builder and guided module configuration. n8n expects comfort with JSON-shaped data moving between nodes; it pays back faster if you already work with APIs.
Billing unit. Zapier and Make charge per step-per-item (task or operation). n8n charges per workflow execution: one run is one execution regardless of how many items or steps flow through it. For an Apify scrape that produces 5,000 rows and runs them through five transformations, n8n bills one execution; Make bills roughly 25,000 operations. The difference compounds at scale.
Yes. Apify offers a native n8n node, a Make.com app with separate Run Actor, Wait, and Get Dataset Items modules, and a Zapier app for triggering Actors. Make exposes Apify's async run lifecycle as the most discrete steps, n8n is cheapest for high-volume runs thanks to execution billing, and Zapier is simplest for one-step triggers.
Software Developer & Automation Specialist
Common mistakes and fixes
Zapier task limit exceeded.
Upgrade the plan, or migrate to Make (which bills per operation) or self-hosted n8n (which bills per workflow execution, so item count is free).
n8n workflow fails on a long-running Apify job.
Use webhooks rather than waiting. Start the Apify run and close the connection; Apify POSTs back to n8n when the run finishes.
Make.com scenario hits its operation limit.
Audit operations per run and filter before write modules. Every row rejected by a filter stops consuming operations in every module after it. For sustained high volume, n8n's execution billing is cheaper.