Fabriq Developer vs Composio: Free Tiers, Catalogues and Time to First Tool Call

Overview

This page is for a specific Friday afternoon. You have a seed-stage product, an agent that needs to touch four or five of your users' SaaS accounts, and a couple of hours before you want a real API response in a terminal. You want to know what $0 buys, whether your provider is in the box, and how much paperwork sits between you and the first successful call.

Two of our other comparison pages argue the enterprise case instead: 10 Best AI Agent Integration Platforms and Composio alternatives both rank on agent identity, per-user authority and audit. Useful if you're answering the security review. Not useful on a Friday, so none of it is repeated here.

Everything about Composio below comes from its pricing page and docs, read on 2026-10-12 and quoted. Everything about Fabriq Developer comes from our own pricing page and the generated catalogue in our codebase. Where we don't publish a figure, we say so rather than estimate.

The Free Tiers, Line by Line

Composio's Hobby plan costs $0 with "no credit card required" and includes 100,000 tool calls a month, 50,000 triggers, three team members, "Connect unlimited accounts" and the whole toolkit catalogue. At a cap, usage pauses rather than billing you. That detail matters more than it looks: a free tier that silently becomes a card charge is a different product from one that stops.

Pro is $29 a month with a $29 monthly usage credit that does not roll over. Past the credit, tool calls are $0.0003 each, trigger events $0.003 each, and LLM tokens $3.75 per million past the first million. Then there are per-execution-mode surcharges, which we think is the genuinely unusual part of the price list: direct execution adds $0.0001 a call, proxy execute $0.0002, sandbox execution $0.0001, a shared connection $0.0003. The same logical tool call can cost different amounts depending on how you ran it.

Fabriq Developer's Free plan is $0 "forever" with 20,000 calls a month, unlimited agents, per-agent tool permissions, request logs and live sessions, and the Python SDK, afctl CLI and MCP endpoint. Launch is $50 for 200,000 calls with add-ons at $2.50 per 10,000. Growth is $300 for 2,000,000 at $1.50 per 10,000.

Two things fall out of that. Composio's free call allowance is five times ours, and if your prototype is a loop hammering one tool, that's the only line you care about. And our free tier has no triggers, so a webhook-driven agent on Fabriq Developer starts at $50 rather than $0. We'd rather write that down than have you find it.

Run the rates out and the ordering flips above the free tier. Composio Pro past its credit is $0.0003 a call, or $3.00 per 10,000, against $2.50 on Fabriq Launch and $1.50 on Growth, before surcharges. None of that matters at prototype volume. It starts mattering around the first real customer.

Counting Catalogues, Which Nobody Does the Same Way

Composio publishes three different catalogue numbers on three of its own pages, and we read that as the unit being genuinely ambiguous rather than as anyone being dishonest. The pricing page lists "1500+ toolkits". The toolkits directory paginates "Showing 1–30 of 1214" and describes "20,000+ tools via MCP or direct APIs". The quickstart says "1000+ apps". A toolkit is an application; a tool is one callable action inside it. Twenty thousand tools across roughly twelve hundred toolkits is about sixteen actions per application, a fair average for a well-covered SaaS API.

Our catalogue is 509 providers, counted from a generated file in our codebase rather than a marketing page. It splits three ways by how a user's credential actually reaches the vault:

Say that plainly, because a developer who hits a console step they did not expect is a developer who leaves. Roughly a quarter of our catalogue has an end-user redirect. The rest is a key someone on your side pastes in once. For many products that's fine, because the provider issues one organization-wide key anyway. For a consumer product where every user brings their own account, it's a blocker.

A narrower limit sits on top. The external-user connect flow accepts thirteen provider values today: gmail, google_drive, google_docs, google_sheets, google_slides, google_calendar, google_meet, google_forms, google_contacts, google_chat, slack, github and notion. Anything else returns 400 Unsupported OAuth provider.

Time to First Successful Call

