Skip to content

Features

Everything for webhooks. Nothing else.

53 features across six areas, each with an example of how you'd use it.

Capture and inspect

See exactly what the provider sent, the moment it arrives.

9 features · 9 available now

All plans

Instant bin URL

A webhook URL in one click, no account needed.

Details and example

A temporary capture URL you get without signing up. Anything sent to it shows up in your browser straight away. A bin takes 100 webhooks a day and is deleted, with its events, after 7 days. Only the browser that made it, or someone with its token, can see what arrived: the token is shown once, when the bin is made, and never appears in a link. The bin's page shows both URLs: the capture URL that receives webhooks, and the viewer URL (app.webhookhq.dev/bins/<id>) to open it again, which asks for the token in any other browser. Opening the capture URL in a browser sends the bin a GET and answers with a short note pointing to the viewer URL.

Plans: All, no account needed

Example

You're evaluating Shopify's order webhooks and want to see the payload before writing any code. You open webhookhq.dev/new, copy the URL https://in.webhookhq.dev/b/k3x9p2q7m4 (bins have no organization, so they live under /b/), paste it into Shopify's notification settings and place a test order. The orders/create payload appears in the browser a moment later.

All plans

Permanent endpoints and custom slugs

Named URLs that never expire, with slugs you choose.

Details and example

Named capture URLs that belong to your organization and never expire. Every URL starts with the organization: in.webhookhq.dev/<organization>/<endpoint>. The endpoint part is random by default; paid plans can choose it. Endpoint names only need to be unique within the organization, so two companies can both have stripe-prod.

Plans: Endpoints on all plans (3 on Free, 5 on Developer, unlimited on Pro and above). Custom slugs on Developer and above

Example

Acme creates an endpoint called "Stripe production" with the slug stripe-prod, so the URL is https://in.webhookhq.dev/acme/stripe-prod. Anyone reading the Stripe dashboard knows exactly where events go. Later Acme renames its organization URL to acme-inc: the endpoint is now shown as in.webhookhq.dev/acme-inc/stripe-prod, and the old acme/stripe-prod URL in Stripe keeps working, so nothing needs updating.

All plans

Endpoint authentication

Only accept webhooks that carry your secret header.

Details and example

Endpoints are open by default: anyone with the URL can send, which is what most providers expect. If the sender can add a header, the endpoint can require one carrying a secret, like Authorization: Bearer whsk_… or X-Api-Key: …. Requests without it get 401 and aren't stored; the endpoint page shows how many were refused in the last 24 hours. Optional, and endpoints that can't use it keep working as before.

Plans: All, including Free and Developer

Example

Your own billing service sends webhooks to in.webhookhq.dev/acme/billing. You turn on a secret header, paste the generated whsk_… secret into the service's config, and a script that found the URL in a log can no longer push fake events into your list.

All plans

Live event stream

Webhooks appear on screen within about two seconds of arriving.

Details and example

New webhooks appear on screen within about two seconds of arriving, pushed over WebSockets. The page doesn't poll, and there's no refresh button.

Plans: All

Example

You click "Send test webhook" in GitHub's repository settings while the endpoint page is open. The ping event slides into the list a moment later, so you know GitHub can reach the URL before you move on to configuring push events.

All plans

Full request view

Body, headers, query and raw bytes, all in one place.

Details and example

Everything about a captured request in one place: JSON and XML bodies pretty-printed and as a collapsible tree (SOAP and other +xml types included), headers, query parameters, form fields, the raw body exactly as sent, the sender's IP address, size and timing. On plans that keep events longer than 30 days, older events' bodies and headers are archived to S3 and load when you open the event, a little more slowly (decision 0015).

Plans: All

Example

Twilio sends SMS status callbacks as form data, not JSON. The form fields tab shows MessageStatus=delivered and MessageSid=SM8f2... as a clean list, and the raw tab shows the exact encoded body for when you need to compare byte for byte.

All plans

Request ID on every response

Every webhook gets an ID back, to trace it or quote it to support.

Details and example

