Changelog

The per-attempt observability launch in May gave every delivery attempt a structured outcome code. This update makes those codes considerably more precise: outcome codes now reflect the destination's actual response, seven new codes cover the most common rejection modes, and failed attempts keep the provider's own error detail for inspection.

Seven new outcome codes

The outcome vocabulary grows from nine to sixteen codes. The new additions distinguish rejection modes that previously landed in the generic client-error bucket:

• invalid_request — the destination rejected the request as malformed
• validation_failed — the destination rejected one or more field values
• destination_not_found — the target resource no longer exists at the destination
• destination_conflict — the request conflicted with current destination state
• destination_gone — the destination reported it is permanently gone
• destination_timeout — the destination reported a request timeout
• payload_too_large — the destination refused the payload size

These join the existing delivered, rate_limited, auth_failed, timeout, network_error, mapping_error, rejected_client_error, rejected_server_error, and internal_error codes. The attempt drill-down on the event detail page renders all sixteen.

Codes that reflect the destination's response

Outcome codes previously reported the broad category of a failure, so many distinct rejections looked the same. They now reflect the destination's actual HTTP response — the real status code plus the provider's own error code. A missing HubSpot list shows as destination_not_found, a rejected field value as validation_failed, a throttled request as rate_limited, and so on.

Every integration maps its destination's responses to the same shared vocabulary, so a rate_limited from HubSpot means the same thing as a rate_limited from a custom webhook — one set of codes to build dashboards and alerting against, regardless of where the event was headed.

Provider error detail on failed attempts

When a delivery fails, the attempt now records a structured response: the HTTP status, the provider's own error code (for example, the error category HubSpot returns), and the destination's response body. The response details view in the attempt drill-down shows exactly what the destination said, so debugging a rejected delivery no longer requires reproducing the call yourself. Response details remain permission-gated the same way as before.

When a product event lands in a destination, you should know exactly what happened — not just whether it ended up green or red. This release turns every event in Meshes into a full delivery story, attempt by attempt, with the controls to act on what you find.

Every attempt, in context

Open any event in the dashboard and each routing rule now expands inline to show the full attempt history. You can see the order things happened in, how long each attempt took, what the destination said, and which attempt finally succeeded or what is still being retried. Failed attempts that captured a response from the destination expose that response on demand, so debugging a flaky webhook or a misconfigured CRM no longer means digging through your own logs to figure out what Meshes saw.

Outcomes that explain themselves

Attempts now carry a structured outcome — delivered, rate limited, auth failure, timeout, server error, and others — so you can tell apart a transient destination blip from a credential problem from a mapping mistake at a glance. The same outcome flows through the API, so dashboards, automations, and support tooling can react to specific failure modes instead of treating every red row the same. The full list of outcome codes is in the API reference.

Status that tells you what to expect

Event and rule status now distinguishes work that is actively being retried from work that has stopped. Retrying means a previous attempt failed but Meshes will try again; canceled means delivery has been stopped on purpose and will not resume. Combined with the new countdown that shows when the next attempt will fire, you always know whether an event is making progress or sitting still.

Take action without leaving the page

Two new controls live directly on the event detail page:

• Cancel stops further delivery for one rule or for the whole event in a single click. In-flight requests are allowed to finish; nothing new is scheduled afterward.
• Retry now fires the next attempt immediately for a rule that is in a retry loop, so you can confirm a fix without waiting for the next scheduled backoff.

Both actions require workspace edit permission. Per-rule cancel and retry-now are available in embedded Meshes experiences your customers see in your own product; event-scope cancel stays inside your team's own dashboard.

Why this matters

• Support gets faster. Front-line teams can answer "did our event reach HubSpot?" without escalating to engineering.
• Customers trust the integration. When something does go wrong, the dashboard shows exactly which attempt failed, why, and when the next one will run.
• You stay in control. A bad destination, a stuck rule, or a runaway retry no longer requires a deploy or a support ticket — it is a click on the event detail page.

Pipedrive is now available as a Meshes destination. Connect a Pipedrive account with OAuth and route product events into Person records and labels without building a separate Pipedrive sync path in your app.

What it does

The Pipedrive integration focuses on Person updates driven by the events you already send through Meshes.

• Sync Person creates or updates a Pipedrive Person by email.
• Update Person Field syncs the mapped Person data and sets one supported editable Person field from the connected account.
• Add Label to Person and Remove Label from Person sync the mapped Person data and keep Person labels aligned with lifecycle and product status changes.
• Meshes loads the connected account's Person field catalog and label list so mappings reflect the actual Pipedrive workspace, including supported custom fields.

Example workflow

A trial.started event can create or update the Person in Pipedrive, set a lifecycle custom field, and add a Person label for the trial state. From there, Pipedrive automations can handle follow-up tasks, deal routing, or campaign enrollment based on those Person updates.

Get started

