Webhook inspector: read a request the way your server sees it

A webhook inspector shows a request as it arrived at the edge of the internet, before any framework parsed it. That view answers questions your application logs can't: which headers were really sent, in what case, with what Content-Type, and which bytes the signature covers.
Get a free webhook URL Free, no account needed.

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:

Raw HTTP requestIllustrative example
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}
Parts of a raw HTTP request
PartWhat to check
Request lineMethod 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-TypeDecides how the body must be parsed. Note the charset: most frameworks assume UTF-8 when it's missing.
Content-LengthShould equal the body's byte length. A mismatch points at a proxy that changed the body.
Signature headerIts format tells you what to compute: here a timestamp t and an HMAC v1, in hex.
User-AgentIdentifies the sender's software. Useful for logging, but anyone can send any User-Agent, so it is never authentication.
BodyThe exact bytes. This, not a pretty-printed version, is what signatures are computed over.

Try it: inspect a real capture

Live, on a real endpoint
See what a capture keeps (path, raw query string, headers and the exact body bytes) on your own endpoint.
No account. The endpoint is yours in this browser and also opens in the playground.

Headers 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-Type but joins most others), and code that reads a single value can see the wrong one.
  • Content-Encoding. A gzip body 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, Cookie and 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:

Same JSON value, different bytes
BodyBytesSHA-256
{"id":"evt_1042","amount":4999}3165f431a3a7a0…1ad3ae39
{ "id": "evt_1042", "amount": 4999 }4053930817b333…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.

Copied as cURL (the body travels as Base64, so every byte survives the shell)Illustrative example
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

Open the playground, send a request from your app, a provider or curl, and see the raw request, headers and body as they arrived.
Get a free webhook URL No account or card needed. Want to keep it? Create a free account

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.

Sources