Unified APIs: Usage-Based vs Per-Connection Pricing for Integrations

Per-connection pricing multiplies with every customer and every integration each one connects, while usage-based pricing tracks API calls, so the gap widens as you add customers: at list prices as of October 2026, 1,000 customers on one integration each cost $65,000 a month at Merge's Launch rate and $1,000 on Unified.to at an assumed 1,000 API calls per customer (our calculation). For B2B SaaS teams choosing a unified API, per-connection pricing suits a few customers who read heavily, and usage-based pricing suits many customers with several integrations each and AI workloads whose activity varies.

What pricing models do unified API vendors use?

Unified API vendors use six pricing models: per-connection, usage-based, per-consumer, per-integration, a flat plan fee plus contract-priced accounts, and hybrid pricing with no public rates. Each ties cost to a different variable, and Nango sits between per-connection and usage-based.

1. Per-connection (linked account)

You pay for every customer-to-integration connection.

Cost formula: customers × integrations per customer × price per connection

If one customer connects two systems, that's two billable units. If 100 customers each connect two integrations, that's 200 billable connections.

Pricing model used by Merge.dev and Finch.

2. Usage-based (API calls or tool calls)

You pay for activity, not connections.

Cost formula: total successful API calls (plus any overages)

Whether a customer connects one integration or five doesn't matter. Cost is driven by actual data activity through the platform.

Pricing model used by Unified.to, which meters API calls, and Composio, which meters agent tool calls. As of 12 October 2026, Composio's Pro plan is $29 a month including $29 of usage credit, with 100,000 tool calls a month free and $0.0003 per tool call after that (for sign-ups since 15 August 2026). Instant Tools (formerly Premium Tools) add the provider's charge, passed through at 0% markup, on top of the regular tool-call charge. Composio costs less per call; Unified.to's price covers one unified model per category, so the same request works across the integrations in that category, where each Composio tool returns provider-native data in its own provider-specific schema.

Nango sits between models 1 and 2: as of 8 October 2026 it charges $0.29 per connection a month plus compute hours and data transfer, and no longer meters requests.

3. Per-consumer (end customer)

You pay for each customer using integrations, regardless of how many they connect.

Cost formula: active customers with at least one integration

One customer connecting five systems still counts as one billable unit.

Pricing model used by Apideck and Paragon (including ActionKit).

4. Per-integration (connector)

You pay for the integrations you offer, not who uses them or how heavily.

Cost formula: number of connectors enabled

Whether 10 customers or 10,000 customers use an integration, the cost remains the same.

Pricing model used by Truto, except its Google connectors, which bill $10 per connection a month (as of 8 October 2026).

5. Mixed flat-tier + per-account at scale

A published monthly plan fee plus connected accounts priced by contract, with feature gates (sync frequency, log retention) that lift on higher plans.

Pricing model used by Knit's Unified API, as of 8 October 2026: Start Up at $499 a month (24-hour sync, 3-day logs, 100,000 API calls a month under fair use), Scale Up and Enterprise by quote, and connected accounts priced by contract on every plan. Launchpad (free) and Individual ($29 a month) are plans for Knit's separate MCP Servers product.

6. Hybrid + opaque

Platform fee + per-account or per-customer charges, with no public pricing grid. Pricing requires sales engagement.

Pricing model used by Kombo (annual platform fee + variable per-connected-customer fee), Codat (annual platform fee + a fee per active company per month, set in an order form; a free account capped at 50 companies, with no page saying whether new sign-ups are open; as of 8 October 2026), Rutter (per 'billable connection', one-year initial term, no published rates; as of 8 October 2026) and Tray.io (Pro, Team and Enterprise plans, all sales-driven; as of 8 October 2026).

Which vendors use which pricing model?

• Note on Finch: Finch publishes one price, Starter at $65 per connection per month, read-only, up to 15 connections and 24 providers; Pro and Premier are quote-only (as of 8 October 2026).

This classification matters because each model creates a different cost curve as your product scales, and a different stress point where the math stops working.

What does each model cost at 100, 1,000 and 10,000 customers?

