Self-hosted alternatives to Zapier and Make: n8n and Activepieces compared

The short answer

Pick n8n if the people who build automations are comfortable with a bit of code: it has more built-in integrations, Code nodes in JavaScript and Python, retries you can tune per node, and it ran our test in a third of Activepieces' memory. Its licence is not open source, though: you may run it for your own business, but not sell it to others as an automation service. Pick Activepieces if you want an MIT licence and a simpler builder for colleagues who do not code. It queues webhooks in Valkey, so a burst of calls is accepted at once and worked through afterwards. It needed about 1 GB of memory at rest and up to 2.1 GB under load.

Neither has a Swedish interface, single sign-on or shared workspaces for free, and neither comes close to the thousands of ready-made connectors Zapier and Make have.

What we tested

We installed both on the same fresh Melonslab VC-P Alloy (2 vCPU, 8 GB) with Debian 13, each under a user of its own, behind the same Caddy. n8n followed our guide n8n with rootless Podman step by step, and every step worked as written, including its update from 2.41.6 to the then current 2.43.4. We have no Activepieces guide, so we ran Activepieces' official image in the same pattern: a pod under its own user, Quadlet units, PostgreSQL, keys as Podman secrets and our Caddy in front (How we ran Activepieces has the files).

Activepieces was our first choice for the second tool, and self-hosting it turned out to be realistic: its GitHub page listed eight releases between 14 September and 12 October 2026, the last of them 0.92.3, and its documentation covers Docker, PostgreSQL and Redis setups for production.

Then we built the same four automations in both, against test services on the same server, so that no data left it:

• A, a lead form. A webhook receives JSON, the name and email are trimmed and lower-cased, the row goes into a PostgreSQL table, and an email goes to sales through a local test mail server, Mailpit.
• B, a poll. Every five minutes, a schedule reads a small local HTTP API and posts the number of open orders to a chat webhook, a local catcher that stands in for Slack or Teams.
• C, a branch with retries. An order over 100 goes to a stock endpoint that fails twice before it answers; a smaller one goes to a payment endpoint that always fails. Both steps retry, and when they give up, an error path posts an alert to the chat.
• D, an AI step. A support ticket goes to an OpenAI-style chat API, a local mock that answers like a language model, and the category comes back to the caller. No real AI service was used.

We then sent each tool 1,000 calls to flow A, rebooted the server, measured memory at rest and under load, invited a second user, checked what each keeps of past runs and flow versions, and backed up and restored Activepieces' database. The n8n guide's own backup and restore was tested when the guide was written.

Zapier and Make themselves were not tested. We did not sign up for either. What this page says about them comes from their own pricing pages, linked where we use them and read on 14 October 2026.

The numbers

Memory is the sum of each app's containers, measured with podman stats five to eight minutes after a reboot, with all four flows published; it moved by less than 5 MB over that time. The peak is the highest reading, sampled every few seconds, while the 1,000 calls ran. The setup time is how long the commands took to run, mostly downloading images, not the time you need to read and type them. The data is the size of each app's volumes after both load tests.

Setup

Both took under two minutes from useradd to a login page, and both ask the first visitor to create the owner account, which our setups do before Caddy shows the app to anyone.

• n8n follows its guide: three containers, an encryption key you generate and keep, and settings that switch off the usage data and update checks n8n sends by default. The guide creates the owner over an SSH tunnel. We installed the guide's pinned 2.41.6 and updated to 2.43.4 with its update step; the restart, with the download and n8n's database update, took about a minute and a half, and the flows kept working.
• Activepieces also starts with three containers: one image that holds the web server, the worker that runs flows and the code sandboxes, plus PostgreSQL and Valkey for its queue. Its own Compose file uses a PostgreSQL image with pgvector, and without it, Activepieces skips the tables for its AI knowledge bases, so we used that image. After the first account, sign-up is closed: a second sign-up answered User is not invited to the platform.

Building the flows

We built all four flows in each tool from the same written description, through each tool's API, so our times say little about building them by hand in the editor, and we did not time that. What we can compare is how many steps each needed and what each step could do.

