canonical: https://jentic.com/apis/activepieces.com/activepieces

# Activepieces API

The Activepieces API manages automation flows, executions, and the data that supports them on an Activepieces instance. It creates and edits flows, triggers and cancels flow runs, organises work into folders and projects, and stores rows in built-in tables. App connections hold the credentials that flows use to reach third-party services, and project releases move a configured project between environments.

## For AI agents

Create and edit automation flows, trigger and cancel flow runs, manage folders, projects, tables, and app connections, and publish project releases on an Activepieces instance.

## Scope

Does not run your automation logic outside Activepieces, provide analytics dashboards, or replace the connected third-party apps. Use for managing Activepieces flows, runs, tables, and connections only.

## Capabilities

- Build automation flows and update their steps
- Trigger, list, and cancel flow runs to control executions
- Organise flows into folders and projects
- Store and query rows in Activepieces tables
- Manage app connections that hold third-party credentials for flows
- Publish project releases and connect a git repo for version control
- Invite users and manage project members

## Use cases

### AI agent flow control

An AI agent operating an Activepieces instance can start, inspect, and stop automation runs on demand. Through Jentic the agent searches by intent and the API token never enters its prompt context, turning Activepieces into a programmable automation backend rather than a dashboard the operator clicks through.

Example prompt: Use Jentic to search 'list Activepieces flow runs', call GET `/v1/flow-runs` to find recent runs, and POST `/v1/flow-runs/cancel` to stop a run that is stuck.

### Programmatic flow management

Teams that version their automations in code can create and fetch flows without opening the builder. The agent creates a flow, then reads it back to confirm the configuration was saved, keeping flow definitions in sync with an external source of truth.

Example prompt: Create a flow via POST `/v1/flows`, then fetch it with GET `/v1/flows/{id}` to confirm it was saved.

### Tables as an automation backend

Activepieces tables store structured rows that flows read and write. An agent can append rows and list existing data to drive downstream automation, using the built-in table store instead of standing up a separate database for lightweight state.

Example prompt: Add a row via POST `/v1/records/{id}` into a table, then list current rows with GET `/v1/records.`

### Connection and release management

Before a flow can reach a third-party service it needs an app connection, and moving a configured project forward needs a release. An agent can provision the connection and publish the release in one sequence, automating environment promotion for Activepieces projects.

Example prompt: Create an app connection via POST `/v1/app-connections`, then publish a release with POST `/v1/project-releases.`

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/v1/flows` | Create an automation flow |
| GET | `/v1/flows` | List flows |
| GET | `/v1/flows/{id}` | Get a flow by id |
| GET | `/v1/flow-runs` | List flow runs |
| POST | `/v1/flow-runs/cancel` | Cancel a flow run |
| GET | `/v1/records` | List table records |
| POST | `/v1/app-connections` | Create an app connection |
| POST | `/v1/project-releases` | Publish a project release |

## Key resources

- **Flows** — Create, read, update, and delete automation flows
- **Flow Runs** — List, inspect, and cancel flow executions
- **Tables** — Store and query structured rows for automations
- **App Connections** — Hold credentials that flows use to reach third-party services
- **Projects** — Group flows and publish releases across environments

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 4 / 100
- **Maturity:** Non-Ready
- **Dimensions:**
  - Foundational Compliance: 99 / 100
  - Developer Experience & Jentic Compatibility: 56 / 100
  - AI-Readiness & Agent Experience: 1 / 100
  - Agent Usability: 92 / 100
  - Security: 60 / 100
  - AI Discoverability: 52 / 100
- **View full report:** https://jentic.com/apis/activepieces.com/activepieces/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Activepieces by hand means handling its bearer token auth against cloud.activepieces.com/api and encoding flow, run, and table calls yourself. Through Jentic you install once, import Activepieces from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Activepieces puts the flow, project, and table ids in the URL path (`/v1/flows/{id}`, `/v1/projects/{id}`), so a rule can pin your agent to one project or flow. You choose the operations it may call, so destructive ones like deleting a flow or removing a user are not included unless you add them.
- **Credential handling:** Your Activepieces API token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'trigger a flow' or 'add a table row', and Jentic returns the matching Activepieces operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **n8n** — n8n is a self-hostable workflow automation platform with a similar flow and execution model
- **Zapier** — Zapier automates multi-app workflows across a large connector library
- **Pipedream** — Pipedream runs code-first event workflows that can call into Activepieces flows

## FAQ

### Is there an Activepieces MCP server?

You don't need an MCP server to give your agent Activepieces. Jentic connects it directly from the API Directory: import it, store your token once, and your agent calls its flow, run, and table operations. That keeps your agent's context free of an extra server's tool definitions.

### What authentication does the Activepieces API use?

The Activepieces API authenticates with a bearer token sent in the Authorization header, per its OpenAPI spec. Through Jentic the token is stored encrypted by your own instance and injected at call time, so it never reaches the agent's context.

### Can I trigger and cancel flow runs with the Activepieces API?

Yes. GET `/v1/flow-runs` lists runs and GET `/v1/flow-runs/{id}` returns a single run, while POST `/v1/flow-runs/cancel` stops a run in progress. Creating and editing the flows themselves is handled by POST `/v1/flows` and GET `/v1/flows/{id}.`

### Can I store data in Activepieces tables through the API?

Yes. GET `/v1/tables` lists your tables, POST `/v1/records/{id}` adds a row, and GET `/v1/records` reads rows back, so a flow or agent can use tables as a lightweight state store.

### What are the rate limits for the Activepieces API?

The OpenAPI spec does not specify rate limits. Check the Activepieces documentation at https://www.activepieces.com/docs for current limits.

### How do I run an Activepieces flow through Jentic?

Search Jentic for 'list Activepieces flow runs', load the input schema, and execute against GET `/v1/flow-runs` or POST `/v1/flow-runs/cancel.` To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Can I limit what my agent is allowed to do with the Activepieces API?

Yes. Write a rule that allows only the flow-run read and cancel operations under one project id, so the agent can start and stop runs for that project and touch nothing else, and every call it makes is logged. Deleting flows or removing users stays out unless you add those operations.