Unified MCP vs Arcade.dev: A 2026 Comparison

August 26, 2025

[Unified MCP](/mcp) and Arcade.dev solve different problems within the MCP integration space. Unified MCP is a hosted MCP server with 22,566 callable tools across 440+ integrations in 27 categories, combining normalized schemas across 2,100+ standardized data objects with passthrough access — the right choice when agents need broad integration coverage and consistent data models across vendors.

Arcade.dev is an MCP runtime specialist with hundreds of pre-built tools and an OAuth-first architecture — the right choice when production agents need rigorous per-user authorization, deployment flexibility (VPC, on-prem, air-gapped), and an open-core foundation. They're not strictly competing for the same buyer.

This post compares the two on integration coverage, schema model, OAuth architecture, deployment options, security posture, pricing, and use case fit.

Key takeaways

• Architectural distinction: Unified is an integration platform with MCP — broad coverage, normalized schemas, hosted-only. Arcade is an MCP runtime specialist — narrower coverage, OAuth-first architecture, deployment flexibility (hosted, self-host, VPC, air-gapped).
• Coverage: Unified leads on breadth — 440+ integrations across 27 categories with strong depth in CRM (49), HR & Directory (236), Accounting (45), and ATS (77). Arcade publishes "100+ services / hundreds of pre-built tools" focused on productivity, dev tools, messaging, and limited CRM.
• Schema model: Unified offers normalized schemas across 2,100+ standardized data objects (Contact, Deal, Candidate, Employee, Invoice, Payslip) plus passthrough via include_external_tools. Arcade uses vendor-native schemas only — no published cross-vendor normalization model.
• OAuth and security: Arcade is explicitly architected as an OAuth 2.1 Protected Resource with server-level and tool-level authorization separation. Unified uses per-connection authorization with stateless customer record handling.
• Deployment: Arcade supports hosted (Arcade Cloud / Arcade Deploy), self-host, VPC, and air-gapped deployments. Unified MCP is hosted-only with multi-region endpoints (US/EU/AU).
• Open source: Arcade is open-core — framework and SDKs are MIT-licensed; hosted runtime is proprietary. Unified is closed source.
• Pricing: Arcade has a free tier and $25/mo Growth tier with usage-based billing. Unified has a 30-day trial and $750/mo entry with unlimited connections.

What problem does each platform solve?

The Model Context Protocol standardizes how AI agents discover and call external tools, but it deliberately leaves operational concerns — retries, idempotency, replay, background execution, caching, authorization, deployment — to implementers. Different vendors fill that gap with different priorities.

Unified MCP prioritizes integration breadth and data consistency. The hosted server surfaces 440+ SaaS integrations as callable tools with normalized schemas across 27 categories, removing per-vendor branching from agent code. The team's design choices favor B2B SaaS products that need CRM, HR, ATS, accounting, and ticketing integrations to behave consistently regardless of which underlying vendor a customer uses.

Arcade.dev prioritizes OAuth correctness, deployment flexibility, and open-core foundations. The runtime is built around per-user authorization, with explicit OAuth 2.1 Protected Resource architecture and granular tool-level access controls. The team's design choices favor production agent teams — particularly in regulated industries — where multi-user delegated access and deployment control matter more than integration breadth.

These optimize for different problems. A reader might genuinely use both: Arcade for productivity-heavy workflows where per-user OAuth dominates, Unified for B2B SaaS data integrations where normalization across many vendors matters.

How do Unified MCP and Arcade.dev differ architecturally?

The fastest way to understand the difference: Unified is an integration platform with MCP; Arcade is an MCP runtime specialist.

Unified MCP architecture:

• Hosted MCP server at mcp-api.unified.to with regional endpoints in US, EU, and AU
• Normalized data layer — 2,100+ standardized data objects (Contact, Deal, Candidate, Employee, Invoice, Payslip, etc.) that work consistently across integrations in the same category
• Passthrough layer — full integration API access via include_external_tools for endpoints outside the normalized schema
• Stateless data routing — every MCP call routes directly to the source API; no customer records stored at rest
• Managed event infrastructure — native webhooks where vendors support them, virtual webhooks (managed polling) where they don't

The architectural emphasis is integration breadth and data consistency: normalized schemas where they reduce complexity, full passthrough where they don't, direct routing to source APIs for live data, and managed event delivery across the integration surface.

Arcade.dev architecture:

