A free Postman mock server alternative — 10,000 requests/day, and it's stateful

Postman's built-in mock servers are great for a quick demo, but the free plan caps them at 1,000 calls per month — one frontend polling every few seconds burns through that in an hour. And they're example-based: they replay saved responses, so a POST doesn't actually create anything and the next GET won't reflect it. Mockbird gives you a stateful mock REST API — creates persist, deletes disappear, filters filter — with 10,000 requests/day per project, free. And because every project exports a native Postman collection, you keep working in Postman.

Try it in 10 seconds (no signup)

Import the shared demo project into Postman right now: Import → paste this link:

https://HOST/m/demo/postman.json

You get folders for products, orders, customers and reviews, each with List / Get one / Create / Update / Delete requests, example JSON bodies that match the schema, and a {{baseUrl}} variable already set. Or peek at it from the terminal:

curl https://HOST/m/demo/postman.json

Your own mock in 60 seconds

Create a project — one request, no account:

curl -X POST https://HOST/api/projects \
  -H 'content-type: application/json' \
  -d '{"name":"my-api","preset":"ecommerce"}'
# → {"id":"abc123","adminKey":"KEY","baseUrl":"https://HOST/m/abc123", ...}

(Presets: blog, ecommerce, saas — or define your own resources, or import an OpenAPI spec.)

In Postman: Import → Link → https://HOST/m/abc123/postman.json.
Send requests. That's the whole setup.

The collection is generated from the live schema on every request, so after you add or change resources, just re-import to sync. Insomnia and Hoppscotch import Postman collections too — the same URL works there.

Stateful beats example-based

The core difference to a Postman mock server: Mockbird endpoints are backed by a real database with seeded, realistic fake data.

# create something…
curl -X POST https://HOST/m/demo/products \
  -H 'content-type: application/json' \
  -d '{"name":"Test Product","price":9.99}'

# …and it's actually there
curl "https://HOST/m/demo/products?search=Test+Product"

Pagination with x-total-count, sorting, field filters, full-text search, relations (?_expand=/?_embed=, nested routes), CORS on everything — the behaviors your real API will have, so your error handling and loading states get exercised for real. Plus simulation knobs Postman mocks don't have: ?mock_delay=2000 for latency and ?mock_status=500 for failures (guide).

Bring your existing collection

Already have your API described as a Postman collection — the same one you built the mock server from? Import it directly; you don't have to recreate anything:

# export your collection from Postman (Collection v2.1), then:
curl -X POST https://HOST/api/projects/import --data-binary @collection.json

Requests become resources (GET /users, /users/:id → users), and here's the part that matters if you've invested in examples: your saved 2xx example responses become the hosted records, verbatim — the same data your mock server was returning, now behind stateful CRUD endpoints with filtering and pagination. Requests without saved examples get a schema inferred from their JSON bodies and realistic seeded data instead. {{baseUrl}} variables, :id/{{userId}} path params and {"data": [...]} wrappers are all handled. Details in the docs.

It round-trips, too: every Mockbird project exports a ready-to-import collection at /postman.json, and that file imports back cleanly.

Testing auth flows in Postman

Flip a project into protected mode and every endpoint requires a Bearer token — and the exported collection handles that for you: it gains an auth (mock) folder whose Login request (any email + password returns a real signed JWT) stores the token in a {{token}} collection variable via a test script. Run Login once; every other request in the collection authenticates automatically. Set expiresIn: 5 in the login body to watch your 401 handling cope with expiry.

Honest comparison

	Postman mock server (free)	Mockbird
Free capacity	1,000 calls/month	10,000 requests/day/project
Behavior	replays saved examples	stateful CRUD on seeded data
Setup	account + collection + examples per endpoint	one curl (or one OpenAPI/db.json paste), no signup
Pagination / filters / search	only what you hand-write as examples	built in on every resource
Latency & error simulation	fixed per mock (delay); `x-mock-response-code` needs matching examples	`?mock_delay=` / `?mock_status=` on any request
GraphQL	✘	same data at `/graphql` + GraphiQL
Works outside Postman	yes (public URL)	yes — plain HTTPS + CORS, plus `openapi.json` and `types.ts` exports

Where Postman's own mocks still win: they replay your exact saved examples (byte-for-byte contract responses, selectable with x-mock-response-name), they live inside the workspace your team already shares, and paid plans raise the caps. If you need precise canned responses rather than realistic behavior, use those — or add a Mockbird custom route with a fixed payload for the handful of endpoints where the exact bytes matter. Written by the Mockbird maker — bias disclosed; Postman numbers checked July 2026.

FAQ

Does the import stay in sync? The collection regenerates from your live schema on every fetch of /postman.json; re-import after schema changes. Postman keeps your edits in the old copy, so re-importing creates a fresh collection alongside it.

Can I go the other way — Postman/OpenAPI → Mockbird? Yes: export your API definition as OpenAPI from Postman and POST it to /api/projects/import — you get a live seeded mock of the whole spec in one request.

Limits? 10,000 requests/day per project, 20 projects per free account (anonymous projects work too — 10/day per IP), records capped per resource. Details in the docs.

The same project also gives you a request bin, mock JWT auth, snapshot fixtures and signed webhooks. (WireMock Cloud's free tier has the same 1,000-calls/month cap — that comparison here.) Create your mock →