Credit where due: Hoverfly is excellent at what it was built for. It's a lightweight Go proxy (Apache-2.0, single binary, actively maintained — v1.12.12 shipped August 23, 2026) whose superpower is capture and replay: point your app through the proxy, record the real downstream API once, then replay those responses deterministically in CI, offline, forever. Add response templating, a rich matcher set (glob, regex, JSONPath, XPath), middleware hooks for arbitrary logic, and a clean admin API, and you have one of the best open-source service-virtualization tools around. If your job is simulating a real third-party service you've recorded, keep Hoverfly — we have no capture mode, and nothing on this page changes that.
This page is about a different job Hoverfly often gets drafted into: -webserver mode as a dev sandbox / frontend mock — an API for your UI or integration tests to talk to while the real backend doesn't exist yet. There, you pay a simulation-authoring tax for none of the record/replay payoff.
We downloaded the current release and ran hoverfly -webserver -import sim.json with a hand-authored simulation: a GET /pets pair returning a one-pet list and a POST /pets pair returning a canned 201. Every claim below is the actual observed behavior.
Wall 1: every response is an authored recording, so writes are theater. POST /pets with {"name":"Fido","species":"cat"} returned our canned {"id":2,"name":"Spot"} — and so did a second POST with a completely different body. The next GET /pets still returned the original one-pet list. Nothing is created; a simulation is a set of recordings, not a datastore.
Wall 2: query params are silently ignored. GET /pets?limit=1 matched our plain path matcher and returned the identical full body. Pagination, sorting, filtering — each variant is another request matcher plus another hand-written response body, per resource, forever.
Wall 3: a miss is a 502 Bad Gateway. GET /pets/2 — the completely obvious sibling of our authored GET /pets — answered HTTP 502 with a plain-text page: "Hoverfly Error! There was an error when matching… create or record a valid matcher first!" Your res.json() throws, and your app's error handling sees a gateway failure instead of the 404 a real API would return.
Wall 4: state exists, but it's a hand-scripted state machine. Hoverfly's requiresState/transitionsState genuinely works — we verified a cart that returns [], flips to "full" after a POST, and then returns an item. But every state and every body is authored in advance: after we POSTed {"sku":"ZZZ"}, the cart showed the A1 we'd written into the simulation weeks… er, minutes earlier. It's a finite state machine you script by hand, not data.
Wall 5: it lives on localhost. Both ports bind 127.0.0.1 by default (verified: webserver and admin API). The moment a teammate, a phone, CI, or a deployed preview needs the mock, you're provisioning and babysitting a server.
Wall 6: the hosted upgrade has no free tier. Hoverfly Cloud starts at $10/month (Developer: 2 simulation instances, 20 req/s each) with a 14-day trial; simulating latency and random failures is gated to the $30/month Professional tier (per their public pricing page, August 2026). Open-source Hoverfly does have fixed delays via globalActions.delays — we measured one — but probabilistic failure injection is a paid Cloud feature. Here, both are free query params on any endpoint.
Where you'd author sim.json and run a binary, create a hosted project instead — nothing to run, nothing to author:
curl -X POST https://mockbird.mockbird.workers.dev/api/projects \
-H 'content-type: application/json' -d '{"name":"my-api","preset":"ecommerce"}'
# → {"id":"<PID>","adminKey":"…","baseUrl":"https://mockbird.mockbird.workers.dev/m/<PID>",…}
# 4 resources, realistic seeded records, live immediatelyOr, if you have an OpenAPI spec, import it — resources and typed seed data are generated from the schemas. Either way, the behaviors you'd hand-author are just true:
# writes persist (ran against the shared demo before publishing):
curl -X POST https://mockbird.mockbird.workers.dev/m/demo/products \
-H 'content-type: application/json' -d '{"name":"hoverfly-guide-check","price":9.99}'
# → {"name":"hoverfly-guide-check","price":9.99,"id":31}
curl https://mockbird.mockbird.workers.dev/m/demo/products/31 # → the same record. It's real.
# missing records are real 404s, not 502 error pages:
curl -i 'https://mockbird.mockbird.workers.dev/m/demo/products/999'
# and the query toolkit needs zero matchers:
curl 'https://mockbird.mockbird.workers.dev/m/demo/products?page=2&limit=3&sortBy=price&order=desc'| Hoverfly | Mockbird | Notes |
|---|---|---|
hoverfly -webserver -import sim.json | POST /api/projects | hosted URL instead of 127.0.0.1:8500; nothing to run |
| request/response pair | resource records or a custom route | routes support status/body/headers/contentType/delayMs + {{query.x}}/{{body.x}} templating |
templated response ({{ Request.Body 'jsonpath' '$.name' }}) | route templating ({{body.name}}) | theirs is richer (verified working); ours covers the common echo cases |
| canned CRUD pairs | real stateful resources | POST→GET-back persists; PUT/PATCH/DELETE; filters/sort/pagination/search built in |
requiresState/transitionsState | snapshots + X-Mockbird-Snapshot | save real data states, restore or pin one per request — no FSM to script |
globalActions.delays | ?mock_delay=2000 | per-request, no simulation edit — measured 1.8 s on the demo |
| Cloud "latency & random failures" ($30/mo tier) | ?mock_chaos=0.3, ?mock_jitter=800 | free — we measured mixed 500/429s at chaos=0.5; guide |
| fail-then-recover scripting | ?mock_seq=502,502,200 | deterministic retry drills, one param — verified 502→502→200 |
admin API PUT /api/v2/simulation | snapshot restore / import | swap entire data states with one call |
journal (/api/v2/journal) | request inspector | always on, last 50 with headers + bodies, readable from tests |
| capture mode (record a real API) | no equivalent | honest: Hoverfly's superpower stays Hoverfly's |
| middleware (any script/binary) | no equivalent by design | we don't execute your code |
| matchers: glob/regex/JSONPath/XPath | exact + _gte/_lte/_ne/_like | honest: their matching DSL is far richer |
# query params that actually work — no matchers authored:
curl 'https://mockbird.mockbird.workers.dev/m/demo/products?page=2&limit=3'
# a real 404 where a Hoverfly miss gives you 502 Bad Gateway:
curl -i 'https://mockbird.mockbird.workers.dev/m/demo/products/999'
# delay + chaos (their paid-tier features) as free query params:
curl 'https://mockbird.mockbird.workers.dev/m/demo/products/1?mock_delay=2000'
curl 'https://mockbird.mockbird.workers.dev/m/demo/products?mock_chaos=0.5'
# fail-then-recover sequence for retry logic (fixed key = one sequence):
curl 'https://mockbird.mockbird.workers.dev/m/demo/products?mock_seq=502,502,200&mock_seq_key=me1'The clean split: Hoverfly for services that exist, Mockbird for services that don't. Capture and replay your real third-party dependencies through Hoverfly in CI; point the frontend at a Mockbird project for the backend you're still designing — schema-first, stateful, and shareable as a URL with no simulation files to sync.
| Hoverfly (OSS) | Hoverfly Cloud | Mockbird | |
|---|---|---|---|
| Price | free, Apache-2.0 | from $10/mo, no free tier (14-day trial) | free while in beta |
| Capture/replay a real API | excellent — the whole point | yes | none |
| Hosted URL others can hit | no — 127.0.0.1 by default, self-host to share | yes — 2 instances at 20 req/s ($10 tier) | yes — 10,000 requests/project/day, no signup |
| Stateful CRUD (POST → GET it back) | no — authored pairs; FSM via requiresState | same model | yes — persistent records, snapshots, restore |
| Unmatched path behavior | 502 Bad Gateway text page (verified) | same model | real 404 with a JSON error |
| Pagination/filter/sort/search | only what you author, per variant | same model | always on, every resource |
| Latency / failure injection | fixed delays yes; random failures no | $30/mo tier | ?mock_delay / ?mock_chaos — free |
| Matching DSL | deep — glob, regex, JSONPath, XPath | same | exact + range/contains operators |
| Works offline | yes | no | no |
| Maintenance | active — v1.12.12 Aug 2026 | active | actively developed |
Written by the Mockbird maker — bias disclosed. Where Hoverfly genuinely wins: capture/replay proxying (record real services once, replay deterministically — we have nothing like it), a matcher DSL we don't approach, working response templating, middleware for arbitrary logic, HTTPS MITM simulation, offline use with no request caps, and an actively maintained single-binary deploy. Every behavioral claim above was verified by us in August 2026 against Hoverfly v1.12.12 in -webserver mode (transcripts as described; default-bind check via ss; delay measured at 1.5 s); Cloud pricing is from hoverfly.io/pricing as of August 26, 2026. If any of this changes, we'll update the page.
Full API reference in the docs. More guides: MockServer alternative · mountebank alternative · WireMock Cloud alternative · Prism alternative · Mockoon alternative · Karate mock server alternative · free mock API tools compared. Create your API →