n8n runs half the internet’s automations. Just don’t call it open source.

n8n runs half the internet’s automations. Just don’t call it open source.

Two camps have emerged in the AI agent landscape. One hands everything to the model — write a prompt and hope the logic holds. The other demands engineers route every pathway by hand. n8n’s Series C announcement puts the observation plainly: neither extreme serves businesses well, and n8n was built for the reality in between — you choose where on that spectrum each agent sits. Seven years in, that middle position has made n8n one of the most-starred projects on GitHub (206,000+ stars, a top-150 repo of all time by the company’s own count), a $2.5 billion valuation on $240 million raised, and — if you run any infrastructure — a platform you have probably already met, whether you know it or not.

This article is the deep-dive I wish existed: what n8n actually is under the hood, the fair-code license story that most coverage gets wrong, how the AI layer is built, what the operational reality of self-hosting looks like, and where the complexity ceiling sits. Everything numeric here traces to a primary source I fetched — n8n’s own docs, the LICENSE.md in the repo, the company’s funding posts, and the security research that made 2026 the year n8n learned what it means to be popular.

I also ran it: the n8n instance serving this article’s verification is live on my own server right now (v2.14.2, healthz 200, the official n8nio/n8n image). What follows is written from that vantage point, not from a landing page.

What n8n actually is

n8n (a numeronym of "nodemation" — node + automation, always lowercase, pronounced "n-eight-n") is a workflow automation platform you can run two ways: their cloud, or your infrastructure. The GitHub repo describes it as a "fair-code workflow automation platform with native AI capabilities. Combine visual building with custom code, self-host or cloud, 400+ integrations."

The core model is simple and worth stating precisely, because everything else builds on it:

• Nodes are the building blocks — an entry point for retrieving data, a function to process it, or an exit for sending it.
• Trigger nodes start workflows (a webhook arrives, a schedule fires, a chat message lands, an email shows up). Every production workflow needs at least one.
• Action nodes do the work — call an API, transform data, write to a database.
• Core nodes provide the logic that isn’t service-specific: IF/Switch routing, loops, merges, the Code node, error handling.
• Cluster nodes are composite: a root node plus attached sub-nodes. This pattern is how the entire AI layer works (more below).

Data flows between nodes as an array of JSON items, each wrapped in a json key — and nodes iterate automatically. Hand a Gmail node an array of 500 items and it fires 500 times without you writing a loop. That single design decision is why n8n feels fast to build with: the platform’s unit of work is the item, and everything (expressions, retries, error branches) operates per item.

When the built-in 2,000+ integrations (the catalog currently counts 2,273) don’t cover you, three escape hatches keep you inside the same canvas:

• Expressions — {{ $json.body.city }} handlebar syntax that runs JavaScript inline; multiple statements go in an IIFE, dates use Luxon.
• The Code node — real JavaScript or Python ("Run Once for All Items" or "Run Once for Each Item"). On self-hosted instances you can import external npm modules; n8n Cloud locks that down. Code nodes can’t touch the filesystem or make HTTP calls — dedicated nodes own those jobs, which is the right call for a platform that runs other people’s code.
• HTTP Request node — any API with an endpoint becomes a node.

That last trio is the honest answer to "is n8n just toys for non-developers?" — it is a visual first language with real escape hatches, and the escape hatches are first-class. The project’s positioning line, "code when you need it, UI when you don’t," is marketing-speak, but the underlying mechanics back it up.

The execution model, for people who run production systems

An execution is a single run of a workflow. Manual runs from the editor don’t count against quotas; production executions (started by triggers, schedules, polling) do — that distinction matters when you’re sizing a paid plan, and it’s where the per-execution pricing model (below) connects to the architecture.

Failure handling is designed, not bolted on: per-node Retry On Fail, per-node On Error behavior (stop, continue, or continue through an error-output branch), and error workflows — any workflow can be designated to run when another fails, triggered by the Error Trigger node with the execution ID, the failed node, and the error details. This is the pattern that separates n8n from Zapier-style tools: the failure path is part of the workflow graph, versioned with it, instead of an email alert bolted on outside.

Under the hood, self-hosted n8n is a Node.js application with a database:

• SQLite by default (~/.n8n/database.sqlite) — explicitly fine for trying things out, explicitly not for production; the docs say production should use PostgreSQL. MySQL/MariaDB support was deprecated back at n8n 1.0.
• Queue mode is the scaling story: a main instance receives triggers/webhooks and generates executions, pushes execution IDs to Redis, and a pool of workers (each its own Node.js instance) pulls them, executes against the shared database, and writes results back. Webhook processors are an optional further layer. Multi-main (several main processes behind a load balancer, leader/follower over Postgres+Redis) exists — it is an Enterprise feature.
• Task runners execute Code-node JavaScript/Python in a separate process (websocket to a task broker); n8n calls them its isolation layer, with an external n8nio/runners sidecar container as the hardened deployment — and in queue mode, each worker needs its own sidecar.
• New minor versions ship most weeks; the stable Docker tag is for production, beta is the bleeding edge. The docs currently show stable at 2.40.x — my server runs 2.14.2, and it is neither ancient nor abandoned, which tells you something about the release cadence.

One ops detail that bites everyone exactly once: with the default SQLite database you must stop n8n before copying the .n8n folder — copying a live SQLite file mid-write produces inconsistent backups. And the CLI --backup export contains only workflows and credentials; users, roles, execution history, variables, and the instance encryption key are not in it. Lose the key from .n8n/config and your stored credentials are unrecoverable. Backup strategy on n8n is a database strategy, not a folder-copy strategy.

The AI layer: LangChain with a canvas

This is where n8n made its bet, and where most of its 2025–2026 growth came from. The docs state the relationship directly: n8n’s AI nodes implement LangChain’s JavaScript framework, mapping LangChain concepts onto visual cluster nodes — agents, chains, tools, memory, vector stores, embeddings, document loaders, output parsers. n8n’s own blog: "In n8n, AI agents are built on top of the LangChain library."

The pattern in practice:

• The AI Agent node is a cluster root: you connect a chat model, optionally memory, and one or more tools; the agent decides which tools to call. Since n8n 1.82.0 every AI Agent node runs as a Tools Agent implementing LangChain’s tool-calling interface — and at least one tool is mandatory (a sensible forcing function: an agent that can’t act is a chatbot with overhead).
• Chat models: the docs’ LangChain mapping lists around 20 sub-nodes — OpenAI, Anthropic, Azure OpenAI, AWS Bedrock, Google Gemini/Vertex, DeepSeek, Groq, Mistral, OpenRouter, and Ollama, which is the one that matters if your data can’t leave the building: a local model, on your metal, wired into the same agent node. The Anthropic node even exposes prompt caching (disabled / 5 minutes / 1 hour) as a dropdown.
• Memory: Simple Memory (buffer window, session key) in-process; Postgres Chat Memory and Redis Chat Memory for persistence; Mongo, Zep and others beyond that. One asymmetry worth knowing from the LangChain mapping docs: memory sub-nodes attach only to the AI Agent root node — n8n’s chain nodes don’t support memory at all. Choose your root carefully.
• Tools: 100+ agent tools including the Call n8n Workflow tool — any workflow becomes a callable tool, which is how you compose multi-agent systems on one canvas. There’s also a Code tool, HTTP Request tool, Calculator, SerpApi, vector-store Q&A, and the app nodes themselves.
• Vector stores: in-memory, PGVector, Pinecone, Qdrant, Supabase, MongoDB Atlas, Azure AI Search, Chroma, Milvus and more — usable as regular nodes for insert/retrieve, attached directly to an agent’s tool connector, or behind a retriever for Q&A chains.
• MCP, both directions: the MCP Server Trigger makes n8n act as an MCP server, exposing its tools and workflows to external MCP clients over SSE or streamable HTTP; the MCP Client Tool lets n8n agents consume tools from external MCP servers; and the node panel now includes an MCP server registry you can connect an agent to in one click. n8n sits fully on both sides of the protocol — which, given that MCP is becoming the de facto tool-plumbing standard, is a quietly strategic position.

A newer, separate Agents feature (preview) goes beyond the canvas node: standalone autonomous assistants with model, instructions, tools, skills, web search, a knowledge base, and both session memory and episodic memory (the latter currently needs an OpenAI credential). It’s n8n hedging toward the "give the agent a desk" model — worth watching, not yet the default way to build.

