A FakeStoreAPI alternative where writes actually work

FakeStoreAPI is the API half the React shopping-cart tutorials on the internet are built on — 20 products, 4 categories, carts, users, a login endpoint, all free with no key. But if your tutorial gets past "render the product grid", you hit its walls fast, and they fail in genuinely confusing ways. All of this verified live, July 2026:

Creates don't create. POST /products returns {"id":21} — but GET /products/21 returns HTTP 200 with an empty body. Not even a 404: your res.json() throws Unexpected end of JSON input and the error message points nowhere near the real cause. The list still has 20 products.
Updates and deletes are theater. PUT /products/1 echoes your change; the next GET shows the old data. DELETE returns the "deleted" record, which is still there.
Filters and pagination are silently ignored. ?title=x returns all 20 products; there's no ?page=; sorting is ?sort=asc|desc by id only.
Register is fake too. POST /users returns {"id":11}; GET /users/11 returns null. Login only works for the 10 hardcoded users.

That's fine for a read-only product grid. It's a wall for carts, checkouts, admin CRUD screens, optimistic updates, or any create-then-refetch flow — i.e. the interesting part of the tutorial. Mockbird keeps what made FakeStoreAPI convenient (free, keyless, CORS on) and removes the walls: your own store, and writes that persist.

Prove it in 10 seconds — no signup

The shared demo project has a live products resource. Create something, then fetch it back:

curl -X POST "https://HOST/m/demo/products" \
  -H 'content-type: application/json' \
  -d '{"name":"My Real Product","price":19.99,"category":"test"}'
# → {"id":31, "name":"My Real Product", ...}

curl "https://HOST/m/demo/products/31"
# → 200, and it's actually there. PUT/PATCH/DELETE stick too.

(Shared demo, resets daily — your id may differ; use the one the POST returns.)

Your own store in one request

The ecommerce preset creates a full seeded backend — 30 products (name, price, image URL, category, stock, rating), 25 orders, 20 customers, 40 reviews with foreign keys:

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

Or skip the terminal: create it with one click.

Translation table

FakeStoreAPI	Mockbird
`/products?limit=5`	`/products?limit=5` — plus real pagination: `?page=2` (or `_page`/`_limit`), `X-Total-Count` header
`?sort=desc` (by id only)	`?sortBy=price&order=desc` — any field
`/products/category/jewelery`	`/products?category=jewelery` — filter by any field, and it actually filters
(no search)	`/products?q=chair` full-text search
(no field selection)	`?select=name,price`
`POST /products` → fake id 21	`POST /products` → 201, record really stored
`/carts?userId=1` (fixed data)	`/customers/1/orders` nested routes from your own FKs, plus `?_expand`/`?_embed` joins
`/auth/login` (10 hardcoded users)	`/auth/login` — any email, or your seeded `users` resource as the roster; register inserts a real record, real signed JWTs, configurable expiry
(no delay/error simulation)	`?mock_delay=2000`, `?mock_status=503` — test loading and error states

The tutorial flows that now work

Add to cart → checkout → order list: POST an order, refetch, it's there. Delete it, it's gone.
Admin CRUD screens: create/edit/delete products and see the table update from the server, not from local state papering over a fake API.
Optimistic updates with rollback: flip ?mock_status=500 on the write to force the rollback path.
Sign-up flow: POST /auth/register creates a user you can immediately log in as.
Broke the data experimenting? Restore a snapshot or reseed — fresh realistic data in one call.

Beyond FakeStoreAPI

Not a shop? Define any schema — or import an OpenAPI spec, a db.json, or a CSV.
A GraphQL endpoint on the same data, with GraphiQL in the browser.
Generated OpenAPI spec, Postman collection, and TypeScript types / Zod schemas from your live schema.
Custom routes, signed webhooks, and a request inspector.

Honest comparison

	FakeStoreAPI	Mockbird
Signup needed	no	no (optional, to keep projects)
Data	20 fixed products with real photos	your schema, realistic seeded data (placeholder image URLs, not curated photos)
Writes	simulated — GET-after-POST returns an empty 200	persist (snapshot/reseed to reset)
Filters / pagination / search	ignored / none / none	any field / page-based + headers / `?q=`
Auth	10 fixed users, register is fake	any email or your users resource; register persists; protected mode
GraphQL / snapshots / exports	—	included, free
Limits	informal	10,000 requests/day per project

Where FakeStoreAPI still wins: its 20 products are hand-picked with real product photography on a CDN — if you just need a pretty read-only grid for a screenshot, it's great, and its zero-setup simplicity is the whole point. Reach for Mockbird when the tutorial (or your app) needs writes, filters, or a schema that isn't a clothing store. Written by the Mockbird maker — bias disclosed; FakeStoreAPI behavior verified live, July 2026. The close cousin DummyJSON has richer data but the same fake-writes wall — covered in its own guide.

Full API reference in the docs. More guides: JSONPlaceholder alternative · fake e-commerce API · mock API for React. Create your API →