# Activepieces: Self-Hosted Automation with a Unified MCP Toolkit

> Activepieces is an open-source automation platform for building trigger-and-action flows through a no-code builder or TypeScript pieces. It also exposes all integrations as MCP servers, making the same piece library available to LLM clients like Claude Desktop or Cursor.

**activepieces/activepieces** — AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

- Repository: https://github.com/activepieces/activepieces
- Website: https://www.activepieces.com
- Stars: 24,752 · Forks: 4,256
- Language: TypeScript
- License: NOASSERTION
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/activepieces-activepieces

## What Activepieces Solves and Who It Is For

Activepieces is an open-source automation platform aimed at teams that want Zapier-style trigger-and-action workflows without depending on a third-party cloud service. The typical user is a developer or a team that operates its own infrastructure and wants to connect services like Google Sheets, Discord, or OpenAI without writing one-off integration scripts.

The platform serves two audiences at once. Non-technical users build flows through a drag-and-drop visual builder that supports branches, loops, and code steps without writing JavaScript. Developers use the TypeScript pieces framework to write custom integrations as npm packages, test them with hot reloading on a local machine, and publish them to npmjs.com under the @activepieces scope.

The README positions the project as an open-source replacement for Zapier, with self-hosting and an open integration ecosystem as the main differentiators. The enterprise tier adds features such as multi-tenancy, branding customization, and an embeddable builder, which are governed by a separate Commercial License.

## Pieces Framework: TypeScript Packages as Integration Units

Every integration in Activepieces is a piece: a TypeScript npm package that implements one or more actions and triggers. The repository states that 60 percent of the pieces are contributed by the community, and all are published to npmjs.com. When a developer contributes a piece to the repository, it becomes available to all platform users and is also automatically exposed as an MCP server.

The execution model uses two container types. An api container handles the visual builder, orchestration, and the REST API. Separate worker containers execute the actual step logic. The docker-compose.yml in the repository defines five worker replicas by default. Each worker uses isolate, a sandboxing binary, for code step execution; the Dockerfile documents that libcap2 must be present in the container for this binary to function, and the AP_EXECUTION_MODE variable in .env.example defaults to UNSANDBOXED for deployments that cannot provide those capabilities.

Flows in Activepieces are fully versioned. The builder supports hot reloading for local piece development, so a developer can iterate on a piece's TypeScript source without restarting the server. The pieces follow npm versioning, and published versions are pinned by the flow editor when a piece is added to a flow.

## Running Activepieces with Docker Compose

The repository ships a docker-compose.yml that starts four services: the main app on port 8080, five worker replicas, a PostgreSQL database using the pgvector image, and Redis 7.0.7. The current release tag in the file is 0.92.0.

The app service definition is:

```yaml
services:
  app:
    image: ghcr.io/activepieces/activepieces:0.92.0
    container_name: activepieces-app
    restart: unless-stopped
    ports:
      - '8080:80'
    depends_on:
      - postgres
      - redis
    env_file: .env
    environment:
      - AP_CONTAINER_TYPE=APP
    volumes:
      - ./cache:/usr/src/app/cache
```

Before bringing the stack up, create a .env file from .env.example. Three variables require generated values. The README recommends using tools/deploy.sh rather than filling them manually:

```bash
AP_ENCRYPTION_KEY=
AP_JWT_SECRET=
AP_POSTGRES_PASSWORD=
AP_FRONTEND_URL=http://localhost:8080
AP_EXECUTION_MODE=UNSANDBOXED
```

With the environment file populated, docker compose up -d starts all services. The UI is accessible at the URL set in AP_FRONTEND_URL, which defaults to http://localhost:8080. The AP_FLOW_TIMEOUT_SECONDS variable, which defaults to 600 in .env.example, sets the maximum duration for a single flow execution.

## MCP Integration and LLM-Facing Toolsets

Every Activepieces piece is also available as an MCP server. The README states that over 280 pieces are exposed this way and can be used with Claude Desktop, Cursor, or Windsurf through the Model Context Protocol. A .mcp.json file at the repository root ships alongside the main application.

The .env.example file documents an optional semantic tool-search feature. Setting AP_TOOL_SEARCH_ENABLED=true enables it, and AP_OPENAI_API_KEY funds the embedding calls that back the catalog search. When that key is absent, the search falls back to keyword-only matching. This feature is off by default.

