Pipes compared to Nango, Composio, Arcade, Paragon, and Merge

Nobody sets out to buy an integration platform. What happens is that a customer asks for Slack, then Jira, then Google Drive, and somebody on the team works out what that costs. Merge, which sells one of the products in this comparison, publishes a widely repeated estimate: roughly 150 senior engineering hours to build a production integration and 300 hours a year to keep it alive, plus a comparable load on customer success at about 150 support tickets a year. Add the two and you land near $48,000 in year one for a single integration. Those are vendor assumptions rather than survey data, and about a third of the dollar figure is support rather than engineering, so treat it as an order of magnitude and not a quote. The order of magnitude is enough. Then you go looking for someone to sell you the way out.

The six products here all answer that request, and they aren't the same product. They sit at different layers of the same stack, which is why feature-by-feature grids between them tend to mislead. Below is the grid, built from what each vendor's own public pages said the week this was written, plus the part a grid can't say: which one you should actually pick, and when it shouldn't be us.

Three layers, and one vendor in two of them

Pipes is a credential layer. Your user authorizes a provider through an embeddable widget, the refresh token stays with WorkOS, and your backend asks for a valid token when it needs one. Pipes owns expiry, refresh, and concurrency.

  
import { WorkOS } from '@workos-inc/node';

const workos = new WorkOS(process.env.WORKOS_API_KEY);

const { accessToken, error } = await workos.pipes.getAccessToken({
  provider: 'slack',
  userId,
});

// error is 'needs_reauthorization' or 'not_installed'
if (!accessToken) return promptReconnect(error);

// accessToken.accessToken is the provider token; use it with Slack's SDK
const slack = new WebClient(accessToken.accessToken);
  

Nango and Paragon are integration runtimes. Auth is table stakes, and the product is the code, sync, and event machinery on top. Nango's own framing covers four jobs: MCP and tools for agents, webhooks and triggers, auth and credentials, and syncs and ingestion. Paragon ships three named products: Managed Sync, ActionKit, and Workflows.

Composio and Arcade are agent tool runtimes. Composio sells just-in-time tool calls, delegated auth, sandboxed environments, and parallel execution across 1,000+ integrations. Arcade calls itself the MCP runtime for production AI agents, sitting between your agents and every system they need to reach.

Merge is both. It used to be the Unified API company; the homepage now reads "Connective infrastructure for production AI." Merge Unified is an integration runtime alongside Nango and Paragon. Merge Agent Handler is an agent tool runtime alongside Composio and Arcade. They are separate products with separate pricing pages, and a third, Merge Gateway, is an LLM router that sits outside this comparison entirely. Any Merge evaluation written from 2024 knowledge will be wrong.

‍

The catalog numbers are in different units

Pipes lists 300+ providers. Nango lists 900+ APIs and 6,000+ reusable templates against them. Composio lists 1,000+ integrations. Paragon's ActionKit lists 1000+ integration actions across roughly 59 of its 121 connectors. Arcade publishes 8,000+ tools across 44 integrations and expects you to extend that with its open-source framework in Python or JavaScript.

Watch that last pair. Arcade's 8,000 is a count of tools and Composio's 1,000 is a count of services, so reading them side by side inverts the real comparison. Normalized to the same unit, it's 44 against 1,000+.

Merge makes the problem visible inside a single vendor. Its integrations page says "240+ integrations," its AI page says "220+ connectors," its Agent Handler page says "thousands of pre-built tools," and its docs enumerate 294 Agent Handler connectors, of which 178 are Merge-built and 116 are third-party MCP servers it imports. Four numbers, four denominators, one company.

Only one of these answers the question you actually have, which is whether the specific API your enterprise customer needs is supported this quarter. Nango publishes a turnaround commitment for that case: new API support in 30 days on Free, 14 on Starter, 7 on Growth, and 2 on Enterprise. Pipes takes a different route to the long tail. Any custom app connects the same way through OAuth or an API key, which works fine for one bespoke internal API and is no substitute for a vendor-maintained connector.

What Pipes does not do

Pipes vends credentials, relays calls, exposes an MCP interface, refreshes tokens, and revokes in one call. It has no managed data sync and no normalized data models.

If your requirement is a fresh, permission-aware copy of a customer's CRM or document store, that gap is the whole decision, and there are three real answers. Paragon's Managed Sync runs at frequencies down to every minute and pairs with a Permissions API for enforcing access control in RAG. Merge Unified normalizes across providers into a Common Model, so BambooHR, Workday, and ADP return the same shape, and syncs ACLs for file storage and ticketing so a retrieval pipeline can filter to what the asking user may see. Nango's syncs come with storage billed per stored record, which tells you plainly that holding the data is part of the deal.

