The Best Open-Source API Mocking Tool for developers (With examples)

Building frontend applications often means waiting for backend APIs to be ready. This can slow down development and leave teams stuck. API mocking tools let you simulate backend endpoints to test and build your applications in parallel, even if the backend is delayed or incomplete.

This article will help you understand what API mocking tools are and why they’re important, and highlight some of the best open-source tools.

What are API Mocking Tools?

API mocking tools are solutions that simulate real API responses. They let you create a “fake” version of an API endpoint that behaves like the real thing. Instead of waiting for the backend team to finish, you can set up mock endpoints and keep developing.

For example, if you’re working on a shopping site and the backend product listing API isn’t done, you can mock an endpoint like /api/products to return sample product data. This means your frontend can keep progressing, testing search and display features without relying on the backend.

API mocking tools also help you simulate different scenarios, such as successful responses, error responses, or slow responses. This makes it easier to find and fix bugs before they affect real users.

Why Do Developers Need API Mocking?

Developers often face challenges when waiting for backend APIs to be built. API mocking tools help solve these issues:

• Delays in backend readiness: Frontend developers can’t move forward when backend endpoints aren’t complete. Mocking lets them build and test features without waiting.

• Unclear API contracts: Teams must align on what endpoints and data structures will look like. Mocking allows frontend teams to work with agreed-upon responses even if the real API isn’t ready.
• Time-consuming server setup: In-house mock servers require finding the right framework, installing it, and maintaining it. Mocking tools provide quick setups without starting from scratch.
• Maintenance overhead: As real APIs change, in-house servers need constant updates. Mocking tools make it easier to adjust mocks with minimal hassle.
• Testing edge cases: Real APIs often don’t let you test scenarios like missing fields, 500 errors, or delayed responses. Mocking enables you to create these cases safely.
• Parallel development: Frontend and backend teams can work at the same time, improving delivery speed and collaboration.

Top Open-Source API Mocking Tools

Here’s an overview of the best open-source API mocking tools available today.

1. Requestly

Requestly is an open-source API interception and mocking tool that is available as a desktop client and browser extension. With support for both REST and GraphQL APIs, Requestly offers a straightforward way to create, manage, and share mock endpoints without setting up a separate mock server.

Key Features of Requestly

• Custom mock rules with static or dynamic responses (including JavaScript logic)
• Grouping and managing rules for complex testing scenarios
• Easy session recording and mocking for multiple endpoints
• CI/CD integration and sharing of mock configurations
• Filtering and viewing traffic by request method, status code, or resource type
• Simulating various scenarios such as server errors, latency, or partial data

Benefits of Using Requestly for API Mocking

• Saves development time: Developers can create mock APIs for endpoints not yet implemented or still in progress, keeping frontend and backend workflows decoupled.
• Improves testing coverage: Teams can simulate various scenarios, including server errors and slow responses, to uncover bugs and edge cases early.

• Enhances team collaboration: Mock rules can be shared and exported, making it easier to maintain consistent environments across development, testing, and staging.
• Reduces backend dependency: Mocked endpoints allow developers to work without relying on backend availability or stability.
• Simplifies updates and maintenance: Mock rules can be adjusted quickly as API contracts evolve, avoiding the overhead of updating traditional mock servers.
• Supports advanced testing flows: By serving mock responses directly, developers can test isolated components or simulate entire flows without needing live backend systems.

2. Hoverfly

Hoverfly is an open-source simulation tool for HTTP(S) traffic. It works as a proxy server to capture and replay traffic or simulate downstream dependencies. It’s designed to help developers test how their applications handle different API responses without relying on live servers.

Key Features of Hoverfly

• Capture and simulate HTTP/S traffic
• Record and replay network calls
• JSON-based simulation data
• CLI and API for scripting
• Integration with automated workflows

Limitations of Hoverfly

• Limited GraphQL support
• Requires manual editing of simulation files for complex behaviors
• Middleware extensions need separate Go-based plugins

3. Mountebank

Mountebank is an open-source tool designed for multi-protocol API mocking. It supports HTTP, HTTPS, TCP, and SMTP, making it versatile for integration and performance testing. It also helps teams create reusable and configurable mock servers.

Key Features of Mountebank

• Multi-protocol support
• JSON-based configuration
• Imposters for simulating complex traffic
• REST API for automation
• Cross-platform compatibility

Limitations of Mountebank

• Lacks native support for request validation or schema enforcement
• Requires separate configuration and scripting for complex flows
• Performance may degrade with large imposters or high traffic volumes

4. MockServer

MockServer is an open-source tool for creating mock and proxy servers. It’s designed for testing and development environments where developers need to simulate HTTP or HTTPS APIs. It works well for performance testing and integration testing.

Key Features of MockServer

• Support for mocking and proxying
• Dynamic response configurations
• Simulate delays and errors
• REST API for programmatic control
• Integration with multiple programming languages

Limitations of MockServer

• Requires Java runtime, even when used in other environments
• Lacks built-in support for recording traffic out of the box
• Complex mocking scenarios need deep configuration knowledge

5. GoMock

GoMock is an open-source mocking framework for Go. It’s mainly used to mock interfaces in Go applications, helping developers create unit tests that don’t rely on real dependencies. It’s an important tool for Go-based software testing.

