Mockoon is the best free desktop GUI for mocks you author by hand — and on day one you face an empty editor. Gostly is a self-hosted proxy that records the traffic your service already sees and replays it byte-for-byte; no fixture to write, and every replay is the exact bytes the API sent. Already on Mockoon? Seed from your existing HAR / Postman / OpenAPI and start with a full library, not a blank canvas.
Mockoon earns its popularity honestly. It is, by a comfortable margin, the best free desktop mocking GUI on the market: MIT-licensed, a clean Electron app with a CLI for CI, and the fastest path for a single developer to compose a working mock for a single API in minutes. Around 200k npm downloads/month and 8.3k+ GitHub stars (June 2026) speak for themselves. If you want a permissively-licensed binary you can run offline forever, it is hard to beat.
The trade-off is where the responses come from. A Mockoon fixture is something you compose in the GUI — and even its proxy-recording mode scaffolds a route for you to fill in with Faker, rather than replaying the bytes the upstream actually returned. That is exactly what most developers want, until two things become true: the mock has to match what the real API actually does, not what you remembered to type, or there are simply too many endpoints with shapes too large and too dynamic to author by hand.
Gostly is built for that case. You put its Rust proxy in front of your upstream and run the self-hosted stack in your perimeter (Docker Compose); in LEARN mode it records for an hour, then replays the recorded traffic byte-for-byte in MOCK mode — including HTTPS. Your recorded traffic stays on your own infrastructure; sensitive headers are redacted before anything is written to disk. There is no LLM in the request path; AI is an opt-in gap-fill, grounded by your recordings rather than a free-text prompt.
And because it runs as your own single-tenant deployment, the controls a security review asks for are built in: SSO via SAML or OIDC, role-based access control, and an append-only audit log on Team. Your recorded traffic never leaves your perimeter — each deployment is single-tenant, with per-tenant RLS policies defined as defense-in-depth.
Faker generates a name that looksreal. Gostly returns the name the API actually sent. A Mockoon fixture is only ever as right as what you remembered to type; Gostly’s mock is the recording — replayed byte-for-byte, inside your own perimeter.
take the upstream offline — the recorded library still serves, 0 live calls
| Feature | Mockoon | Gostly |
|---|---|---|
| Free, OSS desktop GUI | MIT | No |
| Free OSS proxy / server | No | FSL |
| Mock source | Hand-authored fixtures (GUI builder) | Recorded from real traffic |
| Records real upstream traffic | Proxy mode scaffolds a route — you hand-template the body with Faker | Records + replays the real response byte-for-byte |
| Captures real HTTPS / TLS traffic | No | Yes |
| Library on day one (no recordings yet) | Author every fixture by hand first | Seed from a HAR / Postman / OpenAPI file — full library before you record |
| AI-assisted endpoint generation | from a text prompt | opt-in gap-fill grounded by your recordings |
| No LLM in the request path | Yes | Yes |
| CLI for CI | Yes | Yes |
| Team workspace + multi-seat sync | Cloud Team | Team plan |
| Latency / status-code injection | Yes | Yes |
| Chaos / failure injection | manual responses | Markov chaos that learns a degradation profile from your traffic |
| Stateful CRUD across requests | Routes are stateless by design — needs hand-built CRUD-route + data-bucket plumbing | shipping (statechart) |
| Live drift detection vs the real upstream | Manual OpenAPI re-import of a spec (v9.6.1) | Re-record + compare — emits drift events + a freshness score |
| Outbound TLS the upstream accepts | No | JA4-accurate browser-fingerprint impersonation (Pro+) |
| SSO, RBAC, audit log | Cloud account controls (paid) | SAML + OIDC SSO, RBAC, append-only audit log on Team |
| Self-hostable | desktop only | Self-hosted platform (Docker Compose) |
Statecharts and drift detection ship today. AI gap-fill on Gostly is opt-in and grounded by your recordings, not a free-text prompt. gRPC and broader async-protocol capture are on the roadmap.
Choose Mockoon when
Choose Gostly when
| Tier | Mockoon | Gostly |
|---|---|---|
| Free | Desktop app, MIT, unlimited | OSS proxy (FSL) · unlimited services, self-hosted |
| Solo / Pro | $10 / mo (Mockoon Solo) | $10 / mo single user (unlimited services, AI on miss) |
| Team | $100 / mo for 5 seats (Mockoon Team) | $79 / seat / mo (min 3 seats) |
| Self-host / Enterprise | Mockoon Enterprise — custom | $499 / mo Self-host · $25K+ Enterprise |
At the Pro tier the prices are identical; the products are not. At the Team tier Gostly is $79/seat/mo versus Mockoon’s $100 for five seats — so for very small teams Gostly tracks lower, and for larger teams Mockoon’s flat block-of-five may be cheaper. The right comparison is workflow, not sticker price: the moment your constraint becomes “the mock has to match what the real API actually returned,” recording stops being a feature and starts being the requirement.
The objection that kills most Mockoon switches is “I have no recordings yet, so I’d be starting from a blank canvas.” You aren’t. Drop a HAR capture, a Postman collection, or an OpenAPI spec into the dashboard and Gostly seeds a working mock library before you proxy a single request — the same library your recorded traffic lands in. Then real traffic sharpens it to ground truth. A hand-authored fixture is only ever as right as what you remembered to type.
In the dashboard, open Cold-start seeding, drag in the HAR / Postman / OpenAPI file, pick the service, and commit. The mocks land in the same library your recorded traffic does — flip the proxy to MOCK and they serve immediately. Then run your real test suite through the containerized proxy in LEARN mode to sharpen the library to ground truth.
Self-hosted, recorded from real traffic, deterministic in CI. Run it against your staging upstream for an hour and see whether it produces a mock you trust.
Evaluating for a team of 3+? We’d love to talk before you commit.