API Mocking Hub
Mock servers, compared and ranked from 30 days of hands-on testing. Filter by type or search below — every page is editor-independent.
Open-source mocking with full control — our pick for backend teams
Fastest local mock with zero setup — our pick for solo devs
Broadest API platform, mocking included
Turn an OpenAPI spec into a live mock in seconds
Mocking that ships inside an all-in-one API canvas
JVM mock server with contract verification
Control vs convenience — the trade every backend team weighs
Six tools, one matrix — where each one actually wins
Two platforms, two philosophies on where mocking should live
Match the tool to who is mocking and where it runs
What actually matters when mocks run unattended
Prove your client handles a slow auth failure, not just happy paths
A mock running in under a minute, no server required
One command from contract to running mock
Turn a saved example into a mock the whole team can call
A stub is a canned HTTP response a mock server returns in place of the real service, so tests run against a deterministic, offline double instead of a flaky dependency.
Contract testing verifies that a client and a service agree on the shape of their requests and responses, without running the full end-to-end system.
Record-and-replay points a mock at a real API once, captures the traffic, then serves those captured responses offline — deterministically and without hitting the real service again.
OpenAPI import lets a mock server generate responses straight from your OpenAPI contract, so the mock can never drift from the documented API.
Latency simulation makes a mock respond after a configurable delay, so you can test how clients behave when the real API is slow — not just when it is instant.
Fault injection is the practice of deliberately breaking a mocked or real dependency—adding latency, 5xx errors, or dropped connections—to prove the system around it degrades gracefully instead of collapsing. It turns resilience from a hope into a testable property.
Fault injection is the practice of deliberately breaking a mocked or real dependency—adding latency, 5xx errors, or dropped connections—to prove the system around it degrades gracefully instead of collapsing. It turns resilience from a hope into a testable property.
What held up across 30 days of local, proxy, and CI testing