A WebSocket echo server that's actually up — plus something echo servers can't do

If you've ever followed a WebSocket tutorial, you've met echo.websocket.org. Kaazing shut it down in 2021. Lob stood up the community replacement everyone then pasted into GitHub threads — echo.websocket.events — and that one is now dead too (checked July 2026: the handshake fails). The original address was later revived by Ably, and it's a fine pure echo server — but an echo server only tests that your socket opens. Your actual app code handles structured events: tickers, notifications, order updates, chat messages.

Every Mockbird project ships a wss:// endpoint that does both jobs — echo for the plumbing, and a mock realtime feed of your own records for the real thing. No signup, no backend.

The 10-second echo test

npx wscat -c "wss://HOST/m/demo/ws"
> hello
< hello

Text and binary frames both come straight back. The connection greets you with one {"type":"welcome"} frame listing what it can do — add ?quiet=1 if your test asserts byte-exact echo from the first frame.

The part echo servers can't do: stream your data

The demo project has 30 seeded products. Ask for them as a live feed:

npx wscat -c "wss://HOST/m/demo/ws?subscribe=products&interval=500&limit=5"
< {"type":"subscribed","resource":"products","count":5,"interval":500,"repeat":false}
< {"type":"record","resource":"products","seq":1,"of":5,"data":{"id":1,"name":"…","price":…}}
< …
< {"type":"complete","resource":"products","count":5,"repeat":false}

Or drive it with commands on an open connection — subscribe, switch resources, stop, all without reconnecting:

> {"subscribe":"orders","interval":800,"repeat":true,"jitter":400}
> {"unsubscribe":true}
> {"ping":1}

Option	What it does
interval	ms between records (100–10000, default 1000)
jitter	adds 0–jitter random ms per record — realistic, irregular pacing
limit	records per cycle (max 100)
repeat	loop forever — a feed that never runs dry while you build the UI

Because the feed is your project's own records, the events match your schema exactly — the same data your REST and GraphQL endpoints serve, imported from your db.json, CSV or OpenAPI spec if that's how you created it.

Wire it into a UI

A notifications badge, a price ticker, an order dashboard — this is all the client code a prototype needs:

const ws = new WebSocket("wss://HOST/m/demo/ws?subscribe=products&interval=1000&repeat=1&quiet=1");
ws.onmessage = (e) => {
  const msg = JSON.parse(e.data);
  if (msg.type === "record") renderRow(msg.data);   // your schema, one record at a time
};
ws.onclose = () => scheduleReconnect();             // sessions close after 5 min — test this path free

That last line is a feature: real connections drop. Mockbird sessions end after 5 minutes with a clean close, so your reconnect logic gets exercised without you pulling a network cable. Use jitter to make sure your UI doesn't assume a metronome.

Prefer EventSource? The same feed speaks SSE

Not every UI needs a socket. If your app uses Server-Sent Events, the same feed is at GET /m/<project>/sse (text/event-stream, CORS on) — same subscribe / interval / limit / repeat / jitter options, plus SSE's own superpower: every event carries an id:, so when EventSource auto-reconnects it sends Last-Event-ID and the stream resumes where it left off — exactly the behavior your reconnect handling needs to be tested against, and something a plain echo server can never exercise:

curl -N "https://HOST/m/demo/sse?subscribe=products&interval=500&limit=3"

const es = new EventSource("https://HOST/m/demo/sse?subscribe=products&interval=500");
es.addEventListener("record", (e) => {
  const { seq, of, data } = JSON.parse(e.data);  // data = the record itself
  render(seq, of, data);
});
es.addEventListener("complete", () => es.close());  // omit with &repeat=1

Bare /sse (no subscribe) emits timed tick events — the "is my EventSource plumbing wired up?" signal every SSE tutorial needs a live URL for. Docs →

Testing a protected socket

If your real WS endpoint requires auth, flip the project to protected mode and the handshake demands a JWT — passed as ?token=, because the browser WebSocket API can't send an Authorization header (a constraint your production code has to deal with anyway — practice against it here):

TOKEN=$(curl -s -X POST https://HOST/m/YOUR_PROJECT/auth/login \
  -H 'content-type: application/json' \
  -d '{"email":"you@example.com","password":"anything"}' | jq -r .token)
npx wscat -c "wss://HOST/m/YOUR_PROJECT/ws?token=$TOKEN"

Honest comparison

	echo.websocket.org (Ably)	postman-echo /raw	Mockbird
Pure echo	✔ (banner frame first)	✔	✔ (?quiet=1 for byte-exact)
Stream your own schema as events	✘	✘	✔ ?subscribe= any resource
Pacing control (interval / jitter / repeat)	✘	✘	✔
Auth testing	✘	✘	✔ JWT protected mode
Same data over REST + GraphQL + SSE too	✘	✘	✔ one project, every protocol
Session limits	none documented	none documented	5 min / 1000 msgs per connection

Where the others win: Ably's revived echo.websocket.org is a purpose-built, no-frills echo tool (and open source if you want to self-host) — if pure echo forever is all you need, it's great. Mockbird's session caps exist because it's a shared free service; reconnect logic makes them invisible.

Create yours

curl -s -X POST https://HOST/api/projects \
  -H 'content-type: application/json' \
  -d '{"name":"my-api","preset":"ecommerce"}'

…or use the one-click dashboard link — no terminal required. The response's baseUrl + /ws is your socket. Full reference in the WebSocket docs; pair it with SSE streaming if your fallback path uses EventSource.