n8n — Connect any app & build AI agents by drag-and-drop, self-host for free

🔗

Hands-on — 30 seconds

Your shop sells on Facebook + Shopee, and every day customers DM you asking "where's my order right now?". Normally a staffer has to open each tab, copy the order code, look it up in the shipping app, and type the reply back — a whole morning spent doing just that. With n8n you build one drag-and-drop workflow: a webhook receives the message → it calls the courier's API → (optionally) an LLM writes a polite reply → it sends that back to the customer. Build it once, run it 24/7, never open a tab. Why it matters: you fold hours of repetitive copy-paste into a single automated flow; self-hosting on a VPS at ~$3–7/month replaces a Zapier bill of tens of dollars — and the customer data stays on your own server.

"n8n is not a chatbot, and it's not an IDE.It's an orchestration layer: it connects app to app, hard-wires your business logic, and — when needed — drops an AI Agent into the middle of the flow so it can reason on its own."

After this chapter you'll be able to

Self-host n8n with Docker on your machine/VPS and open the canvas at localhost:5678.
Tell when to use n8n vs Zapier/Make/Activepieces — and when NOT to use it.
Build a pure business workflow (cron → API → DB → Slack) with drag-and-drop nodes + a Code node.
Wire in an AI Agent + RAG: connect an LLM (OpenAI/Claude/Ollama) to a Vector Store so a chatbot answers from your own documents.
Understand "execution"-based pricing — why a multi-step workflow on n8n is many times cheaper than on Zapier.
Dodge the real traps: out of RAM, webhooks not arriving, losing your N8N_ENCRYPTION_KEY, exposing your instance to the internet.

This is a tools chapter — you should read it with a terminal open and type along. Once you've self-hosted n8n even once, half the book on automation clicks into place.

Reliability note: the prices, execution limits, node names, and install commands in this chapter come from n8n's official site/docs as of roughly mid-2026. Third-party ROI/case-study figures are explicitly hedged (marked "per n8n" or "self-reported, unverified"). The product moves fast — always cross-check the links in Section 07.

01 · What this tool is & when to use it

n8n (pronounced "n-eight-n," short for "nodemation") is an open-source workflow-automation platform built on a "fair-code" model. It lets you connect many apps/services through a drag-and-drop node-based canvas, while still letting you write code (JavaScript/Python) right inside the workflow.

A simple mental model: each step in your flow is a node (a box). You drag boxes onto the canvas, connect them with wires, and data flows from one node into the next. A node might be "when a webhook arrives," "call this API," "if price > 100 then...," "write to Google Sheets," or "ask an OpenAI/Claude model this question."

The core differences versus Zapier/Make:

Self-host for free on your own server — you own your data and aren't billed per individual step.
Code side-by-side with drag-and-drop — the "Code" node runs whatever JS/Python you want, and "expressions" (the syntax) transform data inline.
From 2024–2026 it became the orchestration layer for AI agents thanks to native LangChain integration.

A few official addresses to remember:

Item	URL
Website	https://n8n.io
Docs	https://docs.n8n.io
GitHub	https://github.com/n8n-io/n8n
Community	https://community.n8n.io

"Open source" but NOT pure open-source — read the license carefully

n8n uses the "Sustainable Use License" (fair-code), not plain MIT/Apache. That means:

Using it yourself / self-hosting internally for your own work or your company → completely free.
But reselling n8n as a service (hosting it for customers as a SaaS that competes with n8n Cloud) → restricted.

This is a very common point of confusion: n8n is "open source" (readable, editable, self-runnable) but not open-source under the strict OSI definition. For 99% of learners and businesses using it internally, this makes no difference — you still use it free. The GitHub repo has over 150k stars (it crossed 150k in late 2025 and is still climbing fast — by mid-2026 it was around ~190k per community sources).

What's inside — n8n's "superpowers"

👉 Quick look at n8n's capabilities (covered in depth later)