Every response WebhookHQ sends to a provider, on every plan, carries the header X-WebhookHQ-Request-Id with a unique ID (a UUID) for that request. That covers accepted webhooks, custom responses, verification handshakes and refusals (wrong endpoint secret, over the plan's limit). Custom responses can't change or remove it. WebhookHQ uses the same ID to follow the webhook through capture, processing and every delivery attempt, so support can trace exactly what happened to it. If the sender includes its own X-Request-Id, WebhookHQ notes it alongside, so either ID finds the request.

Plans: All

Example

Stripe's dashboard shows a delivery that timed out, with the response headers WebhookHQ sent. You copy X-WebhookHQ-Request-Id: 3f2a… from there into a support message, and support finds the webhook, its event and each forwarding attempt from that one ID.

All plans

Search and filters

Find any event by type, provider, status or payload.

Details and example

Find events by event type, provider, status, time range or IDs pulled from the payload. JSONPath search looks inside payloads within a chosen time window. On plans that keep events longer than 30 days, searching inside bodies covers the last 30 days; older events are still found by id, type or path.

Plans: All

Example

A customer says their subscription renewal never went through. You filter the Stripe endpoint by invoice.payment_failed for the last 7 days, then search $.data.object.customer == "cus_Q8x2LmN" to find the exact event in seconds.

Pro+

Custom responses

Choose the status, headers and body providers get back.

Details and example

Choose what an endpoint sends back to the provider: status code, headers, body and an optional delay (up to 5 seconds). Delays are best effort: at most 2 replies wait at once per endpoint and 3 per organization, none while WebhookHQ is busy, and none during a trial; other webhooks get the response straight away. Every plan also answers the standard verification handshakes automatically, with nothing to set up: Slack's url_verification challenge, Microsoft Graph's validationToken, Meta's (Facebook, Instagram, WhatsApp) and Strava's hub.challenge, Dropbox's challenge and Okta's verification header.

Plans: Custom responses on Pro and above. Automatic verification handshakes on all plans

Example

You're building a Twilio SMS bot, and Twilio expects TwiML back. You set the endpoint to answer 200 with Content-Type: text/xml and a <Response> body, and Twilio replies to the texter. Later you set a 3-second delay to see how a provider behaves when responses are slow. Connecting Slack needs no setup at all: WebhookHQ echoes its challenge for you.

All plans

Copy as cURL or fetch

Turn any webhook into a command you can run.

Details and example

Turns any captured request into a ready-to-run curl command or JavaScript fetch call, with the original headers and body. Both buttons are on every event.

Plans: All

Example

You want to rerun a Shopify webhook against your local server without opening WebhookHQ again. You click "Copy as cURL" and paste it into your terminal:

curl -X POST http://localhost:3000/webhooks/shopify \
  -H "Content-Type: application/json" \
  -H "X-Shopify-Topic: orders/create" \
  -H "X-Shopify-Hmac-Sha256: 7d1f..." \
  -d '{"id": 5521458741, "total_price": "49.00", ...}'

Tunnel to localhost

Deliver webhooks to the app on your laptop, and replay any you missed.

7 features · 4 available now

$ whq listen 3000 --endpoint acme-dev
● https://in.webhookhq.dev/acme/acme-dev → http://localhost:3000
Waiting for webhooks. Ctrl-C to stop.

200  workflow_run.completed    41 ms
200  push                      18 ms
500  pull_request.opened       63 ms
200  check_suite.completed     22 ms
All plans

Queued mode

Get webhooks on localhost while providers get an instant 200.

Details and example

WebhookHQ answers the provider with 200 immediately (or your custom response), then delivers the webhook to your local app through the CLI. Your app's response is recorded in the dashboard. See docs/CLI.md.

Plans: Free (1 tunnel), Developer (1), Pro (3), Team (10), Scale (25)

Example

You're building a Stripe checkout flow. You run:

whq listen 3000 --endpoint acme-stripe-test

Each test payment's checkout.session.completed event arrives at http://localhost:3000, and the dashboard shows what your app returned, including any 500 and its error body.

Developer+ Coming soon

Live mode

Your local app's real response goes back to the provider.

Details and example

The provider's request is passed through to your laptop and your app's real response goes back to the provider. This matters for providers that read your response.

Plans: Developer and above

Example

Twilio expects TwiML instructions in the response to an incoming SMS webhook. With whq listen 3000 --live, Twilio receives the <Response><Message>Thanks!</Message></Response> your local app returns, so you can test your auto-reply end to end from your phone.

Developer+ Coming soon

Offline queue

Webhooks wait while you're offline and arrive in order.

Details and example

If your laptop is closed or the CLI isn't running, events wait in WebhookHQ. When you reconnect, they're delivered to your local app in the order they arrived.

Plans: Developer and above

Example

You close your laptop at 6 pm while a nightly GitHub Actions workflow keeps sending workflow_run events. The next morning you run whq listen 3000 and the 14 events from overnight are replayed into your app in order, so nothing is missed.

All plans

Replay into localhost

Send any past event to your app again, as often as you like.

Details and example

Send any past event to your local app again, as many times as you like, from the dashboard or the CLI.

Plans: All

Example

Your handler crashed on a refund event yesterday. After fixing the bug, you replay that exact event by its short id:

whq replay 7c2e9a1 3000

Your app now returns 200, and you've tested the fix against the real payload, not a hand-made one.

All plans

Find, inspect and wait from the terminal

Find and wait for webhooks in the terminal, or let your agent do it.

Details and example

whq endpoints, whq events list (the event list's filters, including search and JSONPath), whq events view (headers, body and deliveries) and whq wait (the next webhook on an endpoint, then shows it). --json prints the API's response unchanged, --body the body alone, and every command has help with examples (whq help <command>). Coding agents such as Claude Code, Cursor and Codex run them like any other command, with the token whq login saved, so they never see it; whq help agents and docs/CLI.md give a snippet for the project's CLAUDE.md or AGENTS.md and Claude Code permissions that allow the read commands and ask before replays. Waiting happens on the user's machine, so it holds nothing open on WebhookHQ's servers.

Plans: All

Example

You tell Claude Code "I'm about to push; tell me the ref when GitHub's webhook lands." It runs whq wait --endpoint acme-github --type push --json, you push, and it answers refs/heads/fix-signature, commit 9c1e2b7.

Developer+ Coming soon

Path routing

Route different paths to different local ports.

Details and example

Send different paths on one endpoint to different local ports.

Plans: Developer and above

Example

Your app runs Stripe webhooks on one service and background job callbacks on another. You run:

whq listen --route /stripe=3000 --route /jobs=4000

in.webhookhq.dev/acme/dev/stripe goes to port 3000 and in.webhookhq.dev/acme/dev/jobs goes to port 4000.

Team+ Partly available

Team routing

One shared test endpoint, delivered to everyone listening.

Details and example

Status: Everyone listening on an endpoint already gets its events; choosing who receives which events is coming.

One shared test endpoint, delivered to every developer who is listening, optionally filtered per person.

Plans: Team and above

Example

Your team shares one Stripe test-mode endpoint. Priya listens for invoice.* events because she's working on billing, and Sam listens for customer.* because he's working on accounts. Each of them gets only their events on their own laptop, and nobody has to reconfigure Stripe.

Debug

Find out why a webhook broke, then prove the fix with the real payload.

10 features · 5 available now

All plans

Edit and replay

Tweak a request and send it anywhere.

Details and example

Change a captured event's method, path, query, headers or body, choose where to send it (one of the endpoint's destinations, any public URL, or your local tunnel while whq listen runs), and send it. The edited request and the answer appear in the event's deliveries as an edited replay; the captured event never changes.

Plans: All

Example

You suspect your handler breaks when amount is zero. You open a real charge.succeeded event, change amount to 0, and send it to localhost:3000. Your app returns a 500, and you've found the bug without waiting for a real zero-amount charge.

All plans

Signature debugger

Find out exactly why signature verification failed.

Details and example

Checks a webhook's signature against your signing secret. When verification fails, it explains why: wrong secret (test and live secrets differ), a secret pasted with spaces or without its whsec_ prefix, or a timestamp outside the allowed window. It shows what the provider signed and the signature your secret produces, so you can compare with your own code. Supports Stripe, GitHub, Shopify, Slack and Standard Webhooks (Svix, Resend, Clerk and others); the secret is stored encrypted.

Plans: All

Example

Your GitHub handler rejects every webhook with "signature mismatch." You add the endpoint's secret to WebhookHQ, and the debugger reports: "Signature matches the raw body, but your app received a body with reordered keys. Verify the raw request body before parsing JSON." You switch your code to verify the raw body and it works.

Pro+

Signed test events

Realistic Stripe, GitHub and Shopify events, signed with your secret.

Details and example

Send realistic sample events for Stripe, GitHub and Shopify, signed with your own secret, so your signature check runs exactly as it would in production. Pick the event type, edit the body if you like, and send it to a destination, any URL or your laptop through whq listen. The test shows up in the endpoint's events, marked as a test, with your server's answer; it doesn't count towards your plan's events.

Plans: Pro and above

Example

Before going live with Shopify, you send a sample orders/paid event signed with your app's secret to your staging server. Your HMAC verification passes and the order is marked as paid, all without creating a real order in a Shopify store.

Pro+ Coming soon

Failure simulation

Make an endpoint fail or slow down to test retries.

Details and example

Make an endpoint return errors for a share of requests, or respond slowly, to see how a provider retries.

Plans: Pro and above

Example

You want to know what Stripe does when your server is struggling. You set the endpoint to return 503 for 30% of requests for one hour, then watch the event list: Stripe retries the failed events with increasing gaps, and you can see exactly when each retry arrived.

Team+ Coming soon

Duplicate event detection

Spot providers sending the same event twice.

Details and example

Flags when the same provider event ID arrives more than once, so idempotency bugs are visible.

Plans: Team and above

Example

A customer was emailed two receipts. The event list marks evt_3PxR... with a "dup" tag: Stripe sent it twice because your server timed out the first time. That confirms your handler needs to skip events it has already processed.

Team+ Coming soon

Payload diff

See exactly what changed between two events.

Details and example

Compare two events side by side and see exactly which fields were added, removed or changed.

Plans: Team and above

Example

One customer.subscription.updated event processes fine and another fails. The diff shows the failing one has cancel_at_period_end: true and a cancellation_details object your code didn't expect.

Team+ Coming soon

Schema drift alerts

Know when a provider changes its payload.

Details and example

WebhookHQ learns the usual shape of each event type and alerts you when a provider adds, removes or changes fields.

Plans: Team and above

Example

Shopify starts sending current_total_price_set as an object instead of a string after an API version change. You get an alert, "orders/updated: field current_total_price_set changed from string to object," before your parser starts failing in production.

Pro+ Coming soon

Handler stub and typed models

Starter code and types generated from a real payload.

Details and example

Generate starter handler code and typed models (TypeScript, Ruby, Python) from a real captured payload.

Plans: Pro and above

Example

You're adding GitHub pull_request webhooks to a TypeScript service. From a captured event you generate a PullRequestEvent interface and an Express handler with signature verification already in place, instead of writing 80 fields by hand.

Paid plans Partly available

AI failure explanation

A plain-language reason a delivery failed, and a fix.

Details and example

Status: In early access: only organizations WebhookHQ gives access see it, until it's generally available.

"Explain with AI" on a failed delivery gives a plain-language reason it failed and a suggested fix, based on the request WebhookHQ sent, your server's response (status, headers, body) and the endpoint's recent deliveries to the same server. The answer appears on the event page within seconds and is kept there, so it's never paid for twice; Copy takes it as Markdown. Each explanation uses one AI credit, shared with Ask AI's answers: Developer 10 a month, Pro 30, Team 100, Scale and Enterprise 300, and 10 for the whole Team trial. Credits reset on the 1st (UTC) and don't carry over; the button shows how many are left, and at 0 when they come back (owners get an upgrade link). The Usage page shows this month's credits used and left, today's Ask AI list filters, when each resets, and this month's uses (when, who, which event).

AI features are off until an owner or admin turns them on in organization settings ("AI features"), which says exactly what is sent to Anthropic and what never is: signing secrets, endpoint credentials, destination headers and credentials in destination URLs are removed before anything is sent, and Anthropic doesn't train on data sent through its API. While they're off, nothing is sent and no AI button shows; members see "Turned off for this organization". Shared pages and the API never use AI. If WebhookHQ's monthly AI budget is ever used up, AI features pause for everyone until the 1st, and no credits are taken. Until AI features are generally available, they're in early access: WebhookHQ staff give an organization access, and only then can its owners and admins turn them on; without access nothing AI shows anywhere, and pricing leaves them out. Taking access away hides them again and keeps the organization's own setting and credits.

Plans: Paid plans, using credits (Developer 10 a month, Pro 30, Team 100, Scale 300; Team trial 10)

Example

Your app returned 422 with a long validation error. The explanation reads: "Your handler requires shipping_address, but this order is a digital product and Shopify omits the field. Make shipping_address optional for digital orders."

Paid plans Partly available

Ask AI

Ask about the page you're on; get an answer, or the event list filtered for you.

Details and example

Status: In early access: only organizations WebhookHQ gives access see it, until it's generally available.

"✦ Ask AI" in the top bar of every organization page (⌘J or Ctrl+J) opens a panel beside the page, a full-screen sheet on phones. It knows the page you're on and shows it as the context ("Endpoint · Stripe", "Event · invoice.paid · d691bfa", "Destination · Staging"), which you can remove to ask a general question about webhooks. One question at a time, and Claude decides what it wants:

  • Filter: a question about finding events ("failed orders shipping to Mumbai over 10") becomes the endpoint's event list filters (event type, sender, delivery state, time, and a condition on the body) and the list opens with them. Chips above the list say what's filtered in plain words (the question, then Failed, Last 24 hours, shipping_address.city contains “mumbai”, with the body's JSONPath as the chip's title); each chip's × removes that filter and Clear removes them all. The search box stays yours. Nothing runs that the filters couldn't run by hand, and a question that matches no filter says so and costs nothing. Only on an endpoint or event page.
  • Answer: anything else ("why did the delivery to Staging fail?", "what does financial_status mean?") gets a short answer in Markdown in the panel, from the page's data: the endpoint's settings, its last 50 events and their deliveries with the latest failure per destination, the event's request and deliveries on an event page, the destination's recent deliveries on its page.

It's read-only: it never changes anything, so anyone who can open the page can ask. An answer uses one AI credit (the same monthly credits as failure explanations); a filter uses one of the day's list filters (Developer 20, Pro 50, Team 100, Scale and Enterprise 200, the Team trial 20, reset at midnight UTC). The panel shows what's left. When the call fails, nothing is charged ("Couldn't answer just now. Nothing was charged."). Your last question stays in the panel for a day, only for you. "ⓘ Uses AI. Verify results." links to what's sent. It uses the same AI features setting, early access and budget as failure explanations; when AI is off, not on the plan or paused, the panel says so.

Plans: Paid plans, using credits (answers share the explanation credits; list filters Developer 20 a day, Pro 50, Team 100, Scale 200; Team trial 20)

Example

On your Shopify endpoint you ask "failed orders shipping to Mumbai over 10". The list shows the two matching events with chips Failed · Last 24 hours · shipping_address.city contains “mumbai”. You click one and ask "why did this fail?": "Your server answered HTTP 422: shipping_address.zip is required. Make zip optional, then use Retry."

Deliver

Forward every event to your servers, with retries when they're down.

6 features · 2 available now

  1. 502 from api.acme.dev

    14:02:00 · first attempt

  2. Timed out after 10 s

    14:02:30 · retry 1

  3. 200 delivered

    14:07:30 · retry 2

All plans

Forwarding and fan-out

Send every webhook on to one or more of your servers.

Details and example

Every webhook an endpoint captures is also sent to one or more of your servers. Fan-out sends the same event to several destinations at once. The original method, headers and body are kept, and the path after the endpoint URL is added to the destination's. Each destination can add its own headers, like Authorization: Bearer ... for your API; they replace the sender's header of the same name and are stored encrypted. Each delivery carries an Idempotency-Key that stays the same across retries, so your server can safely ignore repeats. Destinations that fail continuously for an hour are paused, and their webhooks wait until you resume them; the organization's owners and admins and the workspace's managers get an email saying so, with a link to resume, and another when it's resumed. Only public servers can be destinations; your own machine is reached through the CLI.

Plans: Free and Developer (1 per endpoint), Pro (5 per endpoint), Team (10 per endpoint), Scale (25 per endpoint), Enterprise (unlimited)

Example

Stripe events go to your API at https://api.acme.dev/webhooks/stripe and also to your analytics service. If the analytics service is down, your API still gets every event, and each destination has its own delivery history. When the analytics service has been down for an hour, you get "Deliveries to analytics.acme.dev are paused: 212 waiting", fix it, and click Resume.

All plans Partly available

Retries with backoff

Failed deliveries are retried on a growing schedule.

Details and example

Status: Automatic retries after 30 seconds, 5 minutes and 30 minutes work today; configurable retries are coming.

If a destination fails or times out, WebhookHQ tries again on a schedule that waits longer between attempts.

Plans: Free and Developer (fixed: 3 retries after 30 s, 5 min and 30 min). Configurable on Pro and above

Example

Your API is down for 20 minutes during a deploy. Events that arrived in that window are retried after 30 seconds, 5 minutes and 30 minutes, and they all succeed once the API is back, without anyone stepping in.

Team+ Coming soon

Bulk retry, pause and cancel

Act on hundreds of deliveries at once.

Details and example

Act on many events at once: retry every failed event, pause delivery to a destination, or cancel pending retries.

Plans: Team and above

Example

A bad deploy made your API return 500 for an hour, and 1,240 events failed. After rolling back, you filter by "failed in the last hour," click "Retry all," and watch them succeed. During the incident you could also have paused the destination so retries didn't pile up.

Team+ Coming soon

Filters and routing rules

Send each event only where it belongs.

Details and example

Decide which events go to which destination based on headers, event type or values in the payload.

Plans: Team and above

Example

You send invoice.* events to the billing service, customer.* events to the CRM sync, and drop charge.updated events entirely because nothing uses them. Each service only receives what it handles.

Team+ Coming soon

Transformations

Reshape payloads with small JavaScript functions.

Details and example

Change an event's payload before it's delivered, using small JavaScript functions that run in a sandbox.

Plans: Team and above

Example

Your internal service expects { "orderId": ..., "total": ... }, but Shopify sends a large order object. A transformation maps the fields:

export default (event) => ({
  orderId: event.body.id,
  total: Number(event.body.total_price),
});

The service receives the small shape it expects, and its code doesn't need to know Shopify's format.

Team+ Coming soon

Throttling and deduplication

Deliver at a pace your servers can handle, without repeats.

Details and example

Throttling limits how fast events are delivered to a destination. Deduplication skips events that were already delivered.

Plans: Team and above

Example

Your legacy ERP falls over above 10 requests per second, but a Shopify bulk import sends 3,000 order events in a minute. You throttle the ERP destination to 5 per second, and events queue up and arrive at a pace it can handle. Deduplication makes sure duplicates from Shopify don't create duplicate orders.

Monitor

See every delivery attempt for every event. Alerts and metrics are coming soon.

5 features · 1 available now

All plans

Delivery timeline

Every attempt, status and response, in order.

Details and example

For each event, every delivery attempt in order: when it was sent, which destination, the status code, the response time and the response body.

Plans: All

Example

A customer asks why their order email arrived five minutes late. The timeline shows the first attempt got a 502 at 14:02:00, the retry at 14:02:30 timed out, and the next one succeeded at 14:07:30. You can see exactly where the delay came from.

All plans Coming soon

Metrics

Volume, success rate and response times at a glance.

Details and example

Charts of event volume, delivery success rate and response times (p50 and p95) per endpoint and destination. Scale plans can export metrics to Prometheus or Datadog.

Plans: Basic on Free, Developer and Pro, full on Team, export on Scale and above

Example

You notice p95 response time for your API destination climbed from 300 ms to 4 seconds after Tuesday's deploy. You trace it to a new database query in the webhook handler.

Team+ Coming soon

Failure grouping

Hundreds of failures, grouped into one issue.

Details and example

Similar failures are grouped into one issue instead of hundreds of separate errors.

Plans: Team and above

Example

Instead of 600 failed events, you see one issue: "api.acme.dev returned 401 Unauthorized, 600 events since 09:14." The rotated API token is obvious at a glance, and once it's fixed you retry the whole group.

Pro+ Coming soon

Alerts

Hear about failing deliveries by email, Slack, Discord or webhook.

Details and example

Notifications when deliveries fail, by email, Slack, Discord or a webhook of your own.

Plans: Email on Pro. Slack, Discord and webhook on Team and above

Example

You set an alert: "If more than 5% of deliveries to the payments destination fail within 10 minutes, post to #payments-oncall in Slack." The on-call engineer hears about it before customers do.

Pro+ Coming soon

Silence alerts

Know when a provider goes quiet.

Details and example

Alerts when an endpoint stops receiving webhooks for longer than usual.

Plans: Pro and above

Example

Your Stripe endpoint normally receives events every few minutes. You set a silence alert for 6 hours. When someone accidentally disables the webhook in Stripe's dashboard, you get "Stripe production has received nothing in 6 hours" instead of finding out days later.

Team and platform

Share safely, sign in your way, and connect your tools.

16 features · 13 available now

All plans Partly available

Sign in with GitHub, Google or Microsoft

Use the account you already have.

Details and example

Status: Sign in with GitHub works today; Google and Microsoft are coming soon.

Create an account or sign in with an existing GitHub, Google or Microsoft account, alongside email and password. Accounts with the same verified email are linked, so you can use any of them to sign in. The CLI doesn't sign in at all; it uses an access token from the dashboard (see below).

Plans: All

Example

A developer arrives from a Stripe tutorial and clicks "Continue with GitHub." Two clicks later they have an account and their first endpoint, without creating another password.

All plans

Two-factor authentication

Authenticator codes, with recovery codes for a lost phone.

Details and example

A code from an authenticator app (1Password, Google Authenticator, Authy) after the password, or after signing in with GitHub. Ten one-time recovery codes cover a lost phone.

Plans: All

Example

Your laptop's password manager is compromised. The attacker has your WebhookHQ password but not your phone, so they're stopped at "Enter your code," and too many wrong codes lock the account.

All plans

Onboarding

Set up your organization and team in one short page.

Details and example

Signing up asks for a name, email and password, and a ticked "I agree to the Terms of Service and Privacy Policy." box (the same box comes after signing up with GitHub). After signing up, one short page sets up the organization: its name, who'll use WebhookHQ (just me, a small team, a larger team), and, for teams, invites and company email domain options. Everything can be skipped and changed later. People who sign up from an invitation skip it and join the inviting organization.

Plans: All

Example

Priya signs up as [email protected]. The organization name is already filled in as "Acme." She picks "A small team," leaves "Let people with an @acme.com email ask to join" ticked, invites two colleagues and lands in Acme's Default workspace with a Team trial running.

Paid plans Partly available

Billing

Monthly plans you can change any time.

Details and example

Status: Monthly plans, upgrades, downgrades and invoices work today, paid through Razorpay Checkout (in rupees: Visa, Mastercard and RuPay cards or UPI Autopay; in US dollars: Visa and Mastercard cards issued outside India, as the pricing page's "How can I pay?" and the checkout page say). Rupee checkouts set up a mandate that renewals are charged on about 2 days before each period ends (a card or UPI app that can't hold a mandate can Pay once instead, and its renewals come by pay-now link); US dollar checkouts are paid once and their renewals always come by pay-now link, since Razorpay charges mandates in rupees only; a renewal that doesn't go through is tried again on days 1, 3 and 5 of its period, each time emailing owners and the billing email a pay-now link (one Razorpay Payment Link per invoice, also behind a Pay now button on the Billing page and the invoice's row in the history), and moves the organization to Free if it's still unpaid after 7 days. Rupee renewals over ₹15,000, which Indian banking rules make the customer approve, and renewals without an active mandate get the pay-now link instead of an automatic charge. Owners are emailed when the mandate is cancelled in the bank or UPI app (the plan then ends with the paid period) or paused (renewals wait until it's resumed). Refunds, issued by WebhookHQ only by exception, show in the billing history and on the receipt. Paid plans open in two steps, worded the same on the website's pricing cards and the Billing page: until payments launch, paid plans can't be bought and say "Paid plans open soon." (the website's button is "Start free"); once they launch, customers billed in India can buy them in rupees, while US dollar customers see "Payments from outside India open soon." until Razorpay enables international payments; then everyone sees "Choose Team" and the like. Checkout, the payment page, Pay now and turning on extra events refuse a currency that can't be paid yet, before anything reaches Razorpay. Paid extra events on Team and Scale work: owners turn them on with a monthly cap in Billing (past the cap, webhooks are still received and stored but hidden and not forwarded until the cap is raised or the month resets; the held deliveries can be sent then), their changes are in the history, and the renewal invoice gets a line for the month's extras (at $0 during the introductory offer); a renewal whose extras take it past the payment mandate's limit gets the pay-now link. Extras are billed on the first renewal invoice issued after their month (UTC) ends, so extras not yet billed when a plan ends aren't billed.

Owners choose and change the organization's plan in Billing: monthly (yearly billing, with two months free, is coming after launch), upgrades that start straight away with credit for unused time, and downgrades or canceling at the end of the paid period. Downgrades wait until the organization fits the new plan's limits, and the page says what to remove. Team and Scale can turn on paid extra events with a monthly cap (see Usage); they're billed as a line on the next renewal invoice. Customers billed in India pay the rupee price list, everyone else US dollars; a subscription keeps the currency it started in. Before Razorpay's checkout opens, the owner ticks two boxes, and Pay stays disabled until both are ticked: "I agree to the Terms of Service and the Refund Policy." and the payment authorization, worded for how they pay: with a mandate, "I authorize Valostra Digital Ventures LLP to charge ₹2,499 every month for the Team plan, about 2 days before each period ends, until I cancel. Cancelling takes effect at the end of the paid period."; paying once, "I'm paying ₹2,499 once for this period. Renewals aren't charged automatically; I'll get a link to pay each one." Turning on extra events or raising their cap needs "I authorize charging extra events at $2 per 100,000 on my next invoice, up to $20 a month." (with the real price and cap). Billing keeps a history of every change and every consent (who did what, when) and every invoice, numbered consecutively per financial year (WHQ26-27/0000042), each with a PDF receipt to download (also attached to the receipt email); owners get receipts by email. Billing details (company name, address, country, tax or VAT ID, billing email) are asked for at checkout and editable on the Billing page; each invoice keeps the details it was issued with. Admins can see billing; only owners change it. Enterprise is arranged with sales. The plans list recommends at most one plan: the smallest one above the organization's plan that fits what it uses now (members and invitations, workspaces, endpoints, destinations per endpoint, and this or last month's events), and none on Scale or Enterprise; the website's pricing page keeps its own fixed recommendation. WebhookHQ can give an organization a plan without billing (a complimentary plan), permanently or until a date: Billing then says "Complimentary from WebhookHQ. No billing." (with "until" and the date when it ends), offers no plan at or below it, links to contact us for changes, and still offers the plans above it, which start a normal paid subscription and end the complimentary plan. Owners are emailed 7 days before a complimentary plan ends and when it has ended, and the day after its last day (UTC) the organization moves to Free like any downgrade.

