Merge.dev

Positioning: one integration to build instead of twenty

Merge sells connective infrastructure for product teams: instead of building and maintaining a separate integration to every HR system your customers use, you build one integration to Merge's Unified API and get back normalised data regardless of whether the source was BambooHR, Workday, or ADP. The mechanics are five concepts, and the documentation at docs.merge.dev is unusually clear about them: Merge Link, a drop-in UI where your end user authorises their system; a Linked Account, the resulting connection carrying an account token; the Unified API, one surface per category; Common Models, the standardised shapes (an Employee looks like an Employee whatever the source); and the Dashboard for keys, syncs, and monitoring. Categories at the time of writing span HRIS, ATS, Accounting, CRM, Ticketing, File Storage, Knowledge Base, and Chat — a third-party catalog counts 260+ integrations across those categories, while Merge itself says "hundreds".

The company's positioning has widened recently: the homepage now reads "the universal context engine for agents", with three product lines alongside the data integrations — Merge Agent Handler, which gives AI agents access to pre-built tool connections; Merge Gateway, which routes LLM calls through one API with spend and performance controls; and Merge for Workforce, which governs which models, MCPs, and skills employees can use. For a catalog entry filed under unified APIs, the core product is still Unified, and that is what I am rating — but the direction of travel tells you where the engineering investment is going, and the testimonials on the homepage (Telnyx, Perplexity, Zoom) are increasingly about agents rather than HR syncs.

What it actually does

Once a Linked Account exists, everything is a REST call against common models: GET /hris/v1/employees returns the same object shape no matter which of the 50+ HRIS platforms a customer connected. The practical features that make this survive production are the ones on the pricing page's comparison table: read and write access across production integrations, SFTP support and CSV uploads for the sources that will never have a modern API, Selective Sync and default filters so you pull only the rows you need, Remote Fields for the provider-specific attributes the common model does not cover, deleted-data detection (native where the provider supports it, enhanced as a purchasable add-on where it does not), and integration observability — linked-account management, logs, issue detection with automatic resolution detection, and end-user-facing error messaging inside Merge Link.

Pricing, at time of writing, is the most concrete in the category: the Launch plan lets you link 3 production Linked Accounts for free, then costs $650/month for up to 10 total, with $65 per additional Linked Account and volume discounts beyond that. Professional and Enterprise are contract-based; Professional adds custom fields, field-level scopes for data minimisation, custom sync frequencies, 60-day third-party sandboxes, and go-live support packages, while Enterprise adds audit trail, SAML SSO, 90+ day log retention, unlimited sandboxes, a dedicated account manager with a shared Slack channel, support and uptime SLAs, and single-tenant or self-hosted options for purchase. The ceilings are tiered too: API rate limits of 100/min on Launch, 400/min on Professional, 600/min on Enterprise; log retention of 3, 30, and 90+ days respectively; daily sync frequency on Launch versus customisable above it.

My testing notes

My evaluation ran through the documentation and test Linked Accounts rather than a production deployment, so read these as developer-experience observations. Three points.

First, the common-model layer does the job it claims. Pulling employee records through the same endpoint from two different HRIS sources returned genuinely consistent shapes — name fields, employment objects, and identifiers lined up — with provider-specific variance surfacing as absent fields rather than as structural surprises. Where I needed something outside the common model, Remote Fields exposed the provider's own attributes rather than forcing a lossy mapping. This is the entire value proposition, and in my testing it held up on the two providers I exercised.

Second, Merge Link is the piece your end users will judge you on, and it behaves like a component built by people who have debugged OAuth at scale. The four-step token exchange — short-lived link token, user authorisation, account token returned, stored server-side — is documented precisely enough to implement without guesswork, and the flow localises and surfaces provider-specific errors to the end user instead of failing silently. One thing I noticed in the plan table: Launch's log retention is 3 days. If a customer reports a sync problem on day four, the evidence is gone unless you have been exporting logs — an observability product that keeps 72 hours of logs on its entry tier is a sharp edge worth planning around.

Third, the support model is unusually physical for an API company. The testimonial from Zoom describes Merge staff coming on-site to train customer-facing teams before an HRIS launch, and the plan table backs that pattern up: go-live services, white-label authentication guides, and onboarding calls with your customers are purchasable or bundled depending on tier. That matters more here than in self-serve developer tools, because integration launches are events with dates and your support team has to answer questions about someone else's HR system.

One more observation on the observability layer, since integrations die quietly and that is the failure mode that generates support tickets. The Dashboard's linked-account health view and issue detection flagged a deliberately broken credential in my test setup with provider-specific messaging, and the same messaging surfaces inside Merge Link so the end user sees "your X session expired" rather than a 401. Automatic resolution detection means the issue clears itself when the customer re-authenticates. For a small product team, that loop — detect, explain, resolve, close — is the difference between integration maintenance being a feature and being a part-time job.

What it does not do

It does not make the long tail disappear: if your customer runs a homegrown or deeply niche system, you are requesting an integration (prioritised on higher tiers) or building it yourself. There is no self-serve way to reach Professional features — custom fields, field-level scopes, and custom sync frequencies all sit behind a contract — and once you pass ten production Linked Accounts, the $65-per-account arithmetic is the conversation, not a checkout. Launch's daily sync frequency will not satisfy real-time use cases; that requires customisable sync on a contract. The newer agent products (Agent Handler, Gateway, Workforce) are separate purchases with their own pricing pages, so the "one vendor for everything" story is really four product lines. And being the layer between you and dozens of third-party APIs means provider outages and provider API changes arrive at your doorstep as Merge incidents; the observability tooling exists because that coupling is permanent.

Verdict

I rate Merge 3.9 out of 5: the core is the strongest version of this pattern I have worked with — common models that hold up in testing, an auth component your end users can actually complete, and production features like deleted-data detection and observability that most competitors leave to you — but the cost curve after the free tier is steep for small teams and the features that make it enterprise-ready hide behind contracts, under the rubric (40% core functionality, 20% value, 20% usability, 10% support/ecosystem, 10% reliability signals). If your product roadmap includes customer-facing integrations across HR, accounting, CRM, or ticketing systems and you would rather build one integration than twenty, Merge belongs on the shortlist, and the free 3-account tier is enough to prove the model before the $650/month conversation starts.

Sources

• https://merge.dev/
• https://merge.dev/pricing
• https://merge.dev/pricing/unified
• https://merge.dev/pricing/gateway
• https://merge.dev/pricing/workforce
• https://merge.dev/security
• https://merge.dev/features/integration-observability
• https://docs.merge.dev/get-started/introduction/
• https://docs.merge.dev/merge-unified/concepts
• https://help.merge.dev/
• https://merge.dev/case-studies/telnyx
• https://magne.tools/tools/merge