Beeceptor MCP. Mock APIs and Debug Webhooks with Your AI Agent
Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Beeceptor lets your AI client build, manage, and debug mock APIs and HTTP proxies directly from natural language commands. It's a proxy for testing—you can simulate complex backend dependencies, inspect real webhook traffic, and control network settings (like CORS) without writing any server code.
What your AI agents can do
Add certificate
Attaches an mTLS certificate to your endpoint for secure connection testing.
Bulk replace rules
Replaces multiple existing mock rules simultaneously with a new set of behaviors.
Create rule
Creates a single, specific mock rule that defines how an API should respond to a certain request path.
Create, read, update, or delete specific rules that define how a mocked API should respond to incoming HTTP requests.
List and inspect the full details of every incoming HTTP request—including headers and payloads—as they hit your mock endpoint.
Manage global settings for an endpoint, such as enabling CORS policies or setting up mTLS certificates, to control network access.
Upload industry-standard OpenAPI or Swagger files to automatically generate a full set of mock endpoints and rules.
Store and retrieve key-value pairs across multiple API calls, allowing your mock service to maintain data context (e.g., tracking a user ID).
Ask AI about this MCP
Supported MCP Clients
Waiting for input…
Beeceptor MCP Server: 29 Tools for Mock API & Proxy Management
Use these tools to programmatically create rules, inspect traffic logs, manage state, and control network settings across your mocked APIs.
019e5cffadd certificate
Attaches an mTLS certificate to your endpoint for secure connection testing.
019e5cffbulk replace rules
Replaces multiple existing mock rules simultaneously with a new set of behaviors.
019e5cffcreate rule
Creates a single, specific mock rule that defines how an API should respond to a certain request path.
019e5cffdelete all rules
Deletes every single mock rule currently configured on your endpoint.
019e5cffdelete certificate
Removes an existing mTLS certificate from the endpoint settings.
019e5cffdelete request
Removes a single, specific historical request log entry.
019e5cffdelete requests
Clears out all stored request history logs for debugging purposes.
019e5cffdelete rule
Deletes one specified mock rule from the endpoint's active ruleset.
019e5cffdelete spec
Removes an uploaded OpenAPI or Swagger specification file entirely.
019e5cffdelete state
Bulk deletes multiple stored state items that were used during testing.
019e5cffdelete state item
Deletes a single, specific key-value pair from the session state storage.
019e5cffdownload multipart
Downloads files that were uploaded or processed as part of a multipart request.
019e5cffget job status
Checks the status of an asynchronous job, usually after uploading a large API specification file.
019e5cffget request
Retrieves the full details (headers, body) for one specific historical request log entry.
019e5cffget rule
Fetches all the current configuration and details for a single mock rule.
019e5cffget settings
Gets the current global network settings for an endpoint, including CORS status and logging options.
019e5cffget spec details
Retrieves the full metadata and structure of a previously uploaded API specification file.
019e5cffget state item
Reads the stored value associated with a single key in the session state.
019e5cfflist certificates
Lists all currently available mTLS certificates configured for the endpoint.
019e5cfflist requests
Retrieves a paginated list of recent historical requests that hit your mock API.
019e5cfflist rules
Gets an overview and count of every active mock rule on the current endpoint.
019e5cfflist state
Lists all currently stored state keys and their values in bulk.
019e5cffreorder rules
Changes the processing order of multiple rules, which matters for complex routing logic.
019e5cffupdate rule full
Overwrites every detail of an existing mock rule with a completely new configuration set.
019e5cffupdate rule partial
Modifies only specific parts (like the response body or status code) of an existing mock rule without touching others.
019e5cffupdate settings
Changes global endpoint settings, such as enabling logging or modifying CORS headers.
019e5cffupload blob
Uploads a binary file (like an image or document) to be used in the mock response payload.
019e5cffupload spec
Ingests and validates a new OpenAPI/Swagger specification, generating rules from it.
019e5cffupsert state
Sets or updates one or more key-value pairs in the session state storage in bulk.
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 Beeceptor, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ 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
What you can do with this MCP connector
You're gonna build, manage, and debug mock APIs and HTTP proxies with your AI client using this server. It lets you simulate complex backends without writing a line of actual code. You can control everything from the initial network setup to deep session state management.
When you start up, if you need a clean slate for testing, you've got tools like delete_all_rules and delete_requests right here—they clear out every single mock rule or historical request log entry on the endpoint. You can also wipe out stored session data using delete_state, or just remove one key-value pair with delete_state_item.
If you uploaded a big OpenAPI/Swagger file, you can scrap it entirely with delete_spec.
To define how your mock API behaves, you've got total control over the rules. You start by uploading industry-standard specs using upload_spec, which ingests and validates the data to generate a full set of initial mock endpoints. If you need to change those rules later, you can create a single rule with create_rule or overwrite everything an existing rule uses with update_rule_full.
For minor tweaks—say, changing just the status code or the response body without touching other settings—you use update_rule_partial. You can get a read on what rules are active using list_rules, and you can fetch all the details for one specific rule using get_rule.
Dealing with multiple rules? You can reorder them with reorder_rules, which is crucial when your routing logic depends on sequence. If you need to manage those specs, you can get their full metadata structure by calling get_spec_details. Sometimes you just want to check what rules are already set up; that's where list_rules comes in handy.
When it comes to webhooks and debugging incoming traffic, this server is your best friend. You can list all recent historical requests with list_requests, getting a paginated overview of everything that hit the mock API. For deep dives, you retrieve every single detail—headers, body, everything—for one specific request using get_request.
If you're debugging stateful calls, you manage data persistence by setting or updating key-value pairs in bulk with upsert_state, or reading a stored value for a single key using get_state_item; you can also list all current keys and values using list_state.
To get the whole picture of your setup, you check the global network settings with get_settings. Here you manage access control by modifying CORS headers using update_settings, or adding security layers by attaching an mTLS certificate via add_certificate; if that cert needs removing, you use delete_certificate.
Need to send data back in a mock response? You can upload binary files like images or documents with upload_blob so they show up when your client calls the endpoint. When testing complex scenarios, you also have tools to manage state history: you get status updates for long jobs using get_job_status, and if you're doing a bulk cleanup of stored data items, you use delete_state.
You can check what certificates are currently configured by running list_certificates.
Every action is logged. Besides the general request history, you get full visibility into how your endpoint operates by getting the current configuration and details for any single rule with get_rule, or simply checking which rules exist using list_rules. If you want to see what data was stored before a test run, you can list all state keys using list_state.
How Beeceptor MCP Works
- 1 First, connect the server by supplying your Beeceptor API Key.
- 2 Next, use an action like
create_ruleorupdate_settingsto define the specific mock behavior you need (e.g., status code, response body). - 3 Finally, ask your agent to test it (e.g., "Run a POST request against /data"). The server intercepts and returns the mocked response based on the rules.
The bottom line is: you tell the system what API behavior you need, and it makes it happen instantly for debugging or development testing.
Who Is Beeceptor MCP For?
This is for developers who hate writing boilerplate server code just to test a single endpoint. If your job involves simulating external services—like payment gateways, user logins, or third-party webhooks—you need this. It cuts out the time spent spinning up temporary staging servers.
Needs to quickly mock a backend dependency (e.g., loading product data) so they can build and test the UI without waiting for the actual API team.
Simulates failure states, timeouts, or specific error responses (like 401 Unauthorized) to rigorously test how an application handles bad data.
Debugs complex webhooks and third-party callbacks by inspecting payloads in real time, ensuring the system correctly processes incoming messages.
What Changes When You Connect
- Test API failure states instantly. Use
create_ruleto set up a 401 Unauthorized response for/login, letting you test your client's error handling without needing the real auth service. - Stop manually checking webhooks. With
list_requests, you can see every single incoming payload and header from a third party, making debugging callback integrations fast and painless. - Manage complexity with state. Use
upsert_stateto pass user session IDs between API calls (e.g., getting an ID in step 1, and using that same ID in the mock call for step 2). - Control network security on demand. Need to test a private connection? Add an mTLS certificate using
add_certificate, and control access withupdate_settings. - Build APIs from specs. Instead of writing dozens of rules by hand, use
upload_specwith an OpenAPI file. Beeceptor generates the whole rule set automatically.
Real-World Use Cases
Simulating a Payment Gateway
A developer needs to test checkout flow but the actual payment API is down. They use upload_spec with the Stripe OpenAPI file, which generates all necessary mock rules. Then, they use get_state_item to track the transaction ID across multiple simulated calls, ensuring the front end handles success and failure codes correctly.
Debugging a Third-Party Webhook
A user signs up for a service that sends an event webhook every time. The backend fails to process it because of missing headers. They use list_requests to capture the exact incoming payload, identify the missing header, and then update their application logic.
Testing User Session Context
A multi-step form requires the user ID from step one to process in step three. Instead of building a backend database mock, they use upsert_state to save the user ID after the first call, and then instruct their agent to retrieve that value using get_state_item for the final mocked API call.
Migrating an Existing API
A team receives a massive set of API endpoints documented in Swagger. Instead of spending days writing rules, they simply feed the file via upload_spec. This instantly creates all required mock endpoints and saves hours of setup time.
The Tradeoffs
Creating Rules One by One
A developer needs 50 endpoint mocks but manually calls create_rule fifty times, leading to a massive prompt block and high cognitive load.
→
Don't write rules individually. Use the OpenAPI specification file via upload_spec. This single action generates all necessary mock endpoints in bulk.
Forgetting State Context
A test requires that a user be authenticated before retrieving data, but the developer forgets to pass or check the authentication token between calls.
→
Use upsert_state immediately after login. The subsequent API call can then use get_state_item to retrieve and verify the necessary session token.
Ignoring Traffic Logs
A webhook fails, but the developer assumes it's a code issue and doesn't check what data was actually sent by the source system.
→
Always use list_requests or get_request. Inspecting the raw payload tells you exactly if the problem is on your end or if the source system sent bad data.
When It Fits, When It Doesn't
Use this server if your primary pain point is simulating external services—meaning, you need a fake backend to keep development moving while the real API isn't ready. It excels at debugging webhooks and managing complex state across calls.
Don't use it if you need full computational logic (e.g., running machine learning models or database queries). For that, you need a dedicated compute server. If your problem is merely organizing code structure, use a standard version control system like Git, not this mocking tool. This tool simulates the network layer; it doesn't replace actual data processing.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Beeceptor. 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 server provides 29 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Debugging webhooks means clicking between three different tabs just to see what payload was sent.
Today, when a third-party service hits your webhook, you have to jump into the hosting platform's dashboard. You manually filter by time window, then copy the raw JSON payload and paste it somewhere else to debug which header or field caused the failure. It’s tedious; you spend more time debugging the tool than the code.
With Beeceptor, that process goes away. You ask your agent to list requests, and instantly, all incoming traffic is displayed right here. The agent shows you the full headers and payload for every single webhook hit via `list_requests`. You get immediate visibility into what went wrong.
Beeceptor MCP Server: Control API Rules & Certificates
Before, if you wanted to test a different version of your API (say, v1 instead of v2), you had to deploy multiple branches or manually adjust configuration files on a staging server. If you needed specific security testing, setting up an mTLS certificate was a multi-day process involving ops teams.
Now, you just tell the agent what you need. Need mock rules? Use `create_rule`. Need stronger encryption? Add an mTLS cert with `add_certificate`. You control the entire API lifecycle—from mocking to security setup—right here.
Common Questions About Beeceptor MCP
How do I use Beeceptor MCP Server to mock a full OpenAPI spec? +
You upload the file using upload_spec. This ingests the entire API structure and automatically generates all necessary endpoints, rules, and documentation for your agent to use.
What is the difference between `create_rule` and `update_rule_partial`? +
create_rule makes a brand new rule. Use update_rule_partial when you need to tweak an existing rule—like changing only the response body or status code—without affecting its path or method.
Can I pass data between API calls using Beeceptor MCP Server? +
Yes. Use upsert_state to save critical context (like a user ID) and then retrieve it later with get_state_item within subsequent mock rules.
How do I check if my endpoint settings are correct? +
Run the get_settings tool. This gives you the current state of CORS, logging, and any other global parameters configured for the entire endpoint.
How do I check the status of my client-side TLS with `list_certificates` on Beeceptor MCP Server? +
It lists all active mTLS certificates configured for your endpoint. This process confirms that your AI agent can access and manage secure connections, ensuring strong authentication between services.
Using `delete_requests`, how can I remove large amounts of stored request history from the Beeceptor MCP Server? +
You run delete_requests to wipe out request logs. This is useful for compliance or when you need a clean slate between debugging cycles, keeping your payload and header data private.
When debugging webhooks, what information does `get_request` provide about incoming payloads? +
It retrieves the full details of a single request. You get access to both the complete JSON or form body payload and all associated HTTP headers for deep inspection.
Can Beeceptor MCP Server use `bulk_replace_rules` to modify multiple endpoints simultaneously? +
Yes, bulk_replace_rules handles mass rule updates efficiently. This tool lets you change the mock responses or paths across many rules at once without running individual commands.
Can I enable CORS for my mock endpoint through the AI? +
Yes. You can use the update_settings tool to toggle CORS, request logging, and other endpoint features instantly.
How do I see the payloads of recent requests sent to my Beeceptor subdomain? +
Use the list_requests tool. It retrieves a list of recent incoming HTTP calls, allowing your agent to analyze headers and body content.
Is it possible to simulate a database or state between API calls? +
Yes, Beeceptor provides a key-value store. You can use upsert_state to save data and get_state_item to retrieve it in subsequent mock responses.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Jamendo
Search and stream music from the Jamendo catalog — find tracks, albums, and artists, and explore playlists directly from your AI agent.
PagerDuty
Manage incidents, services, on-call schedules, and escalation policies via PagerDuty — trigger, acknowledge, and resolve alerts from any AI agent.
Apiary
Manage your API design-first workflows via Apiary — read blueprints, publish docs, and run tests directly from your AI agent.
You might also like
Nhost
Manage Nhost authentication and storage — handle user sign-ins, registrations, profile management, and file uploads directly from any AI agent.
USCIS Case Status (Immigration)
Track USCIS immigration case statuses and processing history directly from your AI agent using receipt numbers.
Azure Synapse Analytics
Manage your Azure Synapse data pipelines seamlessly — audit Spark pools, SQL pools, datasets, and integration pipelines via your AI agent.