Technique
How to Forward One Webhook to Multiple URLs
Many services let you register exactly one webhook URL, or make each extra one a chore. Then a second system needs the same events: staging, a replacement you are migrating to, a colleague's environment, a channel. A relay in front turns one URL into several.
17 November 2026 · 3 min read
When you need this
- Production and staging. Staging should see real event shapes, and the provider only has one slot.
- A migration. The old handler and the new one run side by side until you trust the new one.
- Several consumers. Billing wants the event, analytics wants the event, and neither should depend on the other forwarding it.
- An API and a human. Your service gets the untouched webhook, and a channel gets a readable line about it.
How the fan-out works
You register one webhook.stream URL with the provider. Each destination is an automation on that URL. When a request arrives, every automation whose conditions match runs, in parallel and independently: one slow or failing destination does not hold up the others, or the answer to the provider.
Step 1: relay the request unchanged
Open Automations and choose Forward to my API. Enter the destination URL. This preset does two things that matter:
- It sends the original body, byte for byte, not a re-serialised copy.
- It passes along the sender's headers, signature header included.
Together those mean your existing handler can verify the signature exactly as if the provider had called it directly, with the same signing secret. Nothing in your code changes.
Add the same automation again for each further destination.
Step 2: narrow what each destination receives
Destinations do not all have to get everything. Each automation has its own conditions:
| Destination | Conditions |
|---|---|
| Production API | None: everything |
| Staging API | body.livemode equals false |
| Analytics | body.type starts with invoice. |
| Slack channel | body.type equals charge.dispute.created, with a message template |
This is also how you send different providers to different places through one URL. Anything after the ID in the webhook URL is recorded as the path, so you can register …/your-id/stripe with one service and …/your-id/github with another, then filter on request.path.
Step 3: check the deliveries
Each captured request has a Deliveries tab listing every attempt it caused: which automation, the status code, how long it took and the start of the reply. If staging returns 401 while production returns 200, you see both on the same screen as the request that triggered them.
What the destination sees
Besides the provider's own headers, every delivery carries headers that identify the relay:
User-Agent: webhook.stream/1.0
X-Webhook-Stream-Endpoint: <the URL that received it>
X-Webhook-Stream-Request: <the captured request>
X-Webhook-Stream-Hop: 1The request ID is handy for de-duplication and for tracing a delivery back to the capture. The hop header prevents loops: a request that arrives already carrying it is recorded but never forwarded again.
Things worth knowing
- The provider's retry logic no longer sees your server. The relay answers the provider at once with a 2xx. If your API then fails, the provider does not know, and will not retry. The failure is in the delivery log, but nothing re-sends it for you.
- Deliveries are at-most-once. For a consumer that must never miss an event, keep a direct registration with the provider where you can, and use the relay for the extra consumers.
- URL-signing schemes. Twilio signs the destination URL together with the parameters, so its signature will not verify at a forwarded address.
- Destinations must be public HTTPS on the standard port. Private addresses and redirects are refused.
- Budgets are per URL. Each delivery counts, so three destinations use three deliveries per request. Free URLs get 1,000 a day; a pass raises that to 10,000.
And for a server on your own machine
Automations cannot reach localhost. For that there is a separate path: every URL exposes its requests as a stream, and a one-line forwarder replays them against a local server. It runs alongside your automations, so production keeps receiving while you debug the same events locally. See testing webhooks locally.
Put one URL in front
Create a URL, add a forward to your existing endpoint and confirm signatures still verify. Then add the second destination.
Questions
Will signature verification still work at the destinations?
Yes, when you forward the original body and pass along the sender's headers. The bytes and the signature header arrive unchanged. The exception is schemes that sign the URL as well as the body, such as Twilio, because the destination's URL is different from the one the sender signed.
How many destinations can one webhook URL forward to?
A free URL can have 3 automations and a URL with a Pro pass can have 10. Each automation delivers to one destination.
Are forwarded webhooks retried if a destination is down?
No. Each attempt is logged with its status and timing, and failed attempts are not retried. An automation pauses after 15 consecutive failures.
Can I forward to localhost?
Not with an automation, which only delivers to public HTTPS URLs. Use the stream forwarder instead: one command replays incoming requests against a server on your machine.
Keep reading
Transform a webhook payload
Reshape webhook JSON into the payload another API expects using a template: pick fields, keep types, set defaults and format values, with a live preview against a real request.
ReadThe webhook glue server you keep rewriting
Every team has a tiny service that receives a webhook, reformats it and calls another API. The code is twenty lines; running it is the real cost. When to keep writing it and when not to.
Read