Plans: Paid plans

Example

Your team outgrew Pro. You open Billing, pick Team, see $29 minus the credit for the rest of this month, and continue: Team's limits apply at once and the receipt lands in the owners' inboxes. In the spring, after a reorganisation, you schedule a move back to Pro for the next renewal, and the history shows who made each change.

Free plan

Team trial

Try Team free for 14 days, no card needed.

Details and example

A Free organization can use the Team plan free for 14 days, once, without a card: 10 seats, 20 workspaces and Team features. It starts when someone invites teammates or turns on a company email domain option during onboarding, approves a request to join, or clicks "Start free Team trial" on the Members page. Afterwards the organization goes back to Free unless it upgrades.

Plans: Free

Example

A three-person startup signs up on Free, invites the other two during onboarding and spends two weeks wiring up their Stripe and GitHub webhooks together before deciding to pay for Team.

Team+

Company email domain

Colleagues on your domain can find you and ask to join.

Details and example

An organization can claim its company email domain, such as acme.com, then let people who sign up with an @acme.com email find it and ask to join, and limit invitations to @acme.com addresses. Owners and admins approve or decline each request.

Plans: Team, Scale and Enterprise (and the Team trial)

Example

Lee from Acme signs up without knowing Acme already uses WebhookHQ. Instead of creating a second, separate organization, onboarding shows "Your team is already on WebhookHQ: Acme," and Lee clicks "Request to join." Priya gets an email, approves Lee from the Members page, and Lee is in.

