Make vs n8n

Quick verdict

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. 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.

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. 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.

Side-by-side

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 trial (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, SSO, 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 server/client tooling lets agents call Make scenarios from Claude, Cursor, and similar hosts; built-in Make AI provider usage can consume credits differently from standard 1-credit modules. The Make Code app runs JavaScript or Python and bills 2 credits per second of execution time on paid tiers (Enterprise notes extended resources).

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 mid-2026 on product messaging). 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/SAML/LDAP, Git version control, and multi-environment setups need paid Business/Enterprise licenses.
• n8n Cloud: managed hosting with data storage in the EU (Frankfurt called out on 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: re-run single steps, pin data, 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.

Pricing and real cost (TCO)

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

• Free: $0 — 1,000 credits/month, 2 active scenarios, 15-minute minimum interval.
• Core: $9/mo billed annually — 10,000 credits, unlimited active scenarios, 1-minute schedules, Make API.
• Pro: $16/mo billed annually — same 10k entry volume framing + priority execution, custom variables, full-text log search.
• Teams: $29/mo billed annually — team roles, shared scenario templates.
• Enterprise: custom — custom functions, enterprise apps, SSO, 24/7 support, overage protection.

Volume is a slider: paid plans scale from 10k credits upward (20k, 40k, … into the millions) with price rising accordingly — always verify the live pricing page. Data transfer allowance scales with credits (official FAQ: 5 GB transfer per 10,000 monthly credits on paid framing).

Critical billing change: as of August 27, 2025, Make replaced “operations” with credits. Standard modules still convert 1:1 for most actions; AI features and some advanced modules can consume credits dynamically (tokens, file size, processing). Make Code: 2 credits per 1 second of code execution on Core/Pro/Teams. Credits expire at end of term; running out stops scenarios.

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, 20 concurrent, 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, hosted or self-hosted.
• Start-up: 50% off Business for qualifying companies under 20 employees.

Critical: one execution = one full run, independent of how many nodes fire. A 20-step workflow still costs one execution per trigger. Business overages (pricing FAQ): 4,000 EUR per extra 300,000 executions if you exceed quota without upgrading.

TCO people forget:

• Make: iterators, multi-bundle modules, AI credit multipliers, data transfer caps, incomplete-execution storage, webhook queue size — all scale with plan/credits.
• n8n self-host: OS patches, TLS, backups of execution DB, queue mode at scale, rotating secrets, community node bit-rot.
• n8n Cloud: execution ceilings and concurrency; Business overage buckets.
• Both: LLM API costs outside the platform meter, failed-run retries, dual-running during migration.

Security and compliance

Make (managed): Publishes SOC 2 Type II and SOC 3, GDPR posture, encryption, 2FA (enforcement on higher tiers), SSO on Enterprise, hosting on AWS in EU or North America. You trust their multi-tenant cloud with workflow payloads — a common concern for HR/sensitive data even when SOC 2 is cited. Enterprise on-prem agent reaches local systems (e.g. SAP) without moving the execution plane off Make’s cloud.

n8n Cloud: Security program with SOC reporting path; Cloud data called out in Frankfurt (Azure Germany West Central in product/security messaging); encryption and account hygiene documented.

n8n self-host: Compliance boundary is yours. Harden auth, set a persistent N8N_ENCRYPTION_KEY, put TLS in front, authenticate webhooks, restrict who can use Code/HTTP nodes, and plan backups. Unauthenticated public instances and lost encryption keys are classic failure modes.

Community sentiment (Reddit, HN, reviews)

Make praise: Best-in-class visual builder for non-developers; broad curated connectors; cheaper than Zapier at similar volume for many SMBs; free tier usable for learning. Agencies and YouTube ecosystems still teach Make heavily.

Make complaints: Credit/operation bills spike with complex scenarios and iterators; Google Sheets-style multi-step flows feel taxy; proprietary formula language; error handling routes are manual; support quality varies by plan. Ops→credits change (Aug 2025) raised questions about AI/code burn even when 1:1 for standard modules.

n8n praise: “Make killer” for technical users — no per-step tax, code nodes, self-host data control, AI agent graphs. HN users prefer it over Make/Pipedream/Zapier when they want local/unlimited runs and LangChain-style nodes. Scale stories (e.g. multi-million monthly operations after leaving Make) circulate on Reddit. Funding ($180M Series C era) put n8n firmly in mainstream automation conversation.

n8n complaints: Steep learning curve (JSON, expressions, code); Community Edition thin on collab/governance; self-host is a second job; license is fair-code not pure OSS. Polling-based triggers for some apps lag Make/Zapier instant triggers unless you add middleware. Some power users leave n8n for pure Python when workflows outgrow visual tooling. Business-tier pricing can erase the “$5 VPS free forever” story.

Direct framing from 2025–2026 comparisons: developers and high-volume shops lean n8n; non-technical and app-coverage-first teams lean Make; many orgs run both (Make at the edges for marketing SaaS, n8n for core volume/AI).

When Make wins

• Non-developer owners: Ops, marketing, RevOps who need a polished canvas and won’t write JSON expressions daily.
• Long-tail SaaS catalog: You need a maintained connector that already exists in Make’s 3,000+ directory and don’t want to babysit HTTP auth.
• Light-to-medium volume with simple graphs: Core at $9/mo for 10k credits undercuts n8n Cloud Starter if your scenarios are short and you stay under the credit ceiling.
• Zero ops appetite: Fully managed AWS hosting, no Docker, no encryption-key drama.
• Instant SaaS triggers: When Make’s native webhooks/instant modules matter more than n8n’s polling latency on certain apps.
• Enterprise procurement of a pure SaaS iPaaS: SSO, audit, Value Engineering, on-prem agent for private apps without self-hosting the whole platform.

When n8n wins

• Multi-step / high fan-out volume: One execution per run vs credits per module (and per iterated item) flips TCO hard.
• Code-first logic: JS/Python on every plan; no Enterprise gate for custom functions.
• AI agents with tool graphs: LangChain-style agent nodes, memory, model choice, self-host AI starter kits.
• Data residency / air-gapped preference: Community or licensed self-host keeps credentials and payloads on your infra.
• HTTP-to-anything and internal APIs: First-class for services without a polished module.
• Git / environments / SSO for technical teams: Business/Enterprise self-host path.

Risks and failure modes

Recommendation by profile

FAQ

Is Make cheaper than n8n?
At low, simple volume: often yes — Core $9/mo for 10k credits is hard to beat for short scenarios. At high multi-step or iterator-heavy volume: n8n’s per-execution model (or free self-host software) usually wins. Always model your actual monthly module actions vs full runs.

Is n8n free / open source?
Community Edition software is free to self-host. License is fair-code Sustainable Use License — not pure OSI open source; commercial restrictions apply (e.g. offering n8n as a service). Cloud and Business/Enterprise are paid.

Can Make self-host?
Not as a full platform. Enterprise offers an on-prem agent for secure access to local systems; scenarios still execute in Make’s cloud.

What changed with Make “credits”?
On August 27, 2025, Make switched billing unit from operations to credits. Standard actions largely stayed 1:1; AI and some advanced features can use variable credits.

How does n8n count AI usage?
Workflow runs still count as executions. Separate AI Assistant credits apply on Cloud plans for the assistant feature; model API calls (OpenAI, etc.) are usually billed by the model provider, not as n8n steps.

Which has more integrations?
Make advertises 3,000+ curated apps. n8n advertises 1,000+ integrations plus HTTP/GraphQL/code/community nodes to reach any API. Breadth vs depth/custom is the real tradeoff.

Can I migrate Make scenarios to n8n?
There is no perfect one-click migrator that preserves every module quirk. Teams typically rebuild high-cost scenarios first and keep Make for long-tail connectors.

Do I need Business n8n just to self-host?
No — Community is free for internal use. Business unlocks SSO, Git environments, scaling options, and licensed collaboration features with an execution quota on the license.

Sources

This comparison is based on 152 primary and secondary sources in research_cache/make-vs-n8n_sources.json: official product/pricing/docs for both tools, GitHub license and issues for n8n, Reddit and Hacker News threads (praise and complaints), independent reviews, security notes, and video explainers. Citations in the body map to source ids in that file. Pricing and plan details reflect official pages as researched mid-2026 — verify live before purchase.

Bottom line

Choose Make if your constraint is human time and connector coverage: visual scenarios, 3,000+ apps, managed cloud, and entry pricing that makes sense for short workflows. Choose n8n if your constraint is multi-step economics, code, AI agents, or ownership: execution-based billing, fair-code self-host, and developer depth that Make’s credit meter and Enterprise code gates do not match. Many serious teams use Make at the SaaS edge and n8n for volume cores — that dual-stack is a rational 2026 answer, not fence-sitting.