Per-connection pricing costs the most at scale: at 1,000 customers on one integration each, Merge's Launch list price is $65,000 a month, against $1,000 on Unified.to at 1,000 API calls per customer and about $833 on Truto while you enable 10 connectors or fewer (our calculation). The table uses monthly list prices as of 8 October 2026 (Unified.to as of 12 October; yearly billing is 17% off every Unified.to plan), one integration per customer and an assumed 1,000 API calls per customer a month; it's our calculation, and your own call volume and integration count set the real figures.

• Merge offers volume discounts and prices Professional and Enterprise by contract. At 100 or more customers, Launch becomes the cheaper option only once each connection averages more than 130,000 calls a month, the volume at which Scale is the cheapest Unified.to plan (our calculation). Above that volume, the higher figure pays for reads that reach the source at request time, where Launch reads from Merge's copy refreshed on a daily sync, and for webhooks from the source and Passthrough, which Merge starts at Professional. At two integrations per customer, every Merge figure doubles.
• Nango's Pay-as-you-go plan has a $50 monthly minimum, returned as credits. Compute hours ($0.72) and data transfer ($0.50 per GB) depend on how your syncs run, so they aren't modelled. Nango's connection fees sit below every Unified.to figure in the table; Unified.to's price adds events that carry the changed records on supported integrations, where Nango's sync webhooks carry counts of added, updated and deleted records, and a maintained unified model in each category, where Nango has you define the models in code.
• Truto's floor holds while you enable 10 connectors or fewer; each one beyond that adds from $999 a year on Expansion, and Google connectors bill $10 per connection a month. Truto's figure is above Grow's $750 at 100 customers and lower from 1,000 customers (our calculation); Unified.to's covers every integration on every plan, where Truto's Expansion plan covers Standard connectors only, and change events as often as every minute on supported integrations, where Truto's sync jobs have a five-minute minimum.
• Knit's Start Up plan includes 100,000 API calls a month under fair use and a 24-hour sync, and excludes "enterprise apps like Salesforce, Workday, etc."; 1,000 customers at 1,000 calls each is past that allowance. Against Start Up's lower fee, Grow adds change events as often as every minute on supported integrations, where Start Up syncs every 24 hours, and enterprise apps such as Workday, which Start Up excludes.
• Finch's Starter plan is read-only and covers up to 15 connections at $65 each, for employers under 500 employees.
• Composio meters agent tool calls rather than customers, so it isn't in the table.

At 10 customers, most models fit an entry tier: Merge Launch is $650, Apideck Launch covers 25 consumers in one category at $599, Nango's free plan covers 10 connections, and Unified.to Grow is $750 with a 30-day free trial. Merge, Apideck and Nango start lower than Grow. What the difference buys on Unified.to: every category on Grow, where Apideck Launch covers one; webhooks from the source and Passthrough, which Merge starts at Professional; and events that carry the changed records, where Nango's sync webhooks carry counts.

Which pricing model is most predictable at scale?

Per-integration and per-consumer pricing are the easiest to budget, because the bill follows a count you already know: connectors enabled, or customers using integrations. Usage-based pricing is predictable once you know your call volume; on Unified.to, overage is a fixed rate per 1,000 calls rather than a jump to the next plan, and checks that find no new data aren't billed. Per-connection pricing is predictable per unit but multiplies with every integration each customer adds.

What happens to cost when customers connect more integrations?

Adding integrations per customer multiplies cost only on per-connection pricing: going from 2 to 5 integrations per customer raises a per-connection bill about 2.5×, while usage-based, per-consumer and per-integration bills stay flat unless activity, customer count or enabled connectors also rise.

If you expand from 2 integrations to 5 integrations per customer:

• Per-connection: increase ~2.5× instantly
• Usage-based: unchanged unless activity also increases
• Per-consumer: unchanged
• Per-integration: unchanged until you enable connectors beyond the plan minimum (10 on Truto's Expansion), then rises per connector
• Mixed tiers + per-account: depends on tier; per-account portion scales with new connections
• Per-connection plus usage (Nango): connection meter rises ~2.5×; compute and transfer depend on sync volume

This creates a constraint: teams on per-connection pricing often cap the integrations they offer to control cost.

What does each pricing model trade off?

Each pricing model trades simplicity against how cost grows: per-connection is easy to model but compounds with integrations, usage-based tracks activity and rewards batching and webhooks, per-consumer tracks customer count, and per-integration stays flat but limits catalogue breadth.

Per-connection: predictable per-unit, but compounds aggressively

• Easy to model
• Costs increase with customer success
• Penalizes multi-integration usage

This is where the "growth tax" argument comes from. The more your customers adopt integrations, the more your costs multiply.

Usage-based: flexible, requires architectural discipline

• Cost tied to actual activity
• Scales well across customer base sizes (cost flat if activity flat)
• Requires thoughtful API usage (batching, webhooks, caching, and Database Sync for analytics workloads on Grow, Pro and Scale, for objects with native or virtual webhooks)

The trade-off: heavy polling, redundant API calls, or uncached high-frequency reads will drive cost. That discipline is standard production practice: batched reads, webhook subscriptions where supported, and offloading high-volume reads to your own infrastructure via Database Sync (Grow, Pro and Scale, for objects with native or virtual webhooks) keep usage aligned with product value. Composio's tool-call metering adds one more variable: Instant Tools carry the provider's charge on top of the regular call charge, so cost moves with the mix of tools an agent calls.

Competitor framing of usage-based pricing often invokes a "bill shock" narrative: pagination forces 1,000 calls per customer per sync; webhook events drain quotas; retries burn credits in a black box. Check the math: 1,000 paginated API calls at Unified.to's published Grow overage rate of $1.00 per 1,000 calls (as of 12 October 2026) equals $1, not a catastrophic outcome. Unified.to also publishes what is and isn't billable (see "Which hidden costs should you check?").

Per-consumer: smoother scaling, still customer-tied

• Eliminates per-integration penalties
• Predictable monthly costs
• Still increases directly with customer count

Costs don't multiply with integrations, but they still rise as you acquire customers.

Per-integration: fully flat per-connector, but bounded by catalogue

• Fully predictable
• Decoupled from usage and customer count
• Pay for each connector enabled, whether or not it's heavily used

The trade-off: this model is great if you enable a small number of connectors and serve many customers across them, though Truto's 10-connector minimum means even 2 or 3 connectors bill about $9,990 a year. It becomes expensive when you need broad category coverage: 50 enabled connectors × $999/year = $49,950/year baseline at the Expansion starting price before any customer uses them. Compare to Unified.to's Grow tier at $750+/month ($9,000 over a year at the monthly rate, $7,500 billed yearly) for access to all 1867 integrations across 37 categories.

Mixed tiers + per-account: flat at low volume, account-tied at scale

• A published entry-plan fee, with connected accounts priced by contract on every plan
• Lower tiers often include feature gates (sync frequency caps, log retention limits)
• Higher tiers are quote-only

Knit is the clearest example: Start Up is published at $499 a month, connected accounts are priced by contract on every plan, and Scale Up and Enterprise are quote-only (as of 8 October 2026). The 24-hour sync frequency gate on Start Up ($499/month) is a real production constraint for AI workloads.

How does the pricing model change what you build?

Pricing changes product decisions: per-connection pricing pushes teams to limit integrations per customer, usage-based pricing pushes them to batch reads and use webhooks, and per-integration pricing pushes them to cap the connector catalogue.

How many integrations you offer

• Per-connection → limit integrations per customer
• Usage-based → expand freely
• Per-consumer → bundle aggressively
• Per-integration → cap connector count
• Mixed tiers + per-account → manage tier transition carefully

How frequently you sync data

• Usage-based → batch reads, use webhooks, offload analytics
• Per-connection → less pressure on call volume, more pressure on connection count
• Mixed tiers + per-account → mind the sync frequency gates at lower tiers

This directly affects how current your data is, and your UX.

What becomes possible with AI workflows

AI-driven products often query multiple systems per action, trigger many small API calls, and operate dynamically across integrations. Per-connection pricing doesn't map cleanly to this pattern. Usage-based models align more naturally with variable workloads, provided the platform offers structural answers to the bursty workload concern (Database Sync on Grow, Pro and Scale for objects with native or virtual webhooks, batched reads, webhook-driven updates).

Which hidden costs should you check?

Beyond the headline rate, check these ten costs before you sign:

• Pass-through tool charges: Composio's Instant Tools (formerly Premium Tools) add the provider's charge, at 0% markup, to the regular $0.0003 per tool call (as of 12 October 2026). Cost modelling needs to separate Instant Tools from standard calls.
• Sync frequency gates: Knit's Start Up tier ($499/month) locks sync to 24-hour intervals. Faster, down to a 5-minute minimum, requires Scale Up (contact-only pricing).
• Platform fees plus per-account: Codat and Kombo blend annual platform fees with per-company or per-customer rates (Codat counts a company as active if it synced that month); Rutter bills per 'billable connection' on a one-year term and publishes no platform fee. Total cost requires sales engagement; no public dollar grid.
• Linked-account tiers: Merge's Launch plan is free for the first 3 production linked accounts, $650/month for up to 10, and $65 per account beyond 10. Up to 11 accounts, Launch costs less than Grow, but it leaves webhooks from the source, Remote Data (original provider fields) and Passthrough to the contract-priced Professional plan; Unified.to includes raw fields, Passthrough and native webhooks on Grow.
• Three meters: since 2 September 2026 Nango charges per connection ($0.29/month), per compute hour ($0.72) and per GB of data transfer ($0.50). Every sync run is billed compute, even one that finds no changes.
• What counts as a "consumer": Apideck's "Consumer" means an active customer using integrations. A customer not using integrations isn't billed. Verify the definition matches how you'd count your own.
• Bundled tools: Paragon's ActionKit is included in all Paragon tiers; pricing is on connected users/customers at the platform level, not on tools enabled.
• Webhook billing structure: Some vendors charge for every webhook event. Verify what's billable. Unified.to's rules for native and virtual webhooks are under "Change-driven webhooks" below.
• Retry handling: Ask whether retries on an upstream 429 are billed. Unified.to passes the integration's 429 back to you with its status and message, so your client sets the backoff and each retry it sends is a new call; on webhooks, retriable read errors and failed deliveries aren't billed.
• Annual commits with uplift clauses: Per-consumer and enterprise tiers often include annual minimums with year-over-year uplifts. Confirm before signing.

How does Unified.to's usage-based pricing work?

Unified.to charges for API calls on every standard plan, with unlimited customer connections and a fixed overage rate per 1,000 calls (as of 12 October 2026):

• Grow ($750+/month): 750,000 API calls, then $1.00 per 1,000. All 37 categories. Unlimited customer connections. 30-day free trial.
• Pro ($1,500+/month): 2 million API calls, then $0.75 per 1,000. Adds SAML SSO and credential storage in your own secrets manager (11 supported, including AWS Secrets Manager, Azure Key Vault, Google Cloud Secret Manager and HashiCorp Vault). 30-day free trial.
• Scale ($3,000+/month): 6 million API calls, then $0.50 per 1,000. SAML SSO and secrets-manager storage as on Pro, plus HIPAA BAAs and 365-day log retention.
• Enterprise (custom): Priced by usage or by connection; single tenant, private cloud, dedicated cloud or on-prem deployment.
• Yearly billing: 17% off every plan (Grow $7,500+ a year).

Cost scales with API activity, not customer count or integration depth. Adding integrations to existing customers doesn't multiply cost. Customer growth that doesn't drive API activity doesn't compound infrastructure spend.

Structural answers to the usage-based predictability concern

The architectural-discipline trade-off is real for usage-based pricing. Two structural choices keep activity proportional to product value:

Database Sync (Grow, Pro and Scale, for objects with native or virtual webhooks). Stream normalized records to your own Postgres, MongoDB, MySQL, MSSQL, MariaDB, Supabase or Snowflake database. Use API calls for live agent access; use Database Sync for analytics workloads, RAG pipelines, and high-volume cached reads. Customer business data lives in your infrastructure, not Unified.to's, and repeat reads run against your own database. Each page Database Sync sends is billed as one API call.

Change-driven webhooks. Successful API calls are billable, and on webhooks each page successfully delivered is one call. Checks that find nothing, failed deliveries and retriable read errors aren't billed, and subscriptions are unlimited, so a webhook-driven architecture pays for changes, not for watching.

How does pricing affect lock-in and switching costs?

Switching costs come from architecture and contracts more than list price: where customer data is stored, who holds the OAuth credentials, how much code depends on the vendor's SDK and schema, and how long the contract runs.

Key factors:

• Data storage vs pass-through. Sync-and-store platforms hold customer data; migration requires rebuilding pipelines and re-syncing.
• OAuth and credential ownership. Reconnecting every customer can take weeks. Some vendors offer credential export (Unified.to does); some don't. Only tokens issued to your own OAuth app keep refreshing after you leave; plan to re-authorize customers by default.
• SDK and schema dependency. Switching providers means rewriting integration logic.
• Contracts. Annual commitments and uplift clauses increase exit cost.

Pass-through architectures such as Unified.to avoid storing customer business data at rest, which reduces some of this friction. Sync-and-store models (Merge, Codat) create deeper dependency by maintaining canonical copies of customer data in vendor infrastructure.

Which vendors publish their prices?

As of October 2026, eight of the vendors covered here publish at least one price, and five require a sales conversation.

Some providers publish full pricing pages with specific rates: Unified.to, Merge.dev (Launch tier specifics; Professional and Enterprise contract-based, plus a Professional bundle on AWS Marketplace), Apideck (full tier table from $599 to $4,250 a month; Enterprise contact-only; as of 8 October 2026), Truto (from $999/connector/year on Expansion and $1,999 on Enterprise, both sold through sales), Nango (Free and Pay-as-you-go with per-meter rates published), Composio (Hobby free, Pro $29 a month, Enterprise custom, with published usage rates), Knit (Start Up at $499 a month for its Unified API, with connected accounts by contract; MCP Servers plans from free; Scale Up and Enterprise by quote), Finch (Starter at $65 per connection per month, read-only, up to 15; Pro and Premier by quote).

Some require sales conversations for any pricing visibility: Codat, Rutter, Tray.io, Kombo, Paragon.

For buyers, transparency affects evaluation speed and predictability. Sales-driven pricing isn't inherently bad, but it requires more time and creates information asymmetry between vendors and buyers.

How should you evaluate unified API pricing?

Evaluate unified API pricing by modelling your own customers, integrations and call volume against each vendor's published rates:

1. Audit your active connected accounts. Calculate average integrations per customer × projected customer count at 12 and 24 months. That's your linked-account exposure if you go per-connection.
2. Estimate your monthly API call volume. Count resources synced × average record count per customer × pagination depth × sync frequency. Include webhooks and verify what's billable.
3. Calculate total cost at each milestone using every vendor's published pricing. If a vendor doesn't publish pricing, that's a data point.
4. Ask about customization costs. Can you handle custom fields on a self-serve plan, or do you need a Professional/Enterprise upgrade?
5. Check what counts as a billable unit. Webhook deliveries? Provider errors? Internal retries? Sync attempts that find no new data?
6. Verify retry behaviour on upstream 429s. Are provider rate limits absorbed into a single logical call, or does each retry become a billable event?
7. Verify whether the vendor offers a structural escape hatch for high-volume reads (database sync, cached reads, etc.), and whether it's tier-gated.

Which pricing model should you choose?

Choose per-integration pricing for a small, fixed catalogue, per-connection pricing for a few customers who read heavily, and usage-based pricing when you serve many customers across several integrations each or run AI workloads whose activity varies. The first two cost less in those cases; usage-based pricing on Unified.to pays for change events as often as every minute on supported integrations, where Truto's sync jobs have a five-minute minimum, and for reads that reach the source rather than the copy Merge refreshes daily on Launch. On Unified.to, usage-based pricing starts at Grow: $750 a month for 750,000 API calls, with unlimited customer connections and a 30-day free trial (as of 12 October 2026). For the vendors that price by usage, see which unified API solutions have a usage-based pricing model; for a head-to-head on per-connection pricing, see Merge vs. Unified.to.

→ Start your 30-day free trial

→ Book a demo

Written by Mallory Greene.

About the author: Mallory Greene is Head of Marketing at Unified.to_. She writes about integration infrastructure, unified APIs, and MCP for technical teams. Based in Toronto._