Two boundaries worth knowing before you buy on the permissions pitch: Paragon's Permissions API reaches file storage only today, and Merge's ACL sync covers file storage and ticketing. Neither one covers CRM records.

Merge's normalization has a commercial edge to it as well. Remote Data, which returns the raw provider payload alongside the normalized object, and Authenticated Passthrough, which proxies an arbitrary call to the provider, are both Professional and Enterprise only. On the free and Launch tiers you get the Common Model and nothing else. That's a genuinely different posture from Nango or Pipes, where raw provider access is the baseline rather than a tier.

Pipes also has no workflow builder. Paragon's Workflows lets teams write integration logic in TypeScript or a low-code editor, trigger it from their app or third-party webhooks, and promote through development, staging, and production environments with GitHub sync. Composio's answer to multi-step work is a remote ephemeral sandbox where tools run as code and large responses land on a filesystem the agent can browse. Pipes hands you a token and gets out of the way. That's the design, and it's the wrong design for a team that wanted an iPaaS.

The agent story turns on where the token lives

Every product here has an MCP story now, and two of them ship it as something you host yourself. Pipes publishes a reference MCP server as a deployable template. Paragon's ActionKit exposes actions over an API and a self-hosted open-source MCP server with agent-optimized schemas. Nango lists MCP and tools for agents as one of its four core use cases. Arcade is built as an MCP runtime and is framework agnostic across LangChain, LlamaIndex, Mastra, CrewAI, Pydantic, Google ADK, and OpenAI Agents. Merge ships two: a thin open-source MCP server over the Unified API, single account per process, and Agent Handler, which is the real multi-tenant product.

Two things separate them once an agent is actually running unattended.

The first is whether the grant survives the session. Pipes stores a user's authorization as a connected account, a durable object that outlives any login, with a state of connected or needs_reauthorization. A credential pull is one authenticated POST carrying your API key and a user ID, with no session token anywhere in the request. That's what makes a 6am scheduled job possible without a browser in the loop.

