API mocking with latency simulation

Yes — there are several tools specifically designed to mock API responses with configurable latency, errors, timeouts, and other failure conditions. They're useful for resilience testing, including retry logic, circuit breakers, graceful degradation, and handling slow or unavailable dependencies.

The best choice depends on whether you want to simulate failures locally during development, run automated integration tests in CI/CD, or inject faults into a running distributed system.

Tools worth considering

1. WireMock

(Best general-purpose choice)

A flexible HTTP mock server for local development, automated tests, and CI pipelines. Supports fixed and randomized delays, HTTP error codes, empty responses, malformed data, and connection resets.wiremock.org+1

Best for: Testing retry policies, timeout handling, fallback responses, and application behavior under slow or failing APIs.

Official site ·Fault simulation docs

2. MockServer

A strong option when you need precise, programmable failure scenarios. It supports fixed or random latency, configurable error rates, connection drops, malformed responses, and fault injection against proxied upstream traffic.www.mock-server.com+1

Best for: Integration tests and controlled experiments against mocked or real downstream services.

Official site ·Chaos testing docs

3. Toxiproxy

Unlike a traditional API mock, Toxiproxy sits between your application and a real dependency. It can introduce latency and jitter, restrict bandwidth, drop packets, time out connections, and simulate connection resets.github.com

Best for: Testing how your application behaves when the network or a real downstream service becomes unreliable.

GitHub and documentation

4. Hoverfly

Provides API simulation, traffic capture and replay, and configurable delays, errors, and rate limits. It can replace external dependencies with reusable simulations.hoverfly.io+1

Best for: Replaying realistic API traffic and testing integrations without repeatedly calling external services.

Open-source project

5. Mountebank

Supports HTTP, HTTPS, and TCP imposters, with delayed responses and fault conditions such as connection resets or corrupted data.mountebank.herokuapp.com

Best for: Teams that need service virtualization across several protocols, not just REST APIs.

Fault simulation documentation

Quick comparison

Sources: WireMock, MockServer, Toxiproxy, Hoverfly.

Example: simulate a slow or failing API

With WireMock, you can configure a mocked endpoint to return a successful JSON response after a two-second delay:

{
  "request": {
    "method": "GET",
    "url": "/api/orders"
  },
  "response": {
    "status": 200,
    "fixedDelayMilliseconds": 2000,
    "headers": {
      "Content-Type": "application/json"
    },
    "jsonBody": {
      "orders": []
    }
  }
}

You can then create separate scenarios for:

• Slow response: 2-second or randomized delay.
• Transient failure: HTTP 503 on selected requests, followed by HTTP 200.
• Timeout: Delay beyond your client's configured timeout.
• Network failure: Reset the connection instead of returning an HTTP response.
• Rate limiting: Return HTTP 429 with a Retry-After header.

WireMock supports response delays and low-level HTTP fault simulation; connection-level failures may require a fault configuration rather than an ordinary status response.wiremock.org+1

My recommendation

Start with WireMock if you want a straightforward way to define API responses and latency in automated tests. Choose MockServer if you want more programmable, probabilistic fault injection, or Toxiproxy if you need to test network behavior against real services.

One question that would help narrow this down: What environment are you testing?

1. Testing environment

Local development

Integration tests / CI pipeline

Staging or distributed system

Production-like chaos testing

2. Protocol

REST / HTTP

gRPC

TCP / database connections

Multiple protocols

3. Deployment preference

Self-hosted / open source

Hosted / managed

Either

[Find the best fit]

The most reliable way to mock API endpoints for resilience testing is to use a dedicated mock server that lets you control HTTP error responses, response latency, timeouts, and connection failures. Then run your application or integration tests against those controlled failures and verify that retries, circuit breakers, fallbacks, and timeout handling work as expected.

1. Choose a fault-injection tool

WireMock

(Best starting point)

Mock specific endpoints and configure HTTP status codes, fixed or randomized delays, and malformed responses or connection resets. Good for repeatable API integration tests and CI pipelines.

Docs: Simulating faults ·Stubbing APIs

MockServer

Useful for more advanced scenarios, including configurable error rates, response delays, malformed responses, and dropped connections.

Docs:Chaos testing and fault injection

Toxiproxy

Best when you need to simulate network-level problems rather than just return an HTTP error: latency, jitter, bandwidth restrictions, dropped traffic, and connection resets.

Docs:Toxiproxy on GitHub

WireMock is a strong first choice if you primarily test HTTP APIs. Toxiproxy complements it when you need to reproduce failures at the network layer.wiremock.org+2

2. Configure endpoints with specific failures

With WireMock, you can define mappings as JSON files or register them through its admin API. For example, the following mappings simulate a server error and a slow successful response.wiremock.org+1

[
  {
    "request": {
      "method": "GET",
      "url": "/api/orders/500"
    },
    "response": {
      "status": 500,
      "jsonBody": {
        "error": "INTERNAL_SERVER_ERROR",
        "message": "Simulated server failure"
      },
      "headers": {
        "Content-Type": "application/json"
      }
    }
  },
  {
    "request": {
      "method": "GET",
      "url": "/api/orders/slow"
    },
    "response": {
      "status": 200,
      "fixedDelayMilliseconds": 3000,
      "jsonBody": {
        "id": "order-123",
        "status": "processing"
      },
      "headers": {
        "Content-Type": "application/json"
      }
    }
  },
  {
    "request": {
      "method": "GET",
      "url": "/api/orders/unavailable"
    },
    "response": {
      "status": 503,
      "jsonBody": {
        "error": "SERVICE_UNAVAILABLE"
      }
    }
  }
]

