/ SONDA · PROTOCOLS

Connections that stay open, read as they happen.

A WebSocket, a Socket.IO namespace, an event stream or a gRPC stream is an item in the project like a request is. Each one has a live log you can pause, filter and copy from, saved messages to send again, and a plain-words line saying why a connection dropped.

WEBSOCKET SOCKET.IO V4 / V5 SSE GRPC · GRPC-WEB · CONNECT STOMP 1.2

Shared by every live pane

Log1,000 events kept per connection. "Following paused — click to jump to the latest." Filter to one topic, subject or event name.
SendA text or JSON composer with saved presets: send this again, load that one.
WhyA status line that says why the connection ended, in words, not in a code.
Secretssecret:// references resolved at connect time, never stored in the item.
TLSThe Network page's CAs and client certificates apply to WebSocket, Socket.IO, SSE, gRPC-Web and Connect.
/ THE LIVE PANE

One pane for every connection that stays open.

Whatever the protocol, the item opens the same way: a log that follows the connection as it happens — 1,000 events kept, paused when you scroll back, filtered to one topic, subject or event name — a composer with the messages you saved to send again, and a status line that says why the connection ended in words, not in a code.

A secret:// reference is resolved when the connection is made and never stored in the item. The Network page's CAs and client certificates apply to the handshake.

Every line in the list
/ GRPC

gRPC without a code generator.

Messages are built from descriptors at run time — from the server's reflection, or from your .proto files with their import folders and the well-known types. A skeleton of the request message is written for you; you fill it in and call. Unary, server streaming, client streaming and bidirectional, invoked as a batch or kept open as a live stream: one message at a time, half-close when you are done sending, cancel when you are not.

What comes back is all of it: response headers and trailers, the status code with its name and message, the time, every message sent and received, with a live sent / received counter.

# api.example.com:443 · TLS · reflection v1 service orders.Orders method Watch bidirectional stream # the skeleton, written for you { "watch": "" } # sent · received → {"watch":"7f2a"} ← {"id":"7f2a","status":"held"} 27 ms ← {"id":"7f2a","status":"settled"} 2.8 s → half-close # trailers grpc-status 0 OK server envoy 3 sent · 7 received · 2.9 s
Three transportsNative gRPC over HTTP/2, plain or TLS. gRPC-Web, reading grpc-web-text and gzip bodies too. Connect. The web transports need .proto files and do unary and server-streaming calls.
All four shapesUnary, server streaming, client streaming, bidirectional. Invoke as a batch — a client stream is a JSON array — or keep a live stream open: send one message at a time, half-close, cancel.
What comes backResponse headers and trailers, the status code with its name and message, the time, every message sent and received, with a live sent / received counter. A skeleton of the request message written for you.
Forgiving targetshttps:// or grpcs:// means TLS, a path is dropped, a missing port is 443 under TLS. dns:///, unix:, passthrough: and xds: resolver forms are passed through.
Metadata and authMetadata rows; bearer, basic and API key become metadata; -bin keys are base64-decoded for you.
LimitsReflection v1 with a fall-back to v1alpha, 20 s. A call waits up to 120 s. Native gRPC trusts the Network page's CAs; client certificates apply to gRPC-Web and Connect.
/ SOCKETS AND STREAMS

WebSocket, Socket.IO, SSE, STOMP.

Four kinds of long-lived connection, each a first-class item with its own composer, log and settings.

WebSocket: the handshake, the frames, the close in words.

ws and wss, headers and auth on the handshake, subprotocols. Send text or binary, ping by hand, answer the server's pings. Binary frames shown as hex. The close code and its reason, and the messages you saved to send again.

Socket.IO: every event logged, every ack timed.

Socket.IO v4 and v5 over Engine.IO v4. Namespace, the auth payload, a custom path. Every server event logged without subscribing by name. Emit with arguments and ask for an acknowledgement — the round trip is timed. Answer the server's own ack requests. Binary attachments shown.

Server-sent events: parsed, reconnected the browser's way.

GET or POST with a body. Events, data, ids, retry and comment lines parsed. Browser-style reconnect with Last-Event-ID for GET only — a POST is never repeated. The server's retry honoured, 204 ends the stream, a non-2xx refusal is final. Filter by event name or data.

STOMP over WebSocket: frames named, receipts kept.

STOMP 1.2 on a WebSocket item: CONNECT with host, login and heart-beats; SUBSCRIBE with auto, client or client-individual acknowledgement; ACK and NACK; SEND with headers and a receipt; RECEIPT and ERROR frames named. For a STOMP broker over TCP, see Messaging.

/ LOCKFLARE SONDA

Every protocol, in the free edition.

All 74 protocols, listed →