• MCP runtime + framework — Arcade documents an OAuth 2.1 Protected Resource architecture for the MCP server itself
• Authorization separation — server-level authorization (Bearer token validation on every HTTP request) plus tool-level per-user authorization
• Transport: stdio + Streamable HTTP — stdio for local development environments (e.g., Claude Desktop, Cursor), Streamable HTTP for remote deployments. Arcade is the only vendor in this comparison shipping stdio support.
• Hosted + self-host options — Arcade Cloud / Arcade Deploy for managed hosting, or self-host locally, on-prem, or in your own cloud
• VPC and air-gapped deployment — documented for regulated industries (healthcare, banking)
• Open-core foundation — MCP server framework and SDKs (arcade-mcp, arcade-py) MIT-licensed on GitHub; hosted runtime proprietary
• Hundreds of pre-built tools focused on productivity, dev tools, messaging, and limited CRM

The architectural emphasis is per-user OAuth correctness, deployment flexibility, and an open-core foundation that customers can audit and self-host.

The deeper distinction: Unified solves "give my agents consistent access to lots of SaaS data with no integration plumbing." Arcade solves "let many end-users safely authorize my agents to act in their accounts with rigorous OAuth and deployment control." Different problems, different optimal answers.

At-a-glance comparison

How does Arcade's OAuth architecture differ from Unified's?

This is Arcade's most distinctive technical choice and worth understanding clearly.

Arcade's OAuth model:

• The MCP server itself is documented as an OAuth 2.1 Protected Resource — Bearer tokens are validated on every HTTP request to the server
• Authorization is split into two layers:
  • Server-level authorization ("front-door auth") — validates that the requesting client is authorized to talk to the MCP server at all
  • Tool-level authorization — separate per-user identity for individual tool calls, so an agent can act "as the end user" against the underlying integration
• This separation means the MCP client identity (your agent's right to use Arcade) and the end-user identity (whose Gmail or Salesforce the agent is reading) are managed independently

The architectural value is real: for products with many end-users delegating permissions to agents, this model gives you cleaner audit trails, per-user revocation, and explicit OAuth 2.1 compliance at the protocol layer.

Unified's OAuth model:

• Per-connection authorization — each customer's connection to a vendor (e.g., one customer's Salesforce instance) is its own authorized credential
• OAuth flow, refresh tokens, and lifecycle managed centrally by Unified across the integration surface, abstracting per-vendor quirks from application code
• Optional customer-managed secrets — store OAuth credentials in your own AWS Secrets Manager, Google Cloud Secret Manager, Azure Key Vault, or HashiCorp Vault rather than on Unified's infrastructure
• Stateless customer record handling — only connection metadata and tokens retained

The architectural value is different: Unified abstracts OAuth complexity across hundreds of integrations so application teams don't read vendor docs or debug per-vendor quirks. For deeper coverage, see how to handle OAuth across many integrations.

Where each is stronger:

• Arcade is stronger when per-user OAuth correctness is the hardest problem (agents acting on behalf of many end-users in their own accounts)
• Unified is stronger when OAuth abstraction across many vendors is the hardest problem (one engineering team handling auth lifecycle for 50+ vendor integrations)

These overlap less than they might seem at first glance. Many real products need both patterns at once.

How do the integration models differ?

Arcade's tool model: vendor-native tools focused on action execution. Tools mirror the underlying API of the integration with vendor-specific schemas. There's no published cross-vendor normalization model — when working across multiple CRMs or ATS systems, schema reconciliation moves to application logic or prompts. Arcade emphasizes that tools are curated and tested for correctness rather than auto-generated.

Unified's tool model: combines normalized schemas with passthrough.

• Normalized layer: common objects (Contact, Deal, Company, Candidate, Job, Invoice, Bill, Employee, Payslip, etc.) share consistent schemas across integrations within the same category. A crm_contact_list tool returns the same shape whether the underlying integration is Salesforce, HubSpot, Pipedrive, or any of the 49 CRM integrations Unified supports.
• Passthrough layer: for endpoints outside the normalized schema, include_external_tools surfaces vendor-native APIs directly.

The trade-off is real: normalized schemas reduce per-vendor branching in agent code but constrain you to canonical fields. Passthrough preserves full vendor fidelity but requires per-vendor handling. Unified ships both layers; agents pick what they need per call.

For deeper coverage of how Unified handles CRM normalization specifically, see our CRM API integration guide.

What are the integration coverage trade-offs?

Unified leads on integration breadth and category depth; Arcade leads on focused coverage in productivity and dev tools.

Unified's coverage:

