Activepieces

Activepieces is an open-source automation platform designed to be the foundation for both human-driven no-code workflows and AI agent toolchains. Built as a Zapier alternative, it goes further by automatically exposing every integration as a Model Context Protocol (MCP) server, so LLMs like Claude, Cursor, or Windsurf can directly call Gmail, Slack, Notion, HubSpot, and 280+ other services through standardized tool protocols without any extra configuration.

The platform is built around a TypeScript pieces framework where every integration is an npm package that can be developed locally with hot reloading, contributed to the community registry, and automatically versioned and published to npmjs.com. Around 60% of all pieces are community-contributed, creating a growing, self-sustaining ecosystem of integrations that grow the MCP toolkit alongside the workflow library.

Activepieces runs on a multi-process architecture where the API server, execution engine, and workers are separated. User code executes inside Linux kernel-namespaced sandboxes via the isolate binary, giving OS-level isolation rather than just V8 sandboxing. Redis handles job queuing and distributed locking for multi-instance deployments, and PostgreSQL stores flow definitions, run history, and connection credentials.

For enterprise teams, Activepieces offers SAML 2.0 SSO, SCIM provisioning, granular role-based access control, audit logs, and a managed cloud option with SOC 2 and GDPR compliance. The enterprise features layer on top of the MIT-licensed community edition using a cleanly separated packages/ee directory, allowing teams to self-host the community edition with full source access while optionally purchasing enterprise capabilities.

What You Get

• 280+ MCP Servers - Every piece integration automatically becomes an MCP server that Claude Desktop, Cursor, and Windsurf can call directly, making the entire integration library available to LLM agents without extra configuration.
• TypeScript Pieces Framework - Write integrations as typed npm packages with hot reloading for local development, then publish them to npmjs.com where they are versioned and auto-discovered by the platform.
• Visual No-Code Builder - Drag-and-drop workflow editor with loops, branches, auto-retries, inline code blocks with NPM support, AI-assisted data transformation, and full flow versioning.
• Human-in-the-Loop Controls - Pause workflows to collect human input via built-in Chat Interface and Form Interface triggers, or require manual approval before sensitive automation steps proceed.
• AI-First Agent Builder - Create multi-step AI agents with native integrations for OpenAI, Anthropic, Google, Amazon Bedrock, and Azure — configured through the same visual builder used for standard workflows.
• Enterprise-Grade Self-Hosting - Deploy on your own infrastructure with Docker or Helm, with SAML 2.0 SSO, SCIM user provisioning, RBAC, audit logs, and OS-level sandboxing for code execution security.

Common Use Cases

• Building AI Agents for Sales Teams - A RevOps engineer builds a Lead Enrichment Agent that watches a HubSpot trigger, calls OpenAI to classify intent from notes, enriches with Clearbit, and assigns leads in Salesforce — all in the visual builder.
• LLM Tool Augmentation via MCP - A developer adds Activepieces as an MCP server to Claude Desktop, letting Claude directly send emails, create Notion pages, query Google Sheets, and trigger Slack messages on command without any extra code.
• Customer Support Automation - A support team deploys a workflow that reads incoming Zendesk tickets, uses an AI piece to classify and draft responses, routes to human approval via the Chat Interface, then sends the approved reply.
• Internal Operations Reporting - An operations manager schedules a daily flow that pulls metrics from Jira, Google Sheets, and PagerDuty, feeds them through a code block for formatting, and posts a structured summary to a Slack channel.
• Enterprise Workflow Governance - An IT team self-hosts Activepieces with SAML SSO and SCIM, giving marketing and engineering teams isolated projects with separate connection pools, while maintaining centralized visibility and audit trails.
• Developer Tool Integration Pipelines - A platform team builds a CI/CD notification system where GitHub triggers, code analysis steps, and Slack/email notifications are all connected in a versioned, reusable flow template.

Under The Hood

Architecture Activepieces uses a clean layered monorepo where API server, execution engine, worker, and UI live in separate packages tied together by a shared TypeScript types library. The execution flow is fully decoupled: the API server receives trigger events and enqueues jobs through Redis-backed queues, workers pick them up and dispatch to sandboxed engine processes via WebSocket, and the engine evaluates the flow graph step by step using a strategy pattern where each action type (code, loop, branch, piece) has a dedicated executor. This separation ensures that user-supplied code cannot affect the API server. Enterprise features layer cleanly on top of the open-source core through a matched module pattern in a separate packages/ee directory, keeping edition-specific behavior isolated without polluting core logic.