• A, the lead form. n8n needed four nodes: Webhook, Edit Fields with expressions such as {{ $json.body.email.trim().toLowerCase() }}, Postgres and Send Email. In Activepieces, expressions only fill in values, so the clean-up took a Code step, and answering the caller with a result took a Return Response step at the end, five steps in all. Both worked at the first run.
• B, the poll. Three steps in both: a schedule, an HTTP request and a post to the chat. Both kept posting every five minutes, also after the reboot.
• C, the branch. n8n's If node splits the flow, and each HTTP node's On Error setting can send failures down a separate error output. Both error outputs led to the same alert node: six nodes. Activepieces' Router has a branch per condition, and each step with Continue on Failure gets its own success and failure branches. Each branch needs its own steps, so the flow took nine.
• D, the AI step. n8n's OpenAI node takes a base URL in its credential, so we pointed it at our local mock and it worked as it would against OpenAI. Activepieces' OpenAI piece only asks for an API key, so we called the mock with a plain HTTP step and returned the answer. Activepieces also has a general AI piece that uses providers an admin sets up; we did not test it.

Activepieces' SMTP piece only offers ports 25, 465, 587 and 2525, so our test mail server needed one of those. That is no problem with a real email provider on 587.

Speed and load

We sent 1,000 calls to flow A in each tool, ten at a time, from the server itself through Caddy. Each call wrote a row and sent an email, and every one of the 2,000 rows and emails arrived.

• Waiting for the result, which is what a form does when it shows the visitor a reference number, both handled about 8 calls a second. The two vCPUs were the limit: the load average rose above 2 in both tests. One call at a time took about a quarter of a second in both.
• Answering at once is how most webhooks work: the caller gets an OK, and the flow runs afterwards. n8n, in the regular mode our guide uses, runs each flow in the same process that takes the calls, so the calls were no faster: 127 seconds for all of them, with every flow done when the last call returned. Activepieces puts each call on its queue in Valkey and answers right away: it accepted all 1,000 in 13 seconds, with a median answer of 0.12 seconds, and its worker finished the last flow 181 seconds after the first call.

For a burst of calls, such as a newsletter's links or a webshop's order hooks, Activepieces' queue answers the caller faster. When the result matters, both were equally fast on this server.

Queues and workers for more load

n8n has a queue mode: the main process takes webhooks and schedules and puts the runs on Redis, and separate worker processes run them. n8n's editions page says queue mode is included in the free Community edition, while several main processes for high availability need Enterprise. The pricing page lists queue mode under the paid Business plan; we read that as a difference between the two pages. Our guide does not use queue mode, and we did not test it.

Activepieces always has a queue. One container can run both parts, as ours did, or you can run more containers with AP_CONTAINER_TYPE=WORKER next to the main one, as its own Compose file does with five workers. Each worker runs five flows at a time by default. We set that to two to see whether it saved memory: it used about 950 MB instead of 1.03 GB and handled about half as many calls a second, so we went back to the default.

On a 2-vCPU server, more workers will not make either faster; more processors will.

Errors and retries

Flow C showed how each tool retries and what happens when it gives up.

• n8n retries per node with Retry On Fail, and you set Max Tries and Wait Between Tries. With three tries and a second between them, the stock endpoint answered at the third try, and the order that always failed reached the error output after three tries, about two seconds in all. The alert carried the HTTP error: 500 - "{"error": "always fails"}". n8n also has an Error Trigger for a workflow that runs when others fail; we did not use it.
• Activepieces has a Retry on Failure switch per step, with no settings. Our order that succeeded at the third try took 13 seconds, and the one that always failed took 29 seconds before its failure branch posted the alert. That fits what the engine's source code says: four tries, with waits that double each time. The HTTP piece also has its own setting, with three quick tries and no wait. Runs that end in the failure branch count as succeeded in the run list.

Run history and logs

Both list every run with its status, and show what each step got in and gave out.

