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

gmazzeigraf — Sat, 05 Sep 2026 02:09:23 +0000

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.

Pick a method, for example GET.
Set a path, for example /users.
Paste a response body:

[
  { "id": 1, "name": "Ada", "role": "admin" },
  { "id": 2, "name": "Grace", "role": "engineer" }
]

Create the endpoint and copy the URL.

Then call it:

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

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

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

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 }
  }
}

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

Playground — no account, 30-second setup
Create a free account — 3 persistent endpoints
Docs — management API and error codes
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.

MockMe vs Beeceptor: which mock API should you use?

gmazzeigraf — Fri, 04 Sep 2026 02:23:44 +0000

If you need a quick HTTP mock to unblock a frontend, webhook, or API client, Beeceptor and MockMe are two common options. Here's a straight comparison.

Price

Beeceptor's paid plans are often in the $10 / $25 / $99 per endpoint / month range, depending on the tier. MockMe is aimed at indie and small-team use: free with 3 persistent endpoints, Pro $5/month, Enterprise $20/month (subscribe on the site).

If you only need a few stable endpoints, MockMe is usually cheaper. If your team already lives in Beeceptor and needs their higher per-endpoint tiers, stick with what you know.

Signup friction and expiry

MockMe's playground needs no account. Temporary mocks expire after 30 minutes. After you sign up, you can keep a playground mock as a persistent endpoint (up to 3 on Free). Shareable URLs use /m/{slug}. The UI is available in English and Portuguese.

One-click starters: GET /users, /posts, /orders.

Beeceptor is mature and widely known. The tradeoff is usually pricing model and how much ceremony you want before the first request. MockMe optimizes for "open and try."

When to pick which

MockMe — prototype now, low friction, 3 free persistent endpoints, low price, EN/PT UI
Beeceptor — already standard on your team, or you need their specific plan/features

Built for people shipping integrations — not interview prep.

Try it without signing up

Open the playground, pick a template, copy the URL:

https://mockme.fyi

If your team already uses Beeceptor, what's the one thing that would make you switch (or stay)? Drop it in the comments.

DEV Community: gmazzeigraf