• 440+ integrations across 27 categories — see the full list at unified.to/integrations
• Deep coverage in B2B SaaS-relevant categories: CRM (49), HR & Directory (236, including payroll integration for ADP, Gusto, Paychex), Accounting (45), ATS (77), Advertising (13), Ticketing (7), Calendar & Meetings (27), Messaging (18)
• 2,100+ normalized data objects — the only vendor in this comparison shipping a unified data model layer at this depth
• Virtual webhooks across all integrations — Unified synthesizes webhook delivery via managed polling for integrations without native webhook APIs (most payroll, accounting, and HR vendors fall here). For deeper coverage, see what are virtual webhooks?.

Arcade's coverage:

• 100+ services with hundreds of pre-built tools (Arcade's own framing; no versioned total published)
• Strong coverage in productivity (Google Workspace, Microsoft 365), dev tools (GitHub, Linear, Jira), messaging (Slack, Zoom), and ticketing (Jira, Linear, Zendesk)
• Limited CRM coverage (HubSpot, Salesforce)
• No documented HRIS, ATS, or Accounting/ERP coverage
• Custom toolkits supported via Arcade's CLI

Where each gap shows up:

• Arcade is stronger for productivity and dev-tool-heavy agent workflows
• Unified is stronger for B2B SaaS workflows that span CRM, HRIS, ATS, accounting, payroll, and ticketing
• Arcade is stronger when curated, hand-tested tools matter more than coverage breadth
• Unified is stronger when an agent needs cross-vendor data consistency without custom mapping

How does deployment compare?

This is one of Arcade's clearest advantages and worth surfacing honestly.

Arcade's deployment options:

• Hosted (Arcade Cloud / Arcade Deploy) — managed runtime where Arcade runs your MCP servers and tools
• Self-host — run MCP servers locally, on-prem, in your own cloud, or third-party hosting
• VPC deployment — explicitly documented for regulated industries; customer data stays within internal networks
• Air-gapped environments — Arcade documents this as a supported deployment pattern
• Hybrid — on-prem servers connected to Arcade Cloud as a control plane

This flexibility is meaningful for organizations with strict network-level requirements (financial services, healthcare, government) or that need MCP infrastructure co-located with sensitive workloads.

Unified MCP deployment options:

• Fully hosted at mcp-api.unified.to with multi-region endpoints (US, EU, AU)
• Unified manages scaling, availability, and updates
• Customers do not deploy or operate MCP infrastructure
• Optional customer-managed secrets supported (AWS Secrets Manager, Google Cloud Secret Manager, Azure Key Vault, HashiCorp Vault) — but the MCP server itself is hosted

Where each fits:

• Arcade is the right choice for organizations that need VPC, on-prem, or air-gapped deployment for compliance or network-level reasons
• Unified is the right choice for teams that want zero operational MCP burden and are comfortable with multi-region SaaS hosting plus stateless architecture

For teams that explicitly need air-gapped deployment, Arcade is the only option in this comparison that supports it.

How do security and compliance compare?

Both vendors have credible 2026 security posture but with different strengths.

Arcade.dev:

• SOC 2 Type II achieved August 2025, still presented as current in 2025-26 materials
• OAuth 2.1 Protected Resource architecture at the MCP server layer
• Encrypted credential storage; tokens isolated from LLM inference
• Just-in-time authorization, tool-level access controls, audit trails
• VPC and air-gapped deployment for regulated industries
• GDPR alignment

Unified MCP:

• SOC 2 Type II + HIPAA + GDPR + CCPA + PIPEDA alignment
• Stateless architecture by default — no customer records stored at rest; only connection metadata and tokens retained
• Optional hide_sensitive filtering — removes sensitive fields from results before returning to LLMs
• Optional customer-managed secrets (AWS, Google Cloud, Azure, HashiCorp Vault)
• Multi-region deployments (US, EU, AU) for data residency
• TLS 1.2+ in transit, AES-256 for the minimal operational metadata stored at rest

Where each is stronger:

• Arcade's OAuth 2.1 Protected Resource architecture and tool-level authorization separation are stronger for products where per-user delegated access dominates
• Arcade's VPC and air-gapped deployment are stronger for regulated industries that can't use multi-tenant hosted infrastructure
• Unified's HIPAA + PIPEDA coverage is broader for US healthcare and Canadian regulatory contexts
• Unified's stateless architecture meaningfully reduces compliance scope — the integration vendor isn't a sub-processor for the data flowing through it

Both ship at enterprise-credible compliance posture. The right choice depends on which architectural properties matter for your specific procurement process.

How does open-source posture compare?

Arcade is open-core; Unified is closed source. Worth being explicit about what this means in practice.

Arcade's open-core split:

• MIT-licensed: the Arcade MCP server framework and SDKs (arcade-mcp, arcade-py on GitHub) — customers can audit, fork, and self-host the framework freely
• Proprietary SaaS: the hosted runtime (Arcade Cloud / Arcade Deploy), gateway, dashboards, and management plane

This split lets customers verify the framework code, run it in environments where SaaS isn't acceptable, and avoid vendor lock-in at the framework layer while still using Arcade's managed services where convenient.

Unified's closed-source approach:

• The integration platform, MCP server, and SDK auto-generation are proprietary
• SDKs are auto-regenerated from OpenAPI specs on every release across 7 languages — no customer-side framework to audit, but also no manual SDK maintenance
• Customer-managed secrets and the stateless architecture provide some of the same audit and control properties through different mechanisms

Where each is stronger:

• Arcade is stronger for organizations with strong open-source preferences or compliance requirements that benefit from auditable framework code
• Unified is stronger for teams that prioritize broad SDK polyglot support (TypeScript, Python, PHP, Java, Go, C#, Ruby) over framework-level auditability

How does pricing compare?

Arcade.dev:

• Free tier — Arcade's pricing update describes a free tier valued at approximately $76/mo
• Growth plan — $25/mo base + usage-based billing (challenges, executions, workers); executions from $0.01 each
• Per-execution and per-scope-change fees for usage above plan inclusions
• Public pricing page

Unified MCP:

• Free tier — 30-day trial only
• Entry paid plan — $750/mo (Grow plan)
• Pricing model — API call volume with unlimited connections on every plan
• Public pricing page

Honest characterization:

• Arcade is dramatically friendlier for early-stage prototypes and individual developers. The free tier and $25/mo Growth tier remove procurement friction for small teams testing agent ideas.
• Unified's $750/mo entry tier signals enterprise positioning. The unlimited-connections model means scale economics favor B2B SaaS products with many customer connections — you don't get re-priced as you onboard more customers.
• The unit economics differ in shape: Arcade's per-execution model is cheaper at low volume and scales linearly with usage. Unified's volume-based model with unlimited connections favors high connection counts where per-connection economics matter more than per-call pricing.
• For early-stage agent experiments, Arcade's free tier is meaningfully more accessible. For production B2B SaaS at customer scale, Unified's pricing model aligns better with usage growth.

When to choose Arcade.dev

Arcade is the right choice when:

• Your hardest problem is per-user OAuth correctness — agents acting on behalf of many end-users in their own accounts (Gmail, Salesforce, Slack, etc.)
• You need VPC, on-prem, or air-gapped MCP deployment for compliance or network-level requirements
• You're in a regulated industry (financial services, healthcare, banking) where deployment control matters as much as functionality
• You prefer open-core foundations with MIT-licensed framework code you can audit
• Your agent workflows are concentrated in productivity (Google Workspace, Microsoft 365), dev tools (GitHub, Linear, Jira), or messaging (Slack, Zoom)
• You want a free tier or low entry pricing for experimentation
• OAuth 2.1 Protected Resource architecture at the MCP server layer is a procurement requirement
• You want broad deployment flexibility — managed (Arcade Cloud / Arcade Deploy), self-host, VPC, on-prem, or air-gapped — depending on the use case
• You need stdio transport support for local development environments (Claude Desktop, Cursor)

When to choose Unified MCP

Unified MCP is the right choice when:

• Your hardest problem is integration breadth and data consistency across many vendors
• Your agents need normalized schemas across CRM, HR, ATS, accounting, ticketing, or other B2B SaaS categories
• Your product depends on real-time data access without operating polling or sync infrastructure
• You need event delivery from integrations that don't have native webhooks (payroll, accounting, HR systems where Unified's virtual webhooks fill the gap)
• You're building B2B SaaS at customer scale where unlimited connections matter for unit economics
• You need HIPAA, PIPEDA, or specific regional compliance (US/EU/AU multi-region endpoints)
• You want broad SDK coverage (TypeScript, Python, PHP, Java, Go, C#, Ruby) for backend integration alongside MCP
• You want zero operational MCP burden — no infrastructure to deploy, scale, or update
• You want a stateless architecture where the integration vendor isn't a sub-processor for customer data flowing through it

Frequently asked questions

What is the difference between an MCP integration platform and an MCP runtime?

An MCP integration platform (like Unified MCP) prioritizes integration breadth and data consistency — surfacing many SaaS APIs as callable tools with normalized schemas. An MCP runtime (like Arcade.dev) prioritizes the operational layer around MCP itself — OAuth correctness, deployment flexibility, governance, and per-user authorization. Both surface tools to agents via the MCP protocol, but they optimize for different problems.

Which is better for AI agents — Unified MCP or Arcade.dev?

Neither is universally better — they optimize for different problems. Unified MCP is better when your hardest problem is integration coverage and data consistency across many vendors (broad SaaS catalog, normalized schemas, virtual webhooks, real-time data without polling infrastructure). Arcade.dev is better when your hardest problem is per-user OAuth correctness, deployment flexibility, or open-core foundations (OAuth 2.1 Protected Resource architecture, VPC/air-gapped deployment, MIT-licensed framework). Production teams sometimes use both — Arcade for productivity workflows where per-user OAuth dominates, Unified for B2B SaaS data integrations where normalization matters.

How many integrations does each platform support?

Unified MCP supports 440+ integrations across 27 categories with 22,566 callable tools combining normalized objects (across 2,100+ standardized data models) and passthrough access. Arcade.dev publishes "100+ services / hundreds of pre-built tools" but does not publish a versioned integration or tool registry. The numbers reflect different product philosophies — Unified prioritizes published coverage breadth; Arcade prioritizes curated tool quality over enumeration.

Can I self-host either MCP server?

Arcade supports both hosted (Arcade Cloud / Arcade Deploy) and self-host options, including VPC, on-prem, and air-gapped deployments. Unified MCP is hosted-only; customers do not deploy or operate MCP infrastructure, though customer-managed secrets storage (AWS Secrets Manager, Google Cloud Secret Manager, Azure Key Vault, HashiCorp Vault) is supported.

Does either store customer data?

Unified MCP is stateless by default — no customer records are stored at rest; only connection metadata and tokens are retained. Optional hide_sensitive filtering can remove PII fields from results before they return to LLMs. Arcade.dev's public materials emphasize that the platform manages tokens and secrets rather than production data, with encrypted credential storage and audit trails. Specific log retention periods and request/response payload storage policies are not detailed in Arcade's public documentation.

Is either platform open source?

Arcade.dev is open-core: the MCP server framework and SDKs (arcade-mcp, arcade-py) are MIT-licensed on GitHub. The hosted runtime, gateway, and management plane are proprietary SaaS. Unified MCP is closed source, with auto-generated SDKs across 7 languages (TypeScript, Python, PHP, Java, Go, C#, Ruby).

What compliance certifications does each have?

Arcade.dev holds SOC 2 Type II (achieved August 2025) and aligns with GDPR, with VPC and air-gapped deployment options for regulated industries. Unified MCP holds SOC 2 Type II and aligns with HIPAA, GDPR, CCPA, and PIPEDA, with multi-region endpoints (US/EU/AU) for data residency. Different strengths for different procurement requirements.

What's the pricing difference?

Arcade.dev offers a free tier and $25/mo Growth plan with usage-based billing (executions from $0.01). Unified MCP offers a 30-day trial and $750/mo entry plan with API-call-volume pricing and unlimited connections on every plan. Arcade is more accessible for early-stage experimentation; Unified's pricing model favors B2B SaaS at customer scale where connection counts matter.

Final thoughts

Unified MCP and Arcade.dev are both credible 2026 MCP vendors, but they're solving different problems. Unified is the right choice for teams building B2B SaaS products that need broad integration coverage with consistent data models — particularly for CRM, HR, ATS, accounting, and ticketing workflows where normalization across many vendors meaningfully reduces engineering load. Arcade.dev is the right choice for teams building production agents that prioritize OAuth correctness, deployment flexibility (VPC, on-prem, air-gapped), and open-core foundations — particularly in regulated industries or productivity-heavy workflows where per-user delegated access dominates.

For teams whose hardest problem is "lots of vendor integrations with consistent data models, no MCP infrastructure to operate," Unified is usually the answer. For teams whose hardest problem is "secure multi-user authorization with deployment control," Arcade is usually the answer. Many real products need both at once — in which case using both is a reasonable architectural choice rather than a forced trade-off.

Unified.to provides a hosted MCP server with 22,566 callable tools across 440+ integrations in 27 categories, with 2,100+ normalized data objects and full passthrough access to integration APIs.

👉 Read the Unified MCP documentation

👉 Start a 30-day trial

👉 Book a demo