Fabriq Developer vs Arcade: Free Tiers, Tool Counts and the OAuth App You Didn't Plan For

Overview

Arcade and Fabriq Developer are the two products in this market with the most similar thesis, and we've said so in print before. Both put the acting user in the middle of the call. Both keep the credential out of the agent. Arcade's homepage calls itself "the actions runtime between your agents and every system they reach" and says agents "act on behalf of the authenticated user, never through broad service accounts," which is the shape we build around too.

Which makes the architecture comparison boring, so this isn't one. Our other pages cover that ground: 10 Best AI Agent Integration Platforms and Composio alternatives both rank the category on governance.

This one is for the Friday before you've raised a Series A. What's in the free tier, how big the catalogue is and how it's counted, what you set up before the first authenticated call, whose OAuth client it is, and what happens to your users' tokens. Arcade figures come from its pricing page and docs, read 2026-10-12 and quoted. Ours come from our pricing page and the generated catalogue in our codebase.

The Free Tiers, Line by Line

Arcade's Free plan is "$0 /month" with "2,000 auth events / month" and "2,000 tool calls / month", fully managed on Arcade Cloud, community support. Team is "$25 /month + usage": a $25 platform fee, then "Auth events at $0.10 each" and "Tool calls at $0.01 each". Enterprise is custom, "includes annual bundles of auth events and tool calls" with discounted overage rates, and runs on Arcade Cloud, in your VPC, or fully air-gapped, with SSO, RBAC and audit logs.

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 to stare at: the metered auth event and the per-call rate. Arcade bills authorization as its own unit, which makes sense when authorization is the product, but a product whose users reconnect often has a second meter running. And Arcade Team's tool calls are $0.01 each, or $100 per 10,000, against $2.50 per 10,000 on Fabriq Launch and $1.50 on Growth.

We want to be careful with that gap rather than smug, because unit prices on an unbundled $25 plan aren't comparable to a bundled $50 one. Arcade's Enterprise tier "includes annual bundles" at discounted rates that aren't published, and that's presumably where a real customer lands. Above prototype volume, Arcade's Team list price isn't the number you'll pay, and nobody outside Arcade can say what is.

What we can say flatly: 2,000 calls a month is tight. One afternoon debugging a loop can spend it.

Counting Catalogues, Which Nobody Does the Same Way

When we last checked Arcade in August 2026 it published no catalogue count. That's changed: the homepage now advertises "8,000+ permission-aware tools". The auth provider list is a separate and much smaller number: 34 built-in providers, Airtable through Zoom, plus a generic OAuth 2.0 entry for anything else. Its MCP server catalogue, in nine categories from Productivity through Databases, publishes no aggregate count we could find.

Arcade also does something we think the rest of this market should copy. It splits its catalogue into Optimized and Unoptimized tiers, the second formerly called Starter, and describes the difference plainly. Optimized servers "are designed to match the typical data models expected in AI-powered chat interfaces and are subject to evaluation suites to ensure LLMs can safely use them." Unoptimized ones "are heavily influenced by the original API design. Each tool mirrors one HTTP endpoint." Use an Optimized tool where one covers your need, says the guidance, and treat the rest as a complement.

That's the most useful thing in any of these catalogues, because it tells you what a big number is made of. A platform advertising twenty thousand tools is mostly advertising endpoint wrappers. Which are fine. They aren't the same product as a tool somebody wrote an eval for.

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

Say it plainly, because a developer who hits a console step they didn't expect is a developer who leaves. About a quarter of our catalogue has an end-user redirect; the rest is a key somebody on your side pastes in once. A narrower limit sits on top: the external-user connect flow accepts thirteen provider values today, the ten Google ones plus slack, github and notion, and anything else returns 400 Unsupported OAuth provider.

Time to First Successful Call

Arcade's quickstart is short. uv add arcadepy in Python or bun install @arcadeai/arcadejs in TypeScript, then an API key, either passed to the constructor or set as ARCADE_API_KEY:

from arcadepy import Arcade
client = Arcade(api_key="{arcade_api_key}")
user_id = "{arcade_user_id}"

Then the pattern the docs recommend wrapping every call in:

auth_response = client.tools.authorize(tool_name=tool_name, user_id=user_id)
if auth_response.status != "completed":
    print(f"Click this link to authorize {tool_name}:\n{auth_response.url}")
    client.auth.wait_for_completion(auth_response.id)
return client.tools.execute(tool_name=tool_name, input=input, user_id=user_id)

A clean design. Authorization is a first-class check before execution, the link comes back to you to deliver however you like, and wait_for_completion blocks until the user is done. The quickstart's first example is GoogleNews.SearchNewsStories, which needs no authorization, so headline time-to-first-call is a minute or two and time to first authenticated call is a different number.

Ours:

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

url = await af.initiate_connection(request, provider="gmail")   # in your handler
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})

