Jason Lee

Posted on Aug 15

Composio's $29 Sticker Price Didn't Move. Custody of Your Users' OAuth Tokens Did.

#ai #saas #api #mcp

On August 15, 2026, Composio's new pricing takes effect. If you skim the plan names, nothing looks alarming: the entry tier is still $29 a month, the free tier is still free. That's the point worth pausing on. The sticker price didn't move. Almost everything underneath it did — including, easy to miss in the fine print, who is allowed to hold the OAuth tokens your agent uses to act on your users' behalf.

Composio is one of the infrastructure layers that sits between an LLM and the outside world: the piece that turns "the model decided to send an email" into an actual, authenticated, rate-limited, retried API call to Gmail. It's used by agent frameworks and coding tools to give agents hands. And as of today, the way you pay for those hands has changed in ways that are easy to gloss over if you only read the headline numbers.

What actually happened

Composio quietly began rolling out a new pricing structure in early August, then published it in full via a blog post from Scalekit — a direct competitor in the agent-auth space, which is worth keeping in mind as you read their numbers, though the figures check out against Composio's own updated pricing page. Here's the honest before/after:

	Old (until Aug 15)	New (from Aug 15)
Free	20K tool calls/mo	20K tool calls/mo, 20K trigger events/mo, 3 team members — unchanged
Entry tier	$29/mo — 200K tool calls/mo	$29/mo — 50K tool calls/mo
Mid tier	$229/mo — 2M tool calls/mo	$599/mo — 50K tool calls/mo (same pool as the $29 tier)
Overage	$0.249–$0.299 per 1,000 calls	$4 per 1,000 calls ($3 via Sessions)
Team members	Not specified	3 (Free) / Unlimited (Pro & Business)

Two things jump out. First, the $29/mo tier keeps its price but loses 75% of its included volume. Second, and more strikingly, the old $229/mo plan is gone entirely — its replacement, at $599/mo, buys you the same 50,000 tool-call allowance as the cheapest paid tier. The extra $570 a month isn't paying for more capacity; it's paying for Slack support, an IP allowlist, and higher rate limits. If your business case for the $229 plan was "we need 2 million tool calls a month," that capacity no longer exists as a flat-rate product at any price point below custom Enterprise contracts. You're now paying per call.

Composio also split billing into five new metered dimensions that didn't exist as separate line items before: trigger events ($1/1,000 over 50K included), LLM tokens consumed by sandbox and filesystem sub-agent tasks ($3.75/million over 3M included), premium tool usage (billed per tool, against a $5/month credit), sandbox compute ($0.50/GB-hour over 50 GB-hours), and filesystem storage ($0.05/GB over 10GB). None of these are large in isolation. An agent that leans on triggers, runs code in Composio's sandbox, or calls premium connectors (video generation and similar) will now see charges on line items that used to be folded into a flat monthly fee.

Existing customers, and anyone who signs up before today, keep their current plan and limits through December 31, 2026. That's real runway — four and a half months of notice plus a grandfathering window is more transparency than a lot of usage-based infrastructure vendors offer. It is not, however, a permanent shield. It's a deadline with a specific date on it.

What Composio actually does

If you haven't used it, Composio solves a specific, unglamorous problem: giving an LLM the ability to do things in the real world without you writing and maintaining a bespoke integration for every app. The pitch, distilled from their own architecture guide, is built around three failure modes that show up the moment you try to ship a tool-calling agent to production:

The N+1 API problem. Every new tool means a new API, a new schema, a new set of failure modes. Gmail, Slack, and Jira all behave differently, and none of that logic is reusable. Composio ships roughly 1,000 pre-authenticated toolkits (third-party counts vary between ~500 and ~1,000 depending on how "toolkit" is defined) with agent-optimized schemas already written.
The discovery problem. An agent needs to find the right tool out of hundreds without blowing its context window loading every tool definition up front. Composio's "sessions" model exposes meta-tools that search, authenticate, and execute app tools at runtime, so you don't pay context-window tax for tools you never call.
The auth problem. OAuth flows, token refresh, scoping, and credential storage are boring to build and dangerous to build badly. Composio manages the full lifecycle — connect once, and it handles token refresh, storage, and (in the default configuration) custody.

