Originally published on Effloow

How to Self-Host n8n with Docker — AI Workflow Automation Guide 2026

n8n Cloud's Pro plan costs €60 per month for 30,000 executions. A self-hosted n8n instance on a $5 VPS handles unlimited executions. Same software, same features, 12x cost difference.

n8n is an open-source workflow automation platform with 1,400+ integrations and a visual node editor. It started as a Zapier alternative, but in 2026 it has evolved into something more interesting: a visual AI workflow engine where you can chain LLM calls, vector database queries, and tool-using agents — all without writing orchestration code.

This guide walks you through self-hosting n8n with Docker Compose, from initial setup to a working AI workflow with Ollama for local LLM inference. We will build a practical AI agent that can search the web, process documents, and generate structured output — running entirely on your own infrastructure.

By the end, you will have a production-ready n8n instance with PostgreSQL persistence, Ollama integration for private AI inference, and the knowledge to build AI workflows that would cost hundreds on Zapier or Make.

What Is n8n?

n8n (pronounced "nodemation") is an open-source, source-available workflow automation platform. You connect nodes on a visual canvas to build automations — triggers, data transformations, API calls, AI model invocations — and n8n executes them on schedule or in response to events.

Why n8n stands out in 2026

Most automation platforms treat AI as a bolt-on feature — a single "call GPT" action buried among 7,000 other integrations. n8n treats AI as a first-class workflow primitive.

The platform ships with dedicated nodes for:

• LLM chains — connect any model (OpenAI, Anthropic, Google, Ollama) to structured prompts with output parsing
• AI agents — autonomous agents with tool use, memory, and multi-step reasoning
• Vector stores — Qdrant, Pinecone, Supabase, and more for RAG workflows
• Embeddings — generate and query embeddings from multiple providers
• Document loaders — ingest PDFs, web pages, and databases into your AI pipelines

If you have used Dify for AI-specific workflows, think of n8n as the broader automation layer. Dify excels at RAG chatbots and prompt engineering. n8n excels at connecting AI to everything else — your CRM, email, databases, APIs, and file systems.

n8n's execution model

This matters for understanding the cost advantage. Zapier charges per "task" — every individual action in a workflow counts. A 5-step workflow triggered 1,000 times burns 5,000 tasks. Make.com charges per "operation" — similar granularity.

n8n counts per "execution." One execution = one complete workflow run, regardless of how many nodes it contains. A 20-node workflow that processes 1,000 webhook events uses 1,000 executions, not 20,000.

On self-hosted n8n, there is no execution limit at all. You pay for the server. That is it.

Why Self-Host n8n? The Cost Breakdown

The cost math for self-hosting n8n is straightforward and dramatic.

n8n Cloud pricing (as of April 2026)

Source: n8n.io/pricing — verify current pricing before purchasing.

Self-hosted cost

That is unlimited executions, unlimited active workflows, and full data sovereignty for the price of a coffee.

When n8n Cloud makes more sense

Self-hosting is not always the right choice. n8n Cloud is worth the premium if:

• You need multi-user access control without configuring LDAP/OIDC yourself
• You want zero maintenance — no Docker updates, no backups to manage
• Your team does not have anyone comfortable with basic server administration
• You need enterprise SSO and audit logging out of the box

For solo developers, small teams, and anyone who already manages their own infrastructure, self-hosting is the obvious path. If that describes you, our guide to self-hosting your entire dev stack under $20/month covers the broader infrastructure context.

Comparison with other platforms

We covered this in detail in our Zapier vs Make vs n8n comparison, but here is the executive summary:

Prerequisites

Before starting, make sure you have:

• A server or local machine with at least 2 CPU cores and 2GB RAM (4GB recommended for AI workloads)
• Docker Engine 24+ and Docker Compose v2 installed
• A domain name (for production with SSL — optional for local development)
• Basic comfort with the terminal

Recommended servers

For a dedicated self-hosted n8n instance, we recommend:

• Local development: Any machine with Docker installed (Mac, Linux, or Windows with WSL2)
• Production VPS: Hetzner Cloud CX22 (2 vCPU, 4GB RAM, €4.35/mo) — see our Hetzner Cloud setup guide
• AI workloads with local LLMs: Hetzner CAX21 ARM server (4 vCPU, 8GB RAM, €7.49/mo) or a machine with a GPU

If you plan to run Ollama alongside n8n for local AI inference, budget at least 8GB of RAM. Small models like Llama 3.2 (3B) run well on 8GB; larger models like Llama 3.1 (70B) need a GPU server. See our Ollama self-hosting guide for model sizing details.