Register an agent in the console, get an app ID and a one-time app secret, set them as AF_APP_ID and AF_APP_SECRET, then two calls. The argument is the request, not a user id, because identity is read from the session your own auth already established. That's the sharpest API difference between us: Arcade's user_id is a string you choose and pass on every call, ours is derived from the request. We prefer ours because no agent can get a user-id parameter wrong and send somebody else's mail. Arcade's is more flexible if your caller isn't an HTTP request at all.

Figure 1 — Both reach a first call in minutes. The branch that matters is the one hanging off the authorization step, where Arcade's default app pulls your end user into an Arcade account.

Tokens on our side last 900 seconds by default with a 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. For model-driven code the session converts the list with to_openai_tools(), to_anthropic_tools() or to_langchain_tools().

The Verifier Problem

This is the section to read if you read nothing else, and it's the one that isn't on anybody's pricing page.

Arcade does provide default OAuth credentials, generously. Its Microsoft page says Arcade Cloud "provides a default Microsoft auth provider so you can try the Arcade Microsoft MCP servers without registering your own app", and Discord's says Arcade Cloud "includes a default Discord auth provider, so you can start without any configuration." Each carries per-provider caveats worth reading: the Microsoft default supports work and school accounts only.

Two costs come with any default, both documented. On the consent screen, "your users will see the Arcade brand (name and logo) on the auth screen and your authentications will share any rate limits from those providers with other Arcade customers." The harder one is in the production guidance: the default OAuth apps "can only be used with the Arcade user verifier, which requires each end user to sign in to an Arcade account that is a member of your project." That "ties end-user authorization to project membership, which is why the default OAuth apps are intended for development and single-tenant use."

For a multi-user production app the docs tell you to add your own OAuth app credentials "and pair them with a custom user verifier, so your end users are verified by your app rather than by project membership." Two pieces of work: a provider project per integration, plus a verification route you write and host.

Our OAuth clients are ours and there's no verifier to build. The first line on our Developer page listing what you stop building is OAuth clients: our provider apps and verification, not yours. Your customer approves on a consent page we host, with no Fabriq account and no sign-up. Every token records an auth_level saying how strongly the user was proven: app_asserted by default, app_signed if you sign a 60-second EdDSA assertion with a private key we never hold, user_present if a human just completed a connection and we witnessed it.

Figure 2 — The decision tree per provider. Arcade's two yes-branches lead to very different amounts of work, and the split is multi-user versus single-tenant rather than free versus paid.

Who Holds the Token When the Call Goes Out

Both of us keep the secret away from the model the same way: the credential is attached server-side and the agent gets a result. Arcade's docs put it as "Arcade remembers the user's authorization tokens, so you don't have to", and on the tool-building side, "LLMs and MCP clients cannot see or access your OAuth tokens."

There's one real difference, and it cuts for or against Arcade depending on what you're building. Arcade will give your server the raw token on request. Start an authorization with client.auth.start(user_id=..., provider="google", scopes=[...]), wait for it, and auth_response.context.token is the third-party access token, which you can hand to a provider SDK and call the API yourself. Inside a custom tool, context.get_auth_token_or_empty() does the same job.

A genuinely useful escape hatch. It also means the token's blast radius is a per-call-site decision rather than a property of the platform, and once it's in your process it's in your logs, your traces and whatever your error reporter serialises.

On our side, 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 provider credential lives in a vault at a path derived from the organization, agent, external user, tool and connection id, never in a database column or a response body. The agent gets a session, never the secret, and there's no context.token equivalent.

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 3 — Our call path. 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.

The intersection is the piece a prototype doesn't notice and a second customer does. An agent declares the scopes it may ever ask for when you register it; a user grants what they grant; the effective list is the overlap. Arcade describes a comparable model, saying authorization "is delegated, so the agent acts as its user and never past its own scope," which we'd read as the same idea arrived at independently.

What neither of us should be assumed to do is kill the grant at the provider. Disconnecting clears the grant we store, and if you need the token dead at Google you call Google's revocation endpoint yourself. We'd ask Arcade the same question rather than guess.

Where Arcade Is the Better Pick

Arcade is the competitor whose thesis we respect most, so this list is longer than it would be for anyone else.

You want the raw token. auth_response.context.token has no equivalent in our external-user flow. If your product is mostly your own code calling provider SDKs and you want managed OAuth under it rather than a tool-calling layer over it, Arcade is built for that and we aren't.

You need to run it yourself. Arcade's Enterprise tier runs in your VPC or fully air-gapped. If your first customer is a hospital or a bank, that line ends the evaluation.

Your providers are in its 34 and not in our 123. Atlassian, Salesforce, ServiceNow, Zendesk, HubSpot, Linear, Figma and Miro all have built-in Arcade auth providers.

You care about tool quality over tool count. The Optimized tier is subject to evaluation suites. We don't publish an equivalent distinction, and pretending otherwise is the kind of claim this page exists to avoid.

You're single-tenant anyway. If the agent acts for your own team, the verifier requirement isn't a cost, it's just how your users sign in, and you get the fast path with none of the production work.

