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:

DestinationConditions
Production APINone: everything
Staging APIbody.livemode equals false
Analyticsbody.type starts with invoice.
Slack channelbody.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:

Added to every delivery
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: 1

The 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.

Keeping it runningA free URL lives for up to 7 days, which is enough to build this and prove it works. To leave it in place, a Pro pass keeps the same URL alive for 30 days ($3) or 1 year ($19). It is a single payment, not a subscription, and nothing has to be reconfigured at the sender.

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.