Activepieces MCP: Connect Claude to Your Workflows

Activepieces MCP turns your automation flows into MCP-compatible tools that Claude, Cursor, and other AI assistants can use directly. Instead of hunting through dashboards or copying data between tools, your AI calls your Activepieces pieces like native functions. Setup takes about 10 minutes.

What is MCP and Why Activepieces Changes the Game

MCP--Model Context Protocol--is the USB-C standard for connecting AI to external tools. Anthropic introduced it in 2024 to let Claude talk to anything: your calendar, databases, custom APIs, or automation platforms. Activepieces, with 25.5K GitHub stars and 280+ integrations, saw the opportunity to become an MCP server. Now you can hand Claude the keys to your entire automation stack without writing a single API call or webhook.

Before MCP, you had two bad choices: either give Claude direct API access to every tool (security nightmare), or manually orchestrate: Claude says something, you copy the result, you paste it into Activepieces, you wait for the result, you copy it back to Claude. MCP lets Claude call your Activepieces flows directly while you control exactly which flows it can touch and what data it sees. You approve each flow before it goes live. The assistant never gets raw credentials.

Activepieces' version of MCP is different from most MCP servers. It's not just exposing read-only data (like calendar events or Google Sheets rows). It's exposing your flows--your automation logic. Claude can trigger workflows, pass data through them, and get results back in seconds. Think: Claude drafts a customer email, calls your Activepieces flow to look up order history, gets it back, rewrites the email with context, calls another flow to send it. All in one conversation.

Prerequisites: Claude Desktop, Node.js, and Your Activepieces Account

You need four things. First, an Activepieces instance. Either sign up free at activepieces.com (Cloud tier, 5,000 credits/month), or run self-hosted Activepieces on Docker. Second, Claude Desktop installed on your machine (free from anthropic.com). Third, Node.js 16+ (download from nodejs.org). Fourth, basic familiarity with JSON. You do not need coding skills--the MCP config is a few lines of text.

If you choose Cloud, note that each MCP call costs credits. A simple flow that reads data and returns it might cost 50-100 credits per call. Heavy usage (Claude calling your flows 100+ times per day) can burn through credits quickly. If you're building a heavily-automated AI agent, consider managed Activepieces hosting or self-hosted to avoid per-call costs.

For this guide, we'll use Claude Desktop and Activepieces Cloud. The same principles apply to Cursor, Windsurf, or self-hosted Activepieces.

Step 1: Create Your MCP Server in Activepieces

Log into your Activepieces account (cloud or self-hosted). Navigate to the "MCP" section in the left sidebar. Click "Create New MCP Server." Give it a name--something like "Claude Tools" or "My Workflows."

Activepieces generates an API token for this MCP server. Copy it. You'll paste it into Claude Desktop's config in the next step.

Now, which flows should you expose? Do not expose every flow. Start with 1-3 flows that are genuinely useful to Claude. Examples: a flow that looks up customer data, a flow that formats and sends emails, a flow that logs tasks to your project manager. Activepieces calls these "approved flows." In the MCP settings, toggle on the flows you want Claude to access. Leave the rest disabled.

This is your security boundary. Roughly 90% of public MCP servers expose all their tools with no access control. Activepieces requires you to whitelist each flow. Use it. If Claude gets compromised or acts unexpectedly, it can only call the flows you've explicitly turned on.

Step 2: Configure Your AI Client (Claude Desktop, Cursor, Windsurf)

Close Claude Desktop entirely (not just minimized--quit it). Open your system's file browser and navigate to the Claude Desktop config file. On Mac, it is ~/.claude/config.json. On Windows, it is %APPDATA%/Claude/config.json.

If config.json does not exist, create it. Paste this structure:

{
  "mcpServers": {
    "activepieces": {
      "command": "node",
      "args": ["-e", "const mod = require('@activepieces/sdk'); mod.startMcpServer({token: 'YOUR_TOKEN_HERE'})"],
      "env": {
        "ACTIVEPIECES_URL": "https://cloud.activepieces.com",
        "MCP_TOKEN": "YOUR_TOKEN_HERE"
      }
    }
  }
}

Replace YOUR_TOKEN_HERE with the API token from step 1. If you are self-hosting Activepieces, replace the ACTIVEPIECES_URL value with your self-hosted instance URL (for example, your domain or activepieces.yourcompany.com).

Save the file. Restart Claude Desktop. Open Claude and start a new conversation. At the bottom left of the chat input, you should see a small icon (looks like a puzzle piece or plug). Click it. You should see "Activepieces" listed as a connected MCP server. If you see a red X or error, check the config JSON syntax and verify the token is correct.

Step 3: Test Your Connection and Verify in Run History

Now test the connection. In Claude, type something like: "I have connected you to my Activepieces MCP server. What tools are available?" Claude should list your approved flows by name and description. If it sees them, the connection is live.

Now trigger one. Tell Claude: "Use the [flow name] flow to [what you want]." Claude will call the flow with the parameters you specify. It waits for the result and continues the conversation.

