Three ways to stream

Where each one sits

Read each stack from the bottom up. SSE is one long HTTP response. A WebSocket starts as HTTP and then switches to its own frames. Lightstreamer adds sessions and subscriptions on top of a WebSocket.

Server-Sent Events SSE

TCP + TLS

HTTP GET, kept openContent-Type: text/event-stream

Named text eventsevent: quotes
data: {…}
(optional id: and retry:)

Server → client only. The client sends anything else as ordinary HTTP requests.

WebSocket WS

TCP + TLS

HTTP GET with Upgrade: websocketserver answers 101 Switching Protocols

Frames in both directionstext or binary, plus ping/pong

Your own message formatsubscriptions, ids and replay are yours to design

Full duplex. One connection carries messages both ways (RFC 6455).

Lightstreamer LS

TCP + TLS

WebSocket, by defaultfalls back to HTTP streaming, then polling

TLCP sessioncreate, subscribe, update, control, recover

Items × fieldsmodes MERGE, DISTINCT, COMMAND, RAW

Server pushes updates; the client sends control requests (subscribe, unsubscribe) on the same session.

Where each runs in Nexus

Three separate paths. Colour marks the transport on each hop; unmarked arrows are ordinary in-process or database writes.

IG prices to the trader console

IG streaming serverLightstreamer

LS over WSMERGE subscriptions, ≤ 20 items each

Capture daemonnexus-trader capture

1 s and 1 min bars · latest quote

Postgres + Redisbars in TimescaleDB · quote cache, 180 s TTL

each push reads Redis, then SQL 1 min bars

Trader APIGET /trader/quotes/stream

SSEevent: quotes, every 1 s

Trader pageEventSource in the browser

The two ends use different transports. The market-facing feed needs subscriptions and throttling; the browser only needs a one-way snapshot. Orders already go through authenticated REST calls, and EventSource reconnects on its own.

Exchange books to the arbitrage engine

Six crypto exchangeseach with its own WS API

WSccxt.pro watch_order_book

Connectorsone asyncio task per symbol

XADD, approximate MAXLEN

Redis Streamsread by the signal engine

ccxt.pro hides each exchange's WebSocket dialect behind one method. Nexus adds backoff with jitter and a separate delay for rate limits.

RFQ simulator to its dashboard

RFQ engineFastAPI app state

WS/v1/ws/prices · /v1/ws/book
JSON snapshot every 1 s

Dashboardlive quotes with TTL countdown

REST: POST /rfq, then /execute

RFQ enginequote check, credit, limits

The WebSocket only pushes. Trades go over REST so each one is a normal request with a status code.

Side by side

	Lightstreamer LS	WebSocket WS	Server-Sent Events SSE
What it is	A streaming server and client libraries with their own protocol (TLCP)	A browser and network standard for a two-way channel	A browser standard for a one-way event stream over HTTP
Direction	Updates from server; control requests from client	Both ways on one connection	Server to client only
Runs over	WebSocket, or HTTP streaming or polling when blocked	Its own frames after an HTTP Upgrade	A plain HTTP response that stays open
Message model	Subscribe to items and fields; the mode decides delivery	Whatever you define	Named text events with optional ids
Reconnect	Built in, with session recovery	You write it	Built into EventSource; resumes with Last-Event-ID
Slow clients	Server throttles per client; MERGE sends only the latest value	You handle backpressure	You handle it; sending full snapshots makes it simple
Binary data	No, text protocol	Yes	No, UTF-8 text
Proxies	Falls back automatically when WebSockets are blocked	Some proxies and firewalls block the Upgrade	Passes through, but proxy buffering must be turned off
Browser	Vendor JavaScript client	Native WebSocket API	Native EventSource; it can't set custom headers
Cost to run	A dedicated, licensed server	A stateful connection per client	An open HTTP response per client
Suits	Fanning market data out to many clients with entitlements and throttling	Interactive two-way apps: order entry, chat, collaboration	Dashboards, notifications, job progress
In Nexus	Consumed: IG's price feed into the capture daemon	Consumed from six exchanges; served by the RFQ simulator	Served: the trader's live quotes panel

In the code

Lightstreamer client

nexus-trader/src/nexus_trader/capture/stream.py::MarketStreamer

lightstreamer-client-lib 2.2.2. No transport is forced, so the client negotiates and lands on WS-STREAMING.
MERGE subscriptions in chunks of at most 20 items. IG once refused a 35-item subscription while the connection still reported healthy.
Error 21 triggers a one-time switch between the PRICE and MARKET subscription schemes.
Ticks are stamped with our own UTC receipt time; IG's update time has no date.
A second watchdog checks bars are being written, after the stream showed CONNECTED for about 11 hours while writing nothing.

nexus-trader/requirements-lock.txt

The client runs on aiohttp. A parser CVE there mattered because the feed parses IG traffic all day, so the patched version is pinned ahead of the default.

WebSocket client and server

nexus-arb/connectors/base_connector.py::BaseConnector._watch_symbol

await exchange.watch_order_book(symbol) in a loop, one task per symbol, ccxt 4.5.
Exponential backoff with jitter on errors, and a separate base delay for HTTP 429 rate limits.
Latency is receipt time minus exchange time, recorded per connector.

nexus-rfq-sim/app/routers/stream.py::ws_prices, ws_book

FastAPI @router.websocket: accept, then send_json a snapshot every second.
Exits cleanly on WebSocketDisconnect and closes on cancellation.
Push only; execution stays on the REST path.

SSE server and browser

nexus-trader/src/nexus_trader/app/routers/trader.py::quotes_stream

StreamingResponse with text/event-stream. Sends event: quotes, or event: error while keeping the stream open.
Interval is a query parameter, 250 ms to 10 s, default 1 s.
X-Accel-Buffering: no and Cache-Control: no-cache, no-transform, so nginx passes events through as they are written.

nexus-data-web/src/pages/Trader.tsx::LiveQuotesPanel

First paint from a snapshot GET, then new EventSource(url).
Flashes rows whose mid changed; closes the stream on unmount.
Every event is a full snapshot, so a reconnect needs no replay.

What I would change

The SSE generator is synchronous and sleeps between pushes, so Starlette runs it in its worker thread pool and each open stream holds a thread. That is fine for a few operator tabs. An async generator with asyncio.sleep would scale further.

The RFQ WebSockets send a snapshot every second whether or not anything changed. Skipping identical snapshots would cut traffic with no change for the client.

EventSource can't send headers, so an authenticated stream needs a cookie or a short-lived token in the URL. Worth designing before the console leaves the private network.