Different tools. Different direction. Here's how they compare.
Quick take
This is a category clarification, not a takedown. Merge reads customer data in through a unified API. Meshes sends your product events out with delivery guarantees.
Choose Meshes when
Your app emits events like signups, payment failures, and cancellations that need to land in CRMs, email tools, messaging platforms, and webhooks reliably, with retries, fan-out, dead letters, replay, and per-destination observability. Your customers manage their own connections through embedded workspaces.
Choose Merge when
Your app needs to pull contacts from Salesforce, employees from an HRIS, tickets from a helpdesk, or files from a storage provider. You want one API that normalizes data across many third-party systems so you do not build and maintain each integration separately.
Use both when
Merge pulls customer data from their tools into your app. Meshes pushes your product events back out to their tools. Merge handles inbound. Meshes handles outbound. Clean separation, no overlap.
Architecture
The simplest way to understand the difference: Merge reads data in. Meshes sends events out. They operate on opposite sides of the same integration problem.
Scenario 01
Merge approach
Integrate with Merge's CRM Unified API. Pull contacts, accounts, opportunities, and related records from multiple CRM providers through a single normalized interface.
Meshes approach
Meshes does not read data from third-party tools. This is not what Meshes is built for.
Takeaway: For ingesting third-party data, Merge is the right tool.
Scenario 02
Merge approach
Merge supports reads first and also supports writes for many integrations, but it is not an event routing or outbound delivery platform.
Meshes approach
One meshes.emit(...) call. Routing rules determine which destinations receive the event. Meshes delivers to all matching destinations in parallel with independent retries, dead letter capture, and replay.
Takeaway: For outbound event delivery with fan-out and delivery guarantees, Meshes is purpose-built.
Scenario 03
Merge approach
Use Merge to pull customer data from their tools into your app. Merge owns inbound data normalization and the Linked Account relationship.
Meshes approach
Use Meshes to push your product events back out to your customers' tools. Meshes owns outbound routing, delivery guarantees, and embedded customer-facing integration management.
Takeaway: These products are complementary, not competitive. Many integration architectures need both directions.
Inbound with Merge
Read data in
Outbound with Meshes
Send events out
Merge pulls customer data in. Meshes pushes product events out. Same integration surface. Opposite direction.
Feature comparison
| Capability | Meshes | Merge |
|---|---|---|
| Data direction | ||
| Primary direction | Outbound: your app to customers' tools | Inbound: customers' tools to your app |
| Core job | Deliver product events to destinations | Normalize third-party data into your app |
| What it covers | ||
| Outbound event delivery | Yes: fan-out, retries, dead letters, replay | Not the primary use case |
| Inbound data ingestion | No | Yes: unified API across many software categories |
| Write operations to third parties | Yes: destination actions triggered by routed events | Supported for many integrations via the Unified API |
| Data normalization | Field mappings with transforms per connection | Common data models across providers |
| Delivery and reliability | ||
| Fan-out routing | One event to many destinations in parallel | N/A: API request and sync model |
| Automatic retries | Exponential backoff with jitter, per destination | API-level retry handling and sync or webhook patterns |
| Dead letter capture | Yes | N/A |
| Event replay | Yes: replay failed or all deliveries per destination | N/A |
| Developer experience | ||
| SDKs | Node.js and Go | Multiple server-side SDKs plus API support |
| Integration catalog | 11 focused destination types | 220+ integrations across multiple categories |
| Embeddable UI | White-label workspaces for customer-facing integration management | Merge Link and Magic Link for end-user auth and setup |
| Multi-tenant | ||
| Tenant model | One workspace per customer with isolated connections, rules, credentials, and event history | Linked Accounts per end-user or customer connection |
| Scope | ||
| API categories | CRM, email, messaging, meetings, webhooks | ATS, HRIS, CRM, accounting, ticketing, file storage, knowledge base, chat, and more |
| AI support | MCP server for Meshes resources and delivery workflows | Merge Agent Handler and MCP-related agent tooling |
| Deployment | Cloud, managed | Cloud, managed |
| Pricing | ||
| Trial or free entry | Developer plan: 100 events per month and 1 workspace | 3 production Linked Accounts free |
| Pricing model | Event volume plus workspaces | Linked Accounts plus plan tier |
Data direction
Meshes
Outbound: your app to customers' toolsMerge
Inbound: customers' tools to your appMeshes
Deliver product events to destinationsMerge
Normalize third-party data into your appWhat it covers
Meshes
Yes: fan-out, retries, dead letters, replayMerge
Not the primary use caseMeshes
NoMerge
Yes: unified API across many software categoriesMeshes
Yes: destination actions triggered by routed eventsMerge
Supported for many integrations via the Unified APIMeshes
Field mappings with transforms per connectionMerge
Common data models across providersDelivery and reliability
Meshes
One event to many destinations in parallelMerge
N/A: API request and sync modelMeshes
Exponential backoff with jitter, per destinationMerge
API-level retry handling and sync or webhook patternsMeshes
YesMerge
N/AMeshes
Yes: replay failed or all deliveries per destinationMerge
N/ADeveloper experience
Meshes
Node.js and GoMerge
Multiple server-side SDKs plus API supportMeshes
11 focused destination typesMerge
220+ integrations across multiple categoriesMeshes
White-label workspaces for customer-facing integration managementMerge
Merge Link and Magic Link for end-user auth and setupMulti-tenant
Meshes
One workspace per customer with isolated connections, rules, credentials, and event historyMerge
Linked Accounts per end-user or customer connectionScope
Meshes
CRM, email, messaging, meetings, webhooksMerge
ATS, HRIS, CRM, accounting, ticketing, file storage, knowledge base, chat, and moreMeshes
MCP server for Meshes resources and delivery workflowsMerge
Merge Agent Handler and MCP-related agent toolingMeshes
Cloud, managedMerge
Cloud, managedPricing
Meshes
Developer plan: 100 events per month and 1 workspaceMerge
3 production Linked Accounts freeMeshes
Event volume plus workspacesMerge
Linked Accounts plus plan tierImplementation
Merge pulls data into your app. Meshes pushes events out. The code reflects the difference: one is a read operation, the other is an event emission.
Merge
// Read contacts from a customer's CRM via Merge
const response = await fetch(
"https://api.merge.dev/api/crm/v1/contacts",
{
headers: {
Authorization: "Bearer " + mergeApiKey,
"X-Account-Token": customerAccountToken,
},
},
);
const contacts = await response.json();
// Merge normalizes data from multiple CRM providers
// into a common model. Your app reads from one API
// regardless of which CRM the customer uses.This mirrors the current Merge CRM read pattern documented for GET /contacts: Bearer API key plus X-Account-Token for a specific Linked Account.
Meshes
import MeshesEventsClient from "@mesheshq/events";
const meshes = new MeshesEventsClient(
process.env.WORKSPACE_PUBLISHABLE_KEY!,
);
// Deliver a product event to the customer's tools
await meshes.emit({
event: "user.signup",
payload: {
email: "jane@example.com",
first_name: "Jane",
last_name: "Doe",
phone: "+15551234567",
},
});
// Meshes routes this event to HubSpot, Slack,
// Mailchimp, or whatever destinations are configured
// in this customer's workspace. With retries,
// dead letters, and per-destination observability.Merge reads third-party data into your app through a unified API. Meshes delivers your product events out to third-party tools with routing and delivery guarantees. One fetches. The other fires.
Why engineering teams choose Meshes
Meshes is purpose-built for delivering your product events to downstream tools. If your problem is 'how do I get my events into my customers' CRMs,' Meshes is the answer.
One event reaches every configured destination in parallel. A signup can update HubSpot, Mailchimp, Intercom, Slack, and more from a single API call with isolated retry handling per destination.
Exponential backoff, dead letter capture, and replay come standard. When a destination is down, Meshes retries without losing the event and without blocking delivery to other destinations.
Your customers manage their own connections, routing rules, field mappings, and event history inside white-label workspaces embedded in your product.
Configure how event payload fields map to destination fields per connection, with transforms and error handling. No manual data reshaping in your app code for every downstream system.
Use Merge to pull customer data in. Use Meshes to push product events out. Clean architectural separation with no overlap or conflict.
Common questions