The positioning is unusually candid for a vendor. Their "how to build your first AI agent" post names three approaches — from scratch if you’re feeling hardcore, frameworks like LangChain and CrewAI if you want flexibility without reinventing the wheel, or n8n — and argues n8n "uniquely balances implementation flexibility with speed of delivery." My take after building agents both ways: n8n’s real product isn’t the agent, it’s the orchestration around the agent — the triggers, retries, human-approval steps, credential management, and error workflows that turn a demo into something you’re willing to page someone about at 3 a.m. LangChain gives you a better brain; n8n gives you the body, the calendar, and the phone line.

Your software is rightly called source available. Do not gaslight us.

The fair-code story (the part most coverage gets wrong)

n8n is not open source, and this is not a hot take — it’s their own position, stated in their own docs. The Sustainable Use License fails the OSI Open Source Definition, because open-source licenses can’t restrict fields of endeavor, and n8n’s does. n8n doesn’t pretend otherwise; they coined the term fair-code for this model, and the repo README says "fair-code" right up front.

The history matters because it repeats across the industry:

• 2019, launch: Apache 2.0 with the Commons Clause — and the launch post put "Open Source" in quotes, which Hacker News flagged within hours. The most famous artifact of that fight is GitHub issue #40 (October 2019), Drew DeVault’s "n8n is not open source and your project is gaslighting its users," which drew hundreds of upvote reactions and a blunt line worth quoting: "Your software is rightly called source available. Do not gaslight us."
• March 2022: the license switches to the Sustainable Use License (and Apache+Commons Clause is retired).
• Today: the repo is labeled fair-code; enterprise-suffix files (.ee. in filename or dirname) fall under a separate Enterprise License; and every contributor signs a CLA that gives n8n the right to change the license without further permission.

What the Sustainable Use License actually permits (from LICENSE.md, verbatim): "You may use or modify the software only for your own internal business purposes or for non-commercial or personal use. You may distribute the software or provide it to others only if you do so free of charge for non-commercial purposes."

Read that twice, because it’s broader than most people fear and narrower than "open source." A 10,000-employee company can run n8n internally, forever, free — build every internal workflow on it, no license key, no seat tax. What you cannot do is sell n8n to others as a service; that requires a negotiated commercial agreement. The faircode.io framing (co-founded by n8n’s own Jan Oberhauser) is explicit that fair-code is not a software license but a model: source available, free to use and redistribute, "commercially restricted by its authors."

The practical map of what’s free and what isn’t:

• Community edition (free, no license key): almost the complete feature set. Excluded: custom variables, Environments/source control (Git), external secrets, external binary-data storage, log streaming, multi-main mode, projects, SSO (SAML/LDAP), workflow/credential sharing, Git version control.
• Registered Community (free): adds folders, debug-in-editor, custom execution data.
• Business/Enterprise (paid license key): the exclusions above, unlocked. Note for self-hosters: the license key must ping n8n’s license server daily, sending production-execution counts; telemetry is on by default with an opt-out.

The pricing model is the other half of the story. Zapier bills per task (every step, every connector call), Make bills per module action — n8n bills per full workflow execution. Their own blog runs the comparison: workflows with around 100,000 tasks "could easily cost over $500 per month on other platforms" versus roughly $50 on n8n’s Pro plan. That’s vendor math, so treat it as their claim — but the structural point holds regardless of whose numbers you use: a 12-node workflow that fans out over 5,000 items costs 12 executions on n8n and tens of thousands of tasks on a per-step rival. For high-volume internal automation, the billing model can be the whole decision.

And the honest counterpoint, because it matters: n8n has become big enough to have its own pricing gravity. n8n Cloud overage charges apply past quotas; the pricing FAQ openly says pricing "is not tied to how much it cost us to run n8n but the value it brings to you" — value-based, not cost-based, even for self-hosted Business/Enterprise features. The fair-code floor (self-host, community edition, internal use, free forever) is real and stable. The ceiling above it is commercial, and it is theirs.

Where it breaks

An expert review that doesn’t name failure modes is marketing. Here is where n8n genuinely struggles.

The complexity ceiling. Visual builders have a representational limit. When logic becomes deeply bespoke — cyclical multi-agent reasoning, state that must persist across sessions, branching that depends on data shape at runtime — developers end up pushing the hard parts into Code nodes, at which point the visual canvas is decoration around a codebase you can’t see. Third-party comparisons (and my own experience) converge on the same line: n8n was not built for agents that maintain complex state across multi-day sessions; if checkpointed, durable agent state is your core requirement, LangGraph’s model is the stronger fit. Related asymmetry: code-first agents pair with tracing tooling (LangSmith-class execution traces) that make agent decisions debuggable; n8n’s execution log is excellent for workflow logic but thinner when the "logic" lives inside a model’s tool-calling loop. Their newer Evaluations feature acknowledges exactly this gap — testing agents is hard, and n8n is building toward it.

