Binance Mini Ticker in JavaScript: Build a Reliable Market-Data Consumer

@ticker is the wider 24 hour ticker. It adds price change, weighted average, best bid and ask, trade ids, and trade counts. Use miniTicker when close, open, high, low, and the two volumes are enough. If you need the rest, subscribe to @ticker.

The all-market full ticker stream !ticker@arr is deprecated in this SDK. The client comments mark it deprecated as of 2025-11-14, with a retirement date of 2026-03-26, and point you at @ticker or !miniTicker@arr.

The WebSocket protocol is only the transport. Keep the topic list, the parser, and your symbol map in separate places so you can change one without rewriting the others.

You can show the close, open, high, low, or volume you just received. You can store the event with its symbol and E. You can compute your own metrics if you document the formula and the window.

One event is not history. A symbol missing from !miniTicker@arr still has its last stored values. Check the shape before you write state. If a message is malformed, log it and skip it. Treat the stream as market data for your software, not as a forecast. The SDK will not slow you down to stay inside Binance's connection or message limits. That policy belongs in your process.

Check Binance's current page for the stream name, the lowercase symbol, the payload, and the update speed before you lock those into code. The Binance JavaScript tutorial shows how this package is set up.

For one symbol, expect an object with e === '24hrMiniTicker'. For all symbols, expect an array of those objects. The package exports is24hrMiniTickerRaw and isAll24hrMiniTickerRaw for the raw message event. There is no formatted type guard for this stream. isAll24hrMiniTickerRaw reads data[0] with no length check, so an empty array throws. Test Array.isArray(data) && data.length > 0 first.

subscribe(), subscribeSymbolMini24hrTicker(), and subscribeAllMini24hrTickers() return a promise. await means the client connected and requested the topics. It does not mean a ticker arrived. Tickers show up on the event emitter.

sendWSAPIRequest() and WebsocketAPIClient are the other path. You await one command and get one response. getSpot24hrTicker({ symbol, type: 'MINI' }) is that kind of call. The body uses names like symbol, lastPrice, openPrice, volume, and quoteVolume, plus open time, close time, and trade ids. That is a snapshot from the WebSocket API, not a 24hrMiniTicker stream event. Do not parse one with the other's field list.

Public miniTicker needs no keys. WebSocket API trading calls do. On Binance, Ed25519 keys can log in once. HMAC and RSA sign each command.

Use it for a small, named set. One topic per symbol makes the scope obvious. When the set changes, subscribe or unsubscribe as part of that change. unsubscribe() removes the topic from the cache so a later reconnect will not put it back.

Use it when you want broad coverage and you are ready to filter. Keep the latest object per symbol if you need a snapshot, because unchanged names are left out. Confirm coverage against the current Binance docs before you promise a symbol will appear.

REST polling asks for a snapshot on your schedule. The WebSocket pushes events. Neither one gives you history by itself. If you need both, store the REST snapshot, then apply stream events on top, and decide which timestamp wins.

With beautify: false (the default), message gives you the short keys and string numbers. With beautify: true, formattedMessage renames them and parses the known numeric strings:

{
  eventType: '24hrMiniTicker',
  eventTime: 1672515782136,
  symbol: 'BNBBTC',
  close: 0.0025,
  open: 0.001,
  high: 0.0025,
  low: 0.001,
  baseAssetVolume: 10000,
  quoteAssetVolume: 18
}

parseFloat runs on close, open, high, low, baseAssetVolume, and quoteAssetVolume. eventType stays the string 24hrMiniTicker. Use E or eventTime to spot an older event. Equal timestamps are not a reason to drop the event. Define that rule yourself.

Binance keeps a market-data WebSocket for 24 hours, sends ping frames, and disconnects if it does not get a pong. This client answers those pings and reconnects when the socket dies, including that 24 hour drop. Cached topics are subscribed again. You get reconnecting and then reconnected. Set disableHeartbeat: true only if you intend to handle this yourself. The client still cannot promise the stream never gaps. After reconnected, decide whether you need a REST snapshot to fill the hole.

Connection and stream limits stay your problem. The Siebly.io SDK page lists the packages. For this article, the package name on npm is binance.

Use the client to connect, subscribe, heartbeat, and reconnect. Keep validation, your symbol map, and any throttling in your code. Private REST and WebSocket API calls are where the package signs requests, sets timestamps, and types the bodies. A public miniTicker consumer does not need that.

If you do want a one-shot ticker over the WebSocket API, that is a different method and a different payload. From examples/WebSockets/WS-API/ws-api-client.ts:

import { WebsocketAPIClient } from "binance";

const wsClient = new WebsocketAPIClient({
  api_key: process.env.API_KEY_COM,
  api_secret: process.env.API_SECRET_COM,
  beautify: true,
});

const response = await wsClient.getSpot24hrTicker({
  symbol: "BTCUSDT",
  type: "MINI",
});

console.log(response);

type: 'MINI' here is the WebSocket API mini ticker (symbol, lastPrice, openPrice, volume, and so on). It is not the 24hrMiniTicker stream. Public market calls on that API can run without a key, but trading calls need one, and you should keep keys server-side with withdrawal permission off.

The same await pattern exists as a raw command:

import { WebsocketClient, WS_KEY_MAP } from "binance";

const wsClient = new WebsocketClient();

const response = await wsClient.sendWSAPIRequest(WS_KEY_MAP.mainWSAPI, "ticker.24hr", {
  symbol: "BTCUSDT",
  type: "MINI",
});

That promise resolves with the response, or rejects. Stream subscriptions never work this way.

Start with one symbol and the message handler. Add the all-symbol array once the single-object path is boring. Then add beautify if you want the long names. Test a bad payload and a reconnect before you write anything to a database.

Package setup is on the Binance JavaScript SDK page and the tutorial. Stream names and limits stay on Binance's docs.

It is a 24 hour rolling mini ticker on Binance market streams. The event type is 24hrMiniTicker. One symbol uses @miniTicker. All changed symbols use !miniTicker@arr. Fields, in the raw payload, are e, E, s, c, o, h, l, v, and q. Price and volume are strings. Check the current Binance stream page before you depend on that list.

Install binance, create a WebsocketClient, and subscribe with the topic and the wsKey 'main'. Handle message for the raw object. Turn on beautify: true if you also want formattedMessage. is24hrMiniTickerRaw and isAll24hrMiniTickerRaw cover the raw shapes. Guard the array guard with a length check. The tutorial walks through package setup.

@ticker includes price change, bid and ask, and trade counts on top of the open, high, low, close, and volume fields. miniTicker stops at those compact fields. The SDK marks !ticker@arr as deprecated and points at @ticker or !miniTicker@arr. The WebSocket API method getSpot24hrTicker({ type: 'MINI' }) is a third shape again. Read the payload you actually subscribed to.

@miniTicker is one symbol. !miniTicker@arr is every symbol that changed in that 1000ms window, not every listed symbol on every message. Store the last event per symbol if you need a full board.

No. The binance client does not throttle subscriptions or REST calls. It will warn when one connection has a large topic list. Binance's limits still apply, and your process has to respect them. WebSocket API replies can include a rateLimits array. The client does not slow down because of it.

No. Public market streams subscribe without a key. Add credentials only when you call a private REST route or an authenticated WebSocket API command. Keep those secrets on the server, use a key that cannot withdraw, and do not paste them into examples or logs.

Use the stream when you want Binance to push the 24 hour mini ticker as symbols move. Use REST when you want a snapshot on a timer you control, or a backfill after reconnected. The SDK exposes both. The stream path is WebsocketClient. The REST path is MainClient for Spot.