These examples configure three distinct scenarios:

• /api/orders/500: HTTP 500 Internal Server Error.
• /api/orders/slow: HTTP 200 after a three-second delay.
• /api/orders/unavailable: HTTP 503 Service Unavailable.

Save the mappings in your WireMock mappings directory or register them using its admin API. Point your application's test configuration at the mock server instead of the real dependency.

3. Build a resilience test matrix

Start with a defined set of failure scenarios so you can reproduce failures and verify the expected behavior.

WireMock supports fixed and randomized delays as well as several connection and malformed-response faults. For actual network timeouts and connection disruptions, Toxiproxy is another useful option.wiremock.org+2

4. Test realistic response-time distributions

A fixed delay is useful for deterministic tests, but production systems often experience variable latency.

Consider testing these profiles:

Normal latency

50–150 ms with small amounts of jitter. Establish baseline behavior.

Elevated latency

500–1,500 ms. Verify deadlines, responsiveness, and retry budgets.

Long-tail latency

Occasional 3–10 second responses. Verify timeouts, cancellation, and fallback paths.

These are example test values, not universal production thresholds. WireMock supports uniform and log-normal delay distributions for introducing jitter and long-tail latency.wiremock.org+1

5. Automate the tests in your CI pipeline

A useful test loop looks like this:

1. Start mock server

Load endpoint mappings and fault scenarios

2. Inject a failure

500, 503, latency, timeout, or connection reset

3. Execute application tests

Assert retries, fallback responses, and recovery

4. Collect results and clean up

Check error rates, latency, logs, and leaked resources

A few important practices:

• Make failure scenarios deterministic for ordinary CI tests; use randomized chaos experiments separately.
• Test that retries have limits and exponential backoff, so failures do not amplify load.
• Check that circuit breakers open during sustained failures and recover afterward.
• Set explicit timeouts and a total retry budget.
• Keep fault injection confined to test environments, and reset mock state between tests.

6. Tailor the setup to your stack

I can provide a working example with the mock configuration, test code, and commands to run it. Which environment are you using?

Your application stack

Node.js / Jest

Python / pytest

Java / Spring Boot

.NET / xUnit

Go

Other

Which failure modes do you need?

What are you testing?

An HTTP API or microservice

A frontend consuming an API

A database or external dependency

[Generate my test setup]

To thoroughly validate your application's failure handling, timeouts, and resilience, you need an API mocking tool that supports fault injection (latency, random/deterministic HTTP errors, and connection drops).mock-server.com

Here are the top tools that handle configurable network lag and error states exceptionally well, categorized by how you intend to run them:

1. Mockoon (Open Source / Desktop)

• Overview: A fantastic, lightweight desktop application (and CLI) that lets you quickly spin up mock APIs with a visual UI.
• Lag & Error Features: You can configure a global or route-specific delay (in milliseconds) for network lag. You can also specify response status codes (e.g., 500, 503, 404) and define rules to trigger errors conditionally based on headers, query params, or body content.
• Get started: Download or explore documentation on the Mockoon Official Website.dev.to+1

2. MockServer (Open Source / Self-Hosted & Docker)

• Overview: A robust, developer-focused tool built specifically for robust integration testing, unit testing, and chaos engineering.
• Lag & Error Features: Offers advanced Chaos Testing profiles. You can configure probabilistic or deterministic fault injection—including artificial latency (delays), explicit HTTP error statuses (500, 429, etc.), and hard TCP connection drops to test connection resets. It can act as a local mock server or a proxy sitting in front of real upstream dependencies.
• Get started: Check out the setup guides on MockServer Docs.mock-server.com+2

3. WireMock (Open Source / Cloud / Java or Standalone)

• Overview: The industry gold standard for mocking in JVM environments, available as a standalone binary, Docker container, or managed cloud service.dev.to
• Lag & Error Features: WireMock allows fine-grained response tuning. You can set fixed or random uniform/log-normal delays ("fixedDelayMilliseconds": 2000 ) and return fault responses like empty responses, garbled bytes, or connection interruptions alongside standard HTTP error codes.
• Get started: Explore configuration options at WireMock.org.

4. Beeceptor (Cloud / SaaS)

• Overview: A hosted, easy-to-use mocking solution that requires zero local installation.
• Lag & Error Features: Allows you to define custom rules where you can inject response latency (delaying the response by a set number of seconds) and force specific HTTP status codes or custom payloads on the fly.
• Get started: Test it out directly via Beeceptor.dev.to

To help narrow down the best fit, tell me:

• Do you prefer a local desktop app/GUI (like Mockoon), a code/Docker-based tool (like WireMock or MockServer), or a cloud-hosted mock (like Beeceptor)?
• Are you planning to run these tests locally on your machine or inside a CI/CD pipeline?