n8n vs Make

Quick verdict

n8n is a fair-code, source-available workflow platform for technical teams: self-host Community for free software, or run n8n Cloud and pay per full workflow execution (unlimited steps inside a run). JavaScript/Python code nodes, HTTP-to-anything, and a serious AI Agent stack sit in the core product. Make (formerly Integromat) is a fully managed visual automation SaaS: circular scenario canvas, 3,000+ curated app modules, credit-based billing, and a 2026 push into Make AI Agents + MCP — zero servers, lower floor for non-developers.

Pick n8n when multi-step volume, custom code, agent graphs, or data residency make Make’s per-module credits (and cloud-only model) expensive or constrained. Pick Make when marketing/ops need polished SaaS glue today, you want the biggest maintained module library, and you will not own Docker upgrades or JSON debugging at 2am.

Side-by-side

What n8n is in 2026

n8n positions itself as workflow automation for technical teams: visual canvas plus code, AI agents, and deploy-anywhere options. The GitHub repo is among the most-starred automation projects (~197k stars on Community/pricing messaging mid-2026). License is fair-code under the Sustainable Use License — source available, self-hostable for internal use, with commercial restrictions (e.g. reselling n8n-as-a-service) that are not OSI “pure open source.”

Two run modes matter in practice:

• Community Edition (self-hosted): free software; you run Docker/npm/K8s, own updates, backups, reverse proxy, and uptime. Collaboration features like SSO, Git environments, and advanced RBAC need paid Business/Enterprise licenses.
• n8n Cloud: managed hosting (EU Frankfurt called out on the pricing FAQ). Starter / Pro for hosted executions; Business is self-hosted with license features; Enterprise is hosted or self-hosted with SLA support.

Product strengths builders cite: pin and re-run data per node, HTTP node for any API, JS/Python code nodes, error workflows, queue mode at scale, and AI Agent tooling that treats other nodes as tools. Integration count is smaller than Make’s public directory; depth, community nodes, and custom API reach close the gap for technical users.

What Make is in 2026

Make is a managed visual automation platform: scenarios built from modules on a highly visual canvas, routers/filters/iterators, and a large first-party app catalog. Free plan is a real product (1,000 credits/month) but capped at two active scenarios and a 15-minute minimum schedule interval. Paid Core unlocks unlimited active scenarios, 1-minute schedules, API access, and higher data transfer; Pro adds priority execution, custom variables, full-text log search; Teams adds roles and shared templates; Enterprise adds custom functions, advanced security, on-prem agent, and priority support.

Catalog size is a major moat: official messaging cites 3,000+ apps maintained so OAuth drift is more often Make’s problem than yours. For private networks, Enterprise offers an on-prem agent — but scenario execution still happens in Make’s cloud.

AI is productized: Make AI Agents live on the scenario canvas; MCP toolboxes and external MCP servers expand what agents can call alongside native modules. Built-in Make AI provider usage can consume credits differently from standard 1-credit modules. Make Grid maps an organization’s automation landscape for ops visibility.

Billing history that still confuses people: Make historically billed operations. From late August 2025 it shifted to credits (most standard actions still 1:1). Variable credit burn for AI, code runtime, and resource-heavy modules is the new budget risk.

Pricing and real cost (TCO)

n8n cash cost (official Cloud, annual billing mid-2026):

• Community self-host: $0 software; infra often a few dollars to low tens per month depending on VPS size and HA.
• Starter: 20€/mo billed annually — 2,500 workflow executions, unlimited steps per run, 5 concurrent executions, 1 shared project, forum support.
• Pro: 50€/mo billed annually — 10,000 executions, more concurrency/projects, admin roles, workflow history, larger AI Assistant credit pool.
• Business: 667€/mo billed annually — 40,000 executions, self-hosted, SSO/SAML/LDAP, Git version control, environments.
• Enterprise: custom executions, SLA support, advanced security.
• Start-up: 50% off Business for qualifying companies under 20 employees.

Critical: one execution = one full run, independent of how many nodes fire. A 25-step workflow still costs one execution per trigger. Business overages, when documented on the pricing FAQ, are sold in large execution buckets after quota — confirm live FAQ before budgeting.

Make cash cost (official annual list at base 10k credits/mo, mid-2026):

