Webhook debugging for vibe coders

You vibe coded it.
Now see what it actually does.

Your AI wrote the webhook handler from the docs. It never saw the request your account really sends. Eventfy catches every event hitting your app, shows you the payload that broke it, and replays it until the code is right — no second payment, no second signup.

Try Eventfy free See how it works
5 days free · card saved, not charged · cancel any time
EXAMPLE
What the dashboard shows
Total caught
0
Success
0
Failed
0
Avg. response
0
Inkie the Eventfy octopus
Why the generated handler broke

The code looked right.
The request didn't match.

Someone pays and the account never upgrades. Someone signs up and the welcome email never sends. An order lands and the workflow never runs. Nothing on screen looks broken — the frontend is fine, the provider says 200, and your app is still online.

The hard part isn't writing the handler. Your AI did that in seconds. The hard part is that neither of you has ever looked at the request it was supposed to handle.

The model wrote it from the docs.

It knows the shape a Stripe or Clerk payload usually has, because it has read thousands of examples. It has not read yours — where a field is optional, an amount arrives as a string, or an event type comes through that the handler has no branch for.

"It works on my machine" isn't testable.

You can't ask Stripe to send you that one payment again. Reproducing a failed checkout means making another real checkout, and reproducing a broken signup means another real signup. Eventfy keeps the original request so you replay it instead.

You can't paste an error you never saw.

Debugging with an AI works when you can hand it the failure. Eventfy gives you the actual payload, the headers, the status your endpoint returned and every delivery attempt — the context that turns "it's not working" into a fix.

Nobody tells you it failed.

The customer's card was charged, so Stripe is happy. Your site never threw an error, so your host is happy. The event went missing somewhere in between, and the first person to notice is usually the customer.

Four steps. No terminal
archaeology required.

You don't need to know how webhooks work to use this. You paste one URL into the service that's calling your app, and from then on every request it sends is captured, named, and readable — with a button to send it again once you've fixed the code.

01 — CAPTURE

Paste one URL. That's setup.

Drop your Eventfy URL wherever Stripe, Clerk, Supabase, Shopify or your own API asks for a webhook endpoint. It's permanent, so it keeps catching whether your laptop is open or not.

02 — INSPECT

Read the request your AI guessed at

Full payload, headers and raw body, tagged with whoever sent it. Copy the real JSON straight into Cursor or Claude Code so the handler gets rewritten against your data, not the documentation's.

03 — REPLAY

Send the same event again

Edit any field and re-fire the exact event that broke your handler — at your deployed app or at localhost:3000 through the CLI. No second checkout, no second signup, no test card.

04 — AUTOMATE

Make something happen next

Once it works, stop watching it. Set conditions once and Eventfy forwards matching events or posts them to Slack and Discord, automatically.

What actually happens
when a webhook fires.

Most tunnelling tools just ask you to trust them. Here's exactly what Eventfy does with your data, in order, every single time.

Click a step to see it in action
← Click a step to see it in action
Catch URL
https://www.eventfy.space/api/catch/x7k2m Copy
Works with
Stripe GitHub Shopify Clerk + anything else
Connected — listening for events
First event received · stripe.customer.createdjust now
Incoming payload
{ "type": "payment_intent.succeeded",
  "data": { "amount": 2900 },
  "id": "evt_3P9k2mFz..." }
↓ fingerprinted in 8ms
STRIPE
payment_intent.succeeded
Signature verified · 14:22:07
✓
stripe.com — sends the event0ms
↓ <10ms
Eventfy — catches & fingerprints9ms
↓ split
Dashboard — logged & visible11ms
eventfy listen — injected locally12ms
↓
localhost:3000 — your code runs13ms
Terminal
$ eventfy listen 3000 --server www.eventfy.space --lens <token>
✓ forwarding → localhost:3000
200 stripe.payment_intent.succeeded
↓ landed
200 OK POST /webhook · localhost:3000
Editing the payload before re-firing
{ "type": "payment_intent.payment_failed",
  "data": { "amount": 2900,
    "decline_code": "insufficient_funds" } }
