Skip to main content
Debugging webhooks is painful. Providers fire them once, your local machine is offline, and you’re left guessing at the payload. getrequest gives you a permanent capture URL you can hand to any provider.

​
Create a webhook endpoint

  1. Open your project and click New Endpoint.
  2. Set the Method to POST (most webhook providers use POST).
  3. Set the Action:
    • Async API — acknowledges the provider immediately (202) and delivers to your handler in the background, with automatic retries. This is the recommended mode for webhooks: providers expect a fast response and will retry their side if you’re slow, so let getrequest absorb that instead of your handler. See Sync vs. Async endpoints.
    • Sync API — proxies inline and waits for your handler’s response, if you need the provider to see your handler’s actual reply.
    • Static API — capture without forwarding anything yet (see below).
  4. Give it a descriptive Name like Stripe webhook or GitHub webhook — this is just a label for your own reference; it doesn’t appear in the URL.
Click Create and your webhook URL is ready immediately, with a unique, auto-generated ID:

​
Register it with your provider

  1. Go to Stripe Dashboard → Webhooks.
  2. Click Add endpoint.
  3. Paste your getrequest URL.
  4. Select the events to listen for (e.g. payment_intent.succeeded).
  5. Click Add endpoint.
Stripe will immediately send a test event. Open getrequest Logs to see it.

​
Inspect a captured webhook

Open Logs in your project. Every webhook event appears as a row. Click any row to inspect:
  • Headers — signature headers (Stripe-Signature, X-Hub-Signature-256), content type, and any custom metadata the provider sends
  • Body — the full JSON payload
  • Response — what your backend returned (status code and body)
  • Duration — round-trip time from getrequest to your backend
This is everything you need to debug a failed webhook handler without triggering another event.

​
Replay a webhook (paid plans — see FAQ)

Found a failed event? Replay it with one click without waiting for the provider to resend.
  1. Open the log entry.
  2. Click Replay.
  3. getrequest re-fires the exact same request — same headers, same body — to your backend.
  4. The new response appears immediately.
If an outage caused many events to fail — not just one — see Bulk retry & recovering many requests instead of replaying event by event.
Replay requires a Sync API or Async API endpoint. Static API endpoints have no destination to replay to.

​
Verify webhook signatures

This is the one place forwarding behavior actually matters: getrequest does not forward every header to your backend unchanged. Only a fixed allow-list, plus anything starting with X-, makes it through — see Limits, timeouts & error responses for the full list. That has a real consequence for signature headers:
  • X-Hub-Signature-256 (GitHub) — starts with X-, forwarded fine. Your own verification code works exactly as it would with a direct connection.
  • Stripe-Signature (Stripe) — does not start with X- and isn’t on the allow-list, so it is stripped before reaching your backend. Your own handler-side verification against Stripe-Signature will never see the header if you’re forwarding through getrequest.
For Stripe (or any provider whose signature header doesn’t happen to start with X-), don’t rely on your backend to verify it — have getrequest verify it instead, before the header ever gets dropped: set the endpoint’s Authentication to HMAC, point it at the provider’s signature header name, and supply the provider’s signing secret. Requests with an invalid or missing signature get rejected with 401 before reaching your backend at all — see Authenticate endpoints and destinations for the exact fields.
If you don’t configure Authentication, anyone with your getrequest URL can send arbitrary payloads to your backend — verify signatures either in getrequest (recommended, and required for headers like Stripe-Signature that don’t get forwarded) or in your own handler.

​
Use Static API to capture without forwarding

If you want to capture webhook events without your backend receiving them — for example, during an outage or before your handler is built — switch the endpoint to Static API temporarily. Events are captured in Logs. When your handler is ready, switch back to Sync API or Async API and replay the captured events (one at a time, or in bulk — see Bulk retry & recovering many requests).