Open Source Pipedream Alternatives

n8n pairs a visual canvas with real code. You drag nodes to shape a workflow, then drop into JavaScript or Python where the visual metaphor stops paying off, which removes the usual choice between a no-code tool you outgrow and a script nobody else can maintain.

Workflows can run as multi-step agents that use your own data, models and tools. Providers are interchangeable, so moving between OpenAI, Anthropic, Google and open source models does not mean redrawing the architecture around them.

These are the capabilities that carry a workflow from prototype to something people depend on.

• Code inside the canvas: JavaScript, Python and npm packages sit next to the visual nodes.
• Human approvals: a flow pauses for a person before an agent takes a consequential step.
• Observability: runs are traceable across multi-step logic, which is what you want when an agent misbehaves overnight.
• Access control: role-based permissions and audit trails support sensitive data on self-hosted deployments.
• Existing building blocks: more than 1500 integrations and 9000 workflow templates cover the connective work.

An install script starts n8n with Docker, or you can run the container by hand and open the editor on port 5678, and a hosted cloud exists for anyone who prefers not to operate it. The source is always visible under a fair-code sustainable use license, with a separate enterprise license for additional features, and you can write your own nodes.

Activepieces is an open source replacement for Zapier, an automation tool whose defining choice is that its integrations, called pieces, are type-safe TypeScript packages published to npm rather than closed connectors. Roughly sixty percent of them come from the community, and all of the integration source code sits in the same repository.

Contributing a piece has a second effect, because every piece is automatically available as an MCP server for use with LLM clients such as Claude Desktop, Cursor and Windsurf. More than 280 pieces exist on that basis, and local piece development supports hot reloading on your own machine.

The flow builder targets developers and the colleagues who use what they build.

• Control flow: Loops, branches and automatic retries inside fully versioned flows.
• Code steps: Run code with npm packages, or ask AI to write a data cleaning step for a non-technical user.
• Human in the loop: Delay execution or require approval, both built as ordinary pieces on the framework.
• Input interfaces: Chat and form triggers collect information from people directly.
• Native AI: AI pieces let you swap providers or assemble agents with the AI SDK inside the builder.

The Community Edition is MIT licensed while enterprise features carry a separate commercial license. Self-hosting is the intended posture, network-gapped where needed, so developers configure the tools and anyone in the organization builds on the no-code canvas.

Windmill turns scripts into internal tooling. You write a small script that does one job, and the platform parses its parameters, generates a form for it, and makes it callable as an API, a scheduled job or a step inside a larger flow.

The backend is Rust, running stateless API servers and workers that pull jobs from a Postgres queue, with a Svelte front end above them. Jobs are sandboxed with nsjail and PID namespace isolation, and once a job starts there is no overhead beyond roughly 50 milliseconds of queue latency.

Languages and triggers are deliberately wide.

• Runtimes: TypeScript on Bun or Deno, Python with uv, plus Go, Bash, PowerShell, PHP, Rust, C#, Java and Ansible.
• Flows and apps: chain scripts into flows, or assemble richer interfaces in the low-code app editor.
• Triggers: schedules, webhooks, HTTP routes, Kafka, WebSockets and inbound email.
• Local development: a CLI, a VS Code extension and two-way Git sync between your repository and the instance.
• Secrets: one encryption key per workspace for credentials kept in the platform's key-value store.

The Community Edition is free to use internally, while reselling it or serving it as a managed offering needs a commercial agreement. Self-hosting is three files and a Docker Compose command, or a Helm chart on Kubernetes, and it runs on AWS, GCP, Azure, Fly.io, Hetzner and others at roughly one worker per vCPU.

Trigger.dev is a platform for writing background tasks in TypeScript and running them without a timeout. Serverless functions cut work off after a few minutes, which is the wrong shape for an agent that browses, transcodes or waits on a human decision.

Tasks live in your own codebase, version controlled and reviewed like everything else, and reach the platform through the SDK. Durability comes from checkpointing, so a run survives interruption, and atomic versioning means a new deployment leaves runs already in flight untouched.

The runtime gives you rather more than an executor.

• Queues and concurrency: concurrency rules, batch triggering, idempotency and automatic retries after an uncaught error.
• Waits and approvals: pause a run for a set duration, or until a person approves, rejects or comments.
• Realtime: subscribe to runs from your frontend with React hooks, including streaming model responses.
• Build extensions: hook into the build to add system packages, browsers, Python scripts or FFmpeg.
• Observability: full traces and logs per run, plus tags, run metadata, bulk actions and failure alerts.

Development, staging, preview and production environments are supported, and preview branches integrate with Git workflows and Vercel. Machines are configured by vCPU and memory per task. The managed cloud removes infrastructure work entirely, and self-hosting is documented for Docker Compose and for Kubernetes through an official Helm chart.

ByteChef puts agent orchestration and workflow automation in the same graph. Most teams run one tool for deterministic automation and another for agents, then spend their time reconciling the two; here the non-deterministic part and the branching, retrying, approving part share a runtime, a permission model and one audit trail.

The AI Agent is a drag-and-drop component that owns the full loop, model to tool selection to execution to observation to the next step, with streaming and structured output. Twelve LLM providers ship directly, with three aggregator components for routing through a gateway. Every connector is already a tool, workflows can be published as MCP tools, and a fromAi expression in any field turns that property into part of the schema the model sees.

The automation half is built for production rather than demos.

• Visual editor with JSON underneath: workflows stay diffable and Git-friendly.
• Flow control: condition, branch, loop, each, map, parallel, fork-join, subflow, on-error, terminate and wait-for-approval steps.
• Triggers: static and dynamic webhooks, polling, hybrid, app-event listeners, schedules and forms.
• Polyglot code: JavaScript, Python and Ruby running on GraalVM.
• Durable execution: a Postgres-backed runtime with queue mode over Redis, RabbitMQ, Kafka, JMS, AMQP or SQS for horizontal scale.
• Human in the loop: pause for approval, route to Slack or email, resume on the response.

Docker Compose brings up ByteChef and PostgreSQL together. The core is Apache 2.0, with an enterprise tier covering workflows-as-APIs, Git-native environments, Copilot and embedded distribution.

CodeZero replaces the boilerplate around automation with a canvas. A flow is a trigger plus a chain of nodes, and it can be an integration between two services, a whole backend, or a business process with branching and error handling. If you can sketch it, you can ship it.

Nothing has to start from a blank canvas. Describe what you want or pick a template and CodeZero generates the flow, then refines, extends or rewrites any part of it from a prompt on the same canvas. Models are yours to choose, with OpenAI, OpenRouter or any compatible provider powering the workspace.

The platform is aimed at teams rather than solo tinkerers.

• Visual editor: flows stay readable as a graph, which keeps them debuggable and shareable.
• Triggers: HTTP webhooks and cron schedules ship by default, and plugins add more.
• Organizations: projects, roles and fine-grained permissions decide who can change what.
• Runtimes: each runtime component scales on its own, from a single box to a fleet.
• Plugins: new nodes, flow types and triggers extend a runtime without forking it.

Getting started needs only Docker: clone the repository, adjust secrets and settings in the Compose environment file, and bring the stack up. A hybrid deployment keeps the editor in the cloud with runtimes on your own hardware, so data never leaves your network. Licensing varies per component, which is worth checking before you build on it.