Arcade vs Composio pricing: how do tool execution costs compare at scale?

For most teams, the real pricing question isn’t “What’s the list rate?”—it’s “What do tool calls actually cost once my agents are in production and calling APIs all day?” This FAQ breaks down how Arcade’s tool execution pricing works, how it scales, and how to think about it relative to platforms like Composio when you move from a prototype to a multi-user, production agent.

Quick Answer: Arcade prices tool executions transparently by type (standard vs “pro” tools) with clear included quotas and low per-call overages, plus cheap MCP server-hours. At scale, the combination of usage-based pricing, low server-hour costs, and bring-your-own-credentials for expensive APIs usually yields lower and more predictable per-execution costs than generic “integration” platforms that blend tool costs into higher platform fees or lock you into service-account patterns.

---

Frequently Asked Questions

How does Arcade’s tool execution pricing actually work?

Short Answer: Arcade includes a pool of tool executions in each plan, then charges low per-execution overages that differ for standard vs. higher-cost “pro” tools, plus inexpensive hourly pricing for any additional Arcade-hosted MCP workers.

Expanded Explanation: In Arcade, you’re paying for two things tied directly to agent actions:

• How many tools your agents execute (standard vs. pro tools)
• How much Arcade-hosted MCP capacity you consume (server hours)

On the Hobby plan you get:

• 1,000 standard tool executions included
• 100 user challenges (auth prompts) included

On the Growth plan (the “everything in Hobby, scaled up” tier) you get:

• 2,000 standard tool executions included, then $0.01 per standard tool execution
• 100 “pro” tool executions included, then $0.50 per pro tool execution
• 600 user challenges included, then $0.05 per challenge
• Unlimited Arcade-hosted workers at $0.05 per server-hour
• Unlimited self-hosted workers

“Pro” tools are advanced tools with higher infrastructure cost (e.g., heavier workloads, scheduled executions). You can also use your own credentials for some of these, which lets you control the underlying API costs directly instead of paying a hidden markup.

Key Takeaways:

• Standard tools are cheap at scale: $0.01 per execution once you exceed included quotas.
• Pro tools are metered separately at $0.50 per execution (+$0.005 if scheduled), reflecting higher infra cost, with BYO-credentials to keep spend in your control.

---

How do I estimate Arcade costs for agents that call tools heavily?

Short Answer: Multiply expected standard and pro tool calls by their per-call overage rates, then add any Arcade-hosted worker hours you need; you can keep costs low by self-hosting workers and using your own credentials for expensive APIs.

Expanded Explanation: Tool execution cost in Arcade is deliberately linear and easy to model. You don’t need to reverse-engineer bundled “actions” or per-integration fees—you treat tool calls like API calls. For large workloads, the main knobs are:

• Tool mix: How many standard versus pro tools do your agents call?
• Concurrency / throughput: How many workers do you need online, and for how long?
• Hosting model: Arcade-hosted workers at $0.05/server-hour vs. self-hosted (no extra infra fee from Arcade).
• Auth volume: Number of user challenges (auth hand-offs) as users connect Gmail, Slack, Salesforce, etc.

If you’re building a sales or ops agent that:

• Sends 3–5 emails per workflow (Google.SendEmail)
• Adds calendar events (Google.CreateEvent)
• Posts in Slack
• Logs activity in HubSpot or Salesforce,

those are almost all standard tools. At 100k+ calls per month, you’re looking at roughly:

• 2,000 included + 98,000 overage standard executions
• 98,000 × $0.01 = $980 in tool execution overages
• A few dozen to a few hundred server-hours per month (e.g., $5–$50) depending on how many Arcade-hosted workers you run.

Most teams don’t hit “pro tool” usage unless they’re deliberately using advanced, heavy, or scheduled tools.

Steps:

1. Count projected tool calls per user flow (email, Slack post, calendar event, CRM update).
2. Multiply standard and pro tool calls by the published overage rates (after your plan’s included quota).
3. Add MCP worker hours if you plan to use Arcade-hosted workers instead of self-hosting (server-hours × $0.05).
4. Layer in auth challenges (user logins to Google/Slack/etc.) at $0.05 each after included amounts.
5. Adjust for headcount and expected usage growth to see monthly and annual bands.

---

How does Arcade’s tool execution pricing compare to Composio at scale?

Short Answer: Arcade charges directly per tool execution and per MCP worker-hour, while many Composio deployments blend tool usage into broader platform fees and service-account–centric integrations; at high volume, Arcade’s low per-call rate plus BYO credentials typically drives lower marginal costs and better alignment with real API usage.

Expanded Explanation: Both Arcade and Composio exist to connect agents to real systems, but they make different tradeoffs in how they charge and how those integrations work in production:

• Arcade is an MCP runtime with agent-optimized tools and explicit metering:

  • Clear per-call pricing for standard vs. pro tools.
  • Cheap worker-hours for Arcade-hosted MCP servers.
  • Support for self-hosting so you can run as much capacity as you want without extra runtime fees.
  • Tools designed for multi-user authorization (user-specific OAuth, zero token exposure to LLMs).

• Composio is typically positioned around “tons of integrations fast,” often fronted by service accounts or shared app credentials, with pricing that can roll things like integrations, actions, and support into plan-based tiers.

