Stop Building Webhook Infrastructure

Every SaaS platform with an API eventually needs webhooks. And every team that builds them goes through the same painful journey: store a URL, POST a JSON payload, maybe retry once on failure. Ship it. Move on.

Six months later, a customer says they missed a critical event. Your retry queue is backed up because one broken endpoint is consuming all the capacity. You have no delivery logs, no circuit breakers, and no way to answer "did this webhook actually get delivered?"

We built this infrastructure for Zyphr's own notification platform. Now we're making it available to every developer who needs webhook delivery for their product.

What is Webhooks-as-a-Service?

WaaS lets you power webhook delivery for your platform's customers using Zyphr's battle-tested infrastructure. Instead of building retry logic, circuit breakers, signature verification, delivery logging, and endpoint management from scratch, you define your custom event types, publish events via a single API call, and Zyphr handles everything else.

How it works

1. Create an application

Each WaaS application represents a product or service that publishes events. A single Zyphr workspace can have multiple applications.

import { Zyphr } from '@zyphr-dev/node-sdk';

const zyphr = new Zyphr({ apiKey: 'zy_live_xxx' });

const app = await zyphr.waas.applications.createWaaSApplication({
  name: 'Acme Commerce',
  slug: 'acme-commerce',
});

2. Register your event types

Define the events your platform publishes. Include example payloads so your customers know what to expect.

await zyphr.waas.eventTypes.createWaaSEventType(app.id, {
  eventType: 'order.created',
  name: 'Order Created',
  category: 'orders',
  description: 'Fired when a new order is placed',
  examplePayload: {
    order_id: 'ord_abc123',
    total: 99.99,
    currency: 'USD',
    items: [{ sku: 'WIDGET-01', quantity: 2, price: 49.99 }],
  },
});

3. Create endpoints for your customers

When your customers want to receive webhooks, create an endpoint scoped to their tenant ID. Zyphr generates a signing secret they'll use to verify payloads.

const endpoint = await zyphr.waas.endpoints.createWaaSEndpoint(app.id, {
  tenantId: 'cust_abc123',
  url: 'https://customer.com/webhooks',
  events: ['order.created', 'order.shipped'],
});

// endpoint.secret = 'whsec_...' — give this to your customer

4. Publish events

One API call triggers delivery to all subscribed endpoints for that tenant. Delivery is asynchronous -- Zyphr queues it immediately and returns a summary.

const result = await zyphr.waas.events.publishWaaSEvent(app.id, {
  eventType: 'order.created',
  tenantId: 'cust_abc123',
  data: {
    order_id: 'ord_456',
    total: 99.99,
    currency: 'USD',
  },
  idempotencyKey: 'order-ord_456-created',
});

// result.endpointsMatched = 2
// result.deliveriesCreated = 2

That's it. Four steps from zero to production webhook delivery.

What happens after you publish

When you call publishWaaSEvent, Zyphr's delivery pipeline takes over:

1. Validate the event type exists and is active
2. Check idempotency to prevent duplicate deliveries
3. Find matching endpoints for the tenant and event type
4. Queue deliveries to RabbitMQ for async processing
5. For each endpoint, the worker:

   • Checks the circuit breaker state
   • Applies rate limiting
   • Builds a versioned envelope with event metadata
   • Signs the payload with HMAC-SHA256
   • Delivers via HTTP POST
   • Records the full request/response
   • On failure: schedules retry with exponential backoff
   • After all retries exhausted: routes to dead-letter queue

Your customers receive a signed payload that follows the Standard Webhooks spec:

POST https://customer.com/webhooks
Headers:
  webhook-id: msg_abc123
  webhook-timestamp: 1709380800
  webhook-signature: v1,K3xz...
Body:
  {
    "id": "evt_xxx",
    "type": "order.created",
    "api_version": "2026-02-01",
    "created_at": "2026-03-06T12:00:00Z",
    "data": { "order_id": "ord_456", "total": 99.99 }
  }

The embeddable portal

Most webhook providers force your customers into a separate dashboard. With WaaS, you can embed a full webhook management UI directly into your product using the @zyphr-dev/webhook-portal React component.

import { WebhookPortal } from '@zyphr-dev/webhook-portal';

function CustomerSettings() {
  return (
    <WebhookPortal
      token={portalToken}
      theme={{ mode: 'dark', accent: '#6366f1' }}
      onEndpointCreated={(ep) => console.log('Created:', ep)}
    />
  );
}

The portal gives your customers:

• Event type browser with descriptions and example payloads
• Endpoint management (create, edit, pause, delete)
• Event subscription picker
• Delivery log viewer with retry capability
• Test event sender
• Secret rotation with reveal-once UI

Generate a portal token scoped to a specific tenant:

const portal = await zyphr.waas.portal.generateWaaSPortalToken(app.id, {
  tenantId: 'cust_abc123',
  allowedEventTypes: ['order.*', 'payment.*'],
  expiresIn: 3600,
  theme: { mode: 'dark', accent: '#6366f1' },
});

Why not build it yourself?

You can. But here's what "just add webhooks" actually looks like once you need production reliability:

• Retry logic with exponential backoff and configurable intervals
• Circuit breaker to stop hammering broken endpoints
• Rate limiting per endpoint to respect customer infrastructure
• HMAC signing with secret rotation and dual-signing during rotation windows
• Delivery logging with full request/response capture and retention policies
• Dead-letter queue for exhausted deliveries
• Idempotency to prevent duplicate event processing
• Multi-tenant isolation so one customer's broken endpoint doesn't affect others
• Monitoring with health scores, failure rate tracking, and alerting

That's months of engineering. Or one API integration.

What's next

WaaS is live today on all Zyphr plans. The free tier includes 1 application, 5 event types, 10 endpoints, and 1,000 events per month -- enough to build and validate your webhook integration before scaling.

Coming soon:

• Event replay -- replay events within a date range to an endpoint
• Payload transformations -- transform payloads before delivery
• Analytics dashboard -- charts, trends, and success rate visualization

Get started with WaaS | API Reference | View pricing