What even is a webhook?
Think of a webhook like a doorbell. When something happens in one app (say, someone fills out a form, pays for something, or sends a message), that app rings the doorbell of another app (your Make.com scenario) by sending it a package of data over the internet.
That "package" is called a webhook payload. It usually looks something like this:
{
"event": "payment.completed",
"customer": {
"name": "Alex Johnson",
"email": "alex@example.com"
},
"amount": 49.00,
"currency": "USD"
}Your Make.com scenario receives that data, and then does something with it. It sends an email, creates a row in a Google Sheet, pings you in Slack, whatever you've set up.
The problem: webhooks fail silently
Here's where things get frustrating. Webhooks are invisible. When your scenario isn't triggering, you don't always know why. Is the other app even sending the webhook? Is it sending data in the right format? Are the field names different from what you expected?
- •The webhook fires but Make.com says "no data received"
- •The data comes through but a field is called
customer_emailinstead ofemail - •You're not sure if the webhook is even firing at all
- •The payload format changes and your scenario silently breaks
The old way to debug this? Trigger the webhook, run the Make.com scenario, cross your fingers, look at the execution history, and try to guess what happened. If something went wrong, start over.
There's a better way.
Enter the Webhook Inspector
The Webhook Inspector is a free tool (built right here on MakeIntegration) that gives you a temporary URL you can point webhooks at. Then you watch the incoming requests in real time, right in your browser.
No account needed. No setup. You just open the tool, grab your URL, and start sending webhooks to it.
- The full body: every field and value in a pretty expandable tree
- The HTTP method: GET, POST, PUT, PATCH, DELETE
- All headers, including content type, authorization tokens, and more
- Query parameters, if the URL has any
?key=valuestuff - The raw body, exactly as it was sent and unformatted
- Timestamp + IP address so you know when and where it came from
Best part? It updates live. The moment a webhook hits your URL, it appears on screen. No refresh needed.
How to use it, step by step
Open the Webhook Inspector
Head to MakeIntegration › Tools › Webhook Inspector. A unique URL is automatically generated for you, like:
This URL is yours for this session. It's saved automatically in your browser, so you can close the tab and come back to it later.
Copy the URL
Click the copy button next to the URL. That's your inspection endpoint. Now go to whatever app you want to test: Stripe, Typeform, Shopify, a custom app, or even Make.com itself.
Point the webhook at your Inspector URL
In most apps, this is in a "Webhooks" or "Integrations" settings page. Paste your Inspector URL as the destination. If you're testing a Make.com outgoing webhook (the HTTP module), put the URL there instead.
Example: Testing a Make.com HTTP Request module
- Add an HTTP › Make a Request module to your scenario
- Set the URL to your Inspector URL
- Set Method to POST
- Add whatever body data you want to test
- Run the scenario once manually
Trigger it and watch
Fire the webhook from your app: submit the form, trigger the event, run the scenario. Within a second or two, the request appears in the Webhook Inspector panel on the left side. Click it, and the full details load on the right.
Dig into the data
Use the tabs to explore:
- BodyThe main payload. Click any arrow to expand nested objects.
- HeadersAuthentication tokens, content types, and other metadata.
- QueryURL parameters (the
?key=valuepart of the URL). - RawThe exact raw text body, as-is.
Hit the copy button to copy the current tab's content, or download the full request as a JSON file if you want to share it or save it.
Practical example: debugging a Make.com webhook trigger
Let's say you're building a scenario that triggers when someone fills out a Typeform survey. You've set up the webhook in Typeform, but Make.com keeps saying it didn't receive any data.
Here's exactly how you'd debug that:
Step A: Verify the webhook is even firing
Temporarily swap the webhook URL in Typeform to your Inspector URL. Submit a test response. Does it show up in the Inspector? If yes, Typeform is sending it. The problem is on the Make.com side. If not, the issue is in Typeform's webhook settings.
Step B: Check the exact field names
Look at the Body tab. You might see that Typeform sends answers under a key like form_response.answers, not a flat answers object. Now you know exactly how to map it in Make.com.
Step C: Check the Content-Type header
Head to the Headers tab. Is the content-type set to application/json? If it's application/x-www-form-urlencoded instead, Make.com will parse the body differently, and that could be your bug.
Tips and tricks
Your session persists across page refreshes
The Inspector saves your session ID in your browser's local storage. Close the tab, come back tomorrow. Your session URL is the same and your requests are still there.
Share your session URL with teammates
The URL in the inspector bar is shareable. Copy it and send it to a colleague. They can open the same session and see the same requests. Useful for async debugging.
Use "New Session" to start fresh
If you're done with a test and want a clean slate, click "New Session". This generates a brand new URL with no history. Use "Clear" to just wipe the request list without changing your URL.
Download the JSON for reference
The download button saves the full request (method, headers, body, query params) as a JSON file. Great for documenting exactly what an API sends before you build your Make.com mapping.
Wrap up
Webhooks are one of the most powerful features in Make.com, but they're also one of the most frustrating to debug when things go wrong.
The Webhook Inspector gives you a live X-ray view of everything being sent and received. Instead of guessing, you can see it. Once you know exactly what the data looks like, mapping it in Make.com becomes trivial.
It's free, no account needed, and takes about 10 seconds to start using. Give it a try next time you're wrestling with a webhook.
Try the Webhook Inspector
Free, instant, no sign-up required.