↓ re-fired against localhost
200 OK
Handler processed the edited payload
No real charge, no real decline — just your code, tested
✓
Saved as step 3 of "Stripe failure paths" test suite
Debug

Fix it in minutes.
Not after a complaint.

Three things that turn "my app just doesn't do anything" into a fix you can paste into your editor — the difference between a bug nobody notices and one that costs you your first paying customer.

See the payload, not a status code

Every event lands in a live timeline — green for success, red for failure — with the full body, the headers, and the raw request one click away. Eventfy recognises Stripe, Clerk, GitHub, Shopify and a dozen others on sight and labels them, so you don't have to know what evt_1P… means to find the one that failed.

Included on every plan

Replay the exact event that broke it

Stop recreating payments, orders and signups just to reproduce a bug. Pull the original payload from history, change any field — flip succeeded to payment_failed — and hit Re-fire as many times as it takes.

Edit any field before sending

Find the one request that broke production

A searchable history of everything that ever hit your endpoint, filtered by provider, status or date. Save the payloads that matter as a test suite and replay them all in one click — or from CI, so the next deploy checks itself.

30 days to 2 years, by plan
Automate · Eventfy Flows

Turn real events into
real workflows.

Debugging is for when something's broken. Flows is for when it works and you'd rather never touch it again — built on the same events you're already catching, so there's no second integration to wire up.

Included from the Pro plan up — 5 active Flows on Pro, up to 100 on Business.
Click a step to see it in action
← Click a step to see it in action
Trigger
stripe.customer.subscription.deleted
Event landed on Cancellations — checking Flow conditions…
FLOW "Notify on cancellation" triggered ✓
Conditions — all must match
payload.data.object.amountgreater_than5000
platformequalsstripe
MATCH Both conditions passed ✓
No conditions? Every event on the trigger runs the Flow.
Actions — run in order
Webhook forwarded · localhost:3000200 · 42ms
Slack message sent · #billing-alertsok
Discord message sent · #opsok
Logged to the Flow's run history either way — including which conditions failed, if any.
How you actually debug it

A broken webhook,
fixed in four steps.

No reproducing the original action, no guessing from logs. This is the whole loop.

1  Find the failure

Open the timeline and filter to failed. Every event shows the status your endpoint returned and how many delivery attempts it took.

2  Read what was sent

Open the event for the full payload, the headers, and the raw body — the exact request your handler received, not a summary of it.

3  Fix, then re-fire

Change your code, then send that same event again — at your deployed app or at localhost through the CLI. Edit any field first to test the case you couldn't reproduce.

4  Confirm it holds

Save the payload as a test suite step and replay it from CI, so the next deploy checks itself against a real request rather than a fixture someone invented.

Or let your AI do it

If you build with an AI, it can debug with one too.

Eventfy ships an MCP server, so Claude Code, Cursor, Claude Desktop or any MCP-capable assistant can drive it while you build. Your assistant reads the real request instead of guessing at the payload shape — which is usually why the generated handler was wrong. Install once and ask in plain English.

  • "What just failed?" — pulls the failed events with their payloads, headers and the error from each delivery attempt.
  • "What shape is this payload?" — returns every field path and type, so it can write your handler or your types against a real request instead of a guess.
  • "I'll trigger it now — tell me what arrives." — waits for the next live event and reads it back.
  • "Send that one again." — re-fires the exact event at your endpoint once you've changed the code.
$ npm install -g eventfy-cli  &&  eventfy-mcp --key <your-api-key>

17 tools covering webhook URLs, events, re-fires and Flows. Included from Pro.

The same afternoon, twice

Shipping takes an hour.
Finding the bug takes three days.

The build was never the hard part. The hard part starts the moment a real payment, a real signup or a real order goes through something you have no window into.

