Credit where due: Stoplight Prism is a genuinely good tool. It's open source (Apache-2.0, ~5k stars, still actively released as of mid-2026), it turns an OpenAPI 2.0/3.0/3.1 document or a Postman collection into a running mock in one command, and its validation proxy — checking real traffic against the contract — is something we don't do at all. If you're using Prism for contract testing in CI, keep using it. This page is about the two walls you hit when you use it as your development sandbox.
Wall 1: it's stateless — by design, for now. Prism generates responses from your spec's examples and schemas. POST /pets returns whatever the spec says a 201 looks like, but nothing is created: the next GET /pets returns the same example list as before. Every write is theater. This isn't a bug — Prism's own README roadmap lists Data Persistence ("allow Prism act like a sandbox") as an open, unshipped item (checked August 2026). If your frontend has a form, a cart, a settings page — anything that writes and then reads — an examples-replay mock can't exercise it.
Wall 2: it lives on localhost. prism mock api.yaml binds a local port (in Docker you need -h 0.0.0.0 just to escape the container). The moment a teammate, a deployed preview, CI, or your phone needs the mock, you're either self-hosting Prism somewhere or moving to Stoplight's hosted mocking — which lives inside the Stoplight API-design platform, with an account and its plans.
Mockbird takes the same OpenAPI document and gives you a hosted, stateful, seeded CRUD mock — writes persist, reads reflect them, and the URL works for anyone. Free, no signup.
Where you'd run prism mock petstore.json, POST the document instead:
curl -X POST 'https://mockbird.mockbird.workers.dev/api/projects/import?name=petshop' \
-H 'content-type: application/json' --data-binary @petstore.jsonResponse (real output — a petstore spec with a Pet schema):
{
"id": "up2g5axdzz",
"adminKey": "…", ← save it; manage or delete the project with it
"baseUrl": "https://mockbird.mockbird.workers.dev/m/up2g5axdzz",
"imported": true, "kind": "openapi",
"resources": [ { "name": "pets", "seeded": 20,
"fields": ["name","species","photoUrl","adopted","addedAt"] } ],
"try": "curl 'https://mockbird.mockbird.workers.dev/m/up2g5axdzz/pets?limit=3'"
}JSON or YAML, OpenAPI 3.x or Swagger 2.0, Postman collections too — same auto-detecting endpoint. $ref/allOf are resolved, formats (uri, date-time, email, uuid) map to realistic generators, and enums are kept verbatim — a species enum of dog/cat/bird seeds only those values. Prefer a UI? Paste the spec at /app#import.
Your examples are served verbatim — like Prism, but live. If a resource's GET response carries an explicit example / examples (media-level, schema-level, or Swagger 2.0 response.examples), Mockbird hosts those exact records instead of seeding fake data — and unlike Prism's replay, they're stateful: POST adds one, DELETE removes one, filters and pagination work over them. {"data": [...]} wrappers are unwrapped; pass ?examples=0 if you'd rather have seeded data. Details: spec-faithful import.
Non-CRUD paths round-trip too. Real specs aren't all /things and /things/{id}: login endpoints, /search, /health, RPC-style verbs like POST /invoices/{id}/send. Every operation that doesn't fit the CRUD reshaping is imported as a custom route that answers with your spec's own example verbatim (any content type), or a value generated from the schema when there's no example — which is exactly Prism's examples-replay behavior, kept where it belongs, on top of the stateful CRUD. A spec with zero CRUD-shaped paths still imports as a pure fixed-route mock.
curl -X POST https://mockbird.mockbird.workers.dev/m/<PID>/pets \
-H 'content-type: application/json' \
-d '{"name":"Spot","species":"dog","adopted":false}'
# → {"name":"Spot","species":"dog","adopted":false,"id":21}
curl https://mockbird.mockbird.workers.dev/m/<PID>/pets/21
# → the same record. It's real. It's still there tomorrow.PUT/PATCH/DELETE all behave like a real backend, and the full query toolkit works without being declared in your spec: ?species=dog, ?limit=2&page=3, ?sortBy=addedAt&order=desc, ?q=spot, ?select=name,species, range filters like ?addedAt_gte=…. When you want a clean slate, don't restart a process — save and restore named snapshots, or pin a snapshot per request with X-Mockbird-Snapshot so parallel test workers never race.
| Prism | Mockbird | Notes |
|---|---|---|
prism mock api.yaml | POST /api/projects/import | same document in; hosted URL out — docs |
Prefer: code=404 | ?mock_status=404 | any status on any endpoint; deterministic sequences via ?mock_seq= |
Prefer: dynamic=true / -d (faker data) | seeded realistic data by default | generated at import from types/formats/enums; reseed any time (?seed=N on import, or reseed in the dashboard) |
Prefer: example=cat (pick a response variant) | snapshot pinning | save data states (empty, edge-cases, bug-repro) and pin one per request |
| examples replay on non-CRUD paths | automatic at import | login//search/RPC operations become custom routes serving the spec's example verbatim |
| latency / failure drills | ?mock_delay=2000, ?mock_seq=500,500,200, ?mock_chaos=0.3, ?mock_ratelimit=2 | fail on cue for retry/backoff tests — guide |
| request validation (422 from the spec) | strict validation mode | per-field 422 errors from your resource schema — not spec-driven contract checking |
| validation proxy (contract testing) | no equivalent | honest: run Prism for this — the two compose (below) |
| console request log | request inspector | last 50 requests w/ headers + bodies, readable from tests via API |
| — | GraphQL, mock JWT auth, webhooks, exports | generated GraphQL, real signed tokens, HMAC webhooks, export OpenAPI/Postman/TS+Zod/db.json |
# Prefer: code=404 equivalent
curl -i 'https://mockbird.mockbird.workers.dev/m/demo/products?mock_status=404'
# 2s latency on cue (measured 2.1s)
curl 'https://mockbird.mockbird.workers.dev/m/demo/products/1?mock_delay=2000'
# fail twice, then succeed — point your retry logic at it
curl 'https://mockbird.mockbird.workers.dev/m/demo/products?mock_seq=500,500,200&mock_seq_key=me1'
# → 500, 500, 200 across three callsPrism's real superpower is contract enforcement: prism proxy api.yaml https://real-api flags every request/response that violates the spec. Nothing we do replaces that. A setup we'd actually recommend: Prism in CI as the contract cop, Mockbird as the shared stateful sandbox your frontend, previews, and teammates develop against. Same OpenAPI document feeds both — and our exported spec stays in sync with whatever your mock's schema evolves into, so you can even round-trip it back through Prism.
| Prism CLI | Stoplight hosted mocks | Mockbird | |
|---|---|---|---|
| Price | free, open source | part of the Stoplight platform (account + plan) | free while in beta |
| Hosted URL others can hit | no — localhost or self-host it | yes | yes — 10,000 requests/project/day, no signup |
| Stateful writes (POST → GET it back) | no — on the official roadmap, unshipped | no — same engine | yes — persistent records, snapshots, restore |
| Response data | your spec's examples (static) or faker-generated (-d) | same | seeded realistic records honoring formats + enums |
| Filtering / pagination / sorting | only if declared & examples cover it | same | always on: filter, sort, search, paginate, select, ranges |
| Contract validation | excellent — requests & responses vs spec, proxy mode | yes | no (strict field validation only) |
| Failure/latency drills | Prefer: code= for status picking | same | status, delay, sequences, chaos, rate limits, jitter |
| Works offline | yes | no | no |
| Input formats | OpenAPI 2/3/3.1, Postman | OpenAPI | OpenAPI 2/3, Postman, db.json, CSV, HAR |
Written by the Mockbird maker — bias disclosed. Where Prism genuinely wins: contract validation (ajv-backed request/response checking and the proxy mode) is its whole reason to exist and we have no equivalent (a former second gap — CRUD collections serving generated data instead of your examples — closed in September 2026: explicit response examples are now hosted verbatim on CRUD resources and non-CRUD routes alike); it runs offline with no request caps; and it's Apache-2.0 open source you can embed in CI without trusting anyone's uptime. Facts checked August 2026 against the official stoplightio/prism README (v5.15.11, June 2026): mocking + validation proxy + OpenAPI 2/3/3.1 + Postman support, hosted mocking via the Stoplight platform, and the unshipped roadmap items "Data Persistence" and "Recording/Learning Mode".
Full API reference in the docs. More guides: Stoplight platform alternative (the sunset angle) · mock server from an OpenAPI spec · free mock API tools compared · Mockoon alternative · WireMock Cloud alternative · mountebank alternative. Create your API →