Beeceptor already supports SSO with Google, GitHub, and Azure. Now, you can use OTP for signup and login, so you don’t need to rely on passwords.

You can also enable “Restricted Mode” to disable password logins entirely and allow only OTP or SSO.

API implementations evolve constantly, but OpenAPI specifications often fall behind. Your developers keep adding endpoints, modify responses, or change payload structures, while the contract documentation stays outdated. This contract drift can break API clients, invalidate mocks, and cause confusion across development and QA teams.

Beeceptor continuously monitors your APIs to keep your contract accurate. After you upload an OpenAPI specification, Beeceptor records real API traffic and validates every request and response against the spec. When a mismatch appears, Beeceptor flags it as contract drift and shows the exact difference.

Beeceptor AI then generates a smart patch based on the observed traffic. Review it and apply the update to your OpenAPI spec with a single click.

Detection, patching, and commit happen in seconds, saving hours of manual contract maintenance.

Our OpenAPI-to-Mock capability already lets you go from an API specification to a live mock server in under a minute. You upload an OpenAPI spec and instantly see your API come to life with realistic, contextual responses. Instead of static placeholders, Beeceptor automatically generates meaningful test data - product names, people names, ages, street addresses, SSN/Aadhaar numbers, and more - using AI and 300+ built-in data generators. You get a mock API that looks and behaves much closer to a real production system.

Now we’re taking this a step further with custom response overrides.

While Beeceptor can automatically generate contextual responses, you can now override and customize any part of the generated response/field to match your exact testing needs. Want specific product names, controlled user profiles, or predictable IDs for integration tests? You’re in full control.

How: Switch to your endpoint settings and open Customize Test Data under the specification section.

No coding. No infrastructure. No deployments.
Just upload OpenAPI spec and start building.

If you run into syntax errors while building a dynamic response template for your mock rule, Fix with AI is here to help. Available directly from the error notification, it intelligently corrects the issue inline. Whether you’re working with JSON or XML, it focuses only on the relevant syntax errors, so you don’t have to spend time debugging formatting details.

