Socket.IO test server

Connect

How it answers

Every request is answered with one object: { ok: true, data }, or { ok: false, error: { code, message } } — echo alone answers exactly what it was sent. Emit with an acknowledgement and the answer comes to it, so emitWithAck resolves with the object; emit without one and it comes back as an event of the same name. Error codes: invalid_params (with details, one per refused field), not_found, conflict, precondition, rate_limited, session_full, unknown_event, server.

JavaScript (socket.io-client 4)

import { io } from 'socket.io-client'

let session = null   // the token of your writes, kept from the "session" event
const store = io('https://api.sondahub.com/store', { transports: ['websocket'] })

store.on('connect', () => console.log('connected as', store.id))
store.on('orders', (order) => console.log(order.number, order.previous, '→', order.status))
store.on('session', ({ token }) => { session = token })

const product = await store.emitWithAck('getProduct', { id: 1 })
console.log(product.data.name)

const made = await store.emitWithAck('createCategory', { name: 'Garden', slug: 'garden' })
console.log(made.ok ? made.data.id : made.error.message)

// a later connection picks the writes up
const again = io('https://api.sondahub.com/store', { transports: ['websocket'], auth: { session } })

From any browser console, with nothing installed:

const { io } = await import('https://cdn.jsdelivr.net/npm/[email protected]/+esm')
const s = io('https://api.sondahub.com', { transports: ['websocket'] })
s.on('tick', (t) => console.log('tick', t.n))
console.log(await s.emitWithAck('echo', 'hello'))
s.emit('clock', { count: 5, interval: 500 })

Python (python-socketio)

import socketio   # pip install "python-socketio[client]"

sio = socketio.Client()

@sio.on('telemetry', namespace='/fleet')
def telemetry(reading):
    print(reading['serial'], reading['metrics'])

sio.connect('https://api.sondahub.com', namespaces=['/store', '/fleet'], transports=['websocket'])
product = sio.call('getProduct', {'id': 1}, namespace='/store')
print(product['data']['name'])
sio.wait()

The test events

Every namespace answers these — on / and /admin they are all there is.

/admin adds whoami: how you got in, and the token's claims.

The API namespaces

Each of the seven APIs is a namespace with five calls per collection — the same calls, data and rules as the REST API, so a transfer checks the funds and an order refuses an impossible status. /store has listCategories, getCategory, createCategory, updateCategory, deleteCategory and so on for every collection; emit help for the whole list.

What the server pushes

On joining, a welcome event: the namespace's events and topics. Then the API's own activity, about once a second, as events named for the topic. Narrow them as you join with auth: { topics: ['orders'] } (an empty list for none), or later with subscribe and unsubscribe.

connect_error, on purpose

const admin = io('https://api.sondahub.com/admin', { transports: ['websocket'], auth: { token: 'wrong' } })
admin.on('connect_error', (err) => console.log(err.message, err.data))
// → not authorized { reason: 'the token is neither the API key nor a JWT', hint: '…' }

const ok = io('https://api.sondahub.com/admin', { transports: ['websocket'], auth: { token: 'sonda-probe-key' } })
console.log(await ok.emitWithAck('whoami'))   // { ok: true, data: { via: 'api key', … } }

An unknown namespace is refused as a real server refuses it, Invalid namespace — with the namespaces that exist in err.data. Unknown topics in auth are refused the same way.

Socket.IO as it is written

• The handshake and heartbeat. The Engine.IO open packet with its own sid, a ping every 25 seconds and 20 for the pong, after which the connection is closed; 1,000,000 bytes per message at most. A connection that joins no namespace within 45 seconds is closed, as a real server closes it.
• Acknowledgements both ways. Yours are answered; ask makes the server send you an event with an acknowledgement of its own, and it reports what you sent back.
• Binary. Buffers anywhere in the arguments travel as attachments, up to 10 a packet, and come back as binary — echo one, or ask binary for some.
• Errors close the connection, as on a real server: a packet that cannot be read, an event for a namespace you have not joined, a reserved event name (connect, disconnect…), a ping from the client (in Engine.IO 4 the server pings). So does JSON nested more than 32 levels deep.
• Limits. 20 events a second per connection, in bursts of 100: past that, an event with an acknowledgement is answered rate_limited and one without is dropped. sleep waits 10 seconds at most. A connection's writes stop at what a session token can carry (session_full; deletes still work).

Also on sondahub

Fake REST API · Public GraphQL API · gRPC-Web & Connect · SOAP test server · JSON-RPC & XML-RPC · WebSocket test server · SSE test server · Public MQTT broker · MCP test server · MCP OAuth test server · Writes that persist · OpenAPI mock server · Webhook tester · Chaos and rate limits · SAML test IdP and SP · SCIM 2.0 test server · OAuth 2.0 test server · Auth test endpoints · HTTP test endpoints · Fake JSON data · JSONPlaceholder alternative · Stripe sandbox · Twilio sandbox · SendGrid sandbox · Authorize.net sandbox · OpenAI sandbox · Anthropic sandbox

The mock APIs themselves: fake e-commerce API, fake IoT API, fake banking API, fake social media API, fake helpdesk API, fake flight booking API, fake user directory API. Built as the playground for LockFlare Sonda, the API client that lives on your computer.