Implementing a Reliable Coinbase WebSocket Feed in Node.js

The right endpoint depends on which Coinbase product you are integrating with. Retail and professional traders use Advanced Trade:

• Public market data: wss://advanced-trade-ws.coinbase.com
• Private user data: wss://advanced-trade-ws-user.coinbase.com

Institutional setups may still use the Exchange API at wss://ws-feed.exchange.coinbase.com, which uses a different subscription format (channels instead of channel). Advanced Trade is the standard for most new Coinbase websocket feed nodejs projects. The coinbase-api SDK maps these endpoints internally via WS_KEY_MAP, so you subscribe by topic and wsKey rather than hardcoding URLs.

Node.js fits high-throughput market data well because of non-blocking I/O and the event loop. When a message arrives, the runtime queues it for processing. Keep CPU-heavy work off the main thread so you do not delay the next ticker update. A modular design where the WebSocket client emits events to dedicated handlers keeps the system responsive during volatile markets. That pattern also lets you scale data processing separately from connection management, which matters in a modern algorithmic trading system architecture nodejs.

A compliant JWT needs a precise header and payload. The header includes alg, typ, and kid. The payload needs sub, iss, nbf, and exp. Clock drift is a common failure mode in Node.js: if your server time is off by a few seconds, nbf or exp claims trigger Unauthorized errors. Fixing that in a custom module often means NTP sync or manual offset logic.

On Advanced Trade, JWT is attached to each private subscribe message, not just a one-time handshake. That means your signing logic runs on every subscription to the user data socket.

The coinbase-api package handles JWT generation internally. Pass credentials via environment variables or client options, and the SDK signs each private subscribe request on advTradeUserData automatically. It supports both ECDSA (PEM format) and Ed25519 (base64) keys.

import { WebsocketClient } from "coinbase-api";

const client = new WebsocketClient({
  apiKey: process.env.API_KEY_NAME,
  apiSecret: process.env.API_PRIVATE_KEY,
});

client.on("update", (data) => {
  console.log("user update:", data);
});

// Subscriptions on advTradeUserData are signed automatically
client.subscribe("user", "advTradeUserData");

For order execution, use the REST client. The SDK's CBAdvancedTradeClient covers that path with full TypeScript types:

import { CBAdvancedTradeClient } from "coinbase-api";

const client = new CBAdvancedTradeClient({
  apiKey: process.env.API_KEY_NAME,
  apiSecret: process.env.API_PRIVATE_KEY,
});

const order = await client.submitOrder({
  product_id: "BTC-USDT",
  order_configuration: {
limit_limit_gtc: {
base_size: "0.001",
limit_price: "50000.00",
},
  },
  side: "BUY",
  client_order_id: client.generateNewOrderId(),
});

See the Coinbase JavaScript SDK guide for key setup and permissions. For teams that want to avoid maintaining crypto code in-house, a maintained SDK like Siebly.io is the practical choice.

Batch multiple pairs in one product_ids array to keep control traffic low. Coinbase confirms active subscriptions with a subscriptions response event. To scale down at runtime, send an unsubscribe for specific products without tearing down the whole connection.

With the SDK, pass topics as strings or structured objects. This matches examples/AdvancedTrade/WebSockets/publicWs.ts in the coinbase-api repo:

import { WebsocketClient } from "coinbase-api";

const client = new WebsocketClient();

client.on("open", (data) => console.log("connected:", data?.wsKey));
client.on("update", (data) => console.log("data:", data));
client.on("response", (data) => console.log("subscription confirmed:", data));
client.on("reconnect", () => console.log("reconnecting..."));
client.on("reconnected", () => console.log("back online"));
client.on("exception", (data) => console.error("error:", data));

// Simple topic
client.subscribe("heartbeats", "advTradeMarketData");

// Topic with parameters
client.subscribe(
  {
topic: "ticker",
payload: { product_ids: ["ETH-USD", "BTC-USD"] },
  },
  "advTradeMarketData",
);

// Multiple topics in one call
client.subscribe(
  [
{ topic: "market_trades", payload: { product_ids: ["ETH-USD"] } },
{ topic: "level2", payload: { product_ids: ["ETH-USD", "BTC-USD"] } },
  ],
  "advTradeMarketData",
);

Messages arrive as JSON. In production, route by channel (Advanced Trade) or type (Exchange API).

For Advanced Trade level2, the feed sends snapshot and update events inside an events array. Track sequence_num on each message. If you detect a gap after a disconnect, discard your local book and wait for a fresh snapshot before applying increments again.

The Exchange API uses snapshot and l2update message types instead. Same idea, different field names.

Monitor the heartbeats channel (or protocol-level ping/pong) so you know the stream is alive even when the market is quiet. The coinbase-api SDK emits typed update, response, and exception events, which keeps handlers predictable.

Implementing JWT for private streams from scratch is complex and error-prone. You handle signing, token lifecycle, and clock drift on every private subscribe.

• ES256 or EdDSA signing required for each private request
• 120 second token lifespan with strict timing
• High risk of Unauthorized from clock drift

