Webhook.site MCP for AI. Inspect and control every API callback payload.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
Webhook.site MCP lets you instantly create, manage, and inspect HTTP webhooks and API requests. You can generate custom URLs, capture raw payloads, set specific response codes, and test complex third-party integrations without setting up local tunnels or public servers.
Perfect for debugging backend logic and validating callbacks in a conversational environment.
What your AI can do
Create action
Create a custom action for a token
Create global variable
Create a global variable
Create token
Create a new Webhook.site token (URL)
Create new webhooks with specific aliases, set expiry dates, and manage the overall collection of active webhook tokens.
Retrieve detailed metadata for any incoming HTTP request, including headers, query parameters, and the full raw payload body.
Define custom HTTP status codes, headers, and response content to accurately mimic complex failure or success scenarios.
Execute pre-configured actions against specific webhooks, allowing you to automate parts of your development pipeline.
Create and manage environment-wide variables that allow you to track state across multiple webhook tests or debugging sessions.
Ask an AI about this
Waiting for input…
Webhook.site: 17 Tools for API Debugging
These tools let you manage the full lifecycle of HTTP requests, from creating new webhook endpoints to analyzing historical payloads and simulating custom responses.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Webhook.site on VinkiusCreate Action
Create a custom action for a token
Create Global Variable
Create a global variable
Create Token
Create a new Webhook.site token (URL)
Delete Action
Delete a custom action
Delete Global Variable
Delete a global variable
Delete Requests
Delete multiple requests for a token
Delete Token
Delete a token
Execute Action
Execute actions for a specific request
Get Requests
Get requests captured by a token
Get Token
Get details for a specific token
List Actions
List custom actions for a token
List Global Variables
List global variables
List Tokens
List Webhook.site tokens
Set Response
Set dynamic response for a specific request
Update Action
Update a custom action
Update Global Variable
Update a global variable
Update Token
Update an existing token
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The Webhook.site integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Webhook.site, then connect any of our 5,000+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,000+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Webhook.site. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 17 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Dealing with callback chaos today is a nightmare.
Right now, testing webhooks means juggling multiple tools: setting up local tunnels (like ngrok), configuring specific test accounts on external services, and then manually copying payloads from browser developer consoles just to pass them around in documentation. It’s slow, it breaks when the service updates its API, and you're always guessing if the payload you captured is truly representative of production.
With this MCP, that whole process shrinks down to a few conversation turns. You tell your agent what webhook needs testing; it gives you a clean, dedicated URL. The moment a test callback hits, the data appears for immediate inspection and manipulation—no tunnels needed, just pure debugging power.
Using Webhook.site MCP Gives You Request Visibility
You eliminate the need to manually manage test endpoints or write complex mock servers in your local environment. Instead of having a bunch of code just to *receive* data, you get an interactive layer that lets you view everything—headers, query parameters, and raw JSON payloads—all in one place.
This MCP means development time shifts from infrastructure setup to actual problem-solving. You spend less time debugging the connection and more time perfecting your logic.
What your AI can actually do with this
This MCP lets your agent function as an API testing rig. You stop guessing how external services talk to your system and start inspecting the data flow directly. It’s built for developers who need to test complex integrations, simulating everything from successful payments to malformed error responses.
The tool gives you control over the entire request lifecycle. You can define custom webhooks with specific aliases and expiration times. When a webhook fires—whether it's a payment processor or an external service—your agent captures every detail: headers, query parameters, and the raw payload body. Need to test how your app reacts to a 404 error? You use a function to set custom HTTP status codes and response bodies for that specific request.
This whole process is designed to integrate into larger systems; for example, once you capture data here, you can easily chain it with another MCP in the Vinkius catalog—like passing the captured user ID directly to an email sending tool or a billing record creator—all within one agent conversation.
It’s pure debugging power. You get full visibility into every incoming request, and you never have to worry about where your keys sit; credentials pass through a zero-trust proxy that only uses them in transit.
019e5d67-1897-7212-89f9-4dca1fe2f7c0 
Here's how it actually works
The bottom line is that it gives you an API gateway interface inside your chat window, letting you manage complex webhooks without leaving your conversation flow.
First, your agent needs the Webhook.site API Key. You enter this key into Vinkius.
Next, tell your agent what you need—for example, 'Create a new webhook URL for my staging environment' or 'Show me all requests for token XYZ.'
The MCP executes the request, and your agent returns structured data, giving you access to the URLs, payloads, or historical logs needed.
Who is this actually for?
Backend Developers and QA Engineers who hate setting up local tunnels or running dedicated test servers. You're the person who has to validate if a third-party service callback works correctly, but you don’t have access to that external endpoint in staging.
You use this MCP to test new API endpoints and webhooks against dummy data, ensuring your services handle various payloads (success, failure, unexpected fields) before deployment.
You validate third-party callbacks by simulating specific request types—like a payment failed or an account suspended—and confirming the system reacts exactly as required.
You monitor incoming alert streams from production systems and use this MCP to inspect payloads, triggering automated responses based on real-time data flow.
What Changes When You Connect
Stop relying on manual setup. You can use the create_token tool to generate a unique testing URL in seconds, letting your agent handle the rest of the debugging process.
Don't just read logs; manipulate them. Use set_response to force a specific HTTP status code or body content. This lets you validate how your system handles error states (like 500 Internal Server Error) reliably.
Need to debug state? The MCP lets you use functions like create_global_variable and update_global_variable. Your agent can track variables across multiple, distinct webhook calls, which is critical for complex multi-step processes.
Clean up fast. When a test run is done, use the delete_requests tool to purge old data from a token's history, keeping your logs clean and focused on what matters.
Build full workflows by chaining services. You can capture request data via this MCP and then feed that structured payload into another service MCP in the Vinkius catalog for processing.
See it in action
Validating a Stripe Webhook Payload
A payments developer needs to confirm how their backend processes a payment.succeeded event from Stripe. Instead of setting up a local listener, they use the MCP to create a token and then ask the agent to capture requests hitting that URL. They inspect the raw payload using get_requests to verify every field is present.
Simulating a Failure State
A QA engineer needs to test how the user dashboard behaves when an external service times out. They use the MCP's capability to define custom responses, telling the agent to set status 503 and a specific error message payload, allowing them to validate failure logic.
Debugging Multi-Service Flows
A DevOps team is building an automation where receiving a webhook should trigger both logging and billing. They use the MCP to capture the initial request data; then they pass that clean payload through two different, chained MCPS (e.g., Messaging and Billing) to ensure the data integrity remains high across platforms.
Cleaning Up Test Data
After a week of intense debugging cycles involving dozens of temporary webhook URLs, the developer uses list_tokens to see what's active and then executes delete_token on old or abandoned URLs to keep the environment clean.
The honest tradeoffs
Treating it like a simple data store
Just calling 'get_requests' repeatedly without context, which results in reading massive, unusable blocks of raw JSON and making the agent output too verbose to parse.
Always narrow your scope. If you only care about payloads from yesterday, use list_tokens first, then reference that specific token when calling get_requests, or ask the agent to filter by date/method type.
Trying to process data live
Assuming that just because you capture a payload using 'get_requests', your agent can immediately act on it without setting up rules.
You have to set the expectation first. You must use set_response or execute_action to define how the captured data should be processed, otherwise, it's just a log file.
Overwriting state accidentally
Calling 'update_global_variable' with the wrong key name or overwriting a variable needed for a subsequent step in your workflow.
Before you update any global variable, use list_global_variables to confirm the exact existing keys and values. Treat these variables like constants.
When It Fits, When It Doesn't
Use this MCP if your job requires testing how a system reacts to external data feeds or callbacks—think Stripe, Shopify, GitHub, etc. If you need to intercept an HTTP request payload, inspect headers, or simulate a failure state (4xx/5xx), this is the tool. Don't use it if all you need to do is save simple key/value pairs; for that, just using basic global variables might suffice. You should also avoid using this MCP if your entire process happens within one monolithic service—it’s designed specifically when external systems are involved and you need a debugging layer in between.
Questions you might have
How do I start testing a webhook with Webhook.site MCP? +
Start by using create_token to generate a unique URL for your test. Then, tell the agent which token you want to monitor so it's ready when an incoming request fires.
Can I use Webhook.site MCP to simulate a successful payment? +
Yes. You can define custom headers and body content using set_response to force the agent to return a 201 Created status with the specific JSON payload that simulates a successful transaction.
What’s the difference between `get_requests` and `list_tokens`? +
list_tokens shows you all your available webhook URLs, while get_requests pulls the actual historical data—the payloads and headers—that have hit a specific token.
Does Webhook.site MCP handle sensitive keys securely? +
Yes. Credentials pass through Vinkius's zero-trust proxy, which means they are used only in transit and never stored on disk anywhere the user's keys sit.
What tool do I use if I need to purge old or unnecessary webhook payloads? (Using `delete_requests`) +
You should use the delete_requests tool. This lets you target and clear specific log entries from a token, regardless of how many were received. You can define time windows or criteria, which keeps your history manageable without losing important data.
How do I simulate an API error response using the `set_response` tool? +
You configure this with set_response. This allows you to model failure scenarios by setting custom HTTP status codes, headers, and body content for a specific request. You can accurately test how your application handles various types of errors.
Can I use `create_global_variable` to maintain state between different webhook calls? +
Yes, that’s the core purpose of global variables. By using create_global_variable, you store persistent data in your environment. This lets multiple unrelated webhooks read from and write to the same central state.
If I create a token that is no longer needed, how do I properly remove it? (Using `delete_token`) +
You must use the delete_token tool. This command completely removes the webhook URL and all associated configurations from your account. It's important for maintaining a clean and secure environment.
How can I create a temporary webhook URL that expires after one hour? +
Use the create_token tool and set the expiry parameter to 3600 seconds. You can also add an alias to make the URL easier to identify.
Can I see the headers and body of the requests sent to my webhook? +
Yes! Use the get_requests tool with your Token ID. It will return a list of captured requests including full headers, query strings, and the raw payload content.
Is it possible to make the webhook return a specific JSON response? +
Absolutely. Use the set_response tool to define a custom content (base64 encoded), status code, and JSON headers for any specific request received by your token.
We've already built the connector for Webhook.site. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 17 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.