At small scale, both can look affordable. The divergence happens when you move to multi-user, high-volume tool execution:

• With Arcade, your cost curve is basically: included quota → $0.01 per standard tool call + $0.50 per pro tool call + $0.05/server-hour for any extra hosted workers.
• With Composio, you’re usually dealing with higher base plan costs and less direct alignment between your actual API call volume and your monthly bill, especially if you need granular, per-user authorization rather than a single bot identity.

Comparison Snapshot:

• Option A: Arcade
  • Transparent, per-tool-call pricing and cheap worker-hours.
  • Multi-user, user-specific auth baked into the runtime.
  • Self-hosting support with the same licensing and payment terms.
• Option B: Composio
  • Integration-centric pricing that may bundle usage into plan tiers.
  • Often optimized for rapid API connectivity, not per-user authorization at scale.
  • May rely more heavily on service accounts or shared app identities.
• Best for: Teams who expect high-volume tool execution across many users, want bills that scale linearly with actual tool usage, and need user-specific permissions and auditability instead of a single bot account.

---

What do I need to implement Arcade in a way that keeps execution costs predictable?

Short Answer: Use Arcade’s agent-optimized tools with scoped OAuth, segment workloads into standard vs. pro tools, and choose the right hosting model (Arcade-hosted vs self-hosted) so you can control both the per-call and infra side of pricing.

Expanded Explanation: Predictable pricing isn’t just about the rate card—it’s about how you architect your agents. With Arcade, the runtime gives you control levers that directly affect cost and reliability:

• Tool design: Good schemas and clear boundaries often reduce the number of tool calls per task. One well-designed Salesforce.UpsertOpportunity beats five brittle wrapper calls.
• Permission gates: Making the agent ask for permission before big actions (e.g., bulk email, mass updates) caps how many expensive operations actually fire.
• Hosting strategy: If you already run Kubernetes or similar, self-hosting MCP workers lets you scale horizontally with your own infra, keeping Arcade usage focused on auth, orchestration, and governance.
• Credential strategy: Using your own API keys / OAuth apps for “pro” tools keeps the raw API cost with your provider, avoiding hidden markups and giving you volume discounts directly from Google, Salesforce, etc.

Most teams wire this up with a minimal, repeatable pattern:

• SDK calls for auth (client.auth.start(...) + wait_for_completion).
• Agent-optimized tools like Gmail.ListEmails, Google.SendEmail, Google.CreateEvent, Slack.PostMessage, GitHub.CreateIssue.
• Permission gates in code, not prompts.

What You Need:

• A clear sense of your agent workflows (what real actions you expect agents to take).
• A hosting decision (Arcade-hosted vs. self-hosted workers) plus a plan for where your OAuth apps and API credentials will live.

---

From a strategic perspective, when is Arcade’s pricing model the better bet than Composio’s?

Short Answer: Arcade’s pricing model is strategically better when you’re building multi-user, production agents that will call tools heavily and need user-specific permissions, auditability, and predictable, linear costs instead of opaque “integration bundle” pricing.

Expanded Explanation: When you’re running a weekend prototype, pricing details don’t matter as much. Once you’re in front of security and finance, they absolutely do. The core strategic advantages of Arcade’s approach compared to an integration-centric platform like Composio are:

• Cost tied directly to value: You pay for tool executions and runtime where the agent actually does work—sending email, creating calendar events, posting to Slack—not for generic “access” to integrations.
• Multi-user by design: Because agents act with user-specific permissions (not just a single service account), you avoid the awkward (and often expensive) hacks needed to approximate per-user behavior on top of a bot identity.
• Governance and control: Enterprise controls like tenant isolation, audit logs, RBAC, and SSO/SAML let you put guardrails around tool usage. That’s not just a security story; it’s a cost-control story. You can see which tools are hot, which agents are noisy, and where to optimize.
• No token gymnastics: Arcade keeps credentials out of the model (“zero token exposure to LLMs”) and centralizes OAuth, refresh, and token storage. That means fewer broken flows, fewer emergency fixes, and less time burned on the kind of outages that can quietly inflate your cost of ownership.

Teams like LangChain and Snyk call this out explicitly: Arcade hits the sweet spot between AI, auth, and developer experience. That blend is what makes per-execution pricing sustainable when you’re running agents across Gmail, Calendar, Slack, GitHub, HubSpot, Salesforce, Linear, and more.

Why It Matters:

• Impact 1: Your marginal cost per tool execution stays low and predictable as you add more users and workflows, instead of spiking with each new integration or feature.
• Impact 2: You can walk into security and finance reviews with a clean story: “Here’s exactly what an agent action costs, here’s how it’s authorized, and here’s how we govern and audit it.”

---

Quick Recap

Arcade’s pricing is designed around the reality of production agents: you pay for tool executions (standard vs. pro) and runtime hours, with transparent per-call rates and the option to self-host MCP workers and bring your own credentials. Compared to integration-first platforms like Composio, this model tends to deliver lower, more predictable costs at scale—especially when you have many users, high tool call volumes, and strict requirements around user-specific permissions, auditability, and keeping tokens out of the model.

Next Step

Get Started