All plans

Access tokens for the CLI and API

Named tokens for the CLI, the API and scripts.

Details and example

Generate named tokens in the dashboard and use them with the CLI and the REST API. There's no username or password in the CLI, so it works the same whether you signed up with email or GitHub. Each token shows when it was last used, can expire, and can be revoked at any time.

Plans: All (CLI, tunnel and reading through the API). Creating, renaming and deleting endpoints through the API on Pro and above

Example

You create a token called "MacBook" on the Access tokens tab and copy it. It's shown only once:

whq login            # paste whq_8KfQ2x... when asked
whq listen 3000

In CI, you create a separate token called "GitHub Actions" and set it as the WHQ_TOKEN environment variable instead of saving it to a file. When a laptop is lost, you revoke the "MacBook" token and CI keeps working.

All plans

Workspaces and roles

Private workspaces with managers, editors and viewers.

Details and example

Group endpoints into workspaces and control who can view, edit or administer them. Workspaces are private: organization owners and admins manage all of them; members only see the ones they're added to, as a manager (settings, endpoint limit, access), editor (endpoints) or viewer (read-only). Endpoints are unlimited on Pro and above (Free has 3, Developer 5); a workspace's managers can cap how many endpoints it has, to keep it tidy.

Plans: Workspaces on all plans: 1 on Free and Developer, 3 on Pro, 20 on Team, 125 on Scale, unlimited on Enterprise. Owner, admin and member roles everywhere (they matter once a plan has more than one seat); per-workspace access with manager, editor and viewer roles on Team and above

