Webhook inspector: read a request the way your server sees it
By the HookWatcher team · Updated
Anatomy of a captured request
This is a webhook as raw HTTP, the way an inspector's raw view shows it. Every line is something your handler depends on:
POST /a1b2c3d4e5f6g/payments?source=checkout HTTP/1.1
Host: hookwatcher.com
User-Agent: Stripe/1.0 (+https://stripe.com/docs/webhooks)
Content-Type: application/json; charset=utf-8
Content-Length: 31
Stripe-Signature: t=1763190000,v1=5257a869e7ecebeda32affa62cdca3fa51cad7e77a0e56ff536d0ce8e108d8bd
Accept: */*; q=0.5, application/xml
{"id":"evt_1042","amount":4999}| Part | What to check |
|---|---|
| Request line | Method and path. Anything after the endpoint ID (/payments) and the query string are part of what the sender called; some providers append their own query parameters. |
| Content-Type | Decides how the body must be parsed. Note the charset: most frameworks assume UTF-8 when it's missing. |
| Content-Length | Should equal the body's byte length. A mismatch points at a proxy that changed the body. |
| Signature header | Its format tells you what to compute: here a timestamp t and an HMAC v1, in hex. |
| User-Agent | Identifies the sender's software. Useful for logging, but anyone can send any User-Agent, so it is never authentication. |
| Body | The exact bytes. This, not a pretty-printed version, is what signatures are computed over. |
Try it: inspect a real capture
Live, on a real endpointHeaders that matter
HTTP header names are case-insensitive, and many frameworks normalize them to lowercase. HookWatcher stores headers in the order and case that reached it, and replays, exports and diffs send them that way, which matters when a sender (or a proxy in between) does something unusual such as repeating a header. The inspector's Headers tab lists them by name, in lowercase.
- Repeated headers. HTTP allows a header to appear more than once. Frameworks merge them with commas or keep only the first or the last one (Node.js keeps the first
Content-Typebut joins most others), and code that reads a single value can see the wrong one. - Content-Encoding. A
gzipbody is compressed bytes. Decompress before parsing, but verify signatures over whatever the provider signed (check its docs). - X-Forwarded-For. Added by proxies. Don't trust it for allowlisting unless your own proxy sets it; anyone can send it.
- Credentials.
Authorization,Cookieand API key headers shouldn't be copied into tickets or chat. A good inspector masks them by default.
Paste raw headers into the HTTP header parser to get a table with repeated names flagged and the sending provider identified, without uploading anything.
Why exact bytes matter
These two bodies are the same JSON value, and a JSON viewer shows them identically. They are different bytes, so their digests and HMACs differ completely:
| Body | Bytes | SHA-256 |
|---|---|---|
{"id":"evt_1042","amount":4999} | 31 | 65f431a3a7a0…1ad3ae39 |
| { "id": "evt_1042", "amount": 4999 } | 40 | 53930817b333…c70d7a716d |
This is why an inspector should store the body unchanged and show formatted JSON only as a view. If a tool reformats the body and you copy it into a test, your signature check will fail for a reason that has nothing to do with your code.
What HookWatcher's inspector shows
- The body stored unchanged with its SHA-256 fingerprint; compressed and binary bodies are kept as received.
- Every header (listed by name; the original order and case are kept for replay and export), the query string, cookies, source IP and receive time.
- A JSON tree with search and copy-path (for example
data.items[0].price), a raw HTTP view, and the body's bytes in hex in the replay tools. - Credential headers masked until you reveal them. Masking is a view; the stored request never changes.
- Provider detection: Stripe, GitHub, Shopify, Twilio, Razorpay, PayPal, Slack, Discord, WooCommerce and Paddle requests are labelled with their event type.
- Signature verification against the captured bytes for Stripe and GitHub, with your signing secret, on paid plans.
Requests appear as they arrive. Without an account, an endpoint keeps the last 100 requests for 2 days. The features page has the full list.
Reproducing a request
From the inspector you can copy any request as cURL, Node.js or Python (sensitive headers masked), or replay it. A copied cURL command is useful for a quick check; for anything involving signatures, replay the stored request instead, because it sends the original bytes and headers.
printf %s 'eyJpZCI6ImV2dF8xMDQyIiwiYW1vdW50Ijo0OTk5fQ==' | base64 --decode | curl --request 'POST' \ --url 'https://example.com/webhooks/stripe?source=checkout' \ --header 'content-type: application/json; charset=utf-8' \ --header 'stripe-signature: ••••••••' \ --data-binary @-
Inspect a real request in seconds
Frequently asked questions
Is a webhook inspector the same as a proxy or tunnel?
No. An inspector records requests sent to its own URL and answers them itself. A tunnel passes each request through to your local app and returns your app's response. HookWatcher does both: capture endpoints with an inspector, and tunnels whose traffic you inspect on your own machine.
Can I inspect requests my server receives directly?
Not with a capture URL; it sees only requests sent to it. To see production traffic, put the capture endpoint in front of your server and forward each request on, so you get both the inspector view and normal delivery.
Why do header names look different in my framework?
Node.js lowercases header names; PHP exposes them as HTTP_X_GITHUB_EVENT-style server variables; some frameworks title-case them. The values are the same. HookWatcher stores the case that reached it (HTTP/2 senders always use lowercase) and replays it; the Headers tab shows names in lowercase.