Quickstart

This guide walks you through:

1. Creating a workspace
2. Connecting a destination (webhook)
3. Defining an event type and rule
4. Sending your first event
5. Verifying delivery in the UI

This quickstart uses public event ingestion with a workspace publishable key (X-Meshes-Publishable-Key). Publishable keys are intended for client-side use and only work with event ingestion endpoints.

Need to manage workspaces, connections, or rules programmatically? Use the private management API, which requires a server-side machine JWT (never in browser code). See: API Documentation and Authentication.

1. Create a Workspace

In the Meshes dashboard:

1. Go to Workspaces → New Workspace.
2. Choose a name, e.g. Acme Dev or Demo Workspace.

You’ll use the workspace publishable key for sending events. This can be found on the workspace settings page.

2. Connect a Destination (Webhook)

For this quickstart, we’ll send events to a simple webhook.

1. Create or use an existing HTTP endpoint that accepts POST requests (you can use a service like webhook.site while prototyping).
2. In the Meshes dashboard, go to Connections → New Connection.
3. Choose Webhook / HTTP.
4. Enter:
   • Name: Demo Webhook
   • URL: your webhook URL
5. Save the connection.

You now have a destination Meshes can send events to.

3. Define a Rule

Create a rule:

1. Go to Rules → New Rule.
2. Set Event Type: contact.created
   • This is the default event type created for your account
3. Set a Connection: your Demo Webhook connection
   • Payload mapping: pass through the event payload (or map fields as needed)
4. Save the rule and ensure it is enabled.

At this point:

Whenever a contact.created event arrives in this workspace, Meshes will send it to your webhook.

4. Send an Event

You can send events via HTTPS or an SDK. Below are two simple options.

Option A: curl (Publishable Key)

Replace placeholders with your real values:

• WORKSPACE_PUBLISHABLE_KEY – a workspace publishable key

curl -X POST https://events.meshes.io/api/v1/events \
  -H "X-Meshes-Publishable-Key: WORKSPACE_PUBLISHABLE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "event": "contact.created",
    "payload": {
      "id": "lead_123",
      "email": "jane@example.com",
      "first_name": "Jane",
      "last_name": "Doe",
      "source": "marketing-site",
      "tier": "pro"
    }
  }'

You should receive a 2xx response indicating the event has been accepted for processing.

Option B: JavaScript / TypeScript (Publishable Key)

Using the Meshes simple client SDK:

import { MeshesEventsClient } from '@mesheshq/events';

const meshesClient = new MeshesEventsClient(
  `${process.env.MESHES_WORKSPACE_PUBLISHABLE_KEY}`
);

async function sendContactCreated() {
  await meshesClient.emit({
    event: 'contact.created',
    payload: {
      email: 'jane@example.com',
      first_name: 'Jane',
      last_name: 'Doe',
      tier: 'pro',
      utm_source: 'google-ads',
    },
  });

  console.log('Event accepted by Meshes');
}

sendContactCreated().catch(console.error);

Option C: Server-side (Machine JWT)

If you’re emitting events from a backend service, you can authenticate using a machine JWT:

• Authentication

5. Verify Delivery in the UI

1. In the Meshes dashboard, open your workspace.
2. Navigate to Events.
3. Find the contact.created event you just sent.
4. Inspect:
   • Overall event status
   • Per-destination status (your Demo Webhook)
   • Any retries or error messages

If you used a webhook test service, you should also see the incoming HTTP request, including the payload Meshes sent.

Next Steps

After you’ve sent your first event:

• Add additional destinations (e.g., HubSpot + Mailchimp) to see true fan-out.
• Introduce conditions (e.g., only send to Mailchimp when tier = "starter").
• Create multiple workspaces (e.g., acme-dev vs acme-prod) to explore multi-tenancy.
• Check your usage in the dashboard to understand how events and limits are tracked.
• Sending events from a browser/mobile app? Use a publishable key. Managing resources via API? Use the private API with a server-side JWT.

You now have the basics: workspace → connection → event type → rule → event → delivery.

Learn More

• Publishable Keys: client-safe keys for event ingestion
• Send Events: emit a single event
• Bulk Event Ingestion: emit up to 100 events per request
• API Documentation: private management APIs (server-side JWT)