Slow it down
Give any endpoint a delay of up to eight seconds. Skeletons, spinners and timeouts finally have something to wait for.
0 s2 s, your setting8 s cap
Your API, before you writea line of it.
Describe an endpoint in a sentence. Mockbird serves realistic JSON from a live URL, and lets you make it slow or make it fail, so the loading and error states get built today instead of after the backend ships.
- Live
- A real URL in about five seconds
- Latency
- Any delay up to 8,000 ms, per endpoint
- Failures
- A failure rate with the status you choose
- Routing
- Params, wildcards and a 404 that suggests the right path
Five endpoints free. No card, no install, no seed data.
Try itThis creates a real endpoint.
InjectSet before you create it
GET
/Idle[
{
"id": "ord_92kd",
"customer": "Rohan Mehta",
"total": 4820,
"status": "shipped"
},
{
"id": "ord_71bz",
"customer": "Ananya Iyer",
"total": 1290,
"status": "refunded"
}
… 10 more
]
Nothing is saved until you press Create. Demo endpoints stay live for 24 hours.
Test the states you can't fake.
A real backend is slow, sometimes broken, and particular about routes. Mockbird lets you switch each of those on per endpoint, so your loading, error and routing code runs before launch instead of after.
Break it on purpose
Set a failure rate and that share of calls returns the error you pick, from 400 to 503. Your error path runs before a customer finds it.
Last 20 calls at 20%4 × 503 · 16 × 200
Routes that match like a router
Static beats parameter beats wildcard, so /orders/new is never swallowed by /orders/:id. Any method, any depth.
GET
/orders/ord_92kd200
/orders/newchecking100
/orders90
/orders/:id50
/orders/*Bodies that answer the request.
Write tokens into a stored body and they resolve on every call, so GET /orders/:id returns the id that was asked for. Change the request below and watch the response follow.
Request
GET
Stored body · /orders/:id
{
"id": "{{id}}",
"page": "{{query.page}}",
"placedAt": "{{now}}",
"customer": "{{random.name}}",
"ref": "{{random.int}}",
"items": [
{ "pos": "{{index}}" },
{ "pos": "{{index}}" }
]
}
Response · 200 OK
{
"id": "ord_71bz",
"page": "2",
"placedAt": "2026-10-01T09:41:00.000Z",
"customer": "Ananya Iyer",
"ref": 4821,
"items": [
{ "pos": 0 },
{ "pos": 1 }
]
}
Tokens
{{id}} | The matched path param of that name |
{{query.page}} | A query-string value, empty when absent |
{{wildcard}} | Everything captured by a trailing * |
{{now}} | ISO timestamp at request time |
{{index}} | Position in the enclosing array, as a number |
{{random.name}} | A fake name, new on every call |
{{random.int}} | An integer from 1 to 9999, new on every call |
Only the two random tokens break the same-bytes guarantee.
Swap one URL when the backend lands.
Your app calls the mock the way it will call the real API: same paths, same status codes, same JSON. Keep the base URL in an environment variable and the switch is a one-line change.
// .env.local
NEXT_PUBLIC_API_URL=/m/a8f3k2
// app/orders/page.tsx
const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/orders`);
if (!res.ok) throw new Error(`Request failed: ${res.status}`);
const orders = await res.json();
Where the AI sits
No model runs when your app calls the mock. The same request returns the same bytes, every time.
The model runs once, when you press Create. It turns your sentence into a JSON Schema and writes sample records that fit it, and nothing is saved until you accept them.
After that, every call is read from the database and returned verbatim. There is no inference on the request path, so no added seconds, no per-call cost, and no data shifting under the interface you're building. Without a model key, Mockbird falls back to a hand-written skeleton and everything else works the same.
Point your app somewhere real.
Five endpoints free, no card.