Microcks turns specs into mocks: drop in your OpenAPI, AsyncAPI, or gRPC contract and Microcks generates a server you can hit. Gostly starts the other way around — record real upstream traffic and replay it. Both are good products that optimise for fundamentally different starting positions.
Microcks is the spec-driven OSS mocking engine. CNCF Incubating, Apache 2.0, Java/Spring Boot. You write (or import) an OpenAPI, AsyncAPI, gRPC, GraphQL, or SOAP contract and Microcks stands up mocks plus a test runner that validates consumers and providers against that contract. The async-messaging story is its standout wedge — very few open-source mocking tools cover Kafka / AMQP / MQTT alongside REST in one engine.
Gostly is built around a different starting assumption: most teams do not have a clean spec to import. They have a real upstream that already serves traffic, and the fastest path to a usable mock is to record an hour of that traffic and replay it. So Gostly puts a Rust proxy in front of your upstream and runs as a self-hosted stack in your perimeter (Docker Compose); in LEARN mode it records for an hour, then flips to MOCK mode and serves recordings. Optional, opt-in AI can fill anything unrecorded — grounded by the recordings, not a free-text prompt.
Where Microcks expects you to know the contract upfront, Gostly assumes you don’t — and would rather discover it from production behaviour. Where Microcks runs a Spring stack with Keycloak, Gostly is a Docker Compose stack with no JVM and auth built in. Where Microcks is multi-protocol today (REST + AsyncAPI + gRPC + GraphQL + SOAP), Gostly is HTTP and HTTPS today, with gRPC and async messaging on the roadmap.
| Feature | Microcks | Gostly |
|---|---|---|
| OSS license | Apache 2.0 (Java) | FSL → Apache 2.0 in 2y (Rust) |
| Single-binary install | No | Yes |
| Spec-driven workflow (OpenAPI / AsyncAPI / gRPC / GraphQL) | first-class — the wedge | OpenAPI import; AsyncAPI / gRPC roadmap |
| Records mocks from real upstream traffic | No | default workflow |
| Captures real HTTPS / TLS traffic | No | records HTTPS, fingerprint-matched outbound |
| Async messaging mocks (Kafka, MQTT, AMQP) | first-class | HTTP / HTTPS (no async) |
| gRPC server-side mocking | shipping | roadmap |
| Contract testing (consumer-driven) | shipping (test runner) | No |
| AI gap-fill grounded by your traffic | No | Yes |
| JVM-free runtime | No | Yes |
| CNCF governance / vendor-neutral | Incubating | No |
| SAML / RBAC / audit log | Microcks Hub Enterprise | SAML + OIDC SSO, RBAC, audit log on Team |
| Chaos / fault injection | limited (latency, error code) | shipping (latency, status, Markov chains) |
Roadmap items are explicitly labelled. Async messaging, gRPC, and contract testing are 2026 roadmap on Gostly’s side, not shipping today.
Choose Microcks when
Choose Gostly when
If your team already has the spec: Microcks is the conservative, mature choice. The contract becomes the source of truth, mocks are derivative, and the same artifact drives consumer-side validation. Adding async transports is genuinely best-in-class.
If your team has the upstream but not the spec: Gostly inverts the usual order — the traffic becomes the source of truth, the recorded JSONL becomes the diffable artifact, and the spec (if you still want one) is generated by export from what you already recorded. Faster TTFV when the contract isn’t already documented.
These aren’t contradictions, they’re different orderings of the same tetris pieces. We’ve heard from teams who run both: Microcks for the contract-first services, Gostly for the legacy ones nobody ever specced.
| Tier | Microcks | Gostly |
|---|---|---|
| Free / OSS | OSS (Apache 2.0) — fully featured, self-host | Unlimited services, OSS proxy (FSL) |
| Pro / Solo | No single-seat tier | $10 / mo single user |
| Team | Microcks Hub commercial — talk to sales | $79 / seat / mo |
| Self-host / Enterprise | Microcks Inc. paid support; OSS self-host always free | $499 / mo Self-host · $25K+ Enterprise |
Microcks is the most capable free, open-source platform in this space — CNCF-governed, multi-protocol, with contract testing and a dashboard, all in the OSS distribution. If your APIs are spec-first and you need REST, async, and gRPC mocks generated from a contract, it is excellent and hard to beat. Gostly is a different kind of platform: it records your real upstream and replays it byte-for-byte, so there is no contract to author — and it adds drift detection, statechart state, AI grounded in your own recordings, and self-hosted SSO, RBAC, and an audit log, all inside your perimeter. The honest split is contract-first (Microcks) versus record-from-reality (Gostly), not free versus paid.
We don’t recommend ripping out Microcks if it’s working — especially if you’re using its async transports. The interesting test is the inverse: take a service Microcks doesn’t have a contract for, point Gostly at the real upstream for an hour, and see whether the recorded JSONL gives you a usable mock without hand-authoring a spec.
Self-hosted, language-agnostic, recording-first. Run it against your staging upstream for an hour and see whether it produces a mock you trust without ever touching an OpenAPI file.
Evaluating for a team of 3+? We’d love to talk before you commit.