Method 1: n8n Self-Hosted AI Starter Kit (Recommended)

n8n maintains an official Self-Hosted AI Starter Kit that bundles n8n with PostgreSQL, Ollama, and Qdrant (a vector database). This is the fastest path to a working AI workflow setup.

Step 1: Clone the repository

git clone https://github.com/n8n-io/self-hosted-ai-starter-kit.git
cd self-hosted-ai-starter-kit

Step 2: Configure environment variables

cp .env.example .env

Edit the .env file with secure values:

# .env — CHANGE THESE VALUES
POSTGRES_USER=n8n_user
POSTGRES_PASSWORD=your-secure-password-here
POSTGRES_DB=n8n

N8N_ENCRYPTION_KEY=generate-a-random-32-char-string
N8N_USER_MANAGEMENT_JWT_SECRET=generate-another-random-string
N8N_DEFAULT_BINARY_DATA_MODE=filesystem

# Uncomment for Mac/Apple Silicon running Ollama locally
# OLLAMA_HOST=host.docker.internal:11434

Generate secure random strings for the encryption keys:

openssl rand -hex 32  # Run twice — once for each key

Important: The N8N_ENCRYPTION_KEY encrypts stored credentials. If you lose it, all saved credentials become unreadable. Back it up somewhere safe.

Step 3: Start the stack

Choose the command that matches your hardware:

# NVIDIA GPU (recommended for AI workloads)
docker compose --profile gpu-nvidia up -d

# AMD GPU (Linux only)
docker compose --profile gpu-amd up -d

# CPU only (works everywhere, slower AI inference)
docker compose --profile cpu up -d

# Mac / Apple Silicon (uses host Ollama — install Ollama separately)
docker compose up -d

The first run pulls several Docker images and downloads the Llama 3.2 model (about 2GB). This takes a few minutes depending on your connection speed.

Step 4: Access n8n

Open your browser and navigate to:

http://localhost:5678

You will see the n8n setup screen. Create your admin account — this is the owner account for your instance. Choose a strong password.

What the starter kit includes

The Docker Compose stack runs five services:

The starter kit also includes a demo AI workflow that you can access at http://localhost:5678/workflow/srOnR8PAY3u4RSwb after setup. It demonstrates an AI chatbot chain using Ollama — a good starting point for understanding n8n's AI capabilities.

Method 2: Minimal n8n Setup (Without AI Stack)

If you only need workflow automation without the AI components, a simpler setup with just n8n and PostgreSQL is lighter on resources.

Docker Compose for minimal n8n

Create a docker-compose.yml file:

volumes:
  n8n_storage:
  postgres_storage:

services:
  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}
    volumes:
      - postgres_storage:/var/lib/postgresql/data
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -h localhost -U ${POSTGRES_USER} -d ${POSTGRES_DB}']
      interval: 5s
      timeout: 5s
      retries: 10

  n8n:
    image: n8nio/n8n:2.14.2
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_USER=${POSTGRES_USER}
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
      - DB_POSTGRESDB_DATABASE=${POSTGRES_DB}
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - N8N_USER_MANAGEMENT_JWT_SECRET=${N8N_USER_MANAGEMENT_JWT_SECRET}
      - N8N_DIAGNOSTICS_ENABLED=false
    volumes:
      - n8n_storage:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy

Create the .env file:

POSTGRES_USER=n8n_user
POSTGRES_PASSWORD=your-secure-password
POSTGRES_DB=n8n

N8N_ENCRYPTION_KEY=your-random-encryption-key
N8N_USER_MANAGEMENT_JWT_SECRET=your-random-jwt-secret

Start it:

docker compose up -d

This minimal setup uses roughly 512MB of RAM — suitable for even the smallest VPS instances.

Building Your First AI Workflow

Now that n8n is running, let us build a practical AI workflow. We will create an AI-powered content summarizer that:

1. Receives a URL via webhook
2. Fetches the web page content
3. Sends it to an LLM for summarization
4. Returns the summary as a structured JSON response

Step 1: Create a new workflow

