Learn how WebSocket cryptocurrency APIs work, how to connect to Binance and Bybit streams, and stream live Bitcoin and Ethereum price data with Python and JavaScript code examples.
If you've ever watched a crypto chart and noticed the price ticking live without refreshing the page — that's WebSocket at work. For traders running bots, monitoring order books, or building algo strategies, understanding WebSocket APIs isn't optional. It's the difference between reacting to prices from two seconds ago and acting on what's happening right now.
A WebSocket API creates a persistent, two-way connection between your client and a server. Unlike a traditional REST API where you send a request and wait for a response, WebSocket keeps the channel open — the server pushes data to you the moment it's available. For crypto trading, this means you receive every trade tick, every order book update, and every price change as it happens, without constantly hammering the server with requests.
The difference between WebSocket and API (REST) comes down to connection model. REST is like sending a letter — you write, you wait, you get a response. WebSocket is like a phone call — the line stays open and both sides can talk at any time. In trading, that distinction can be worth real money. A 200ms polling delay versus a 1ms push is not a small difference when you're trading volatility.
| Feature | WebSocket | REST API |
|---|---|---|
| Connection | Persistent (stays open) | New request each time |
| Data delivery | Server pushes updates | Client polls for data |
| Latency | 1–5 ms typical | 50–300 ms typical |
| Bandwidth | Low (streaming diffs) | High (full payload per poll) |
| Best for | Live prices, order book, trades | Historical data, account info |
| Complexity | Moderate | Simple |
Most exchanges offer both. Binance provides a full REST API for placing orders and pulling account history, while their WebSocket API delivers real-time market data streams. Bybit and OKX follow the same model. For algo bots, the typical pattern is REST for order execution and WebSocket for market data ingestion. Trying to run a high-frequency strategy on REST polling is a losing game — you'll be trading stale data.
Binance offers one of the most developer-friendly crypto websocket apis available. No authentication is required for public market data streams — you just connect and subscribe. Here's a minimal Python example using the websockets library to stream live Bitcoin trades from the bitcoin websocket api:
import asyncio
import websockets
import json
async def stream_btc_price():
# Binance Bitcoin WebSocket API - no auth needed for public market data
url = "wss://stream.binance.com:9443/ws/btcusdt@trade"
async with websockets.connect(url) as ws:
print("Connected to Binance BTC/USDT trade stream")
while True:
msg = await ws.recv()
data = json.loads(msg)
price = float(data['p']) # trade price
qty = float(data['q']) # trade quantity
side = "BUY" if not data['m'] else "SELL" # m=True means seller is market maker
print(f"BTC: ${price:,.2f} | {qty:.5f} BTC | {side}")
asyncio.run(stream_btc_price())Install the dependency first with pip install websockets. Each message from the bitcoin websocket api contains the trade price (p), quantity (q), and a market maker flag (m) that indicates buy or sell side. The data arrives in milliseconds — no polling, no lag. For testing, you can also paste the WebSocket URL directly into browser developer tools using the WebSocket frame inspector.
A production-grade WebSocket connection needs to handle disconnects gracefully. Networks drop, servers restart, and your bot should recover automatically without manual intervention. Here's how to stream both BTC and ETH tickers simultaneously from Binance with exponential backoff reconnection logic:
import asyncio
import websockets
import json
async def stream_multiple_pairs():
# Combine BTC and ETH ticker streams via Binance combined stream endpoint
streams = "btcusdt@ticker/ethusdt@ticker"
url = f"wss://stream.binance.com:9443/stream?streams={streams}"
reconnect_delay = 1
while True:
try:
async with websockets.connect(url) as ws:
print("Connected to Binance multi-stream")
reconnect_delay = 1 # reset delay on successful connection
while True:
msg = await ws.recv()
data = json.loads(msg)
ticker = data['data']
symbol = ticker['s'] # e.g. BTCUSDT
price = float(ticker['c']) # last price
change_pct = float(ticker['P']) # 24h change %
volume = float(ticker['v']) # 24h base asset volume
print(f"{symbol}: ${price:,.2f} | {change_pct:+.2f}% | Vol: {volume:,.0f}")
except websockets.exceptions.ConnectionClosed as e:
print(f"Connection closed ({e.code}). Reconnecting in {reconnect_delay}s...")
await asyncio.sleep(reconnect_delay)
reconnect_delay = min(reconnect_delay * 2, 60) # exponential backoff, cap at 60s
except Exception as e:
print(f"Unexpected error: {e}")
await asyncio.sleep(reconnect_delay)
asyncio.run(stream_multiple_pairs())Binance allows up to 1024 streams per WebSocket connection and 300 connections per IP. For serious bots, batch your symbol subscriptions to stay within limits. OKX and Bybit have similar constraints — always check the exchange's WebSocket API documentation before scaling to avoid IP bans.
If you're building a frontend dashboard or a Node.js trading bot, JavaScript is a natural fit. This websocket real time example connects to the ethereum websocket api via Binance's aggregate trade stream — which collapses consecutive trades from the same taker into a single message, reducing noise while keeping latency low:
const WebSocket = require('ws');
// Ethereum WebSocket API via Binance aggTrade stream
const WS_URL = 'wss://stream.binance.com:9443/ws/ethusdt@aggTrade';
function connectToStream() {
const ws = new WebSocket(WS_URL);
ws.on('open', () => {
console.log('Connected to Ethereum WebSocket stream');
});
ws.on('message', (rawData) => {
const trade = JSON.parse(rawData);
const price = parseFloat(trade.p);
const quantity = parseFloat(trade.q);
const isBuy = !trade.m; // m=true: seller is market maker (sell side)
const timestamp = new Date(trade.T).toISOString();
const side = isBuy ? 'BUY' : 'SELL';
console.log(`[${timestamp}] ETH: $${price.toFixed(2)} | ${quantity.toFixed(4)} ETH | ${side}`);
});
ws.on('error', (err) => {
console.error('WebSocket error:', err.message);
});
ws.on('close', (code) => {
console.log(`Disconnected (${code}). Reconnecting in 5s...`);
setTimeout(connectToStream, 5000);
});
}
connectToStream();Install with npm install ws. For browser-based apps, WebSocket is natively built into all modern browsers — no library needed, just use new WebSocket(url) and attach your event handlers. Platforms like Bybit and OKX support this same connection pattern with their own stream URLs, so switching exchanges is mostly a matter of swapping the endpoint and adjusting the message schema.
The most common question new traders ask is whether a crypto websocket api free option exists for serious production use. The answer is yes — every major exchange offers free public WebSocket feeds for market data, no API key required:
For authenticated streams — your own order updates, account balance changes, or private trade history — you'll need API keys regardless of exchange. But for price feeds, order books, and trade data, all of the above are genuinely free with generous rate limits. If you'd rather not maintain WebSocket infrastructure yourself, platforms like VoiceOfChain already process these streams in real time and surface actionable trading signals without you writing a single line of connection code.
VoiceOfChain connects to multiple exchange WebSocket streams simultaneously and delivers pre-processed signals — price alerts, volume spikes, trend reversals — directly to traders in real time. If building and maintaining WebSocket infrastructure isn't your priority, using a dedicated signal platform is a legitimate and practical alternative.
WebSocket APIs are the backbone of real-time crypto trading infrastructure. Whether you're building a price alert bot, an order book visualizer, or a full algorithmic trading system, knowing how to connect, handle reconnections, and parse incoming streams is a foundational skill every serious trader should have. The barrier to entry is low — Binance, Bybit, OKX, Coinbase, and KuCoin all provide these streams for free. Start with a simple BTC or ETH trade stream, get comfortable with the message format, then layer in error handling and multi-symbol subscriptions as your needs grow. If you'd rather skip the infrastructure work entirely and focus on making trading decisions, platforms like VoiceOfChain handle the WebSocket layer and deliver ready-to-act signals directly.