HTTP & Request Debugging

Webhook testerfor real incoming requests

Create an inbox, send a test callback to its URL and inspect what actually arrived.

Webhook tester

Incoming events

Receive URL

No requests captured yet.

Send a test request from your webhook provider or HTTP client. The URL accepts writes; this tab alone holds the key for reading events.

No requests captured yet.

Request details

Choose an event to inspect its headers and body.

Requests reach HeyUtils servers and are held for 30 minutes, then deleted. Sensitive header values are redacted before storage; paths, query values and bodies are not. Send test data only.

Filter captured events

Create an inbox to get a receive URL.

When a payment sandbox says it sent an event but your handler saw nothing, a webhook tester gives you an independent receive point. Put the temporary webhook URL into the sender's test configuration, then compare the captured method, path, query, headers and body with your expectation.

This request bin is a short-lived webhook catcher, not a production endpoint. The public URL accepts requests; a separate management key, held only in this browser tab, unlocks the event list. You can inspect webhook requests without handing the sender your own application server.

Why use this webhook tester

See the real callback while keeping read access separate from the public address.

An address for sending, a key for reading

A sender only needs the temporary webhook URL. It cannot open the event list with that URL alone; the browser tab keeps a separate management key. The webhook tester masks common credential headers before an event is stored, while leaving the raw path, query and body visible for debugging.

A public request enters an inbox while a separate private key opens the event list.

Repeat the captured event without forwarding it

A replay makes a marked copy of the selected event in the same inbox. This lets you compare two records and verify your filters. It never calls an arbitrary destination, so it cannot pretend to test your application handler or trigger a production side effect.

One captured request is copied into a second marked event inside the same inbox.

Follow an event through its short lifetime

01

Create only when the sender is ready

The 30-minute clock starts when you create the inbox, not when the first callback arrives. The management key lives only in this tab, so keep it open while you test; reloading loses access to earlier records.

02

Check the captured request, not the sender's claim

The list refreshes every three seconds while this tab is visible. Inspect method and path first, then query, masked headers and the Body. A binary Body is displayed as Base64 instead of being silently decoded as broken text.

03

Apply filters before you export

Method and text filters operate on captured events, never on what the endpoint accepts. Editing a filter briefly disables export while the visible result updates. Download includes the current filtered records, up to the 50-event inbox limit.

What the inbox records and lets you inspect

Real HTTP capture

The webhook tester accepts GET, POST, PUT, PATCH, DELETE, HEAD and OPTIONS at a random address. Each accepted request records its method, path, query, arrival time, redacted headers and a body up to 64 KiB. A full or expired inbox rejects new events instead of truncating them.

Focused review and export

Choose a method or search the captured path and body to find one callback among retries. Details retain the original event; the JSON download contains only the currently visible filtered set, with no management key.

Bounded temporary storage

The random inbox expires after 30 minutes and holds at most 50 events. A server-side expiry alarm removes the event data. Refresh stops when the tab is hidden, and a manual refresh is available when checking a delivery immediately.

Limits that matter during callback debugging

This is a server-side temporary service
The callback is uploaded to HeyUtils when the sender invokes the URL. Do not send production secrets or customer data. Authorization, cookies and common token headers are masked before storage, but paths, query values, custom body fields and unusual credential names are not automatically redacted.
Replay remains inside the inbox
Replay adds one copy of an existing event to the same inbox and consumes one of its 50 slots. It does not forward to your server, open a localhost tunnel, verify an HMAC signature or let you set a custom HTTP response. Use your own integration test for those tasks.
Expiry and quotas are enforced before storage
The 30-minute deadline does not extend when a new event arrives. Bodies over 64 KiB, headers over 8 KiB, a full inbox and bursts of requests receive an error instead of a partial record. There is no account, permanent history, share page or manual early-delete button.

Webhook tester questions

How do I test a webhook with this tool?

Create an inbox, copy its receive URL into your provider's test webhook setting, send a test event and return to this tab. The webhook tester refreshes the event list every three seconds while visible. Open an event to inspect what reached this address.

Is my webhook data private?

The receive URL is public to anyone you give it to, so they can send data. Only the separate management key in this tab can read events. Common credential headers are masked before storage, but the path, query and body are retained; send test data only.

Can I replay webhook requests?

Yes, after a preview and explicit confirmation. Replay creates a marked copy in this same inbox; it does not call your app, your provider or any arbitrary URL. It also consumes one event slot.

How long are requests kept?

The inbox has a fixed 30-minute lifetime from creation, with a maximum of 50 records. Once it expires, new requests are rejected and stored events are deleted. Reloading your browser tab loses its private management key sooner.

Can I send test webhook requests manually?

Yes. Use a tool such as curl or an HTTP client to send a small request to the receive URL. This page never sends a sample request automatically and cannot forward a captured event to an external destination.

Did a callback behave differently?

Try the webhook tester with a test callback

Start a temporary inbox when your sender is ready, then inspect the captured event before the 30-minute window closes.

This tool receives and temporarily stores requests on HeyUtils servers.