Verify it worked two ways. First, check Claude's response. Second, go back to Activepieces and look at the "Run History" for that flow. You should see a new run with a timestamp seconds ago. Click it to see what parameters Claude sent and what the flow returned. This builds confidence that data is flowing correctly and gives you a record of what Claude has triggered.

Common issues: If Claude says the tools are not available, the MCP server did not start. Quit Claude Desktop again, double-check the config.json file (correct token, correct URL, no typos), and restart. If the flow runs but returns the wrong data, check the flow itself in Activepieces--Claude is calling it correctly, but the flow logic might need fixing.

Step 4: Using MCP Client Pieces to Connect External MCP Servers

This is less common but powerful. Activepieces can also consume external MCP servers through MCP client pieces. If you have a different MCP server running (e.g., a custom tool or a public MCP like the Filesystem MCP), you can add it as a piece inside Activepieces and call it from your flows.

To do this, add an "MCP Client" piece to your flow in Activepieces. Provide the MCP server's URL and authentication. The piece then exposes that server's tools as Activepieces actions. Claude calls your Activepieces flow, your flow calls the external MCP server, your flow returns the result to Claude. You get full control over which external MCP tools Claude can access and in what context.

This is useful if you want to sandbox a third-party MCP server. Instead of giving Claude direct access, Activepieces acts as a trusted intermediary. The flow can transform data, add logging, or block certain calls before they reach the external server.

Authentication and Security Best Practices

Activepieces MCP supports OAuth and token-based auth. Token auth (what we used above) is simpler but less secure for long-lived connections. If you are running production AI agents, rotate the token monthly. Generate a new one, update Claude's config, delete the old token.

For each flow Claude can access, ask yourself: What can go wrong if Claude calls this flow with malicious input? A flow that sends emails could spam your customers. A flow that writes to a database could corrupt data. A flow that deletes records could wipe your database. Activepieces does not prevent a rogue AI from doing these things--it just ensures only approved flows are callable. The security of each flow is your responsibility. Add validation inside each flow: check input length, validate email addresses before sending, require confirmation before deletes.

For even higher security, use Activepieces' approval flows. Instead of Claude calling a sensitive flow directly, it calls a flow that triggers a manual approval step. Your phone gets a notification. You review what Claude wants to do. You approve or reject. Only then does the action execute. This prevents AI hallucinations from silently corrupting your data.

Pricing and Credit Implications

Activepieces Cloud charges credits for flow executions. Your plan includes 5,000 credits/month free. Each flow call costs roughly 50-200 credits depending on complexity. A flow that only reads data and returns it costs less than a flow that calls multiple external APIs.

If Claude calls your flows 10 times per day (reasonable for a moderately-active AI agent), that is 300 calls per month. At 100 credits per call, you are at 30,000 credits per month--far over free tier. The next tier costs $10/month for 50,000 credits. Above that, $20, $50, up to $200/month for 500,000 credits.

If you are running Activepieces self-hosted (Docker), there are no per-call credits. You pay for the server infrastructure (usually $10-30/month on a VPS). Each flow call costs only CPU and network, not money. Self-hosted makes sense if you expect heavy usage--more than 50,000 credits per month on Cloud would cost you $20+/month, which is comparable to a cheap VPS.

Activepieces also offers managed hosting where Opsily handles deployment, backups, and scaling for you. This removes the operational burden of self-hosting while keeping costs predictable.

Frequently Asked Questions

How do you set up Activepieces MCP server in Claude Desktop? Create an MCP server in Activepieces, copy its API token, add the token to Claude Desktop's config.json file, and restart Claude. The config tells Claude where to find Activepieces and what credentials to use.

What is the difference between Activepieces as an MCP server vs. MCP client? As a server, Activepieces exposes your flows to Claude. As a client, Activepieces consumes external MCP servers and calls them from inside your flows. You control both directions.

How do you authenticate Activepieces with OAuth for MCP tools? Each piece in Activepieces that needs auth (Gmail, Slack, Google Calendar) already has OAuth built in. When you add the piece to a flow, you connect your account once. The MCP server inherits those credentials. Claude does not see the credentials--Activepieces handles them securely.

Can you use Activepieces MCP on self-hosted instances? Yes. Self-hosted Activepieces supports MCP the same way Cloud does. Update the config.json to point to your self-hosted URL instead of cloud.activepieces.com.

What are the security best practices for scoping MCP server access? Whitelist specific flows, not all flows. Add input validation inside each flow. Use approval flows for sensitive operations. Rotate API tokens monthly. Never expose flows that delete data or cost money without explicit user approval.

How do you test if your Activepieces MCP server is connected? Ask Claude "what tools are available?" If it lists your flows by name, the connection works. Then trigger a flow and check Activepieces' Run History to confirm the call arrived and executed.

The Bottom Line

Activepieces MCP is the simplest way to give Claude access to your entire automation stack without API keys or webhooks. Setup takes 10 minutes. The security model is clear: you approve which flows Claude can touch. For heavy usage or long-term reliability, managed Activepieces hosting removes the operational headache while keeping your costs predictable. Start with one test flow. Build from there.