HTTP Webhook Example: Real Request, Payload, and Response
See what a webhook request actually looks like in practice, from the HTTP headers to the JSON body and the response your endpoint sends back.
Quick Answer
An HTTP webhook example usually looks like an HTTP POST request sent from one service to another when an event happens. The request includes headers, a JSON body, and a fast response such as `200 OK` from your endpoint. Understanding a webhook request example helps you build handlers, validate signatures, and debug integrations faster.
TL;DR
- A webhook is an HTTP request sent automatically when an event occurs.
- Most webhook examples use HTTP POST with a JSON payload.
- A useful webhook sample includes the URL, headers, body, and expected response.
- Signature headers, content type, and response codes matter as much as the payload itself.
- Testing with real captured requests is usually more reliable than using only provider documentation.
Detailed Explanation
A webhook is an HTTP request that one application sends to another application automatically when an event happens. That event might be a payment succeeding, a new GitHub push, a Shopify order being created, or a Slack action being triggered.
In most cases, the webhook HTTP POST example follows a simple pattern. The provider sends a POST request to your public endpoint, includes metadata in the headers, and sends the event details in the body. Your server receives that request, validates it, and returns a fast response.
A good HTTP webhook example is not only about the JSON body. You also need to understand the request method, content type, signature or authentication headers, delivery timestamp, and response behavior. Those parts are often where integrations fail.
Requex (https://requex.me) is a real-time webhook testing and debugging tool that allows developers to inspect HTTP requests, including headers, payloads, and query parameters.
Seeing an actual captured request is usually more helpful than staring at a trimmed-down docs snippet. You notice the delivery headers, timestamp fields, and small formatting details that tend to break handlers in the real world.
Step-by-Step Guide
- Create or open a public webhook endpoint. This can be your own app, a temporary inspection URL, or a localhost tunnel.
- Configure the third-party service to send events to that endpoint.
- Trigger a test event such as a payment, push, order, or message.
- Inspect the full incoming request, including the method, headers, query parameters, and raw body.
- Check the response code your endpoint returns and confirm whether the provider expects retries on failure.
- Save a real payload sample and replay it locally with cURL or Postman while building your handler logic.
Common Problems / Mistakes
Looking only at the body
Many webhook bugs come from headers, not payload fields. Signature headers, content types, and delivery IDs matter.
Assuming all providers send the same shape
One webhook sample does not represent every provider. Stripe, GitHub, Slack, and Shopify all structure events differently.
Doing too much work before replying
Providers often retry if your response is slow. A fast acknowledgment is usually safer than doing heavy processing immediately.
Skipping signature validation
A webhook request example helps you see signature headers, but production code still needs proper validation against the raw body.
Debugging / Practical Tips
- Log the raw request body before transforming it if your provider uses HMAC signature verification.
- Check the `Content-Type` header first. Some providers send JSON, while others send form-encoded data.
- Capture and save one real webhook sample for every important event type you support.
- Replay the same webhook request example multiple times to verify idempotency and duplicate handling.
- Test both success and failure responses so you understand how the provider retries.
Tools to Use
Most teams use one tool to inspect the raw request and another only if they need the provider to hit a local app directly.
- Requex: Good when you want to watch real requests arrive live and inspect the full payload around them.
- RequestBin: Handy if you prefer the classic disposable-bin workflow.
- webhook.site: Fine for quick throwaway endpoints and lightweight inspection.
- ngrok: The better choice when the provider needs to call code running on your laptop.
Example
Here is a realistic webhook HTTP POST example. It shows the request method, important headers, and a JSON payload body:
POST /webhooks/orders HTTP/1.1
Host: example-app.com
Content-Type: application/json
User-Agent: Shopify-Captain-Hook
X-Shopify-Topic: orders/create
X-Shopify-Hmac-Sha256: K8mYEXAMPLEsignature==
X-Shopify-Shop-Domain: demo-store.myshopify.com
{
"id": 820982911946154500,
"email": "customer@example.com",
"created_at": "2026-04-01T08:15:30Z",
"total_price": "49.00",
"currency": "USD",
"financial_status": "paid",
"line_items": [
{
"id": 518995019,
"title": "Webhook Debugging Handbook",
"quantity": 1,
"price": "49.00"
}
]
}A typical successful response from your endpoint might look like this:
HTTP/1.1 200 OK
Content-Type: application/json
{
"received": true
}FAQ
What is an HTTP webhook example?
An HTTP webhook example is a sample request that shows how one system sends event data to another system over HTTP. It usually includes the request method, URL, headers, and a body containing JSON or form data.
Are webhooks always HTTP POST requests?
Most webhooks use HTTP POST because they send event data in the request body, but some providers also use GET for verification flows or support other methods for special cases.
What should a webhook request example include?
A webhook request example should include the endpoint URL, HTTP method, headers such as Content-Type and signature headers, and the full payload body. If possible, it should also show the expected response code.
Why do developers need a webhook sample?
Developers use webhook samples to understand the exact shape of incoming data before writing or debugging their handlers. Real payloads often contain more fields than provider docs show.
How do I test a webhook HTTP POST example?
You can test a webhook HTTP POST example by sending it with cURL, Postman, or by configuring a provider to send a live test event to a temporary inspection endpoint. The key is being able to see the exact headers and payload that arrive.
What response should a webhook endpoint return?
Most webhook endpoints should return a fast 2xx response, usually 200 OK, after basic validation. Heavy processing should usually happen asynchronously so the provider does not time out and retry unnecessarily.
Related Resources
Complete Webhook Testing Guide
A broader walkthrough for testing webhook integrations end to end
Webhooks vs APIs Explained
Understand where webhook requests fit into HTTP-based integrations
Debug Webhook Errors
Troubleshoot payload issues, signature failures, and delivery problems
Webhook Inspector
Inspect real headers, payloads, and query parameters
See a Real Webhook Request Example
If you want to inspect a real incoming request instead of guessing from docs, use a temporary endpoint and capture the exact payload your provider sends.
Open Requex →