4,500+ servers built on MCP Fusion
Vinkius

Beeceptor MCP. Mock APIs and Debug Webhooks with Your AI Agent

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Beeceptor MCP on Cursor AI Code Editor MCP Client Beeceptor MCP on Claude Desktop App MCP Integration Beeceptor MCP on OpenAI Agents SDK MCP Compatible Beeceptor MCP on Visual Studio Code MCP Extension Client Beeceptor MCP on GitHub Copilot AI Agent MCP Integration Beeceptor MCP on Google Gemini AI MCP Integration Beeceptor MCP on Lovable AI Development MCP Client Beeceptor MCP on Mistral AI Agents MCP Compatible Beeceptor MCP on Amazon AWS Bedrock MCP Support

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.

+ 26 more capabilities included
Mock API Rule Management

Create, read, update, or delete specific rules that define how a mocked API should respond to incoming HTTP requests.

Webhook Traffic Inspection

List and inspect the full details of every incoming HTTP request—including headers and payloads—as they hit your mock endpoint.

Network Configuration Control

Manage global settings for an endpoint, such as enabling CORS policies or setting up mTLS certificates, to control network access.

API Specification Upload

Upload industry-standard OpenAPI or Swagger files to automatically generate a full set of mock endpoints and rules.

Session State Management

Store and retrieve key-value pairs across multiple API calls, allowing your mock service to maintain data context (e.g., tracking a user ID).

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

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.

add019e5cff

add certificate

Attaches an mTLS certificate to your endpoint for secure connection testing.

bulk019e5cff

bulk replace rules

Replaces multiple existing mock rules simultaneously with a new set of behaviors.

create019e5cff

create rule

Creates a single, specific mock rule that defines how an API should respond to a certain request path.

delete019e5cff

delete all rules

Deletes every single mock rule currently configured on your endpoint.

delete019e5cff

delete certificate

Removes an existing mTLS certificate from the endpoint settings.

delete019e5cff

delete request

Removes a single, specific historical request log entry.

delete019e5cff

delete requests

Clears out all stored request history logs for debugging purposes.

delete019e5cff

delete rule

Deletes one specified mock rule from the endpoint's active ruleset.

delete019e5cff

delete spec

Removes an uploaded OpenAPI or Swagger specification file entirely.

delete019e5cff

delete state

Bulk deletes multiple stored state items that were used during testing.

delete019e5cff

delete state item

Deletes a single, specific key-value pair from the session state storage.

download019e5cff

download multipart

Downloads files that were uploaded or processed as part of a multipart request.

get019e5cff

get job status

Checks the status of an asynchronous job, usually after uploading a large API specification file.

get019e5cff

get request

Retrieves the full details (headers, body) for one specific historical request log entry.

get019e5cff

get rule

Fetches all the current configuration and details for a single mock rule.

get019e5cff

get settings

Gets the current global network settings for an endpoint, including CORS status and logging options.

get019e5cff

get spec details

Retrieves the full metadata and structure of a previously uploaded API specification file.

get019e5cff

get state item

Reads the stored value associated with a single key in the session state.

list019e5cff

list certificates

Lists all currently available mTLS certificates configured for the endpoint.

list019e5cff

list requests

Retrieves a paginated list of recent historical requests that hit your mock API.

list019e5cff

list rules

Gets an overview and count of every active mock rule on the current endpoint.

list019e5cff

list state

Lists all currently stored state keys and their values in bulk.

reorder019e5cff

reorder rules

Changes the processing order of multiple rules, which matters for complex routing logic.

update019e5cff

update rule full

Overwrites every detail of an existing mock rule with a completely new configuration set.

update019e5cff

update rule partial

Modifies only specific parts (like the response body or status code) of an existing mock rule without touching others.

update019e5cff

update settings

Changes global endpoint settings, such as enabling logging or modifying CORS headers.

upload019e5cff

upload blob

Uploads a binary file (like an image or document) to be used in the mock response payload.

upload019e5cff

upload spec

Ingests and validates a new OpenAPI/Swagger specification, generating rules from it.

upsert019e5cff

upsert 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
Start building

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. 1 First, connect the server by supplying your Beeceptor API Key.
  2. 2 Next, use an action like create_rule or update_settings to define the specific mock behavior you need (e.g., status code, response body).
  3. 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.

Frontend Developer

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.

QA Engineer

Simulates failure states, timeouts, or specific error responses (like 401 Unauthorized) to rigorously test how an application handles bad data.

Backend Developer

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_rule to 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_state to 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 with update_settings.
  • Build APIs from specs. Instead of writing dozens of rules by hand, use upload_spec with an OpenAPI file. Beeceptor generates the whole rule set automatically.

Real-World Use Cases

01

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.

02

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.

03

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.

04

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

How we secure it →

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

add_certificate bulk_replace_rules create_rule delete_all_rules delete_certificate delete_request delete_requests delete_rule delete_spec delete_state delete_state_item download_multipart get_job_status get_request get_rule get_settings get_spec_details get_state_item list_certificates list_requests list_rules list_state reorder_rules update_rule_full update_rule_partial update_settings upload_blob upload_spec upsert_state

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.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 29 tools

We've already built the connector for Beeceptor. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 29 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

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.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.