• n8n keeps runs for 14 days or up to 10,000 runs by default, the values its settings showed us. After our tests, its database held 2,038 runs in 82 MB, and a dump of it was 1 MB.
• Activepieces keeps runs for 30 days by default, set with AP_EXECUTION_DATA_RETENTION_DAYS. Each run also shows how long it waited in the queue and how long it ran. It keeps more per run: after about the same number of runs, its database was 470 MB and a dump 112 MB.

Credentials

Both encrypt the passwords and keys you save for other services, with a key you hold. In both databases, our PostgreSQL and SMTP passwords were stored encrypted, not as text. Lose the key, and a backup of the database no longer opens them: back the key up with the database.

• n8n encrypts with N8N_ENCRYPTION_KEY, which our guide generates as a Podman secret. Code nodes cannot read it: our guide tested that.
• Activepieces encrypts connections with AP_ENCRYPTION_KEY. We ran Code steps in SANDBOX_CODE_ONLY mode, which runs them in an isolated V8 context; there, process was not defined and require did not exist, so code could not read the environment. Activepieces' default, UNSANDBOXED, does not isolate code, and its documentation advises against it.

In both, flows could reach our test services on the server, at host.containers.internal. Activepieces can block private addresses for code with AP_NETWORK_MODE=STRICT; we did not test it, as it would also have blocked our test services. Fetching secrets from a vault such as HashiCorp's or OpenBao is paid in both.

Versions and export

• n8n keeps a flow's earlier versions for 24 hours in the free edition, as its settings showed. Every workflow can be downloaded or copied as JSON and pasted into another n8n, which is how our n8n guide hands out its examples, and the n8n export:workflow command exports them all. Version control with Git is in the paid Business plan.
• Activepieces keeps every published version of a flow: when we published flow A a second time, both versions were listed. Flows can be exported as JSON and imported again. Git sync is in its paid Ultimate plan.

For either, a nightly export to a Git repository with your own script is a few lines.

Users and permissions

We invited a second user, Erik, into each.

• n8n lets the owner invite any number of members for free. Each member sees only their own workflows and credentials: sharing them is paid, and so is the admin role. Inviting Erik as an admin answered Cannot invite admin user without advanced permissions. Please upgrade to a license that includes this feature.
• Activepieces invited Erik as a member, and gave him a project of his own. He could not see Anna's flows: No role found for the user. Shared projects with roles are paid. With SMTP set, the invite arrived by email; without it, you copy the invite link yourself.

So in both free versions, several people can build flows side by side, but not in the same workspace.

Sign-in and single sign-on

We tested passwords in both. Neither has single sign-on for free: n8n has SAML and LDAP in its Business plan, and Activepieces has SSO from its Team plan in the cloud, according to their pricing pages.

Swedish

Neither has a Swedish interface. n8n's editor is in English; its documentation describes N8N_DEFAULT_LOCALE for other languages, and the 2.43.4 image held English and Spanish. Activepieces comes in 11 languages, among them German, French and Dutch. In both, your flows, emails and messages are in whatever language you write them.

Integrations and code

• n8n's integrations page listed 2,366 integrations on 14 October 2026; our install had 842 node types built in, triggers and helper nodes included. More come as community nodes from npm. The HTTP Request node covers any service with an API, and Code nodes run JavaScript or Python in the separate runner container.
• Activepieces' pricing page says "760+ integrations", and our install listed 768 pieces. Pieces are npm packages that Activepieces downloads the first time a flow uses one. Code steps run JavaScript or TypeScript; npm packages in Code steps need the sandbox mode that requires a privileged container, according to its sandboxing documentation.

At start, Activepieces fetched its list of pieces from Activepieces' cloud, its log said. AP_PIECES_SYNC_MODE=NONE switches that off, which we did not test. Our n8n guide switches off n8n's connections to n8n's servers and lists them.

Resources

n8n is one Node.js process at about 316 MB at rest, plus PostgreSQL and a small code runner. Under 1,000 calls, it peaked at 660 MB.

Activepieces runs more processes in its container: the web server at about 430 MB, the worker at about 225 MB and four warm code sandboxes of about 155 MB each, which together made its 1.03 GB at rest. Under load, it peaked at 2.13 GB.

