📡 Is httpbin.org down right now? We check it (and 14 other classic public mock/placeholder APIs) with a plain GET every 30 minutes — see the live status page.

httpbin.org is 503ing again — here's a free alternative for the same jobs

httpbin is the tool everyone reaches for to test an HTTP client: echo my request back, give me a 500, make the response slow. But httpbin.org is a free community-run instance, and it's chronically overloaded — as of this writing (July 2026) it's returning:

curl https://httpbin.org/get
# → 503 Service Temporarily Unavailable

If your test suite or tutorial depends on it, that's your build failing for someone else's capacity problem. Here's how to do the common httpbin jobs on Mockbird — no signup, CORS on, free — starting with a drop-in you can point existing scripts at right now.

Option 0: swap the host — a drop-in httpbin-compatible surface

Mockbird serves an httpbin-compatible surface at /m/httpbin/*: same paths, same response shapes as httpbin.org's greatest hits. If your script or test suite hardcodes httpbin.org, change the host and most of it keeps working:

# before (503 right now)
curl "https://httpbin.org/get?x=1"

# after — same response shape back
curl "https://HOST/m/httpbin/get?x=1"

curl -X POST "https://HOST/m/httpbin/post" -d 'name=bob'      # form echo, httpbin-style
curl "https://HOST/m/httpbin/status/418"                      # any status (comma list randomizes)
curl "https://HOST/m/httpbin/delay/3"                         # seconds, max 10 — like httpbin
curl "https://HOST/m/httpbin/uuid"                            # {"uuid": "..."}
curl "https://HOST/m/httpbin/headers"                         # your request headers
curl -u user:pass "https://HOST/m/httpbin/basic-auth/user/pass"
curl -X PUT "https://HOST/m/httpbin/anything/whatever?x=1" -d '{"a":1}' -H 'content-type: application/json'

Covered: /get /post /put /patch /delete /anything/* /headers /ip /user-agent /uuid /status/:codes /delay/:n /base64/:val /json /xml /html /robots.txt /basic-auth/:u/:p /bearer /redirect/:n /response-headers /cookies /stream/:n /gzip /deflate /brotli. GET /m/httpbin returns the full self-describing list.

Deliberately not covered: /redirect-to (open redirect), /cookies/set (we never set cookies), /image* + /bytes + /drip (binary/stream noise), /digest-auth. The /gzip-family endpoints return the same JSON shape, but actual content-encoding is negotiated by the CDN. One more honesty note: /ip returns your IP to you — nothing on this surface is logged with IPs.

The rest of this guide covers the same jobs done Mockbird-natively — useful when you want realistic JSON payloads, your own resources, or endpoints httpbin never had.

Try it in 10 seconds (no setup)

# echo — like httpbin /get, /post, /anything
curl "https://HOST/m/demo/echo?foo=bar"
# → {"method":"GET","path":"/m/demo/echo","query":{"foo":"bar"},"body":null, ...}

curl -X POST "https://HOST/m/demo/echo" \
  -H 'content-type: application/json' -d '{"hello":"world"}'
# → {"method":"POST", ..., "body":{"hello":"world"}}

# force any status code — like httpbin /status/503
curl -i "https://HOST/m/demo/products?mock_status=503"

# slow response — like httpbin /delay/3 (milliseconds here)
curl "https://HOST/m/demo/products?mock_delay=3000"

?mock_status= and ?mock_delay= work on every endpoint (and combine), so you can test timeouts and error handling against realistic JSON payloads, not just empty bodies.

The httpbin greatest hits, translated

httpbin	Mockbird
`GET /get`, `POST /post`, `/anything`	`ANY /m/demo/echo` — echoes method, path, query, body
`/status/500`	`?mock_status=500` on any endpoint (100–599)
`/delay/3`	`?mock_delay=3000` (up to 10s, milliseconds)
`/headers`	request inspector — headers of your last 50 requests, see below
`/uuid`	a one-line template route with `{{uuid}}`, see below
`/post` as a dumping ground	catch-all `/*` request bin that logs everything — request-bin guide
`/ip`	no equivalent — we deliberately don't capture client IPs

See your request's headers (the /headers job)

Every request to a Mockbird project is logged in its request inspector — method, path, query, body snippet, and headers (content-type, user-agent, accept, referer, and all x-* headers; auth headers are redacted to their scheme). The demo project's inspector is public, so this works with zero setup:

curl "https://HOST/m/demo/echo" -H 'x-test-header: hello'

curl "https://HOST/api/projects/demo/requests"
# → last 50 requests, yours on top, headers included

On your own project the inspector is private (admin key or dashboard), with a live auto-refresh view — handy for checking exactly what your HTTP client, webhook sender, or SDK is actually putting on the wire, including signature headers.

Build your own /uuid and /anything

Custom routes give you httpbin-style utility endpoints under your own URL. Create a project and add templated routes:

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

# GET /uuid — a fresh UUID per request
curl -X POST https://HOST/api/projects/abc123/routes \
  -H 'X-Admin-Key: KEY' -H 'content-type: application/json' \
  -d '{"method":"GET","path":"/uuid","body":"{\"uuid\":\"{{uuid}}\"}"}'

# ANY /anything/* — echo on any method, any depth
curl -X POST https://HOST/api/projects/abc123/routes \
  -H 'X-Admin-Key: KEY' -H 'content-type: application/json' \
  -d '{"method":"ANY","path":"/anything/*","body":"{\"method\":\"{{method}}\",\"path\":\"{{path}}\",\"query\":{{{query}}},\"body\":{{{body}}}}"}'

curl "https://HOST/m/abc123/uuid"
# → {"uuid":"550270df-3fca-4f54-b9bd-5ff151c38558"}

curl -X PUT "https://HOST/m/abc123/anything/deep/path?x=1" \
  -H 'content-type: application/json' -d '{"k":"v"}'
# → {"method":"PUT","path":"/m/abc123/anything/deep/path","query":{"x":"1"},"body":{"k":"v"}}

Templates can use {{uuid}}, {{now}}, {{ts}}, {{rand}}, {{query.x}}, {{params.x}}, {{headers.x}}, {{body.x}} and more; you control status, content-type, response headers, and per-route delay. Full reference in the custom endpoints guide and docs.

And because this is a mock-API service, the same project can also host seeded CRUD resources, GraphQL, and mock JWT auth — so your "httpbin" and your fake backend live at one base URL.

Honest comparison

	httpbin.org	Mockbird
Echo / anything endpoint	yes (when up)	yes — demo `/echo` or your own routes
Any status code	`/status/:code`	`?mock_status=` on any endpoint
Delays	`/delay/:s` (≤10s)	`?mock_delay=` ms (≤10s)
Header inspection	echoed in response	echoed via templates + logged in inspector (last 50)
Redirects, gzip, images, cookies, digest auth	yes — huge catalogue	no
Client IP echo	`/ip`	no — IPs deliberately not captured
Reliability	community instance, frequently 503	runs on Cloudflare's edge; per-project 10k req/day cap keeps it that way
Self-hostable	yes (docker)	no

Where httpbin still wins: its endpoint catalogue is far bigger (redirect chains, gzip/deflate/brotli bodies, images, cookies, cache headers, basic/digest auth challenges), the response shapes are a de-facto standard, and you can docker run kennethreitz/httpbin to self-host it — if you need those, do that. postman-echo.com is another hosted echo option. This page is written by the Mockbird maker — bias disclosed. httpbin.org's 503 verified live in July 2026; it may well be back up when you read this — the point is a dependency you don't have to check first. Anonymous Mockbird projects have a per-IP daily creation cap; sign up (free) to keep projects permanently.

Full API reference in the docs. More guides: mock any endpoint · webhook.site alternative · testing loading & error states. Create your API →