How it works, architecturally

The current SDK generation centers on what Composio calls a session: composio.create(user_id) returns an object scoped to one of your end users, and session.tools() hands your agent framework of choice (OpenAI, Anthropic's Claude Agent SDK, LangChain, CrewAI, Vercel's AI SDK, and others all have first-party provider packages) a ready-to-use tool list. Every session also exposes a hosted Model Context Protocol endpoint, so you can point Claude, Cursor, or any MCP client at session.mcp.url instead of wiring a provider package at all.

Underneath that, there's a sandbox: a remote, ephemeral execution environment where tools can run as code rather than single request/response calls, with large responses stored on a navigable filesystem instead of getting stuffed into the model's context. That's the origin of the new LLM-token, sandbox-compute, and filesystem-storage meters — they weren't billable line items before because the sandbox is a relatively newer part of the product surface, but the compute and storage were never free to run; they were previously absorbed into the flat tool-call price.

The credential model deserves its own paragraph because it's the part of this change most likely to matter to you if you're running a real product. By default, Composio holds your users' OAuth tokens — the "brokered credentials" pattern, where the LLM never sees a raw API key and Composio's infrastructure makes the call on the agent's behalf. That's a legitimate, sensible security design, and it's genuinely part of Composio's core value proposition: you're not writing token storage and refresh logic yourself. But as of this pricing change, self-managed credentials — where you hold custody instead of Composio — moved behind the $599/mo Business tier. Below that, third-party custody of your users' tokens isn't a choice you're opting into for convenience; it's the only option available at that price point. For a weekend project that's a non-issue. For a team handling regulated data or answering a customer's security questionnaire, "who holds the keys to our users' Gmail and Slack" just became a $599/month decision instead of an architectural one you made deliberately.

Why this should matter to you, in dollars

Scalekit ran four realistic usage scenarios through the new pricing (standard tool-call overage only, using the $29/mo Pro tier as the base since $599 buys support, not volume):

Scenario	Tool calls/mo	Old cost	New cost	Increase
MVP stage	15K	$0 (Free)	$0 (Free)	No change
Early traction	75K	$29/mo	$129/mo	~4.4x
High growth	500K	$229/mo	$1,829/mo	~8x
At scale	2M	$229/mo	$7,829/mo	~34x

The shape of that curve is the actual story. It's flat at the free tier and gets brutal exactly where a team would normally consider itself succeeding — the point where an agent is doing enough real work that a founder would call it "traction." A team at 500K calls a month isn't a toy prototype; that's meaningful production usage, and the bill for it just went up 8x. None of these figures include the new trigger-event, LLM-token, sandbox, or storage meters, which would push real bills higher still for agents that use those surfaces.

This isn't happening in isolation. Composio raised a $29M Series A led by Lightspeed in mid-2025, and repricing after a growth round — moving from acquisition-subsidized flat rates toward unit economics that reflect actual compute and API cost — is a familiar pattern across AI infrastructure in 2026 as vendors face the real cost of running LLM-adjacent workloads at scale. The specifics differ everywhere, but the underlying pressure — someone eventually has to pay for the tokens and compute that used to be absorbed for growth — is showing up across the category.

Practical use cases (and where the new pricing bites)