Drag-and-drop canvas + code side-by-side — each step is a node; the "Code" node runs JS/Python; the expression transforms data inline. This is the biggest difference from Zapier (which is far more limited on code).
400+ built-in integrations (per the GitHub/n8n description as of mid-2026) + an HTTP Request node to call any REST API (even one without a dedicated node) → connectivity is effectively unlimited.
70+ AI/LangChain nodes (per 2026 sources): AI Agent (orchestrates and lets the LLM pick which tool to call), Model nodes (OpenAI's GPT-5.x / GPT-4o, Anthropic Claude, local models via Ollama), Memory (keeps conversation context), Vector Store (Pinecone/Qdrant/Supabase for RAG), Tools (attach another node as a "tool" for the agent to call).
Varied triggers — Webhook, Schedule (cron), app polling, chat trigger, form trigger.
Self-host or Cloud — run via Docker/npm on a VPS, or use the n8n-managed Cloud version.
Queue mode — a queue-based mode (Redis + multiple workers) to scale horizontally under heavy load.
Enterprise governance (higher paid tiers) — SSO/SAML/LDAP, RBAC, Git version control, dev/prod environments, log streaming, external secrets.
"Execution"-based billing — one workflow run = one execution, whether the workflow has 3 steps or 50 (this matters a lot for cost — see Section 02).

How it compares to other tools

n8n isn't the only option. The table below positions it next to the direct competitors people most often weigh (characteristics as of mid-2026, subject to change):

Criterion	n8n	Make	Zapier	Activepieces	Pipedream
Positioning	No-code + code, self-hostable	Visual no-code (strong visuals)	Simplest no-code, most apps	Open-source no-code, cheap, strong on MCP/AI	Dev-first, code-centric
Integration count	~400+ (+ any HTTP)	Very many	~8,000+ (the most)	~600+ "pieces" (count varies by source)	NPM packages (nearly unlimited via code)
Self-host	Yes (free)	No	No	Yes (free, true OSS)	No (mainly cloud)
License	fair-code (Sustainable Use)	Proprietary	Proprietary	MIT (true OSI)	Proprietary
Pricing model	Per execution (cheap for multi-step workflows)	Per operation (every step counts)	Per task (every step counts, ramps up fast)	Flat-rate, high task limits	Per credit (compute-time)
Code	JS + Python, strong	JS, more limited	Limited	Has code	Strongest (JS/Python/TS, NPM)
Best for	Mid-level dev/technical users who need control + data sovereignty	Ops teams who like the visual builder	Non-technical people stitching SaaS quickly	Budget-conscious SMBs wanting OSS + AI agents	Engineers who prefer code over a canvas

Reading the table correctly: n8n's biggest selling point is execution-based pricing + free self-hosting. A 10-step workflow on n8n counts as 1 execution; the same workflow on Zapier might count as ~10 tasks → roughly an order of magnitude more expensive at high volume. In exchange, Zapier has the most ready-made apps (~8,000+) and the easiest UI for someone with zero technical background.

When to consider a competitor

Non-technical, just need to wire a few SaaS apps fast: → Zapier (most apps, smoothest onboarding).
Want a pretty visual builder, moderate volume, cheaper than Zapier: → Make (free 1,000 ops/month across 2 scenarios, Core from ~$10–12/month for 10,000 ops — billed annually).
Low budget + want true OSS (MIT license) + prioritize MCP/AI tooling: → Activepieces (flat-rate, notable in 2026 for ~400 MCP servers).
An engineering team that wants pure code, durable execution: → Pipedream (best-in-class code experience, free tier ~100 credits/day on a credit model based on compute-time, not invocations) — or Temporal/Trigger.dev at larger scale.
Need self-host / data sovereignty / multi-step workflows / a controlled AI agent: → n8n (exactly this chapter's strength).

n8n vs "hand-coded AI agents" (LangGraph / CrewAI / AutoGPT)

This is a very common 2026 question: we already have LangGraph/CrewAI — what do we need n8n for?

Pick n8n when: you want an agent with clear guardrails + integration with enterprise systems (CRM/ERP/email/DB), you need someone not-too-technical to still see the flow, and you need to combine hard business logic (if/else, retry) with the LLM's reasoning. n8n is the orchestration layer — the agent's reasoning sits neatly inside a controllable workflow frame.
Pick a hand-coded framework (LangGraph/CrewAI...) when: you need very fine-grained control of the agent loop, complex multi-agent setups, dynamic logic that's hard to express as nodes, and your team has strong AI engineers.

When NOT to use n8n

🛑 The real boundaries — don't use n8n for everything

Very high load / strict real-time on a single instance: benchmarks show that at 200 VUs on a single C5.large box in single-mode, response time can climb to ~12 seconds, and with binary data the failure rate can reach ~74%. In other words, a single instance is not for high throughput unless you turn on queue mode / scale horizontally. For large scale → a proper queue-mode architecture, or Temporal/Step Functions for durable execution. (Benchmark source: blog.n8n.io/the-n8n-scalability-benchmark — see Section 07 on benchmarking.)
A fully non-technical team that just needs to stitch a few simple SaaS apps: Zapier is easier and needs less infrastructure care. Self-hosting n8n has a "hidden cost" = your team's ops time (even though the software is free).
Need a huge number of ready-made apps right now: Zapier (~8,000+) has far broader coverage.
Extremely complex agent logic / dynamic multi-agent: hand-coded frameworks (LangGraph/CrewAI) control this better than a node canvas.
No one to handle (or no desire to handle) security, disk encryption, reverse proxy, backups: don't self-host — use Cloud or a managed service instead.

Is there a usable free plan? — YES, but understand it correctly

This is the most-confused part, so let's draw a sharp line:

n8n Cloud NO LONGER has a permanent free plan (it was removed). There's only a 14-day trial (Starter/Pro need no card; Business needs a card).
Self-host (Community Edition) = TRULY FREE, with UNLIMITED executions. It has the full 400+ integrations and the core features. Only the enterprise features (SSO, advanced RBAC, log streaming, dedicated support) are locked behind paid tiers.

→ This is the main free path: pay for a VPS (~$3–7/month) instead of paying n8n. You own everything and your data never leaves your own server.

n8n Cloud pricing (per n8n.io/pricing as of mid-2026)

Prices are listed in EUR; below are the annual-billing rates (monthly billing is ~17% more):

Plan	Price (annual)	Executions/month	Hosting	Key points
Starter	~€20/month	2,500	Cloud	1 project, 5 concurrent, unlimited users, ~50 AI credits, forum support
Pro	~€50/month	10,000	Cloud	3 projects, 20 concurrent, 7-day insights, ~150 AI credits, admin roles
Business	~€667/month	40,000	Self-hosted/Cloud	6 projects, SSO/SAML/LDAP, 30-day insights, Git version control, dev/prod environments
Enterprise	Custom	Custom / unlimited	Cloud or Self-host	Unlimited projects, 200+ concurrent, 365-day insights, ~1,000 AI credits, external secrets, log streaming, SLA

(Some third-party sources list Starter at ~€24/month — the gap is monthly vs. annual pricing. Read it as "~€20–24/month depending on cycle" and cross-check the pricing page directly.)

Understand the "per-execution" pricing model — this decides your wallet

1 workflow run = 1 execution, regardless of step count. A 10-step or 50-step workflow still costs 1 execution.
Compared to Zapier (billed per task = one task per step) and Make (billed per operation = one operation per step), n8n is much cheaper for complex workflows. This is n8n's number-one sales argument.
Self-host = unlimited executions → nothing to count, you're only limited by your server's capacity.
(Hedged source) There's reportedly a "Startup Plan" with ~50% off the Business tier for companies under 20 employees — per third-party sources, so verify directly with n8n if you need it.

Payment & card access

n8n Cloud is paid by international credit card (Visa/Mastercard); the Annual Business & Enterprise tiers also support invoice / wire transfer.
(Thin sourcing on specifics): n8n's docs don't single out any particular country. Some users across multiple countries report payment failures with certain card types — n8n recommends re-entering card details on the billing page. If a card fails, try another card or contact support.

Note for Vietnam / SEA readers — card payments

Domestic-only cards from some countries (Vietnam included) are often blocked for recurring international SaaS charges. To pay for n8n Cloud you'll need an international Visa/Mastercard with online payments enabled; if it's declined, try another card or use a virtual card that supports international payments. The simpler route is to self-host — it sidesteps the payment issue entirely, saves money, and keeps your data on your own server. For learning, self-hosting is the default to prefer.

Self-hosting (2 ways)

Version note — from n8n 2.0 (January 2026)

n8n 2.0 is a major milestone: it requires Node.js 20.19+ (Node 18 dropped), makes LangChain first-class (AI Agent + ~70 AI nodes), and ships a stateful, "enterprise-hardened" engine. If you install via npm, use the right new Node version; before upgrading a running instance, read the release notes (Section 07) because 2.0 includes some breaking changes.

Option A — Docker (recommended). Install Docker Desktop first, then run:

bash

# Create a volume for durable storage (so you don't lose workflows when the container restarts)
docker volume create n8n_data

# Run n8n
docker run -it --rm \
  --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  docker.n8n.io/n8nio/n8n

Then open http://localhost:5678 → the "Set up owner account" screen to create the first admin account.

Option B — npm (needs Node.js 20.19+; supports 20 / 22 / 24 — Node 18 was dropped in n8n 2.0):

bash

# The fastest way, no permanent install (recommended for a quick trial):
npx n8n

# Or install globally then run:
npm install n8n -g
n8n start

This also serves on port 5678. (Note: avoid sudo npm install -g, which easily breaks permissions; if you hit permission issues, install Node via nvm instead of sudo.)

For production — don't forget these critical environment variables

When you move to a real VPS, use docker-compose (n8n + PostgreSQL + a Traefik/Nginx reverse proxy) and set these environment variables:

N8N_ENCRYPTION_KEY=<a-fixed-secret-string> — MUST stay fixed. This is the key that encrypts your credentials; changing the key wipes all stored credentials.
DB_TYPE=postgresdb + the DB_POSTGRESDB_* variables — connect PostgreSQL instead of the default SQLite (more robust for production).
GENERIC_TIMEZONE=Asia/Ho_Chi_Minh — so cron/schedules run on the right timezone (set this to your own timezone).
WEBHOOK_URL=https://your-domain — so webhooks work correctly behind a reverse proxy.

The official image is docker.n8n.io/n8nio/n8n. Don't expose n8n directly to the internet — bind to 127.0.0.1 and put it behind an HTTPS reverse proxy (see Section 04).

03 · The hands-on workflow — step by step (with real commands/config)

Open a terminal and type along. We go from standing up an instance → a pure business workflow → wiring in an AI Agent + RAG.

03a · Example A — Self-host with Docker (basic → with a DB)

Step 1 — Install Docker Desktop (available on macOS/Windows/Linux).

Step 2 — Run the two Docker commands from Section 02, then open localhost:5678 → create the owner account.

Step 3 — Go to production with docker-compose. Create a docker-compose.yml file roughly like this (trimmed to the important parts):

yaml

services:
  n8n:
    image: docker.n8n.io/n8nio/n8n
    restart: always
    ports:
      - "127.0.0.1:5678:5678"   # bind localhost, NOT 0.0.0.0
    environment:
      - N8N_ENCRYPTION_KEY=replace-with-your-own-fixed-secret-string
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=strong-db-password
      - GENERIC_TIMEZONE=Asia/Ho_Chi_Minh
      - WEBHOOK_URL=https://n8n.your-domain.com
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres

  postgres:
    image: postgres:16
    restart: always
    environment:
      - POSTGRES_DB=n8n
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=strong-db-password
    volumes:
      - pg_data:/var/lib/postgresql/data

volumes:
  n8n_data:
  pg_data:

Step 4 — Put it behind a reverse proxy (Traefik/Nginx) with HTTPS, pointing your domain at port 5678 bound on 127.0.0.1. Under heavy load, turn on queue mode (add Redis + a worker container).

03b · Example B — A pure business workflow (no AI)

This is the most common workflow shape, and it needs no AI: fetch data on a schedule → transform → filter → write → notify.

A typical node structure:

text

Schedule Trigger (cron)
   → HTTP Request (call the source API)
   → Code node (transform the data)
   → IF (filter by condition)
   → Google Sheets / Postgres (write)
   → Slack / Email (notify)

An important tip: when processing many records (a few hundred or more), insert a Split in Batches node to chunk the work instead of handling everything at once — this avoids running out of RAM (see Section 04).

A sample Code node (transforming data): n8n needs the returned data in the right item-array shape [{ json: {...} }]:

javascript

// Code node — tag each item as "expensive/cheap" based on price
return items.map((item) => {
  const price = item.json.price ?? 0
  return {
    json: {
      ...item.json,
      label: price > 100 ? 'expensive' : 'cheap'
    }
  }
})

And an expression () is used to inject a value inline into a node's field — for example, in a Slack-message node:

text

Order {{ $json.order_id }} for customer {{ $json.customer_name }} has a status update.

03c · Example C — AI Agent + RAG (a chatbot that answers from your own documents)

This is the most "of-the-moment" part of n8n in 2026. (The n8n 2.0 (January 2026) milestone made LangChain "first-class" with 70+ AI nodes — per 2026 sources; if you need to be 100% sure, cross-check the official n8n blog.)

A typical node structure for a RAG chatbot:

text

Chat Trigger (or Webhook)          ← receives the user's question
   → AI Agent node                 ← the orchestration hub
        ├─ Chat Model: OpenAI (GPT-5.x / GPT-4o) or Anthropic Claude / local Ollama
        ├─ Memory: Window Buffer Memory   (keeps conversation context)
        ├─ Tool → Vector Store: Qdrant/Pinecone/Supabase  (holds document embeddings → RAG)
        └─ (optional) Tool: HTTP Request, Gmail...  (for the agent to call itself)
   → Output → return to the channel (Telegram / Web / messaging API)

The central node is the AI Agent (the n8n-nodes-langchain.agent package). It uses the LLM's reasoning to decide on its own when to query the Vector Store and when to call a tool — you don't have to program each if/else branch.

OpenAI model names change fast — pick from the node's dropdown

Per sources as of mid-2026: GPT-4o was removed from the ChatGPT interface (Feb 13, 2026), still usable via the API but no longer the flagship — the 2026 flagship is the GPT-5 / GPT-5.5 line. Wherever you see "GPT-4o" in this chapter, read it as "any OpenAI model": names/versions change constantly, so pick the actual model in the node's dropdown (OpenAI/Anthropic/Ollama) rather than hard-coding a name.

A sample system prompt (set inside the AI Agent — a real example):

text

You are the customer-support assistant for [Company]. Answer only based on the
documents provided through the lookup tool (the vector store). If you can't find
the information, say "I don't have that information yet" and offer to hand off to
a human agent. Keep replies short and polite.

Note for Vietnam / SEA readers — non-English content works fine

n8n handles non-English content in workflows well because the intelligence lives in the LLM (OpenAI's GPT-5.x/GPT-4o, Claude, etc. all understand many languages). You can absolutely have the agent reply to customers in Vietnamese (or any language) politely, write non-English content into Google Sheets/Postgres, or send non-English emails. n8n's English-only interface is just an initial learning hurdle — it doesn't affect the output.

Want it fully private? Use local Ollama

If your data is sensitive and you don't want prompts leaving your server, swap the OpenAI/Anthropic Chat Model node for Ollama running locally. Then all reasoning happens on your own machine, and nothing is sent to an external LLM provider (see Section 04 on privacy).

04 · Pro tips & common mistakes

High-value tips (you'll feel the difference immediately)

7 hands-on tips

Self-host first, Cloud later. Learn and build real projects on self-host (unlimited executions, a ~$3–7 VPS). Only move to Cloud when you need SSO/RBAC/SLA or you'd rather not run the infrastructure yourself.
One workflow = one purpose. Don't cram everything into one giant flow — it's both hard to debug and prone to running out of RAM. Split it up and call between pieces via sub-workflows.
Many records → always use Split in Batches. This is the number-one cause of out of memory.
The HTTP Request node is the "universal key." No dedicated node for an app? Call its REST API directly with HTTP Request — there's almost nothing n8n can't connect to.
Turn on retry-on-fail for nodes that call external APIs. Third-party APIs (OpenAI/Supabase...) often hit rate limits; add a wait/retry node so the flow self-recovers instead of dying.
Keep N8N_ENCRYPTION_KEY fixed and back it up. Losing the key = losing all credentials. Store the key somewhere safe (a password manager), separate from your repo.
Enable automatic pruning of execution data. It both keeps the server light and reduces your compliance burden (old data is deleted automatically — see the security box below).

Security & privacy — where your data goes

You're handing n8n real data (orders, customers, sometimes even secrets). Read this carefully before going to production:

Self-host (recommended for sensitive data):

Data never leaves your environment — you decide where it's stored, who can access it, and how long to keep it. This fits data-sovereignty / privacy requirements (e.g. the EU's GDPR, or your local data-protection law).
n8n salts + hashes user passwords and encrypts credentials with N8N_ENCRYPTION_KEY. BUT you must handle yourself: encrypting the PostgreSQL volume (at-rest) and HTTPS via a reverse proxy (in-transit). n8n does not encrypt the disk for you.
If you self-host, you're responsible for deleting user data on request → so enable pruning of execution data after a few days.

The most common self-hosting risks:

Leaving n8n exposed directly to the internet → dangerous. Bind 127.0.0.1 + a hardened reverse proxy.
Losing N8N_ENCRYPTION_KEY → losing all stored credentials.
Forgetting to enable MFA + RBAC (advanced RBAC is a paid feature).
Not updating n8n regularly. Vulnerabilities are patched on a cadence — running an old build leaves known risks open. Watch the release notes and upgrade (read the breaking changes before moving to 2.0).
Enabling the public REST API when you don't need it. If you don't use it, turn it off; if you do, make sure it's authenticated.
Letting the Code node read your real environment variables (a secret-leak risk). Consider setting N8N_BLOCK_ENV_ACCESS_IN_NODE=true to block the Code node from accessing process.env, and N8N_SECURE_COOKIE=true so cookies are only sent over HTTPS.

Don't put anything into an external LLM that you don't want exposed:

When a node calls an LLM (OpenAI/Anthropic), the prompt content leaves to the LLM provider — true whether you self-host or use Cloud. For full privacy → use local Ollama.
With n8n Cloud, data also passes through n8n's infrastructure (which uses Cloudflare to fend off bad traffic).

Official pages: https://n8n.io/legal/security/ and https://docs.n8n.io/privacy-security/.

Common errors & how to handle them

~90% of n8n incidents fall into: auth failures, webhooks not arriving, Code node returning the wrong data shape, rate limits from external APIs, out of RAM, dropped DB connections, workflows stuck in the queue.

FAQ & common errors (operations)

Q: It says "Execution stopped... n8n may have run out of memory," and then later runs fail instantly (2–7ms). → Out of RAM. The corrupted memory state makes subsequent runs die immediately. Fixes: increase the container/server RAM; set an execution timeout; use Split in Batches to chunk the work instead of processing 1,000 records at once; avoid cramming everything into one giant workflow. (There was a reported memory leak in one specific build, v1.99.1, related to the Code node — GitHub issue #16862 — so keep your version current.)

Q: The webhook doesn't work / nothing arrives. → Common causes: (1) the workflow is inactive — you must activate it; (2) you're using the Test URL instead of the Production URL; (3) a wrong URL declared on the third-party side (Stripe/Typeform/HubSpot); (4) a changed signing secret; (5) a dropped ngrok tunnel; (6) a firewall/Cloudflare rule blocking it. When self-hosting behind a reverse proxy, remember to set WEBHOOK_URL correctly. On n8n Cloud, if a webhook doesn't respond within 100 seconds → error 524 (Cloudflare).

Q: Auth/credential failure (an external API call is rejected). → The token expired or OAuth hasn't refreshed. Fix: re-enter the credential, and check that the scope has enough permissions.

Q: The Code node runs but the next node throws a data error. → n8n needs data in the right [{ json: {...} }] shape. Make sure the Code node returns a proper item array (see the example in Section 03b).

Q: Calls to OpenAI/Supabase keep getting blocked (rate limit). → Add a wait/retry node, reduce batch sizes, and turn on retry-on-fail for that node.

Q: I want detailed logs to debug. → Set the environment variable N8N_LOG_LEVEL=debug for detailed logs.

Q: After moving servers, all my stored credentials are gone. → Almost certainly because N8N_ENCRYPTION_KEY doesn't match (the new key differs from the old one). You must use the exact old key. This is why you back up the key.

Q: Hitting Test runs fine, but "production" does nothing. → Most common: you forgot to enable Active. While a workflow is inactive, production triggers (webhook/schedule) don't fire — it only runs when you click Test manually. Flip the Active switch in the top corner, and for webhooks remember to use the Production URL (not the Test URL).

Q: After a version upgrade my workflow broke / a node says deprecated. → n8n has breaking changes between major versions (especially 2.0). Before upgrading: read the release notes (Section 07), back up, and upgrade in a test environment first. After upgrading, reopen the workflow to swap deprecated nodes for their new equivalents.

05 · Exercises / mini-projects

Do them in order. Each has clear success criteria so you can self-check.

Exercise 1 — Stand up an instance & a "Hello workflow" (basic)

Goal: self-host n8n with Docker, create an account, and run your first manual workflow.

Install Docker, then run the two commands from Section 02:

bash

docker volume create n8n_data
docker run -it --rm --name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

Open http://localhost:5678, create the owner account.
Create a new workflow: Manual Trigger → HTTP Request (call any public API, e.g. a weather API or https://api.github.com) → click Execute Workflow and look at the returned data.

Completion criteria

n8n runs and the canvas opens at localhost:5678.
You have an owner account and one workflow that ran manually and succeeded.
(Reflection) You understand why you need -v n8n_data:... (it preserves data when the container restarts).

Exercise 2 — A scheduled, automated business workflow (core)

Goal: build a cron → API → transform → write → notify flow, exactly the kind used in production.

Schedule Trigger (set it to run hourly, and remember to set the timezone to your own, e.g. Asia/Ho_Chi_Minh).
HTTP Request to fetch data from a source (an exchange-rate API, gold price, RSS...).
Code node to transform the data — return a proper [{ json: {...} }]:

javascript

return items.map((item) => ({
  json: { summary: `Current price: ${item.json.price}`, timestamp: new Date().toISOString() }
}))

Write to Google Sheets (or Postgres), then send a Slack/Email notification.

Completion criteria

The workflow is active and runs on schedule (no manual click needed).
Data is written correctly to Sheets/DB and a notification goes out.
(If many records) You inserted Split in Batches to avoid running out of RAM.

Exercise 3 — A RAG chatbot that answers from documents (advanced)

Goal: wire in an AI Agent + Vector Store so the bot answers based on your own documents.

Load documents (a PDF / company FAQ) into a Vector Store (Qdrant/Supabase) via an ingest workflow (read file → create embeddings → write to the vector store).
The chat workflow: Chat Trigger → AI Agent with:
- a Chat Model (an OpenAI model like GPT-5.x/GPT-4o, or local Ollama if you want privacy),
- Window Buffer Memory,
- a Tool → Vector Store pointing at the store from step 1.
Set a system prompt (the sample in Section 03c), and test a few questions.

Completion criteria

The bot answers correctly based on the loaded documents, and says "I don't have that information yet" when asked something out of scope.
The bot replies politely in the language set by your system prompt.
(Reflection) When to switch the OpenAI model (GPT-5.x/GPT-4o) to Ollama so data never leaves your server.

06 · Case studies & real use-cases (from the community)

This section gathers real cases of n8n in use during 2025–2026, so you can see what the tool does at real scale. Cases 1–6 come from the official case-study page (n8n.io/case-studies) — the figures are published by n8n/customers, so read them as "per n8n." The freelancer "making money" case is a personal, independently-unverified account, clearly labeled.

Read the numbers correctly

The hours/money-saved figures are self-reported by n8n or the customer on a marketing page — treat them as "per n8n," not an independent audit.
The freelancer case of ~$8,200/month is self-reported on Medium, not verifiable — it only illustrates a hot services market, don't treat it as a benchmark figure.
The "n8n 2.0 / 70+ AI nodes" milestone comes from a third-party 2026 source → cross-check the official blog if you cite it in print.

06a · Six official case studies (per n8n)

① Delivery Hero — automated IT-ops, saving ~200 hours/month

Context: a global food-delivery company that gets ~800 account-unlock requests a month, each previously taking ~35 minutes by hand.
What they did: built one IT-ops workflow automating the unlock process.
Result: processing time per request dropped from ~35 to ~20 minutes (not fully to zero) — the ~15-minutes-saved-per-request, across ~800 requests/month, adds up to ~200 hours/month (per n8n).
Lesson: a repetitive, high-volume task with a clear process → a prime candidate for n8n. The ROI comes from frequency × time-per-instance.
Source: https://n8n.io/case-studies/

② Vodafone — automated threat intelligence, saving ~£2.2 million

Context: the cybersecurity team processed threat intelligence manually, which was labor-intensive.
What they did: automated the threat-intelligence pipeline with n8n.
Result: ~£2.2 million saved (per n8n). (Another source cites "33 workflows, ~5,000 person-days/year" — that figure has thinner sourcing, so prefer the £2.2 million number from the official page.)
Lesson: n8n isn't only for small tasks — large enterprises use it for cybersecurity at scale.
Source: https://n8n.io/case-studies/

③ StepStone — running 200+ workflows, ~25× faster integration

Context: a recruitment platform that needs to integrate many data sources continuously.
What they did: moved 200+ critical workflows onto n8n.
Result: integrating a new data source became ~25× faster — from ~2 engineering weeks down to ~2 hours (per n8n).
Lesson: the biggest value is often integration speed, not just saved ops hours.
Source: https://n8n.io/case-studies/

④ Field Aerospace — proposals from ~2 weeks to ~25 minutes

Context: drafting technical proposals was a multi-week effort.
What they did: used n8n (combined with AI) to auto-generate proposal drafts.
Result: cut from ~2 weeks to ~25 minutes, reaching an 80% draft (per n8n).
Lesson: AI + automation is strongest at the "blank page to 80% draft" stage — humans just polish the rest.
Source: https://n8n.io/case-studies/

⑤ Musixmatch — saved 47 engineer-days over 4 months

Context & result: automated repetitive engineering tasks; saved 47 engineer-days over 4 months (per n8n).
Lesson: stack up many small workflows → savings measured in person-months per quarter.
Source: https://n8n.io/case-studies/

⑥ System AI — 97% less data-entry time

Context & result: automated data entry; each record went from 4–5 minutes to 10–20 seconds — a ~97% reduction (per n8n).
Lesson: manual data entry is a cheap automation "gold mine" with fast ROI.
Source: https://n8n.io/case-studies/

(There are many more cases on the official page if you want variety: iMi Digital — Shopware import from 1 day → 10 minutes; Koralplay — 70% of payment tickets automated; Deda.Tech — ITSM rollout from 2 days → 30 minutes.)

06b · A "making money" use-case from n8n services (self-reported, read with caution)

A freelancer at ~$8,200/month building n8n workflows — read it as an anecdote

Context: a Medium post (Mar 2026, author Ravindu Himansha) describes a freelancer who builds n8n workflows for clients. What they did: worked ~25 hours/week; the first client came from a comment on Reddit; the first job was only ~$600. Result (self-reported): reached ~$8,200/month. Lesson: the n8n services market is hot — knowing how to build good workflows is a skill you can sell, not just save internally. Note: this is a personal, independently-unverifiable account — paraphrased for inspiration, don't treat it as a benchmark figure. Source: Medium (Ravindu Himansha), Mar 2026.

06c · Common concrete use-cases (grouped by type)

What n8n is commonly used for

IT-ops / internal: unlocking accounts, granting permissions, syncing users across systems (the Delivery Hero pattern).
Cybersecurity: threat-intelligence pipelines, automatic alert triage (the Vodafone pattern).
Data integration: connecting many APIs/DBs, syncing CRM ↔ Sheets ↔ a data warehouse (the StepStone pattern).
Sales / customer care (a great fit for online shops): a webhook receives a DM → looks up the courier → an LLM drafts a reply → sends to the customer; auto-create orders from a form/landing page.
AI Agent + RAG: a chatbot answering from company documents, an internal assistant that looks up policies.
Content drafting: from blank page to an 80% draft of a proposal/report (the Field Aerospace pattern).
Data entry / document processing: OCR an invoice → extract fields → write into the system (the System AI pattern).

07 · Summary & official sources

6 things to take away

n8n = an open-source (fair-code) automation platform: connect apps with drag-and-drop nodes + write code side-by-side. "Open source" but not strictly OSI — free to use yourself, no strings.
The truly free path = self-host (Docker on a VPS at ~$3–7/month, unlimited executions). n8n Cloud removed its permanent free plan, leaving only a 14-day trial.
"Execution"-based pricing (1 run = 1 execution, regardless of step count) → multi-step workflows are many times cheaper than Zapier. This is the core advantage.
Works fine anywhere (both Cloud and self-host, no geo-blocking). Cloud payment needs an international card and can occasionally snag — so prefer self-host to sidestep it.
The of-the-moment AI: AI Agent + Memory + Vector Store (RAG) with OpenAI/Claude/Ollama. For full privacy → local Ollama so prompts never leave your server.
Critical traps: out of RAM (use Split in Batches), webhooks not arriving (activate + correct URL + WEBHOOK_URL), and never lose N8N_ENCRYPTION_KEY (lose it = lose all credentials).

The product moves very fast — when this material goes stale, use the official links below to update yourself:

Topic	Official link
Homepage	https://n8n.io
Pricing	https://n8n.io/pricing/
Docs	https://docs.n8n.io
Docker install	https://docs.n8n.io/hosting/installation/docker/
npm install	https://docs.n8n.io/hosting/installation/npm/
Release notes (latest version)	https://docs.n8n.io/release-notes/
Performance & benchmarking	https://docs.n8n.io/hosting/scaling/performance-benchmarking/
AI Agent node	https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent/
Case studies	https://n8n.io/case-studies/
Security & privacy	https://n8n.io/legal/security/ · https://docs.n8n.io/privacy-security/
GitHub	https://github.com/n8n-io/n8n
Community	https://community.n8n.io

This chapter draws mainly on n8n's official site/docs as of roughly mid-2026. Several figures are explicitly hedged in the text: the EUR pricing (~€20–24/month depending on monthly/annual cycle), the "n8n 2.0 / 70+ AI nodes" milestone (2026 source), the GitHub star count ("over 150k" in late 2025, still climbing fast), OpenAI model names (GPT-4o still works via the API but the 2026 flagship is the GPT-5 line — pick the model in the node's dropdown), the Vodafone "person-days" figure (thin sourcing — prefer the official £2.2 million number), and the freelancer ~$8,200/month case (self-reported, unverified). When in doubt, cross-check the official links in the table above.

n8n — Connect any app & build AI agents by drag-and-drop, self-host for free ​

01 · What this tool is & when to use it ​

What's inside — n8n's "superpowers" ​

How it compares to other tools ​

n8n vs "hand-coded AI agents" (LangGraph / CrewAI / AutoGPT) ​

When NOT to use n8n ​

02 · Sign-up / install & access — pricing & access ​

Is there a usable free plan? — YES, but understand it correctly ​

n8n Cloud pricing (per n8n.io/pricing as of mid-2026) ​

Payment & card access ​

Self-hosting (2 ways) ​

03 · The hands-on workflow — step by step (with real commands/config) ​

03a · Example A — Self-host with Docker (basic → with a DB) ​

03b · Example B — A pure business workflow (no AI) ​

03c · Example C — AI Agent + RAG (a chatbot that answers from your own documents) ​

04 · Pro tips & common mistakes ​

High-value tips (you'll feel the difference immediately) ​

Common errors & how to handle them ​

05 · Exercises / mini-projects ​

Exercise 1 — Stand up an instance & a "Hello workflow" (basic) ​

Exercise 2 — A scheduled, automated business workflow (core) ​

Exercise 3 — A RAG chatbot that answers from documents (advanced) ​

06 · Case studies & real use-cases (from the community) ​

06a · Six official case studies (per n8n) ​

06b · A "making money" use-case from n8n services (self-reported, read with caution) ​

06c · Common concrete use-cases (grouped by type) ​

07 · Summary & official sources ​

n8n — Connect any app & build AI agents by drag-and-drop, self-host for free

01 · What this tool is & when to use it

What's inside — n8n's "superpowers"

How it compares to other tools

n8n vs "hand-coded AI agents" (LangGraph / CrewAI / AutoGPT)

When NOT to use n8n

02 · Sign-up / install & access — pricing & access

Is there a usable free plan? — YES, but understand it correctly

n8n Cloud pricing (per n8n.io/pricing as of mid-2026)

Payment & card access

Self-hosting (2 ways)

03 · The hands-on workflow — step by step (with real commands/config)

03a · Example A — Self-host with Docker (basic → with a DB)

03b · Example B — A pure business workflow (no AI)

03c · Example C — AI Agent + RAG (a chatbot that answers from your own documents)

04 · Pro tips & common mistakes

High-value tips (you'll feel the difference immediately)

Common errors & how to handle them

05 · Exercises / mini-projects

Exercise 1 — Stand up an instance & a "Hello workflow" (basic)

Exercise 2 — A scheduled, automated business workflow (core)

Exercise 3 — A RAG chatbot that answers from documents (advanced)

06 · Case studies & real use-cases (from the community)

06a · Six official case studies (per n8n)

06b · A "making money" use-case from n8n services (self-reported, read with caution)

06c · Common concrete use-cases (grouped by type)

07 · Summary & official sources