IntegrationCustom destination
Custom Webhooks - Authenticated, Signed Event Delivery to Any Endpoint
Webhooks are the universal escape hatch in the Meshes catalog. If the destination accepts HTTPS requests, Meshes can route product events there with authentication, HMAC signing, and the same retries, fan-out, and delivery visibility as first-party integrations.
user.signupinvoice.paidpage.completed|Actionssend_webhookThe event names shown here are examples. In Meshes, event types are fully customized for each organization.
What you can do
Supported actions with real product context behind them
Choose None, Basic Auth, Bearer Token, or Custom Header authentication. All credentials are encrypted at rest. Optionally enable HMAC-SHA256 or HMAC-SHA512 payload signing so receivers can verify request integrity.
Not every destination needs a dedicated first-party integration to be useful. Sometimes the system you need to reach is an internal service, a partner endpoint, or a SaaS tool that already exposes a clean webhook receiver.
Meshes gives those endpoints the same delivery layer as the rest of your stack. Configure the HTTPS URL, authentication scheme, HMAC signing, HTTP method, and payload format in your Meshes workspace — then create a rule and let Meshes handle delivery, retries, and observability.
send_webhookDeliver an authenticated, optionally signed event payload to an HTTPS endpoint
Use Meshes to deliver the matching product event to any receiver that can accept a webhook request, with configurable auth, HMAC signing, custom headers, payload format, and HTTP method.
Common use cases
Where Meshes teams put Webhooks to work
Workflows where this destination tends to matter first — the product event, the destination action, and the operational retry path living inside the same workspace.
Internal services reachable without a custom dispatcher
Send user.signup or billing events into your own downstream services while keeping retries and observability inside Meshes.
Support a destination before it has a dedicated integration page
If the tool exposes an HTTP endpoint, webhooks let you route events there now instead of waiting for first-party coverage.
Partner and customer-owned endpoints connected safely
Use customer workspaces and webhook connections so each tenant can receive the events relevant to its own external systems.
Unsupported tools inside the same event layer
Custom webhooks let the long tail of your integration surface still benefit from Meshes fan-out, retries, and delivery history.
How it works
Connection, rule, event — the three-step operating model
A connection lives in the workspace, a rule binds the event to the action, and the delivery layer handles the last mile with retries, replay, and per-destination history.
Connect Webhooks
Create the webhook connection in Meshes with the HTTPS endpoint, HTTP method, authentication, HMAC signing, and payload format your destination requires.
Create routing rules in Meshes
Create rules for events like user.signup or invoice.paid, choose send_webhook, and decide which product events should be forwarded to that endpoint.
Emit the event and review delivery
Emit the event from your app or use Send Test Event in Meshes. Meshes delivers the signed, authenticated payload, retries transient failures, and records the full delivery history.
Event example
Emit the product event once
import MeshesEventsClient from '@mesheshq/events';
const meshes = new MeshesEventsClient(
process.env.WORKSPACE_PUBLISHABLE_KEY!,
);
await meshes.emit({
event: 'invoice.paid',
resource: 'invoice',
resource_id: 'inv_482',
payload: {
invoice_id: 'inv_482',
account_id: 'acct_913',
amount: 49900,
currency: 'usd',
paid_at: '2026-03-22T10:30:00.000Z',
},
});Connection model
Configurable
Choose None, Basic Auth, Bearer Token, or Custom Header authentication. All credentials are encrypted at rest. Optionally enable HMAC-SHA256 or HMAC-SHA512 payload signing so receivers can verify request integrity.
Why Meshes
Why teams use Meshes for Webhooks
Webhooks sits inside the same fan-out, retry, replay, and delivery-visibility layer as every other destination — customer-connected or internal — that the workspace owns.
HMAC signatures let receivers verify every payload
Enable HMAC-SHA256 or HMAC-SHA512 signing so endpoints can cryptographically prove each request came from Meshes and has not been tampered with in transit.
Configurable auth keeps endpoints locked down
Attach Basic Auth, Bearer Tokens, or custom auth headers to every request. Credentials are encrypted at rest and never exposed after they are saved, so webhook connections stay secure without extra infrastructure.
It covers the long tail of your integration surface
If the destination can receive HTTPS requests, you can usually route product events there without waiting for a bespoke connector.
You still get retries and replay
Custom endpoints deserve the same delivery guarantees as first-party integrations, especially when they power critical internal flows.
One event path can serve both first-party and custom destinations
Your app emits the event once and Meshes fans it out to supported integrations and webhook endpoints in parallel.
It is the fastest way to support unique customer workflows
When a customer needs their own endpoint in the loop, webhooks let you support that without hardcoding per-customer logic into the product.
Keep exploring
Related guides, use cases, docs, and comparison pages
Concrete patterns, supporting documentation, and build-vs-buy context that usually come up during evaluation.
Catalog
All integrations
Return to the integrations catalog and compare custom webhooks with the rest of the Meshes destination surface.
Open linkDocs
Quickstart
Fastest path to creating a webhook connection and routing your first event through Meshes.
Open linkDocs
Integrations and rules reference
Webhook action model and rule metadata shape for send_webhook.
Open linkUse Case
User signup fan-out
Example of one product event reaching several destinations at once from the same Meshes rule set.
Open linkGuide
Routing guides
Additional Meshes patterns that can also be applied when the destination is a custom HTTPS endpoint.
Open linkCompare
Meshes vs. DIY
Breakdown of what it takes to build your own webhook routing, retries, dead letters, and replay path from scratch.
Open link