The practical effect is that any automation piece built for Activepieces flows is immediately reusable as an LLM tool, without writing a separate MCP server definition. This is a concrete architectural difference from most self-hosted workflow automation platforms, which keep their integration code on the server side only.

## Builder Capabilities: Loops, Branches, and Human Pauses

The visual builder supports loops, branches, automatic retries, and outbound HTTP calls. A code step lets users write arbitrary JavaScript with npm package imports. A built-in ASK AI mode inside the code step allows a non-technical user to describe a data transformation in natural language instead of writing code.

Human-in-the-loop pauses and approval gates are implemented as regular pieces built on the piece framework, not as platform-level special cases. Both a Chat Interface trigger and a Form Interface trigger are available for collecting human input at flow start. Language translations for the builder interface are documented in the README, with progress tracked through Crowdin.

## Licensing: Community Edition and the Enterprise Boundary

The Community Edition source code is under the MIT license. Enterprise features live in a separate packages/ee/ directory and are governed by a Commercial License. The .env.example file and the README point to activepieces.com/pricing for the list of features that require a commercial arrangement.

Enterprise-only capabilities include multi-tenancy and the ability to embed the visual builder inside another product. An engineer building a SaaS product that needs to white-label the automation builder must review the commercial license before shipping. The Community Edition does not restrict the number of flows, users, or pieces, so most self-hosted deployments fall within it.

## Activepieces versus Zapier and n8n

Zapier is a closed, cloud-only SaaS. The three concrete differences Activepieces offers are: the source code is open under MIT for the Community Edition, the platform can be self-hosted on infrastructure you control, and pieces are standard TypeScript npm packages that any developer can fork, modify, or publish.

n8n is the closest self-hosted alternative. Both use a visual flow builder and support code steps. The key architectural distinction is that Activepieces makes every integration available as an MCP server out of the box. n8n does not ship this as a native feature of its node system. Activepieces pieces are typed TypeScript packages with npm versioning, while n8n uses a JavaScript-based node system with a different contribution model.

Both tools run on Docker, but Activepieces requires PostgreSQL and Redis while n8n can run with a single SQLite file for smaller workloads, which makes the n8n setup simpler for solo developers. For teams that need data to remain on-premises and want to expose their automation integrations to LLM agents through MCP, Activepieces provides a path that n8n does not bundle.

## Conclusion

Teams that need self-hosted automation with an open integration library should evaluate the Community Edition first and verify the commercial license boundary at activepieces.com/pricing before building features that require an embedded builder or multi-tenancy. Teams running on restricted Kubernetes environments must test the AP_EXECUTION_MODE setting before committing to production, since sandboxed code steps depend on Linux kernel capabilities via libcap2.

## FAQ

### What does Activepieces do?

Activepieces is an automation platform that connects services through trigger-and-action flows built with a visual no-code builder or custom TypeScript pieces. It also exposes all integrations as MCP servers for use with LLM clients like Claude Desktop, Cursor, or Windsurf.

### Is Activepieces free?

The Community Edition is released under the MIT license and is free to self-host. Enterprise features including multi-tenancy and embedded builder support are governed by a separate Commercial License; activepieces.com/pricing lists which features require a paid arrangement.

### How do you install Activepieces?

The recommended path is Docker Compose. Copy .env.example to .env, generate the required secrets using tools/deploy.sh, then run docker compose up -d. The UI is then available at the URL set in AP_FRONTEND_URL, which defaults to http://localhost:8080.

### How does Activepieces compare to Zapier?

Zapier is a closed, cloud-only SaaS. Activepieces is self-hosted and open-source under MIT for the Community Edition. Activepieces pieces are TypeScript npm packages that developers can write, publish, and modify; Zapier's integration code is not accessible.

### Is Activepieces open source?

Yes. The Community Edition source is MIT-licensed and hosted at github.com/activepieces/activepieces. Enterprise features within the same repository are under a separate Commercial License, documented in packages/ee/LICENSE.

## Sources

- [activepieces/activepieces on GitHub](https://github.com/activepieces/activepieces)
- [Issues](https://github.com/activepieces/activepieces/issues)
- [Project website](https://www.activepieces.com)
- [README](https://github.com/activepieces/activepieces/blob/main/README.md)
- [Releases](https://github.com/activepieces/activepieces/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/activepieces-activepieces