Let's start with the respect it deserves: Microcks is probably the most serious open-source API mocking project there is — a CNCF incubating project that turns OpenAPI, AsyncAPI, gRPC protobuf, GraphQL schemas, Postman collections and SoapUI projects into live mocks, and runs conformance tests against your real implementation. If your organization needs contract testing across REST, gRPC, SOAP and Kafka on a Kubernetes platform, Microcks is the right answer and this page won't pretend otherwise.
This guide is for a different moment: you have an OpenAPI spec (or nothing at all), you want a mock API URL your frontend or tests can hit in the next sixty seconds, and standing up a platform to get it feels like overkill. That's the gap Mockbird fills.
Microcks is self-hosted infrastructure — there is no hosted free tier to sign into. The production install is a Helm chart or Operator on Kubernetes; the local route is Docker Compose bringing up the Microcks app plus Keycloak (auth) and MongoDB (storage). The team has done genuinely great work shrinking the trial path — the uber all-in-one image boots with a single docker run and their Testcontainers modules are excellent for ephemeral test-time mocks — but the uber image is all-in-memory (state gone on restart), and anything durable or shared is back to deploying and operating the real thing: your cluster, your upgrades, your uptime.
The second thing to know is the mocking model. Microcks mocks are example-driven: responses come from the request/response examples you author in your artifacts. Their docs are upfront that only comprehensive request/response example pairs are used — provide a request example without a matching response example and it's discarded. For GraphQL, gRPC and Swagger 2.0 you need a second artifact (a Postman collection carrying the examples) alongside the schema. This model is exactly what you want for contract fidelity — the mock returns precisely what the contract promises. It's less what you want for "give my frontend 50 plausible products and let me POST new ones": examples are canned, and your spec probably doesn't have many.
Mockbird inverts both assumptions: it's hosted (nothing to deploy), and it generates data from your schema — no examples required — then gives you real, persistent CRUD on top.
Take a spec with zero example objects:
curl -s -X POST --data-binary @openapi.yaml \
"https://mockbird.mockbird.workers.dev/api/projects/import?seed=5"
The response is a live base URL plus an admin key. Your Pet schema with an enum: [dog, cat, parrot] and a format: date-time field comes back as five seeded records with valid species and ISO timestamps — we verified this guide's exact spec end-to-end before publishing. JSON or YAML, OpenAPI 3.x or Swagger 2.0, $ref and allOf resolved.
And the mock is stateful — writes persist, no example authoring:
curl -s -X POST https://mockbird.mockbird.workers.dev/m/YOUR_ID/pets \
-H 'Content-Type: application/json' \
-d '{"name":"Waffles","species":"cat","adopted":false}'
# → {"name":"Waffles","species":"cat","adopted":false,"id":6}
curl -s https://mockbird.mockbird.workers.dev/m/YOUR_ID/pets/6 # it's really there
curl -s "https://mockbird.mockbird.workers.dev/m/YOUR_ID/pets?species=cat"
No spec handy? Skip the import entirely — one click creates a seeded multi-resource backend, or try the shared demo right now:
curl -s "https://mockbird.mockbird.workers.dev/m/demo/products?limit=2"
| Microcks | Mockbird |
|---|---|
| Import job / artifact upload (OpenAPI) | POST /api/projects/import with the spec body (guide) |
| Postman collection artifact | Same import endpoint — saved example responses become records (docs) |
| HTTP Archive (HAR) artifact | Same import endpoint — recorded responses become resources (guide) |
| Example-driven responses | Schema-seeded realistic data (?seed=N), then live CRUD — examples optional, not required |
| Dynamic mock content | Response templating on custom routes: {{params.x}}, {{now}}, {{uuid}} (guide) |
| Delays / latency on operations | ?mock_delay=2000 per request, plus ?mock_jitter (guide) |
| Error simulation | ?mock_status=503, probabilistic ?mock_chaos=0.3, sequences via ?mock_seq |
| GraphQL mock (schema + Postman examples) | GraphQL endpoint generated from the same resources — one artifact, queries + mutations (guide) |
| Keycloak users / service accounts | None needed — anonymous project + admin key; optional mock JWT auth on the mock itself |
| Grafana / observability stack | Built-in request inspector (last 50 requests, headers, bodies) |
| Microcks | Mockbird | |
|---|---|---|
| Hosting | Self-hosted (K8s/Helm/Operator, Docker Compose, uber image for trials) | Hosted, zero install |
| Setup to first mock URL | Deploy platform → import artifact | One curl (or one click) |
| Protocols | REST, GraphQL, gRPC, SOAP, AsyncAPI/Kafka — nobody else comes close | REST + GraphQL (+ SSE/WebSocket echo) |
| Response model | Examples you author (contract-exact) | Generated from schema + real CRUD state |
| Writes | Dispatcher-scripted; not a real data store | Persist for real — POST, then GET it back |
| Contract / conformance testing | Yes — a core feature, and excellent | No — mocking only (request validation at most) |
| CI ephemeral mocks | Testcontainers modules — first-class | Create/delete a project per run via API (guide) |
| Open source / self-host | Yes, CNCF incubating | No — hosted service (but your data ejects as db.json/OpenAPI/Postman anytime) |
| Auth to manage mocks | Keycloak login | None — admin key in the create response |
| Price | Free (your infra + ops time) | Free while in beta |
Bias note: we build Mockbird, so read the table accordingly — but we've tried to keep every row checkable. Pick Microcks when you need multi-protocol coverage, conformance testing against real implementations, or an on-prem requirement. Pick Mockbird when the job is "hosted fake backend, now" — a frontend to unblock, a workshop, a CI stub, a prototype. Plenty of teams could sensibly use both: Microcks in the platform, Mockbird for the quick ones.