canonical: https://jentic.com/apis/composio.dev/composio

# Composio Platform API

The Composio Platform API powers Composio's tool-use platform for AI agents. It exposes endpoints for managing connected accounts to third-party SaaS tools, configuring auth flows, executing toolkit actions, subscribing to triggers, and orchestrating MCP servers. Agent builders use it to give an LLM authenticated, scoped access to hundreds of external tools without writing per-vendor OAuth code, and to inspect execution and trigger logs for debugging.

## For AI agents

Connect AI agents to third-party SaaS tools through Composio: link accounts, configure auth, execute toolkit actions, subscribe to triggers, and inspect logs.

## Scope

Does not host the LLM, run the agent loop, or store conversation memory - use for connecting agents to third-party SaaS tools and managing auth, execution, and triggers only.

## Capabilities

- Link a user account to a third-party SaaS toolkit through a hosted OAuth flow
- Execute a toolkit action against a connected account on behalf of an agent
- Subscribe to triggers so an external SaaS event invokes an agent webhook
- Manage auth configurations so multiple agents share one OAuth client per toolkit
- Rotate webhook subscription secrets and event filters
- Inspect action execution and trigger logs for debugging an agent run
- Manage organization projects, members, and per-project API keys

## Use cases

### Multi-Tool Agent Account Linking

Give end-users a single onboarding flow that connects their Slack, Gmail, GitHub, and Notion accounts to your agent. The `/api/v3/auth_configs` endpoints define reusable OAuth clients, `/api/v3/connected_accounts` manages each user's linked account, and `/api/v3/connected_accounts/link` returns a hosted link the user follows to grant consent. Agent builders use this to skip building per-vendor OAuth flows.

Example prompt: Create a connected-account link for user u_42 to connect their Gmail, then poll `/api/v3/connected_accounts/{nanoId}/status` until it reports active

### Tool Execution from an LLM

Run a toolkit action selected by the LLM against the user's connected account. Composio handles the auth injection, parameter validation, and response normalization so the agent only needs to choose the action and pass the inputs. This removes the integration burden when an agent's plan involves multiple SaaS tools in a single chain.

Example prompt: Execute the slack_send_message tool with channel #ops and text 'Deployment complete' on behalf of connected account ca_8821

### Event-Driven Agents via Triggers and Webhooks

Wake an agent on real-world events such as a new email, a Stripe charge, or a GitHub PR. Triggers subscribe to upstream SaaS events and Composio forwards them to a webhook subscription registered at `/api/v3/webhook_subscriptions` with a rotatable secret. Engineering teams use this for incident-response and notification agents that should not poll.

Example prompt: Subscribe a webhook with URL https://app.example.com/hooks for github_pull_request_opened events and rotate its signing secret

### Operations and Debugging

Inspect why an agent run failed by pulling structured logs of action executions and trigger deliveries. `/api/v3/internal/action_execution/logs` and `/api/v3/internal/trigger/logs` return the inputs, outputs, and errors for each call. Platform teams use these endpoints to build observability dashboards over agent activity.

Example prompt: Retrieve the last 50 action execution log entries and return the ones whose status is not 'success'

### Agent-Driven Composio Operations via Jentic

Let an AI assistant manage Composio itself: provision projects, rotate API keys, and audit connected accounts. Through Jentic the agent searches by intent, loads the schema for the relevant Composio operation, and executes the call without the developer wiring auth or pagination. This is useful for platform teams running many agents on Composio.