Example

You keep "Production" and "Staging" in separate workspaces. Contractors get viewer access to Staging only, so they can debug test events without seeing production customer data.

All plans

Usage

This month's usage at a glance, and an email before you hit a limit.

Details and example

A Usage tab showing the organization's plan (and any Team trial) and this month's usage against its limits: events, seats (including pending invitations), workspaces and endpoints, with endpoints broken down by workspace, and AI credits (see AI failure explanation). Bars turn amber at 80% and red at 100%, and the page says when event counts reset. Owners and admins also get an email the first time a month's events reach 80% of the plan, and another at 100%, naming the endpoints that sent the most. What each plan includes is on the Pricing page's comparison, linked from the plan card.

Each received request counts as one event, and a large one once for every 100 KB of body (a 250 KB request counts as 3); forwarding to several destinations, retries and replays don't count again. Over the monthly events, nothing is lost: every webhook is still received and stored, and senders get their usual reply. Team can go 10% and Scale 20% over for free. Past that (and on Free, Developer and Pro, past the limit itself), new events are hidden and their deliveries held until you upgrade, and the event list says how many are waiting. On Team and Scale an owner can instead turn on extra events with a monthly spending cap: once usage passes the free margin, every event above the plan's included amount is charged ($2 per 100,000 on Team, $1 on Scale) on the next invoice, and events keep showing and forwarding until the cap. For an organization's first two months on Team or Scale, extras are free: events keep showing and forwarding past the margin (up to twice the included events), and invoices show what they would have cost. Upgrading or turning on extras shows the hidden events straight away, and you choose whether to send their held deliveries. Past the cap, webhooks keep arriving and are stored (senders get their usual reply), but they're hidden and not forwarded, and owners get an email; raising the cap shows them again and lets you send their held deliveries, or the month resets. At twice the included events, new webhooks are turned away with 429 and not stored until the month resets, in every case: extras on or off, during the introductory offer, and whatever the cap.