Composio's quickstart installs a core package plus a framework adapter. For the Claude Agent SDK path that is uv add python-dotenv composio composio-claude-agent-sdk claude-agent-sdk, or npm install dotenv @composio/core @composio/claude-agent-sdk @anthropic-ai/claude-agent-sdk. You put COMPOSIO_API_KEY in a .env, create a session with composio.sessions.create(user_id="user_123"), and call session.tools().

The session is the interesting design choice. Composio's docs define it as "the runtime context for an agentic run: the scoped environment an AI agent works in while it acts for one of your users," handing the agent "meta tools to discover, authenticate, and execute app tools at runtime, instead of loading hundreds of tool definitions into context." Authorization then happens mid-conversation: when a tool needs a connection, "the session generates a Connect Link with session.authorize()", or the agent drives the flow through COMPOSIO_MANAGE_CONNECTIONS.

So your first successful call can be very fast, because the quickstart deliberately starts with a tool that needs no authorization. The clock you care about is time to first authenticated call, and that one runs through the Connect Link and, for production, through the next section.

Ours looks like this:

pip install agentic-fabriq-sdk        # Python, imports as af_sdk
npm install @agenticfabriq/sdk        # TypeScript

from af_sdk import AgenticFabriq

af = AgenticFabriq()   # reads AF_APP_ID / AF_APP_SECRET

# inside your request handler
url = await af.initiate_connection(request, provider="gmail")
return redirect(url)

async with await af.for_user(request) as session:
    tools = await session.get_tools()
    result = await session.call_tool("google_gmail_list_messages", {"max_results": 5})

You register an agent in the console, which gives you an app ID and a one-time app secret. Those become AF_APP_ID and AF_APP_SECRET. Then two calls. The argument you pass is the request, not a user id, because identity is read from the session your own auth already established. We like that for a boring reason: there's no user-id parameter for an agent to get wrong, and no code path where a loop iterates over the wrong variable and sends somebody else's mail.

Figure 1 — The two setup paths. Composio's cliff is at the end, when you move to production. Ours is at the start, when you find out whether your provider has a redirect.

Tokens on our side are short-lived: 900 seconds by default, hard ceiling of one hour, and the Python client re-mints 60 seconds before expiry, so calling for_user per request is the intended pattern rather than waste. If you're driving a model instead of calling tools yourself, the session converts the same list with to_openai_tools(), to_anthropic_tools() or to_langchain_tools(). The TypeScript SDK deliberately does not wrap an MCP client; it gives you a token and an MCP URL for the client you already have.

Do You Have to Register Your Own OAuth Client?

This is the question that decides whether you ship this week, and both of us bury it in docs rather than put it on a pricing page.

Composio's answer is a clean split. Its authentication docs tell you to create an Auth Config, a blueprint holding the method, scopes and credentials for a toolkit, then give two paths: "Development/Testing: Use Composio's managed authentication (no setup required)" and "Production: Generate your own OAuth credentials from the toolkit's developer portal." The same page flags that the older Composio-managed route is being retired, warning that initiate() "will start returning 400 BadRequest on 2026-05-08 for new organizations" and pointing you at connected_accounts.link() instead.

Read that as a timeline, not a footnote. A frictionless demo on Composio's OAuth app, then a real project per provider before real users touch it. For Google that's a Cloud project, a consent screen, scope justifications and, for restricted scopes, a verification review not measured in days.

Our answer is that the OAuth clients are ours. The first line on our Developer page listing what you stop building is OAuth clients: our provider apps and verification, not yours. Registering an agent is one form and a one-time secret, no provider paperwork to begin. We broker the consent screen, and the authorization code is exchanged server-side before anything reaches a vault.

The cost is the console step for the 374 providers with no OAuth flow, plus the thirteen-provider limit on the end-user connect flow. One more boundary worth stating: the hosted credential-entry page, where your user pastes their own API key on a page we host and you never see it, supports Notion only today. Requesting method="api_key" for anything else returns 400. Nice machinery, exactly one provider behind it right now.

Who Holds the Token When the Call Goes Out

Neither of us hands your agent the user's secret, which is worth saying before the differences, because it's the part most teams get wrong building this themselves.