Example prompt: On the prompt 'rotate the API key for project nano_77 and report the new key fingerprint', call the regenerate-api-key endpoint and return the rotated key prefix

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/v3/connected_accounts/link` | Generate a hosted link to connect a third-party account |
| GET | `/api/v3/connected_accounts` | List connected accounts |
| GET | `/api/v3/connected_accounts/{nanoId}/status` | Check the status of a connected account |
| POST | `/api/v3/auth_configs` | Create a reusable auth configuration for a toolkit |
| POST | `/api/v3/webhook_subscriptions` | Create a webhook subscription |
| POST | `/api/v3/webhook_subscriptions/{id}/rotate_secret` | Rotate the signing secret for a webhook |
| GET | `/api/v3/internal/action_execution/logs` | Inspect recent action execution logs |
| GET | `/api/v3/internal/trigger/logs` | Inspect recent trigger delivery logs |

## Key resources

- **Authentication** — Session info and logout for the calling user
- **Auth Configs** — Reusable OAuth client configurations per toolkit
- **Connected Accounts** — Per-user linked accounts and link generation
- **Toolkits and Tools** — Catalog of integrations and the actions they expose
- **Triggers** — Event subscriptions on upstream SaaS tools
- **Webhook Subscriptions** — Outbound webhook delivery and secret rotation
- **Logs** — Action execution and trigger delivery logs
- **Organization and Projects** — Org members, projects, and per-project API keys
- **MCP** — MCP server orchestration and partner endpoints

## Why Jentic

- **Setup:** Wiring the Composio Platform API by hand means learning its API key scheme, standing up connected accounts and auth configs, and wiring your own webhook subscriptions and execution logs. Through Jentic you install once, import the Composio Platform API from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Composio puts the connected account and subscription ids in the URL path (`/connected_accounts/{nanoId}/status`, `/webhook_subscriptions/{id}/rotate_secret`), so a rule can pin your agent to a specific connected account or subscription. You choose the operations it may call, so you can allow reading account status and execution logs while leaving secret rotation out unless you add it.
- **Credential handling:** Your Composio API key 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 'link a connected account' or 'check execution logs', and Jentic returns the matching Composio operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Pipedream** — Workflow platform that brokers OAuth and exposes thousands of SaaS actions
- **Zapier Natural Language Actions** — Zapier's NLA endpoint that exposes Zapier actions to AI agents
- **Anthropic Messages** — Claude chat completions with native tool-use support

## FAQ

### What authentication does the Composio Platform API use?

The API supports several API-key headers depending on context: x-api-key for project keys, x-org-api-key for organization-scoped calls, x-user-api-key for user-scoped calls, and a cookie-based authToken for the dashboard session. Through Jentic the appropriate key is stored encrypted in the vault and injected at execution time.

### Can I link a user's third-party account with the Composio API?

Yes. Create an auth config via POST `/api/v3/auth_configs` for the toolkit you want, then call POST `/api/v3/connected_accounts/link` to generate a hosted link the user follows to grant consent. The resulting connected account is referenced by its nanoid in subsequent action calls.

### How do I execute a toolkit action through the Composio API?

Resolve the action under the Tools resource, then submit its inputs against the user's connected account. Composio injects the connected-account credentials, validates inputs against the action schema, and returns a normalized response that the agent can pass back to the LLM.

### What are the rate limits for the Composio Platform API?

Composio applies plan-tier rate limits with bursts handled per project key. The free tier is in the low hundreds of requests per minute and paid tiers scale up; agents should respect HTTP 429 responses, which Jentic surfaces as structured errors rather than retrying silently.

### How do I subscribe to a SaaS event through Jentic?

Run the Jentic search query 'subscribe to a Composio trigger', load the returned operation (POST `/api/v3/webhook_subscriptions`), and execute it with the URL, event types, and secret. Rotate the secret periodically via POST `/api/v3/webhook_subscriptions/{id}/rotate_secret.`

### Can I inspect why an action execution failed?

Yes. GET `/api/v3/internal/action_execution/logs` returns the recent execution log entries with inputs, outputs, and error details. GET `/api/v3/internal/action_execution/log/{id}` fetches a single entry for deep inspection.

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

Yes. Jentic One runs self-hosted, so your own rules decide which Composio operations and credentials the agent may use. Because Composio puts the connected-account nanoId and subscription id in the URL path, you can pin the agent to a specific connected account or webhook subscription. You choose the operations it may call, so you can allow reading connected-account status and action execution logs while leaving webhook secret rotation out unless you add it.