All field notes
Webhook guide 3 min read

GitHub Webhook Tester: Inspect Payloads and Deliveries

A practical workflow for receiving a GitHub test delivery, reading its event headers and payload, diagnosing failed deliveries, and hardening the real receiver.

Published August 2, 2026By Webhook Tester
github webhook testergithub webhook testtest github webhookgithub webhook eventsgithub webhook deliverygithub webhook payload
01

What a GitHub Webhook Tester Should Prove

A GitHub webhook test should answer four questions: did GitHub reach the payload URL, which event was sent, what JSON arrived, and what response did the endpoint return. A temporary request inspector is useful because it removes your application code from that first delivery check.

The test does not prove that your production parser, signature validation, queue, or business logic is correct. It gives you a known delivery sample and the HTTP evidence needed to build those parts accurately.

Use repository or organization test data. Webhook payloads can contain repository names, user details, issue text, commit metadata, and other information that should not be copied into a public debugging tool without review.

02

Create and Trigger a Test Delivery

Create a temporary endpoint here, then add a webhook in the relevant GitHub repository, organization, or GitHub App settings. Paste the temporary URL into the payload URL field and choose application/json when you want a directly readable JSON body.

Subscribe only to the event needed for the integration. A focused push, issues, pull_request, or ping test is easier to reason about than sending every event type to the same debugging session.

Save the webhook and trigger the real action, or use GitHub delivery controls when available. Keep the GitHub delivery page and the request inspector open together so the sender record and receiver record can be compared.

  • Use a test repository or synthetic issue and pull-request content
  • Select only the event types the integration consumes
  • Record the GitHub delivery ID before troubleshooting
  • Remove the temporary payload URL after the test
03

Read the Headers and JSON Payload

Start with X-GitHub-Event. Your production router should use this header to choose the correct event contract instead of guessing from fields in the body. Use X-GitHub-Delivery as the stable identifier in logs and duplicate-detection records.

When a secret is configured, X-Hub-Signature-256 contains the SHA-256 signature. Capture the raw body exactly as received because parsing and re-serializing JSON before verification can change bytes and cause a valid signature check to fail.

Compare the payload with the official event documentation and keep fixtures for the event variants your code supports. A pull request event with action opened is not interchangeable with synchronize, closed, or reopened.

04

Diagnose Failed Deliveries and Redeliveries

A missing request usually points to the payload URL, DNS, TLS, firewall, or routing. A received request with a non-success response points to receiver validation or application behavior. A timeout means the receiver should acknowledge sooner and move work to a background queue.

Use GitHub delivery history to inspect the recorded request and response. After fixing the endpoint, redeliver the same delivery instead of creating an unrelated event. That gives you a cleaner before-and-after comparison.

Treat repeated deliveries as normal. Store the delivery ID, make processing idempotent, and return a safe success response when an already-processed delivery arrives again.

05

Move the Test Into a Production Receiver

Replace the temporary URL with your controlled HTTPS endpoint. Verify X-Hub-Signature-256 before trusting the payload, use constant-time comparison, and reject requests that do not match the configured secret.

Acknowledge valid deliveries quickly and queue slower processing. Log the delivery ID, event name, response status, and processing outcome without logging secrets or unnecessary personal data.

Turn captured test payloads into fixtures, then cover signature failures, duplicated delivery IDs, unsupported actions, malformed JSON, and temporary downstream failures in automated tests.

  • Verify the signature against the raw request body
  • Route by X-GitHub-Event and validate the action
  • Deduplicate with X-GitHub-Delivery
  • Respond quickly and process asynchronously
  • Keep test fixtures free of sensitive repository data

Common questions

Frequently asked questions

How do I test a GitHub webhook online?
Create a temporary endpoint, use it as the GitHub webhook payload URL, choose the events you need, and trigger a test event. Inspect the received method, event headers, delivery ID, and JSON body before implementing the production receiver.
Which headers identify a GitHub webhook delivery?
X-GitHub-Event identifies the event type and X-GitHub-Delivery identifies the delivery. When a secret is configured, GitHub also sends X-Hub-Signature-256 so your production endpoint can verify the raw request body.
Does an online inspector verify the GitHub signature?
This inspector displays the signature header but does not know your webhook secret and does not verify it. Signature verification belongs in your application and must use the unmodified raw body plus the secret configured in GitHub.
Can GitHub redeliver a failed webhook?
GitHub exposes delivery history and supports redelivery for recent deliveries. Use the delivery record to compare request and response details, then redeliver after fixing the receiver.

Primary sources

Official references

Try it with a real request

Turn the guide into a test.

Open a temporary endpoint, send your payload, and inspect exactly what arrived.

Open the tester