Composio executes through its own layer. The docs describe proxying: "You can proxy requests to any supported toolkit API and let Composio inject the authentication state," with the auth context coming from the connected account rather than your process. Custom tools inherit auth the same way through ctx.proxy_execute(), and the docs we read describe no API for retrieving a connected account's raw credential.

Ours is the same at the boundary and differs in what the agent is handed. for_user mints a short-lived, user-scoped token and returns a session whose identity is already baked in, so no method on it takes a user id. The credential lives in a vault at a path derived from the organization, agent, external user, tool and connection id, never in a database column and never in a response body. The agent gets a session, never the secret.

Fabriq gateway gateway computes: user's scopes INTERSECT agent's scopes gateway --fetch by reference--> Vault --access token--> gateway gateway --authorized request--> Provider API --response--> gateway gateway --result only--> your backend. The credential never leaves the gateway. -->

Figure 2 — The credential is attached server-side. The effective tool list is the intersection of the user's scopes and the agent's, so a broadly scoped agent acting for a narrowly scoped user gets the narrow set.

That intersection is the piece we'd defend hardest, and the piece a prototype doesn't notice. An agent declares the scopes it may ever ask for when you register it; a user grants what they grant; the effective tool list is the overlap. So the same agent acting for two users sees two different tool lists. Every token also records an auth_level: app_asserted by default, app_signed if you sign a 60-second EdDSA assertion with a private key we never hold, or user_present if a human just completed a connection and we witnessed it.

What we don't do is revoke at the provider when you disconnect. Disconnecting clears the grant we store. If you need the token dead at Google, call Google's revocation endpoint yourself.

Where Composio Is the Better Pick

A comparison page that concedes nothing isn't a comparison. Four cases where we'd tell you to use Composio.

Your provider list has a long tail. Twelve hundred toolkits against our 509 providers isn't a close call, and the gap is widest exactly where prototypes go: niche vertical SaaS, a regional payment processor, the analytics tool three people on your team use. If two of your four providers aren't in our catalogue, nothing else here matters.

You're burning calls in a loop. 100,000 free tool calls a month against our 20,000 is five times the headroom, and a retry loop can eat 20,000 in an afternoon.

You need triggers on day one. Composio's free tier includes 50,000 trigger events a month. Ours start on the $50 Launch plan. If the whole product is a webhook waking an agent, that's $50 a month at zero revenue.

You want the agent to drive its own connections. The meta-tool pattern, where the agent discovers, authenticates and executes at runtime and hands the user a Connect Link mid-conversation, is a nice shape for a chat product. Ours puts the connect step in your application's flow: tidier with an onboarding screen, worse for a single chat box.

Where we'd argue for us: managed OAuth clients that keep working in production, providers in the Google, Slack, GitHub and Notion neighbourhood, and per-user scoping plus a per-call audit record on the free tier. If you do want the enterprise argument, the agent access control taxonomy sets out the nine dimensions, credential model and enforcement point among them, that a security review eventually asks about.

Frequently Asked Questions

Is Composio free? Yes. Hobby is $0 with no credit card: 100,000 tool calls and 50,000 triggers a month, three team members, unlimited connected accounts. Usage pauses at the cap. Pro is $29 a month with a $29 usage credit included.

Is Fabriq Developer free? Yes. The Free plan is $0 forever with 20,000 calls a month, unlimited agents, per-agent tool permissions, request logs and live sessions, and the SDK, CLI and MCP endpoint. Triggers start on the $50 Launch plan.

How many integrations does Composio have? Depends which page you read. The pricing page says "1500+ toolkits", the directory lists 1,214, the quickstart says "1000+ apps". All three count applications. The action count it advertises is "20,000+ tools".

How many integrations does Fabriq Developer have? 509 providers. Of those, 123 have a live OAuth redirect, 12 have one in progress, and 374 have no OAuth flow and are connected once in the console. The end-user connect flow accepts thirteen provider values today.

Do I need my own OAuth app to use Composio? Not for development. Its docs say to use managed authentication for development and testing, and to "Generate your own OAuth credentials from the toolkit's developer portal" for production. So yes for production, per provider.