Both together, at their peaks, used less than 3 GB of our 8 GB server.

Updates and backups

n8n pins its version, and its guide updates by changing the tag after a backup; n8n publishes a minor version most weeks. Activepieces released eight versions in the month before our test. We pinned 0.92.3 and did not test an update, which is a new tag and a restart; it updates its database when it starts.

Backing up n8n is its guide's script: a database dump and the encryption key. For Activepieces, we dumped the database and saved the three secrets, dropped and recreated the database, and restored the dump: the flows and both connections came back, and flow A wrote a row and sent an email again. Both came back by themselves about a minute after a reboot, and the five-minute flows kept running.

How we ran Activepieces

Activepieces' Docker documentation starts with a single container and an embedded database, and says that setup cannot scale. For production it points to PostgreSQL and Redis, as in its Compose file. We kept that, with Valkey for Redis and one container for the web server and worker. Two things we learned:

• If you restart the app while it is still starting, a lock it takes in Valkey can be left behind, and the next start waits until it runs out, about ten minutes, while the log shows only Socket.IO connection error. Wait, or remove it with podman exec activepieces-valkey valkey-cli del database-migration-lock. A few of those errors are normal in the first 20 seconds of every start.
• The SANDBOX_CODE_ONLY mode works in rootless Podman. The modes that isolate whole processes need a privileged container.

As a user activepieces, created like n8n in step 1 of the n8n guide, create the secrets:

openssl rand -hex 16 | tr -d '\n' | podman secret create ap-encryption-key -
openssl rand -hex 32 | tr -d '\n' | podman secret create ap-jwt-secret -
openssl rand -hex 24 | tr -d '\n' | podman secret create ap-db-password -
printf %s 'your-smtp-password' | podman secret create ap-smtp-password -

~/.config/containers/systemd/activepieces.pod:

[Pod]
PodName=activepieces
PublishPort=127.0.0.1:8137:80
AddHost=flows.example.com:host-gateway

[Install]
WantedBy=default.target

activepieces-db.container:

[Container]
ContainerName=activepieces-db
Image=docker.io/pgvector/pgvector:pg18
Pod=activepieces.pod
Volume=activepieces-db:/var/lib/postgresql
Environment=POSTGRES_USER=activepieces POSTGRES_DB=activepieces
Secret=ap-db-password,type=env,target=POSTGRES_PASSWORD
HealthCmd=pg_isready -U activepieces
HealthInterval=10s
Notify=healthy
AutoUpdate=registry

[Service]
Restart=always
TimeoutStartSec=300

activepieces-valkey.container:

[Container]
ContainerName=activepieces-valkey
Image=docker.io/valkey/valkey:9-alpine
Pod=activepieces.pod
Volume=activepieces-valkey:/data
AutoUpdate=registry

[Service]
Restart=always

activepieces-app.container:

[Unit]
Requires=activepieces-db.service activepieces-valkey.service
After=activepieces-db.service activepieces-valkey.service

[Container]
ContainerName=activepieces-app
Image=ghcr.io/activepieces/activepieces:0.92.3
Pod=activepieces.pod
Volume=activepieces-cache:/usr/src/app/cache
Environment=AP_FRONTEND_URL=https://flows.example.com AP_ENVIRONMENT=prod
Environment=AP_POSTGRES_HOST=127.0.0.1 AP_POSTGRES_PORT=5432 AP_POSTGRES_DATABASE=activepieces AP_POSTGRES_USERNAME=activepieces
Environment=AP_REDIS_HOST=127.0.0.1 AP_REDIS_PORT=6379
Environment=AP_EXECUTION_MODE=SANDBOX_CODE_ONLY
Environment=AP_TELEMETRY_ENABLED=false
Environment=AP_ENGINE_EXECUTABLE_PATH=dist/packages/engine/main.js
Environment=TZ=Europe/Stockholm
Environment=AP_SMTP_HOST=smtp.example.com AP_SMTP_PORT=587 AP_SMTP_USERNAME=flows@example.com AP_SMTP_SENDER_EMAIL=flows@example.com AP_SMTP_SENDER_NAME=Activepieces
Secret=ap-smtp-password,type=env,target=AP_SMTP_PASSWORD
Secret=ap-db-password,type=env,target=AP_POSTGRES_PASSWORD
Secret=ap-encryption-key,type=env,target=AP_ENCRYPTION_KEY
Secret=ap-jwt-secret,type=env,target=AP_JWT_SECRET

