Self-Hosted n8n vs Zapier: Where the Break-Even Actually Is

Executive verdict

For multi-step workflows above ~2,000 runs a month, move off Zapier to n8n — but start on n8n Cloud Pro, and only self-host once you pass its 10,000-execution ceiling, where the next cloud tier jumps to €667/month.

The whole decision hinges on one billing detail most comparisons skip. Zapier counts a task for every successful action step. n8n counts one execution per workflow run, no matter how many steps it has. A 5-action workflow run 10,000 times is 50,000 Zapier tasks — but only 10,000 n8n executions.

Tool / Approach	Best For	Pricing / Self-Host Cost	Setup Effort	Critical Dealbreaker	Action CTA
Zapier Professional	Non-technical teams, low volume, widest app catalogue	$89/mo for 5k tasks · $289/mo for 50k (annual billing)	~1 hour	Every action step is billed — cost scales with workflow length, not just volume	Try Zapier →
n8n Cloud Pro	Technical teams, 2k–10k runs/month	€50/mo for 10,000 executions (annual billing)	~2 hours	Hard ceiling at 10k executions; the next tier is €667/mo	Try n8n Cloud →
n8n self-hosted (Community)	Engineering-owned pipelines above 10k runs/month	Free software + VPS ($14.99/mo renewal on a 2 vCPU / 8 GB box)	1–2 days	You own uptime, upgrades, backups and security	Get a VPS →
Make	Visual branching scenarios on a budget	$9/mo for 5,000 credits	~2 hours	Also billed per action (most actions = 1 credit)	Try Make →

Prices checked September 19, 2026 on each vendor’s pricing page. n8n prices are listed in EUR. Re-check before you commit — the arithmetic below is shown so you can re-run it.

Architecture and data flow

The reference workload for every number in this article is a lead-routing pipeline — the kind of workflow most teams migrate first.

[ Trigger / Webhook ] -> [ Parse & Filter ] -> [ AI / LLM Node ] -> [ Storage / CRM ] -> [ Error Fallback / Alert ]
   form POST in          validate + dedupe      classify lead        create record         error workflow
                                                                     + log row + notify     pages a human

What moves through each stage:

1. Trigger / Webhook — a form or app POSTs JSON. In Zapier the trigger is not billed; in n8n the run starts here.
2. Parse & Filter — schema check plus an idempotency lookup. Zapier’s Filter and Formatter steps are not billed as tasks.
3. AI / LLM node — one model call returns a structured classification. This is the only stage metered by the token.
4. Storage / CRM — create the CRM record, append a log row, notify the owning rep in Slack, send the confirmation email.
5. Error fallback — runs only on failure; alerts a human with the execution ID.

Counting billable actions: LLM call, CRM create, log row, Slack message, email = 5 Zapier tasks per run, versus 1 n8n execution per run.

Production implementation blueprint

This is the self-hosted path. If you’re starting on n8n Cloud, skip to step 4 — the workflow is identical.

n8n’s own documentation is blunt about the prerequisite: “n8n recommends self-hosting for expert users. Mistakes can lead to data loss, security issues, and downtime.” Take that seriously before step 1.

1. Provision the server

A 2 vCPU / 8 GB VPS comfortably runs n8n plus Postgres for this workload — the cost model below uses Hostinger’s KVM 2 at that size. Point a DNS A record (e.g. flows.example.com) at it and install Docker.

2. Run n8n on Postgres, not SQLite

n8n defaults to SQLite, which its docs describe as fine for trying things out, with Postgres recommended for anything running around the clock. Use Compose so both services restart together:

services:
  postgres:
    image: postgres:16
    restart: unless-stopped
    environment:
      POSTGRES_USER: n8n
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: n8n
    volumes:
      - pg_data:/var/lib/postgresql/data

  n8n:
    image: n8nio/n8n:<pinned-version>
    restart: unless-stopped
    ports:
      - "127.0.0.1:5678:5678"
    environment:
      DB_TYPE: postgresdb
      DB_POSTGRESDB_HOST: postgres
      DB_POSTGRESDB_PORT: 5432
      DB_POSTGRESDB_DATABASE: n8n
      DB_POSTGRESDB_USER: n8n
      DB_POSTGRESDB_PASSWORD: ${POSTGRES_PASSWORD}
      N8N_ENCRYPTION_KEY: ${N8N_ENCRYPTION_KEY}
      N8N_WEBHOOK_URL: https://flows.example.com/
      GENERIC_TIMEZONE: UTC
      N8N_RUNNERS_ENABLED: "true"
      EXECUTIONS_TIMEOUT: 300
      EXECUTIONS_DATA_PRUNE: "true"
      EXECUTIONS_DATA_MAX_AGE: 168
      N8N_CONCURRENCY_PRODUCTION_LIMIT: 10
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres

volumes:
  pg_data:
  n8n_data:

Three settings matter more than they look:

• N8N_ENCRYPTION_KEY — set it yourself. If you let n8n generate one and later lose the volume, every stored credential becomes unreadable.
• N8N_WEBHOOK_URL — the public URL n8n puts in webhook addresses. Older guides use WEBHOOK_URL, which n8n’s docs mark deprecated from 2.35.0.
• Pin the image tag. latest turns every restart into an unplanned upgrade.