No native Git in the free edition. Workflows export to JSON (so external versioning is possible — mind credential references in the exports), but real source control (push/pull to a Git repo, environments as instance+branch, workflow diffs) is a Business/Enterprise feature. For a solo builder this is fine. For a team of five shipping workflow changes to production, it is the first wall you hit — and it’s a wall n8n chose, deliberately, because it sits exactly where team-scale buyers start paying.

The ops burden is real. "n8n recommends self-hosting for expert users. Mistakes can lead to data loss, security issues, and downtime" — their own docs, not mine. The minimum spec for the current Docker Compose setup is 4 GB RAM / 2 vCPUs. Queue mode drags in Postgres and Redis. There’s no filesystem binary storage in queue mode (use S3). Releases land weekly and the docs recommend a full backup before every update. None of this is unreasonable; all of it is a standing commitment.

Security: the cost of becoming infrastructure. 2026 was rough. The numbers, each traceable to a primary source: GitGuardian found 4,576 unique n8n API tokens leaked in public GitHub commits across 1,255 hostnames — and of the 896 instances they could reach, 321 accepted a leaked token. More than 100,000 n8n instances are visible through Shodan. Researchers at Cyera disclosed "Ni8mare" (CVE-2026-21858, CVSS 10.0), an unauthenticated RCE chain that turned an arbitrary-file-read into full instance takeover — the payload reads the SQLite user database plus the encryption key from .n8n/config, forges an admin session, and runs arbitrary workflows. CISA added an n8n RCE to its Known Exploited Vulnerabilities catalog in March 2026. Separately, attackers abused trusted *.app.n8n.cloud webhook URLs for phishing at scale (mail volume up ~686% in a year), because email filters trust n8n’s subdomains.

To keep the balance the evidence itself provides: Cyera’s own writeup credits n8n’s security team with a strong posture and fast response, and the structural lesson isn’t "n8n is insecure" — it’s that n8n is a credential vault by function. It holds keys to every system you connect. A single sandbox escape exposes the instance and everything it touches (Pillar Security’s framing, after two further critical n8n CVEs in 2026: "n8n is a credential vault by function"). If you run it: keep it off the public internet unless you absolutely must, authenticate every webhook (Basic/Header/JWT — authentication is opt-in, and n8n’s own security-audit tool flags unprotected webhooks as a report category), treat the encryption key as crown-jewel material, patch weekly, and — if your threat model justifies it — put credentials in an external secrets store (Vault, AWS Secrets Manager — an Enterprise feature).

n8n is a credential vault by function.

Who should pick what

The decision is about the shape of your work, not about which tool is "best":

• Zapier / Make (hosted-only, per-task/per-credit billing): the widest SaaS connector catalogs (Zapier claims 9,000+; Make 3,000+ apps) and zero ops. If your automations are linear, business-owned, and low-volume, the simplicity is worth the meter running.
• n8n (self-hostable, per-execution billing, fair-code): high-volume internal automation, data that must not leave your infrastructure, custom code in the loop, AI agents that need real tools and memory, and pricing that doesn’t explode with item counts. The bill of fare for teams with someone who enjoys running Postgres.
• LangGraph / custom code (code-first): multi-day agent state, checkpointing, bespoke reasoning graphs, full observability. More control, more engineering. n8n can call out to it (or be called by it) via HTTP and MCP — the boundary doesn’t have to be either/or.

The pragmatic pattern I keep landing on: n8n as the body, code-first agents as the brain where needed. The workflow handles ingestion, routing, retries, human gates, and delivery; the hard reasoning runs in a sub-agent the workflow calls. You get the orchestration for free and keep full control exactly where it earns its keep.

The bottom line

n8n is the rare automation platform whose architecture, license, and business model all point the same direction: own the middle ground between pure-AI autonomy and pure hand-coded routing, then win on deployment flexibility. It is not open source — it’s fair-code, on purpose, and the distinction carries real restrictions you should understand before building a business on it. It is genuinely excellent at the unglamorous layer where AI agents meet production: triggers, tools, memory, retries, error paths, humans-in-the-loop. And it is a serious operational commitment: Postgres, queue mode, weekly patches, a credential vault worth defending.

