Activepieces – Open Source AI Automation Platform

TL;DR

TL;DR: Activepieces is an open source automation platform that ships 280+ MCP servers out of the box, letting you connect AI agents to real-world workflows and self-host everything on your own infrastructure.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: activepieces.com
• Documentation: activepieces.com/docs
• Source repository: github.com/activepieces/activepieces
• License: MIT (verified via GitHub API license.spdx_id: NOASSERTION — README badge shows MIT; LICENSE file confirmed in repo)
• HN launch thread: news.ycombinator.com/item?id=44435189
• Latest release: 0.86.3 (verified via GitHub Releases API)
• Stars: 23,377 (GitHub API, as of 2026-07-23)
• Source last checked: 2026-07-23

What Is Activepieces?

Activepieces is an open source general-purpose automation platform positioned as an alternative to Zapier. Unlike legacy automation tools, it was designed from the ground up with AI agents as a first-class citizen.

The headline feature is 280+ MCP servers included out of the box — every integration piece (Google Sheets, OpenAI, Discord, RSS, and many more) is automatically available as an MCP server that AI coding assistants like Claude Desktop, Cursor, and Windsurf can use directly.

The platform is written in TypeScript. Pieces are npm packages, meaning any developer can package a new integration and publish it to the npm registry — 60% of existing pieces were contributed by the community.

Key Differentiators from n8n

n8n has had MCP support added, but Activepieces took a different approach:

• MCP-native: All 280+ pieces double as MCP servers without extra configuration
• TypeScript-first: Pieces are TypeScript npm packages, not JSON workflow definitions
• AI SDK: Built-in AI SDK lets non-technical users build agentic flows using a no-code builder
• Human-in-the-loop: First-class support for approval gates and delay steps, useful for agentic workflows

Setup Workflow

Step 1: Quick Start with Docker

The fastest way to get running locally is Docker:

docker run \
  -d \
  --name activepieces \
  -p 8080:80 \
  -v ~/.activepieces:/data \
  activepieces/activepieces

Open http://localhost:8080 to access the web UI.

Step 2: Docker Compose (Production)

For a production setup with a database and worker:

version: "3.8"
services:
  activepieces:
    image: activepieces/activepieces
    environment:
      - AP_PORT=80
      - AP_DATABASE_TYPE=postgres
      - AP_DATABASE_ARGUMENTS=postgresql://user:password@postgres:5432/activepieces
    ports:
      - "80:80"
    depends_on:
      - postgres

  postgres:
    image: postgres:16
    environment:
      - POSTGRES_DB=activepieces
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

docker compose up -d

Step 3: Connect Your First MCP Piece

1. Open the Activepieces UI at http://localhost:8080
2. Create a new flow
3. Click Add Trigger → choose a trigger type (e.g., Schedule, Webhook, Form)
4. Click Add Step → search the piece catalog
5. Every piece in the catalog is also available as an MCP server

To expose an MCP server for a piece, go to Settings → MCP Servers and enable the pieces you want to expose.

Step 4: Use MCP with Claude Desktop

Add the Activepieces MCP server to your Claude Desktop config (~/.claude/desktop-config.json):

{
  "mcpServers": {
    "activepieces": {
      "command": "npx",
      "args": ["-y", "@activepieces/mcp-server"]
    }
  }
}

Deeper Analysis

Strengths

AI-native integrations: With 280+ MCP servers, the hard part of connecting AI agents to external tools is largely solved. You get Google Sheets, Slack, Notion, GitHub, and dozens more — all ready for LLM tool-calling with zero glue code.

Self-hosted security: The platform is designed for network-gapped environments. If your automation handles sensitive data, you can run it entirely on-premises with no outbound traffic requirements.

TypeScript pieces: Unlike JSON/YAML workflow definitions in other platforms, pieces are TypeScript npm packages. This means full programmatic flexibility — conditionals, loops, custom logic — without being locked into a visual-only DSL.

Community velocity: 60% of pieces are community-contributed. The project ships frequent updates (0.86.3 at time of writing) with active development.

Weaknesses

Younger ecosystem than n8n: n8n has been around since 2017 and has a larger community and more third-party resources. Activepieces is growing fast but has a smaller plugin ecosystem by comparison.

Documentation gaps: Some enterprise-grade deployment topics (LDAP auth, high-availability clustering) have thinner documentation coverage than the core features.

No built-in AI model hosting: Activepieces connects to AI providers via their APIs — it does not run its own models. You need an OpenAI/Anthropic API key or compatible endpoint.

License Note

The GitHub API reports license.spdx_id: "NOASSERTION". Checking the repository directly, the project uses the MIT license (confirmed by the README badge and LICENSE file in the repository root).

Practical Evaluation Checklist

• Self-hosted on a $6 VPS (Docker minimum requirements: 1 CPU, 512MB RAM)
• Docker and Docker Compose installed
• Access to a domain or subdomain for production deployment
• API keys for the external services you want to connect
• Optional: Claude Desktop, Cursor, or Windsurf for MCP integration

Security Notes

• All data stays on your server when self-hosted — no forced cloud dependency
• Execution logs can be restricted to admin-only access
• Network-gapped deployment is a documented use case (explicitly mentioned in the README)
• As a TypeScript/node application, standard Node.js security considerations apply

FAQ

Q: How does this compare to n8n? A: Both are open source automation platforms. Activepieces has MCP integration built-in from the start, while n8l added MCP support later. Activepieces uses TypeScript/npm for pieces; n8n uses a JSON-based workflow schema. For AI agent use cases, Activepieces’ MCP-native approach tends to require less configuration.

Q: Does it require a database? A: Yes, for production. The default Docker image uses a file-based SQLite store for quick local dev, but production deployments require PostgreSQL (configured via AP_DATABASE_TYPE and AP_DATABASE_ARGUMENTS).

Q: Can I run it on a Raspberry Pi? A: Yes, the Docker image runs on ARM64. A Raspberry Pi 4 with 4GB RAM is sufficient for personal/homelab use. Do not expect high-throughput performance on underpowered hardware.

Q: Is there a managed cloud option? A: Yes, Activepieces offers Activepieces Cloud for those who do not want to self-host.

Q: How does MCP integration work? A: Each piece in the catalog is automatically available as an MCP server. You enable pieces in Settings → MCP Servers, then connect them to AI coding tools like Claude Desktop. The AI can then trigger automation flows through tool-calling.

Conclusion

Activepieces solves the integration problem for AI agents at scale — 280+ MCP servers means you get a working tool for almost any external service without writing custom connectors. The self-hosted model makes it suitable for teams with data sovereignty requirements, and the TypeScript-based piece framework means developers can extend it without learning a proprietary DSL.

If you are evaluating automation platforms for an AI-augmented workflow, Activepieces deserves a closer look. The combination of MCP-native design, active development (23K GitHub stars, frequent releases), and Docker-based deployment makes it straightforward to self-host and evaluate.

Getting started: activepieces.com/docs/install/overview covers Docker, Docker Compose, Helm, Railway, and more.