Beeceptor MCP for AI. Fake APIs and Proxies for Testing
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
Beeceptor lets you build, manage, and test mock APIs and HTTP proxies directly from your AI agent. You can simulate backend services—like payment gateways or user profiles—by creating specific rules, managing complex state data, and inspecting real-time request history without writing server code.
What your AI can do
Add certificate
Adds a new mutual TLS (mTLS) security certificate for the endpoint.
Bulk replace rules
Replaces multiple mock rules across endpoints at once.
Create rule
Sets up a single, specific mock API rule (e.g., what response to send for a GET request).
Create specific mock rules and update complex API behaviors using simple commands.
List and inspect every incoming HTTP request in real-time, helping you debug webhooks or third-party integrations.
Store key-value pairs across multiple mock calls, ensuring your simulated service remembers context (like a user's session ID).
Configure security settings for endpoints, including CORS rules and authentication requirements.
Ask an AI about this
Waiting for input…
Beeceptor with 29 Tools
These tools let your AI agent build, inspect, and maintain mock APIs—from creating simple rules to handling complex security certificates.
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 Beeceptor on VinkiusAdd Certificate
Adds a new mutual TLS (mTLS) security certificate for the endpoint.
Bulk Replace Rules
Replaces multiple mock rules across endpoints at once.
Create Rule
Sets up a single, specific mock API rule (e.g., what response to send for a GET...
Delete All Rules
Removes every existing mock rule from the system.
Delete Certificate
Deletes an mTLS security certificate that was previously added.
Delete Request
Removes a single, specific request record from the history log.
Delete Requests
Clears all historical records of incoming API traffic.
Delete Rule
Deletes one specific mock rule from the system.
Delete Spec
Removes a previously uploaded API specification file.
Delete State Item
Removes a single, specific data item from the persistent state storage.
Delete State
Clears all saved state items in bulk from the key-value store.
Download Multipart
Allows you to download binary file content that was processed by the mock API.
Get Job Status
Checks the status of a background job, like processing an uploaded specification.
Get Request
Retrieves the full details for one specific request recorded in the history log.
Get Rule
Fetches all the details for a single mock rule you created.
Get Settings
Retrieves the current configuration and settings for an entire endpoint.
Get Spec Details
Gets detailed metadata about a specification file that was uploaded.
Get State Item
Retrieves the value associated with one specific key-value pair in storage.
List Certificates
Lists all active mTLS certificates configured for the endpoint.
List Requests
Retrieves a list summary of recent incoming API requests.
List Rules
Shows a summary list of all mock rules currently active on the endpoint.
List State
Retrieves an overview listing all current state items stored in memory.
Reorder Rules
Changes the processing order of multiple mock rules on an endpoint.
Update Rule Full
Completely replaces all details for a specific mock rule, overwriting everything.
Update Rule Partial
Modifies only certain parts of an existing mock rule (e.g., changing the response body without touching the method).
Update Settings
Changes general configurations for an endpoint, like enabling logging or CORS.
Upload Blob
Allows you to upload arbitrary binary files into the system.
Upload Spec
Ingests an OpenAPI or Swagger file so mock endpoints can be generated automatically.
Upsert State
Adds or updates one or more key-value pairs in the state storage, ensuring data...
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 Beeceptor 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 Beeceptor, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ 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 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 connection provides 29 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Manual API Mocking is a Nightmare
Today, if your backend service isn't ready, you have to manually deal with broken calls. You copy over old JSON payloads and paste them into local dev servers or use complicated environment variables just to make the frontend compile. Then, every time a small change is needed, you're clicking through multiple tabs—the documentation, the mock server console, and the code—just to get a single endpoint working.
With this MCP, you don't touch any local config files or fake JSON copies. You talk to your agent, telling it exactly what the API needs to return. The system handles creating, updating, and running all those rules for you, so you just focus on writing code that works.
Beeceptor MCP: Control Your Entire Mocking Lifecycle
You eliminate the need to juggle separate tools for logging and rule management. Instead of checking one console for status, another place for rules, and a third place for state, you use your agent to orchestrate it all. You can list all active rules with `list_rules` then immediately get details on a specific endpoint's configuration using `get_settings`.
This gives you total control over the test environment from one spot. Your workflow stays contained and traceable because every rule, certificate, and state item is managed through defined tools like `create_rule`, `list_certificates`, and `upsert_state`. Period.
What your AI can actually do with this
When you're building a client application, the last thing you want is to wait for the full backend team to finish their endpoint. This MCP lets your AI agent connect to an external service that acts as a fake API layer. You can set up mock rules, defining exactly what response your app gets when it calls a certain URL—whether that’s a successful data payload or a specific 401 error code.
It's how you isolate components for testing. If you need to simulate complex interactions, like tracking user state across multiple API calls, this MCP handles the storage and retrieval. Connecting Beeceptor via Vinkius gives your agent access to a full catalog of tools, letting it manage everything from endpoint settings to request logging in one place.
019e5cff-46ec-716a-8bd8-a25d618b761a 
Here's how it actually works
The bottom line is you get an instant, controllable proxy layer that lets your agent treat any external API like it's running locally on your machine.
Subscribe to this MCP and provide your Beeceptor API Key.
Your agent executes a command like create_rule or list_rules to set up the required mock endpoints and rules.
The system processes the request, making the simulated endpoint immediately available for testing by your AI client.
Who is this actually for?
Frontend developers who are blocked waiting for a backend endpoint. QA engineers needing to force-test edge cases (like timeouts or specific 500 errors). Backend developers debugging third-party webhook payloads that fail intermittently.
Needs to mock the data layer for a new feature before the backend team deploys it. They'll use create_rule and update_settings constantly.
Must simulate failure conditions, like invalid certificates or missing state data. They rely on tools like add_certificate and list_requests to validate failures.
Uses this MCP to test webhook integrations from external systems by inspecting every payload using get_request and cleaning up history with delete_requests.
What Changes When You Connect
You can simulate complex API behavior by setting specific rules, which is necessary when you don't have access to the actual backend service. Need to test failure? Just use create_rule to force a 503 error.
Debugging webhooks is easier than ever. Instead of guessing where the payload broke, your agent uses list_requests and get_request to show you exactly what came in—headers, body, everything.
It handles state management. If your API needs to know if a user has already paid, you use upsert_state. The mock service keeps track of that data across multiple calls so it feels real.
You don't have to manually configure security settings. Use update_settings to toggle CORS or request logging for an endpoint with a single command.
Building from specs is fast. Uploading OpenAPI files via upload_spec automatically generates all the necessary mock endpoints, saving hours of manual configuration.
See it in action
Testing complex user flows
A developer needs to test a multi-step checkout process that relies on three separate services (inventory, payment, shipping). They use create_rule for each service and upsert_state to maintain the order ID across all mock calls. This confirms the entire flow works even when only one piece of code is available.
Debugging external webhooks
A third-party payment processor sends a webhook that sometimes fails and sometimes succeeds. The QA engineer uses list_requests to capture all traffic, then uses get_request on the failed entry to check headers for specific error codes.
Simulating rate limits
A team needs to test how their app handles being throttled. They use update_settings to enable request logging and then write a mock rule that returns a 429 Too Many Requests status, confirming the client handles the limit gracefully.
Migrating from old APIs
The team needs to test a new API version against legacy clients. They upload the Swagger spec using upload_spec and then use get_spec_details to verify all necessary endpoints are mocked correctly before code is written.
The honest tradeoffs
Wiping everything with delete_all_rules
A developer gets frustrated and runs delete_all_rules because one mock endpoint isn't working. They lose all the temporary, valid rules they had set up for another feature.
Instead of deleting everything, check what you need first. Use list_rules to see exactly which rules exist, then use delete_rule or update_rule_partial on just the broken endpoint.
Overwriting state by default
A developer forgets they set a temporary user ID in the mock state and runs a new test. The subsequent call doesn't see the original data because the state was reset.
Always remember to explicitly save or retrieve context. Use get_state_item before making an action, then use upsert_state immediately after to persist the result.
Using wrong update functions
Trying to change a single response body using update_rule_full, which forces you to re-specify the method and path, wasting time.
Only modify what's necessary. Use update_rule_partial when you just need to tweak the response payload or headers without touching the rule's core definition.
When It Fits, When It Doesn't
Use this MCP if your problem is 'I need a fake API layer right now to keep development moving.' You must use it when you are debugging webhooks, testing front-to-front flows, or isolating components. Don't use it if you need full production load balancing or advanced traffic splitting; for that, you'd look at dedicated service mesh tools. Use this MCP if you require granular control over every response code and data payload (e.g., forcing a 401 error). If all you need is to see historical logs, list_requests is enough. But if you also need to set up the rules, manage state, and change settings like CORS, this MCP handles the whole loop.
Questions you might have
How do I test a request failure using the create_rule tool? +
You use create_rule to define the specific path and method, then set the desired response status code (like 401 or 500) in the payload definition. This forces your application to handle error states correctly.
Can I make sure my mock API remembers data from a previous call? Which tool handles this? +
Yes, you use state management tools. Call upsert_state to save key-value data (like an authenticated user ID) and then retrieve it later with get_state_item within the same mocked workflow.
How do I see what traffic has hit my mock API recently? Do I need list_requests? +
You use list_requests to get a summary of recent activity. For full debugging, run get_request on the specific ID to view all headers and payloads from that single call.
Do I need to delete everything manually when my project is done? Is there a clean-up tool? +
Yes. You can use tools like delete_all_rules, delete_requests, or delete_state to wipe out all mock configurations, historical logs, and saved data.
How do I secure my mock endpoint using the add_certificate tool? +
You use add_certificate to establish an mTLS certificate. This adds a critical layer of security, ensuring that only clients presenting the correct private key can interact with your mocked API.
If I have an OpenAPI specification file, how do I use the upload_spec tool? +
Upload your full API spec using upload_spec. The system analyzes the document and automatically generates a comprehensive set of mock endpoints. This is much faster than manually creating every single rule.
How do I change endpoint settings like CORS or enable logging using update_settings? +
You use update_settings to manage these global parameters. This lets you configure things such as cross-origin access (CORS) and request logging without having to adjust individual mock rules.
What's the best way to update dozens of mock behaviors quickly? Should I use bulk_replace_rules? +
Yes, if you need to change many rules at once, bulk_replace_rules is your best bet. It allows you to overwrite or modify large groups of existing rules with one single command.
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.
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.
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.