Do I need my own OAuth app to use Fabriq Developer? No. The provider apps and their verification are ours. The trade is that 374 of our 509 providers are connected in the console instead.

Which is cheaper, Composio or Fabriq Developer? Below the free caps, Composio, by five times on included calls. Above them, past Composio's Pro credit a tool call is $0.0003, or $3.00 per 10,000, against $2.50 per 10,000 on Fabriq Launch and $1.50 on Growth, before Composio's execution-mode surcharges.

Does Composio store my users' access tokens? Yes, and it attaches them server-side. Its docs describe proxying requests and letting Composio "inject the authentication state", and we found no documented API for reading a connected account's raw credential back out.

Does my end user need an account with the integration platform? Not with us. Fabriq Developer is for products whose agents act on your users' own accounts without those users ever creating a Fabriq account. Composio's connected-account docs describe your application owning the user_id and don't state that end users need a Composio account, so confirm that with them.

What's the fastest honest path to a first authenticated tool call? Pick a provider with an OAuth redirect on both sides, Gmail or Slack. On Composio, create the session, let the Connect Link authorize your own account, and accept that production needs your own client later. On ours, register the agent, initiate_connection(request, provider="gmail"), approve, then for_user(request).

Conclusion

The two free tiers are close enough that the price list isn't the decision. Composio gives you five times the calls and triggers you'd otherwise pay $50 for. We give you OAuth clients that survive the move to production and per-user scoping on the free plan. Both are real, and neither is what costs you the afternoon.

What costs you the afternoon is a provider. Composio's cliff is at the end: a fast demo, then an OAuth project and possibly a verification queue per provider before real users. Ours is at the start: a quarter of the catalogue has an end-user redirect and the rest is a console step. Both are findable in twenty minutes of docs, which beats finding out in week three.

So do the twenty minutes. Write down your four providers, look each up on both sides, and let the fourth one settle it. Catalogue totals are marketing arithmetic, and ours is no more useful than theirs.

Sources

All URLs read 2026-10-12. Fabriq figures are from our own published pricing page and the generated provider catalogue in our codebase, and are labelled as ours.

• Composio pricing — Hobby at $0 with no credit card, 100,000 tool calls and 50,000 triggers a month, 3 team members, unlimited connected accounts, usage pausing at the cap; Pro at $29 with a $29 credit; per-call, per-trigger and per-execution-mode rates; Enterprise terms.
• Composio toolkits directory — "Showing 1–30 of 1214" toolkits and "20,000+ tools via MCP or direct APIs", and the toolkit-versus-tool distinction.
• Composio quickstart — install lines for the Python and TypeScript paths, COMPOSIO_API_KEY, session creation, and the "1000+ apps" figure.
• How Composio works — the session definition, composio.sessions.create(user_id=...), meta tools instead of loading hundreds of definitions, and session.authorize() generating a Connect Link.
• Authenticating tools, Composio — Auth Configs, managed authentication for development versus your own OAuth credentials for production, and the initiate() deprecation notice.
• Executing tools, Composio — direct execution, proxy execute injecting authentication state, pinned toolkit versions, and framework handling of the execution loop.
• Connected accounts, Composio — the user_id model, ACTIVE / INACTIVE / REVOKED states, and the note that this page is legacy in favour of sessions.
• Custom tools, Composio — ctx.proxy_execute() inheriting auth, with no documented path to the raw credential.
• Agentic Fabriq pricing — our own Free, Launch and Growth developer plans: 20,000 calls a month free, $50 for 200,000 with add-ons at $2.50 per 10,000, $300 for 2,000,000 at $1.50 per 10,000.
• Fabriq Developer — ours: what you stop building, including OAuth clients and consent screens, and the one-form agent registration with no provider paperwork.
• Agentic Fabriq documentation — ours: the developer quickstart, initiate_connection and for_user, 900-second tokens with a one-hour ceiling, the thirteen-provider external-user connect list, and the Notion-only hosted credential page.
• Agent access control taxonomy — ours, vendor-neutral: nine dimensions including credential model, enforcement point and audit granularity.