How to Stream Crypto Market Data in Node.js: A Resilient Engineering Guide

A raw WebSocket client will sit there looking connected while the exchange has already dropped you. Firewalls and load balancers do this all the time: the TCP session dies, no close frame shows up, and your process keeps waiting. If you have watched that happen on Binance, Bybit, or OKX, you already know a thin wrapper around ws is not enough.

Each venue also wants a different heartbeat, a different topic shape, and a different way to keep a local order book honest. This guide uses the Siebly.io SDKs for that work: binance, bybit-api, okx-api, @siebly/kraken-api, and coinbase-api. They open the socket, send the heartbeat that venue actually expects, and subscribe again after a drop. They do not pace your traffic. Quotas, queues, and backpressure stay in your process.

Use a current Node.js LTS (22 or 24). The samples below are shortened from the example folders in those packages. Official exchange docs stay the source of truth for limits and payload fields.

• Heartbeats and reconnects are already inside the WebSocket clients. You listen for events. You do not call socket.terminate() yourself.
• Topic names are not shared. publicTrade.BTCUSDT is Bybit. btcusdt@trade is Binance. { channel: 'trades', instId: 'BTC-USDT' } is OKX.
• A local order book is not one algorithm. Binance diff depth needs a REST snapshot. Bybit and OKX push a snapshot on the socket first.
• WebsocketAPIClient methods return a Promise on Binance, Bybit, OKX, and Kraken. Coinbase orders stay on the REST client. sendWSAPIRequest() on coinbase-api is a stub and should not be used.
• None of these SDKs throttle you. Bybit can surface rate-limit headers on REST responses. That is information, not a limiter.

Market data is a long-lived WebSocket, not a poll loop. Node.js still has one event loop. JSON.parse() runs on that thread inside the client before your handler sees the message. A slow handler, or a giant book snapshot, will delay timers. If heartbeats slip, the exchange closes you.

The clients emit events so your code can stay small. They do not move parsing onto a worker thread. If a callback sorts a full book or writes to disk, that cost is still yours. Keep the listener thin and hand the payload off.

You can build this on the ws package and the RFC 6455 framing rules. You will then own subscription memory, sequence checks, backoff, and a different signature scheme per venue. Binance signs with HMAC, RSA, or Ed25519 (the WebSocket API is happiest with Ed25519). OKX needs a passphrase as well as key and secret. Bybit authenticates the private socket on connect.

The clients cover that plumbing:

• TypeScript types for requests and responses. That catches mistakes in your code at compile time. It does not inspect live payloads, and it will not notice a field rename on the exchange until the package types are updated.
• They remember topics and subscribe again after a reconnect.
• They emit lifecycle events. The event name is not the same on every package. Binance and Kraken emit reconnecting. Bybit, OKX, and Coinbase emit reconnect. All of them emit reconnected when the new socket is up.

They do not enforce exchange rate limits. Bybit spot does batch subscribe calls (at most 10 topics per message, 500 on the other v5 public sockets). That is packet shape, not a quota.

The package index is at siebly.io/sdk.

Install the package for the venue you are calling:

npm install binance
npm install bybit-api
npm install okx-api
npm install @siebly/kraken-api
npm install coinbase-api

The npm name for Kraken is @siebly/kraken-api. The others match the folder names.

Public market data should stay on the public socket. Authenticated order entry is a different URL. You usually do not pass the URL yourself. The client picks it from the product you subscribe to.

import { isWsFormattedTrade, WebsocketClient } from "binance";

const wsClient = new WebsocketClient({ beautify: true });

wsClient.on("formattedMessage", (data) => {
  if (isWsFormattedTrade(data)) {
console.log("trade", data);
return;
  }
  console.log("other", data);
});

wsClient.on("reconnecting", ({ wsKey }) => {
  console.log("reconnecting", wsKey);
});
wsClient.on("reconnected", (data) => {
  console.log("reconnected", data?.wsKey);
});

wsClient.subscribeSpotTrades("BTCUSDT");
wsClient.subscribeSpotPartialBookDepth("BTCUSDT", 20, 1000);

import { WebsocketClient } from "bybit-api";

const wsClient = new WebsocketClient();