In the n8n editor (http://localhost:5678), click "Add Workflow" in the top-right corner. Name it "AI Content Summarizer."

Step 2: Add a Webhook trigger

1. Click the + button to add a node
2. Search for "Webhook" and select it
3. Set the HTTP Method to POST
4. Set the path to summarize
5. Under "Respond," select "Using 'Respond to Webhook' Node" — this lets us return the AI-generated summary

Step 3: Add an HTTP Request node

1. Add a new node after the Webhook
2. Search for "HTTP Request"
3. Set the URL to: {{ $json.body.url }} — this reads the URL from the incoming webhook payload
4. Set the method to GET
5. Under "Options," set Response Format to "String" — we want the raw HTML

Step 4: Add an AI chain

1. Add a "Basic LLM Chain" node
2. Connect it to the HTTP Request output
3. Configure the model:
   • If using Ollama (from the starter kit): select Ollama Chat Model and choose llama3.2
   • If using an API: select OpenAI Chat Model or Anthropic Chat Model and add your API credentials
4. Set the prompt:

Summarize the following web page content in 3-5 bullet points. Focus on the key facts and actionable information. Return the summary as JSON with the format: {"title": "...", "bullets": ["...", "..."], "word_count": N}

Content:
{{ $json.data }}

Step 5: Add a Respond to Webhook node

1. Add a "Respond to Webhook" node at the end
2. Set "Respond With" to "All Incoming Items"

Step 6: Test it

Activate the workflow, then call it:

curl -X POST http://localhost:5678/webhook/summarize \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com"}'

You should receive a JSON response with the AI-generated summary.

This basic pattern — trigger → fetch data → AI processing → structured output — is the foundation for most AI automation workflows. From here, you can add error handling, conditional branches, database storage, and notification steps.

Advanced: AI Agent Workflows with Tool Use

n8n's AI Agent node goes beyond simple LLM chains. It creates autonomous agents that can reason, use tools, and take multi-step actions — similar to what you would build with LangGraph or CrewAI in code, but configured visually.

What an AI Agent can do in n8n

An n8n AI Agent node combines:

• An LLM (any supported model) for reasoning
• Tools that the agent can call: HTTP requests, code execution, database queries, web search
• Memory for multi-turn conversations
• Output parsers for structured responses

Building a research agent

Here is a workflow pattern for an AI research agent:

1. Webhook trigger — receives a research question
2. AI Agent node configured with:
   • Model: Ollama (llama3.2) or Claude/GPT-4 via API
   • Tools:
     • SerpAPI or Google Search node — for web research
     • HTTP Request tool — for fetching specific pages
     • Code tool — for data processing and calculations
   • System prompt: "You are a research assistant. Search the web to answer questions thoroughly. Cite your sources with URLs."
3. Respond to Webhook — returns the agent's research report

The agent autonomously decides which tools to use, in what order, and how many times — based on the question and intermediate results.

Agent tool configuration

To add tools to an AI Agent node:

1. Click the AI Agent node
2. Under "Tools," click "Add Tool"
3. Select from available tool nodes (Calculator, Code, HTTP Request, SerpAPI, etc.)
4. Each tool gets a name and description that the LLM uses to decide when to invoke it

The key insight is that the tool descriptions matter as much as the system prompt. Write clear, specific descriptions so the agent knows when each tool is appropriate.

Memory for multi-turn conversations

For chatbot-style workflows, add a Window Buffer Memory or Postgres Chat Memory sub-node to the AI Agent. This gives the agent conversation context across multiple interactions.

With PostgreSQL already in your stack, Postgres Chat Memory is the natural choice — sessions persist across n8n restarts and you get full conversation history in your database.

n8n vs Zapier vs Make: When to Choose What

We wrote a detailed comparison of all four platforms. Here is the decision framework:

Choose Zapier if:

• You need the largest integration library (7,000+ apps)
• Your team is non-technical and needs the simplest interface
• Budget is not a primary constraint
• You need enterprise compliance certifications

Choose Make.com if:

• You need complex multi-branch workflows at scale
• You want the best price-to-operations ratio on a managed platform
• Your workflows involve heavy data transformation
• You do not want to manage infrastructure

Choose n8n (self-hosted) if:

• You want AI workflow automation as a first-class feature
• You need unlimited executions at a fixed server cost
• Data sovereignty matters — GDPR, client contracts, or privacy requirements
• You are comfortable with Docker and basic server management
• You want to run local LLMs via Ollama without API costs

Choose n8n Cloud if:

• You want n8n's features without managing infrastructure
• You need managed scaling and high availability
• Your execution volume fits within the tier pricing

Production Deployment Tips

Running n8n locally is one thing. Running it reliably in production requires a few more steps.

Reverse proxy with Caddy

For production deployments, put n8n behind a reverse proxy with automatic SSL. Caddy is the simplest option.

Add Caddy to your docker-compose.yml:

  caddy:
    image: caddy:2-alpine
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data

Create a Caddyfile:

n8n.yourdomain.com {
    reverse_proxy n8n:5678
}

Add WEBHOOK_URL=https://n8n.yourdomain.com to your n8n environment variables so webhook URLs resolve correctly.

Backups

Your n8n data lives in two places:

1. PostgreSQL database — workflow definitions, credentials (encrypted), execution logs
2. n8n_storage volume — binary data, encryption keys

Automate daily backups:

#!/bin/bash
# backup-n8n.sh
BACKUP_DIR="/backups/n8n/$(date +%Y-%m-%d)"
mkdir -p "$BACKUP_DIR"

# Database backup
docker compose exec -T postgres pg_dump -U n8n_user n8n > "$BACKUP_DIR/n8n-db.sql"

# Volume backup
docker run --rm -v n8n_storage:/data -v "$BACKUP_DIR":/backup alpine \
  tar czf /backup/n8n-storage.tar.gz -C /data .

echo "Backup completed: $BACKUP_DIR"

Run this daily via cron:

0 3 * * * /path/to/backup-n8n.sh

Updating n8n

Pin your n8n version in docker-compose.yml (e.g., n8nio/n8n:2.14.2 instead of latest) and update deliberately:

# 1. Backup first
./backup-n8n.sh

# 2. Update the image tag in docker-compose.yml

# 3. Pull and restart
docker compose pull n8n
docker compose up -d n8n

Check the n8n release notes before updating. Major version bumps may include breaking changes to workflow nodes.

Credential encryption

n8n encrypts stored credentials using the N8N_ENCRYPTION_KEY environment variable. If this key is lost or changed, all saved credentials become unreadable.

Best practices:

• Generate a strong key: openssl rand -hex 32
• Store it outside the server (password manager, encrypted backup)
• Never commit .env files to version control
• Set the key before creating any credentials — changing it later requires re-entering all credentials

Resource monitoring

For a typical self-hosted n8n instance:

If running AI workloads with Ollama, the LLM inference is the bottleneck. Monitor Ollama's memory usage separately — a 3B parameter model uses about 2GB of RAM, while a 7B model needs 4-5GB.

Five Practical AI Automation Examples

Here are five n8n workflows you can build today with the self-hosted AI stack.

1. Email triage agent

• Trigger: New email arrives (IMAP or Gmail node)
• AI Agent: Classifies email as urgent/normal/spam, extracts action items
• Actions: Labels email, creates tasks in your project management tool, sends Slack alert for urgent items
• Model: Llama 3.2 (3B) via Ollama — fast enough for classification tasks

2. RSS-to-summary pipeline

• Trigger: RSS Feed trigger (check every hour)
• AI Chain: Summarizes each new article in 3 bullet points
• Output: Posts summaries to a Slack channel or Discord server
• Model: Any LLM — this is a straightforward summarization task

3. Customer support auto-responder

• Trigger: Webhook from your support system
• AI Agent with tools: Searches knowledge base (Qdrant vector store), drafts a response
• Human review: Sends draft to Slack for approval before sending
• Model: Claude or GPT-4 via API for quality-sensitive responses

4. Document processor

• Trigger: File uploaded to a watched folder or S3 bucket
• Processing: Extract text from PDF, split into chunks, generate embeddings
• Storage: Store embeddings in Qdrant for later RAG queries
• Model: Ollama for embeddings, any LLM for subsequent queries

5. Competitor monitoring dashboard

• Trigger: Scheduled (daily)
• Web scraping: HTTP Request nodes fetch competitor pages
• AI Analysis: Compares changes, identifies new features or pricing updates
• Output: Generates a daily digest email with structured comparison data
• Model: Llama 3.2 via Ollama for cost-free daily runs

Each of these workflows runs on the same $5/month server. On Zapier, the email triage agent alone would cost $50+/month due to the per-task billing on multi-step workflows.

Connecting n8n to Local LLMs via Ollama

If you used the AI Starter Kit, Ollama is already running. Here is how to configure n8n to use it.

Adding Ollama as a credential

1. In any AI node, click the Model parameter
2. Select "Ollama Chat Model" or "Ollama"
3. Create new credentials:
   • Base URL: http://ollama:11434 (inside Docker network) or http://localhost:11434 (if Ollama runs on the host)
4. Select your model (e.g., llama3.2)

Pulling additional models

To download more models into your Ollama instance:

docker compose exec ollama ollama pull mistral
docker compose exec ollama ollama pull codellama
docker compose exec ollama ollama pull nomic-embed-text  # For embeddings

For a complete guide on Ollama model selection, hardware requirements, and optimization, see our Ollama + Open WebUI self-hosting guide.

When to use local LLMs vs API models

The hybrid approach works well: use local Ollama models for high-volume, internal tasks and API models for customer-facing or quality-critical outputs.

Frequently Asked Questions

Is n8n really free to self-host?

The n8n Community Edition is free to self-host under the Sustainable Use License. You can use it for your own projects and business automations. The license restricts reselling n8n as a hosted service. For most self-hosting use cases, it is effectively free.

How many workflows can self-hosted n8n handle?

There is no artificial limit on workflows or executions. The practical limit is your server's CPU and RAM. A 2-core, 4GB RAM VPS comfortably handles 50+ active workflows with moderate traffic. For high-volume scenarios (thousands of executions per minute), scale vertically or run n8n in queue mode with multiple workers.

Can I use n8n with OpenAI and Anthropic APIs?

Yes. n8n has native credential types for OpenAI, Anthropic, Google AI, Hugging Face, and many more. Add your API key in the credentials settings and select the corresponding model in any AI node. You can mix and match providers within the same workflow.

How do I update n8n without losing data?

Pin your version, backup your database and volumes, update the image tag in docker-compose.yml, then run docker compose pull && docker compose up -d. Your workflows, credentials, and execution history are stored in PostgreSQL and survive container updates.

Is self-hosted n8n secure enough for production?

n8n encrypts stored credentials, supports LDAP/OIDC/SAML authentication, and provides role-based access control. For production, add a reverse proxy with SSL (Caddy or Nginx), keep the instance updated, restrict network access to port 443, and use strong encryption keys. The self-hosted version gives you more security control than any cloud platform because you own the network boundary.

Can n8n replace Zapier for a small team?

For most use cases, yes. n8n covers the same integration patterns — triggers, API calls, data transformation, scheduling — with 1,400+ built-in nodes. The main gap is Zapier's larger app library (7,000+ apps). If the specific integrations you need exist in n8n (check the n8n integrations page), you will save significant money by switching.

How does n8n compare to Dify for AI workflows?

They serve different purposes. Dify is purpose-built for AI: RAG chatbots, prompt engineering, model management. n8n is a general-purpose automation platform with strong AI capabilities added. Use Dify when your entire workflow is AI (chat interfaces, document Q&A). Use n8n when you need AI as part of a broader automation that connects to external services, databases, and APIs.

What We Learned Running n8n

At Effloow, we run 14 AI agents for content production, SEO analysis, and site management. n8n handles our workflow automation layer — connecting agents to external services, scheduling recurring tasks, and processing webhooks from various platforms.

Three things we learned the hard way:

1. Pin your n8n version. We initially ran :latest and an automatic update broke a webhook workflow in production. Pin to a specific version and update manually after testing.

2. Set up execution log pruning. By default, n8n stores all execution data. After a month of active workflows, our PostgreSQL database grew to 8GB. Set EXECUTIONS_DATA_PRUNE=true and EXECUTIONS_DATA_MAX_AGE=168 (hours) to auto-prune old execution data.

3. The AI Starter Kit is the right starting point. We initially set up n8n alone and added Ollama later. The starter kit's Docker Compose configuration handles the networking, volume mounts, and service dependencies correctly from the start. Save yourself the debugging.

Getting Started: Your First 30 Minutes

Here is a concrete plan for your first session with self-hosted n8n:

1. Minutes 0-10: Clone the AI Starter Kit, configure .env, run docker compose --profile cpu up -d
2. Minutes 10-15: Open http://localhost:5678, create your admin account, explore the demo workflow
3. Minutes 15-25: Build the AI Content Summarizer workflow from the tutorial above
4. Minutes 25-30: Test the webhook, iterate on the prompt, try switching between Ollama and an API model

After that, explore n8n's workflow templates library — there are hundreds of community-built workflows you can import and customize.

Self-hosting n8n is one of the highest-ROI moves for any developer or small team building with AI. Unlimited automations, local LLM inference, and full data control — all for the cost of a small VPS.

n8n is open-source software maintained by n8n GmbH. This guide covers the self-hosted Community Edition. For managed hosting with support, see n8n Cloud (affiliate link — we earn a commission at no extra cost to you).

This article may contain affiliate links to products or services we recommend. If you purchase through these links, we may earn a small commission at no extra cost to you. This helps support Effloow and allows us to continue creating free, high-quality content. See our affiliate disclosure for full details.