Plans: All

Example

On the 18th, Priya gets an email: "Acme has used 812,400 of 1,000,000 events this month. Most came from stripe-prod (521,000)." She finds a health check posting to the endpoint every few seconds and removes it. A product launch still takes Acme to 1.15M, past Team's free 10%, but they had turned on extras with a $20 cap: forwarding never stops, and the next invoice has a line for 150k extra events, $3.

Team+

Audit log

Who changed what, and when.

Details and example

A record of who changed what and when: endpoints, destinations, secrets, members, access tokens, shares, billing and settings, by members, through the API, by WebhookHQ staff or by WebhookHQ itself (a paused destination), with what changed from what to what; secrets only show that they changed. Kept for a year; owners and admins see it in settings.

Plans: Team and above (recorded on every plan, so upgrading shows the last year)

Example

Deliveries to production stopped at 15:40. The audit log shows a teammate changed the destination URL at 15:39 while testing, so you know what to put back. (One-click revert, from stored before and after values, comes later.)

All plans Partly available

Sharing and automatic redaction

Share events, endpoints or workspaces read-only.

Details and example

Status: Sharing events, endpoints and workspaces by link or email works today; automatic redaction is coming.

Share an event, an endpoint or a whole workspace, read-only, with people outside your organization: anyone with a link, or specific email addresses (each person gets their own link by email). Endpoint and workspace shares show webhooks as they arrive. Shares expire after 1, 7 or 30 days and can be revoked at any time, whole or one person at a time; you can see who opened them. To keep shares from being used to send mail in bulk, each member can email shares to at most 30 people an hour, and an organization to 100; links aren't limited. Viewers never see your endpoint URLs, where webhooks are forwarded or anything else in the organization. Team plans will automatically hide secrets and personal data (API keys, card details, emails, phone numbers) in shared views.