Key Features of GoMock

• Mock interfaces for unit tests
• Integration with the Go testing framework
• Automated code generation for mocks
• Fine-grained control over mock behavior

Limitations of GoMock

• Only mocks interfaces, not structs or functions
• Requires boilerplate setup with mockgen
• No support for HTTP or external service mocking

6. Mockoon

Mockoon is an open-source desktop app that helps developers mock REST APIs. It provides a user-friendly graphical interface for quickly creating and managing mock endpoints. It’s well-suited for small to mid-sized testing scenarios.

Key Features of Mockoon

• GUI-based API mocking
• Dynamic and static response creation
• Environment export and import for sharing
• Cross-platform desktop app
• Quick endpoint setup

Limitations of Mockoon

• Native support for response templating is limited to Handlebars
• High memory usage in long-running or high-volume test suites
• Advanced matching logic requires a verbose and deeply nested configuration

7. WireMock

WireMock is an open-source tool for mocking HTTP APIs. It’s designed to help developers create reproducible tests for their applications by recording and replaying API interactions. WireMock supports both REST and SOAP.

Key Features of WireMock

• Record and playback real traffic
• Dynamic response templating
• Scenario-based testing and stateful behavior
• Automation via Java API and Docker support
• REST and SOAP compatibility

Limitations of WireMock

• Primarily Java-focused for direct integration
• High memory usage in long-running or high-volume test suites
• Advanced scenario management requires additional scripting

How to Set Up API Mocks Using Requestly

Requestly helps developers set up mock APIs quickly and directly within their existing workflows. It combines a browser extension and a desktop app to intercept real API traffic, then lets you modify responses or create mock endpoints for testing. This approach ensures you can work with realistic data, simulate errors, and test how your application behaves in different scenarios.

Here are some scenarios where Requestly API Mocking makes sense.

• Test features without a finished backend: Use predefined responses to continue frontend work even if backend endpoints are incomplete.
• Simulate different scenarios: Quickly test how your app handles server errors, timeouts, or missing data fields.
• Collaborate with teams: Share mock rules with other developers to keep testing environments consistent.
• Avoid hitting live servers: Reduce backend load during testing by serving requests directly from Requestly.
• Handle API changes smoothly: Update mock rules as the API contract evolves to match the latest specifications.

Follow these steps to set up Requestly for API Mocking.

1. Install Requestly

To start, download the Requestly desktop app from the official site. Choose the version for Windows, Mac, or Linux based on your platform. Once installed, sign up for an account. Requestly also requires a browser extension, which you can install on Chrome, Firefox, Edge, Opera, and other major browsers.

2. Connect to the Browser 

Open the Requestly desktop app and make sure it’s running. In the browser extension pop-up, click Connect to begin intercepting traffic. This step ensures that any network requests from your browser will be captured in the desktop client.

3. Capture and View API Traffic

Next, perform typical actions in your browser, like searching for products or logging in, so that the network traffic is generated. Requestly will capture this traffic in real time. This makes it easy to see exactly what requests your application makes and which endpoints are active.

Example scenario: While working on a product search page for a shopping app, the backend /api/products endpoint may not be available. Requestly captures this GET request to /api/products in its traffic log by performing a search in the app.

4. Filter Traffic

To focus only on the requests you care about, use filters in the Requestly desktop client. You can narrow down traffic by request method (GET, POST, etc.), response status codes, or resource types. This ensures you’re working with only the endpoints you want to mock.

5. Create Mock Rules

Once you’ve identified the request you want to mock, create a rule that defines the behavior you need. Here’s how:

• Right-click on the chosen request in the traffic list and select Modify Response Body.
• In the rule editor, specify how to match the request: whether to use an exact URL or partial matching.
• Set the desired response status code, like 200 for success or 500 for error testing.
• Enter the response body you want to send back. This can be static JSON for simple tests or dynamic JavaScript for more complex scenarios.
• Save the rule so you can enable or disable it whenever needed.

Continuing the above example, in the product search scenario, a mock response for /api/products might be created with the following JSON:

{

  "products": [

    { "id": 1, "name": "Laptop", "price": 999 },

    { "id": 2, "name": "Headphones", "price": 199 },

    { "id": 3, "name": "Smartwatch", "price": 299 }

  ]

}

This static response allows the front end to display product listings even if the backend is not ready.

6. Validate and Manage Rules

After saving your mock rule, it’s essential to validate that it works as expected. Clear the traffic logs in Requestly, then repeat the same browser action. If everything is set up correctly, you’ll see the mocked response highlighted differently in the traffic list. All of your rules will be listed in the HTTP Rules tab so you can manage them as needed.

Talk to an Expert

Conclusion

API mocking is a practical way to keep frontend development moving even when backend APIs are not ready. It lets teams build, test, and validate new features without waiting for backend endpoints to be complete.

Among all the API mocking tools, Requestly provides a simple yet powerful way to intercept traffic, create static or dynamic mocks, and manage them with minimal effort. Its browser extension and desktop app setup means developers can start working with real network traffic immediately, removing the delays caused by incomplete APIs.

Try Requestly for Free