PraetoManaged Technical Services
DocsRequest Access
v1 — webhook delivery infrastructure

Reliable webhook delivery for modern SaaS.

Praeto Dispatcher handles event delivery, retries, replay, signing, dead-letter handling, observability, usage limits, and safety controls so your team does not have to build webhook infrastructure from scratch.

Request Access View Docs

Built by Praeto Managed Technical Services for SaaS teams that need reliable, secure, customer-facing webhooks.

dispatcher.praeto.dev
Delivered
99.94%
In-flight
1,284
Retries
37
Recent deliverieslive
del_028aorder.created
142ms200
del_028bsubscription.updated
98ms200
del_028cinvoice.paid
311msretry
del_028duser.created
76ms200
Product under Praeto

Dispatcher is one product under Praeto Managed Technical Services.

Praeto builds technical automation and infrastructure. Dispatcher is the hosted webhook delivery product for teams that need reliable event fan-out, customer visibility, and operational controls.

Available now

Praeto Dispatcher

Hosted webhook delivery API with retries, DLQ, replay, HMAC signing, endpoint health, metrics, usage limits, and safety controls.

Read Dispatcher docs →
The problem

Webhooks are simple until they fail.

A customer endpoint goes down. A request times out. A payload gets retried twice. Nobody knows whether the event was delivered, replayed, failed, or silently dropped.

Most teams start with a basic HTTP POST and eventually rebuild the same delivery system: queues, retries, logs, signing, idempotency, replay, usage limits, and support tools.

Features

Webhook infrastructure without the rebuild.

Praeto Dispatcher gives your product the reliability layer customers expect once webhooks become part of real business workflows.

↗

Durable delivery

Publish once. Praeto queues, fans out, retries, and records every delivery attempt for subscribed endpoints.

↻

Retries + backoff

Transient failures are retried with controlled backoff and clear terminal states for non-retriable responses.

☷

Dead-letter queue

Failed deliveries are retained for inspection and replay instead of silently disappearing into logs.

⌁

Signed webhooks

Outbound requests include timestamped HMAC signatures so customers can verify authenticity.

◐

Secret rotation

Rotate endpoint signing secrets with overlap windows so customer integrations do not break during key changes.

⌘

Endpoint health

Track success rate, failure rate, recent status codes, pending deliveries, and dead-letter counts.

▶

Replay tools

Replay individual deliveries after a customer fixes their endpoint or requests a resend.

▣

Usage + safety limits

Measure current usage and enforce payload, fan-out, endpoint, and request-rate limits before they become incidents.

How it works

One API call. Reliable delivery behind the scenes.

1

Publish an event

Your application sends a single request to Praeto Dispatcher with an event type and JSON payload.

2

Praeto queues delivery

The event is matched against active subscribed endpoints and written to durable delivery records.

3

Customers receive webhooks

Each destination receives a timestamped, signed webhook request with retry-safe delivery semantics.

4

You get visibility

Inspect events, deliveries, attempts, failures, usage, endpoint health, and replay history from the API.

Publish an eventhttps://api.praeto.dev
curl -X POST https://api.praeto.dev/v1/events \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Idempotency-Key: order-123-created" \
  -H "Content-Type: application/json" \
  -d '{
    "event_type": "order.created",
    "payload": {
      "order_id": "ord_123",
      "customer_id": "cus_456",
      "total": 149.00
    }
  }'
Customer setup

Go from API key to first delivery in minutes.

Dispatcher is built to be easy for technical customers to validate quickly: create an endpoint, store the signing secret, send a test event, inspect attempts, and replay failures when needed.

1

Create endpoint

Register a customer webhook URL and subscribe it to the event types it should receive.

2

Store secret

Save the returned signing secret and use it to verify Praeto webhook requests.

3

Publish event

Send a single authenticated event request with an idempotency key.

4

Inspect + replay

Use delivery, attempt, health, usage, and replay APIs to debug customer issues fast.

Start with the docs Request API access
Reliability + safety

Built for the parts of webhooks that usually break.

When a customer says “we never got the webhook,” you should not have to guess. Praeto gives you visibility into events, delivery status, response codes, retry counts, dead-lettered deliveries, endpoint health, monthly usage, rate limits, and replay history.

  • Idempotency keys prevent duplicate event creation during publisher retries.
  • SSRF protection blocks localhost, private networks, metadata IPs, embedded credentials, and unsupported protocols.
  • Circuit breakers automatically disable endpoints that repeatedly fail with no successful deliveries.
  • Retention cleanup keeps old event and delivery history from growing forever.
  • Rate limits and fan-out limits protect the platform from accidental floods and abusive usage.
Pricing

Simple pricing for early teams.

Start small, validate your integrations, and scale delivery volume when customers depend on it.

Free

$0 /mo
  • 10,000 delivery attempts
  • Signed webhooks
  • Endpoint health
  • Replay support
  • 7-day retention

Starter

$29 /mo
  • Higher delivery volume
  • Longer retention
  • Usage visibility
  • DLQ + replay tools
  • Priority onboarding

Growth

Custom
  • Custom limits
  • Advanced observability
  • Higher fan-out
  • Longer retention
  • Support options

Stop rebuilding webhook infrastructure.

Praeto Dispatcher gives your team reliable delivery, secure signing, replay tools, DLQ handling, usage limits, and customer-ready observability.

Request Access Read the Docs