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 does Quickmock work?

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 Mock 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.

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.company}} — random company name
{{faker.city}} — random city name

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)

Delay (ms) Simulate a slow API. 0–30000 ms. Expires in

Response Headers

Import from cURL

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

60 mocks created 3,494 requests served

Frequently asked questions

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 live inspector that shows incoming requests in real time — method, path, headers, query, and body. You can clear the log any time.

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. Full list of 22 tokens (people, IDs, network, text, time) is in the form under "Dynamic tokens".

Quick glossary

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 I built Quickmock

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.

GitHub · LinkedIn · Telegram

What I don't do

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 inspector feature. You can clear them any time, and they disappear when the mock expires.
Your language preference, in a cookie. That's it for cookies.

Last updated: 2026-05-25