Plans: Sharing single events on all plans. Sharing endpoints and workspaces on Team and above. Automatic redaction on Team and above

Example

You need help from Shopify support on a strange payload. You share the event with [email protected]; they open their link without an account. Later you share your Shopify endpoint with a contractor for a week, watch that they've opened it, and revoke their access when the work is done.

Pro+

Export and REST API

Download events, or manage everything from code.

Details and example

Download events as CSV or JSON, and manage endpoints and events from your own code. Exports follow the event list's filters (up to 50,000 events). An export that includes events older than 30 days is prepared in the background, and you get an email with a download link (valid for 7 days). The API covers endpoints (list, create, rename, delete) and events (list with the same filters and JSONPath, read in full with deliveries); see docs/API.md. Reading endpoints and events works on every plan, for the CLI and coding agents, at 600 requests a minute per token.

Plans: Pro and above (reading through the API: every plan)

Example

Your CI pipeline creates a fresh endpoint for each test run, points a GitHub test app at it, then calls the API to confirm the expected events arrived:

curl https://app.webhookhq.dev/api/v1/events?endpoint=ci-run-4821 \
  -H "Authorization: Bearer whq_..."
All plans Partly available

MCP server

Let AI coding agents find, inspect, replay and wait for your webhooks.

Details and example

