Free for Windows, macOS & Linux · v0.1.0

API Mock Server The backend isn't ready. Your frontend can be.

API Mock Server gives you a working fake API in seconds, from a folder of JSON files or your OpenAPI file. Then it lets you make that API slow, make it fail, or make it stop answering, so your loading screens and error messages are built now, not after something breaks in production.

Download free See how it works
  • No code to write
  • No account needed
  • Windows, macOS & Linux
  • Your data never leaves your machine
API Mock Server showing every request as it arrives: the status, how long it took, the delay added and any error that was injected
To a working API
3 clicks
Backend code to write
0
Failure modes
5
Price
$0

Waiting for the backend slows everyone down

The frontend is always the last to know.

Real networks are slow and real servers fail. Your app should handle both well. API Mock Server lets you build and test all of it now, on your own machine, as often as you like.

Blocked on the backend

The endpoint you need is "coming next sprint". So the screen that uses it waits too, and so do you.

01

Loading states nobody has seen

On localhost every answer is instant, so the spinner, the skeleton and the double-click bug never show up until real users do.

02

Error screens built after the outage

The 500 page, the retry button, the "you're offline" message: written in a hurry, the night production fell over.

03

Tests that can't make the server fail

Your tests prove the happy path works. Proving the app survives a 503 or a dropped connection is the part nobody gets to.

04

Three steps to a working API

New project. Start. Build.

  1. 1
    Click New project

    You get a ready-to-use example with users, posts, orders and a login.

  2. 2
    Click Start server

    Your API is now running at http://localhost:4000.

  3. 3
    Point your app at it

    Change your app's API address and start building.

That's all. No code to write, no account to create, nothing to set up.

users.json → http://localhost:4000
# Your app sends          It gets
GET    /users           the list of users
GET    /users/1         user number 1
POST   /users           a new user, with a new id
PATCH  /users/1         the user, changed
DELETE /users/1         the user, removed
GET    /users/1/posts   only the posts of user 1

A fake API that acts like a real one

Real enough that your app can't tell.

JSON files, OpenAPI files and hand-written answers, with every request in plain sight.

From JSON files

One JSON file. A complete API.

Make a file called users.json with a list of users in it, and you have the whole REST API for users. It behaves like a real server: add a user and it's in the list the next time you ask.

  • List, get, create, replace, update and delete, with new ids handed out for you
  • Related records: /users/1/posts returns only the posts of user 1
  • Search, filter, sort and split into pages, just like a real API
  • Your files on disk are never changed, and Reset data puts everything back

Already using json-server? Your db.json works as it is.

Query any list
GET /users?role=admin
    only admins
GET /users?age_gte=18
    age 18 or more
GET /users?name_like=ada
    name contains "ada"
GET /users?q=london
    search everything
GET /users?_sort=-createdAt
    newest first
GET /users?_page=2&_limit=20
    page 2, 20 per page

OpenAPI & Swagger

Your OpenAPI file, ready to use.

Got an OpenAPI or Swagger file from the backend team? Open it, and every endpoint in it works straight away. No waiting for the real thing.

  • Examples first: if the file has example responses, you get those
  • Real-looking data when it doesn't: names look like names, emails like emails, prices like prices
  • The same data every time, so your screens don't jump around. Change the seed for a fresh set
  • Ask for order 42 and you get an order with id 42
  • More than one example, like "paid" and "refunded"? Ask for the one you want
  • OpenAPI 3
  • Swagger 2
  • YAML
  • JSON
An order generated from an OpenAPI file, with realistic emails, products, prices and dates

Request checks

Find out what the API will reject. Today.

If your app sends something the API won't accept, you find out now, not when the real server turns it down. Missing fields, wrong types, values too long or too small: you get a clear list of what's wrong.

  • Every request body checked against your OpenAPI file
  • Errors that point at the exact field, like body.items[0].quantity
  • Errors your file describes look exactly like the real ones
POST /orders · 400
{
  "error": "The request body doesn't match the OpenAPI spec",
  "details": [
    "body.customerEmail: is required",
    "body.items[0].quantity: must be at least 1"
  ]
}

