Webhooks + email · Instant start · Agent-ready

One engine.
Both doors.

Anything that arrives — a webhook or an email — becomes a reliable event: durably stored before we even say 200, verified, delivered with retries, and replayable.

⇲ Webhooks in + ✉ Email in ⇗ Delivered out
Stored before ack <100ms edge ack retries + dead-letter Region-flexible
How Emithook receives and delivers webhooks and email Events arrive over HTTPS, a queue you write to, inbound email, or the Send API. They flow into the Emithook engine, where each is signed, routed and retried, then delivered to HTTPS endpoints, queues, or an application's subscribers. 🌐HTTPS/<slug> 📥QueueSQS · Kafka · … 📧Email@in.emithook Send APIPOST /v1/send Emithook one engine 🌐HTTPSyour URL 📨QueueSQS · Pub/Sub 👥Subscribersfan-out events → → delivered RECEIVE SIGN & ROUTE DELIVER
Don't take our word for it — prove it in 10 seconds.

Click once, get a live webhook URL and email address, curl it, watch it arrive. emithook.com → try → curl → delivered

Prove it →
Works with every provider
WhatsAppShopifyStripeRazorpaySlackGitHubTwilioZoho
The problem

Events are harder than they seem.
Email is worse.

Lost events, silent failures, nothing to replay when a customer asks “where’s my order?” — and when the same order arrives as an email, your webhook tooling can’t even see it. Today that’s three vendors and glue code.

A webhook gateway

catches your webhooks — but knows nothing about the emails carrying the same business events.

An email-parsing API

POSTs the mail once and shrugs — no retries, no replay, no delivery guarantees, no log to debug from.

A send-webhooks service

pushes your events out — on yet another dashboard, signature scheme and retry policy to learn.

Emithook is all three on one engine — one log, one replay, one retry policy, one place to look when something breaks.

One engine, every door

Receive webhooks. Receive email.
Send anywhere.

However an event reaches you — or leaves you — it rides the same pipeline: stored, verified, routed, retried, logged, replayable.

Webhooks in

Give providers a stable URL — we ack in <100ms and route to your systems. Be down for hours, lose nothing.

  • HTTPS edge or a queue you already write to
  • Provider presets: signature verify + handshakes
  • Zero-setup domain, or bring your own
  • Durable buffer, full audit, one-click replay

Email in

Give anything an email address. Incoming mail becomes a normal event — same delivery, retries and logs as a webhook.

  • Unlimited addresses on your domain or ours
  • SPF / DKIM / DMARC verdicts on every message
  • Attachments ride as claim-check links
  • An inbox your AI agent can read over MCP

Delivery out

Push your own events as webhooks-as-a-service — to a URL, a queue, or every subscriber of an application.

  • Send API + per-tenant fan-out
  • Standard Webhooks signing receivers trust
  • Backoff retries, circuit breaker, dead-letter
  • Consumer portal & delivery logs
How teams use it

Three delivery patterns, zero infra

01 · Fan-out

One event → many destinations

An event always goes to the same set of endpoints. Define the routes once.

02 · Per-tenant

Same event → each tenant's URL

Register customers as applications. POST /v1/app/{tenant}/event resolves their destinations.

03 · Direct send

Just deliver this payload

Ad-hoc POST /v1/send to a URL or queue — we handle slow endpoints, retries and DLQ.

The founding guarantee

Config can never drop a webhook.
Neither can we.

Ingest is architecturally separate from everything else: every request is written to a durable queue before the sender gets its 200. Processing, delivery, your configuration — even our own deploys — happen after that, and none of them can lose what's already stored. Miss nothing; replay anything, for 14 days.

ingest — what happens before you get a 200
# POST https://wh.emhk.in/acme/orders received edge, t+0ms stored durable queue, replayable 200 returned sender is done ──── everything below can fail safely ──── → verified · transformed · delivered ×8 retries → dead-letter if exhausted — replayable
Stored
before the 200, always
0
retries over ~28h + DLQ
0
edge ack p99
0
replay window
The Emithook console dashboard — event volume by source, delivery KPIs, a needs-attention panel and per-route health
One dashboard — volume across every source, per-route health, and what's degrading right now, one click from replay.
Progressive disclosure

Simple enough for your PM.
A swiss-knife for you.

Every other tool in this category assumes a developer is driving. Emithook's console is simple by default — and one Advanced toggle away from the full toolkit.

🧭

Simple, by default

Three answers and you're live — no webhook expertise required.

  • Who sends to this URL? Pick the provider — verification and handshakes arm themselves
  • Paste the signing secret — we know each provider's headers and algorithms
  • Pick a destination — retries, backoff and logs are automatic
🛠

Advanced, one toggle away

Flip the switch and the whole engine is yours.

  • Custom responses, provider handshakes & sync proxy mode
  • JS transforms (sandboxed) or your own HTTP transformer
  • Generic HMAC, replay tolerance, zero-downtime secret rotation
  • Per-route filters and the full retry schedule