Where we'd argue for us: end customers who must never see our name, a free tier ten times larger on calls, no separate auth meter, and no verifier to build. If you want the governance argument instead, the agent access control taxonomy sets out the nine dimensions, credential model and delegation model among them, that a security review eventually asks about.

Frequently Asked Questions

Is Arcade free? Yes. The Free plan is $0 a month with 2,000 auth events and 2,000 tool calls a month on Arcade Cloud, with community support. Team is $25 a month plus usage, at $0.10 per auth event and $0.01 per tool call.

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.

How many tools does Arcade have? Its homepage says "8,000+ permission-aware tools", and it lists 34 built-in auth providers plus a generic OAuth 2.0 option. We found no published aggregate count of MCP servers in its catalogue.

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

Do I need my own OAuth app to use Arcade? Not in development, for the many providers with a default. But the default apps work only with Arcade's user verifier, which requires each end user to have an Arcade account in your project, so multi-user production needs your own app and a custom verifier.

Do I need my own OAuth app to use Fabriq Developer? No. The provider apps and their verification are ours, and there's no verifier to build. The trade is that 374 of our 509 providers are connected in the console instead of through an end-user redirect.

Do my users need an Arcade account? On a default Arcade OAuth app, yes, per its production docs. With your own OAuth app and a custom verifier, no. With us, no.

Which is cheaper, Arcade or Fabriq Developer? On list prices, we are: 20,000 free calls against 2,000, then $2.50 per 10,000 on Launch against $0.01 per call on Arcade Team. But Arcade's Enterprise bundles are discounted and unpublished, so above prototype volume nobody outside Arcade can answer this.

Can I get the user's access token out of either platform? Out of Arcade, yes: auth_response.context.token after client.auth.start, or context.get_auth_token_or_empty() inside a tool. Out of our external-user flow, no.

Conclusion

We think Arcade is the closest thing to us in this market, and the free tiers aren't where the difference shows up. Ten times the calls is a real advantage for us and a small one, because both numbers are prototype numbers and both plans exist to get you to a paid one.

The difference shows up at the user verifier. Arcade's defaults are built for an operator running an agent for themselves or their own company, and its docs say so: development and single-tenant use. Ours are built for a product whose users are strangers. If you're the first kind of team, Arcade's fast path is genuinely fast and you'll never pay the verifier cost. If you're the second, you'll pay it right before launch, which is the worst week to find a new project in your backlog.

Against that, our catalogue floor is uneven and we'd rather you heard it here. Check your four providers against Arcade's 34 and our 123 before you write anything, and let that lookup decide rather than a tool count on either homepage.

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.

• Arcade pricing — Free at $0 with 2,000 auth events and 2,000 tool calls a month; Team at $25 a month plus $0.10 per auth event and $0.01 per tool call; Enterprise with annual bundles, VPC and air-gapped deployment, SSO, RBAC and audit logs.
• Arcade homepage — "8,000+ permission-aware tools", the actions-runtime framing, and delegated authorization with agents acting on behalf of the authenticated user.
• Arcade quickstart — uv add arcadepy, bun install @arcadeai/arcadejs, ARCADE_API_KEY, the authorize-then-execute helper, and the no-auth first example.
• Arcade auth providers — the 34 built-in providers plus generic OAuth 2.0, and the trade-off on default providers: Arcade branding on the auth screen and shared provider rate limits.
• Secure auth in production, Arcade — default OAuth apps working only with the Arcade user verifier, project membership, the development and single-tenant framing, and the own-app-plus-custom-verifier requirement.
• Authorized tool calling, Arcade — Arcade remembering the user's authorization tokens and the user_id-only execution path.
• Directly call third-party APIs, Arcade — client.auth.start, wait_for_completion, and auth_response.context.token as a usable third-party credential.
• Add user authorization to your MCP tools, Arcade — context.get_auth_token_or_empty(), and the token being injected at runtime where LLMs and MCP clients cannot see it.
• Types of tools, Arcade — Optimized servers subject to evaluation suites, Unoptimized tools mirroring one HTTP endpoint each, and the recommendation between them.
• Arcade MCP servers catalogue — the nine categories, the Optimized and Starter tiers, and the absence of a published aggregate count.
• Microsoft auth provider, Arcade — a default Microsoft auth provider in Arcade Cloud, usable without registering your own app, limited to work and school accounts.
• Discord auth provider, Arcade — a default Discord auth provider included in Arcade Cloud, with your own app credentials recommended for production.
• Agentic Fabriq pricing — ours: Free at 20,000 calls a month, Launch at $50 for 200,000 with add-ons at $2.50 per 10,000, Growth at $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 one-form agent registration with no provider paperwork.
• Agentic Fabriq documentation — ours: initiate_connection and for_user, 900-second tokens with a one-hour ceiling, the thirteen-provider external-user connect list, the auth_level ladder, and the Notion-only hosted credential page.
• Agent access control taxonomy — ours, vendor-neutral: nine dimensions including credential model, delegation model and enforcement point.