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.

Read more here: https://beeceptor.com/docs/soap-services-dynamic-operation-response/#matching-soap-operations

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.

We’re excited to introduce the AI Rules Generator - a powerful new way to create mock APIs and rules in Beeceptor using natural language.

Instead of manually configuring endpoints, conditions, and responses, you can now simply describe what you need in plain English, and Beeceptor's AI will generate complete rule sets for you.

Skip the manual step, and get your mock behavior up in a few seconds!

Beeceptor just stateful! We're thrilled to roll out Stateful Mocks, giving your mock APIs memory and 'context'. Now you can build more dynamic, personalized APIs, all from the Beeceptor UI.

Here’s what’s new:

• State Variables: Store key-value pairs to simulate things like shopping carts, login sessions, or personalized responses.

• CRUD Routes: Create flexible, schema-less routes with full CRUD support. Push any JSON, import sample data, and simulate real-world APIs like product listings or user profiles.

• Manage state data from the UI: Review, update, and debug your state data directly from the Beeceptor dashboard. No code or workarounds needed!

Get started today and bring your mocks to life with stateful behavior!

Collaboration just got a major upgrade! We're excited to introduce the 'Manager' role. This is designed to give you more control and flexibility when sharing your endpoints.

With this, you can delegate setup and day-to-day management tasks to your teammates without giving up ownership. Managers have nearly full access to a Beeceptor endpoint, with the only exception being billing.

Note: Sharing roles, including Manager, are available on the Team plan and above.

👉 Invite a teammate today and make building together even easier!

We know the struggle: guessing syntax, hunting for the right test data, or figuring out what a request body looked like. So we fixed that.

Here’s what’s new:

• 🧠 Smart Suggestions as You Type: Just type {{ and get instant suggestions for built-in test data generators, request fields, operators, all in one place.
• 🔍 Real Request Data at Your Fingertips: Inserting a request param? See actual example values from past requests so you know exactly what you're picking.
• 📚 Built-In Syntax Help: Each suggestion comes with syntax, description, and a quick example. Jump to the comprehensive docs right from there.

No more guesswork. Just write, pick, and move on. Try it out and build real-looking responses in seconds.

Want to try inserting a product name? Type {{product and let the menu guide you.

Beeceptor's template engine just got more powerful! Now you can use advanced operators and helpers to create dynamic, realistic mock responses with ease.

Examples:

• Math & Logic: {{modulo 7 3}} → 1 and{{round 3.7}} → 4.
• Request Data Handling: {{toFixed (body 'amount') 2}} → Formats request body’s amount to 2 decimal places
• String Manipulation: {{split "1;2;3;4" ";"}} → 1,2,3,4
• Encoding: {{base64 "hello world"}} → aGVsbG8gd29ybGQ=
• Randomization: {{{someOf (array 'car' 'house' 'boat' 'bike' 'land')}}} → Random subset like ["bike","land"]

Build smarter mocks faster, check out the docs.

Beeceptor now supports stateful mock APIs with three powerful persistence helpers, allowing you to maintain context across requests for more realistic API testing.

📦 Data Store (Key-Value)
Store and retrieve values across mock requests, making it easy to persist user details, order IDs, or session data. For example:

{{data-store 'set' 'lastOrder' (body 'orderId') }}
{{data-store 'get' 'lastOrder'}}

🔢 Step Counters
Track numerical sequences like API call counts or sequential order numbers for stateful workflows. For example:

bash
{{step-counter 'inc' 'visitCount'}}  
{{step-counter 'get' 'visitCount'}}  

📜 Lists (Ordered Collections)
Dynamically manage collections by adding, removing, or retrieving items-ideal for workflows like shopping carts, task queues, or multi-step processes.

{{list 'push' 'cartItems' (body 'productId')}}
{{list 'get' 'cartItems'}}

What can done when mocks are stateful?

• 🛒 Maintain a shopping cart across multiple API calls.
• 🛒 Simulate an order processing pipeline where order status changes over time.
• 🔑 Mock login sessions by storing and retrieving session tokens.
• 🔑 Keep track of failed login attempts and enforce temporary lockouts.
• 🔑 Simulate user preferences that persist across requests.
• 📊 Track API usage limits by incrementing counters per user or API key.
• 📊 Implement progress tracking for onboarding flows or multi-step forms.

Beeceptor now supports enhanced array manipulation with the #each helper in its dynamic template engine. You can iterate over arrays in incoming requests, apply transformations, and generate responses that adapt to varying array lengths and structures.

Syntax:

[
{{#each (body 'listOfItems')}} 
   {
      "rank": {{@index}}, "title": "{{this.name}}", "details": "{{this.description}}", "id": "{{faker 'string.uuid'}}"
   }{{#unless @last}},{{/unless}}
{{/each}}
]

Key highlights:

• Leverage @first, @index, and @last variables for conditional logic during iteration.
• Prevent trailing commas in JSON responses with the #unless helper.

Learn more with examples in the documentation.

We’ve made building powerful mock APIs even better by adding date and time formatting! Now you can easily confirm data recency with just a few template tweaks. Check out these handy examples:

• {{now 'utc'}} → Gives date & time in UTC format. E.g 2024-10-13T16:29:58Z
• {{now 'x'}} → Unix epoch time in milliseconds. E.g. 1730177984595

You can also generate relative times with extra parameters:

• {{now '{hours:3}' 'utc'}} → date & time in UTC format, 3 hours from now.
• {{now '{months:-11, days:-1}' 'iso'}} → 11 months and 1 day ago, in ISO format.

Learn more about these updates in the docs.

We are excited to introduce SOAP request handling in Beeceptor! This new feature automatically parses SOAP XML envelopes and converts them into a simplified JSON format. You can now easily refer to parameters in the SOAP request's header and body, and use them in a mock template.

Example:

{{body 'Envelope.Body.GetCityWeatherByZIP.ZIP'}}

For more details, refer to the documentation and examples.