[Service]
Restart=always
TimeoutStartSec=900

Run systemctl --user daemon-reload and systemctl --user start activepieces-pod. It is ready when curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8137/api/v1/flags prints 200. Before Caddy shows it to anyone, create the first account, which becomes the admin, on the server:

curl -s -X POST http://127.0.0.1:8137/api/v1/authentication/sign-up -H 'content-type: application/json' \
  -d '{"email":"anna@example.com","password":"a-long-password","firstName":"Anna","lastName":"Berg","newsLetter":false,"trackEvents":false}'

Then add the block to Caddy's ~/Caddyfile and restart Caddy:

flows.example.com {
    reverse_proxy 127.0.0.1:8137
}

Webhooks are at https://flows.example.com/api/v1/webhooks/<flow id>, with /sync at the end to wait for the flow's answer. The email settings are for invites and password resets; we tested them against a local test mail server, not a real email provider. To back up, run podman exec activepieces-db pg_dump -U activepieces -Fc activepieces > activepieces-db.dump and save the secrets with podman secret inspect --showsecret --format '{{.SecretData}}' ap-encryption-key and the same for the other three. To restore, create the secrets, start the pod, stop activepieces-app, drop and create the activepieces database, run pg_restore -U activepieces -d activepieces --no-owner with the dump, and start activepieces-app again.

Licence and cost

We read the licence texts and pricing pages on 14 October 2026.

• n8n is made by n8n GmbH in Berlin, Germany, under its own Sustainable Use License, which is source-available, not an open-source licence. Its key line: "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." Files with .ee in their names, the enterprise features, need a paid licence. n8n's licence FAQ spells out what that means for a company:
  • Allowed: running n8n to run your business; building automations for clients on your own n8n, and charging for building, setting up and maintaining them, as long as the clients cannot create or edit them; using n8n behind the scenes in your own product, where users trigger flows you built and even connect their own accounts; running several instances.
  • Not allowed: hosting n8n as a service where clients build workflows; letting outside users build or configure their own workflows through your product, "whether via a custom UI, our API, MCP, or an AI agent"; forking n8n into your own automation product; white-labelling it; using the enterprise features without a licence.
  • n8n's test, in its words: "is n8n the thing being sold, or is it a tool that supports something else being sold?" For unclear cases it asks you to write to license@n8n.io.
  • The free Community edition lacks, according to n8n's editions page: sharing workflows and credentials, projects, single sign-on with SAML or LDAP, Git version control and environments, external secrets, log streaming, custom variables and several main processes. The self-hosted Business plan, on the pricing page, costs 667 euros a month billed yearly, with 40,000 runs a month, SSO, LDAP, Git, environments and 6 shared projects; Enterprise is priced on request.
• Activepieces is made by Activepieces Inc. in the United States. Its licence file puts everything outside its ee folders under the MIT licence, so you may use, change, host and even sell it; the ee parts need a commercial licence. The free Community edition we ran lacks shared projects and roles, single sign-on, API keys, audit logs, Git sync, secret managers and custom branding; the platform settings in our install showed all of them switched off. Its pricing page prices runs, not steps: "A run is one credit however many steps it has." In the cloud, Free has 1,000 credits a month, Plus costs 20 US dollars a month for 10,000 and Team 200 dollars for 50,000, 25 users and SSO. Ultimate, in the cloud or on your own servers, and Enterprise control, self-hosted or air-gapped, are priced on request, and Embed, for putting the builder in your own product, starts at 36,000 dollars a year.