The Emithook console endpoint page in simple mode — provider, secret and destination, nothing else
The real console, simple mode — three questions, live endpoint. Flip Advanced for the rest.
Batteries included

Everything reliable delivery needs

The reliability layer you'd otherwise build and maintain yourself.

🔁

Retries, DLQ & replay

Exponential backoff with jitter (immediate → 5s → … → ~28h), then a replayable dead-letter queue. Replay one, in bulk, or from the archive.

🔐

Signed payloads

Standard Webhooks HMAC with zero-downtime secret rotation.

🛡

SSRF-guarded

DNS-pinned, private-IP denylist, no redirects, isolated egress.

🧯

Circuit breaker

Auto-pause dead endpoints, park events, probe & recover.

🧭

Guided destinations & central registry

Define a destination once, reference it everywhere. Connect any queue via a step-by-step flow that hands you the exact IAM grant — no shared keys.

🌐

Zero-setup domains

Live instantly on our domain — bring your own with auto-TLS.

🗂

Logs & archive

Every attempt logged; gzipped hourly files per URL for export.

Developer-first & agent-native

For your terminal, your code,
and your AI agents

Everything is one scoped API. The console, CLI, SDKs and an MCP server all do the same things — so an LLM can query deliveries and run ops, safely.

🤖

MCP server

Connect Claude, Cursor or your own agent. Reads are safe by default; writes (replay, rotate secret) need a write key & confirmation.

Full CLI

Operate & query from the terminal or CI — logs, replay, send, DLQ redrive. Scriptable, JSON output.

📦

TypeScript SDK

One typed client for send + management today; more languages on the roadmap — or generate a client from the OpenAPI spec. Receivers verify with the open Standard-Webhooks libraries.

// deliver one payload to a destination
await fetch("https://api.emithook.com/v1/send", {
  method: "POST",
  headers: { Authorization: `Bearer ${EK_KEY}`,
             "Idempotency-Key": invoiceId },
  body: JSON.stringify({
    destination: "dst_acme",
    event_type:  "invoice.created",
    payload:     { amount: 4999, currency: "INR" }
  })
});  // → 202 { message_id }
// fan out to a tenant's subscribed endpoints
await emithook.app("acme").send({
  event_type: "invoice.created",
  payload: { id: "INV-2026-001", amount: 4999 }
});
// → delivered to every endpoint on invoice.*
//   each signed, retried & logged independently
// receivers verify with the open Standard Webhooks lib
import { Webhook } from "standardwebhooks";

const wh = new Webhook(process.env.WHSEC);
app.post("/hooks", (req, res) => {
  const evt = wh.verify(req.rawBody, req.headers); // throws if invalid
  handle(evt);
  res.sendStatus(200);
});
# operate & query from your terminal
npm i -g @emithook/cli
emithook replay --dlq --endpoint /razorpay-live
emithook send -d dst_acme -t invoice.created -f body.json
# same scoped API powers console, CLI & MCP

Standard Webhooks compliant, on the wire

Every payload we sign verifies with the open standardwebhooks libraries — no proprietary SDK required to receive from us, ever. Open contracts over lock-in.

Read the spec →
FAQ

Questions, answered

What is Emithook?
The event front door: infrastructure that receives webhooks and email, and sends webhooks — one engine with signing, retries, dead-letter queues, logs and one-click replay. Every event is durably stored before it's acknowledged. The reliability layer you'd otherwise build yourself.
Does it handle both inbound and outbound?
Yes. Emithook receives & relays inbound webhooks (via HTTPS or a queue you write to) and sends outbound webhooks as a service — including fan-out to an application's subscribers — on the same delivery engine.
Can I try it without an account?
Yes — get an instant endpoint: a webhook URL and an email address on one id, no signup. Send anything to either and watch it arrive live. Claim it later and the URL, address and history become yours to keep.
Is it LLM / AI-agent friendly?
Yes. Emithook ships an MCP server alongside a full CLI and SDKs over one scoped API, so AI agents can query deliveries and run operations like replay — with write actions gated behind confirmation.
Can it turn inbound email into webhooks — and can an AI read it?
Yes to both. The built-in MX engine gives you unlimited addresses (your domain or ours). Incoming mail is parsed, SPF/DKIM/DMARC-verified, shown in an inbox, and delivered as an event — and it's LLM-readable via MCP, so an agent can read and act on its own mail.
How fast can I start — do I need DNS?
No setup. You're live in seconds on our dedicated ingest domain — a webhook URL and an email address, already TLS- and DKIM-ready. Bringing your own domain is optional, for branding.
Where is my data stored?
You choose your region. The managed cloud is multi-region by design — India (AWS ap-south-1) is available today, with more regions coming.

Give every event a front door.

Your instant endpoint is one click away — a webhook URL and an email address, live right now, no signup.