Windmill vs Zapier
Eight questions teams ask when they outgrow a no-code automation tool, with an honest answer on each one for where Windmill or Zapier is the better pick.
- 01What you can buildWhich solution fits for your specific use case
- 02TargetWho the platform is built for
- 03Build experienceHow you build on each platform
- 04IntegrationsHow the platform integrates with your existing stack
- 05Migration & lock-inHow hard to get in, how hard to get out
- 06Enterprise requirementsAudit logs, observability, security, performance
- 07Licensing & pricingOpen source, pricing, self-hosting
- 08VerdictThe verdict
Windmill in one sentenceAn open-source workflow engine and developer platform to build and orchestrate all your internal software: scripts, workflows, data pipelines, AI agents and internal apps. Made for engineers who want full code flexibility and local dev experience, both to build internal software and to manage the underlying infrastructure.
Zapier in one sentenceThe no-code automation standard: a hosted service that connects more than 10,000 apps through triggers and actions you configure in a form, billed per task. Best for business teams who need a SaaS-to-SaaS automation live this afternoon without involving an engineer.
Which internal software can you build and orchestrate?
Windmill is built to centralize and orchestrate all your internal software in one place. Scripts, workflows, data pipelines, full-code apps, AI agents and operator UIs run on a single runtime, with shared resources, auth and observability. Zapier covers SaaS-to-SaaS automation extremely well, with Tables, Forms, Chatbots and Agents around it, and bills one task per successful action, which is what makes high-row-count jobs an awkward fit.
| Primitive | Windmill | Zapier |
|---|---|---|
Chain steps with branching, retries and approval steps | ||
Cron jobs with retries, error handling and alerting | ||
Standalone functions exposed as APIs, webhooks or cron jobs without a wrapping workflow | ||
ETL, syncs and scheduled data jobs over large row counts | Per-task billing | |
Agents that call tools, branch on outputs and run as workflow steps | ||
Isolated environments with persistent volumes for running coding agents | ||
Drag-and-drop dashboards and admin tools with built-in components | Tables & Forms | |
Custom dashboards and admin tools built in React or Svelte | ||
Run the whole platform on your own infrastructure |
Zapier does ship data and UI primitives around the Zap: Tables, Forms, Chatbots, Canvas and Agents are all listed on its pricing page, with record and page caps per plan. They are purpose-built surfaces rather than a general app builder: there is no documented way to write the UI yourself in React or Svelte, as there is with the Windmill app builder.
Who is each platform built for?
Zapier is built so that a non-developer can ship an automation without asking anyone, and it is very good at that. Windmill is built for developer-led teams who want automations to live in the same place as the rest of their code, with review, versioning and ownership attached.
WindmillZapierPrimary audience
WindmillDeveloper-led teams. Engineers own the platform end-to-end: code, Git, local dev, workspace forks, code review, CI/CD, AI coding tools, infrastructure as code. Non-developers consume the result through auto-generated UIs, apps and run-only workspace roles.
ZapierAnyone in the business. Picking a trigger and an action from the app directory and mapping fields in a form needs no engineer, no infrastructure and no deploy. For a two-app automation this is genuinely the fastest path of the two, and it is the reason Zapier is the default in most companies.
Working as a team
WindmillEverything the platform manages can be a file in Git, so the usual team mechanics apply: branches, pull requests, review, rollback. Permissions run through RBAC, groups and folders. Self-hosted Community Edition allows up to 50 users and a maximum of 4 groups; unlimited groups and granular permissions are Enterprise only.
ZapierSharing is a plan boundary. Per the pricing page, Free and Professional are single-seat; shared Zaps, shared folders, shared app connections and folder permissions start on Team plan, which includes 25 seats. Unlimited seats, role-based admin permissions and app access controls are Enterprise only.
Who ends up maintaining it
WindmillThe same people who maintain the rest of your code. An automation is a script with tests, a diff and an owner, which is why it survives the author leaving.
ZapierWhoever built it, usually in the tool itself. Zapier keeps version history (one month on Professional, six months on Team) and Enterprise adds version comparison, but a Zap is edited in the Zap editor rather than reviewed as a diff.
How do you build on each platform?
Zapier is form-first: you configure a Zap, and code is an escape hatch with a plan-dependent runtime and a fixed 512 MB of memory. Windmill is code-first: the step is the code, in a real runtime you size, with a local dev loop, package imports and whole-workspace Git sync. As AI writes more of the automation, that difference turns practical: a diff in a Python file is reviewable, testable and revertible in a way a changed field mapping is not.
Building on WindmillOn Windmill, every step of a flow is a script. Compose them visually as a DAG with branches, loops and approval steps, in any of the 20+ supported languages.
WindmillZapierAuthoring
WindmillWrite scripts in 20+ languages in a dedicated script editor. Windmill parses the function signature to generate the input UI, the JSON schema and the argument types. Each script is a standalone primitive with its own UI, API endpoint and scheduler, no wrapper required. Flows compose scripts either visually in the flow editor or in full code with workflows as code in Python or TypeScript.
ZapierBuild a Zap in the editor by choosing a trigger, then actions, then mapping fields between them in forms. Free plans are limited to two-step Zaps; multi-step Zaps, filters, paths and Formatter start on Professional. Code is the exception rather than the medium: a Code by Zapier step runs a JavaScript or Python snippet inside one action.
Code steps and their limits
WindmillThere is no distinction between a code step and a normal step: every step is code, running in a real runtime on a worker you size. Timeouts, memory and concurrency are your configuration, not a plan tier. Long-running jobs, heavy dependencies and native extensions are ordinary cases.
ZapierJavaScript (Node.js 22) and Python 3.13 only, with 512 MB of memory on every plan. Standard runtime is 1 second on Free, 30 seconds on Professional and Team and 2 minutes on Enterprise, extendable to 10 minutes on paid plans. Code steps are rate limited to 10 requests per 60 seconds on Free and 225 per 10 seconds on paid plans.
Local dev & IDE
WindmillRun and test scripts locally with the Windmill CLI. VS Code extension, native language tooling (LSP, type-checking, linting) and AI coding tools such as Claude Code and Codex work against real source files.
ZapierAuthoring happens in the browser. Zapier does publish a Platform CLI for building integrations locally in TypeScript or Node.js, with version control and automated tests, but that is for publishing an app to the directory rather than for developing the Zaps your team runs.
Dependencies
WindmillAny npm, PyPI, Go, Maven or Cargo package is a first-class import. Windmill detects the import, resolves the version and pins it in a per-script lockfile, with no install step and no restart. Private PyPI and npm registries are Enterprise only.
ZapierPaid plans can add npm and PyPI packages to a Code step from a Packages sidebar, optionally pinned to a version. Public registries only, ESM JavaScript packages only, no native modules, and install time is capped at 30 seconds on paid plans and 120 seconds on Enterprise.
Resources & secrets
WindmillZapierApp connections are held and refreshed by Zapier, which is a real convenience: you authorize once through OAuth and never handle the token. Sharing connections across a team starts on Team plan, and managed app connections plus app and action access controls are Enterprise only.
Git & CI
WindmillScripts, flows, apps, resources, variables, schedules, folders, groups and permissions are all files in Git, deployed through the CLI and Git sync. Internal tooling runs like application code: pull requests, reviews, rollbacks, CI/CD. Git sync is free for up to 2 users; beyond that is Enterprise only.
ZapierNo Git sync for Zaps. Change management is in-product version history, one month on Professional and six months on Team, with version comparison and approval requests on Enterprise only. Promoting a Zap between a staging and a production environment is not a documented workflow.
AI while authoring
WindmillBecause every script and flow is a real file, coding agents operate on them directly, and what they produce lands in a pull request like any other change. Windmill also has an in-product AI builder for generating and editing scripts and flows.
ZapierCopilot turns a plain-language description into a trigger-and-action outline and can suggest field values, including mapped fields from earlier steps. It offers an auto-build mode and an ask-as-you-build mode, and the help center still labels it a beta. Copilot has a daily message limit on Free and is unlimited on paid plans.
WindmillThe logic is an ordinary Python function in a file. Windmill reads the signature to generate the input form, the JSON schema and the webhook contract, resolves requests into a per-script lockfile, and runs the same file locally through the CLI. The flow definition only wires steps together: the step code lives on its own and can run as a standalone API endpoint or a scheduled job without any flow around it.
- large_charges.py
- flow.yaml
import requests
import wmill
def main(customer_id: str, min_amount: float = 500.0):
api = wmill.get_resource("f/billing/internal_api")
account = requests.get(
f"{api['base_url']}/accounts/{customer_id}",
headers={"Authorization": f"Bearer {api['token']}"},
timeout=30,
).json()
charges = [c for c in account["charges"] if c["amount"] >= min_amount]
if not charges:
return {"notified": False, "charges": []}
return {
"notified": True,
"owner_email": account["owner_email"],
"charges": charges,
}
summary: Notify the account owner about large charges
value:
modules:
- id: large_charges
value:
type: script
path: f/billing/large_charges
input_transforms:
customer_id:
type: javascript
expr: flow_input.customer_id
- id: notify
skip_if:
expr: "!results.large_charges.notified"
value:
type: script
path: f/slack/post_message
input_transforms:
email:
type: javascript
expr: results.large_charges.owner_email
Most of the Zap is configuration rather than code: a trigger and actions picked from the app directory, with fields mapped in the Zap editor. Where no action fits, Code by Zapier runs a JavaScript (Node.js 22) or Python 3.13 snippet as one action step. Inputs arrive in an input_data dictionary you map in the form, and the step returns a single output object.
- Code by Zapier (Python)
- Zap structure
# Code by Zapier, "Run Python" action step.
# Values from earlier steps are mapped into input_data in the step's form.
import requests
customer_id = input_data['customer_id']
min_amount = float(input_data['min_amount'])
account = requests.get(
'https://api.internal.example.com/accounts/' + customer_id,
headers={'Authorization': 'Bearer ' + input_data['token']},
).json()
charges = [c for c in account['charges'] if c['amount'] >= min_amount]
# A Code step returns a single output object.
return {'owner_email': account['owner_email'], 'charge_count': len(charges)}
1. Trigger New Charge in Stripe
polled every 15 min (Free), 2 min (Professional), 1 min (Team)
triggers never consume tasks
2. Filter Only continue if Amount is greater than 500
filters and paths consume no tasks
3. Code Run Python, fields mapped into input_data
standard runtime 1s (Free), 30s (Pro and Team), 2 min (Enterprise)
1 task per successful run
4. Action Send Channel Message in Slack
1 task per successful run
How does the platform integrate with your existing stack?
Zapier has the catalog: more than 10,000 apps with maintained triggers and actions and credentials it manages for you, which no code-first platform can match on breadth. Windmill trades the catalog for the package ecosystems: any npm, PyPI, Go or Maven library is an import away, so the integration you need is whatever the vendor publishes an SDK for.
Adding an integration on WindmillType import stripe in the script editor and run. Windmill detects the import, resolves the version and pins it in a per-script lockfile. No venv, no install step, no restart: a new integration is a new import.
WindmillZapierConnecting out
WindmillAny npm, PyPI, Go or Maven package is a first-class import with automatic dependency resolution and no plugin layer in between: you call the vendor's real SDK with full type inference in the editor. 50+ pre-built resource types cover common databases (Postgres, Snowflake, BigQuery), SaaS (Slack, Stripe, GitHub, Notion, OpenAI) and infrastructure (S3, Redis, Kafka). A community Hub holds reusable scripts and flows.
ZapierThis is where Zapier wins outright. More than 10,000 apps are in the directory, each with maintained triggers, actions and searches, and Zapier manages the credentials. Unlimited premium apps start on Professional. Nothing in a code-first platform matches the time-to-first-working-automation on a long-tail SaaS tool that Zapier already supports.
Receiving events
WindmillNative triggers for HTTP, cron, Kafka, NATS, Postgres CDC, SQS, MQTT, SMTP, WebSocket, GCP Pub/Sub and Azure Event Grid. Every script and flow also gets an HTTP endpoint and a webhook URL for free. Postgres, WebSocket and MQTT triggers are self-hosted; Kafka, NATS, SQS, GCP and Azure triggers are Enterprise only.
ZapierApp triggers are mostly polled, on a plan-dependent interval: every 15 minutes on Free, 2 minutes on Professional and 1 minute on Team and Enterprise. Apps that support it can trigger instantly, and Webhooks by Zapier covers raw HTTP from Professional up. Triggers never consume tasks, including polling checks.
Extending
WindmillA new integration is a script with a new import: save and run, no restart and no image rebuild, in the web editor, the CLI or Git sync. Custom logic can be exposed as a typed script, packaged as a resource type for shared use, or published to a private workspace Hub (Enterprise only).
ZapierThree routes. A Code step for one-off logic inside a Zap. Webhooks by Zapier for raw HTTP against anything, though the help center suggests building a proper app once you need more than two HTTP requests or authenticated requests. Or build a full integration on the Zapier Platform, in the browser-based visual editor or locally with the TypeScript and Node.js CLI.
AI clients and MCP
WindmillWindmill works in both directions. It acts as an MCP server so Claude, Cursor or any MCP client can trigger your scripts and flows and inspect jobs, resources, variables, schedules and workers. It is also an MCP client: an AI session or an agent step can use external MCP servers, or Windmill scripts, as tools, with the tool schema generated from each script's typed signature.
ZapierZapier MCP exposes the directory to AI clients, which the page puts at 9,000+ apps and 66,000+ triggers and actions, with credentials managed by Zapier and every MCP action logged in History. It is included in every plan, and each tool call uses two tasks. Enterprise IT can enable or disable MCP per workspace and set app and action-level access controls.
How hard to get in, and how hard to get out?
Zapier is far faster to get into, and that matters more than it sounds: a working automation this afternoon beats a better one next sprint. Windmill is far cheaper to get out of. Step logic is standard code that runs anywhere, the CLI exports the workspace as files, and the runtime itself is open source and self-hostable.
WindmillZapierGetting in
WindmillPaste a function body into the script editor: Windmill infers the arguments, generates a UI and handles the dependencies. There is no DSL to learn, but there is code to write, so the first automation takes longer than it would on Zapier. Triggers, schedules, variables and apps migrate one at a time.
ZapierMinutes, and no infrastructure. Pick the trigger, pick the action, map the fields, turn it on. For teams without engineering capacity this is decisive, and it is worth being blunt about: if your automation is two SaaS apps and a filter, Zapier will get you there first.
Getting out
WindmillStep logic is already standard code (TypeScript, Python, Go, Bash, SQL) that runs anywhere, and the CLI exports the whole workspace as plain files. What you lose by leaving Windmill is the runtime, not the step code. You can also keep the runtime and just move it: the core is AGPLv3 and self-hostable.
ZapierA Zap is configuration living in Zapier's service, edited in the Zap editor. The Platform CLI builds integrations for the directory, not exports of your Zaps, so a move means rebuilding each trigger, field mapping, filter and path on the new platform. What does port cleanly is whatever sits in Code steps, since that is plain Python or JavaScript.
The usual reason teams move
WindmillVolume, control or review. Per-task billing is predictable until an automation starts touching thousands of rows; a code-first platform on workers you own prices that differently. Teams also move when the automation becomes load-bearing enough to need tests, code review and an owner.
ZapierZapier is often the right place to stay. Low-volume, broad-catalog, non-developer automation is what it is built for, and replacing it with code you have to maintain is a real cost. The migration case is specific: high volume, logic that outgrew a Code step, or a requirement that the automation run on your own infrastructure.
Audit logs, observability, security, performance
Both cover the enterprise basics, and both paywall them: SAML SSO and audit logs start on Zapier's Team plan, while uncapped SSO, SAML, SCIM and the SOC 2 Type II report are Enterprise on Windmill. The structural difference is where the work runs. Zapier executes on Zapier's infrastructure with plan-tier limits on polling frequency, code runtime and memory. Windmill executes on workers you own and size, so latency and throughput are an infrastructure decision rather than a pricing one.
WindmillZapierObservability
WindmillReal-time streaming logs, per-run inputs, outputs and duration, and a trace ID on every job. Job run details are retained up to 30 days on self-hosted Community Edition and 60 days on cloud, unlimited on Enterprise. Queue metrics, Prometheus metrics, OpenTelemetry tracing and service logs on S3 are Enterprise only.
ZapierZap History shows every run and its data. Enterprise adds an Observability API, analytics, alerts and log streams that "send real-time workflow data to tools like Datadog or Splunk", plus custom data retention. On lower plans, observability is the history UI.
Audit logs
WindmillA full trail of who ran, edited and deployed what, with the actor, timestamp and payload. Cloud Team retains 7 days. Self-hosted Community Edition does not include audit logs, and unlimited retention is Enterprise only.
ZapierAn audit log with 6 months of retention on Team plan and 1 year on Enterprise only, which also exposes audit data through an API. Free and Professional have none.
Security & compliance
WindmillRBAC with groups and folders, SSO for up to 10 users, encrypted secrets at rest and sandboxed script execution in open source. Uncapped SSO, SAML and SCIM with group sync, custom OAuth, instance-level roles, service accounts and the SOC 2 Type II report are Enterprise only.
ZapierZapier's enterprise page lists "SOC 2 Type II, SOC 3, GDPR, and CCPA compliance", SSO, SCIM provisioning and domain capture, role-based permissions, granular app and action permissions, and VPC Peering to reach internal data sources. SAML SSO appears on Team plan; SCIM, Super Admin and app access controls are Enterprise only.
Isolation & tenancy
WindmillMultiple isolated workspaces on the same instance, each with their own users, resources, secrets and access controls, plus worker groups to pin sensitive jobs to specific machines. Self-hosted Community Edition is capped at 3 workspaces; unlimited is Enterprise only.
ZapierFolders and folder permissions organize Zaps from Team plan up, and separate workspaces are listed as an Enterprise only feature. Execution always happens on Zapier's infrastructure.
Performance & throughput
WindmillRoughly 10ms cold starts on a queue-based worker pool you scale yourself. Dedicated-worker mode keeps runtimes and dependencies pre-warmed, and concurrency limits cap how many jobs a script runs at once. Both ship on the cloud plans; on self-hosted they are Enterprise only, as are autoscaling and step priority. Otherwise throughput is a function of the hardware you give the workers.
ZapierLatency is bounded by the polling interval on most triggers (15 minutes down to 1 minute by plan) and by Code step limits: 512 MB of memory, 1 second to 2 minutes of standard runtime by plan, and code rate limits of 10 requests per 60 seconds on Free or 225 per 10 seconds on paid plans. Instant triggers and webhooks avoid the polling delay.
Open source, pricing, and self-hosting?
Windmill is open source at the core and free to self-host with unlimited executions, with published per-seat and per-compute pricing above that. Zapier is a hosted service billed per successful action, which is the simpler proposition at low volume and the expensive one at high volume. Neither is fully open source: Windmill's Enterprise features live in a separate proprietary codebase.
WindmillZapierOpen source & self-hosting
WindmillAGPLv3 core, free to self-host with unlimited executions on Docker, Kubernetes or Fargate. Enterprise features (SSO beyond 10 users, dedicated workers, audit logs, external secret backends) ship in a separate proprietary codebase, so Windmill is not "fully" open source either. Managed cloud is available.
ZapierZapier is a hosted service: the pricing page lists cloud plans only, and the enterprise page describes VPC Peering for reaching internal data sources and Bring Your Own Model through AWS Bedrock rather than running Zapier yourself. The parts that are open to developers are the Platform UI and CLI for building integrations.
How you are billed
WindmillSeats plus compute. Self-hosted Community Edition is free and unmetered. Cloud Team is 10 USD per seat per month with 10,000 executions included per seat, capped at 10 seats. Enterprise is per seat plus compute units, where one compute unit is 2 worker-gb-month. Prices are published on the pricing page with a calculator, no sales call required.
ZapierPer task, defined as "any successful action that runs in Zapier". Triggers, filters, paths, Formatter and Delay consume none; a Code step is 1 task per run at standard runtime; each MCP tool call is 2 tasks; Agents are metered separately in activities. Free includes 100 tasks per month, Professional and Team price a monthly task allowance, and Enterprise is a custom annual limit quoted by sales.
What that means for cost
WindmillCost tracks the infrastructure and the team, not the volume of work. An automation that fans out over 100,000 rows costs the same as one that runs once a day, provided the workers can keep up.
ZapierCost tracks successful actions, which is predictable and cheap at low volume and the main reason teams eventually look elsewhere. It also makes the no-code convenience self-funding: you pay for the catalog and the managed credentials in the task price.
The verdict
Windmill and Zapier are not the same kind of product. Zapier models an automation as configuration: a trigger and actions chosen from a directory of more than 10,000 apps, with fields mapped in a form, running on Zapier's infrastructure and billed per successful action. Windmill models an automation as code: a script in TypeScript, Python, Go, Bash or SQL that is also a standalone API endpoint and scheduled job, with flows composing those scripts on workers you run.
Zapier is the right call if the people building the automations are not engineers, the integrations you need are in its directory, and the volume is low enough that per-task billing stays comfortable. The catalog and the managed credentials are real advantages, and the time from idea to working automation is genuinely shorter.
Windmill fits the cases Zapier is not shaped for. The step is real code in a real runtime, so timeouts, memory and dependencies are your configuration rather than a plan tier. Everything the platform manages can live in Git, which means pull requests, review and rollback. The same runtime also carries data pipelines, AI agents and both low-code and full-code internal apps, with shared resources, auth and observability. And because nothing meters individual steps, cost tracks the infrastructure and the team rather than the number of successful actions.
The AI question cuts in a specific direction. Both platforms now generate automations for you: Zapier Copilot drafts a Zap from a description, and coding agents write Windmill scripts directly. The difference is what you are left holding. A generated Python file can be read in a diff, tested, and reverted by commit. A generated set of field mappings is harder to review, and version history inside the tool is not the same thing as a repository. The more of the automation an agent writes, the more that matters.
If you are deciding between the two, the honest test is your own worst automation: take the Zap that has grown a Code step, a few paths and a comment nobody understands, and rebuild it on each. The fastest way to judge is to spend an afternoon in each.
Frequently asked questions
Build your internal platform on Windmill
Scripts, flows, apps, and infrastructure in one place.