Without it
You"Build me a SaaS."
ClaudeDone.
You"Add Stripe."
ClaudeDone.
CustomerPays £49
StripePayment successful ✓
Your app???
Webhook✕
You find out when the customer emails you.
With Eventfy
CustomerPays £49
StripePayment successful ✓
EventfyEvent captured ✓
EventfyYour app returned 500
YouRead the payload. Fix the handler.
YouReplay the event
Your app200 OK ✓
Fixed before the customer noticed.

Don't guess. See exactly what happened.

Eventfy lets you capture the event, inspect the payload, find the problem and replay it — without recreating the original action.

Try Eventfy free

Built fast. Debugged properly.

Cursor, Claude Code, Lovable, Bolt, v0, Replit — whatever built it, the integrations behave the same way once real users arrive. Eventfy is the window into that half. Read the full report on where vibe-coded apps break →

Payments

See what happened when a Stripe payment didn't trigger correctly.

Signups

See whether your signup event actually reached your application.

Orders

Inspect and replay Shopify events without creating another order.

APIs & webhooks

See the requests moving between the services your app depends on.

Develop

Real events, straight into
localhost.

Run one command and live webhooks arrive in your local project as you build. No exposed ports, no tunnel URL that changes on every restart, no ten minutes lost each morning before you can start work.

  • Installs as a single global package — npm install -g eventfy-cli.
  • Auto-reconnects if your laptop sleeps or your wifi drops.
  • Replay a saved test suite from CI — it exits non-zero if anything fails.
$ npm install -g eventfy-cli
$ eventfy listen 3000 --server https://www.eventfy.space --lens <token>
 
✓ connected  → www.eventfy.space
✓ forwarding → localhost:3000
 
200 stripe.payment_intent.succeeded 11ms
200 github.push · main 8ms
500 shopify.orders.create — retrying 204ms
$

Your entire request history,
always searchable.

Event history
2 years
On Business — 30 days on Individual
Filter operators
14
Match on any field in the payload
Actions per Flow
5
Forward, Slack, Discord — in order
Free trial
5 days
Card saved, nothing charged
Works with anything that sends a webhook — including
Stripe Clerk Supabase Shopify GitHub Vercel Resend Twilio PayPal Polar Lemon Squeezy Paddle Slack Discord Notion Linear Airtable Calendly

Pricing plans

Most teams get the plan back the first time it helps them catch a broken payment or a missed deploy before a customer does.

Individual
For solo developers debugging their own integrations.
£29/ month
 
Start Free Trial
  • 5 webhook URLs
  • 30-day event history
  • Localhost forwarding via the CLI
  • Up to 3 test suites
  • Automation — not included
Pro most popular
For developers who want to automate what happens next.
£49/ month
 
Start Free Trial
  • Everything in Individual, plus:
  • Eventfy Flows — 5 active automations
  • Webhook → webhook, Slack, Discord actions
  • Automation run history
  • 20 webhook URLs, 180-day history
  • Unlimited test suites
Team
For teams building and monitoring integrations together.
£149/ month
 
Start Free Trial
  • Everything in Pro, plus:
  • 25 active Flows
  • 100 webhook URLs, 1-year history
  • Up to 5 workspaces
  • Up to 5 team members
Business
For production-scale webhook infrastructure.
£399/ month
 
Start Free Trial
  • Everything in Team, plus:
  • 100 active Flows
  • Unlimited webhook URLs, 2-year history
  • Up to 20 workspaces
  • Priority onboarding
Eventfy Enterprise
Built around your infrastructure — custom team size, event volume, retention, SSO, and a contract that fits how you actually work. We build what you need when you need it, not before.

Every plan starts with a 5-day free trial — full access. Card details are processed securely via PayPal's Advanced Checkout (they never touch our servers) — your card is saved, not charged, and nothing is billed until the trial ends. Prices shown outside the UK are estimates in your local currency (incl. a currency conversion fee) — the exact price is set by your billing address at signup.

