# Beeceptor MCP for AI Agents AI Agent Connect > Beeceptor MCP lets you build, manage, and monitor mock APIs and HTTP proxies directly through your AI agent. It handles request logging, rule creation, and state management so you can test webhooks and backend dependencies without writing real server code. ## Overview - **Category:** developer-tools - **Price:** Free - **Endpoint:** https://edge.vinkius.com/vk_preview_yMcAgY4AoI9RN5MBzAq1ZxJ0JFyGbDPrTCKLzG2z/ai-agent-connect - **Tags:** mock-api, http-proxy, api-testing, webhook-debugger, rest-api ## Description Beeceptor lets you build, manage, and monitor mock APIs and HTTP proxies directly through your AI agent. Instead of manually spinning up mock environments or writing boilerplate code to simulate responses, you can just tell your agent what the API should do. It handles the heavy lifting of creating endpoints, setting up CORS, and managing request logging. You'll find it's a huge time-saver when you're trying to build out a frontend before the backend is actually ready. It also works great for debugging webhooks because you can see every payload hitting your proxy in real-time. If you need to keep track of data across multiple calls, you can manage state like a key-value store. It's one of the more practical tools available in the Vinkius catalog for anyone who spends their day wrestling with integration points and edge cases. You can even drop in an OpenAPI spec to let the agent generate mock endpoints for you automatically. This means you can test your entire flow from the client side to the endpoint without actually having to host a single line of production code. Whether you are trying to simulate a flaky third-party payment gateway or just need to see how your app handles a specific status code, Beeceptor gives you the control you need to move fast. ## Tools ### delete_state Remove specific items from your mock state. This helps keep your state storage clean. ### download_multipart Download a multipart file from a request. Use this to inspect file uploads in your logs. ### get_job_status Check the status of a specification upload job. This helps you know when your mock is ready. ### get_request Fetch the details of one specific request. This lets you drill down into a single interaction. ### get_rule Retrieve details for one mock rule. Use this to see the exact configuration of a specific path. ### get_settings View your current endpoint settings. This shows your active CORS and logging configurations. ### get_spec_details Get the details of a specific API specification. This confirms what was uploaded to your mock. ### get_state_item Fetch a single item from your state storage. Use this to get data used in previous requests. ### list_certificates See all mTLS certificates currently active. This helps you manage your proxy security. ### list_requests Get a list of all incoming request history. This is your primary way to debug webhooks. ### list_rules See all active mock rules for your endpoint. Use this to audit your current mock behavior. ### list_state View all current state items. Use this to see what data your mock is currently holding. ### upload_spec Upload an OpenAPI or Swagger file. This automatically generates mock endpoints from your docs. ### upsert_state Bulk update or insert items into your mock state. This is the fastest way to seed state data. ### add_certificate Add an mTLS certificate to your proxy. This is necessary for secure, authenticated connections. ### bulk_replace_rules Swap out multiple mock rules at once. It's much faster than updating rules one by one. ### create_rule Create a new mock rule for a specific endpoint. This defines how the agent responds to a request. ### delete_all_rules Wipe every mock rule from your current setup. Use this to reset your environment completely. ### delete_certificate Remove an mTLS certificate from your proxy. This clears out old security credentials. ### delete_request Remove a single request from your history. This keeps your logs focused on what matters. ### delete_requests Clear out your entire request history. It's the quickest way to wipe your logs. ### delete_rule Delete a specific mock rule. Use this when you no longer need a particular behavior. ### delete_spec Remove an uploaded API specification. This clears out old documentation from your mock environment. ### delete_state_item Delete a single item from your state. This is useful for targeted state cleanup. ### reorder_rules Change the sequence of your mock rules. This is important when multiple rules might match a path. ### update_rule_full Update every part of a mock rule. Use this for significant changes to an endpoint's behavior. ### update_rule_partial Change just one part of a mock rule. This is the way to go for small tweaks like a status code. ### update_settings Change your endpoint settings like CORS or logging. Use this to adjust your proxy configuration. ### upload_blob Upload a binary blob for your mock. This allows you to serve static data from your mock. ## Prompt Examples **Prompt:** ``` I need to mock a login endpoint that returns a 401 if the password is wrong. ``` **Response:** ``` I've set up the mock rule for your login endpoint. Here is the configuration: | Method | Path | Status | Behavior | | :--- | :--- | :--- | :---| | POST | `/login` | 401 Unauthorized | Returns `{"error": "Invalid credentials"}` Your agent can now simulate this behavior for your frontend tests. ``` **Prompt:** ``` Show me the last few requests that hit my webhook URL. ``` **Response:** ``` I'm pulling the latest traffic from your proxy now... **Recent Webhooks:** * **POST** `/callback` - `200 OK` * *Payload:* `{"event": "user.signup", "id": "usr_9921"}` * **POST** `/callback` - `200 OK` * *Payload:* `{"event": "user.login", "id": "usr_9921"}` Would you like to see the headers for the first one? ``` **Prompt:** ``` Create a mock for a weather API that returns a 200 and some fake temperature data. ``` **Response:** ``` I've created a new mock rule for the weather API. It will now return the following data for all GET requests: ```json { "city": "San Francisco", "temp": 68, "condition": "Cloudy" } ``` You can start testing your weather widget immediately. ``` ## Capabilities ### Create mock API rules Define how your agent should respond to specific paths and methods. ### Inspect incoming traffic See real-time request logs to debug webhooks and external callbacks. ### Manage API state Store and retrieve data across different mock requests for persistent behavior. ### Upload API specs Turn OpenAPI or Swagger files into live mock endpoints instantly. ### Configure proxy settings Set up CORS, authentication, and logging for your subdomains. ### Manage mTLS certificates Handle secure connections with custom certificates for your proxy. ## Use Cases ### Frontend Mocking A developer needs to build a checkout page but the payment API isn't ready. They ask the agent to create a mock rule for /pay that returns a 200 OK. ### Webhook Debugging A dev is confused why a stripe webhook isn't firing. They use the agent to call `get_request` and see the actual JSON payload hitting the proxy. ### Edge Case Testing A QA engineer wants to see if the app crashes on a 503 error. They tell the agent to use `update_rule_partial` to return a 503 status for the /user endpoint. ### Rapid Prototyping A founder wants to see an API flow. They upload a Swagger spec and use `get_settings` to verify the mock environment is live. ## Benefits - Stop waiting on backend teams by using `upload_spec` to turn documentation into live mock endpoints instantly. - Debug messy webhooks faster by using `list_requests` to see every payload and header in real-time. - Simulate complex app behaviors by creating and managing specific responses with `create_rule` and `reorder_rules`. - Keep your mock data persistent across different calls by using `upsert_state` and `get_state_item` for key-value storage. - Handle secure connections easily by managing mTLS certificates with `add_certificate` and `list_certificates`. - Save time on repetitive tasks by using `bulk_replace_rules` to update multiple behaviors in one go. ## How It Works The bottom line is you get a live, programmable mock environment that your agent can control and monitor in real-time. 1. Subscribe to the Beeceptor MCP and add your API key to your AI client. 2. Tell your agent to create mock rules or upload a specification for your desired endpoint. 3. Start sending requests to your mock URL and watch the logs appear in your agent's view. ## Frequently Asked Questions **What does Beeceptor MCP do for my development?** It lets you create mock APIs and proxies that your agent can interact with. You can simulate real backend behavior without actually building the backend yet. **Can I use Beeceptor MCP to test webhooks?** Yes. You can use it to intercept and view every request that hits your proxy, making it easy to see the exact data being sent by third-party services. **How does Beeceptor MCP handle API documentation?** You can upload OpenAPI or Swagger specs, and the Connector will automatically turn those definitions into mock endpoints for you. **Can I store data in Beeceptor MCP?** Yes, it includes state management tools. You can save and retrieve information across different requests, which is great for simulating things like user sessions. **Is Beeceptor MCP good for QA testing?** It's perfect for QA. You can easily set up rules that return specific error codes or simulate slow responses to see how your app handles failures. **Can I manage security with Beeceptor MCP?** You can manage mTLS certificates through the Connector, allowing you to set up secure, authenticated connections for your mock environment. **How does Beeceptor MCP help with frontend work?** It removes the blocker of waiting for backend APIs. You can get a functional mock environment immediately so you can build out your UI. **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.