ActivePieces MCP - 280+ Automation Pieces as AI Tools

TL;DR

TL;DR: ActivePieces is an open-source automation platform where all 280+ of its pieces are available as MCP servers, letting AI agents trigger workflows in Claude Desktop, Cursor, or any MCP-compatible client.

Source and Accuracy Notes

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

• Project page: activepieces.com
• Source repository: github.com/activepieces/activepieces
• License: MIT (verified via README badge)
• Docs: activepieces.com/docs
• Blog (MCP announcement): activepieces.com/blog

What Is ActivePieces?

ActivePieces describes itself as:

An open source replacement for Zapier

The twist that makes it relevant for this post: every piece is also an MCP server. From the README:

When you contribute pieces to Activepieces they become automatically available as MCP servers that you can use with LLMs through Claude Desktop, Cursor or Windsurf!

So you get a self-hosted automation engine where the same building blocks that power your Zapier-like workflows are directly callable by AI agents via the Model Context Protocol.

MCP Coverage

The README claims 280+ pieces available as MCP servers. The pieces cover categories like:

• AI providers (OpenAI, Anthropic, Google AI, etc.)
• CRM (Salesforce, HubSpot, Pipedrive)
• Communication (Slack, Discord, Email)
• Development (GitHub, GitLab, Jira)
• Marketing (Mailchimp, SendGrid, Twitter/X)
• Productivity (Google Drive, Notion, Airtable)

Setup Workflow

Prerequisites

• Node.js 18+ for self-hosting
• Docker (optional, for containerized deploy)
• An MCP-compatible AI client (Claude Desktop, Cursor, Windsurf)

Step 1: Install ActivePieces

The fastest way to get started is the Docker one-liner:

docker run -d \
  --name activepieces \
  -p 3000:3000 \
  -v $(pwd)/packages:/home/node/app/packages \
  activepieces/all-in-one:latest

Open http://localhost:3000 to access the dashboard.

Alternatively, use the npm-based install for a developer setup:

npm install -g @activepieces/cli
ap start

Step 2: Connect Your First App

In the ActivePieces dashboard:

1. Click Connections → Add Connection
2. Authenticate with a tool you use (e.g., GitHub, Slack, Notion)
3. The connection is now available for both manual automations and MCP calls

Step 3: Enable MCP for Your Agent

ActivePieces pieces are available as MCP servers out of the box. To connect them to an AI agent:

1. Find your MCP server URL (ActivePieces exposes it at /api/v1/mcp on your install)
2. In Claude Desktop, add to your claude_desktop_config.json:

{
  "mcpServers": {
    "activepieces": {
      "url": "http://localhost:3000/api/v1/mcp"
    }
  }
}

3. Restart Claude Desktop — your agent can now call any ActivePieces piece directly

For Cursor and Windsurf, the MCP connection URL is the same; the UI for adding MCP servers differs slightly.

Step 4: Trigger a Flow from Your Agent

Once connected, your agent can use natural language to trigger automations:

"Send a Slack message in #sales whenever a new HubSpot deal closes"

ActivePieces resolves the connected accounts and executes the flow server-side.

Deeper Analysis

Why This Matters for AI Agents

The core problem with giving AI agents access to tools is that most tools require OAuth, API keys, and custom integration code. ActivePieces solves this by:

1. Pre-built connectors — 280+ apps already have auth and API handling
2. MCP native — no custom agent code needed; just point your MCP client at the server
3. Self-hosted — your credentials stay on your infrastructure

This is a meaningful step toward agents that can actually do things in your existing software stack, not just reason about it.

Self-Hosted vs. Cloud

ActivePieces offers both a cloud-hosted version at activepieces.com and a self-hosted option. The self-hosted option is MIT-licensed and free. If you want AI agents touching your internal tools, self-hosted is the right choice — you do not want your CRM credentials going through a third-party cloud.

Piece Development

Pieces are TypeScript npm packages. If you need a connector not yet available, the hot-reloading local development setup lets you build and test a new piece against your live ActivePieces instance:

cd packages/pieces
npm run generate
# Edit the generated piece TypeScript files
# Changes hot-reload into your running instance

Practical Evaluation Checklist

• [x] README clearly describes MCP integration (verified via github.com/activepieces/activepieces)
• [x] Self-hosted option (Docker, npm) — MIT license
• [x] 280+ pieces / MCP servers listed in README
• [x] Pieces are TypeScript npm packages (verified via README)
• [x] Cloud option available at activepieces.com
• [x] MCP endpoint at /api/v1/mcp (documented in README context)
• [x] MIT license (badge in README)
• [x] Active development — last push July 2026
• [x] ~23k GitHub stars

Security Notes

• Self-hosted ActivePieces keeps all credentials on your infrastructure
• Connections (OAuth tokens, API keys) are stored encrypted in your own database
• If using the cloud option, credentials go to ActivePieces servers — evaluate accordingly for your data sensitivity level

FAQ

Q: Do I need to build flows manually, or can agents create them? A: You build the flows (triggers + actions) in the ActivePieces visual builder. Once built, agents can trigger them via MCP. Agents cannot yet create flows autonomously.

Q: Can I use ActivePieces without MCP, as a plain automation tool? A: Yes. The MCP integration is an extra layer on top of the core automation engine. You can use it purely as a self-hosted Zapier alternative with a visual builder.

Q: How is this different from n8n or Make? A: The key differentiator is first-class MCP support. n8n and Make have community-contributed MCP nodes, but ActivePieces has built its pieces framework so every piece is automatically an MCP server — no extra config needed.

Q: Does ActivePieces support private pieces (internal tools)? A: Yes. You can build private pieces as TypeScript packages and load them into your self-hosted instance. They become MCP servers just like the official ones.

Conclusion

ActivePieces turns 280+ app integrations into MCP servers your AI agents can actually call. If you are running self-hosted AI agents and want them to interact with Slack, HubSpot, Notion, GitHub, or dozens of other tools without building each OAuth integration from scratch, ActivePieces is worth evaluating. The MIT-licensed self-hosted option keeps your credentials off third-party infrastructure.