Personal/internal assistants that read a user's email, calendar, and CRM to summarize or triage — light call volume, and the free-to-$29 tier is genuinely still fine for this.
Multi-tenant SaaS features where each of your customers connects their own Slack, GitHub, or HubSpot account and an agent acts on their behalf — this is exactly the workload that scales into the "high growth" and "at scale" scenarios above, because call volume grows with your customer count, not your engineering effort.
Coding-agent tool surfaces — Composio ships native plugins for Claude Code and Codex and works over MCP with Cursor, letting a coding agent search Sentry issues, file Linear tickets, or open GitHub PRs without you hand-building each integration.
Sandboxed multi-step workflows, e.g., "pull 50 Notion pages, summarize each with a sub-LLM call, write results back" — this is precisely the pattern that now touches three new meters at once (tool calls, LLM tokens, sandbox compute).

What the marketing doesn't emphasize

A few things worth knowing before you commit that don't show up in the headline pricing:

SOC 2 Type II is Enterprise-only, according to competitive teardown from Arcade's own comparison page (a competitor's framing, but the underlying claim is checkable against Composio's own docs) — which complicates a security review for any startup still on Pro or Business trying to close an enterprise customer of its own.
A DPA (data processing agreement) is a $500/month add-on, even at the $599/mo Business tier; it's only bundled free at Enterprise. If GDPR or SOC 2 compliance is why you're paying for Business, budget for it separately.
Enterprise pricing isn't published anywhere — "custom," talk to sales, for VPC/on-prem and dedicated SLAs. Any cost comparison you do has a ceiling of "Business tier," and the real number for serious scale requires a sales conversation.
Billing has had accuracy issues before. A public GitHub pull request from Composio's own repo shows a customer flagging, via support, that the marketing pricing page quoted $0.299/$0.249 per 1,000 overage calls while the actual billing dashboard was already charging $0.39/$0.34 — a discrepancy that had apparently been live long enough for a customer to notice and escalate before it was fixed (fittingly, the fix was investigated and shipped by Devin, an AI coding agent, with a second AI reviewer bot signing off on the PR — a small, unplanned demonstration of the exact category of software Composio sells infrastructure to). It's a minor incident on its own, but it's a data point on how much you should trust the number on the pricing page versus what actually lands on your invoice.

How it stacks up against the competition

Composio isn't the only company selling "auth plus tools" for agents, and the category has sorted into fairly distinct bets:

Platform	Catalog	Auth model	Pricing shape	Best fit
Composio	~500–1,000 pre-built toolkits	Managed OAuth, brokered credentials by default	Usage-based, now with 6 meters	Fast multi-tool prototyping and production agents that don't need deep compliance
Arcade	~112 first-party integrations	Per-user OAuth, native just-in-time consent, tokens never enter LLM context	Platform fee + transparent per-execution rate	Regulated industries needing identity-scoped, auditable tool calls
Nango	800–900+ OAuth providers	Per-connection managed OAuth, self-hostable	Free self-hosted tier; sync/actions/observability gated to paid Enterprise	Code-first teams that want to own the auth layer and build their own tool schemas
Klavis AI	300+ services	Managed OAuth, SOC 2	Free / enterprise, Apache 2.0 open source	Teams that want an open-source, context-efficient tool catalog (their "Strata" approach specifically targets context-window bloat from huge catalogs)
Zapier's MCP	9,000+ apps, 30,000+ actions	Account-owner credentials (not per-user)	Plan-based task quotas	Maximum raw app coverage under a single account, not per-end-user agent products
Pipedream	3,000+ apps, 10,000+ tools	Per-end-user OAuth	Credit-based	Broad catalog with per-user auth; now backed by Workday's resources post-acquisition

The competitive framing worth being skeptical of: most of the detailed head-to-head comparisons circulating right now — including Scalekit's own pricing breakdown and Arcade's published Composio comparison — come from companies competing directly with Composio for the same budget line. That doesn't make their numbers wrong (Scalekit's math checks out against Composio's own published pricing pages), but read the qualitative claims ("Composio is best suited for prototyping," "harder to predict at scale") as competitor positioning, not neutral fact. The one genuinely independent signal is the math: a jump from $229/mo to $1,800–$7,800/mo for the same workload isn't a framing choice, it's arithmetic against Composio's own numbers.

