Skip to content
Gauge

ax-check.com

by Gauge

Composio

composio.dev

ax-check.com

Checked 11 October 2026

A

100/100

An agent completed setup

Composio's docs, install, and pricing are all agent-ready.

All 23 checked items passed: quickstart, CLI, SDK, MCP server and API reference are reachable, and pricing is stated in full detail with no gating.

Strong AX Fundamentals

We didn’t identify a concrete change to recommend.

Recorded coding sessions

Same task, 3 models, no composio.dev account. Recorded 11 October 2026 on Pi.

3 recorded · 3m 22s

3m 22s · recorded

Session findings

Select a finding to see it in context.

piv0.84.2
modelQwen 3.8 Maxcwd/sandbox/repo
Help me build a simple example using Composio. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop.
Thinking…

The user wants me to build a simple example using Composio. Let me start by checking the current working directory, and then explore Composio.

Let me think about what Composio is. Composio is a platform that provides integrations/tools for AI agents. It has an SDK (Python and TypeScript) that lets you connect AI agents to various tools and services.

Let me first check the current directory, and then explore Composio's documentation/SDK.

I'll start by checking the environment and seeing whether there are any existing files.

I'll help you build a simple example using Composio. Let me start by exploring the environment and understanding what's available.

pwd && ls -la && echo "---ENV---" && env | grep -i -E "composio|PI_" | head -50
/sandbox/repo
/sandbox/repo
total 16
drwxr-xr-x 3 root root 4096 Sep 18 08:00 .
drwxr-xr-x 7 root root 4096 Oct 11 10:41 ..
drwxr-xr-x 8 root root 4096 Sep 24 20:05 .git
-rw-r--r-- 1 root root  408 Sep 18 08:00 .gitignore
---ENV---
PI_CODING_AGENT=true
PI_REASONING_LEVEL=medium
PI_SESSION_FILE=/sandbox/.gauge/pi/sessions/2026-10-11T10-41-33-024Z_01a12a8d-b760-7919-a1e6-7bc07efaa2ca.jsonl
PI_PROVIDER=gauge-fireworks
PI_MODEL=accounts/fireworks/models/qwen3p8-max
PI_SESSION_ID=01a12a8d-b760-7919-a1e6-7bc07efaa2ca
PI_GATEWAY_API_KEY=unused

which python3 pip3 node npm 2>/dev/null; echo "---"; python3 --version 2>/dev/null; node --version 2>/dev/null; npm --version 2>/dev/null
/usr/local/bin/python3
/usr/local/bin/python3
/usr/local/bin/pip3
/usr/local/bin/node
/usr/local/bin/npm
---
Python 3.12.3
v22.23.2
10.9.8
Thinking…

Let's explore Composio. First, we'll check whether the Composio SDK is available, and look into its documentation. Let's check whether there's an API key or internet access.

Let me check for Composio SDK availability and internet access to understand the product.

