A webhook often starts out as a small feature. After an order is paid or a booking is confirmed, your backend makes an HTTP POST to another service. Done.
Then the receiving service goes offline for a few minutes. A request times out. An event is delivered twice because the receiver processed it but the acknowledgement never made it back. Suddenly, that simple HTTP request needs a queue, retries, signatures, delivery history and a way to investigate failures.
Why I Built Hookstride
I've been working on Hookstride because I wanted a more focused way to handle that delivery infrastructure.
I was using a payment gateway that allowed me to configure only one webhook destination. The problem was that I had multiple projects and wanted to use the same verified payment gateway account across them.
I needed a way to receive those webhook events and forward them to the appropriate applications without constantly changing webhook URLs or building separate workarounds for every project.
So I started building a solution for myself.
As I worked on it, I realized this wasn't necessarily a problem unique to me. Other developers managing multiple applications could run into similar limitations.
That got me thinking: why keep this solution to myself when other developers could benefit from it?
That's how Hookstride started. What began as a way to route webhooks between my own projects grew into a platform for reliable event delivery, with automatic retries, signed requests, delivery logs, replay, and more.
Where webhook implementations get tricky
1. An HTTP request succeeding isn't the same as the business action succeeding. A 2xx response means the receiver acknowledged the request. Make sure your receiver records the event durably before it acknowledges it.
2. A timeout doesn't tell you whether the receiver processed the event. Your sender may retry, and your receiver must be prepared for duplicates. Webhook deliveries should be designed for at-least-once, not assumed to be exactly-once.
3. Retrying immediately can make failures worse. Use bounded retries with backoff, and preserve enough information to diagnose permanently failing destinations.
4. Security isn't optional. If the receiver cannot verify the request signature, anyone who knows its URL may try to send it forged events.
Sending an event through Hookstride with Python
In this example, a booking has already been committed in your application. You have configured an HTTPS receiving endpoint as a Hookstride destination and generated a project API key.
import os import requests def send_booking_confirmed(booking_id: str) -> dict: response = requests.post( "https://api.hookstride.com/api/v1/events/", headers={ "Authorization": f"Bearer {os.environ['HOOKSTRIDE_API_KEY']}", "Idempotency-Key": f"booking-{booking_id}-confirmed", }, json={ "endpoint": os.environ["HOOKSTRIDE_ENDPOINT_ID"], "event_type": "booking.confirmed", "payload": {"booking_id": booking_id, "status": "confirmed"}, }, timeout=10, ) response.raise_for_status() return response.json() This is a simplified submission example, not a complete durable-outbox implementation. Run submission outside the user's request path when appropriate. If sending the event to Hookstride fails or times out, retry the submission with the same idempotency key. For stronger guarantees from your own database to Hookstride, use a transactional outbox or equivalent durable task.
Once the API accepts the event, Hookstride stores it, schedules delivery, signs its outbound request, records delivery attempts and retries eligible transient failures. You can inspect the result and replay terminal events through the dashboard.
The receiving side still matters
Hookstride does not run your business logic. Your receiver needs to:
- Read the raw request bytes.
- Check
X-Webhook-Timestampfor freshness. - Verify
X-Webhook-Signatureusing the destination's signing secret. The standard signature isv1=followed by the HMAC-SHA256 digest oftimestamp + "." + raw_body. - Confirm the signed envelope's
idandtypeagree with the identifying headers; don't trust an unsigned event ID on its own. - Store the verified event ID with a unique constraint and commit durable handling before returning
2xx. Process duplicate events safely.
This division of responsibility is important: your application decides what happened and how to handle it; Hookstride handles the outgoing delivery layer.
I'd value practical feedback
Hookstride has an API, CLI and dashboard, with a free tier for getting started. I'm looking for a few backend developers to try sending a real test event and tell me where the setup is confusing, what's missing from the docs, or what breaks in their workflow.
Explore it: https://hookstride.com
Quickstart: https://hookstride.com/docs#quickstart
If you've built webhook retries yourself, which part took more time than you expected?