The structural difference that actually matters, independent of who's saying it: Composio and Zapier sell you a large pre-built catalog and bill for it in an abstracted unit (calls, credits, tasks). Arcade and Nango sell you infrastructure and let you build or bring your own tool layer, billing in a unit that maps more directly to what your agent does. Neither approach is strictly better — the pre-built catalog is faster to ship, the infrastructure approach is more predictable at scale — but the new Composio pricing pushes it further toward "infrastructure-priced, catalog-shaped," which is an awkward middle: you're paying per-call like an infrastructure product, without the deployment control (self-hosting, choosing where compute runs) that usually comes with infrastructure pricing.

An independent read

Nothing about this repricing is dishonest in the narrow sense. Composio published the new numbers, gave over four months of notice, and grandfathered every current customer through the end of the year — that's a legitimate transition, not a bait-and-switch, and plenty of infrastructure vendors have handled repricing with far less warning. The free tier is genuinely untouched, and for prototyping, 50K tool calls a month is still enough to build and validate most agents.

Where it's fair to push back is the magnitude and where it lands. Going from $229/mo to somewhere in the $6,000–$8,000/mo range for the same 2-million-call workload is not a rounding error you absorb with a roadmap conversation — and it lands hardest precisely on the customers who validated the product by using it the most. There's also a legibility problem: six separate meters (tool calls, trigger events, LLM tokens, premium tool credit, sandbox compute, filesystem storage) replace what used to be one number on a pricing page. That's arguably more honest about what actually costs Composio money to run, but it also makes "what will this cost me next month" a genuinely harder question to answer from the pricing page alone — you now need production telemetry across five dimensions to forecast your bill, not just a call counter.

And the credential-custody change is the one most likely to be underweighted by teams reading the pricing page quickly. It's presented as one line in a feature-gating table, but "who holds your users' third-party access tokens" is an architecture and security decision, not a support-tier perk — and it's now bundled with Slack support and an IP allowlist behind the same $599/mo paywall rather than priced or reasoned about on its own.

Who should try it, who should wait, who should look elsewhere

Try it: you're prototyping or running an internal tool with modest, predictable call volume. The free tier is unchanged and 50K calls on Pro is still a real budget for validating an agent idea. Nothing here should slow you down.

Model it out before December 31: you're already a paying Composio customer running meaningful production volume, especially anywhere near the old $229/mo tier. The grandfather clause is real runway, not a reason to wait until it expires — run your actual monthly call count through the new-plan numbers now, because the delta at your current volume is the number that should drive whether you renegotiate, migrate, or absorb the increase.

Price the whole curve before you commit, not just the entry tier: you're evaluating tool-calling infrastructure for a new build. A $29/mo sticker price tells you almost nothing about what the product costs once real users are hitting it. Ask Composio — and Arcade, Nango, and every other vendor in this category — what a mid-size production workload actually costs, and get self-managed credential pricing (if you'll need it) in writing rather than discovering it at renewal.

Look elsewhere: you need deterministic, auditable per-call cost from day one and identity-scoped credentials as a baseline rather than a paid upgrade — Arcade's model is built around exactly that. Or you need to self-host and own the auth layer outright with no vendor lock-in — Nango's free self-hosted tier covers the OAuth piece, at the cost of building your own tool schemas.

Usage-based pricing makes repricing like this structurally possible in a way flat pricing doesn't — that's not unique to Composio, it's true of the whole category. The lesson generalizes past this one vendor: when you're choosing infrastructure you plan to depend on for years rather than months, weigh the pricing model, not just this month's headline number.

What's your team's actual exposure if a core piece of infrastructure you depend on repriced overage 13–16x overnight — do you have the telemetry today to answer that question in an afternoon, or would you be finding out the hard way on next month's invoice?

Sources:

DEV Community