Tech Stack The backend is a Fastify-based Node.js API server built and run with Bun for performance. PostgreSQL serves as the primary data store via TypeORM with a full migration system and CI-enforced schema validation. Redis handles both job queuing via BullMQ and distributed locking for safe multi-instance deployments. Piece execution runs inside Linux kernel-namespaced sandboxes using the isolate binary, providing OS-level process isolation beyond what V8 isolates offer. The frontend is a React application using React Query and Radix UI primitives. The MCP server implementation uses the official @modelcontextprotocol/sdk, and AI integrations are handled through the Vercel AI SDK with unified adapters for OpenAI, Anthropic, Google, Amazon Bedrock, Azure, and xAI. Build orchestration uses Turborepo.

Code Quality The codebase maintains Vitest-based unit and integration test suites across multiple packages — shared utilities, API, worker, and web — alongside Playwright for end-to-end scenarios. Test files demonstrate realistic, detailed fixture data and cover complex flow branching and dual-authentication patterns for thorough coverage. TypeScript is applied strictly throughout, with @activepieces/shared providing typed contracts between services and a custom ActivepiecesError hierarchy with explicit error codes replacing generic exception throwing. ESLint and Prettier enforce consistent style. The extensive community pieces directory shows some variability since contributions come from hundreds of developers, but the Piece class framework enforces interface compliance. Core packages demonstrate high engineering discipline; community pieces vary proportionally with contributor experience.

What Makes It Unique The defining innovation is the automatic dual-purpose of every piece: any integration built for workflow automation simultaneously becomes an MCP server, making the entire library of 280+ integrations available to LLMs through standardized tool protocols without any additional work. The MCP server builder exposes meta-tools that let AI agents programmatically construct, validate, and publish automation workflows — meaning an LLM can build and deploy a workflow autonomously. The use of Linux kernel namespaces (isolate binary) for code sandbox isolation is more rigorous than typical V8-only sandboxing found in competing tools. The clean dual-edition architecture (MIT community + proprietary enterprise) within a single TypeScript codebase with shared types allows the community to audit and contribute to core logic while the commercial tier adds governance features transparently.

Self-Hosting

Activepieces uses a split licensing model: all core automation code outside the packages/ee and packages/server/api/src/app/ee directories is released under the MIT license, meaning you can freely use, modify, distribute, and build commercial products with the community edition. The enterprise features — including SAML SSO, SCIM provisioning, audit logs, advanced RBAC, white-labeling, and managed platform controls — are released under a proprietary Commercial License that requires an Activepieces Enterprise subscription to use in production. For most self-hosting scenarios involving small to mid-size teams without enterprise SSO or compliance requirements, the MIT-licensed community edition covers all core automation and AI agent functionality.

Running Activepieces yourself requires a non-trivial infrastructure footprint. The standard deployment uses Docker Compose with PostgreSQL, Redis, and multiple application containers (API server, worker, engine). You are responsible for provisioning these services, managing database migrations, handling backups, scaling workers horizontally for high throughput, and monitoring for execution failures. The Helm chart provides a Kubernetes deployment path for teams already operating container infrastructure, but setting up piece sandboxing properly — particularly the isolate binary with kernel namespace support — requires a Linux host with appropriate capabilities. This is not a one-click deployment; expect setup time and ongoing operational ownership.

Compared to the Activepieces cloud offering, self-hosters miss out on managed upgrades, built-in high availability, SLA guarantees, and first-party support channels. The cloud tier also provides pre-configured AI credit management, platform-level analytics, and a shared OAuth app registry that eliminates the need to create your own OAuth clients for services like Google or Microsoft. Enterprise license holders gain access to dedicated support, but the self-hosted path fundamentally means your team absorbs the operational burden that the cloud product handles for you. Teams with mature DevOps capabilities and strict data residency requirements will find self-hosting viable; teams without those capabilities should weigh the operational overhead honestly against the cloud option.