
Comparison
Fabriq Developer vs Composio: Free Tiers, Catalogues and Time to First Tool Call
Free tiers, catalogue counts, who owns the OAuth app, and the setup before your first authenticated tool call. First-party, checked 29 October 2026.
TL;DR
Both are free to start, and the number that decides your afternoon is not the free call allowance. It's whether you have to register your own OAuth client before anything works for a real user.
Composio's Hobby plan is $0 with no credit card and includes 100,000 tool calls a month, 50,000 triggers and unlimited connected accounts. Fabriq Developer's Free plan is $0 forever with 20,000 calls a month. Composio wins that line five to one.
Then read Composio's own auth documentation, which splits the setup two ways: "Development/Testing: Use Composio's managed authentication (no setup required)" and "Production: Generate your own OAuth credentials from the toolkit's developer portal." That second line is the Google Cloud console, a consent screen and a verification queue, and it is not on the pricing page.
Our answer is narrower than "we handle OAuth". Agentic Fabriq's shared provider apps are a paid-plan feature: on Free, your users connect through your own OAuth app, and Gmail and full Google Drive use your own Google app on every plan because Google treats those scopes as restricted. What you avoid on a paid plan is a provider project for Calendar, Sheets, Docs, Slack, Notion and most of the rest, after one attestation.
The other number to know is the shape of our catalogue: 511 providers, of which 125 have a live OAuth sign-in, 12 are building one, and 374 have no OAuth at all and connect by credential instead. The external-user OAuth flow drives thirteen provider values end to end today; everything else goes through a credentials page we host, which your user, not you, fills in.
So: evaluate on the provider you actually need, not the catalogue total. Open both docs pages for that one provider and see which flow it has.
Published by Agentic Fabriq. This is a first-party comparison: we make one of the two products on it, so read it as our argument rather than an independent test. We score neither product and we call nothing here independent. Comparison checked: 29 October 2026. Every Composio claim below links to Composio's own current pricing page or documentation, with the date we read it; where a figure is not published on a primary source we say so instead of estimating. Fabriq figures come from our own pricing page, the Fabriq Developer page, the Developer Quickstart, and the generated provider catalogue in our codebase.
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, re-read on 2026-10-29 and quoted. Everything about Fabriq Developer comes from our own pricing page, our Developer Quickstart and the generated catalogue in our codebase. Where we don't publish a figure, we say so rather than estimate.
The honest framing: Composio is a bigger catalogue with a sharper production cliff. We're a smaller catalogue with the cliff moved to the start, where you can see it. Which trade you want depends on which providers you need and when you ship.
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, Growth $300 for 2,000,000. That works out at $2.50 and $1.50 per 10,000 included calls
respectively, and if you run past the pool, add-on calls are $2 per 10,000 on either paid plan.
| Composio Hobby | Fabriq Developer Free | |
|---|---|---|
| Price | $0, no credit card | $0, forever |
| Tool calls included | 100,000 / month | 20,000 / month |
| Triggers included | 50,000 / month | not on Free; Triggers start on Launch |
| Seats | 3 team members | not published per plan |
| Connected end users | "Connect unlimited accounts" | not published per plan |
| At the cap | usage pauses | not published |
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 per 10,000 included on Fabriq Launch, $1.50 on Growth and $2 for add-on calls, before Composio's execution-mode 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 1540" and the site describes "20,000+ tools via MCP or direct APIs". The homepage says "1,500+ apps" and the quickstart says "1000+ apps". A toolkit is an application; a tool is one callable action inside it. Twenty thousand tools across roughly fifteen hundred toolkits is about thirteen actions per application, a fair average for a well-covered SaaS API. (The directory read 1,214 when we first wrote this page on 2026-10-12 and 1,540 on 2026-10-29, which is the best argument we can make for checking a catalogue number yourself rather than quoting ours.)
Our catalogue is 511 providers and 62,678 catalogued actions, counted from a generated file in our codebase rather than a marketing page. It splits three ways by whether a user can sign in at the provider at all:
| Connect path | Providers | What your user does |
|---|---|---|
| Live OAuth sign-in | 125 | Gets redirected, approves at the provider, comes back |
| OAuth in progress | 12 | Not yet; today the credential route is the only one |
| Credential only | 374 | No OAuth flow at all; supplies a credential instead |
Of the 125 with a live OAuth sign-in, 87 can run on Agentic Fabriq's own provider app and 116 accept an OAuth app you register yourself; most support both. Three quarters of the catalogue has no OAuth at all, and that is the honest shape of it.
What those 374 are not, on the developer path, is an admin step. Our developer documentation is explicit that there is no admin-entered credential path for external users: every credential, an OAuth grant or a pasted key, is supplied by your user on a page Agentic Fabriq hosts. 448 of the 511 providers reach that page — 444 where your user pastes a credential, and 4 (WhatsApp, Instagram, LinkedIn, Telegram) where they complete the provider's own sign-in, a QR scan or a pairing code, with no credential to paste. The ticket lives in the URL fragment, is single-use, expires in five minutes, allows three attempts, and the credential is probed against the provider before it is stored. An earlier version of this page said that hosted page supported Notion only; that was true when we wrote it and is not true now, and the correction runs in our favour.
A narrower limit does still sit on top, and it is the one to plan around. The external-user OAuth 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.
The test that beats both catalogue numbers: write down the four providers your product needs this quarter and look each up in Composio's toolkit directory and in ours, checking the connect flow for that specific provider. A total of 511 or 1,540 tells you nothing about whether your fourth provider is the one that isn't there.
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 # TypeScriptfrom 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 is one of the thirteen on the end-user OAuth path.
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 has a plan boundary in it, and we would rather you read it here than find it on the pricing page. Agentic Fabriq's shared provider apps (our client, our verification, our consent screen) are a paid-plan feature. On Free, your users connect through an OAuth app you register. On Launch or Growth you get our shared apps for non-restricted scopes after a one-time attestation, which covers Calendar, Sheets, Docs, Slack, Notion and most of the catalogue. Gmail and full Google Drive are restricted scopes under Google's policy and always go through your own Google app, on every plan. So if Gmail is the integration your product is built on, you file for Google verification either way, and we should not be sold to you on the basis that you don't.
What we do remove on a paid plan is the per-provider project for everything that isn't a restricted scope. Registering an agent is one form and a one-time secret. We broker the consent screen, and the authorization code is exchanged server-side before anything reaches the vault. The other cost is reach: thirteen providers on the end-user OAuth path, and the rest through the hosted credentials page described above.
| Composio | Fabriq Developer | |
|---|---|---|
| Demo without your own OAuth app | Yes, managed auth for development | Yes, on a paid plan; Free is bring-your-own |
| Production without your own OAuth app | No, per the docs | Yes for non-restricted scopes on a paid plan |
| Gmail / full Google Drive | Your own client for production | Your own Google app on every plan |
| Consent screen branding | Yours, once you bring a client | Ours, on our shared apps |
| Setup unit | Auth Config per toolkit | One agent registration, plus one attestation |
| The catch | Own credentials before production | 13 providers on the end-user OAuth path |
If you check one thing before committing: pick your hardest provider, the one with restricted scopes, and work out who stands between you and that provider's review queue. On Composio in production, you do. With us, we do, where we have a redirect.
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.
Side by Side, Eight Dimensions
One table, eight dimensions, every Composio cell sourced to a Composio page we read on 2026-10-29. Where a figure is not published on a primary source, the cell says so rather than carrying a guess, and no row here is scored.
| Dimension | Composio | Fabriq Developer | Composio source, read 2026-10-29 |
|---|---|---|---|
| Provider coverage | "1500+ toolkits" on the pricing page; the directory paginates "1–30 of 1540"; "20,000+ tools via MCP or direct APIs"; the homepage says "1,500+ apps" | 511 providers, 62,678 catalogued actions; 125 with a live OAuth sign-in, 12 in progress, 374 credential-only | pricing, toolkits, composio.dev |
| User-connection model | A session is "the runtime context for an agentic run"; you create it with a user_id your app chooses, and session.authorize() returns a Connect Link the user opens | initiate_connection(request, provider); identity is read from your framework's session, so no method takes a user id. 13 providers on the end-user OAuth path, 448 through an Agentic Fabriq-hosted credentials page | how Composio works |
| Who owns the OAuth app | "Development/Testing: Use Composio's managed authentication (no setup required)" and "Production: Generate your own OAuth credentials from the toolkit's developer portal" | Agentic Fabriq's shared apps on a paid plan for non-restricted scopes after a one-time attestation; your own app on Free; Gmail and full Google Drive always your own Google app | authenticating tools |
| Credential handling | SOC 2 Type II; the proxy "inject[s] the authentication state" from the connected account, and custom tools inherit auth through ctx.proxy_execute(). No API for reading a connected account's raw credential on the pages we read | Vault-held at a path derived from org, agent, external user, tool and connection id; attached server-side at call time. The agent gets a session, never the secret, and there is no raw-token path in the external-user flow | executing tools, custom tools, composio.dev |
| SDK / framework support | composio plus a framework adapter; the quickstart names OpenAI Agents, the Claude Agent SDK and the Vercel AI SDK, and the catalogue is reachable from "any AI tool that supports connecting to MCP servers" | Python agentic-fabriq-sdk and TypeScript @agenticfabriq/sdk, one MCP endpoint, and to_openai_tools() / to_anthropic_tools() / to_langchain_tools() on the session | quickstart, composio.dev |
| Audit access | "Every action is recorded, so you can see exactly what your AI did." Per-plan retention or export terms are not published on the pricing page we read | Request logs and live sessions on the Free plan; each call records the agent, the acting user, the tool and the outcome, denials included | composio.dev, pricing |
| Pricing unit | Three meters (tool call, trigger event, sandbox LLM token) plus a per-execution-mode surcharge: $0.0001 direct, $0.0002 proxy execute, $0.0001 sandbox, $0.0003 shared connection | One meter: an API call is any request your agent makes through Fabriq, including authenticating and retrieving credentials, and the duration of a call does not change its cost | pricing |
| Self-hosting | No self-hosted, VPC or air-gapped option is published on the pricing page or homepage we read. Ask Composio rather than taking this row as a no | Helm install into your own Kubernetes cluster on AWS or GCP on a custom plan; every other plan runs on our managed cloud | pricing |
Two rows are worth more than the rest if you are deciding this week. The pricing-unit row, because an agent that makes many short calls meets Composio's surcharge structure differently from a batch job. And the who-owns-the-OAuth-app row, because that is the one that has a calendar attached to it.
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. Fifteen hundred toolkits against our 511 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.
Which to Choose
Choose Fabriq Developer when your users are strangers who will never create an account with us and
identity has to come from the session your own auth already established rather than a user_id string your
code passes; when the providers you need sit in the Calendar, Sheets, Docs, Slack, Notion or GitHub
neighbourhood; when you want the credential to stay out of the agent's process by default rather than by
discipline; when one flat per-request meter is easier to forecast than three meters plus an execution-mode
surcharge; or when you want per-user scope intersection and a per-call audit record on a free plan.
Fabriq Developer and the Developer Quickstart are the two pages to
read next, in that order.
Consider Composio when your provider list runs into the long tail — this is its real and substantial advantage, and roughly three times our catalogue is not a gap we can argue away. Also when 100,000 free tool calls a month matters more than anything else on this page, when you need trigger events before you are paying anyone, or when you want the agent itself to discover, authorize and execute at runtime and hand the user a Connect Link mid-conversation. That meta-tool shape is a genuinely better fit for a single chat box than ours, which expects the connect step to live in your application's onboarding flow.
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. On 2026-10-29 the pricing page said "1500+ toolkits", the directory paginated "1–30 of 1540", the homepage said "1,500+ apps" and the quickstart said "1000+ apps". All four count applications. The action count it advertises is "20,000+ tools".
How many integrations does Fabriq Developer have? 511 providers and 62,678 catalogued actions, from the generated catalogue in our codebase on 2026-10-29. Of those, 125 have a live OAuth sign-in, 12 have one in progress, and 374 have no OAuth flow and connect by credential instead. The end-user OAuth flow accepts thirteen provider values today; 448 providers reach the Agentic Fabriq-hosted credentials page your user fills in.
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? It depends on the plan and the scope. On the Free plan, yes: your users connect through your own OAuth app. On Launch or Growth, our shared provider apps cover non-restricted scopes after a one-time attestation. Gmail and full Google Drive are restricted scopes under Google's policy and use your own Google app on every plan.
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 included on Fabriq Launch, $1.50 on Growth and $2 per 10,000 for add-on calls, before Composio's execution-mode surcharges. The units aren't identical, though: a Fabriq call includes authenticating and retrieving credentials, not only the tool call.
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 in two places you can see from the start — thirteen providers on the end-user OAuth path, and a paid plan before you can use our shared provider apps at all. 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.
The question we'd actually ask a vendor: not how many integrations you have, but what I have to register myself before a real customer can connect the fourth one. Everything else on a pricing page is downstream of that answer.
Sources
Composio URLs re-read 2026-10-29; where a figure changed since this page was first published on 2026-10-12, both readings are given above. Fabriq figures are from our own published pricing page, our developer documentation 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, "Connect unlimited accounts", hard-capped with "usage pauses until the next month or until you upgrade"; Pro at $29 with a $29 non-rolling credit; $0.0003 per tool call, $0.003 per trigger event, $3.75/M sandbox LLM tokens; execution-mode surcharges of $0.0001 direct, $0.0002 proxy execute, $0.0001 sandbox, $0.0003 shared connection; "1500+ toolkits"; no self-hosting, VPC or audit-retention terms published (checked 2026-10-29)
- Composio homepage — "1,500+ apps", SOC 2 Type II, "Every action is recorded, so you can see exactly what your AI did", and MCP reachability from any MCP-capable client (checked 2026-10-29)
- Composio toolkits directory — "1–30 of 1540" toolkits and "20,000+ tools via MCP or direct APIs", and the toolkit-versus-tool distinction (checked 2026-10-29; read 1,214 on 2026-10-12)
- Composio quickstart — install lines for the Python and TypeScript paths,
COMPOSIO_API_KEY,composio.sessions.create(user_id=...), the OpenAI Agents / Claude Agent SDK / Vercel AI SDK adapters, and the "1000+ apps" figure (checked 2026-10-29) - How Composio works — the session definition,
composio.sessions.create(user_id=...), meta tools instead of loading hundreds of definitions, andsession.authorize()generating a Connect Link. - Authenticating tools, Composio — an Auth Config as "a blueprint that defines how authentication works for a toolkit across all your users", managed authentication for development/testing versus "Generate your own OAuth credentials from the toolkit's developer portal" for production, and the
initiate()deprecation returning400 BadRequestfrom 2026-05-08 for Composio-managed auth configs (checked 2026-10-29) - 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_idmodel, 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 — ours: Free, Launch and Growth developer plans; 20,000 calls a month free with bring-your-own OAuth app and no access to our shared provider apps; $50 for 200,000 calls and $300 for 2,000,000, which is $2.50 and $1.50 per 10,000 included calls; add-on calls at $2 per 10,000; shared provider apps for non-restricted scopes on a paid plan after a one-time attestation; Gmail and full Google Drive on your own Google app on every plan; Helm self-install on AWS or GCP on a custom plan; what counts as an API call (checked 2026-10-29)
- Fabriq Developer — ours: what you stop building, and the one-form agent registration with a one-time secret.
- Developer Quickstart and Connecting Your Users' Tools — ours:
initiate_connectionandfor_user, identity read from the request, 900-second tokens with a one-hour ceiling, theauth_levelladder, the thirteen-provider external-user OAuth list, and the hosted credentials page — an end-user flow, not an admin one, covering roughly 450 providers, with the four linked-account providers signing in rather than pasting (checked 2026-10-29) - Agent access control taxonomy — ours, vendor-neutral: nine dimensions including credential model, enforcement point and audit granularity.