For a company automating its own work, both free versions allow it at no cost, and on your own server the data stays in Sweden. If you want to offer automation to your customers as a product, n8n's licence does not allow it without an agreement with n8n; Activepieces' MIT licence does.

Zapier and Make today

What follows is from Zapier's and Make's own pricing pages, read on 14 October 2026, not from our tests.

Zapier, according to its pricing page, bills per task: each action that completes counts, while triggers, failed steps and its built-in tools such as Formatter, Filter and Paths do not. Free has 100 tasks a month, two-step Zaps only and a check for new data every 15 minutes. Professional costs 29.99 US dollars a month, or 19.99 billed yearly, for 750 tasks, with multi-step Zaps and checks every 2 minutes. Team costs 103.50 dollars a month, or 69 billed yearly, for 2,000 tasks, 25 users, checks every minute and SAML single sign-on. Both have tiers up to 2 million tasks, and Enterprise is priced on request, with SCIM and a yearly task limit. Its app directory says it connects 9,000+ apps.

Make has billed in credits since 27 August 2025, according to its pricing page: most module actions cost one credit, and its routers and error handlers none. Free has 1,000 credits a month, 2 active scenarios, a 15-minute minimum interval, runs of at most 5 minutes and 7 days of execution logs. For 10,000 credits a month, the page showed Core at 9 US dollars a month, Pro at 16 and Teams at 29, marked "Save 15%" for yearly billing, all with a 1-minute interval, runs of up to 40 minutes and 30 days of logs. Teams adds team roles; single sign-on, audit logs and 60 days of logs are in Enterprise, priced on request. Make runs on AWS in the EU or North America, and says it has 3,500+ apps.

Both are hosted services only, and every step or run costs credits: our load test of 1,000 calls to a four-step flow would have used about 2,000 Zapier tasks, as its Formatter step is free, and about 4,000 Make credits, by their own counting rules.

What you give up compared with Zapier and Make

Moving to your own server keeps the data your automations handle in Sweden, costs a fixed server price however many runs you have, and lets flows reach systems that never face the internet. But be honest about what you leave behind:

• The connectors. Zapier lists over 9,000 apps and Make over 3,500, many of them maintained with the vendor. n8n has hundreds and Activepieces 768 built in. For anything else, you read the service's API documentation and build HTTP requests yourself.
• No maintenance. Updates, backups, the server and its security are yours. n8n publishes a version most weeks and Activepieces about two a week; someone has to follow them.
• OAuth sign-in to other services. Zapier and Make come with their own registered apps for Google, Microsoft and others. On your own server, you often register an OAuth app with each service yourself before you can connect it.
• Teams. Shared workspaces, roles and single sign-on are free in neither of the self-hosted tools, while Zapier's Team and Make's Teams plans include roles.
• Help. Zapier and Make have support teams. For the free versions of n8n and Activepieces, you have forums and documentation.

Which one to pick

For most companies automating their own work: n8n. It has the most built-in integrations of the two, Code nodes in JavaScript and Python, retries you tune per node, a 24-hour flow history, and it used about 330 MB at rest and 660 MB under our load. Its weak points are a licence that is not open source and forbids offering n8n to others as an automation service, sharing, admins, SSO and Git only on paid plans, no Swedish, and webhooks that are not queued in our guide's setup. Follow the n8n guide, on a VC-P Alloy.

For an MIT licence, or a product of your own: Activepieces. It is the one to choose if your customers should build their own flows, or if a simple, step-by-step builder suits your colleagues better. It accepted a burst of 1,000 webhooks in 13 seconds, keeps every published version and 30 days of runs, and isolates code in a sandbox without a privileged container. Its weak points are about 1 GB of memory at rest and 2.1 GB under load, retries you cannot tune, no Python, no Swedish, fewer integrations, shared projects and SSO only on paid plans, a large run history in the database, a fast release pace, and no guide of ours yet: the files in How we ran Activepieces are what we ran, on top of the Podman guide. A VC-P Alloy suits it too.

Together they used under 3 GB at their peaks, so one VC-P Alloy runs both, as ours did.