Activepieces MCP

Live

OAUTH 2.1

WORKFLOW AUTOMATION

Automation

Activepieces MCP gives agents authenticated access to your workflow automation: build flows, flip status, test runs, and debug failures without opening the editor.

  • Per-user credentials: each call uses the actual user's token, never a shared bot.
  • Encrypted per-tenant vault: AES-256, resolved at request time, never in LLM context.
  • Scoped before every call: pre-call scope check, 90-day SIEM-exportable audit chain.
Activepieces MCP
agent · Acme Q3
Run
Which automation flows failed overnight, and why?
S
activepiecesmcp_ap_list_runs
88ms
Activepieces agent
3 of 41 runs failed overnight. Lead sync flow failed at step_2 (Slack channel not found) at 02:14 UTC. The other 38 runs succeeded.
Sources: 41 runs, 12 flows, last 24h
activepiecesmcp
41 runs
18:29
Message Claude...

Tools your automation agent reaches for on Activepieces, scoped per user.

CALL ANY TOOL
Run workflow automation end to end: list flows, build new ones from a prompt, test, publish, and trace every failed run.
activepiecesmcp_ap_list_flows
List flows
List flows in the current project with status, trigger type, and published state.
Parameters
Name
Type
Required
Description
name
string
Optional
Filter by flow name (partial match).
status
string
Optional
Filter by status: ENABLED or DISABLED.
limit
integer
Optional
Max flows to return (default 100, max 500).
activepiecesmcp_ap_build_flow
Build a flow
activepiecesmcp_ap_test_flow
Test a flow
activepiecesmcp_ap_lock_and_publish
Publish a flow
activepiecesmcp_ap_change_flow_status
Enable or disable a flow
activepiecesmcp_ap_list_runs
List runs
activepiecesmcp_ap_get_run
Inspect a run
Build your Agent
Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.
Python · LlamaIndex
import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Activepieces tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["activepiecesmcp"], toolNames: [
    "activepiecesmcp_ap_list_flows",
    "activepiecesmcp_ap_build_flow",
    "activepiecesmcp_ap_list_runs"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Which flows failed overnight?" }] });
import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["activepiecesmcp"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Which flows are enabled right now?" }],
  tools,
});

// Execute the tool call with the user's vaulted Activepieces credential
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");
import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["activepiecesmcp"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Build a flow that posts new Stripe payments to Slack." }],
  tools,
});

// Tool call runs with the user's vaulted Activepieces credential
await sk.tools.executeTool(msg.content, "user_123");
import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["activepiecesmcp"] }, pageSize: 100,
});

const agent = new Agent({
  name: "activepieces_automation_agent",
  model: "gemini-2.5-pro",
  instruction: "Manage Activepieces flows for the signed-in user.",
  tools,
});

await agent.run("Why did the lead sync flow fail last night?");
Try these prompts
Copy any prompt into your agent. Each maps directly to an Activepieces tool. Click to copy, paste into your agent, done.
Flow operations
Copy the prompt
Copied
Which flows are enabled right now?
Copy the prompt
Copied
Disable the abandoned cart flow until we fix the coupon step.
Copy the prompt
Copied
Duplicate the onboarding flow and rename the copy to Onboarding v2.
Build and ship flows
Copy the prompt
Copied
Build a flow that posts new Stripe payments to #finance in Slack.
Copy the prompt
Copied
Test the welcome email flow with mock signup data.
Copy the prompt
Copied
Publish the lead sync flow if validation passes.
Debug runs
Copy the prompt
Copied
Which runs failed in the last 24 hours?
Copy the prompt
Copied
Why did the lead sync flow fail last night? Show the failing step.
Copy the prompt
Copied
Retry this morning's failed run and confirm it succeeds.
SEE HOW AUTH WORKS
Your users connect once. Their Activepieces credentials stay vaulted, every call is scope-checked, and every action is logged.
1
Authorize
Your user connects
Activepieces MCP
once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access
Who:
user ‘A’
when:
Once per user
access:
Limited to user
2
Store
Their
Activepieces MCP
token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection
vault:
encrypted
scope:
per-user
tokens:
auto-refreshed
3
Resolve
When your agent calls a
Activepieces MCP
tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs
speed:
~40ms
check:
before every call
seen by:
nobody
4
Audit
Every
Activepieces MCP
tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it
history:
90 days
export:
SIEM-ready
logged:
every call
Test other agents
See the same per-user auth pattern across other automation connectors.
ENGINEERING
Slack workflow agent (LangGraph)
LangGraph agent that drives multi-step Slack workflows: triggers, approvals, and follow-up actions per user identity.
ENGINEERING
DevOps assistant agent
Triage GitHub incidents, open Linear tickets, and notify the on-call channel in Slack with context already attached.
Why Scalekit
Secure your agent's access. Connectors ship in minutes
Other connector libraries treat auth as a demo afterthought. Scalekit starts with identity, scope enforcement, and audit. Connectors follow.
01.
Shared tokens break per-user analytics
A shared Activepieces token looks fine in a demo. In production every flow edit, publish, and delete looks like one service account, and you cannot tell who shipped the change that broke a live automation. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.
// shared token
audit → bot_service_account

// scalekit
audit → user_abc ✓
02.
Authentication is not authorization
03.
Multi-tenancy is architectural
04.
Activepieces today. Ten connectors tomorrow.
“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”
Venu Madhav Kattagoni
Head of Engineering / Von
FAQs
Frequently Asked Questions
Does the agent access Activepieces as the user or through a shared key?
As the user. Scalekit resolves the credential of the person who triggered the agent at request time, so every flow build, publish, and status change in your audit trail is attributed to a real user, not a shared service account.
Where is the Activepieces token stored?
In an AES-256 encrypted vault with per-tenant namespacing. Tokens are resolved at request time, never enter LLM context, refresh automatically, and can be revoked from one dashboard.
Can I limit what the agent does in Activepieces?
Yes. Filter by tool name in listScopedTools to expose only what you want, for example read-only run inspection without build, publish, or delete. Scalekit also enforces scope checks before every API call.
What happens when a user revokes access?
The credential is invalidated at the next tool call. The call fails closed, other users' connections are unaffected, and the revocation is logged in the audit chain.
Can the agent permanently delete flows or tables?
Only if you let it. Activepieces exposes destructive tools like ap_delete_flow and ap_delete_table, and deletion cannot be undone. Filter them out of listScopedTools for read-and-build agents, or keep them scoped so every delete is pre-checked and attributed to the user who asked.
Start in your coding agent
Up and running in one command
Install the Scalekit skill in your editor of choice. Connector, auth, tools, prompt, all wired up
Claude Code REPL
/plugin marketplace add scalekit-inc/claude-code-authstack
/plugin install agentkit@scalekit-auth-stack
Cursor Code REPL
# ~/.cursor/mcp.json
{
""mcpServers"": {
""activepiecesmcp"": {
""url"": ""https://mcp.scalekit.com/activepiecesmcp"",
""headers"": { ""Authorization"": ""Bearer $SCALEKIT_TOKEN"" }
}
}
}
Codex Code REPL
# ~/.codex/config.toml
[mcp_servers.activepiecesmcp]
url = ""https://mcp.scalekit.com/activepiecesmcp""
auth_env = ""SCALEKIT_TOKEN""
Copilot Code REPL
# .vscode/mcp.json
{
""servers"": {
""activepiecesmcp"": {
""url"": ""https://mcp.scalekit.com/activepiecesmcp"",
""type"": ""http""
}
}
}