DEV Community

gmazzeigraf
gmazzeigraf

Posted on

MockMe: Instant Mock APIs When the Backend Is Not Ready Yet

#webdev #api #testing #javascript

The frontend is ready. The mobile app is waiting. The contract is agreed. And the real API is still "next sprint."

You have seen this movie. You either hard-code fixtures, spin up a local JSON server, or wait. None of those options is great when you just need a URL that returns the right status code, the right body, and CORS headers that do not fight you.

That is why I built MockMe.

What is MockMe?

MockMe is a hosted mock API service. You describe an HTTP method, a path, a status code, and a JSON body. Seconds later you have a live URL you can call from the browser, Postman, curl, or your test suite.

  • Playground first. No account required. Create a temporary endpoint and start calling it immediately.
  • Persistent when you need it. Sign up and keep endpoints that do not expire after a coffee break.
  • Readable URLs. https://mockme.fyi/m/your-team/users instead of a UUID soup.
  • Conditional responses. Return 400 when a field is missing, 403 for a bad header, or a different payload for ?role=admin.
  • OpenAPI import. Drop a spec and generate a pile of endpoints instead of clicking through them one by one.
  • A real management API. Create, update, and inspect mocks from a script or CI pipeline.

CORS is on by default. GET, POST, PUT, PATCH, and DELETE all work. Custom headers and response delays are first-class.

Try it in sixty seconds

Open the playground. No registration.

  1. Pick a method, for example GET.
  2. Set a path, for example /users.
  3. Paste a response body: 
[
  { "id": 1, "name": "Ada", "role": "admin" },
  { "id": 2, "name": "Grace", "role": "engineer" }
]
Enter fullscreen mode Exit fullscreen mode
  1. Create the endpoint and copy the URL.

Then call it:

curl https://mockme.fyi/api/mock/temp/{session-id}/users
Enter fullscreen mode Exit fullscreen mode

Playground endpoints last 30 minutes of inactivity. That is enough to unblock a UI spike, a demo, or a failing integration test. When you need the URL to survive the weekend, create a free account and promote the mock to a persistent endpoint.

Persistent mocks with readable URLs

Registered endpoints live under your account slug:

https://mockme.fyi/m/{account-slug}/users
https://mockme.fyi/api/mock/user/{user-id}/users
Enter fullscreen mode Exit fullscreen mode

Both forms serve the same mock. The slug form is the one you want in a README or a frontend .env.

A free account includes:

  • 3 persistent endpoints
  • All HTTP methods
  • CORS
  • Custom response headers and delays
  • Request history

Pro adds 50 endpoints, OpenAPI import, higher limits, and longer history. Enterprise is there when a team needs unlimited endpoints, collaboration, and an SLA.

Conditional rules: one path, many realities

A static 200 with a happy-path JSON is useful. Real clients also need the unhappy path.

MockMe lets you attach dynamic rules to an endpoint. Each rule looks at the query string, the body, or a header, extracts a value with XPath, and decides whether to fire. The first matching rule (by priority) wins.

Examples that show up in every frontend I have shipped:

  • Missing email in the body → 400 with a validation error
  • X-Role: guest → 403
  • ?status=archived → an empty list
  • amount greater than 100 → a slower response, so you can test loading states

You can change the status code, body, headers, and delay per rule. The default response is the fallback when nothing matches.

That means one mock URL can drive success, validation, auth, and empty-state screens without a forest of /users-ok and /users-error paths.

Import an OpenAPI spec, skip the busywork

If you already have an OpenAPI document, do not retype every path.

On Pro and Enterprise you can upload JSON or YAML. MockMe parses the operations, suggests response bodies, and can create the endpoints in bulk — including a first pass at dynamic rules from the spec. You pick what to keep, then hit create.

This is the fastest path from "here is the contract" to "the app can call something that looks like production."

Drive it from CI

The dashboard is convenient. The management API is what you want in a pipeline.

Mint an API key in the dashboard, then:

curl -X POST https://mockme.fyi/api/v1/endpoints \
  -H "Authorization: Bearer mk_live_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "List users",
    "method": "GET",
    "path": "/users",
    "status_code": 200,
    "response_body": [{ "id": 1, "name": "Ada" }]
  }'

curl https://mockme.fyi/m/your-account/users
Enter fullscreen mode Exit fullscreen mode

The same API lists endpoints, attaches rules, reads request logs, and reports plan usage. Errors return a stable code you can branch on, plus a docs_url:

{
  "error": {
    "code": "endpoint_limit_reached",
    "message": "The free plan allows 3 persistent endpoints. Upgrade to create more.",
    "docs_url": "https://mockme.fyi/docs#endpoint_limit_reached",
    "details": { "plan": "free", "current": 3, "max": 3 }
  }
}
Enter fullscreen mode Exit fullscreen mode

The machine-readable spec lives at /api/v1/openapi.json.

Who is this for?

  • Frontend and mobile developers waiting on a backend that is not deployed yet
  • QA folks who need predictable 404s, 500s, and slow responses
  • Anyone writing contract tests who does not want to stand up a whole stack
  • Teams that already have an OpenAPI file and want a mock in minutes, not a sprint

If you have ever pasted a fake fetch wrapper "just for now" and shipped it by accident, this is for you.

Try it

  1. Playground — no account, 30-second setup
  2. Create a free account — 3 persistent endpoints
  3. Docs — management API and error codes
  4. Pricing — Free, Pro, and Enterprise

I would love to hear what you mock first, and what is still missing. Drop a comment, or reach out from the contact page.

Happy mocking.

Top comments (1)

Collapse
 
doushabao profile image
Doushabao •

Nice work! Mock APIs are a lifesaver when you're waiting for the backend team. I've been in that exact situation — frontend ready, contract signed, backend still "next sprint" 😅

A few things I'd love to see in tools like this:

  1. Schema validation — auto-generate mock data from an OpenAPI spec instead of manually defining each response
  2. Response delay simulation — crucial for testing loading states and timeout handling
  3. Stateful mocks — like a mock checkout flow where step 1 returns a cart ID that step 2 needs

For quick local mocking, I also use JSON Server + json-server-zero when I just need a REST API that reads/writes to a JSON file. It's great for prototyping without any external dependencies.

The OpenAPI import feature you mentioned is a big win — that's the hardest part of setting up mocks from scratch. Do you plan to support async API specs too?