Two hundred thousand GitHub stars don’t make a platform right for you. But if your automations have outgrown per-task billing, if your data has a residency requirement, or if your agents keep dying in the gap between "the demo worked" and "this runs in production" — that is exactly the gap n8n was built to close.

Go deeper / Sources

Every load-bearing claim above traces to a page fetched during research (September 27, 2026). Primary sources:

• n8n repository (product description, fair-code positioning, name origin, stars) — https://github.com/n8n-io/n8n
• Sustainable Use License, full text — https://github.com/n8n-io/n8n/blob/master/LICENSE.md
• n8n docs — Sustainable Use License rationale (OSI positioning) — https://docs.n8n.io/privacy-and-security/sustainable-use-license/
• n8n docs — Community edition features (what’s gated) — https://docs.n8n.io/deploy/host-n8n/community-edition-features/
• n8n docs — Node types / trigger & action model — https://docs.n8n.io/integrations/builtin/node-types/
• n8n docs — Data structure (items, `json` key) — https://docs.n8n.io/build/work-with-data/understand-n8ns-data-structure/
• n8n docs — Code node (JS/Python, modes, npm restrictions) — https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.code/
• n8n docs — Queue mode (main/Redis/worker architecture, webhook processors, multi-main) — https://docs.n8n.io/deploy/host-n8n/configure-n8n/scaling/enable-queue-mode/
• n8n docs — Choosing the database (SQLite default, Postgres for production) — https://docs.n8n.io/deploy/host-n8n/configure-n8n/choose-n8ns-database/
• n8n docs — Backup & restore (what `--backup` misses; stop-before-copy) — https://docs.n8n.io/deploy/host-n8n/keep-n8n-running/backup-and-restore/
• n8n docs — AI Agent node (cluster nodes, Tools Agent) — https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent/
• n8n docs — LangChain in n8n (mapping, memory asymmetry) — https://docs.n8n.io/build/integrate-ai/langchain-in-n8n/
• n8n docs — MCP Server Trigger / MCP Client Tool — https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-langchain.mcptrigger/
• n8n blog — Series C announcement ($180M, $2.5B valuation, 6x users / 10x revenue, two-camps framing) — https://blog.n8n.io/series-c/
• n8n blog — Series B announcement (€55M, Highland Europe, 200k users / 3,000+ enterprises) — https://blog.n8n.io/series-b/
• n8n blog — per-execution pricing argument — https://n8n.io/blog/n8n-execution-advantage/
• n8n press page (Berlin, 2019, Jan Oberhauser, "n eight n") — https://n8n.io/press/
• n8n integrations catalog (count) — https://n8n.io/integrations/

• Zapier pricing / apps directory (per-task model, connector counts): https://zapier.com/pricing / https://zapier.com/apps

• Make pricing (per-credit model) — https://www.make.com/en/pricing
• faircode.io (fair-code definition, "commercially restricted by its authors") — https://faircode.io/
• OSI Open Source Definition (criterion 6, field-of-endeavor) — https://opensource.org/osd
• GitHub issue #40 (the 2019 license fight, primary thread) — https://github.com/n8n-io/n8n/issues/40
• Cyera Research — Ni8mare, CVE-2026-21858 (CVSS 10.0, attack chain, remediation) — https://www.cyera.com/research/ni8mare-unauthenticated-remote-code-execution-in-n8n-cve-2026-21858
• SecurityWeek — two further critical n8n CVEs (RCE + sandbox escape) — https://www.securityweek.com/critical-n8n-vulnerabilities-allowed-server-takeover/
• The Hacker News / GitGuardian — 4,576 leaked tokens, 36% of reachable instances accepted, 100k+ Shodan-visible instances — https://thehackernews.com/2026/08/leaked-n8n-api-tokens-exposed-live.html
• Paubox — n8n webhook phishing abuse, CISA KEV listing — https://www.paubox.com/blog/attackers-abuse-n8n-workflow-automation-webhooks-to-deliver-malware
• TechCrunch — Series B coverage (fair-code framing, valuation context) — https://techcrunch.com/2025/03/24/fair-code-pioneer-n8n-raises-60m-for-ai-powered-workflow-automation/

Second-order context (not primary, used only as corroboration): Wikipedia’s n8n entry (license history, SAP investment reporting).