EventInbox ingests, queues, signs, retries and delivers every event from your stack to every endpoint — with replay, observability and durable delivery with idempotency built in.
Stop building the same brittle webhook plumbing in every service. EventInbox is the durable layer your whole event pipeline runs through.
Every inbound event is persisted the instant it lands. Buffer through traffic spikes and downstream outages without dropping a single payload.
Learn more →Exponential backoff with jitter, circuit breaking and per-endpoint rate limits. Failed deliveries recover automatically — up to 12 attempts over 72 hours.
Learn more →HMAC signatures and rotating secrets on every request. Your consumers verify authenticity in one line — replay attacks and spoofing closed off by default.
Learn more →Every attempt, payload, header and response code — searchable and live. Trace exactly what happened to any event without grepping a dozen log streams.
Learn more →Re-deliver a single event, a time window, or an entire endpoint with one click or one API call. Ship a bug fix and replay the day it was broken.
Learn more →eventinbox listen tunnels production events straight to localhost. Build and debug webhook handlers without deploying or ngrok.
Learn more →Point your producers at EventInbox, register endpoints, and let the platform handle the hard parts. SDKs for every runtime you ship.
Fire-and-forget from any producer. EventInbox persists it immediately and returns an ID.
Subscribe consumers to event types. Fan one event out to many destinations.
Validate the signature and process. We retry until you return 2xx.
Watch deliveries live in the dashboard and replay anything that failed.
import { EventInbox } from "eventinbox"; const ei = new EventInbox(process.env.EI_KEY); // fire an event — persisted & delivered durably await ei.events.send({ type: "payment_intent.succeeded", data: { id: "pi_3kf9", amount: 4200 }, }); // → evt_8a2f · queued to 3 endpoints
from eventinbox import EventInbox ei = EventInbox(os.environ["EI_KEY"]) # fire an event — persisted & delivered durably ei.events.send( type="payment_intent.succeeded", data={"id": "pi_3kf9", "amount": 4200}, ) # → evt_8a2f · queued to 3 endpoints
ei := eventinbox.New(os.Getenv("EI_KEY")) // fire an event — persisted & delivered durably ei.Events.Send(ctx, eventinbox.Event{ Type: "payment_intent.succeeded", Data: M{"id": "pi_3kf9", "amount": 4200}, }) // → evt_8a2f · queued to 3 endpoints
curl https://api.eventinbox.com/v2/events \ -H "Authorization: Bearer $EI_KEY" \ -d '{ "type": "payment_intent.succeeded", "data": { "id": "pi_3kf9", "amount": 4200 } }' # → { "id": "evt_8a2f", "endpoints": 3 }
Exponential retries with jitter across 72 hours. Endpoints heal and pick up exactly where they left off — in order, with idempotency keys.
Anything that exhausts retries lands in a dead-letter queue with a full attempt trace, and pings your on-call before customers notice.
Fix the bug, then replay the dead-letter queue — a single event or an entire window — straight from the dashboard or API.
A homegrown queue gets you 60% of the way — then eats a quarter of your roadmap on the long tail of failure modes.
| Capability | DIY queue + cron | EventInbox | Generic queue |
|---|---|---|---|
| Durable, ordered delivery | partial | ✓ built-in | partial |
| Durable at-least-once + idempotency keys | ✕ | ✓ | ✕ |
| Retries with backoff & jitter | hand-rolled | ✓ | manual |
| Signed payloads & rotation | ✕ | ✓ | ✕ |
| Per-event observability | grep logs | ✓ live | ✕ |
| Replay & backfill | ✕ | ✓ 1-click | ✕ |
| Local dev forwarding | ngrok | ✓ native | ✕ |
| Time to production | weeks | minutes | days |
Every plan includes durable delivery, retries, signing, replay and observability. You only pay for the events you actually send.
Overage: from $1.50 per additional 100K events. Annual plans save 25%.
Our SDKs, CLI and signature-verification libraries are MIT-licensed. Read the source, file an issue, send a PR.
Start free in under five minutes. No credit card, 100k events on us every month.