Any other answer

A login, a search, a health check. Write it once.

For everything that isn't a list of records, write the answer once in a small file. It can use what your app sent, and it can send back a file, like an image or a PDF.

  • Use the request in the answer: {{body.email}}, {{query.search}}, {{params.id}}
  • Send files: images, PDFs, anything
  • Wildcards and any status code, like a 410 for an old API
routes.json
[
  { "method": "POST", "path": "/login",
    "body": { "token": "abc123",
              "email": "{{body.email}}" } },
  { "method": "GET",
    "path": "/users/:id/avatar",
    "file": "avatar.png" },
  { "path": "/old-api/*", "status": 410 }
]

See every request

When your app does something strange, see exactly what it got.

The Requests tab shows every call your app makes, as it happens. Search it, pause it, clear it.

  • The method, address and status of every call
  • How long it took, and how much delay was added
  • Any injected error, clearly marked
  • What answered: a data file, a fixed answer, or the OpenAPI file
The API Mock Server request list in dark mode, showing status, time, injected delay and errors for each call

Every route in one list

Know exactly what your fake API answers.

The Routes tab lists every route and where its answer comes from. Search it, see each route's delay and error rules at a glance, and open any GET route in your browser with one click.

  • Every route from your JSON files, your routes file and your OpenAPI file
  • The rules on each route, visible at a glance
  • One click to open any GET route in the browser
Every route listed with its source, from data files, routes.json and an OpenAPI file

Make it slow. Make it fail.

Break the API on purpose, before production does it for you.

Choose how often it happens, from never to every time: "5% of all requests fail with 500 or 503". Then give one route its own rules. Make only the payment page fail, or only the order list slow.

  • Every route can have its own delay, error rate and errors
  • Errors your OpenAPI file describes look exactly like the real ones
  • One switch turns everything off, for when you just want to work fast
Add a delayAnswers take longer: 1500 ms, or a random time like 200-800 ms
Delay
Return errorsSome or all answers are 500, 503, 404, 429, or any code you pick
Errors
Time outNo answer at all, then the connection closes
Timeout
Drop the connectionIt breaks halfway: "Failed to fetch" in the browser
Drop
Send slowlyThe answer arrives bit by bit, like on a bad mobile network
Slow
The rule for one route: a 1.5 second delay, and 30% of requests fail with 404, 503 or a dropped connection
One route, its own rules: a 1.5 second delay, and 30% of requests fail with a 404, a 503 or a dropped connection.

Ask from your app or your tests

"When the server returns 500, show an error" is now a two-line test.

Need a slow answer or an error for just one request? Add a header.

  • X-Mock-Delay: 2000A 2 second wait
  • X-Mock-Status: 503A 503 error (or timeout, drop, slow)
  • X-Mock-Chaos: offNo delays or errors, for this request only
  • X-Mock-Example: refundedThe "refunded" example from your OpenAPI file
  • ?__delay=2000No headers in your tool? Use the address instead
All delay and error rules in one place: rules for every request, rules for single routes, and the headers your app can send

Share it. Script it.

Set it up once. Everyone gets the same fake API.

Everything you set up is saved in the project folder, so you can share it or put it in Git. Your tests can even change the rules while the server runs, through a small built-in API at /__admin: turn on errors before a test, put the data back after it, and read the list of requests your app made.

Made for everyday work

The small things, done properly.

  1. 01

    Changes show up at once

    Save a JSON file or the OpenAPI file and the API updates. No restart.

  2. 02

    Many projects

    Keep a list of fake APIs and run several at once, on different ports.

  3. 03

    Works with your browser

    Cross-origin requests (CORS) are allowed, so your web app can call it straight away.

  4. 04

    A base path if you need one

    Like /api, to match your real server.

  5. 05

    Send it to Postman

    One click makes a Postman collection with every route. Each request checks its answer, so it doubles as a quick test.

  6. 06

    Share it with your team

    Everything lives in the project folder. Put it in Git and everyone gets the same fake API.

  7. 07

    Light and dark

    Themes that follow your system.

  8. 08

    Updates itself

    When a new version is out, it offers to install it.