You can stay focused, designing your mock APIs. It’s fast, context-aware, and built to save you time. Give it a try today![we think you’ll love how much smoother template editing becomes!

Beeceptor now supports payments in Chinese Yuan (CNY), making it easier for customers to pay using their local currency.

Along with existing support for USD, INR, GBP, EUR, BRL, JPY, and AUD, Beeceptor now covers most major regions with localized payment options, helping you subscribe and manage billing more conveniently worldwide.

Customers in India can pay using UPI, while wire transfer / bank payments are available for annual plans. Beeceptor also supports PO-based order processing for organizations that require purchase order workflows.

When external/vendor APIs act unpredictably, go offline, or return unexpected errors, your test coverage takes a hit. Beeceptor now includes a built-in Forward Proxy that routes outbound HTTP(S) traffic, intercepts API calls, and gives you precise control over how upstream services behave during a test run. You can now observe real network traffic in flight, and build hebahiors without changing application code. You get full control over your test scenarios.

With Forward Proxy you can intercept specific API or HTTP calls, inspect request and response payloads, and create mock rules to simulate targeted scenarios such as failures, 500 errors, latency spikes, or custom responses. You can deliberately trigger edge cases and validate how your application performs under stress.

Beeceptor's Forward Proxy integrates seamlessly with existing mocking, rules engine, and traffic inspection capabilities.

Key use cases:

• Inspecting and logging outbound API calls during end-to-end test runs.
• Validating request structure before traffic reaches external systems.
• Selectively mocking specific third-party APIs while allowing others to pass through.
• Simulating upstream failures such as timeouts, 4xx, or 5xx responses.
• Injecting controlled test data into live integration flows.
• Reproducing production issues safely in lower environments.

Beeceptor now shows in real time who is actively editing a mock rule, so you always know what’s happening before making changes. If someone is working on a rule, now you can see it immediately, helping you avoid accidental overwrites and confusion. You can now confidently keep building and refining mocks without second guessing who’s editing what.

We’ve made it much easier to bring your 2FA codes into Beeceptor. You can now simply drag-n-drop or paste image files, or even scan a QR code directly using your device camera if your QA code is on another device, making the experience faster and more seamless for sandbox and test authentication.

You can also generate a persistent link to retrieve future codes whenever you need them, so you don’t have to repeat the setup every time.

We’ve shipped brand-new user interface for Beeceptor! All the existing features remain the same, now presented in a cleaner and more intuitive design. The updated UI offers better contrast, and improved readability, making it easier to find what you need and work faster.

Alongside the visual update, we’ve rewritten the Rules Engine behind the scenes to deliver better performance and reliability.

This upgrade not just makes Beeceptor faster, easier to use, and eliable, but also helps us ship new features faster in the future. All these, without impacting your existing integrations.

Managing more than ten rules is now smoother with an upgraded, stable interface.

• Search instantly across request path, rule ID, request body, and more for accurate filtering.
• Search results show high-quality matches and hide irrelevant ones.
• New or updated rules auto scroll into view with a highlight so you never lose track.
• Jump from request history directly to the matching rule with a single click.
• Reorder rule priority easily by dragging the leftmost icon.

Beeceptor now supports localized test data for mock responses, enabling you for region-accurate demos.

You can set a preferred locale per endpoint, and Beeceptor will generate names, addresses, phone numbers, dates, and more based on that region. The synthetic data generation is supported in Portuguese, Spanish, English, French, Indonesian, or Chinese languages.

Beeceptor supports path templates that work the same way developers define routes in Django, Spring Boot, Express, FastAPI, and Rails. Write something like /orders/:orderId/items/:itemIndex and it matches just as you expect. Beeceptor extracts each named parameter, URL-decodes it, and makes it available in responses using below syntax:

{{pathParam 'orderId'}}

A rule matching with path template ensures -

• trailing slashes don’t cause mismatches
• dynamic segments resolve consistently
• path segments are URL decoded

Beeceptor’s stateful lists just became far more powerful! You can now simulate dynamic data structures like stacks, queues, sets, and arrays - bringing real-world stateful API behavior in your mock services.

The upgraded list now supports several intuitive operations:

• size - Returns the number of items in the list.
• shift - Removes and returns the first item (ideal for FIFO queue simulations).
• unshift - Adds an item to the start of the list.
• contains - Checks if a value already exists.
• push-unique - Appends an item only if it doesn’t already exist (set-like behavior).
• update - Modifies an existing item in place.

These new operations open up new possibilities - think task queues that process in-order, stacks that track user actions, or sets that keep your data clean and unique. You can even simulate live data flows like message processing, shopping carts, or session states - all right inside Beeceptor, without touching a real backend.

The new Body Parameter Matching operator enhances request matching for REST APIs that send structured JSON data in the request body. Beeceptor now parses the body and evaluates specific parameters-making it possible to match requests based on nested fields or items in an array.

You use dot notation to reference any field within a JSON data. This is like XPath, but for JSON. For example, match requests using keys like user.email, user.demographic.country, or user.addresses.0.city.

Beeceptor’s Local Tunnel now includes a browser security interstitial to protect users from phishing and credential theft.

Key details:

• Shows a warning page when a Local Tunnel URL is opened from a web browser.
• Helps users confirm they’re intentionally visiting a local tunnel.
• Protects against phishing vectors that mimic popular social or financial services to steal credentials.
• API traffic remains unaffected - the warning appears only for browser-based access.

Beeceptor applies this warning intelligently and selectively - it appears only when a local tunnel endpoint is accessed interactively through a browser.

This strengthens Beeceptor’s commitment to user safety, protecting against misuse while keeping it seamless for automation and API testing.

Start building your frontend with GraphQL! We are thrilled to launch the [GraphQL Mock Server](https://beeceptor.com/graphql-mock-server), the fastest way to turn your Schema Definition Language (SDL) into a live, fully-functional endpoint.

Upload the schema (or introspect a live API!) and get a mock server instantly. Here’s the magic:

• 🧠 AI-Powered Test Data: Beeceptor analyzes your schema's field names, data types, and relationships to generate realistic, contextual mock data-not just random placeholders. User names look like names, emails look like emails.
• Instant Setup: Upload your .graphql file or paste an introspection URL. Beeceptor validates, deploys, and gets your endpoint live in seconds.
• Full Operation Coverage: Supports Queries, Mutations, and Subscriptions right out of the box, ensuring you can test the entire client-side experience.
• Schema-Aware Resolution: Every mock response is 100% type-safe and schema-compliant, preventing runtime errors and ensuring your data shapes are always correct.

You told us managing large rule sets could slow you down. We listened - here are some new features for power-user workflow, making it easier to manage mock servers with 50+ mock rules.

What’s new:

• Updated rules highlight instantly - never lose track of changes.
• Smart search keeps the right rule always in view.
• Precise results, even in big rule sets.
• From request history → one-click jump to the matched mock rule.

Faster changes, less friction - so you can focus on testing with confidence.

You can now use state variable filters in Beeceptor to build smarter, context-aware mock APIs.

Key highlights:

• Customize responses based on user preferences stored as key-value pairs.
• Simulate retry logic by tracking counters across requests.
• Enforce quotas or rate limits using counter thresholds.
• Model user journeys with cleaner mock rules.
• Build state machines where the state changes on each API call.

This update makes it easier to design mocks that behave closer to real production APIs-without writing extra code.

The new SOAPAction Matches filter in mock rules makes it easier to handle and test SOAP/XML-based requests. This filter allows you to create mock rules that specifically target the SOAP requests, giving better support for SOAP-based integrations.

Beeceptor automatically detects the SOAP action from various request components, ensuring smooth matching without the need to worry about version compatibility in your mock rules.

Now, a faster and smarter way to spin up mock servers directly from your OpenAPI specs.

You can now upload your API contract and get a fully functional mock server in under a minute, complete with realistic, demo-friendly response data - all powered by Beeceptor's AI.