The second is whether your process ever holds the token. Pipes relay calls the provider on your behalf and streams the response back, so the provider credential never enters your environment:

  
const res = await fetch('https://api.workos.com/relay', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.WORKOS_API_KEY}`,
    'Content-Type': 'application/json',
    'X-Relay-URL': 'https://slack.com/api/chat.postMessage',
    'X-Relay-User': userId,
    // Only when the connection is organization-scoped. Sending it otherwise is a 402.
    ...(organizationId ? { 'X-Relay-Organization': organizationId } : {}),
  },
  body: JSON.stringify({ channel, text }),
});
  

Relay's constraints are real. It's in early access and enabled per environment by contacting WorkOS support; bodies forward byte-for-byte up to 5 MB with a 30 second upstream timeout, X-Relay-URL must be HTTPS, and redirects come back to you instead of being followed. Those two limits are the ones to check against your workload before you route anything bulky through it. A user who never connected, whose grant was revoked, or whose organization scope doesn't match produces a 402 with code relay_authorization_required rather than a generic auth failure.

Merge takes the mirror-image position. It holds the provider credentials and hands you an account token; Agent Handler stores the credential against a registered user and attaches it transparently on every call. There's a proxy, on paid tiers, but no documented way to get the underlying provider token back at all.

Where Arcade and Merge go further than us is policy. Arcade supports pre- and post-tool-call hooks so teams can enforce custom rules without forking the runtime, and its team authored the URL Elicitation proposal that Anthropic accepted into the MCP specification in November 2025. Merge's Agent Handler scans every tool call for PII, PHI, payment data, and custom patterns before it leaves, with allow, redact, or block configurable per tool pack. Pipes leaves that enforcement to your code, and it leaves the audit trail to your code too: Audit Log events for credential pulls are ones you emit yourself. That buys you the exact actor and target shape you want, at the cost of writing it.

Deployment is where the shortlist gets cut

Pipes runs on WorkOS. Credentials are user-scoped and stored in Vault, encrypted at rest with AES-256, PKCE is the default flow, and the SOC 2, HIPAA, and GDPR posture is inherited from the platform. There is no self-hosted Pipes.

If your security review requires the credential store inside your own perimeter, the other five have an answer and we don't. Nango publishes a free self-hosted edition anyone can run with docker-compose, covering auth and proxy, with functions, webhooks, MCP, and RBAC reserved for Enterprise and Cloud; it's source-available under the Elastic License 2.0, with 11.6k GitHub stars. Arcade deploys to your VPC, on-prem, or fully air-gapped. Paragon offers self-host and forward-deploy on Enterprise, including a managed on-premise option in your own cloud account. Composio lists bring-your-own-cloud plus a KMS proxy on Enterprise, so it never sees your tokens in plaintext. Merge offers US, EU, and APAC residency, with single-tenant and self-hosted as purchasable Enterprise line items and on-prem for Agent Handler, though nobody at Merge advertises air-gapped.

Two operational details about Pipes belong in the evaluation. WorkOS-managed shared credentials are for sandbox environments only, so production means registering your own OAuth app per provider. And deleting a connected account removes the stored access and refresh tokens and returns a 204, but does not revoke access on the provider's side. That caveat belongs in your incident runbook, whichever vendor you pick.

Pricing, in the units each vendor actually bills

The meters differ more than the prices do.

Nango bills per connection, where a connection is one authorized user account: Free includes 10, Starter 20, Growth 100, on plans that start at $0, from $50/mo, and from $500/mo. Starter and Growth then bill $1 per additional connection; Free is a hard cap. Usage meters stack on top: $0.0001 per proxy request, $0.0001 per function run, $0.0000002 per millisecond of function compute, and $0.0001 per stored record above the included tier.

Composio bills the tool call. Free is hard-capped at 100K tool calls, 50K triggers, and unlimited connections with no credit card; Pro is $29/mo with monthly usage credit, then $0.0003 per tool call and $0.003 per trigger event. Connected accounts on your own OAuth app are free, and premium third-party tools pass through at cost plus a 5% platform fee. The current rate card applies to signups from August 15, 2026, with existing customers otherwise grandfathered through December 31, 2026, though premium tool calls start billing for everyone on September 1, 2026.

Arcade bills two meters: 2,000 auth events and 2,000 tool calls a month on the $0 plan, then a $25/mo platform fee on the Team plan with auth events at $0.10 and tool calls at $0.01 each.

Paragon bills on Connected Users, meaning tenants rather than individual end users. It publishes two tiers, Pro and Enterprise, and no prices.

Merge bills two meters on two products. Unified is per production Linked Account: three free, then $650/month for up to ten, then $65 each, with API calls and records unmetered, which is a real difference from the usage-metered vendors here. Agent Handler is credit-based per tool call, free to 2,000 credits a month and $1,000/month for 25,000 on Pro, though the credits-per-call conversion isn't published, so you can't model that line without a call. Professional and Enterprise are quote-only across both.

Pipes is the awkward one. WorkOS publishes real numbers for the rest of the platform, but the pricing estimator has no Pipes line item. Practically, that means the one row you can't fill in on your year-one spend model is ours, and filling it in takes a call. Budget your evaluation timeline for that.

When to choose them, and when to choose us

Choose Nango if you want integrations as code with a self-hosting escape hatch you can run for free, an inspectable runtime, the long tail of APIs with a contractual turnaround on new ones, and per-connection billing you can forecast.

Choose Composio if your workload is high-volume agent tool calls and you'd rather pay per call than per user, especially with a hard-capped free tier for prototyping and sandboxed code execution for multi-step work.

Choose Arcade if MCP governance is the requirement: policy hooks around every tool call, and deployment down to air-gapped. Note that SSO, RBAC, and audit logs are Enterprise-tier rather than included at $25.

Choose Paragon if you're a SaaS company shipping customer-facing integrations and need managed sync, workflows, and per-tenant economics in one platform, with self-host available for the security review.

Choose Merge if the job is reading customer HR, ATS, accounting, ticketing, or file-storage data across many providers and you want one schema instead of N provider shapes, or if you're building enterprise search over customer documents where per-user ACLs decide what retrieval may return. Budget for Professional if you need the raw payload, because both escape hatches from the Common Model are paid-tier.

Choose Pipes if what you're missing is credentials and consent, not a data platform. It fits best when the grant has to outlive the session, because a connected account is a durable object rather than a login artifact; when you want the provider token out of your runtime entirely; when a Vault-backed store and one-call revocation matter more than a connector catalog; and when you're already on WorkOS and would rather not add another vendor to the security review, since it's the same API key, dashboard, and compliance posture as SSO, Directory Sync, Audit Logs, and AuthKit.

Catalog size makes for an easy pitch slide. What decides this is which layer of the stack you're missing, and who's holding your users' refresh tokens while your agent runs at 3am.