Start your free trial

Five days free.
Card saved, not charged.

Pick a plan, save a card, and nothing is taken until the trial ends. Cancel any time before then and you are not charged at all.

Eventfy
Individual
Cardholder
Your name
Billing & payment
Your card details go straight into PayPal's secure fields — they never touch our servers. Your card is stored, not charged: nothing is taken until your 5-day trial ends.
Start your free trial
Eventfy Individual
Eventfy Individual £29/month
✓ 5 days free — nothing charged today
Due today £0.00
Your card is saved securely, not charged. Your first payment is taken when the free trial ends, and you can cancel before then.

    Before you ask.

    The things people usually want to know before they hand over a card.

    Because the model wrote it from documentation and examples, not from your data. It knows the shape a Stripe or Clerk payload usually has. It has never seen the one your account actually sends, where a field is optional, an amount is a string, or an event type arrives that the handler does not branch on. Eventfy shows you the real request so the handler can be written against it.
    No. Setup is pasting one Eventfy URL into Stripe, Clerk, Supabase or Shopify where it asks for a webhook endpoint. From then on, everything that service sends is captured and readable, and Eventfy names the event types and flags the failures for you.
    Yes. Eventfy ships an MCP server, so Claude Code, Cursor and Claude Desktop can list failed events, read the real payload shape, wait for the next live event, and re-fire an event after you change the code. It is included from the Pro plan.
    No, that is the point of re-firing. Eventfy keeps the original request, so once you have changed your code you send the same event again, as many times as you need, without a second payment, order or signup.
    Because they're read-only. Stripe or Shopify will show you that a request was sent and what it got back — but you can't send it again at your local machine, you can't change a field first to test the failure path, and you can't search across every provider in one place. Eventfy keeps the payload and lets you re-fire it, edited, as many times as you need.
    Those are general no-code automation tools with hundreds of app connectors. Eventfy is built around one thing — the webhook itself — so it does the parts they don't: inspecting the raw request, replaying it with edits, forwarding it into localhost, and keeping a searchable history. Flows then automate the same events you're already debugging, rather than being a separate system you configure from scratch.
    Every payload your catch URL receives, successful or failed, counts once toward your monthly total. If you use Re-fire to replay something from history, that replay counts as a new event too — it's a real request, not a preview.
    Yes. Any service that can send a webhook to a URL works — Eventfy doesn't care who's sending it, only that something arrived. If it can POST to a link, Eventfy can catch it.
    Because it isn't a browser request. Re-fire runs from Eventfy's servers as a genuine outbound HTTP call, the same way the original webhook arrived — so it reaches localhost or a staging environment cleanly, with none of the cross-origin restrictions a browser-based replay would trip.
    Your card is billed automatically for the plan you picked at signup once the trial ends. You can cancel any time before then and you won't be charged at all — your card is stored at signup, not billed. Your event history and webhook URLs stay in place either way.
    Tunnels are great for exposing localhost, but the URL usually changes every time you restart, and if your laptop is closed or the tunnel drops, whatever fires in that window is just gone. Eventfy's catch URL is hosted and permanent — paste it into Stripe once and it keeps working whether your machine is on or not, with every event waiting in your history when you get back.
    Not right now. Eventfy runs as a hosted service so your catch URL and CLI tunnel work the moment you sign up — no infrastructure to stand up or maintain on your end.
    Yes, in transit and at rest. How long events stick around depends on your plan — 30 days on Individual, 180 on Pro, 1 year on Team, 2 years on Business. Need something longer or more specific? Enterprise plans can request a custom retention window.

    You shipped in a weekend.
    Don't debug it for a month.

    See the real request. Fix the handler your AI guessed at. Replay it until it holds. Then automate what happens next.

    Start your free trial 5 days free · card saved, not charged · cancel any time