Mock any HTTP endpoint online, free — your paths, your responses

Sometimes you don't need a whole fake backend. You need one endpoint: a /health check for a load balancer test, a /config your app fetches at boot, a third-party callback URL, an endpoint that echoes back what you sent it. Tools built for this exist — Beeceptor is the best known — but its free tier stops at 50 requests a day, which one hot-reloading dev session burns through before lunch, and its rules engine (custom paths, templated responses) is largely a paid feature (full breakdown: Beeceptor alternative guide).

Mockbird does hosted custom endpoints free: define any path, any method, any response, with response templating that can echo query params, path params, headers, and the request body — 10,000 requests per project per day, CORS on, no signup to try it. And because every project is also a full seeded CRUD mock API, you're not stuck when "just one endpoint" grows into "actually, I need fake products too."

Try it in 10 seconds (no signup)

The shared demo playground has three custom routes pre-defined. These work right now, from your terminal:

# a plain fixed-ish response with a live timestamp
curl https://HOST/m/demo/health
# → {"status":"ok","service":"mockbird-demo","time":"2026-07-25T22:47:43.054Z"}

# path params: /config/:key
curl https://HOST/m/demo/config/theme
# → {"key":"theme","value":"40037","fetchedAt":"2026-07-25T22:47:43.090Z"}

# echo endpoint: reflects method, query, and body — any HTTP method
curl -X POST https://HOST/m/demo/echo \
  -H 'content-type: application/json' -d '{"hello":"world"}'
# → {"method":"POST","path":"/m/demo/echo","query":{},"body":{"hello":"world"},
#    "requestId":"a18f9518-..."}

1. Create a project

One request, no account (claim it later if you want to keep it):

curl -X POST https://HOST/api/projects \
  -H 'content-type: application/json' -d '{"name": "my endpoints"}'
# → {"project":{"id":"abc123",...,"adminKey":"KEY",...}}

2. Define an endpoint

curl -X POST https://HOST/api/projects/abc123/routes \
  -H 'content-type: application/json' -H 'x-admin-key: KEY' \
  -d '{
    "method": "GET",
    "path": "/v1/feature-flags/:flag",
    "body": "{\"flag\":\"{{params.flag}}\",\"enabled\":true,\"checkedAt\":\"{{now}}\"}"
  }'

It's live immediately at https://HOST/m/abc123/v1/feature-flags/dark-mode. Paths can be up to 8 segments deep, :name segments are parameters, method can be GET/POST/PUT/PATCH/DELETE or ANY, and you can set the status code, content type, extra response headers (also templated), and a per-route delay. Up to 20 routes per project. The dashboard has a UI for all of this if curl isn't your thing.

Response templating

Placeholder	Becomes
`{{query.x}}`	query-string param `?x=…`
`{{params.x}}`	path param from a `:x` segment
`{{body.x}}`	field from a JSON request body
`{{headers.x}}`	request header (case-insensitive)
`{{method}}` / `{{path}}`	request method / full path
`{{now}}` / `{{ts}}`	ISO timestamp / epoch millis
`{{uuid}}` / `{{rand}}`	random UUID / random integer

Double braces are JSON-string-escaped, so untrusted input can't break out of your JSON. Triple braces insert raw JSON — {{{body}}} drops in the entire request body as an object, {{{query}}} the whole query map (that's how the demo's /echo works). Dotted paths reach nested fields: {{body.user.email}}.

Overriding generated endpoints

Custom routes take precedence over resource routes. If your project has a seeded products resource but one test needs /products to return a fixed payload — or a 500 — define a custom route at /products and the generated CRUD endpoint steps aside. Delete the route and the resource is back. No re-seeding, no second project.

The opposite also exists: a trailing * segment (/*, /webhooks/*) makes a catch-all that matches any remaining path but acts as a fallback behind your resources and specific routes — the building block for a free request bin.

Simulating failures and latency

Every custom route accepts the same simulation params as the rest of Mockbird: ?mock_status=503 forces an error response, ?mock_delay=2000 adds latency on top of any per-route delayMs. Requests show up in the request inspector with method, path, and body snippet — handy when you're pointing a webhook or an app you don't control at the URL.

Honest comparison

Tool	Free requests	Custom paths + templated responses	Also a full CRUD mock API
Beeceptor	50/day	paid rules engine (free tier is limited)	no — proxy/intercept model
webhook.site	100 total, then URL stops; free URLs expire in 7 days	one static default response; scripted actions paid	no — inspection-first
json-server	n/a (self-hosted)	needs middleware code	yes, but you host it
Mockbird	10,000/day per project	free — 20 routes/project, templating included	yes — seeded resources, GraphQL, auth, snapshots

Where those tools still win: Beeceptor and webhook.site can proxy/forward to a real upstream and are great for one-off webhook inspection with zero project setup; json-server gives you unlimited everything if you're happy running it yourself. Mockbird's angle is hosted + free + generous, with the rest of a mock backend attached. Written by the Mockbird maker — bias disclosed, numbers checked July 2026. Migrating from the discontinued mocky.io? See the mocky alternative guide.

Full parameter reference in the docs. Custom routes also cover the httpbin jobs — echo, UUIDs, forced status codes. When your one endpoint grows up, the same project does seeded CRUD, GraphQL, mock auth, and snapshot fixtures. Create a project →