ReqRes vs Mockoon

Mockoon and ReqRes both give you an API to build and test against before the real one exists. The difference is where it runs and what it remembers. Mockoon is a mock server you run on your own machine or in CI. ReqRes is a hosted API with a public URL, persistent data and real user accounts, so there is nothing to install or keep running.

TL;DR

• Mockoon is a free, open-source (MIT) desktop app, CLI and Docker image. You design routes locally and serve them from your machine or pipeline.
• ReqRes is hosted. You call it with fetch() from anywhere, including a teammate's laptop, a phone, a deployed preview or a CI runner, with no server to start.
• Mockoon's CRUD data lives in memory and resets when the mock restarts. ReqRes collections are stored, so data you write is still there tomorrow.
• Mockoon simulates auth with rules. ReqRes has real app users with magic-code login and per-user data.
• Pick Mockoon for offline, file-based mocks you version with your code. Pick ReqRes when you want a shared, always-on backend with no setup.

What Mockoon is

Mockoon is an open-source API mocking tool that runs locally with no account. It ships as a desktop app, a CLI (@mockoon/cli) and a Docker image, and it has an official GitHub Action for CI. Mocks are JSON files you can commit alongside your code.

It is strong at designing responses:

• Rules and templating - match on path, query, headers, body and cookies, and template responses with request data
• Proxy and recording - forward unknown routes to a real API and turn recorded traffic into mocks
• OpenAPI import and export
• Latency and status codes per route
• CRUD routes backed by data buckets (held in memory, reset on restart)

Mockoon Cloud adds hosted mocks and collaboration. The Team plan is $100/month billed annually, with 5 seats, 3 cloud mocks and 100,000 calls a month. There is no free cloud tier.

What ReqRes is

ReqRes is a hosted backend you call with fetch(). It has three parts:

• A free demo API at https://reqres.in/api/users with no signup, widely used in tutorials and courses. Add ?delay=3 to any demo request to test loading states.
• Projects with persistent collections, app-user authentication, request logs and custom endpoints.
• Failure scenarios - named failures you can trigger on demand to test error handling. Three are free (a 429 rate limit, a 422 validation error and malformed JSON). All 15, including timeouts, 5xx errors and redirect loops, come with the Agent Developer plan.

Key differences

When to choose ReqRes

• Nobody has to run anything. Frontend, QA and product can all hit the same URL, from any device.
• You need data that sticks. A demo, a prototype or a multi-step test flow that writes data and reads it back later.
• You need real users. Log in, get a session, and see only that user's records, without building auth.
• You want to see every call. Request logs show exactly what your app sent.
• You want error handling tested against real failures, not just a status code you typed.

Example scenarios:

• A frontend team building against an API the backend team has not shipped yet
• A QA engineer running the same flow from a laptop, a phone and a CI job
• A student or bootcamp cohort that cannot install tools on locked-down machines
• A demo that has to keep working after you close your laptop

When to choose Mockoon

• You want everything local and offline, with no account and no network dependency.
• You want mocks in Git as JSON files that change with your code.
• You need detailed response design, with conditional rules, templating, proxying and recording from a real API.
• Your tests should reset to a known state each run (in-memory state is an advantage here).
• You want it free at any volume and are happy to host it yourself.

Side by side: write, then read back

ReqRes (data is stored):

const headers = {
  'Content-Type': 'application/json',
  'x-api-key': 'YOUR_MANAGE_KEY', // pro_* key for writes, keep it server-side
};

await fetch('https://reqres.in/api/collections/tasks/records', {
  method: 'POST',
  headers,
  body: JSON.stringify({ data: { title: 'Write tests', done: false } }),
});

// Later, from any machine, the record is still there
const res = await fetch('https://reqres.in/api/collections/tasks/records', { headers });
const { data } = await res.json();

Mockoon (CRUD route on a data bucket, served locally):

await fetch('http://localhost:3000/tasks', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ title: 'Write tests', done: false }),
});

// Works until the mock restarts, then the bucket resets to its initial data
const tasks = await fetch('http://localhost:3000/tasks').then((r) => r.json());

Testing error handling

ReqRes returns real failure responses on demand:

# Free, no signup
curl -i https://reqres.in/agent/v1/scenarios/rate-limited      # 429 with Retry-After
curl -i https://reqres.in/agent/v1/scenarios/validation-error  # 422
curl -i https://reqres.in/agent/v1/scenarios/malformed-json    # 200 with a broken body

Mockoon lets you add a rule or response that returns the status code and body you choose, with optional latency on the route.

Both work. ReqRes gives you ready-made failures with realistic headers (such as Retry-After on a 429) and nothing to configure; timeouts, 5xx errors and the other scenarios are on the Agent Developer plan. Mockoon gives you full control for free, and you build each one yourself.

Using both

They fit together well. Many teams keep Mockoon mocks in the repo for fast, offline unit and integration tests, and use ReqRes for anything that has to be shared, persistent or reachable from outside a machine: demos, preview deployments, cross-device QA and teaching.

ReqRes is not for you if...

• You need to work fully offline
• Your mocks must live in your repository as files
• You need to proxy or record traffic from an existing API
• You need to mock protocols other than REST

Common questions

Is ReqRes a free Mockoon alternative?

For hosted use, yes. The ReqRes demo API needs no signup at all, and projects start on a free tier (250 requests a day, 3 collections). Mockoon itself is free to run locally; its hosted cloud starts at $100/month billed annually.

Does Mockoon keep data between restarts?

No. Mockoon's CRUD routes remember writes while the mock is running, but the state is not saved to the data file, so it resets on restart. ReqRes stores collection data until you delete it.

Can I use ReqRes in CI like Mockoon's GitHub Action?

Yes, and there is nothing to start. Point your tests at https://reqres.in with a project key. If your pipeline cannot reach the internet, Mockoon's local CLI is the better fit.

Does ReqRes support OpenAPI like Mockoon?

ReqRes publishes an OpenAPI spec for its own API at reqres.in/openapi.json. If you need to import your own spec and generate a mock from it, Mockoon does that today.

Next step

• Best mock API tools, by use case
• Call the free demo API - no signup
• Create a project - persistent collections, auth and logs
• Test error handling - failure scenarios for 429s, validation errors and more