Status: The server and its four tools work today, signed in with an access token pasted into the client; signing in through the browser (OAuth), organization controls for MCP access, a list of connected apps and MCP calls on the Usage page are coming.

A hosted Model Context Protocol server at https://mcp.webhookhq.dev/v1/mcp that coding agents such as Claude Code and Cursor connect to while you debug. Four tools: find_webhooks (filters and search over the endpoints you can open, short summaries, newest first), inspect_webhook (headers, body, signature check, deliveries with each attempt's response), replay_webhook (to a destination, a public URL or your open whq listen tunnel, only after you confirm) and wait_for_webhook (the next webhook on an endpoint, waiting up to 25 seconds a call). It signs in with an access token from the Access tokens tab and sees exactly what that token can: your workspaces for a personal token, replays only where you're an editor or above. Read tools are marked read-only and replay as a tool that changes something, so clients can ask before it; webhook contents are marked as third-party data that agents must not take instructions from. It follows MCP 2026-07-28 (stateless requests) and answers clients on 2025 versions too. Each tool call is audited. Setup: docs/MCP.md (the website's /docs/mcp).

Plans: All, with no daily cap (300 requests a minute per token)

Example

While fixing a webhook bug, you ask your coding agent, "Find the last failed Stripe event and replay it to localhost after my fix." The agent finds the event, shows you where it would send it, and after you confirm replays it through your tunnel and reports that your app now returns 200.

Scale+ Coming soon

Custom domain

Receive webhooks on your own domain.

Details and example

Receive webhooks on your own domain instead of webhookhq.dev. In settings you add a domain such as hooks.acme.com and create the two DNS records shown: a CNAME pointing to WebhookHQ and a TXT record proving you own the domain. Once DNS has updated, the domain turns Active, HTTPS is set up and renewed automatically, and your endpoints receive at https://hooks.acme.com/<endpoint>[/any/path], with no organization in the path. Your in.webhookhq.dev URLs keep working alongside it. Custom domains receive webhooks only; the dashboard stays on app.webhookhq.dev.

Plans: Scale and above

Example

Your customers configure webhooks to https://hooks.acme.com/orders, which points to WebhookHQ. If you ever change providers, their configuration doesn't need to change.

Scale+ Coming soon

Static outbound IP

Forwarding from fixed IPs your firewall can allow.

Details and example

All forwarding comes from fixed IP addresses that you can add to a firewall allowlist.

Plans: Scale and above

Example

Your company's API only accepts traffic from approved IPs. Security adds WebhookHQ's two outbound IPs to the allowlist once, and forwarding works without opening the firewall to the internet.

Enterprise Coming soon

SSO and SCIM

Company sign-in and automatic member provisioning.

Details and example

Company-wide single sign-on through your organization's identity provider (Okta, Google Workspace, Microsoft Entra ID) over SAML or OpenID Connect, with sign-in enforced for every member. SCIM adds and removes members automatically when people join or leave. This differs from the social sign-in above, which any individual can use.

Plans: Enterprise

Example

When an engineer leaves the company and IT disables their Okta account, their WebhookHQ access is removed the same day without anyone remembering to do it.

Start in a minute

Try it with your own webhooks.

Free to start, with 10,000 events a month. Upgrade when you go to production.

$ curl -X POST https://in.webhookhq.dev/acme-test \
    -H "Content-Type: application/json" \
    -d '{"event": "hello.world"}'

HTTP/2 200

# It's already in your dashboard:
● POST  hello.world   just now