3. Put TLS in front

Bind n8n to localhost (as above) and terminate HTTPS with a reverse proxy. With Caddy, the whole config is:

flows.example.com {
    reverse_proxy 127.0.0.1:5678
}

4. Build the workflow with an authenticated webhook

Create a Webhook node with Header Auth so random traffic can’t trigger paid steps. Callers send the secret in a header; the payload carries an idempotency key:

{
  "event": "lead.created",
  "idempotency_key": "lead_2026-09-19_8f21c",
  "lead": {
    "email": "ops@acme.co",
    "company": "Acme Logistics",
    "employees": 240,
    "message": "Need to automate carrier invoice reconciliation"
  }
}

5. Call the model with a strict output contract

Use an HTTP Request node against the Anthropic Messages API. A small model is the right call for classification:

{
  "model": "claude-haiku-4-5",
  "max_tokens": 300,
  "system": "Classify inbound B2B leads. Reply with JSON only: {\"segment\": \"smb|mid|enterprise\", \"intent\": \"high|medium|low\", \"route_to\": \"sales|support|nurture\"}",
  "messages": [
    { "role": "user", "content": "Company: Acme Logistics. Employees: 240. Message: Need to automate carrier invoice reconciliation" }
  ]
}

Headers: x-api-key: <your key>, anthropic-version: 2023-06-01, content-type: application/json. Parse the JSON reply in the next node and route anything that fails to parse to the error branch rather than guessing.

6. Wire the error path

Enable Retry On Fail on the HTTP Request and CRM nodes, then create a separate workflow that starts with an Error Trigger node and posts the failed execution’s ID to Slack. Success should be silent; only exceptions reach a human.

Unit economics and operational bottlenecks

Reference workload: 5 billable actions per run, one short LLM classification per run. Zapier prices are Professional tier, annual billing.

Monthly runs	Zapier tasks needed	Zapier Pro	n8n Cloud	n8n self-hosted (VPS only)
1,000	5,000	$89	€20 (Starter, 2,500 execs)	$14.99
10,000	50,000	$289	€50 (Pro, 10,000 execs)	$14.99
40,000	200,000	$769	€667 (Business, 40,000 execs)	$28.99 (4 vCPU / 16 GB)

The self-hosted column is the bill, not the cost. The honest comparison adds your time:

self-hosted monthly cost = VPS + (maintenance hours × loaded hourly rate) example: $14.99 + (2 h × $75) = $164.99/month

The hourly figures are an assumption — substitute your own. Run with them and three thresholds fall out:

• vs Zapier: $164.99 lands between Zapier’s 10k-task tier ($129) and 20k-task tier ($189). At 5 tasks per run, self-hosting starts winning around 2,000–4,000 runs a month.
• vs n8n Cloud Pro: €50 beats $164.99 outright. Up to 10,000 executions, Cloud is cheaper than self-hosting once your time is priced in.
• Past 10,000 executions: the next Cloud tier is €667 for 40,000. Self-hosting at ~$29 for the server plus the same maintenance hours wins decisively here — this is the real break-even.

LLM cost is small by comparison. Assume ~800 input + 150 output tokens per classification on claude-haiku-4-5 ($1 / $5 per million tokens):

(800 × $1 + 150 × $5) ÷ 1,000,000 = $0.00155 per run → 10,000 runs ≈ $15.50/month

That is roughly the same on every platform — the orchestration layer, not the model, drives the difference in this workload.

Failure mode 1: duplicate webhook deliveries

Symptom: a sender retries after a slow response, the workflow runs twice, and the lead gets two CRM records and two emails — and you pay for two model calls.

Fix: check idempotency_key against a store (a Postgres table or Redis set with a TTL) in the Parse & Filter stage, before any billable step. Respond to the webhook quickly and do slow work afterwards so senders stop retrying.

Failure mode 2: model rate limits during a burst

Symptom: a batch import fires hundreds of webhooks at once; the model API starts returning 429 (rate limited) or overloaded errors, and executions fail in a cluster.

Fix: turn on Retry On Fail with a wait between tries, cap parallel runs with N8N_CONCURRENCY_PRODUCTION_LIMIT, and let the Error Trigger workflow collect anything that still fails so it can be replayed — not silently dropped.

Failure mode 3: the server quietly fills its disk

Symptom: execution history grows until Postgres runs out of space; runs start failing weeks after launch, with nothing changed.

Fix: keep EXECUTIONS_DATA_PRUNE on with a sensible EXECUTIONS_DATA_MAX_AGE (168 hours above), add a disk-usage alert at 80%, and store large payloads outside n8n’s execution log.

30-minute deployment checklist

• Copy N8N_ENCRYPTION_KEY and the Postgres password into your password manager — not only onto the server
• Send the sample webhook twice with the same idempotency_key and confirm exactly one CRM record exists
• Break the model API key on purpose and confirm the Error Trigger alert arrives in Slack with the execution ID
• Schedule a nightly pg_dump off the server and test-restore it once