• Free: $0 — 1,000 credits/mo, 2 active scenarios, 15-min min interval, 5-minute max scenario runtime, 5 MB file size.
• Core: $9/mo annual for 10k credits (monthly list often ~$10–11). Unlimited active scenarios, 1-min schedules, API access (rate limits scale by plan).
• Pro: $16/mo annual for 10k credits (~$18–19 monthly list). Priority execution, custom variables, full-text log search, larger files.
• Teams: $29/mo annual for 10k credits (~$34 monthly list). Team roles, shared templates, collaboration features.
• Higher credit sliders: 20k → millions; price scales with volume on the pricing page. Extra credits often cost ~25% more than included credits (post-Nov 2025 adjustments — verify live help docs).
• Enterprise: custom, overage protection, 24/7 support, on-prem agent, enterprise apps.

Critical: each module action generally burns credits. Most standard modules = 1 credit per operation; Make’s own AI features can bill more based on tokens/usage; third-party AI apps often still 1 credit per op. Routers and some error-handler modules are frequently free of credit charge per help/FAQ patterns. Data transfer allowance scales (commonly cited as ~5 GB per 10k credits on paid tiers).

TCO people forget:

• n8n self-host: OS patches, TLS, backups of execution DB, queue mode at scale, community node bit-rot, encryption-key hygiene.
• n8n Cloud: execution ceilings and concurrency; Business self-host license still meters executions and pings the license server.
• Make: multi-step fan-out, iterators over large arrays, chatty Watch modules (poll costs credits even with no new data), AI token-linked credits, data-transfer caps tied to credit tier.
• Both: LLM API costs, failed-run retries, dual-running during migration, rebuild labor (no lossless Make↔n8n converter).

Community sentiment (Reddit, HN, reviews)

n8n praise: Execution pricing and self-host freedom beat Make when workflows get long or AI-agent heavy. HN users prefer n8n over Make/Zapier/Pipedream for unlimited local runs, code nodes, and AI tooling — loops and error handling that take “10+ minutes of modules” on Make can be a few lines of JS/Python. G2/Capterra reviewers emphasize flexibility and value when you can operate the stack. Migration threads on r/n8n and r/automation repeatedly cite pricing and flexibility as reasons to leave Make.

n8n complaints: Steep learning curve (JSON, expressions, code); Community Edition thin on collab/governance; self-host is a second job; fair-code is not pure OSS. Self-hosters report import/JSON friction, HTTPS requirements, RAM spikes on huge payloads, and missing multi-user analysis features without paid tiers. Some r/selfhosted users bounce back to Node-RED for simpler home automation. Power users sometimes resent Business-tier execution metering on hardware they already pay for.

Make praise: Fastest visual onboarding, broadest curated connectors, non-developers can own automations, strong scenario recovery/error routes. Still the default answer when the question is “which tool will ops actually use without engineering?” G2/Capterra satisfaction scores sit high in vendor comparison pages (commonly mid–high 4.x).

Make complaints: Credit bills scale with steps and loops; Free tier is a teaser for production; Trustpilot is noisier than G2 with support/billing friction stories. Complex multi-path logic can feel constrained versus n8n’s free-form canvas. Teams that already invested heavily in Make scenarios debate sunk cost versus n8n’s agentic depth.

Direct framing from 2025–2026 comparisons: developers and high-volume shops lean n8n; non-technical and app-coverage-first teams lean Make; migrations often start when Make credits or branching complexity hurt — not when someone randomly prefers open source branding.

When n8n wins

• High volume multi-step flows where Make credits explode (steps × items × runs)
• Code in the middle of every non-trivial workflow (JS/Python, custom transforms)
• Self-host / data residency / VPC requirements with full execution on your infra
• AI agents with tools, memory, and eval loops as first-class workflow graphs
• Internal APIs and databases as first-class citizens via nodes/HTTP
• You already operate containers and will own monitoring
• You need Git-based environments and SSO without waiting on Enterprise sales only (Business path exists)

When Make wins

• Non-technical owners (ops, marketing, sales, CS) shipping without engineering tickets
• Long-tail SaaS connectors maintained by Make rather than community packages
• Time-to-value > unit cost for the next 90 days on light-to-medium credit use
• Team templates, roles, Grid/ops visibility without standing up n8n governance yourself
• You want Make AI Agents + MCP on a managed credential layer across 3,000 apps
• No appetite for self-host failure modes (disk, upgrades, exposed ports)
• You need vendor-managed professional support on all paid plans rather than forum-first support

