Create a mock API in 30 seconds

Paste a response. Pick a status code. Get a URL. No signup.

🔒 No trackers · No analytics · No accounts

How to create a mock API in 30 seconds

Quickmock is an online mock API and REST endpoint generator: paste a JSON (or any) response body, pick an HTTP method and status code, and get a public URL you can call from anywhere — no signup, no install.

1Fill out the form below — method, response body, status code.
2Click "Create Mock" and you'll get a public URL like /m/abc123def456.
3Use the URL in your code. Open the mock page to watch requests live.

Example: create and call a mock with curl

Create a mock that returns 200 with a JSON body:

curl -X POST https://quickmock.dev/api/mocks \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "GET",
    "response_status": 200,
    "content_type": "application/json",
    "response_body": "{\"hello\":\"world\"}",
    "ttl_seconds": 604800
  }'

Then call your new mock:

curl https://quickmock.dev/m/abc123def456
# => {"hello":"world"}

Create a free mock API endpoint

Name (optional)

HTTP Method Response Status Content-Type

Custom path

/m/<slug>/

Optional. Adds a readable label after the slug — your URL becomes /m/<slug>/users/123. Any path under /m/<slug>/* still hits this mock, so it's a hint for humans, not a constraint. Letters, digits, dashes, dots, underscores, slashes; up to 255 characters. Response Body / 512 KB

Dynamic tokens — substituted on every request

Drop these tokens anywhere in the response body. The mock stores them as-is and renders fresh values on each hit. request.* tokens echo parts of the incoming request — values are inserted verbatim.

Person

{{faker.name}} — random first + last name
{{faker.firstname}} — random first name
{{faker.lastname}} — random last name
{{faker.username}} — random handle
{{faker.email}} — random email under @example.com
{{faker.phone}} — random phone (E.164-ish, US)

IDs & network

{{faker.url}} — random https URL on example.com
{{faker.ipv4}} — random IPv4 address
{{faker.uuid}} — random UUID v4
{{faker.int}} — random integer (0..999999)
{{faker.bool}} — random true / false
{{faker.color}} — random hex color, #rrggbb

Text & places

{{faker.word}} — random lorem-ipsum word
{{faker.sentence}} — random 4–8 word sentence
{{faker.lorem}} — random 2–4 sentence paragraph
{{faker.company}} — random company name
{{faker.city}} — random city name
{{faker.price}} — random price, NN.NN

Dynamic values

{{random.pick:a|b|c}} — one random item from a | separated list
{{seq}} — position of this hit, starting at 0 and increasing forever

Time

{{now.iso8601}} — current UTC time, RFC 3339
{{now.unix}} — current Unix timestamp, seconds
{{now.unix_ms}} — current Unix timestamp, milliseconds
{{now.date}} — current UTC date, YYYY-MM-DD
{{now.time}} — current UTC time, HH:MM:SS
{{now.rfc1123}} — current UTC time, RFC 1123 (HTTP date)

Request echo

{{request.method}} — HTTP method of the incoming request
{{request.path}} — URL path of the incoming request
{{request.ip}} — caller IP address
{{request.query.id}} — query parameter by name
{{request.header.x-request-id}} — request header by name
{{request.body}} — raw request body (first 16 KB)
{{request.body.user.name}} — JSON field from the request body, dot path

Delay (ms)

Fixed delay, or set max for random jitter in the min–max range. 0–30000 ms. Expires in

Response Headers

Enable CORS Adds permissive Access-Control-* headers and answers the OPTIONS preflight, so browser code on any origin can call this mock. No credentials are exposed.

Flaky simulation

Make the mock behave like an unstable API: random errors and a response sequence that changes on every call. Tokens like {{faker.uuid}} work in every body.

Error rate (%) This share of requests gets the alternate response below. 0 turns it off. Error status

Error body

Response sequence

Responses are served in order — step 1 is the main response above — then loop. The position is shared by all callers.

Named variants & conditional rules

Add deterministic responses, then select them explicitly or when request conditions match. JSON arrays; limits: 20 variants, 20 rules, 8 conditions per rule.

Response variants (JSON) Response rules (JSON)

Explicit selector: X-Quickmock-Variant header or ?__quickmock_variant=name. Rules support method, path, query, header and JSON body fields.

Multi-route workspace & OpenAPI

Expose up to 50 method + path routes under one slug. Paste routes directly or convert an OpenAPI 3.x JSON/YAML document.

Routes (JSON)

OpenAPI 3.x document

Inspector privacy

The inspector is owner-only by default. Credential headers are always redacted before storage.

Allow anyone with the slug to read request logs Store request bodies Store sender IP addresses

Import from cURL

Paste a cURL command — the form pre-fills the method, body, and Content-Type for you.

Import JSON

Pre-fill the form from an exported mock config.

1,002 mocks created 19,236 requests served

What can you use a mock API for?

Not sure where to start? See ready-to-run recipes for retry testing, flaky APIs, webhooks, and more.

Browse all guides →

Ready-made mock templates

Reproduce the shape of a Stripe, GitHub, Slack, or OAuth2 response without writing the payload yourself — pick a template and create the mock in one click.

Browse all templates →

Mock API FAQ

What is Quickmock?

Quickmock is a free online tool that creates a public HTTP mock endpoint in 30 seconds. You paste a response body, pick a method and status code, and get a URL you can call from any client — curl, Postman, your frontend, a CI test, anywhere.

Do I need to sign up or pay?

No. There is no account, no email, no credit card. Mocks are limited per IP and expire after the TTL you pick (up to 30 days). The service is free and open source.

What can I use Quickmock for?

Frontend prototyping while the backend is not ready, webhook testing, integration and contract tests, reproducing edge cases like 500 errors or slow responses, API demos, and teaching examples.

Can I see who calls my mock?

Yes. Every mock has a private live inspector for incoming method, path, headers, query, and body. Unlock it with the mock's admin token; body and sender-IP capture can be disabled.

Can mocks return dynamic data?

Yes. Drop tokens like {{faker.uuid}}, {{faker.name}}, {{faker.email}}, or {{now.iso8601}} into the response body — the mock stores the template as-is and substitutes fresh values on every hit. request.* tokens echo the incoming request back: {{request.query.id}}, {{request.header.x-request-id}}, {{request.body.user.name}}. The full list (people, IDs, network, text, time, request echo) is in the form under "Dynamic tokens".

Mock API glossary: endpoint, TTL, faker tokens

Mock API: A fake HTTP endpoint that returns a response you control — used to develop against an API before the real one exists, or to reproduce specific responses in tests.
Endpoint: A single addressable URL on a server that accepts requests of a given method (GET, POST, …) and returns a response. Quickmock gives you one per mock.
TTL: Time-to-live — how long a mock stays alive before Quickmock deletes it. Pick 1 hour, 24 hours, 7 days, or 30 days at creation.
Faker token: A placeholder like `{{faker.email}}` or `{{now.iso8601}}` that Quickmock substitutes with a fresh random value on every request, so the same mock can return different data each call.
Content-Type: The HTTP header that tells the client how to parse the response body — `application/json`, `application/xml`, `text/plain`, `text/html`.

Why another free mock API tool?

Every team I've worked on has spent hours of dev time on the same problem: the frontend needs an endpoint that the backend hasn't built yet, or QA needs to reproduce a flaky 500, or someone wants to demo an API contract without spinning up a whole service. I kept reaching for hosted mock-API tools that demand a signup, a paid tier for anything past three endpoints, and a privacy policy I'd rather not read. Quickmock is what I wanted instead: a public URL in 30 seconds, no account, no tracking, real request inspector, fully open source.

Who built this

Quickmock is built and maintained by Nikita Chernykh — backend engineer / tech lead — as a free side project. The whole thing is open source on GitHub; the code, the schema, the deploy script — everything you see is in the repo.

Personal site · GitHub · LinkedIn · Telegram

No signup, no tracking, no accounts

No third-party analytics. No tracking pixels. No fingerprinting. No external JS or fonts. No ads. No accounts, no email, no data sold or shared.

What I do log (and why)

Your IP for rate limiting — kept for 8 hours in Redis, then dropped.
The IP that created a mock — to enforce the 50-mocks-per-IP limit. Never shown in the UI.
Requests to your mocks — that's the private inspector. Body and sender-IP capture can be disabled; retained requests disappear with the mock.
Language preference and, after admin-token verification, a path-scoped HttpOnly inspector session.

Last updated: 2026-09-08