Create a Pipedrive connection, add a rule for the event you want to send, choose the Person action that fits the workflow, and map the fields Meshes should write. Use Send Test Event to verify the Person update before turning the rule on. See the Pipedrive docs for setup and mapping details.

Customer.io is now available as a Meshes destination. Use it to identify people, sync customer traits, and track behavioral events from the product events your app already emits to Meshes.

What it does

The Customer.io integration helps lifecycle, growth, and product teams keep Customer.io profiles and campaigns aligned with real product activity.

• Identify profiles with userId, email, or anonymousId.
• Send additional payload fields as Customer.io traits.
• Track behavioral events with the Meshes event name or an optional event_name_override.
• Connect with a Customer.io CDP API Key.
• Choose the US or EU Customer.io region for the connection.

Example workflow

A user.signup event can identify the new profile in Customer.io, attach traits like email, plan, and first_name, and record the signup event so Customer.io campaigns and segments can react to it.

Get started

Create a Customer.io connection, add a rule for the event you want to send, map the identity fields, and use Send Test Event to verify the delivery. See the Customer.io docs for the setup flow and field mapping details.

Discord is now available as a connection type in Meshes. Add the Meshes bot to your Discord server, pick the destination channel in the rule builder, configure an embed title and message template, and Meshes handles delivery with retries.

Channel-aware rule setup

Each rule targeting a Discord connection includes a live channel picker backed by the connected server. After the bot is authorized, Meshes loads the available text and announcement channels so you can route each event to the right destination without hardcoded channel IDs.

Embed titles and templated message delivery

Discord rules use a required embed title plus a message template with {{field}} interpolation. When an event fires, Meshes renders the title and body from the event payload and posts a rich embed to the selected channel.

Example rule values:

Title: Payment failed

Template:

Customer: {{customer.email}}
Plan: {{plan}}
Retry at: {{retry_at}}

Templates support nested field access such as {{user.name}}, so Discord notifications can stay concise while still carrying the product context your team needs.

How it works

1. Connect Discord from the Connections page and authorize the Meshes bot for your server
2. Create a rule targeting the Discord connection
3. Select a channel, set the embed title, and write the message template
4. Meshes renders the embed, delivers it to Discord, and retries transient failures automatically

Discord is the latest supported integration, joining HubSpot, Salesforce, Intercom, Mailchimp, ActiveCampaign, Resend, Zoom, AWeber, MailerLite, Slack, and Webhooks.

SendGrid is now available as a connection type in Meshes. You can connect a SendGrid account with an API key, select a Dynamic Template in the rule builder, or send an inline HTML email directly from the event that should trigger the message.

This integration supports two actions: Send Email (Template) for SendGrid Dynamic Templates and Send Email for inline HTML delivery. That means welcome emails, trial onboarding prompts, billing confirmations, and other transactional sends can all run from the same product events you already route to the rest of your stack.

No custom SendGrid worker is required. Create the connection in Connections -> New Connection -> SendGrid, add a rule for the event you care about, map email plus any template_variables you need, and Meshes handles the delivery path.

ActiveCampaign connections now support a Sync Contact action alongside the existing list and tag actions.

Sync Contact creates or updates the contact record in ActiveCampaign using the fields mapped in your Meshes rule. Unlike the list and tag actions, it does not require selecting a target list or tag — the mapped fields are the entire operation. This is useful when the goal is keeping contact data current without triggering list-based or tag-based automation.

When to use it

• Keep ActiveCampaign contact properties up to date from product events without subscribing the contact to a list.
• Upsert contacts with custom field values before a separate rule handles list or tag assignment.
• Sync profile data like name, phone, or custom fields from events where the only goal is a contact record update.

How it works

1. Open Rules and create a new rule.
2. Select your ActiveCampaign connection and choose Sync Contact.
3. Map the event fields to ActiveCampaign contact fields. The mapping catalog includes core fields (email, firstName, lastName, phone) and custom fields from the connected account.
4. Save the rule and send a test event to verify the contact is created or updated.

email is required for all ActiveCampaign contact actions, including Sync Contact.

Learn more

• ActiveCampaign integration docs
• Integrations overview

Meshes webhooks are no longer config-only. Every webhook connection now supports authenticated, signed delivery with full control over how the request reaches your endpoint.

Authentication

Attach credentials to every webhook request. Choose from:

• None — no auth headers
• Basic Auth — Authorization: Basic header from a username and password
• Bearer Token — Authorization: Bearer header
• Custom Header — any header name and value, such as X-API-Key

All credentials are encrypted at rest and never returned in plaintext after they are saved.

HMAC payload signing

Enable HMAC-SHA256 or HMAC-SHA512 so your endpoint can cryptographically verify that every request body came from Meshes and has not been tampered with. The signature is computed from the exact bytes sent and attached in a configurable header (default X-Meshes-Signature). Signing is independent of authentication — use both together for defense in depth.

Custom headers

