An order is paid. The warehouse needs to know, accounting needs to know, and the team channel wants a message. The payment provider sends one webhook to one address, so someone writes a small service that receives it and forwards it three times.
That service works until accounting's API is down for an hour. Then it either retries inline and holds up the warehouse copy, or gives up and the accounting copy is gone. Nobody notices until month end.
You can fan the webhook out without writing that service. Point the provider at one EchoRelay endpoint and add a target for each service. Each one gets its own copy, its own credentials, its own retries, and the shape it expects.
Set it up in five steps
1. Create an endpoint. An endpoint is the address the provider sends to, together with the list of places each request goes. On a line called v1, an endpoint orders-paid that accepts POST answers at https://<your-project>.echorelay.cloud/v1/orders-paid.
2. Give the provider the address and an API key. The provider sends the key as Authorization: Bearer or in an X-Api-Key header. Some providers only let you paste a URL. For those, the key can go in the address as ?api_key=. Prefer a header where you can, because URLs end up in logs. Mint a separate key for each provider, so you can rotate one without touching the others.
3. Add one queued target per service. A target is one place a request is delivered to. Queued means the provider gets an accepted response at once and delivery happens in the background, which is what a webhook sender wants. Give each target the auth that service expects. If it is a partner's key, save it in the credential vault and reference it, so the key lives in one place.
4. Reshape where a service wants a different body. The warehouse may want the whole order and the team channel only a sentence. A mapping on the channel's target builds that sentence from the provider's fields, and the other targets still get the original. How mapping works covers the details.
5. Try it, then publish. Changes collect in a draft. Run a sample payload through the draft to see what each target would receive, without anything being sent, then publish. Send one real test from the provider and open its delivery receipt: there is one delivery per target, each with its own status.
One slow service no longer holds up the others
Each target is delivered on its own. If accounting answers with an error that is worth retrying, only accounting is retried, with a longer wait before each attempt than the one before, and the warehouse and the channel have already been delivered. The retry schedule, and which statuses count as temporary, are set per target, so a partner with strict rate limits can be retried more gently than your own service.
If accounting still has not accepted it after the last retry, the delivery waits in Held for retry. That entry belongs to the accounting target alone. Retry it once accounting is back and only accounting receives it again. Nothing is sent twice to the warehouse to get one copy through to accounting.
Adding a service is a target, not a deploy
Next quarter the CRM wants paid orders too. You add a fourth target to the same endpoint and publish. The provider's webhook settings do not change, nothing is deployed, and the other three targets carry on untouched. Taking a service away is the same edit in reverse.
If the sender needs an answer in the same call, one target on the endpoint can be synchronous. Its reply goes back to the sender while the queued targets are delivered in the background. An endpoint has at most one synchronous target, because a sender can only receive one answer.
What to build on the receiving side
Two things, and neither is new if you have received webhooks before. Delivery is at least once, so a target can occasionally see the same request twice; on a signed target, deduplicate on the webhook-id header. And there is no delivery order, so if order matters, sort on a timestamp or sequence number in the body.
Each target counts as one delivery, so a request fanned out to three services is three deliveries. The pricing page has the current rates.
What you no longer run
The forwarder was a service with its own deploy, its own queue, and its own on-call page for when a downstream API had a bad hour. With fan-out configured, the service that received the webhook no longer exists. Adding a consumer of the event is a change in the panel, a retry storm at one partner stays with that partner, and the copy that failed can be found and sent again. See how fan-out works.