wsClient.on("update", (data) => {
  console.log(data);
});

wsClient.on("reconnect", ({ wsKey }) => {
  console.log("reconnecting", wsKey);
});
wsClient.on("reconnected", (data) => {
  console.log("reconnected", data?.wsKey);
});
wsClient.on("exception", (data) => {
  console.error("ws exception", data);
});

wsClient.subscribeV5("publicTrade.BTCUSDT", "spot");
wsClient.subscribeV5("orderbook.50.BTCUSDT", "spot");

import { WebsocketClient } from "okx-api";

const wsClient = new WebsocketClient();

wsClient.on("update", (data) => {
  console.log(data);
});

wsClient.on("reconnect", ({ wsKey }) => {
  console.log("reconnecting", wsKey);
});
wsClient.on("reconnected", (data) => {
  console.log("reconnected", data?.wsKey);
});

wsClient.subscribe([
  { channel: "trades", instId: "BTC-USDT" },
  { channel: "books", instId: "BTC-USDT" },
]);

import { WebsocketClient, WS_KEY_MAP } from "@siebly/kraken-api";

const wsClient = new WebsocketClient();

wsClient.on("message", (data) => {
  console.log(data);
});

wsClient.on("reconnecting", (data) => {
  console.log("reconnecting", data);
});
wsClient.on("reconnected", (data) => {
  console.log("reconnected", data);
});

wsClient.subscribe(
  {
topic: "trade",
payload: { symbol: ["BTC/USD"] },
  },
  WS_KEY_MAP.spotPublicV2,
);

wsClient.subscribe(
  {
topic: "book",
payload: { symbol: ["BTC/USD"], depth: 10 },
  },
  WS_KEY_MAP.spotPublicV2,
);

import { WebsocketClient } from "coinbase-api";

const wsClient = new WebsocketClient();

wsClient.on("update", (data) => {
  console.log(data);
});

wsClient.on("reconnect", (data) => {
  console.log("reconnecting", data);
});
wsClient.on("reconnected", (data) => {
  console.log("reconnected", data);
});

wsClient.subscribe(
  {
topic: "ticker",
payload: { product_ids: ["BTC-USD"] },
  },
  "advTradeMarketData",
);

Do not use one sync procedure for every venue. The lastUpdateId flow below is Binance spot diff depth. Bybit and OKX hand you the snapshot on the WebSocket.

import { MainClient, WebsocketClient } from "binance";

const restClient = new MainClient();
const wsClient = new WebsocketClient({ beautify: true });

wsClient.subscribeSpotDiffBookDepth("BTCUSDT", 100);

const snapshot = await restClient.getOrderBook({
  symbol: "BTCUSDT",
  limit: 1000,
});

console.log(snapshot.lastUpdateId);

On a raw ws socket, a dead session is cleared with socket.terminate(), not a graceful close(), so the process does not wait on a handshake that will never finish. These clients already do that internally when the pong timer fires. Calling terminate() on a socket you dug out of the client fights the reconnect logic. Listen for the lifecycle events instead, and keep your own book in a state you can rebuild. A reconnect is a gap. Treat the local book as dirty until you have a fresh snapshot.

Backoff matters when you are opening sockets yourself. A thundering herd during an outage gets you banned. Binance documents a cap of 300 connection attempts per 5 minutes per IP. OKX documents 3 new connection requests per second per IP. The SDKs reconnect with a short delay (reconnectTimeout, 500ms by default on these clients). They do not implement truncated exponential backoff, and they do not know about those IP caps. If you open many clients, or you reconnect in a tight loop of your own, you can still trip the venue.

Same story for subscribe and order quotas:

• OKX allows 480 subscribe, unsubscribe, and login requests per connection per hour. That number is not an order limit. Order placement has its own, much higher, cap. Calling 480 "operations" will make you throttle trades that the venue would have accepted.
• The clients will not slow those calls down for you.

Bybit REST responses can include rateLimitApi, parsed from response headers, per account and per endpoint. Read it if you want. Nothing in the client waits when the remaining budget gets low.

Exchange state goes further on reconnect state. The short version for these packages: topics you passed to subscribe / subscribeV5 are stored, and they are sent again after reconnected. Topics you never registered that way will not come back.