Add up to five static headers to every request for routing keys, tenant identifiers, or any metadata your endpoint expects.

Payload format

Choose Wrapped to send the full Meshes event envelope, or Raw to send only the payload object. In raw mode, event metadata is promoted to X-Meshes-* HTTP headers so your endpoint can still access the event ID, name, resource, and timestamps.

HTTP method

Select POST, PUT, or PATCH per connection. The default is POST.

Learn more

• Webhook integration docs
• Integrations overview

Meshes embed sessions now support two new additive access shapes on top of the existing workspace session model.

What is new

• Resource sessions lock the iframe to one resource + resource_id pair
• Dashboard sessions expose a read-only dashboard-only embed
• launch_page replaces raw launch paths with a small initial-page enum
• Server-side enforcement now keeps resource and dashboard sessions constrained even when a token is used directly against the API

What resource sessions can do

• launch into dashboard, rules, or events
• view only in-scope rules and events
• create rules and emit or retry events only inside the locked resource scope
• open matching Event Detail when the event belongs to that resource pair

What dashboard sessions can do

• launch into dashboard
• read dashboard shell data and dashboard metrics
• stay read-only and dashboard-only

What changed for integrators

• use launch_page instead of raw route strings
• choose session_type when minting a session
• send resource and resource_id only for resource sessions

Learn more

• Embed overview
• Session API overview
• Workspace pages available in embed

You can now embed key Meshes workspace pages directly inside your own product with session-based access and an iframe-ready launch flow.

This release adds a new embedded workspace surface for teams that want to expose integrations to their own customers without sending them to a separate admin app. Your backend mints a short-lived session, your frontend mounts the returned launch_url, and the embedded experience handles refresh, navigation, and resizing through a small postMessage contract.

What is included

• Embedded workspace pages for dashboard, connections, rules, events, event detail, and connection mappings
• Session minting and refresh with POST /api/v1/sessions and POST /api/v1/sessions/:sessionId/refresh
• Launch URLs for iframe bootstrap
• Iframe messaging for ready, auth, refresh, expired, navigation, and resize events
• Scoped payload access with the events.payload:read session scope

What this unlocks

• expose customer-specific integration settings inside your own app
• keep access scoped to a single Meshes workspace
• refresh embedded access without remounting the entire iframe
• handle iframe height and token refresh from your host app

Typical integration flow

1. your backend mints a session for the correct workspace
2. your frontend mounts the returned launch_url
3. the iframe sends meshes:ready
4. your frontend sends meshes:auth with the current access_token
5. your frontend refreshes the session when the iframe asks for a new token

Learn more

• Embed overview
• Embed quickstart
• Session API overview
• Iframe message contract

Slack is now available as a connection type in Meshes. Connect your Slack workspace via OAuth, pick a destination channel, configure a message template, and Meshes handles delivery with retries.

Templated messages

Each rule targeting a Slack connection includes a message template with {{field}} interpolation. When an event fires, Meshes renders the template with the event payload and posts to the configured channel.

Example template:

🎉 New signup: {{email}}
Plan: {{plan}}
Source: {{source}}

Templates support Slack markdown formatting and nested field access via dot notation (e.g., {{user.name}}). Missing fields render as empty strings rather than broken template syntax.

How it works

1. Connect your Slack workspace from the Connections page
2. Create a rule targeting the Slack connection
3. Select a channel and write your message template
4. Meshes routes matching events to Slack with automatic retries

Slack is the latest supported integration, joining HubSpot, Salesforce, Intercom, Mailchimp, ActiveCampaign, Resend, Zoom, AWeber, MailerLite, and Webhooks.

Rule actions now support a textarea field type for multiline input. This powers Slack's message template editor and is available for any integration that needs multiline configuration in rule setup.

Previously, rule action fields only supported single-line text and password inputs. The new textarea type renders a resizable monospace text area in the rule configuration form - useful for templates, message bodies, or any structured text input.

This is a platform-level change, not specific to Slack. Any integration can now define a kind: "field" action data entry with type: "textarea" and get multiline input in the rule form automatically.

Meshes is now live with paid plans. Send product events from your app and route them to HubSpot, Salesforce, Intercom, Mailchimp, ActiveCampaign, Resend, Zoom, AWeber, MailerLite, and custom webhooks — with retries, deduplication, and delivery guarantees built in.

What you get

• Fan-out routing — one event, multiple destinations, delivered in parallel
• Automatic retries — exponential backoff with jitter, dead letter queues for failures
• Field mappings — transform event payloads into the format each destination expects
• Multi-tenant workspaces — isolate connections, rules, and credentials per customer
• 10 integrations — CRMs, email platforms, messaging tools, and webhooks

Getting started

Sign up at meshes.io and send your first event in minutes. The Developer tier is free — 100 events/month, 1 workspace, 3 connections. Card required to activate your account.

Paid plans start at $49/mo (Builder) with annual pricing available with 2 months free.