Your data stays on your computer

No account. No cloud. Nothing to sign up for.

API Mock Server runs entirely on your machine. Your files and your requests never leave it. The only time it goes online is to check for updates.

Who uses API Mock Server

Anyone who can't wait for the real API.

  • Frontend & mobileBuild screens before the backend exists, and test loading and error states.
  • QA & testMake failures happen on demand, and repeat them exactly.
  • Backend teamsShare a working version of the API with the frontend team on day one.
  • Design & productTry out a prototype with realistic data.
  • TrainersGive students an API that works without a real server.

Coming next

Built with the people who use it.

  • Keep your changes

    Save the data your app creates back to the files, if you want to.

  • Record mode

    Copy answers from a real API and turn them into mocks.

  • Answers in order

    Fail the first time, succeed the second, to test retries.

  • WebSockets & live updates

    For apps that don't just ask, but listen.

Want a say in what comes first? Tell us.

API Mock Server vs a simple mock tool

More than a JSON file on a port.

CapabilitySimple mock toolAPI Mock Server
API from JSON files Yes With filters, sorting, pages and related records
OpenAPI / Swagger files Sometimes Examples, or realistic data from the schema
Checks what your app sends No A clear list of what is wrong
Delays Sometimes, one for everything Fixed or random, per route
Errors Usually one at a time, by hand By chance, by route, or on request
Timeouts, dropped connections, slow answers No All three, on demand
Desktop app No Windows, macOS and Linux
Live list of requests No With delays and errors marked
Change rules from tests No Built-in admin API
Postman collection No One click, with checks

Get API Mock Server 0.1.0 · Free

Your fake API is a minute away.

Pick the file for your system. We'll email you a one-time code, and the download starts as soon as you enter it.

First launch, servers & CI

Windows

If Windows shows "Windows protected your PC", choose More info, then Run anyway. API Mock Server then appears in the Start menu.

macOS

Open the .dmg and drag API Mock Server into Applications. The first time, open System Settings, Privacy & Security, and click Open Anyway.

Linux

Install the .deb with apt or the .rpm with dnf, like any other package. The AppImage needs no install: make it executable (chmod +x) and run it.

Updating

API Mock Server updates itself: when a new version is out, it offers to install it. Your projects and settings are kept.

The first-launch warning appears because API Mock Server is new and not yet widely downloaded; it only shows once. Verify your download (optional): each file's SHA-256 checksum is in SHA256SUMS.txt.

Download API Mock Server

Where should we send your code?

We'll email you a one-time code to start . No account, no spam.

FAQ

Questions, answered.

Something else? Ideas, or a demo for your team? Email jamal@unravelers.tech.

Is API Mock Server really free?

Yes. Download it and use it for as many projects as you like.

Do I need to know how to code?

No. Make a new project in the app, click Start, and you have an API. You only edit JSON files if you want different data.

I already have an OpenAPI or Swagger file. Can I use it?

Yes. Open the folder that has it and every endpoint works. It reads OpenAPI 3 and Swagger 2, in YAML or JSON.

Does it change my JSON files?

No. Changes your app makes are kept in memory. Click Reset data, or restart, to go back to what the files say.

Can my whole team use the same fake API?

Yes. Everything is saved in the project folder. Share it or put it in Git, and everyone who opens it gets the same fake API.

Can I use it in automated tests?

Yes. Use headers like X-Mock-Status: 500 to cause an error on one request, or change the rules for the whole server through /__admin before a test.

Can other people on my network use it?

Yes. Set "host": "0.0.0.0" in the project's mockapi.json and others can reach it at your computer's address.

Does it send my data anywhere?

No. Everything runs on your computer. It only goes online to check for updates.

Which systems does it run on?

Windows 10 and 11, macOS 11 or later on Apple silicon and Intel, and 64-bit Linux.

Stop waiting for the backend

Build the whole frontend today. Including the parts that break.

API Mock Server is free for Windows, macOS and Linux. A working API in seconds, and every failure you need to test, on demand.

Download API Mock Server, free Talk to us