If you have ever connected a form to a CRM or had a payment trigger an email, there was probably a webhook involved. This article offers webhooks explained in plain terms for founders and business owners: what they are, why they matter for automation, and what to check before you rely on them for anything important.
A one-sentence definition
A webhook is a message one app sends to a web address you choose, automatically, the moment something happens.
That is it. When a customer pays, a form is submitted or an order ships, the source app sends a small package of data (usually in JSON format) to a URL. Whatever is listening at that URL, an automation platform, your own server or another app, receives it and acts on it.
Webhooks explained through an analogy
Think of two ways to find out whether a parcel has arrived.
- Polling: you walk to the front door every ten minutes to check. Most trips are wasted, and you might still miss it for a while.
- Webhook: the courier rings the doorbell when they arrive. You only act when there is something to act on.
In software terms, polling means one app repeatedly asks another, “Anything new?” through its API. A webhook flips this: the source app pushes the news as soon as it happens.
Webhooks vs APIs: not either-or
People often ask whether they should use a webhook or an API. In practice they work together.
| Webhook | API request | |
|---|---|---|
| Who starts it | The source app, when an event happens | Your system, when it needs something |
| Direction | Pushed to you | Pulled by you |
| Typical use | “Tell me when an order is placed” | “Give me the full order details” or “Create an invoice” |
| Timing | Near real-time | Whenever you call it |
A common pattern is: a webhook tells you an event happened and includes an ID, then your automation calls the API to fetch full details or to update another system.
What a webhook message contains
A typical webhook is a short HTTP request with a few parts: the event type (for example, “order created”), an event ID, a timestamp, the relevant data such as order number and customer email, and often a signature in the headers that proves who sent it. You configure webhooks in the source app’s settings or developer area by entering the destination URL and choosing which events to send. Many apps also show a delivery log, which is invaluable when troubleshooting, because you can see whether an event was sent and what response came back.
Everyday business examples
- A payment processor notifies your system when a payment succeeds or fails, so you can unlock access or send a dunning email.
- A website form sends each submission to your CRM or an automation platform.
- An e-commerce store notifies your fulfillment or accounting tools when an order is created or refunded.
- A scheduling tool tells your CRM when a meeting is booked or cancelled.
- An e-signature service reports when a contract has been signed.
- A code repository notifies your deployment pipeline when new code is pushed.
What can go wrong
Webhooks are simple, but relying on them for business-critical flows means planning for a few realities:
- Your endpoint is down. If the receiving URL is unavailable, the event may be retried for a while or lost, depending on the provider. Check each provider’s retry behavior.
- Duplicates. Providers may send the same event more than once. Your receiver should recognize an event it has already processed (usually via an event ID) and skip it. This is called making the handler idempotent.
- Out-of-order delivery. An “updated” event can arrive before the “created” one. Design logic that can cope, for example by fetching the latest state from the API.
- Fake requests. Anyone who discovers your URL can send data to it. Most reputable providers sign their webhooks so you can verify the request genuinely came from them.
- Slow processing. Many providers expect a quick response. Acknowledge receipt fast, then do heavy work in the background.
Setting up a webhook safely: a checklist
- Use HTTPS for the receiving URL.
- Verify the signature or secret the provider includes with each request.
- Store the raw event before processing it, so you can replay it if something fails.
- Make processing idempotent using the event ID.
- Respond quickly and process in a queue or background job for anything slow.
- Subscribe only to the events you need.
- Log failures and alert someone when events stop arriving or keep failing.
- Document which webhooks exist, where they point and who owns them.
Testing before you go live
Most providers let you send a test event or replay a past one. Use this to confirm your receiver handles the data correctly, including edge cases like missing optional fields. Request-inspection tools can show you exactly what a provider sends before you build anything on top of it. Test failure too: switch off the receiver briefly and confirm you get alerted and that events are recovered when it comes back.
No-code or custom code?
Automation platforms like n8n, Make and Zapier can generate a webhook URL for you and let you build the follow-on steps visually. That is ideal for most internal workflows; our comparison of the three covers how they differ. Custom code makes sense when volumes are high, logic is complex or the webhook drives your product itself, such as unlocking paid features after a subscription payment. Real-time products often go further and use persistent connections like WebSockets, as we did for the voice companion in our Oryn project.
Need help wiring it together?
SiteWright Technologies builds integrations that use webhooks and APIs properly, with signature checks, retries and monitoring, whether in an automation platform or custom code. See our automation solutions or contact us to talk about the tools you want connected.