The coinbase-api SDK handles signing behind the scenes.

• JWTs are generated and attached to each private subscribe request automatically
• On reconnect, cached subscriptions are re-sent with fresh JWTs
• Supports both ECDSA and Ed25519 key formats
• Connect with API keys and start receiving data in minutes

A raw WebSocket needs boilerplate to survive network jitter, load balancer timeouts, and exchange maintenance.

• Silent disconnections cause data gaps in order books and trades
• You must wire up ping/pong monitoring and reconnection yourself
• Separate endpoints for public vs user data add routing complexity

The SDK ships with connection management built in.

• Automatic reconnection with resubscribe from cached topics
• Configurable ping interval (default 10s) and pong timeout (default 1s)
• One subscribe() API routed to the correct endpoint via WS_KEY_MAP

• Use least-privilege API keys for automated systems
• Never enable withdrawal permissions on keys used for data streaming
• Store credentials in environment variables or a secrets manager, never in source code

Subscribe to heartbeats on the public market data socket for a regular pulse during quiet markets. Reset a "last seen" timestamp on each one.

The SDK also sends protocol-level pings on a pingInterval (10 seconds by default) and closes the socket if no pong arrives within pongTimeout (1 second by default). You can tune both in the client options:

import { WebsocketClient } from "coinbase-api";

const client = new WebsocketClient({
  pingInterval: 10000,
  pongTimeout: 1000,
  reconnectTimeout: 500,
});

Separate fatal errors from recoverable ones. Bad API keys or invalid signatures should stop the retry loop to avoid lockout. Network resets and timeouts are recoverable. Log state transitions (CONNECTING, OPEN, CLOSING, CLOSED) for production debugging.

The SDK emits reconnect and reconnected events so you can hook logging or alerts without building a state machine from scratch. You still own local state reconciliation (order book snapshots, fill tracking, etc.).

A raw Advanced Trade integration easily needs 50+ lines for JWT signing, endpoint selection, and subscribe formatting. The SDK cuts that to a handful of lines. It routes public traffic to advTradeMarketData and private traffic to advTradeUserData, re-subscribes cached topics after reconnect, and types request/response shapes across Coinbase products.

If you are maintaining custom WebSocket code with manual signing, migrating to coinbase-api reduces ongoing maintenance. The TypeScript types catch bad payloads at compile time. Check the Siebly.io releases page for SDK updates, and Siebly AI patterns if you are designing larger data pipelines.

Advanced Trade is the current standard, using wss://advanced-trade-ws.coinbase.com for public data and wss://advanced-trade-ws-user.coinbase.com for private data. Coinbase Pro is legacy with different auth and message shapes. For new Coinbase websocket feed nodejs work, use Advanced Trade. The coinbase-api SDK targets the current endpoints.

Usually clock drift or a bad signature. Coinbase expects a JWT signed with ES256 or EdDSA, expiring within 120 seconds. If server time is off, nbf or exp checks fail. The coinbase-api SDK generates and attaches JWTs to private subscribe requests so you do not have to debug signing by hand.

No. Siebly.io SDKs (coinbase-api, binance, bybit-api, okx-api, kucoin-api, bitget-api, gateio-api, bitmart-api, @siebly/kraken-api, and the rest) do not throttle requests for you. Some clients can parse exchange rate-limit headers on REST responses, but none will slow your calls automatically. Stay within Coinbase's 10 requests per second inbound limit on WebSocket control messages. Exceeding it can trigger temporary bans.

Yes. Node.js event-driven I/O handles low-latency ticker and L2 ingestion well. For execution, use CBAdvancedTradeClient over REST. Coinbase's WebSocket API supports order commands at the protocol level, but coinbase-api does not implement awaitable WebSocket requests for Coinbase yet. SDKs like binance, bybit-api, okx-api, kucoin-api, and @siebly/kraken-api do support sendWSAPIRequest() or a WebsocketAPIClient wrapper.

Standard accounts are limited to 10 subscriptions per product per channel. For more pairs, open additional connections or upgrade your subscription tier. Multiple connections need careful event loop management so high-throughput streams do not block processing.

Coinbase Advanced Trade supports WebSocket order commands in its API, but the coinbase-api SDK handles orders through the REST CBAdvancedTradeClient.submitOrder() method. That is the supported path today. WebSocket order placement via sendWSAPIRequest() is not implemented for Coinbase in this SDK.

Track sequence_num on level2 and watch heartbeats for connection health. After a gap, discard local cache and resubscribe for a fresh snapshot. Use backoff between reconnect attempts to avoid rate limits. The SDK reconnects and resubscribes cached topics automatically, but you still reconcile local state yourself.

On Advanced Trade, anything on the private user data endpoint (advTradeUserData) requires a signed JWT on each subscribe request: user, futures_balance_summary, and similar account channels. Public channels on advTradeMarketData (ticker, level2, market_trades, heartbeats) do not need credentials. Use least-privilege API keys with only the permissions your streams require.