Tools With a Streaming Feed

What the flag claims

interfaces.websocket: true says the product publishes a persistent connection it pushes down. It says nothing about what is on that connection, how often it moves, whether a key is needed to open it, or whether the data behind it is any fresher than a poll would have been. Twenty-two of the sixty cards here carry it, and behind that one boolean sit at least four unrelated products.

Six of the twenty-two are the platforms themselves — Kalshi, Polymarket, Polymarket US, Limitless, Myriad and Manifold — where the flag describes the developer surface the platform publishes rather than anything in the app you sign into. Five of those surfaces have a card of their own: kalshi-api, polymarket-clob-api, polymarket-us-api, limitless-api and manifold-api. Myriad's stream is documented on its own card. The other sixteen split evenly: eight data APIs, and eight clients, SDKs and terminals.

Four things come down these channels

Every change to the book, as a delta. Kalshi's WebSocket carries incremental order-book updates, market tickers, public trades and your own fills; you apply the deltas and hold the book yourself. pykalshi exists largely because of that — its OrderbookManager applies the deltas and hands back the current book, which it describes as the piece every market-making script otherwise writes badly once. Predexon runs an L2 order-book channel among eight Polymarket channels. DepthFeed is the recorded version of the same idea: a book captured at every change rather than sampled on a clock, with the raw tick tape of every book change sold on its top tier.

Snapshots on a cadence. Predictefy's WebSocket sends full book snapshots rather than deltas, which is less code on your side — no sequence numbers, no resync — and also means you cannot reconstruct what happened between two of them. Polyrama is the case to look at hardest: every page that shows market data subscribes to a socket that broadcasts once a second, over quotes that themselves refresh every 30 seconds. The connection is live. The number is up to half a minute old, and no amount of push cadence changes that.

Events rather than prices. Polymarket US runs a private stream for order, position and balance updates beside its markets stream, and its batch routes make that stream load-bearing: a 200 on a batch create is not a result, the per-entry exchange outcome is delivered on the order stream, and canceledOrderIds is an echo of the request rather than a confirmation. If you are not holding the socket, you do not know what happened. limitless-sdk streams position changes, transactions, order events and market lifecycle events alongside book and price updates. manifold-api has a per-market topic for updates to resting limit orders.

Observations from before anything has settled. Predexon's pending-trades channel reports Polymarket fills seen in the Polygon public mempool before they are mined, which the vendor describes as three to five seconds ahead of confirmation — and the documentation is careful that a mempool observation is not a trade, since some never confirm. Its other channels carry UMA oracle proposals and disputes, splits and merges, and collateral movements. None of that is a price, and all of it moves before one does.

Most of these carry two channels rather than one, split by what they authenticate. Polymarket's CLOB API is the clearest example: a public market channel with book snapshots, price changes, last trade prices and tick-size changes, and a separate authenticated user channel carrying only your own orders and fills. Polymarket's Python SDK subscribes across four — the CLOB market and user channels plus the live-data and sports feeds — and handles reconnection and heartbeats for you, which is work you would otherwise do twice. When you are reading the flag on a card, the question worth asking is which of those two halves you actually need, because the public one is often free and the private one is usually what the identity check is protecting.

Whether it opens without a key

There is no rule here, so it has to be read per card.

• Open. Limitless's public channels for prices and market lifecycle answer without authentication, over Socket.IO on a /markets namespace. Manifold's WebSocket takes topic subscriptions with no key at all, and wants a ping every 30 to 60 seconds or it closes the connection. Myriad's read access is open, with a key issued on request only to raise the rate limit.
• Signed, even for public data. Kalshi's REST market data answers unauthenticated GETs, but the WebSocket handshake itself returns 401 without signed headers — including for channels that carry nothing but public data. There is no keyless live stream on that venue.
• Gated behind an identity check. Polymarket US's public gateway needs no key for markets, books and price history, but the developer key that opens either WebSocket requires the iOS app, an account and identity verification. That gate sits on the streams, not only on the writes.
• Not sold at the bottom of the price list. Predexon's free plan has no WebSocket at all; its Dev plan caps you at 10 subscriptions of 10 items across three channels, and Pro at 100 subscriptions of 500 items or two wildcard subscriptions per channel.

A stream is a meter

Two products here charge for the connection in a way that makes the market's own activity your bill. PMXT prices one REST call at one credit and one WebSocket message at 0.1, so a book that ticks ten times a second exhausts the free month's credits in about seven hours of streaming. Predictefy charges 2 credits per connection-minute — except for a Polymarket pending-fills subscription, which is 800, a factor of four hundred, and about half an hour of the free plan's 25,000 monthly credits.

Where the meter is not credits it is connections: PMXT allows 5 streams free, 20 on Starter and 100 on Pro; DepthFeed runs 5 subscriptions on one connection at 29 US dollars a month and 100 with wildcards across five connections at 249. Working out what you can afford to watch is a question about how many markets you need at once, and that number is usually larger than people expect.

One venue lets you find out before it costs anything: Kalshi runs a full demo environment on separate hosts with separate credentials, which makes it the one place in this collection where a streaming integration can be rehearsed without live money. Limitless is explicit about the opposite — no sandbox, no testnet, no mock mode — and suggests rehearsing with minimum-size live orders on a low-volume market instead.

Async only, Node only, and per-venue

The flag is silent on three constraints that decide whether a stream fits your code at all.

Streaming is async in most of these SDKs and only async. polymarket-client implements subscribe() on its async clients and not on the synchronous ones, so a sync script that wants live book updates has to poll or move. polymarket-us-python ships both a sync and an async client and both of its WebSocket connections are async-only regardless. limitless-sdk is async throughout, on python-socketio.

polymarket-us-typescript adds a second constraint: its WebSocket half checks for window.document and throws, because the exchange authenticates streams with headers a browser WebSocket cannot send. Streaming there is Node-only by design, not by omission.

And on a cross-venue client, streaming is per-venue even when the REST is unified. CCXT covers seven event venues in its prediction namespace, and live watch methods exist for Polymarket, Myriad and Opinion only — Kalshi, Limitless, Binance and Hyperliquid have none. One unified interface, four venues you still have to poll.

What it changes, and what it does not

The honest reason most readers end up needing one of these is fan-out rather than speed. Limitless documents it plainly: there is no batched order-book endpoint, one market per request, and following several markets means the WebSocket. Polling thirty markets inside a rate limit is the problem a stream solves.

What it does not solve is depth. A push feed shortens the distance between a change in the book and your code seeing it; it does nothing about how much is resting in that book, and on the short-dated markets most of these feeds specialise in, that is the number that decides your fill. Where the liquidity comes from is the page for that, and what a trade actually costs for the fees and spread a faster quote does not reduce. Predexon's own framing of its mempool channel is the right posture for the whole collection: a leading indicator, not a fill.

Nothing in this collection has been streamed by this site against a funded account. Channel contents, credit weights, connection limits and authentication rules above are read from each vendor's own documentation and dated on the cards.