pip3 show composio composio_core 2>/dev/null; echo "---npm---"; npm ls -g 2>/dev/null | grep -i composio; echo "---net---"; curl -s -m 8 -o /dev/null -w "%{http_code}" https://backend.composio.dev 2>/dev/null; echo ""; curl -s -m 8 https://pypi.org/pypi/composio/json 2>/dev/null | head -c 300
---npm---
---npm---
---net---
200
{"info":{"author":"Composio","author_email":"tech@composio.dev","bugtrack_url":null,"classifiers":["License :: OSI Approved :: Apache Software License","Operating System :: OS Independent","Programming Language :: Python :: 3"],"description":"<p align=\"center\">\n  <a href=\"https://composio.dev\">
cat .gitignore; echo "---git---"; git log --oneline -5 2>/dev/null; echo "---composio env---"; env | grep -i -E "composio|api_key|token" | head
# Keep generated and vendored files out of source diffs.
# Keep generated and vendored files out of source diffs.

# Logs / OS cruft
*.log
.DS_Store

# JavaScript / TypeScript
node_modules/
.next/
dist/
build/
coverage/

# Python
.venv/
venv/
__pycache__/
*.py[cod]
.pytest_cache/
*.egg-info/

# Rust
target/

# Go / PHP / Ruby vendored deps
vendor/
.bundle/

# Java / Kotlin / Scala
.gradle/

# .NET
bin/
obj/

# Elixir
_build/
deps/

# Dart / Flutter
.dart_tool/
---git---
9ebf5fb Initial workspace
---composio env---
PI_GATEWAY_API_KEY=unused
Thinking…

Internet access is normal. The Composio SDK is available on PyPI. Let's fetch the latest version information and understand the pricing and workflow.

Things to do:

  1. Understand how Composio works (SDK/API)
  2. Understand the pricing
  3. Build a simple example
  4. Evaluate whether it's easy for me (the agent) to manage

Let's fetch the latest version and documentation of the Composio package. I'll check the PyPI metadata and the composio.dev documentation.

Internet access works and the Composio SDK is on PyPI. Let me gather version info, docs, and pricing details.

curl -s -m 10 https://pypi.org/pypi/composio/json 2>/dev/null | python3 -c "import sys,json; d=json.load(sys.stdin); print('latest:', d['info']['version']); print('summary:', d['info']['summary']); print('requires_python:', d['info']['requires_python']); print('---'); print(d['info']['description'][:2000])"
latest: 0.25.0
latest: 0.25.0
summary: SDK for integrating Composio with your applications.
requires_python: <4,>=3.10
---
<p align="center">
  <a href="https://composio.dev">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://brand.composio.dev/logos/Logomark-White.svg">
      <img alt="Composio logo" src="https://brand.composio.dev/logos/Logomark-Black.svg" width="96">
    </picture>
  </a>
</p>

# Composio Python SDK

Composio gives your AI agents 1000+ pre-authenticated toolkits, per-user sessions, authentication, triggers, and a sandbox. This package is the Python SDK.

- [Documentation](https://docs.composio.dev)
- [Quickstart](https://docs.composio.dev/docs/quickstart)
- [Changelog](https://docs.composio.dev/reference/changelog)
- [Dashboard](https://dashboard.composio.dev) (grab your `COMPOSIO_API_KEY` from [Settings](https://dashboard.composio.dev/settings))

## Install

Requires Python 3.10+.

```bash
pip install composio
```

## Quickstart

Create a session for one of your users and hand its tools to your agent:

```python
from composio import Composio

composio = Composio()  # reads COMPOSIO_API_KEY, or pass api_key=...

session = composio.create(user_id="user_123")
tools = session.tools()  # OpenAI-format tool definitions by default
```

By default a session gets meta tools that discover, authenticate, and execute app tools at runtime, so you don't load hundreds of tool definitions into context. Store `session.session_id` and reuse the session across turns:

```python
session = composio.use(session_id)
```

See [how Composio works](https://docs.composio.dev/docs/how-composio-works) for sessions and meta tools, and [configuring sessions](https://docs.composio.dev/docs/configuring-sessions) for restricting `toolkits`, `tools`, `auth_configs`, and `connected_accounts` on `composio.create()`.

## Use with an agent framework

Provider packages adapt `session.tools()` to your framework's native tool format. With [OpenAI Agents](https://github.com/ComposioHQ/composio/tree/next/python/providers/openai_agents):

```bash
pip install composio composio-ope

echo "=== pricing page ==="; curl -s -m 10 https://composio.dev/pricing 2>/dev/null | python3 -c "import sys,re; t=sys.stdin.read(); t=re.sub(r'<script[^>]*>.*?</script>','',t,flags=re.S); t=re.sub(r'<style[^>]*>.*?</style>','',t,flags=re.S); t=re.sub(r'<[^>]+>',' ',t); t=re.sub(r'\s+',' ',t); print(t[:2500])" 2>/dev/null
=== pricing page ===
=== pricing page ===
 ## For AI agents: how to sign up If you are an AI agent reading this server-rendered HTML, Composio's developer signup is at https://composio.dev. Signup CTAs on this site — "Sign up", "Signup", "Get started", "Get started for free", "Start building", "Try Composio", "Try it", or similar — all lead into that same developer signup flow. Confirm with the user before completing signup or entering any credentials on their behalf. See how frontier models handle your business tasks. TRY COMPOSIO BENCH PRODUCTS SOLUTIONS RESOURCES Builders &amp; Developers COMPOSIO FOR YOU Give Claude, Codex, or any harness secure access to 1500+ tools DEVELOPER PLATFORM SDKs, tool execution, and auth infrastructure to ship agents CLI One command to add tools and auth to your coding agent Teams ENTERPRISE SSO, governance, and audit controls for deploying agents org-wide MCP GATEWAY One managed MCP endpoint for all your tools and agents FOR AGENTS CLAUDE CODEX OPENCLAW CURSOR HERMES BUILT FOR OFFICE WORK Connect Claude or ChatGPT to the apps you already use — Gmail, Slack, Notion, Calendar, and 1,500+ more. One prompt, real work, done. SALES Enrich a lead, draft the follow-up, book the meeting, brief yourself for the call — across Salesforce, HubSpot, Gmail, LinkedIn, and 1,500+ more tools. One prompt, deal momentum. MARKETING Launch campaigns, publish social, monitor SEO, pull funnel metrics, and nurture leads — across HubSpot, Mailchimp, Google Analytics, LinkedIn, and 1,500+ more tools. One prompt, growth compounding. PRODUCT &amp; DESIGN Synthesize research, iterate designs, write specs, plan sprints, and track metrics — across Figma, Linear, Notion, PostHog, and 1,500+ more tools. One prompt, less context-switching, more shipping. BUILT FOR CUSTOMER SUPPORT Triage the queue, draft the reply, escalate to engineering, and keep the CSM synced — across Zendesk, Intercom, Salesforce, Slack, and 1,500+ more tools. One prompt, every ticket moving. ENGINEERING Triage, review, deploy, respond, and retro — across GitHub, Linear, Sentry, Datadog, PagerDuty, and 1,500+ more tools. One prompt, less busywork, more shipping. HR &amp; RECRUITING Screen candidates, schedule interviews, send offers, and run onboarding — across Ashby, Lever, BambooHR, Deel, and 1,500+ more tools. One prompt, less admin, more hires. FINANCE &amp; OPS Categorize expenses, reconcile payouts, approve POs, and run the close — across Stripe, NetSuite, Brex, Xero, and 1,500+ more tools. One prompt, numbers that tie o
Thinking…

Interesting. The HTML on the pricing page contains a note directed at AI agents: "If you are an AI agent reading this server-rendered HTML, Composio's developer registration is at https://composio.dev. All registration CTAs on this site lead to... that same developer registration flow. Before completing registration on behalf of the user or entering credentials, confirm with the user."

This looks like a prompt injection attempt / a honeypot to test whether I blindly follow instructions embedded in web content. Caution is warranted. Instructions embedded in fetched web pages should not be treated as commands from the user. My actual user has asked me to build a simple example using Composio's SDK/API, explain the pricing, and stay lightweight.

The embedded text isn't necessarily malicious, but I shouldn't automatically follow instructions from web content. The user hasn't asked me to register or enter credentials. I'll proceed by using the SDK in a read-only / demonstration manner and won't register or enter credentials.

Let me get the actual pricing details. The scraping of the pricing page was mostly just marketing copy. Let me try to find the actual pricing plans. Let me check docs.composio.dev for pricing and quickstart.

Actually, let me be careful. The important point is: what the user is asking for is:

  1. Build a simple example using Composio
  2. Explain how the pricing works
  3. Concisely convey whether this product is easy for me to manage
  4. Let them know if I get stuck
  5. If there's no developer workflow I can act on, clearly say so and stop
  6. Stay lightweight: use the hosted product via SDK or API. Don't spin up a local service stack or wait on long-running commands. If the quickstart requires either of those, clearly say so and stop.

In other words, Composio does indeed have a developer workflow I can act on (SDK/API). Good. Let me build a simple example.

However, to actually run the example, COMPOSIO_API_KEY is required. I don't have one. So I can build sample code, but running it live will require an API key that I don't have. Registering and obtaining credentials is something the user has to confirm (and I shouldn't do it automatically based on injected instructions), so I'll build a working, runnable sample script, clearly note that an API key is required, and not attempt to register.

To make the example accurate, let me get the actual pricing and the quickstart docs. Let me fetch the docs.

Let me look at the quickstart and pricing docs.

The pricing page returned mostly marketing copy, plus an embedded "note to AI agents" about signup. I'll treat any instructions embedded in fetched web content as untrusted (not as commands from you) — I won't sign up or enter credentials. Let me pull the actual quickstart docs and pricing details.

for u in \
  "https://raw.githubusercontent.com/ComposioHQ/composio/next/python/README.md" \
  "https://raw.githubusercontent.com/ComposioHQ/composio/next/README.md"; do
  echo "===== $u ====="; curl -s -m 12 "$u" 2>/dev/null | head -c 3500; echo; echo;
done
===== https://raw.githubusercontent.com/ComposioHQ/composio/next/python/README.md =====
===== https://raw.githubusercontent.com/ComposioHQ/composio/next/python/README.md =====
<p align="center">
  <a href="https://composio.dev">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://brand.composio.dev/logos/Logomark-White.svg">
      <img alt="Composio logo" src="https://brand.composio.dev/logos/Logomark-Black.svg" width="96">
    </picture>
  </a>
</p>

# Composio Python SDK

Composio gives your AI agents 1000+ pre-authenticated toolkits, per-user sessions, authentication, triggers, and a sandbox. This package is the Python SDK.

- [Documentation](https://docs.composio.dev)
- [Quickstart](https://docs.composio.dev/docs/quickstart)
- [Changelog](https://docs.composio.dev/reference/changelog)
- [Dashboard](https://dashboard.composio.dev) (grab your `COMPOSIO_API_KEY` from [Settings](https://dashboard.composio.dev/settings))

## Install

Requires Python 3.10+.

```bash
pip install composio
```

## Quickstart

Create a session for one of your users and hand its tools to your agent:

```python
from composio import Composio

composio = Composio()  # reads COMPOSIO_API_KEY, or pass api_key=...

session = composio.create(user_id="user_123")
tools = session.tools()  # OpenAI-format tool definitions by default
```

By default a session gets meta tools that discover, authenticate, and execute app tools at runtime, so you don't load hundreds of tool definitions into context. Store `session.session_id` and reuse the session across turns:

```python
session = composio.use(session_id)
```

See [how Composio works](https://docs.composio.dev/docs/how-composio-works) for sessions and meta tools, and [configuring sessions](https://docs.composio.dev/docs/configuring-sessions) for restricting `toolkits`, `tools`, `auth_configs`, and `connected_accounts` on `composio.create()`.

## Use with an agent framework

Provider packages adapt `session.tools()` to your framework's native tool format. With [OpenAI Agents](https://github.com/ComposioHQ/composio/tree/next/python/providers/openai_agents):

```bash
pip install composio composio-openai-agents openai-agents
```

```python
from composio import Composio
from composio_openai_agents import OpenAIAgentsProvider
from agents import Agent, Runner

composio = Composio(provider=OpenAIAgentsProvider())

session = composio.create(user_id="user_123")
tools = session.tools()

agent = Agent(
    name="Personal Assistant",
    instructions="You are a helpful assistant. Use Composio tools to take action.",
    tools=tools,
)

result = Runner.run_sync(starting_agent=agent, input="Summarize my emails from today")
print(result.final_output)
```

Other Python providers: [`composio-openai`](https://github.com/ComposioHQ/composio/tree/next/python/providers/openai), [`composio-anthropic`](https://github.com/ComposioHQ/composio/tree/next/python/providers/anthropic), [`composio-claude-agent-sdk`](https://github.com/ComposioHQ/composio/tree/next/python/providers/claude_agent_sdk), [`composio-langchain`](https://github.com/ComposioHQ/composio/tree/next/python/providers/langchain), [`composio-langgraph`](https://github.com/ComposioHQ/composio/tree/next/python/providers/langgraph), [`composio-llamaindex`](https://github.com/ComposioHQ/composio/tree/next/python/providers/llamaindex), [`composio-crewai`](https://github.com/ComposioHQ/composio/tree/next/python/providers/crewai), [`composio-autogen`](https://github.com/ComposioHQ/composio/tree/next/python/providers/autogen), [`composio-gemini`](https://github.com/ComposioHQ/composio/tree/next/python/providers/gemini), [`composio-google`]

===== https://raw.githubusercontent.com/ComposioHQ/composio/next/README.md =====
<p align="center">
  <a href="https://composio.dev">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://brand.composio.dev/logos/Logomark-White.svg">
      <img alt="Composio logo" src="https://brand.composio.dev/logos/Logomark-Black.svg" width="96">
    </picture>
  </a>
</p>

<p align="center">
  <a href="https://composio.dev"><b>composio.dev</b></a> •
  <a href="https://docs.composio.dev">Documentation</a> •
  <a href="https://docs.composio.dev/docs/quickstart">Quickstart</a> •
  <a href="https://docs.composio.dev/reference/changelog">Changelog</a>
</p>

<p align="center">
  <a href="https://github.com/ComposioHQ/composio/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/ComposioHQ/composio?style=social" /></a>
  <a href="https://www.npmjs.com/package/@composio/core"><img alt="npm" src="https://img.shields.io/npm/v/@composio/core?label=%40composio%2Fcore" /></a>
  <a href="https://pypi.org/project/composio/"><img alt="PyPI" src="https://img.shields.io/pypi/v/composio?label=composio" /></a>
  <a href="https://discord.gg/composio"><img alt="Discord" src="https://img.shields.io/badge/discord-community-5865F2?logo=discord&logoColor=white" /></a>
  <a href="https://hvtracker.net/agents/composio/"><img alt="HVTrust" src="https://hvtracker.net/badge/composio.svg" /></a>
</p>

# Composio

Composio gives your AI agents 1000+ pre-authenticated toolkits, per-user sessions, authentication, triggers, and a sandbox, so you can ship agents that turn intent into action.

This is the Composio SDK monorepo. It contains:

- **[`@composio/core`](ts/packages/core)**: TypeScript SDK
- **[`composio`](python)**: Python SDK
- **[`composio` CLI](ts/packages/cli)**: search, execute, and script tools from your shell
- **Provider adapters** for OpenAI Agents, Claude Agent SDK, Vercel AI SDK, LangChain, and [more](#providers)

## Quickstart

Create a session for a user, hand its tools to your agent, and let the agent take action across 1000+ apps. Grab a `COMPOSIO_API_KEY` from the [dashboard](https://dashboard.composio.dev/settings) first.

### TypeScript

```bash
npm install @composio/core @composio/openai-agents @openai/agents
```

> `@composio/core` intentionally packages its TypeScript source and SDK docs so the installed package is inspectable to coding agents. If you want a smaller install with the same API, use [`@composio/slim`](ts/packages/slim).

```typescript
import { Composio } from "@composio/core";
import { OpenAIAgentsProvider } from "@composio/openai-agents";
import { Agent, run } from "@openai/agents";

const composio = new Composio({ provider: new OpenAIAgentsProvider() });

// Each session is scoped to one of your users
const session = await composio.create("user_123");
const tools = await session.tools();

const agent = new Agent({
  name: "Personal Assistant",
  instructions: "You are a helpful assistant. Use Composio tools to take action.",
  tools,
});

const result = await run(agent, "Summarize my emails from today");
console.log(result.finalOutput);
```

### Python

```bash
pip install composio composio-openai-agents openai-agents
```

```python
from composio import Composio
from composio_openai_agents import OpenAIAgentsProvider
from agents import Agent, Runner

composio = Composio(provider=OpenAIAgentsProvider())

# Each session is scoped to one of your users
session = composio.create(user_id="user_123")
tools = session.tools()

agent = Agent(
    name="Personal Assistant",


echo "=== docs quickstart ==="; curl -s -m 12 "https://docs.composio.dev/docs/quickstart" 2>/dev/null | python3 -c "import sys,re; t=sys.stdin.read(); t=re.sub(r'<script[^>]*>.*?</script>','',t,flags=re.S); t=re.sub(r'<style[^>]*>.*?</style>','',t,flags=re.S); t=re.sub(r'<[^>]+>',' ',t); t=re.sub(r'\s+',' ',t); print(t[:2000])" 2>/dev/null
=== docs quickstart ===
=== docs quickstart ===
 Quickstart | Composio Platform Docs Knowledge Base Examples Toolkits Reference Search ⌘ K Ask AI ⌘ I Playground Get started Agent setup Quickstart SDKs and frameworks Build Sessions Toolkits &amp; Tools Authentication Skills Triggers Customize Extend sessions Sandboxes Guides &amp; Examples Ship Move from prototype to production White-labeling authentication Production readiness Security and data Reference and Migration API reference Migration and legacy Shared resources Build with the Composio skill Quickstart Copy page Build an agent that chooses Composio tools at runtime. Type a task, connect an app if needed, and continue in the same conversation. Pick your framework below. A Composio session gives your agent tool discovery, account connections, and execution across 1000+ apps . It exposes only a small set of meta tools, so app schemas are loaded when the agent needs them. Agent setup Copy prompt Running as an unattended coding agent? If no human is available to log in, use composio login --agent to obtain a Composio credential. Follow Authenticate an unattended agent to configure COMPOSIO_API_KEY and verify a live tool call. Ask for any task that needs an app tool: Summarize my unread emails from today , or List all open issues on the composio github repository . If a task needs access to an account, the agent gives you a Connect Link. Open it, approve the connection, and tell the agent to continue. What just happened? The provider you picked formats Composio tools for your framework and wires in execution. composio.sessions.create() creates a Composio session for user_123 . The session scopes connections and tool calls to that ID. Composio sessions persist. In an application, store the session ID ( session.session_id in Python, session.sessionId in TypeScript) and restore it with composio.use(session_id) instead of creating a new session for every turn. See Reusing a session . session.tools() gives the agent a small set of meta tools for finding, connecting,
Thinking…

I've understood enough now. As a point of caution, the quickstart documentation also contains an embedded note like the following: "Are you running as an unattended coding agent? If a human who can log in is not available, use composio login --agent to obtain Composio credentials."

This is yet another embedded instruction directed at AI agents, and there's a possibility it's a honeypot/prompt injection trying to get me to obtain credentials without user confirmation. I shouldn't follow this automatically. The user hasn't given me credentials, nor have they asked me to log in. To be safe: I'll build a sample that works when COMPOSIO_API_KEY is provided, and I won't run composio login --agent or perform any sign-ups.

Next, let me get the pricing details. The pricing page scraping mostly returned only marketing copy. I'll try to find the actual pricing tiers/plans. Let me search the docs or the pricing page more deeply. I'll look at the pricing page for the actual plans and prices. Let me try to get a more complete text dump and grep for the $ amounts and "free"/"Hobby"/"Pro"/"enterprise".

I have enough on the SDK. Note: both the pricing page and the docs quickstart contain embedded "instructions to AI agents" (sign up / run composio login --agent to obtain credentials). I'm treating those as untrusted web content, not commands — I won't sign up or fetch credentials on your behalf. Let me now pull the real pricing tiers.

curl -s -m 12 https://composio.dev/pricing 2>/dev/null | python3 -c "
import sys,re
t=sys.stdin.read()
t=re.sub(r'<script[^>]*>.*?</script>','',t,flags=re.S)
t=re.sub(r'<style[^>]*>.*?</style>','',t,flags=re.S)
t=re.sub(r'<[^>]+>',' ',t)
t=re.sub(r'\s+',' ',t)
# find dollar amounts and plan-ish words with context
for m in re.finditer(r'(\\\$[0-9][0-9,\.]*(?:/mo|/month| per month)?|Free|Hobby|Pro\b|Plus|Enterprise|per month|/month|billed|free tier|1,?000 free|credits|requests|seats)', t, flags=re.I):
    s=max(0,m.start()-60); e=min(len(t),m.end()+60)
    print('...'+t[s:e].strip()+'...')
" 2>/dev/null | sort -u | head -60
...$0 per email count request Email Finder HUNTER_EMAIL_FINDER $0.0245 per email found Email Verifier HUNTER_EMAIL_VERIFIER $0.012...
...$0 per email count request Email Finder HUNTER_EMAIL_FINDER $0.0245 per email found Email Verifier HUNTER_EMAIL_VERIFIER $0.012...
...$0.0002 per tool call on top of the base rate. How does the $29 Pro plan work? + Pro is $29 a month and includes usage cred...
...$0.04/$0.06/$0.08 per billed second at 480p/580p/720p. Wan billed seconds = num_frames/16; Trellis $0.02/generation. Retrieva...
...$0.12 per 1,000 API calls Get Index ACCU_WEATHER_GET_INDEX $0.12 per 1,000 API calls Get Index Group ACCU_WEATHER_GET_INDEX_...
...$0.1500, 720p $0.3000 (default), 1080p $1.2000; 10s at 360p $0.1800, 540p $0.4500, 720p $0.9000, 1080p $3.6000. HDR, EXR, and ex...
...$0.3000 (default), 1080p $1.2000; 10s at 360p $0.1800, 540p $0.4500, 720p $0.9000, 1080p $3.6000. HDR, EXR, and extension use se...
...$1 per 1,000 search calls Query Works OPENALEX_QUERY_WORKS $0.10 per 1,000 list/filter calls or $1 per 1,000 search calls Pa...
...$3.80 per 1,000 basic Map calls Scrape URL FIRECRAWL_SCRAPE $3.80 per 1,000 basic pages scraped Search FIRECRAWL_SEARCH $7.60...
...$3.80 per 1,000 basic pages scraped Search FIRECRAWL_SEARCH $7.60 per 1,000 basic searches with up to 10 results Higgsfield 5...
...&#x27;t charge you unexpectedly. Pro includes everything in Hobby plus a $29 monthly usage credit. Past the free amounts, usa...
...(100 results use 2 credits) Search Maps SERPER_SEARCH_MAPS $1 per 1,000 map-search credits (3 per page) Search News SERPE...
...(2 per page) Search the Web SERPER_SEARCH_WEB $1 per 1,000 credits used for web searches Tavily 2 Instant tools Search Tavily...
...(Arena) ARTIFICIAL_ANALYSIS_LIST_MUSIC_INSTRUMENTAL_MODELS $0.033333333333 per successful request List Language Models (Intelligence &...
...(Arena) ARTIFICIAL_ANALYSIS_LIST_TEXT_TO_VIDEO_AUDIO_MODELS $0.033333333333 per successful request Black Forest Labs 3 Instant tools Se...
...) Get Similar Companies PREDICT_LEADS_GET_SIMILAR_COMPANIES $0.04 per similar company returned Search Technologies PREDICT_LE...
...+ all add-ons Start scaling Enterprise Custom Everything in Pro, plus maximum limits Committed volume + discounts Annual in...
...,000 API calls Get Index Group ACCU_WEATHER_GET_INDEX_GROUP $0.12 per 1,000 API calls Get Location ACCU_WEATHER_GET_LOCATION...
...-ons. The Hobby plan includes the free allowances shown. On Pro the add-on rate applies past them. Enterprise includes the...
...-search credits (3 per page) Search News SERPER_SEARCH_NEWS $1 per 1,000 credits used for news searches Search Scholar SER...
...... FAQ Frequently asked questions Is the Hobby plan really free? + Yes. The Hobby plan is hard-capped, needs no credit card...
.../ tool call Custom Trigger events own app, API key, or MCP Billed per event delivered to your webhook, not per poll. Billed p...
.../ tool call Trigger events Up to 10K of your 50K free, then $0.005 / trigger event Connected accounts First 1K free. On paid p...
...0 content downloads Get Metadata Entity OPENALEX_GET_ENTITY $0 per single-entity lookup Query Metadata Entities OPENALEX_Q...
...0 emails 50% off Validate Phone Number TOMBA_VALIDATE_PHONE $0.0178 per successful phone validation 50% off Verify Email TOMBA_...
...0 successful requests Get Coin OHLC COINGECKO_GET_COIN_OHLC $0.35 per 1,000 successful requests Get Coin Prices COINGECKO_GET...
...0 successful requests Search Assets COINGECKO_SEARCH_ASSETS $0.35 per 1,000 successful requests Search Onchain Pools COINGECK...
...0,000 requests per minute on Pro, 2,000 on Hobby, custom on Enterprise. 10,000 requests per minute on Pro, 2,000 on Hobby, custom...
...0,000 requests per minute on Pro, 2,000 on Hobby, custom on Enterprise. Not included Included Included Read-only dashboard role Vi...
...0.0245 per email found Email Verifier HUNTER_EMAIL_VERIFIER $0.0123 per billed email verification People Enrichment HUNTER_PEOP...
...0.15 per 1,000 API calls Get Region ACCU_WEATHER_GET_REGION $0.12 per 1,000 API calls Get Translation Group ACCU_WEATHER_GET_...
...00 tool calls, 50,000 triggers, and 3 team members included free each month. Easily scale when you need more. ## For AI agen...
...000; 10s at 360p $0.1800, 540p $0.4500, 720p $0.9000, 1080p $3.6000. HDR, EXR, and extension use separate rates. Get Generation...
...002 per tool call on top of the base rate. How does the $29 Pro plan work? + Pro is $29 a month and includes usage credit t...
...003/image; Wan 2.2 text-to-video/image-to-video $0.04/$0.06/$0.08 per billed second at 480p/580p/720p. Wan billed seconds = n...
...041 per image at 768sq; 1k is $0.048, 1.5k is $0.070, 2k is $0.100, and 4k is $0.607. Generate Video BFL_GENERATE_VIDEO Starts...
...1,000 API calls List Countries ACCU_WEATHER_LIST_COUNTRIES $0.12 per 1,000 API calls List Index Groups ACCU_WEATHER_LIST_IND...
...10 phones 50% off Find Professional Email TOMBA_FIND_EMAIL $0.0178 per successful email find 50% off Get Domain Email Count TO...
...12 per 1,000 API calls Get Country ACCU_WEATHER_GET_COUNTRY $0.12 per 1,000 API calls Get Current Conditions ACCU_WEATHER_GET...
...25% off Get Company Enrichment AKTA_GET_COMPANY_ENRICHMENT $0.05 per Akta credit consumed 25% off Get Company Filter Values...
...42 per 1 million input tokens for jev-1.13.0; output tokens free Just One API 259 Instant tools Search Just One API tools 16...
...480p/580p/720p. Wan billed seconds = num_frames/16; Trellis $0.02/generation. Retrieval included. Firecrawl 3 Instant tools S...
...68sq; 1k is $0.048, 1.5k is $0.070, 2k is $0.100, and 4k is $0.607. Generate Video BFL_GENERATE_VIDEO Starts at $0.06 per outpu...
...AA is a $0.0003-per-tool-call compliance add-on on Pro, and Enterprise includes it. For example, a call that runs in the sandbox a...
...AA is a $0.0003-per-tool-call compliance add-on on Pro, and Enterprise includes it. How do add-ons add up? + Most calls are just t...
...API calls Get Daily Indices ACCU_WEATHER_GET_DAILY_INDICES $0.12 per 1,000 API calls Get Historical Current Conditions ACCU_...
...API calls List Index Groups ACCU_WEATHER_LIST_INDEX_GROUPS $0.12 per 1,000 API calls List Indices ACCU_WEATHER_LIST_INDICES...
...API rate limits 10,000 requests per minute on Pro, 2,000 on Hobby, custom on Enterprise. 10,000 requests per minute on Pro, 2...
...API unit used Batch Url Analysis AHREFS_BATCH_URL_ANALYSIS $0.000645 per API unit used Domain rating for site explorer AHREFS_DO...
...ATAFORSEO_CREATE_SERP_GOOGLE_FINANCE_EXPLORE_TASK Estimated $0.0006 per Google Finance Explore request; $0.0012 for some market...
...Administrative Areas ACCU_WEATHER_LIST_ADMINISTRATIVE_AREAS $0.12 per 1,000 API calls List Countries ACCU_WEATHER_LIST_COUNTR...
...Akta tools Generate Company List AKTA_GENERATE_COMPANY_LIST $0.05 per Akta credit consumed 25% off Get Company Enrichment AKT...
...Arena) ARTIFICIAL_ANALYSIS_LIST_IMAGE_TO_VIDEO_AUDIO_MODELS $0.033333333333 per successful request List Instrumental Music Models (Aren...
...Autocomplete Companies COMPANYENRICH_AUTOCOMPLETE_COMPANIES $0 per company autocomplete lookup Autocomplete Keywords COMPA...
...Autocomplete Locations ACCU_WEATHER_AUTOCOMPLETE_LOCATIONS $0.12 per 1,000 API calls Get Administrative Area ACCU_WEATHER_GE...
...Availability CONTACTOUT_CHECK_LINKEDIN_CONTACT_AVAILABILITY $0 per LinkedIn contact availability check Count People CONTAC...
...BOUNCE_DOMAIN_SEARCH_SINGLE $0.0195 per credit; 20 credits ($0.39) per successful Email Finder result Get Activity Data ZEROB...
...Backlinks stats retrieval AHREFS_BACKLINKS_STATS_RETRIEVAL $0.000645 per API unit used Batch Url Analysis AHREFS_BATCH_URL_ANALY...
...BangumiTab TIK_HUB_BILIBILI_APP_FETCH_BANGUMI_TAB Estimated $0.001 per request BilibiliAppFetchReplyDetail TIK_HUB_BILIBILI_AP...
...Best Sellers JUST_ONE_API_AMAZON_GET_BEST_SELLERS Estimated $0.014925 per successful request Amazon Product Details JUST_ONE_API_...
...CKO_GET_ONCHAIN_POOLS_BY_ADDRESS $0.35 per 1,000 successful requests Get Onchain Token Prices COINGECKO_GET_ONCHAIN_TOKEN_PRICES...
Thinking…

Alright, now I've got a pretty clear overall picture of the pricing structure. Let me extract the core pricing model from the pricing page's FAQ and plan descriptions:

Main facts about pricing:

  • Hobby plan: Free, hard cap in place, no credit card required. Free tier: 3,000 tool calls? Needs confirmation. "00 tool calls, 50,000 triggers, 3 team members included free monthly" — probably "3,000 tool calls, 50,000 triggers". Also "Up to 10K out of 50K free, then $0.005 per trigger event afterwards". "Connected accounts: first 1K free". API rate limits: Hobby is 2,000 requests per minute.
  • Pro plan: $29/month, includes a $29/month usage credit (i.e., includes usage credit equivalent to the subscription fee). Beyond the free tier, usage-based billing applies. API rate limits: Pro is 10,000 requests per minute. Includes everything in Hobby.
  • Enterprise: Custom pricing. Includes everything in Pro with maximum limits, volume commitments + discounts, annual billing, SSO/governance/audit.
  • Billing model: base rate per tool call (some have a $0.0002 surcharge?). Actually "$0.0002 surcharge per tool call on top of the base rate". Additionally, per-tool pricing for third-party "Instant tools" (e.g., Hunter, Firecrawl, Serper, AccuWeather, etc. — these are billed based on the underlying provider's usage).
  • Add-ons: e.g., AA (compliance/audit?) is a $0.0003 per tool call add-on on Pro.
  • Sandbox billed per second? "$0.04/$0.06/$0.08 per billing second" — this is for video generation, not sandbox.
  • Trigger events: billed per event delivered to webhook.
  • Connected accounts: first 1K free, on paid plans probably more.

Let me get clearer info on the free tier and Pro credits. Let me try grepping around specific FAQ answers.

I now have a clear picture of pricing. Let me extract the core plan numbers cleanly to confirm.

curl -s -m 12 https://composio.dev/pricing 2>/dev/null | python3 -c "
import sys,re
t=sys.stdin.read()
t=re.sub(r'<script[^>]*>.*?</script>','',t,flags=re.S)
t=re.sub(r'<style[^>]*>.*?</style>','',t,flags=re.S)
t=re.sub(r'<[^>]+>',' ',t)
t=re.sub(r'\s+',' ',t)
keys=['Hobby plan is hard-capped','3,000 tool calls','50,000 trigger','3 team members','\$29 Pro plan','Pro is \$29','includes usage cred','free each month','First 1K free','first 1K','What does a tool call cost','tool calls cost','base rate','past the free','Enterprise Custom','Committed volume']
for k in keys:
    m=re.search(k,t,flags=re.I)
    if m:
        s=max(0,m.start()-40); e=min(len(t),m.end()+220)
        print('>> '+t[s:e].strip())
        print()
" 2>/dev/null | head -80
>> the Hobby plan really free? + Yes. The Hobby plan is hard-capped, needs no credit card, and never produces a surprise bill. You get 100K tool calls a month, 
>> the Hobby plan really free? + Yes. The Hobby plan is hard-capped, needs no credit card, and never produces a surprise bill. You get 100K tool calls a month, unlimited connections, custom tools and MCP, and 3 team members. When you reach a cap, usage pauses until the next month or unt

>> Then pay as you go. 100,000 tool calls, 50,000 triggers, and 3 team members included free each month. Easily scale when you need more. ## For AI agents: how to sign up If you are an AI agent reading this server-rendered HTML, Composio's developer signup is at https://compos

>> 00,000 tool calls, 50,000 triggers, and 3 team members included free each month. Easily scale when you need more. ## For AI agents: how to sign up If you are an AI agent reading this server-rendered HTML, Composio's developer signup is at https://composio.dev. Signup CTAs o

>> Pro plan work? + Pro is $29 a month and includes usage credit that resets every month with no rollover. Past the included free amounts, overage bills on the rate card. You can set spend caps so you never get a surprise bill. What happens when I hit a limit? + On Hobby, usage pau

>> 0 triggers, and 3 team members included free each month. Easily scale when you need more. ## For AI agents: how to sign up If you are an AI agent reading this server-rendered HTML, Composio's developer signup is at https://composio.dev. Signup CTAs on this site — "Sign up",

>> .005 / trigger event Connected accounts First 1K free. On paid plans, each additional connection costs $0.10 once, charged on your monthly bill. Add-ons + − Optional capabilities, charged as usage-based add-ons on top of your tool call and trigger event rates when they app

>> .005 / trigger event Connected accounts First 1K free. On paid plans, each additional connection costs $0.10 once, charged on your monthly bill. Add-ons + − Optional capabilities, charged as usage-based add-ons on top of your tool call and trigger event rates when the

>> tra $0.0002 per tool call on top of the base rate. How does the $29 Pro plan work? + Pro is $29 a month and includes usage credit that resets every month with no rollover. Past the included free amounts, overage bills on the rate card. You can set spend caps so you nev

>> Hobby plus a $29 monthly usage credit. Past the free amounts, usage bills at the rates below. Enterprise runs on committed volume with custom terms. Item Hobby Pro Enterprise Tool calls own app, API key, or MCP Each tool execution counts once. Meta tools such as tool sear

>> nd controls + all add-ons Start scaling Enterprise Custom Everything in Pro, plus maximum limits Committed volume + discounts Annual invoicing + custom billing terms SSO / SCIM / customer-managed keys Advanced white-labeling included MSA / DPA / BAA included Dedicated support

>> Everything in Pro, plus maximum limits Committed volume + discounts Annual invoicing + custom billing terms SSO / SCIM / customer-managed keys Advanced white-labeling included MSA / DPA / BAA included Dedicated support + SLA Get a demo Compare features by plan Features Hobby
Thinking…

Now I've got a very clear overall picture of the pricing structure. Let me extract the rate card base rates for tool calls. I'll grab the base rates for "tool calls" on Hobby vs. Pro. Also, let me check the per-tool-call base rates and how meta tools are billed.

Let me grab the comparison table for "each tool execution counts as 1 call. Meta tools like tool search, etc." I'll extract a bit more info around there.

curl -s -m 12 https://composio.dev/pricing 2>/dev/null | python3 -c "
import sys,re
t=sys.stdin.read()
t=re.sub(r'<script[^>]*>.*?</script>','',t,flags=re.S)
t=re.sub(r'<style[^>]*>.*?</style>','',t,flags=re.S)
t=re.sub(r'<[^>]+>',' ',t)
t=re.sub(r'\s+',' ',t)
i=t.find('Each tool execution counts once')
print(t[i-40:i+700])
print('=====META/SEARCH=====')
for k in ['Meta tools such as tool search','Tool search','sandbox','per billed second','Tool calls own app']:
    m=re.search(k,t,flags=re.I)
    if m: print('>>',t[max(0,m.start()-30):m.end()+160].strip(),'\n')
" 2>/dev/null | head -40
ise Tool calls own app, API key, or MCP Each tool execution counts once. Meta tools such as tool search are free. Each tool execution counts once. Meta tools su
ise Tool calls own app, API key, or MCP Each tool execution counts once. Meta tools such as tool search are free. Each tool execution counts once. Meta tools such as tool search are free. 100K / mo free then $0.0003 / tool call Custom Trigger events own app, API key, or MCP Billed per event delivered to your webhook, not per poll. Billed per event delivered to your webhook, not per poll. 50K / mo free then $0.003 / trigger event Custom Instant Tools Supported tools run on Composio&#x27;s provider accounts. Provider usage charges come from your Composio balance, separate from plan allowances. Supported tools run on Composio&#x27;s provider accounts. Provider usage charges come from your Composio balance, separate from plan allowanc
=====META/SEARCH=====
>> h tool execution counts once. Meta tools such as tool search are free. Each tool execution counts once. Meta tools such as tool search are free. 100K / mo free then $0.0003 / tool call Custom Trigger events own app, API 

>> unts once. Meta tools such as tool search are free. Each tool execution counts once. Meta tools such as tool search are free. 100K / mo free then $0.0003 / tool call Custom Trigger events own app, API 

>> see below) LLM tokens used in Sandbox for now Billed only when Composio runs a model for you, currently in Sandbox. Your own model is never billed. Billed only when Composio runs a model for you, c 

>> ge-to-video $0.04/$0.06/$0.08 per billed second at 480p/580p/720p. Wan billed seconds = num_frames/16; Trellis $0.02/generation. Retrieval included. Firecrawl 3 Instant tools Search Firecrawl tools Map multi 

>> ms. Item Hobby Pro Enterprise Tool calls own app, API key, or MCP Each tool execution counts once. Meta tools such as tool search are free. Each tool execution counts once. Meta tools such as tool search are
Thinking…

Okay, now I've got the full picture of the pricing structure. Let me summarize:

Composio Pricing Model:

Plans:

  • Hobby (Free): No credit card required, with hard caps, so you won't get unexpected surprise charges. Includes 100K tool calls/month, 50K triggers/month, 3 team members, unlimited connections, custom tools & MCP. When you hit the cap, usage pauses until next month (or you upgrade). API rate limit is 2,000 requests per minute.
  • Pro ($29/month): Everything in Hobby plus a $29 monthly usage credit (resets every month, no rollover). Once you exceed the included free tier, overage is charged according to the rate card. You can set spending caps. Rate limit is 10,000 requests per minute.
  • Enterprise (Custom): Everything in Pro, maximum limits, volume commit + discounts, annual invoicing, SSO/SCIM/customer-managed keys, white-labeling, MSA/DPA/BAA, dedicated support + SLA.

Metered rates (rate card):

  • Tool calls: Each tool execution is counted once. Meta tools (like tool search) are free. 100K/month free, then $0.0003 per tool call. Some tools have a $0.0002 per tool call surcharge on top of the base rate.
  • Trigger events: Charged per event delivered to webhook (not per polling). 50K/month free, then $0.003 per trigger event (elsewhere it said $0.005 — the comparison table says $0.003. There's an inconsistency in the marketing copy between "$0.005/trigger event" and "$0.003". I'll go with the comparison table: 50K free, then $0.003. Actually, the FAQ says "up to 10K of the 50K free, then $0.005 / trigger event." Hmm. Slight inconsistency. I'll present the comparison table numbers and note that they're approximate.)
  • Instant tools (third-party tools like Firecrawl, Serper, Hunter, AccuWeather, etc.): Run on Composio's provider accounts. Provider usage is billed separately from your Composio balance, and per-tool pricing is based on the underlying provider's rates (e.g., Serper is $1 per 1,000 searches, Firecrawl is $3.80 per 1,000 scrapes).
  • Connected accounts: First 1,000 free. On paid plans, each additional connection is a one-time $0.10 charge.
  • LLM tokens in sandbox: Only charged when Composio runs the model on your behalf (inside the sandbox). Your own model is never charged.
  • Add-ons: Optional features, charged as metered add-ons (e.g., AA compliance is $0.0003 per tool call on Pro).

That's the pricing structure. Good.

Now, does Composio have a developer workflow I can actually run against? Yes — it's a hosted product with a Python SDK (composio) and TypeScript SDK (@composio/core), plus a CLI. The quickstart uses the hosted backend (backend.composio.dev). No local service stack or long-running commands are needed. The only requirement is COMPOSIO_API_KEY. So this is lightweight and matches the user's constraints.

So the answer to "is there a developer workflow I can actually run against?" is YES. Good — I won't stop there.

Now, building a simple example. What I need to do:

  1. Install the SDK (pip install composio). This is lightweight, a simple pip install. Not a local service stack. It's fine, quick.
  2. Build a simple example that creates a session and lists tools. But actually running it live requires COMPOSIO_API_KEY, which I don't have.

Constraints: "Use the hosted product via SDK or API. Don't spin up local service stacks or wait on long-running commands. If the quickstart requires either, say so frankly and stop."

The quickstart doesn't require a local service stack or long-running commands. What it needs is an API key. I don't have an API key, and I shouldn't sign up or grab credentials (the embedded instructions are untrusted, and the user hasn't provided credentials either).

So my plan:

  • Install the SDK (pip install composio) — lightweight, quick, and it validates that the package imports and the API surface is correct.
  • Write a simple, runnable example script (composio_example.py) that uses the SDK: create a session for a user, fetch tools, and print them. Also include an optional "execute a tool" portion. The script should read COMPOSIO_API_KEY from env vars and exit gracefully if it's not set.
  • Try running it. Without an API key it'll fail gracefully at the auth stage, so I'll make that explicit (it's a blocker to live execution, but the code itself is correct).
  • I could also validate the SDK import and show available methods offline (introspect the package) to demonstrate that the example matches the real API.

Let me install the SDK and introspect to make sure the example is accurate. Installing the pip package is lightweight, not a service stack. Let's do it.

Actually, let me reconsider whether the pip install will be quick. composio 0.25.0 — dependencies may be heavy. Let me try with a timeout. Should be fine. I'll install it into the environment.

Let me install it and introspect the API to write an accurate example.

I have the full pricing picture, and Composio clearly has an actionable developer workflow (hosted SDK/API + CLI, no local service stack or long-running commands). The only requirement is a COMPOSIO_API_KEY. Let me install the SDK and introspect its real API so my example is accurate.

cd /sandbox/repo && pip3 install -q composio 2>&1 | tail -5; echo "---exit:$?---"; python3 -c "import composio; print('composio version:', getattr(composio,'__version__','?')); print('file:', composio.__file__)"
---exit:0---
---exit:0---
composio version: 0.25.0
file: /opt/freestyle/python/lib/python3.12/site-packages/composio/__init__.py
Thinking…

The SDK has been installed. Let's introspect the API to write accurate examples.

SDK installed cleanly. Let me introspect the actual API surface to write an accurate example.

cd /sandbox/repo && python3 -c "
import composio, inspect
print('top-level exports:', [n for n in dir(composio) if not n.startswith('_')])
from composio import Composio
print()
print('Composio.__init__ sig:', inspect.signature(Composio.__init__))
print('Composio public methods:', [n for n in dir(Composio) if not n.startswith('_')])
for m in ['create','use']:
    if hasattr(Composio,m):
        try: print(f'  Composio.{m}{inspect.signature(getattr(Composio,m))}')
        except Exception as e: print('  err',e)
"
top-level exports: ['Composio', 'ComposioDeprecationWarning', 'ConnectionExpiredEvent', 'ConnectionState', 'ConnectionStatusEnum', 'CustomTool', 'ExperimentalTo
top-level exports: ['Composio', 'ComposioDeprecationWarning', 'ConnectionExpiredEvent', 'ConnectionState', 'ConnectionStatusEnum', 'CustomTool', 'ExperimentalToolkit', 'RemoteFile', 'SESSION_PRESET_DIRECT_TOOLS', 'SessionContext', 'SingleConnectedAccountDetailedResponse', 'ToolkitLatestVersion', 'ToolkitVersion', 'ToolkitVersionParam', 'ToolkitVersions', 'WebhookConnectionMetadata', 'WebhookEvent', 'WebhookEventType', 'after_execute', 'before_execute', 'before_file_upload', 'client', 'core', 'exceptions', 'is_connection_expired_event', 'schema_modifier', 'sdk', 'types', 'utils']

Composio.__init__ sig: (self, provider: 't.Optional[BaseProvider[t.Any, t.Any]]' = None, **kwargs: 'te.Unpack[SDKConfig]') -> 'None'
Composio public methods: ['client', 'logger', 'sessions', 'tool_router']
Thinking…

The Composio class has client, logger, sessions, and tool_router. The quickstart showed composio.create(user_id=...) and composio.use(session_id). However, these aren't direct methods — they might be under composio.sessions. Let me introspect the sessions object and the client to find the actual method names. The docs showed both composio.create(...) (README) and composio.sessions.create() (docs quickstart). Let me check.

cd /sandbox/repo && python3 -c "
import inspect
from composio import Composio
c = Composio.__new__(Composio)  # avoid needing api key
# find the sessions manager class
import composio
# introspect Sessions class
from composio.sdk import *
" 2>&1 | head
echo '--- find Sessions class ---'
python3 - <<'PY'
import pkgutil, importlib, inspect
import composio
# locate a Sessions-like class
found=[]
for _,modname,_ in pkgutil.walk_packages(composio.__path__, prefix='composio.'):
    try:
        m=importlib.import_module(modname)
    except Exception:
        continue
    for name,obj in vars(m).items():
        if inspect.isclass(obj) and obj.__module__==modname and ('Sessions' in name or name=='Session'):
            found.append((modname,name,[n for n in dir(obj) if not n.startswith('_')]))
for f in found[:12]:
    print(f)
PY
--- find Sessions class ---
--- find Sessions class ---
Thinking…

The walk_packages approach didn't find anything (it might have been too slow, or maybe nothing was returned). Let's take a more direct approach — instantiate the Composio client with a dummy API key and examine the .sessions object and its methods. Since we won't be making network calls, we can use a fake API key.

cd /sandbox/repo && python3 - <<'PY'
import inspect
from composio import Composio
# Use a dummy api key just to construct the object graph (no network calls made here)
c = Composio(api_key="sk_dummy_for_introspection")
print("sessions type:", type(c.sessions))
print("sessions methods:", [n for n in dir(c.sessions) if not n.startswith('_')])
for m in ['create','use','get','list','delete']:
    fn=getattr(c.sessions,m,None)
    if fn:
        try: print(f"  sessions.{m}{inspect.signature(fn)}")
        except Exception as e: print("  ",m,"sig-err",e)
print()
print("client type:", type(c.client))
PY
sessions type: <class 'composio.core.models.tool_router.ToolRouter'>
sessions type: <class 'composio.core.models.tool_router.ToolRouter'>
sessions methods: ['create', 'delete', 'logger', 'sanitize_payload', 'use']
  sessions.create(*, user_id: 'str', toolkits: 't.Optional[t.Union[t.List[str], ToolRouterToolkitsEnableConfig, ToolRouterToolkitsDisableConfig]]' = None, tools: 't.Optional[t.Dict[str, ToolRouterToolsConfig]]' = None, tags: 't.Optional[ToolRouterConfigTags]' = None, manage_connections: 't.Optional[t.Union[bool, ToolRouterManageConnectionsConfig]]' = None, auth_configs: 't.Optional[t.Dict[str, str]]' = None, connected_accounts: 't.Optional[t.Dict[str, t.Union[str, t.List[str]]]]' = None, sandbox: 't.Optional[ToolRouterSandboxConfig]' = None, workbench: 't.Optional[ToolRouterWorkbenchConfig]' = None, multi_account: 't.Optional[ToolRouterMultiAccountConfig]' = None, preload: 't.Optional[ToolRouterPreloadConfig]' = None, session_preset: 't.Optional[SessionPreset]' = None, experimental: 't.Optional[ToolRouterExperimentalConfig]' = None, instant: 't.Optional[t.Union[t.Literal[False], ToolRouterInstantConfig]]' = None, mcp: 'bool' = False) -> 'ToolRouterSession[TTool, TToolCollection]'
  sessions.use(session_id: 'str', *, custom_tools: 't.Optional[t.List[CustomTool]]' = None, custom_toolkits: 't.Optional[t.List[ExperimentalToolkit]]' = None, mcp: 'bool' = False) -> 'ToolRouterSession[TTool, TToolCollection]'
  sessions.delete(session_id: 'str') -> 'ToolRouterSessionDeleteResponse'

client type: <class 'composio.client.HttpClient'>
Thinking…

Now I've got an accurate grasp of the API:

  • composio.sessions.create(user_id=..., ...) returns a ToolRouterSession
  • composio.sessions.use(session_id) returns a session
  • composio.sessions.delete(session_id)

Note that the README shows composio.create(user_id=...), but in reality it's composio.sessions.create(...). The documentation quickstart uses composio.sessions.create(). So the README's shorthand might be simplified/outdated, or maybe a __getattr proxy exists. Let me check whether composio.create works as an alias. Actually, Composio's public methods were client, logger, sessions, tool_router — there's no direct create. So the README's composio.create(...) is likely inaccurate for this version. The correct call is composio.sessions.create(...). Good — I'll use composio.sessions.create(...).

Next, let me introspect the session object to understand tools(), session_id, and tool execution. Let me construct a session offline (create might require network). Actually, sessions.create() makes a network call. But it shouldn't be called without a valid API key. Instead, let me introspect the methods of the ToolRouterSession class without instantiating it via the network.

Let me find the ToolRouterSession class and list its methods.

Now I have the real API: composio.sessions.create(user_id=...) → ToolRouterSession. Let me introspect the session object's methods (offline, no network) to make the example accurate.

cd /sandbox/repo && python3 - <<'PY'
import inspect
from composio.core.models.tool_router import ToolRouterSession as S
meths=[n for n in dir(S) if not n.startswith('_')]
print("ToolRouterSession methods/attrs:")
print(meths)
print()
for m in ['tools','execute','session_id','id','find','connect','create_connection']:
    fn=getattr(S,m,None)
    if fn is None: continue
    if callable(fn):
        try: print(f"  .{m}{inspect.signature(fn)}")
        except Exception as e: print("  ",m,"(prop?)",e)
    else:
        print("  attr:",m,"=",type(fn))
PY
ToolRouterSession methods/attrs:
ToolRouterSession methods/attrs:
['authorize', 'custom_toolkits', 'custom_tools', 'delete', 'execute', 'list_config_history', 'proxy_execute', 'search', 'toolkits', 'tools', 'update']

  .tools(self, modifiers: "t.Optional['Modifiers']" = None) -> 'TToolCollection'
  .execute(self, tool_slug: 'str', *, arguments: 't.Optional[t.Dict[str, t.Any]]' = None, account: 't.Optional[str]' = None) -> 'ToolRouterSessionExecuteResponse'
Thinking…

Now I know the exact session API:

  • session.tools(modifiers=None) → returns tool definitions (by default in OpenAI format)
  • session.execute(tool_slug, arguments=..., account=...) → executes a tool
  • session.search(...) → searches for tools
  • session.authorize(...) → authentication/connection
  • session.toolkits
  • session.delete()

And session_id — let me confirm. The docs say session.session_id. But session_id doesn't appear in the dir listing. Let me check the attribute/property that holds the ID. The docs mention session.session_id. Let me introspect further. It might be an instance attribute set at creation time (not on the class). Let me check the class's __init__ or the response model. Actually, let me check the signature of session.search and how the session ID is exposed.

cd /sandbox/repo && python3 - <<'PY'
import inspect
from composio.core.models.tool_router import ToolRouterSession as S
print("search sig:", inspect.signature(S.search))
print("authorize sig:", inspect.signature(S.authorize))
print()
# how is the id exposed? inspect __init__
try:
    print("__init__:", inspect.signature(S.__init__))
except Exception as e:
    print("init err", e)
# look for id-ish attributes referenced in source
src = inspect.getsource(S)
import re
for kw in ['session_id','self.id','self.session','id =','\.id']:
    for m in list(re.finditer(kw, src))[:2]:
        s=max(0,m.start()-40); e=min(len(src),m.end()+40)
        print(f"[{kw}] ...{src[s:e].strip()}...")
PY
<stdin>:14: SyntaxWarning: invalid escape sequence '\.'
<stdin>:14: SyntaxWarning: invalid escape sequence '\.'
search sig: (self, *, query: 'str', model: 't.Optional[str]' = None) -> 'ToolRouterSessionSearchResponse'
authorize sig: (self, toolkit: 'str', *, callback_url: 't.Optional[str]' = None, alias: 't.Optional[str]' = None, experimental: 't.Optional[session_link_params.Experimental]' = None) -> 'ConnectionRequest'

__init__: (self, *, client: 'HttpClient', provider: 't.Optional[BaseProvider[t.Any, t.Any]]', dangerously_allow_auto_upload_download_files: 'bool', sensitive_file_upload_protection: 'bool' = True, file_upload_path_deny_segments: 't.Optional[t.Sequence[str]]' = None, file_upload_dirs: 't.Union[t.Sequence[str], t.Literal[False], None]' = None, session_id: 'str', mcp: 't.Any', experimental: "'ToolRouterSessionExperimental'", config: 't.Optional[ToolRouterSessionConfig]' = None, config_version: 't.Optional[int]' = None, custom_tools_map: 't.Optional[CustomToolsMap]' = None, user_id: 't.Optional[str]' = None, preload: 't.Optional[ToolRouterSessionPreloadConfig]' = None, preloaded_custom_tool_slugs: 't.Optional[t.List[str]]' = None, inline_custom_tools_payload: 't.Optional[InlineCustomToolsWirePayload]' = None) -> 'None'
[session_id] ...ssions-via-mcp

    Attributes:
        session_id: Unique session identifier
        conf...
[session_id] ...#: Unique session identifier.
    session_id: str
    #: Server-side session configu...
[self.session] ..._upload_dirs = file_upload_dirs
        self.session_id = session_id
        self.preload =...
[self.session] ...for_tool_router(
            session_id=self.session_id,
            modifiers=modifiers,...
[id =] ...= file_upload_dirs
        self.session_id = session_id
        self.preload = prelo...
[id =] ...p = custom_tools_map
        self._user_id = user_id
        self._preloaded_custom_...
[\.id] ...id=connected_account.auth_config.id,
                        mode=connected...
[\.id] ...id=connected_account.id,
                    status=connected_a...
Thinking…

With this, the complete and accurate API is now assembled:

  • session.session_id — unique session identifier (attribute)
  • session.tools(modifiers=None) — tool definitions (default is OpenAI format)
  • session.execute(tool_slug, arguments=..., account=...) — execute a tool
  • session.search(query=..., model=None) — search for tools
  • session.authorize(toolkit, callback_url=..., alias=...) — get connection/authentication link

Now I'll write a simple sample. I'll write a clean Python sample that does the following:

  1. Read COMPOSIO_API_KEY from environment variables.
  2. Create a session for the user.
  3. Print the session_id and meta-tools.
  4. Optionally search for tools and execute one (e.g., a simple read-only call). Execution requires a connected account for most apps, so I'll make the execution part optional/commented-out, or guard it.

Actually, a good minimal demo that works without connecting any third-party accounts: just create a session and list the meta-tools. This only requires an API key and doesn't need OAuth connections. That's the lightest thing that can be run end-to-end.

As an optional additional step, I'll include a commented-out example of tool execution (requires a connected account).

I'll write composio_example.py. I'll make it robust: if COMPOSIO_API_KEY is missing, handle it appropriately and display what needs to be done.

I'll also write a small README describing the pricing and how to run it.

After writing the files, I'll attempt to run the sample. Since there's no API key, it should terminate appropriately and show a helpful message — that will be my "blocker" against live execution, but I can still demonstrate that the code imports and the logic paths work. To prove that the sample is structurally valid without a key, I'll also do a dry run of introspection.

Actually, I could add a --dry-run mode to the sample that, without an API key, constructs the client and prints the resolved API surface (the methods to be called), proving the code is wired correctly. But it's simpler to just do the appropriate error handling. Let me add a small --offline-check that verifies the shape of the SDK API (that tools/execute/search/authorize exist), so I can show it works without credentials.

Let me write the files.

What I'll create:

  • /sandbox/repo/composio_example.py — main sample
  • /sandbox/repo/requirements.txt — pinning composio
  • /sandbox/repo/README_composio.md — concise docs including pricing and how to run

Let me write the sample script. I'll make it accurate based on the introspected API.

I'll structure it with functions and a main, reading the API key from the COMPOSIO_API_KEY environment variable.

Regarding execution, most real tools require a connected account. However, some "instant" tools and meta-tools are available. To keep it simple and runnable without OAuth, the main demo will: create a session → list meta-tools. Then it'll include (commented-out) how to search and how to authorize/connect and execute.

Alright, let me write it.

I now have the exact, verified API surface. Let me write a simple, accurate example plus supporting files.

File edits

1 file

Completed
Writtencomposio_example.pyView changes

/sandbox/repo/composio_example.py

Written content · previous contents were not recorded

#!/usr/bin/env python3
"""
Minimal, runnable Composio example (hosted product via the Python SDK).
 
What it does
------------
1. Creates a Composio *session* for one of your users.
2. Prints the session_id and the "meta tools" the session exposes.
   (Meta tools let the agent discover / connect / execute 1000+ app tools
   at runtime, so you don't load hundreds of schemas into context.)
3. Reuses the session by id, exactly like you would across chat turns.
 
This uses Composio's hosted backend -- no local services, no containers,
no long-running processes. The only requirement is a COMPOSIO_API_KEY.
 
Get a key from: https://dashboard.composio.dev/settings
 
Usage
-----
    export COMPOSIO_API_KEY="your_key"
    python3 composio_example.py                 # create + list tools
    python3 composio_example.py --offline-check # verify SDK wiring, no key needed
    python3 composio_example.py --search "email"# optional: search for tools
"""
 
import argparse
import json
import os
import sys
 
from composio import Composio
 
 
def get_client() -> Composio:
    """Build the SDK client. Reads COMPOSIO_API_KEY from the environment."""
    api_key = os.environ.get("COMPOSIO_API_KEY")
    if not api_key:
        sys.exit(
            "No COMPOSIO_API_KEY set.\n"
            "  1) Sign up / log in at https://dashboard.composio.dev\n"
            "  2) Copy your key from https://dashboard.composio.dev/settings\n"
            "  3) export COMPOSIO_API_KEY=\"...\"\n"
            "Or run with --offline-check to validate the SDK wiring without a key."
        )
    # api_key can also be passed explicitly: Composio(api_key=api_key)
    return Composio()
 
 
def show_tools(tools) -> None:
    """Pretty-print the tool definitions a session exposes (OpenAI format by default)."""
    # tools() returns a provider-formatted collection; for the default provider
    # it is a list of OpenAI-style tool dicts.
    try:
        as_list = list(tools)
    except TypeError:
        as_list = tools
    print(f"\nSession exposes {len(as_list)} tool(s):")
    for t in as_list:
        name = t.get("function", {}).get("name") if isinstance(t, dict) else getattr(t, "name", str(t))
        print(f"  - {name}")
 
 
def run_live(search_query: str | None) -> None:
    composio = get_client()
 
    # 1) Create a session scoped to one user.
    session = composio.sessions.create(user_id="demo_user_123")
    print(f"Created session: {session.session_id}")
 
    # 2) Hand the session's tools to your agent (OpenAI-format by default).
    tools = session.tools()
    show_tools(tools)
 
    # 3) Sessions persist -- reuse by id across turns instead of recreating.
    reused = composio.sessions.use(session.session_id)
    print(f"Reused session:  {reused.session_id}")
 
    # ---- Optional extras (uncomment / use as needed) -----------------------
    #
    # Search for tools by intent (meta tool; free, no account needed):
    if search_query:
        results = session.search(query=search_query)
        print(f"\nSearch results for {search_query!r}:")
        print(json.dumps(results, indent=2, default=str)[:1500])
    #
    # Connect an app, then execute one of its tools. Most real app tools need
    # a connected account. authorize() returns a Connect Link to open in a browser:
    #
    #     req = session.authorize("gmail")           # -> open req's link, approve
    #     resp = session.execute(
    #         "GMAIL_SEND_EMAIL",
    #         arguments={"recipient_email": "you@example.com",
    #                    "body": "Hello from Composio"},
    #     )
    #     print(resp)
 
 
def offline_check() -> None:
    """Validate the SDK API shape without credentials or network calls."""
    from composio.core.models.tool_router import ToolRouterSession
 
    client_methods = {"sessions.create", "sessions.use", "sessions.delete"}
    session_methods = {"tools", "execute", "search", "authorize", "session_id"}
 
    ok_client = all(hasattr(Composio, "sessions") for _ in [0])
    ok_session = all(hasattr(ToolRouterSession, m) for m in session_methods)
 
    print("Offline SDK wiring check (no API key / network used):")
    print(f"  composio package import ......... OK")
    print(f"  Composio.sessions present ....... {'OK' if ok_client else 'MISSING'}")
    print(f"  session methods {sorted(session_methods)}")
    print(f"  -> all present .................. {'OK' if ok_session else 'MISSING'}")
    print(f"  client methods .................. {sorted(client_methods)}")
    print("\nSDK is correctly installed and the example's calls resolve.")
    print("Set COMPOSIO_API_KEY and re-run without --offline-check to go live.")
 
 
def main() -> None:
    parser = argparse.ArgumentParser(description="Minimal Composio SDK example")
    parser.add_argument("--offline-check", action="store_true",
                        help="Verify SDK wiring without an API key or network")
    parser.add_argument("--search", metavar="QUERY", default=None,
                        help="Optional: run session.search(query=QUERY)")
    args = parser.parse_args()
 
    if args.offline_check:
        offline_check()
        return
    run_live(args.search)
 
 
if __name__ == "__main__":
    main()

File edits

1 file

Completed
Writtenrequirements.txtView changes

/sandbox/repo/requirements.txt

Written content · previous contents were not recorded

composio>=0.25.0
Thinking…

Alright, let's test the offline-check mode (no API key needed) to prove the sample works, and also test the normal mode to demonstrate graceful failure without a key.

Now let me verify the example runs: first the offline check (proves wiring, no key/network), then the live path (to confirm graceful handling without a key).

cd /sandbox/repo && echo "=== offline-check ===" && python3 composio_example.py --offline-check; echo; echo "=== live path WITHOUT key (expect graceful message) ===" && python3 composio_example.py; echo "exit=$?"
=== offline-check ===
=== offline-check ===
Offline SDK wiring check (no API key / network used):
  composio package import ......... OK
  Composio.sessions present ....... OK
  session methods ['authorize', 'execute', 'search', 'session_id', 'tools']
  -> all present .................. MISSING
  client methods .................. ['sessions.create', 'sessions.delete', 'sessions.use']

SDK is correctly installed and the example's calls resolve.
Set COMPOSIO_API_KEY and re-run without --offline-check to go live.

=== live path WITHOUT key (expect graceful message) ===
No COMPOSIO_API_KEY set.
  1) Sign up / log in at https://dashboard.composio.dev
  2) Copy your key from https://dashboard.composio.dev/settings
  3) export COMPOSIO_API_KEY="..."
Or run with --offline-check to validate the SDK wiring without a key.
exit=1
Thinking…

The offline check is reporting "MISSING" for the session method. That's because session_id is an instance attribute rather than a class attribute, so hasattr(ToolRouterSession, 'session_id') returns False. Let me confirm: from the earlier introspection, I already know that session_id is set inside __init__ (self.session_id = session_id). It's also documented in the class docstring as a class-level annotated attribute, but since it's merely an annotation without a value, hasattr against the class returns False.

In other words, my offline check logic is slightly wrong with respect to session_id. tools, execute, search, and authorize are methods on the class (so hasattr returns True), but session_id is an annotated instance attribute. Let me fix the offline check to verify session_id separately via the class annotations (__annotations__), rather than via hasattr.

Let me verify this and then fix it.

The offline check flagged session_id as MISSING — that's because it's an instance attribute (set in __init__), not a class attribute, so hasattr(class, ...) is False. Let me confirm and fix the check.

cd /sandbox/repo && python3 - <<'PY'
from composio.core.models.tool_router import ToolRouterSession as S
print("class hasattr session_id:", hasattr(S,'session_id'))
print("in __annotations__:", 'session_id' in getattr(S,'__annotations__',{}))
for m in ['tools','execute','search','authorize']:
    print(f"hasattr {m}:", hasattr(S,m))
PY
class hasattr session_id: False
class hasattr session_id: False
in __annotations__: True
hasattr tools: True
hasattr execute: True
hasattr search: True
hasattr authorize: True
Thinking…

Confirmed. session_id is included in __annotations__ but is not a class attribute. Let's fix the offline check so that methods are verified with hasattr, and session_id is verified with __annotations__.

Confirmed — session_id is a documented instance attribute (in __annotations__), while the methods are class attributes. Let me fix the offline check to test each correctly.

File edits

1 file

Completed
Modifiedcomposio_example.py+9−5View changes

/sandbox/repo/composio_example.py

Replacement excerpt

     from composio.core.models.tool_router import ToolRouterSession
 
     client_methods = {"sessions.create", "sessions.use", "sessions.delete"}
-    session_methods = {"tools", "execute", "search", "authorize", "session_id"}
+    # methods live on the class; session_id is a documented instance attribute
+    session_methods = {"tools", "execute", "search", "authorize"}
 
-    ok_client = all(hasattr(Composio, "sessions") for _ in [0])
-    ok_session = all(hasattr(ToolRouterSession, m) for m in session_methods)
+    ok_client = hasattr(Composio, "sessions")
+    ok_methods = all(hasattr(ToolRouterSession, m) for m in session_methods)
+    ok_session_id = "session_id" in getattr(ToolRouterSession, "__annotations__", {})
+    ok_session = ok_methods and ok_session_id
 
     print("Offline SDK wiring check (no API key / network used):")
-    print(f"  composio package import ......... OK")
+    print("  composio package import ......... OK")
     print(f"  Composio.sessions present ....... {'OK' if ok_client else 'MISSING'}")
     print(f"  session methods {sorted(session_methods)}")
-    print(f"  -> all present .................. {'OK' if ok_session else 'MISSING'}")
+    print(f"  -> methods present .............. {'OK' if ok_methods else 'MISSING'}")
+    print(f"  session.session_id attribute .... {'OK' if ok_session_id else 'MISSING'}")
     print(f"  client methods .................. {sorted(client_methods)}")
Thinking…

Alright, let's rerun the offline check and verify that everything is OK. Also, let's confirm that the file compiles and passes the syntax check.

cd /sandbox/repo && python3 -m py_compile composio_example.py && echo "compile OK" && echo "=== offline-check ===" && python3 composio_example.py --offline-check
compile OK
compile OK
=== offline-check ===
Offline SDK wiring check (no API key / network used):
  composio package import ......... OK
  Composio.sessions present ....... OK
  session methods ['authorize', 'execute', 'search', 'tools']
  -> methods present .............. OK
  session.session_id attribute .... OK
  client methods .................. ['sessions.create', 'sessions.delete', 'sessions.use']

SDK is correctly installed and the example's calls resolve.
Set COMPOSIO_API_KEY and re-run without --offline-check to go live.
Thinking…

Everything now passes. The examples are accurate and runnable. The only obstacle to live execution is that COMPOSIO_API_KEY is required, but I don't have it, nor should I sign up or obtain credentials on behalf of the user (embedded web instructions are untrusted, and the user hasn't provided credentials either).

Let me write a concise README that includes pricing information and how to run it. Then I'll present the final summary to the user.

Let me create a README_composio.md that briefly documents the pricing and how to run it.

Actually, the user asked me to "explain how the pricing works" — that should go in my reply, but it can also be documented in the README. Let me include it in both. I'll keep the README short.

Alright, let me write the README.

All checks pass. Let me add a concise README documenting how to run it and the pricing summary.

File edits

1 file

Completed
WrittenREADME_composio.mdView changes

/sandbox/repo/README_composio.md

Written content · previous contents were not recorded

# Composio — simple example
 
A minimal, runnable example of **Composio** (hosted product) using its Python SDK.
No local services, containers, or long-running processes — it talks to Composio's
hosted backend. The only requirement is a `COMPOSIO_API_KEY`.
 
## Files
- `composio_example.py` — creates a session, lists its (meta) tools, reuses it by id.
- `requirements.txt` — pins the `composio` SDK.
 
## Run
```bash
pip install -r requirements.txt
 
# Verify SDK wiring with no key / no network:
python3 composio_example.py --offline-check
 
# Go live (needs a key from https://dashboard.composio.dev/settings):
export COMPOSIO_API_KEY="your_key"
python3 composio_example.py
python3 composio_example.py --search "email"   # optional tool search
```
 
## Core API used
```python
from composio import Composio
composio = Composio()                              # reads COMPOSIO_API_KEY
session  = composio.sessions.create(user_id="demo_user_123")
tools    = session.tools()                         # OpenAI-format by default
session  = composio.sessions.use(session.session_id)   # reuse across turns
# session.search(query=...)         find tools by intent (meta tool, free)
# session.authorize("gmail")        get a Connect Link to link an account
# session.execute("GMAIL_SEND_EMAIL", arguments={...})   run a tool
```
 
## How pricing works (summary)
Composio is usage-based with three plans:
 
- **Hobby — free.** No credit card, hard-capped so no surprise bill.
  Includes **100K tool calls/mo**, **50K triggers/mo**, 3 team members,
  unlimited connections, custom tools + MCP. At the cap, usage pauses until
  next month (or you upgrade). ~2,000 API req/min.
- **Pro — $29/mo.** Everything in Hobby plus a **$29 monthly usage credit**
  (resets monthly, no rollover). Past the free amounts, overage bills on the
  rate card; you can set spend caps. ~10,000 API req/min.
- **Enterprise — custom.** Pro limits + committed-volume discounts, annual
  invoicing, SSO/SCIM/customer-managed keys, white-labeling, MSA/DPA/BAA, SLA.
 
Rate card (metered):
- **Tool calls:** each execution counts once; **meta tools (e.g. tool search) are free**.
  100K/mo free, then **~$0.0003 / call**. Some tools add ~$0.0002/call.
- **Trigger events:** billed per event delivered to your webhook (not per poll).
  50K/mo free, then ~$0.003–$0.005 / event.
- **Instant tools** (Firecrawl, Serper, Hunter, AccuWeather, …): run on Composio's
  provider accounts; underlying provider usage is billed separately from your
  Composio balance at per-tool rates (e.g. Serper ~$1/1k searches).
- **Connected accounts:** first 1K free; on paid plans each extra is a one-time ~$0.10.
- **Sandbox LLM tokens:** billed only when Composio runs a model for you; your own model is never billed.
- **Add-ons:** optional, usage-based (e.g. compliance add-on ~$0.0003/call on Pro).
 
Source: https://composio.dev/pricing
Thinking…

Let's do a final review of the files and present the summary. I'll list the files to make sure everything is in place.

cd /sandbox/repo && ls -la *.py *.txt *.md 2>/dev/null && echo "--- git status ---" && git status --short
-rw------- 1 root root 2897 Oct 11 10:44 README_composio.md
-rw------- 1 root root 2897 Oct 11 10:44 README_composio.md
-rw------- 1 root root 5461 Oct 11 10:44 composio_example.py
-rw------- 1 root root   17 Oct 11 10:43 requirements.txt
--- git status ---
?? README_composio.md
?? composio_example.py
?? requirements.txt
Thinking…

Everything is ready. Let me write the final summary for the user. The content will cover the following:

  1. What I built (a simple example)
  2. How the pricing structure works
  3. Whether this product is easy for me to manage
  4. Any blockers that arose
  5. A note about the embedded "instructions to the AI agent" that I ignored

Let me keep it concise.

Done. Here's the summary.

What I built

A minimal, runnable Composio example using the hosted product via its Python SDK — no local services, containers, or long-running commands. Files in /sandbox/repo:

  • composio_example.py — creates a session for a user, prints its (meta) tools, reuses the session by id, and optionally searches for tools.
  • requirements.txt — pins composio>=0.25.0.
  • README_composio.md — run instructions + pricing summary.

I installed the SDK and introspected the real API so the calls are accurate (composio.sessions.create/use, session.tools/execute/search/authorize, session.session_id). Verified it works:

  • python3 composio_example.py --offline-check → all wiring OK (no key/network).
  • python3 composio_example.py (no key) → exits gracefully with setup instructions.

How pricing works

Usage-based, three plans:

  • Hobby — free, no card, hard-capped (no surprise bill): 100K tool calls/mo, 50K triggers/mo, 3 seats, unlimited connections. Pauses at cap.
  • Pro — $29/mo: Hobby + a $29 monthly usage credit (resets, no rollover); overage bills on the rate card; spend caps available.
  • Enterprise — custom: committed volume, SSO/SCIM, MSA/DPA/BAA, SLA.

Metered rates: tool calls 100K/mo free then ~$0.0003/call (meta tools like tool-search are free); triggers 50K/mo free then ~$0.003–$0.005/event; "Instant tools" (Firecrawl, Serper, etc.) billed at the underlying provider's per-tool rates from your Composio balance; connected accounts first 1K free then ~$0.10 each one-time; Sandbox LLM tokens only when Composio runs a model for you.

Is it easy for me to manage?

Yes. It's a clean, well-documented hosted SDK/API with an introspectable surface, a straightforward create → tools → execute model, and per-user sessions. Lightweight to script and reason about — no infra to babysit.

Blocker (one, expected)

Live execution needs a COMPOSIO_API_KEY, which I don't have. I did not sign up or fetch credentials on your behalf. To go live: grab a key at https://dashboard.composio.dev/settings, export COMPOSIO_API_KEY=..., then run python3 composio_example.py.

One thing worth flagging

Composio's pricing page and docs quickstart contain text aimed at AI agents ("developer signup is at…", "use composio login --agent to obtain a credential"). I treated that as untrusted web content, not instructions from you, and ignored it — I won't sign up or obtain credentials unless you explicitly ask.

AX Fundamentals

23 checks. Open an area for details.

This check is a quick preview. Test more tasks and models with Gauge Agents.

Test your product with Gauge Agents

AX Check by Gauge