Five n8n alternatives compared

People go looking for an n8n alternative for four reasons that keep coming up. The Sustainable Use License stops you from hosting n8n for paying customers or embedding it in a product. The team doesn't write JavaScript and finds the item model hard going. The team writes a lot of code and would rather have real Python and TypeScript files than a canvas. Or the automations run on a factory floor talking MQTT and n8n is the wrong shape for that. Each of the five tools below answers one of those, and none of them answers all four, which is why this isn't a ranking.

Zapier

Zapier is the hosted, no-code option with the widest catalogue. The pricing page claims over 9,000 app integrations, and for a marketing or sales team that's the number that matters, because the long tail of small SaaS tools tends to ship a Zapier integration before anything else. Billing is per task: each action step in a Zap consumes one, triggers and built-in tools like Filter and Formatter don't, and the Free plan gives 100 tasks a month with two-step Zaps only. Multi-step Zaps start on the Professional plan. There is no self-hosted version. Data goes through Zapier's infrastructure, and the Enterprise tier is where the compliance paperwork lives.

Pick Zapier when the automations are short glue between well-known SaaS apps and the people building them will never open a terminal. Skip it when a single Zap needs to loop over hundreds of records, because each of those loops is a task and the monthly count climbs faster than anyone budgets for. Zapier's pricing page lists the current plan limits, and the task definition is the paragraph to read twice.

Make

Make is the closest hosted equivalent to n8n's canvas, with routers, iterators and aggregators that let one scenario branch and loop the way an n8n workflow does. It bills in credits, one per module run per bundle, with a Free plan of 1,000 credits a month that caps you at two live scenarios and a schedule no tighter than every 15 minutes. The billing shape is the main thing separating it from n8n Cloud, which counts a whole workflow run as one execution, and the full breakdown is in the Make.com vs n8n comparison. Make has an on-prem agent for reaching apps behind a firewall, but the scenario engine itself never leaves Make's servers.

It suits non-developers who need branching and loops, and it gets expensive once workflows fan out across large batches, since credits are counted per bundle through every module.

Windmill

Windmill is the code-first option. A workflow is a set of scripts, each one a real file in Python, TypeScript, Go, Bash, SQL, GraphQL, PowerShell or Rust, and Windmill parses the script's signature to generate an input form for it. Scripts chain into flows, and flows can get a UI through Windmill's app builder. The core is AGPLv3 with some Apache 2 parts, the Community Edition is free for internal use and an Enterprise license is required to redistribute it or offer it as a managed service. Self-hosting is three files:

curl https://raw.githubusercontent.com/windmill-labs/windmill/main/docker-compose.yml -o docker-compose.yml
curl https://raw.githubusercontent.com/windmill-labs/windmill/main/Caddyfile -o Caddyfile
curl https://raw.githubusercontent.com/windmill-labs/windmill/main/.env -o .env
docker compose up -d

Postgres is mandatory, since it holds the whole state including the job queue, and the Windmill self-hosting docs give a sizing rule of one worker per vCPU with 1 to 2 GB of RAM each. The stack listens on port 80 through Caddy, and the first login is [email protected] with the password changeme, which you change before the server is reachable from anywhere else. Community Edition limits to know about: SSO capped at 10 users, job retention of 30 days or less, Git sync for up to 2 users, no audit logs and 10 GiB of object storage.

Windmill is for a team that already has the scripts and wants scheduling, retries, secrets and a UI around them without rewriting anything into nodes. It's also the strongest of the five for internal tools, since a script becomes a form and a flow becomes a small app. A team that doesn't code will not enjoy it; the canvas exists, but the scripts are the product.

Activepieces

Activepieces is the one to look at if the n8n license is the problem. The Community Edition is MIT, which means you can host it for customers, embed it and rebrand it without asking anyone, and the enterprise features (agents and chat, projects, API access, SSO, custom RBAC, audit logs, secret managers, branding, Git sync) sit behind a commercial license. The editor is a vertical flow rather than a free canvas, which non-developers find easier to read. Integrations are called pieces, they're TypeScript npm packages published on npmjs.com, about 60% are community contributed and the Activepieces repository counts 280+ of them, all of which are also exposed as MCP servers for use from Claude Desktop, Cursor or Windsurf.

The single-container install is one command:

docker run -d --name activepieces -p 8080:80 \
  -v ~/.activepieces:/root/.activepieces \
  -e AP_DB_TYPE=PGLITE \
  -e AP_REDIS_TYPE=MEMORY \
  -e AP_FRONTEND_URL="http://localhost:8080" \
  activepieces/activepieces:latest

That runs an embedded Postgres and an in-memory queue, and the docs are blunt that it cannot scale and cannot be migrated to the multi-container setup later, so treat it as an evaluation instance. The production install uses external Postgres and Redis from the start.

The obvious fit is a company building a product on top of an automation engine, or an agency that wants one instance per client without a licensing conversation. The integration count is a fraction of n8n's, so check the pieces list against the apps you need before committing.

Node-RED

Node-RED is older than all of the above and solves a different problem. It came out of IBM's emerging technology group as a way to wire hardware and MQTT topics to HTTP endpoints, and it lives under the OpenJS Foundation with an Apache 2.0 license. Flows are stored as JSON and the function node takes JavaScript. The editor runs on port 1880 after sudo npm install -g node-red and node-red, or from the nodered/node-red Docker image. Version 5.0 shipped on June 9, 2026 with a redesigned editor, a dark theme, a build moved from Grunt to npm scripts and a minimum of Node.js 22.9.0, and the Node-RED 5.0 release post recommends Node.js 24, which is what the official images use. Two things to plan for: the editor ships with no login until you set adminAuth in settings.js, and the catalogue is community nodes on npm with nothing like a curated SaaS integration library, so a Salesforce or HubSpot connector means finding a node someone else maintains or writing HTTP requests by hand.

Pick Node-RED for IoT, for home and industrial automation, for anything that speaks MQTT or serial and for dashboards over live device data. Skip it as a general SaaS integration tool, because that's the job n8n was built to do better.

Running any of these on your own server

Three of the five self-host, and all three ship as Docker images that fit on a small VPS with Postgres alongside. Windmill wants a worker per vCPU and Activepieces wants Postgres and Redis for anything past evaluation. Node-RED is happy with a single Node.js process. n8n itself needs the same treatment, and the guide to self-hosting n8n on a VPS covers the reverse proxy and the backup routine, and both apply almost unchanged to the other three.

Whichever tool you land on, a Docker VPS with Docker already installed gets you from an empty server to a first flow in a few minutes, and the security habits in the n8n security best practices guide (auth in front of the editor, secrets out of the compose file) carry over to Windmill and Activepieces with the variable names changed.