Merge.dev — now marketed simply as Merge — is a unified API platform that lets B2B SaaS products connect to 250+ third-party tools through a single endpoint. Its catalog covers HRIS, ATS, CRM, accounting, ticketing, file storage, and knowledge base categories. In 2025 Merge added a second product, Merge Agent Handler, which gives AI agents secure access to these same tools so they can read data and take actions across your customers' SaaS stacks. This guide covers how Merge's pricing model works, what each plan actually includes, and how it compares to alternatives including Knit.
The most important thing to understand about Merge pricing before anything else: Merge charges per linked account, where one linked account equals one customer's connection to one integration. A customer using your product with Salesforce and Workday connected counts as two linked accounts. At 10 customers, that's manageable. At 100 customers using two integrations each, you're looking at $13,000 per month on the self-serve Launch plan. This guide shows you exactly where the costs go and when it makes sense to look at alternatives.
The short version: Merge bills a flat $65/month per linked account above its 10-account base. That cost climbs in a straight line as you add customers — $1,950/month at 30 accounts, $3,250+/month at 50. Knit's account-based pricing scales on a declining curve instead, and adds a zero-storage architecture and dedicated support earlier in the plan ladder.
How Merge.dev Pricing Works
Merge.dev Pricing Plans
| Plan | Price | Linked Accounts Included | Support | Key Features |
|---|---|---|---|---|
| Launch (self-serve) | First 3 linked accounts free, then $650/month | Up to 10 production linked accounts; $65/month per additional account | Core unified API access, basic sync, standard integrations | |
| Professional (contract) | Custom — typically $30,000–$55,000/year platform fee plus ~$65/connected account | Negotiated | Email + chat | Custom fields, field-level scopes, custom sync frequencies, sandboxes, go-live support |
| Enterprise (contract) | Custom — Vendr transaction data shows $100,000–$250,000+ annually depending on scope | Negotiated with volume discounts | Email + chat, dedicated account manager, shared Slack channel (first 90 days), support SLA | Security audits, SSO, audit trails, unlimited sandboxes, white-glove support |
Billing note: Merge's Launch plan is free for your first 3 production linked accounts. Once you scale beyond 3 (up to 10 total), the $650/month base plan applies, with $65/month for each additional linked account beyond 10. Merge charges based on the net-average daily count of active linked accounts during the prior month, billed on the first of each month. You are not charged for accounts connected and then disconnected within the billing period.
What Merge.dev Actually Costs at Your Customer Count
Merge charges a flat $65 per linked account per month above the 10-account base. Knit's pricing also scales with connected accounts, but on a significantly gentler curve — and Knit additionally offers API calls-based pricing for teams that prefer usage-based billing over account-based tiers. The table below shows the cost difference at comparable account counts:
| Linked Accounts | Merge.dev Launch Cost/Month | Knit Cost/Month | Monthly Saving with Knit |
|---|---|---|---|
| 10 | $650 (base) | $499 (Start Up) | $151 |
| 20 | $650 + (10 × $65) = $1,300 | ~$800 (Start Up) | ~$500 |
| 30 | $650 + (20 × $65) = $1,950 | ~$1,000 (Start Up) | ~$950 |
| 50+ | $650 + (40 × $65) = $3,250+ | Start Up continues to scale by account volume, or Scale Up from $1,500/month if you need custom field mapping, white-labeled auth, or configurable sync | Significant; contact getknit.dev/pricing for an exact quote |
| 100+ | Enterprise contract ($6,500+/month on Launch) | Enterprise — custom | Custom |
Note: Knit's Start Up plan price scales with connected account volume regardless of feature needs. Scale Up is a separate feature upgrade — custom field mapping, white-labeled authentication, configurable sync frequencies, and priority connector requests — that starts at $1,500/month and isn't strictly tied to account count.
Knit's Start Up plan cost decreases on a per-account basis as volume increases — about $50/account at 10 accounts, dropping to roughly $33/account at 30 — while Merge's rate stays fixed at $65/account throughout the self-serve Launch plan. For teams building integrations that will reach 20–50+ connected customers, the savings add up fast. If your needs grow beyond Start Up's scope, Knit's Scale Up plan starts at $1,500/month — still well below Merge's Professional contract pricing. Knit also offers API calls-based pricing as an alternative to account-based tiers for teams with variable usage patterns.
What Is Included in Each Merge.dev Plan
Several features that integration teams often assume are standard require Professional or Enterprise plans on Merge:
| Feature | Launch | Professional | Enterprise |
|---|---|---|---|
| Core unified API access (read) | Yes | Yes | Yes |
| Write / create / update operations | Limited | Yes | Yes |
| Custom fields and field mapping | No | Yes | Yes |
| Field-level scopes (limit data access per customer) | No | Yes | Yes |
| Custom sync frequencies | No | Yes (configurable) | Yes (configurable) |
| Sandbox environments | No | Yes | Unlimited |
| Go-live support / implementation help | No | Yes | Yes |
| SSO / SAML | No | No | Yes |
| Audit trails and logs | No | No | Yes |
| SLA guarantees | No | No | Yes |
| Dedicated account manager | No | No | Yes |
For most production integrations serving enterprise buyers, custom field mapping, configurable sync frequencies, and sandbox environments aren't optional extras — they're table stakes. On Merge, all three sit behind the Professional plan, so teams typically hit this upgrade well before account-based billing becomes the bigger cost factor.
Merge Agent Handler: Merge's AI-Focused Product
In 2025, Merge launched Merge Agent Handler alongside their existing unified API. Where the unified API normalizes data reads and writes across SaaS categories, Agent Handler is designed for AI agent use cases — giving LLMs and AI agents the ability to access tools, read structured data, and take actions across your customers' connected SaaS applications.
Merge now positions itself as "the infrastructure layer for production AI" — a shift from the pure unified API positioning it held until 2024. If you are building AI agents into your product and need those agents to access customer data across multiple SaaS tools, Merge Agent Handler is worth evaluating separately from the standard unified API pricing. Agent Handler pricing is contract-based and not publicly listed.
Knit's Answer: MCP Servers and the AI Integrations Agent
Knit's closest equivalent to Merge Agent Handler is its managed MCP hub: 150+ pre-built MCP servers spanning HRIS, ATS, CRM, accounting, and ticketing, deployed serverlessly so agents get tool access without your team standing up or patching infrastructure. Knit handles authentication (OAuth, SAML, service accounts, token refresh), supports hot-swapping tools at runtime so agents see new capabilities without a restart, and uses semantic tool search to surface only the relevant tools for a given task — which keeps token costs down and improves accuracy. Like the rest of Knit's platform, the MCP servers run on a zero-storage architecture, so agent calls pass through to the source system rather than hitting a cached copy.
Behind the catalog sits Knit's AI Integrations Agent — the technology that reads and interprets a SaaS provider's API documentation, then builds and maintains a tailored connector automatically, including endpoints that fall outside a standard unified schema. This is also what lets Knit extend into the custom, enterprise-specific workflows and orchestrations that off-the-shelf unified models often can't reach: Knit can typically add a missing app to its catalog in about 2 days, versus the 2–6 weeks common for unified API vendors, as long as the provider's API documentation is available.
| Merge Agent Handler | Knit MCP Servers + Integrations Agent | |
|---|---|---|
| What it does | Gives AI agents access to tools, structured data, and actions across connected SaaS apps | 150+ managed MCP servers give agents tool access out of the box; the Integrations Agent builds custom connectors by reading a provider's API docs |
| Data handling | Same caching model as Merge's unified API — data is stored on Merge's servers | Zero-storage — agent calls pass through to the source system in real time |
| Non-standard endpoints / custom workflows | Handled through custom contract work | Integrations Agent can build a tailored connector, typically within ~2 days given API docs |
| Pricing | Contract-based, not publicly listed | MCP servers available via mcphub.getknit.dev; Integrations Agent scoping through the Knit team |
Merge.dev: Where It Excels and Where It Falls Short
Merge.dev strengths
- Broadest integration catalog in the unified API category — 250+ integrations across HRIS, ATS, CRM, accounting, ticketing, file storage, and more
- Normalized data models that abstract away provider-specific quirks — your product code stays stable when Salesforce or Workday changes their API
- Established enterprise track record — used by Drata, Ramp, and AngelList among others; $75M+ in funding and strong G2/Gartner reviews
- Merge Webhooks provide near-real-time sync for providers that support them; other providers use configurable polling intervals
- Strong documentation and developer experience for initial integration
Merge.dev limitations worth knowing
- Cost scales with linked accounts — at 100 customers using 2 integrations each, you're paying $13,000/month on the self-serve plan, and that's before custom fields or configurable sync are even available
- Data storage model: Merge caches a copy of your customers' data on its servers. For customers in regulated industries or with strict data residency requirements, this adds a compliance conversation to every enterprise sales cycle
- Batch sync for providers without webhook support — delta sync frequencies depend on your plan; daily sync is the default on lower tiers
- Write operation coverage is narrower than reads — not all integrations support full CRUD operations via the unified API
- Customer support below Professional tier is email-only — no dedicated account manager until Enterprise
Knit: Where It Has the Edge as an Alternative
Knit strengths
Knit never caches or retains customer data on its servers — data passes through in real time. This removes a recurring item from security reviews and data residency conversations that Merge's data-caching model often raises with enterprise buyers.
Knit handles sync scheduling, retries, and failure recovery centrally across its catalog, so reliability doesn't hinge on whether an individual provider supports webhooks well. On Merge, sync quality varies by provider — webhooks where supported, daily batch polling where they aren't.
On Scale Up and above, Knit lets you set sync frequency per integration to match your actual use case, rather than choosing from a fixed set of preset intervals.
Knit includes dedicated Slack support starting at Scale Up ($1,500/month). On Merge, a shared Slack channel doesn't appear until Enterprise, where annual contracts typically start around $100,000.
Knit's catalog spans HRIS, payroll, ATS, CRM, accounting, ticketing, and e-signature, including Salesforce, Workday, NetSuite, and SAP SuccessFactors. If a connector you need isn't yet supported, Scale Up includes the ability to request new integrations, so catalog gaps can often be addressed without waiting on a public roadmap.
Merge.dev vs. Knit: Full Pricing Comparison
| Merge.dev Launch | Merge.dev Professional | Knit Start Up | Knit Enterprise | |
|---|---|---|---|---|
| Price | First 3 linked accounts free, then $650/month (10 linked accounts) | ~$30–55K/year platform fee + ~$65/connected account | $499/month (10 accounts), scaling to ~$1,000/month at 30 | Custom |
| Free trial | 3 production linked accounts free | N/A | 30-day full-feature trial | N/A |
| Pricing model | Per linked account — scales with customer count | Per connected account + platform fee | Start Up: tiered by connected accounts, from $499/month for 10 (~$800 for 20, ~$1,000 for 30). Scale Up: feature-based upgrade from $1,500/month, independent of account count. API calls-based pricing also available. | Custom |
| Data storage | Merge caches customer data on its servers | Merge caches customer data on its servers | Zero storage — data passes through in real time, nothing retained | Zero storage |
| Sync model | Webhooks where supported; polling otherwise | Webhooks + configurable polling | Fixed 24-hour sync on Start Up; configurable/real-time sync on Scale Up and above | Webhook-first, configurable |
| Write operations | Limited on Launch | Full CRUD on most integrations | Full CRUD on supported integrations | Full CRUD |
| Custom field mapping | No | Yes | No on Start Up — included from Scale Up | Yes |
| Support | Email + chat | Email on Start Up; dedicated Slack support from Scale Up onwards | Dedicated account manager + Slack support | |
| Best for | Small teams evaluating Merge with few customers | Mid-market teams needing full features | Growing SaaS teams starting with core integrations on a budget | Enterprise with compliance requirements |
When Merge.dev is the right choice
- You need broad category coverage from day one — Merge's 250+ integrations means you can ship integrations with any tool your customers use without waiting for a provider to add it
- Your customers are large enterprises with strict compliance and audit requirements — Merge's Enterprise plan includes SSO, audit trails, and security audits that are non-negotiable for some buyers
- You have relatively few high-value customers — at 10–20 linked accounts, Merge's $650/month (after 3 free) is competitive and the feature depth is hard to match
- Your integration roadmap includes file storage or knowledge base tools — these are categories in Merge's catalog that currently fall outside Knit's core focus areas (HRIS, payroll, ATS, CRM, accounting, ticketing, and e-signature)
When Knit is the better choice
- Your integration count is growing and per-account cost is starting to show up in your unit economics — Knit's Start Up plan cost decreases as volume increases (from ~$50/account at 10 to ~$33/account at 30), compared to Merge's fixed $65/account throughout. Knit also offers API calls-based pricing as an alternative if usage-based billing better fits your model.
- Your customers are sensitive about third-party data storage — Knit operates on a zero-storage model where customer data passes through in real time and is never retained on Knit's servers, removing the data residency objection from your enterprise sales cycle
- You're comfortable starting lean and upgrading as you grow — Knit's Start Up plan ($499/month) covers core integrations with a fixed 24-hour sync and Knit's branding on the auth flow; if you later need custom field mapping, white-labeled auth, or configurable sync, Scale Up starts at $1,500/month as a flat feature fee — independent of account count, unlike Merge's per-account pricing, which keeps climbing as you add customers
- You need predictable unit economics as you scale — Merge's per-linked-account model means integration costs grow as a direct function of customer growth, which compresses margins
Ready to see Knit's pricing and zero-storage architecture for yourself?
Try Knit free for 30 days — no credit card required →Other Merge.dev Alternatives Worth Evaluating
| Alternative | Pricing Model | Best For | Key Difference vs. Merge |
|---|---|---|---|
| Knit | Start Up from $499/month (10 accounts), scaling to ~$1,000/month at 30; Scale Up from $1,500/month adds custom field mapping and white-labeled auth. API calls-based pricing also available. 30-day free trial. | SaaS teams where integration count scales with customers | Zero-storage architecture, declining per-account cost at scale, API calls-based pricing option, transparent upgrade path |
| Nango (open source) | Usage-based / self-hosted option available | Teams that want open-source flexibility or to self-host | Open source core; can run on your own infrastructure |
| Apideck | Per-linked-account (similar to Merge) | Teams needing API management + unified API in one | Broader API management features beyond unified API |
| Unified.to | Starting from $750/month API calls based | Cost-sensitive teams or those needing simple CRM/HRIS integrations | Narrower catalog but lower cost at scale |
| Truto | Usage-based from $0/month (open source) | Teams comfortable with self-hosted or usage-based pricing | Open source option; |
Frequently Asked Questions
How much does Merge.dev cost?
Merge.dev's self-serve Launch plan includes your first 3 production linked accounts free, then costs $650/month for up to 10, with each additional linked account billed at $65/month. Knit's Start Up plan starts at $499/month for 10 connected accounts, scaling to approximately $800/month at 20 accounts and $1,000/month at 30 accounts — a significantly gentler curve than Merge's fixed $65/account rate. If you need custom field mapping, white-labeled authentication, or configurable sync, Knit's Scale Up plan starts at $1,500/month. Knit also offers API calls-based pricing as an alternative billing model. Merge's Professional and Enterprise plans are contract-based; Vendr transaction data shows annual contracts typically ranging from $30,000 for Professional to $250,000+ for large Enterprise deployments, depending on linked accounts, integration categories, and feature requirements.
What is a linked account in Merge.dev?
A linked account is Merge's billing unit — it represents one customer's authenticated connection to one integration. If your product connects 50 customers to Salesforce and 30 of those same customers also connect to Workday, that is 80 linked accounts. Merge charges a fixed $65/month per linked account above the 10-account base (after the first 3, which are free). Knit's Start Up plan also prices by connected account but on a declining-rate curve: ~$50/account at 10, ~$40/account at 20, ~$33/account at 30. Knit additionally offers API calls-based pricing for teams that prefer usage-based billing, and a Scale Up plan from $1,500/month for teams that need custom field mapping, white-labeled authentication, or configurable sync regardless of account count. If you're evaluating Merge, model your expected linked account count 12–18 months out before committing — the monthly figure changes significantly as customers add integrations.
What does Merge.dev do?
Merge.dev is a unified API platform that lets B2B SaaS products integrate with 250+ third-party tools — HRIS, ATS, CRM, accounting, ticketing, file storage — through a single API endpoint instead of building each integration separately. Knit provides a similar unified API capability with a zero-storage architecture and tiered pricing that scales more gradually than Merge's fixed per-account rate. Merge has recently expanded into AI infrastructure with Merge Agent Handler, which gives AI agents access to and the ability to act across these same integrated tools.
How much is Merge.dev enterprise pricing?
Merge's Enterprise contracts are custom-priced and not publicly listed. Based on Vendr transaction data from actual buyer contracts, annual deals typically range from around $100,000 for smaller Enterprise deployments (under 50 linked accounts, 1–2 integration categories) to $250,000+ for large-scale enterprise deployments. Knit's Enterprise plan is also custom-priced and includes zero-storage architecture, dedicated support, custom SLAs, and role-based access controls. For teams that need more than Knit's Start Up plan but aren't yet at Enterprise scale, Knit's Scale Up plan (from $1,500/month) covers custom field mapping, white-labeled authentication, and configurable sync. For either platform, the main cost drivers are linked account volume, number of integration categories, and required support tier.
Is Merge.dev worth it?
Merge.dev is worth it if you need broad integration coverage across multiple SaaS categories and have a relatively small number of high-value customers. Where Knit and alternatives become more cost-effective is at scale: if your customer base is growing and each new customer adds linked accounts, Merge's per-account cost adds up quickly. Teams with 50+ customers using 2–3 integrations each should model the total cost before committing to Merge's pricing structure. The decision usually comes down to integration breadth needed versus total cost at your expected customer count.
Does Merge.dev store my customers' data?
Yes — Merge caches a copy of your customers' data on its servers to serve your API requests. This is central to how Merge's architecture works: it syncs from source systems on a schedule and stores the normalized copy for fast reads. Knit operates differently with a zero-storage model where data flows through in real time and is never retained on Knit's servers. For teams selling to enterprises with strict data residency requirements or GDPR obligations, the data storage difference is often a deciding factor.
What are the best alternatives to Merge.dev?
The most commonly evaluated alternatives to Merge.dev are Knit (Start Up plan from $499/month for 10 accounts scaling to ~$1,000/month at 30, with a Scale Up plan from $1,500/month for custom field mapping and white-labeled auth; zero-storage architecture, API calls-based pricing also available, 30-day free trial), Nango (open-source option with self-hosting available), Apideck (broader API management features), Unified.to (flat-rate from $250/month, narrower catalog), and Truto (open-source core, usage-based pricing). Knit's free 30-day trial covers the full Unified API feature set and is a practical way to compare without committing.
Is there a free version of Merge.dev?
Merge.dev's Launch plan includes 3 free production linked accounts — enough for small-scale prototyping but not for a production deployment with real customers. Knit offers a 30-day free trial covering the Start Up plan's feature set (starting at $499/month for 10 connected accounts after the trial), giving you time to build and test a real integration before committing. For teams evaluating unified API options, Knit's 30-day full-feature trial is a more useful comparison baseline than Merge's 3-linked-account limit.
Is Merge.dev an iPaaS?
No — Merge.dev is a unified API, not a general-purpose iPaaS like Zapier or Workato. Knit sits in the same category: rather than letting you build arbitrary workflows between any two apps, both platforms normalize a fixed set of categories — HRIS, ATS, CRM, accounting, ticketing — into a single API your product calls directly. The distinction matters when you're scoping a project. An iPaaS is built for internal automation between tools your team already uses internally. A unified API like Merge or Knit is built to power customer-facing integrations inside the product you sell — your customers connect their HR or CRM systems through your app, not through a separate automation tool. If your goal is to ship "Connect your Workday account" inside your product, you're in unified API territory, not iPaaS.
.webp)