Several venues accept orders on a WebSocket, and the matching reply comes back on that same connection. The awkward version is an event handler that hunts through every frame for your id. WebsocketAPIClient hides that. You await a method. The client attaches an id, and resolves the Promise when the reply with that id arrives.

The method names are not the exchange opcodes.

• binance: submitNewSpotOrder and cancelSpotOrder send order.place and order.cancel on wss://ws-api.binance.com:443.
• bybit-api: submitNewOrder, amendOrder, and cancelOrder send order.create, order.amend, and order.cancel on wss://stream.bybit.com/v5/trade.
• okx-api: submitNewOrder and cancelOrder send order and cancel-order.
• @siebly/kraken-api: submitSpotOrder and cancelSpotOrder send spot v2 add_order and cancel_order.
• coinbase-api has no WebSocket order client. Orders go through REST, for example CBAdvancedTradeClient.submitOrder.

Bybit's trade API calls the correlation field reqId, and the venue allows up to 36 characters. The SDK does not generate a 36-character UUID. getNewRequestId() is an incrementing number, sent as a string. That is enough for the Promise map, which keys off op plus reqId.

Binance spot order, from the WebSocket API example. Ed25519 keys avoid signing every command. HMAC and RSA still work, and each command is signed.

import { WebsocketAPIClient } from "binance";

const wsClient = new WebsocketAPIClient({
  api_key: process.env.API_KEY,
  api_secret: process.env.API_SECRET,
});

const response = await wsClient.submitNewSpotOrder({
  symbol: "BTCUSDT",
  side: "SELL",
  type: "LIMIT",
  timeInForce: "GTC",
  price: "50000",
  quantity: "0.001",
});

Bybit linear order. The client connects and authenticates on first use. Demo trading can consume events, but it does not support this trade socket.

import { WebsocketAPIClient } from "bybit-api";

const wsClient = new WebsocketAPIClient({
  key: process.env.API_KEY,
  secret: process.env.API_SECRET,
});

const response = await wsClient.submitNewOrder({
  category: "linear",
  symbol: "BTCUSDT",
  orderType: "Limit",
  qty: "0.001",
  side: "Buy",
  price: "50000",
});

OKX needs the passphrase as well. The type marks instId as deprecated (March 2026) in favor of instIdCode when you have the numeric code. The current examples still pass instId, and that field is still accepted.

import { WebsocketAPIClient } from "okx-api";

const wsClient = new WebsocketAPIClient({
  accounts: [
{
apiKey: process.env.API_KEY || "",
apiSecret: process.env.API_SECRET || "",
apiPass: process.env.API_PASSPHRASE || "",
},
  ],
});

const response = await wsClient.submitNewOrder({
  instId: "BTC-USDT",
  tdMode: "cash",
  side: "buy",
  ordType: "limit",
  px: "50000",
  sz: "0.001",
});

Kraken spot. The client fetches and refreshes the private WebSocket token. You do not call getWebSocketsToken() yourself.

import { WebsocketAPIClient } from "@siebly/kraken-api";

const wsClient = new WebsocketAPIClient({
  apiKey: process.env.API_SPOT_KEY || "",
  apiSecret: process.env.API_SPOT_SECRET || "",
});

const response = await wsClient.submitSpotOrder({
  order_type: "limit",
  side: "buy",
  limit_price: 50000,
  order_qty: 0.001,
  symbol: "BTC/USD",
});

Coinbase is the exception. WebsocketClient.sendWSAPIRequest() is marked "Not supported by this exchange, do not use" and returns undefined. Place, amend, and cancel through the REST clients (CBAdvancedTradeClient, CBExchangeClient, CBInternationalClient, CBPrimeClient). Use the WebSocket client for market data and user streams, not for order entry.

Keep ingestion and order entry apart in your own process. A book handler that also submits orders will stall both when the book gets busy. The SDK will happily let you do that on one connection. The exchange will still count every subscribe and every order against the quota for that connection.

More writeups live on the Siebly.io blog. The SDK index lists every package, including the ones not covered here (Bitget, BitMart, Gate.io, HTX, KuCoin).