Risks and failure modes

• n8n “free forever” myth: software free, production not free — under-sized VPS, untested restores, public instances without auth
• n8n license surprises: fair-code restricts offering n8n as multi-tenant SaaS without commercial terms; Embed has separate commercial rules
• n8n Community collab gap: multi-user SSO/RBAC needs paid tiers
• n8n Business meter on self-host: power users resent execution quotas on DIY infra; license key must stay valid
• n8n community nodes: powerful but not all first-party; treat third-party nodes as supply-chain risk
• Make credit shock: iterators over large datasets, AI provider modules, busy months, extra-credit premiums
• Make Free ceilings: 2 scenarios and 15-minute schedules look fine in demos and fail in production schedules
• Make cloud-only data path: on-prem agent is not full self-host of scenario runtime
• Vendor lock-in of process: both encode tribal knowledge; Make scenarios differ from n8n JSON — rebuild costs hours either way

Recommendation by profile

FAQ

Is n8n free compared to Make?
n8n Community software is free if you self-host; you still pay infrastructure and ops time. Make Free is limited (1k credits, 2 scenarios). For managed hosting, n8n Starter starts at 20€/mo annual; Make Core at $9/mo annual for 10k credits — different meters, so “cheaper” depends on steps × volume.

Does Make charge per step?
Yes in practice: each module action consumes credits (usually 1). Complex scenarios with many modules or itemized loops burn more credits per run. n8n Cloud bills one execution per full workflow run regardless of step count.

Can I self-host Make like n8n?
No full platform self-host. Enterprise on-prem agent reaches private networks; scenarios still execute in Make’s cloud. n8n Community runs the full product on your servers.

Which is better for AI agents in 2026?
n8n has deeper agent/tool/memory composition for technical builders. Make AI Agents on the canvas plus MCP tools are strong for teams that want agents without self-host ops. Choose by who will maintain the agent graphs and how credits vs executions hit your budget.

How many integrations does each have?
Make advertises 3,000+ apps. n8n ships roughly 1,000+ integrations in current product messaging plus HTTP/GraphQL and community nodes. Count quality and maintenance matter more than raw totals.

Is n8n open source?
Source-available fair-code under the Sustainable Use License — free for most internal use, not pure OSI open source for all commercial scenarios (especially offering n8n as multi-tenant SaaS).

Should I migrate from Make to n8n?
Migrate when credit cost or logic complexity dominates, and someone technical will own the stack. Dual-run critical scenarios; rebuild is manual (no lossless 1-click conversion).

What about Zapier?
Zapier still wins pure long-tail connector breadth and non-tech defaults. Make sits between Zapier simplicity and n8n power; n8n undercuts both on multi-step volume when self-hosted or execution-metered carefully. See also n8n vs Zapier and Zapier vs Make.

Does n8n Cloud store data in the EU?
n8n’s pricing FAQ states hosted data is stored in the EU on servers in Frankfurt, Germany. Self-hosted instances store data wherever you deploy them. Always re-check current privacy docs for your compliance file.

When do Make Free limits force an upgrade?
As soon as you need more than two active scenarios, schedules tighter than 15 minutes, longer runtimes, larger files, or more than ~1,000 module actions per month. Core is the realistic production floor for most SMBs.

Sources

This comparison draws on 120 primary and secondary sources: official n8n and Make pricing/docs, GitHub releases and issues, security pages, G2/Capterra/Trustpilot, independent reviews and YouTube breakdowns, Reddit, and Hacker News. Full list with notes: research_cache/n8n-vs-makecom_sources.json. Pricing and plan details change — verify on official pages before buying.

Bottom line

If your automations are mostly SaaS-to-SaaS glue owned by non-engineers, start with Make — Core pricing and the module library will get you production faster. If you are a builder who ships multi-step, code-heavy, or agent workflows — or you need data to stay on infrastructure you control — choose n8n, usually Community self-host or Cloud Pro depending on ops capacity. The honest middle path many teams take: Make at the edges for business users, n8n for high-volume and AI cores.