How to Scrape Binance Spot Market Data in 2026

Binance is the largest crypto spot exchange by volume, and its public REST API is genuinely good — no key required for market data, generous rate limits, and clean JSON. So why would anyone “scrape” it? Because turning the raw API into an export-ready, full-universe snapshot takes more glue than it looks: you have to join two endpoints, convert dozens of stringified numbers per pair across 3,500+ symbols, filter and sort, and emit flat rows your warehouse or backtester can actually ingest. This guide covers what the Binance spot feed exposes and how to bulk-export it cleanly in 2026.

What’s worth extracting

For every spot trading pair, Binance exposes a full 24-hour rolling snapshot. The fields that matter per pair:

• Symbol & assets — the pair symbol (BTCUSDT) plus its base and quote asset breakdown (BTC / USDT).
• Trading status — whether the pair is actively TRADING, halted, or delisted.
• Last price — the most recent traded price.
• 24h change — both absolute and percent price change over the rolling window.
• OHLC-ish window values — 24h open, high, low and the weighted-average price (VWAP).
• Volume — base-asset volume and quote-asset volume over 24h.
• Order book top — best bid and best ask.
• Activity — 24h trade count, and the open/close window timestamps.
• Generation timestamp — when the snapshot was taken.

The full-universe coverage is the point. A single run gives you ~3,500+ rows — one consistent snapshot of the entire Binance spot market — rather than the per-symbol cherry-picking most people do by hand.

How the data is exposed

This is a clean public-API story, not a bot-evasion one. The honest picture:

• Two official endpoints, no key. Binance publishes exchangeInfo (the metadata: which symbols exist, their base/quote split, trading status, precision) and the ticker/24hr endpoint (the live rolling stats). Both are public and keyless for market data.
• The work is the join. exchangeInfo tells you the universe and the asset breakdown; ticker/24hr gives you the live numbers. You join them on symbol to get a complete row that knows both the structure and the price.
• Everything is a string. Binance returns prices and volumes as strings ("43210.50000000") to avoid float ambiguity. You must convert them to proper numeric types or your analytics will silently misbehave.
• Two requests per run. Done right, the whole 3,500-pair universe is two API calls — the bulk ticker/24hr and one exchangeInfo — joined locally. No per-symbol fan-out.

The practical realities:

1. Rate limits are weight-based. Binance meters requests by “weight,” and the all-symbols ticker call has a high weight. Calling it once per run is fine; calling it in a tight loop will get you IP-banned.
2. Numeric conversion is non-negotiable. Leave the strings as strings and sorting/filtering breaks subtly.
3. Symbol universe drifts. New listings and delistings happen constantly; exchangeInfo is how you stay current.

Endpoint structure

# The symbol universe + asset breakdown + trading status
https://api.binance.com/api/v3/exchangeInfo

# Live 24h rolling stats for ALL symbols in one call
https://api.binance.com/api/v3/ticker/24hr

# (Optional) single-symbol stats
https://api.binance.com/api/v3/ticker/24hr?symbol=BTCUSDT

Joining exchangeInfo (structure) with the bulk ticker/24hr (live data) on the symbol field is the entire pipeline. The actor wraps that join, the numeric conversion, and adds filtering by quote asset and minimum quote volume, trading-status filtering, multi-metric sorting and a row cap.

▶ Run the Binance Spot Market Scraper — all 3,500+ pairs in one run: price, 24h change, high/low, volume, bid/ask, trade count. Filter by quote asset and volume, schedule for a fresh feed. Pay per result.

Build it yourself vs. use a managed actor

Hitting the API is trivial; productionizing the snapshot is the part with sharp edges:

• Building from scratch — call both endpoints, join on symbol, convert every numeric string, apply quote-asset and volume filters, sort, cap, and emit flat rows. Then schedule it, handle the weight-based rate limits so you don’t get banned, and keep the symbol universe fresh. A day or two, plus the rate-limit discipline.
• Using a managed actor — set your quote-asset filter and minimum volume, schedule it, and get flat export-ready rows. The join, numeric conversion and rate-limit safety are handled.

The deciding factor is usually the scheduling-plus-rate-limit safety. A backtest archive needs regular snapshots without tripping Binance’s weight limits — getting that wrong gets your IP banned mid-collection.

Schema design for downstream use

A flat per-pair row built for CSV/warehouse ingestion:

{
  "symbol": "BTCUSDT",
  "base_asset": "BTC",
  "quote_asset": "USDT",
  "status": "TRADING",
  "last_price": 64210.5,
  "price_change": -812.3,
  "price_change_percent": -1.25,
  "open_price": 65022.8,
  "high_price": 65500.0,
  "low_price": 63800.0,
  "weighted_avg_price": 64480.1,
  "base_volume": 18422.7,
  "quote_volume": 1187904221.5,
  "best_bid": 64209.0,
  "best_ask": 64211.0,
  "trade_count": 1843221,
  "open_time": "2026-05-31T06:00:00Z",
  "close_time": "2026-06-01T06:00:00Z",
  "generated_at": "2026-06-01T06:00:01Z"
}

Schema choices worth making:

• Store both base_volume and quote_volume. Liquidity-first strategies sort on quote volume (USD-ish); inventory analysis wants base volume. You’ll want both.
• Keep numerics as numbers, not strings. This is the whole point of the conversion step — downstream math depends on it.
• Always store generated_at. A 24h ticker snapshot is only meaningful with the timestamp; this is how you build a time series.
• Don’t drop status. Filtering on TRADING avoids polluting analytics with halted or delisted pairs.

Typical use cases

• Algorithmic / quant trading — live signal generation, liquidity-first market lists, mean-reversion, momentum and grid strategies.
• Cross-exchange arbitrage — combine with other exchange scrapers (e.g. Bitget) to build an arbitrage matrix.
• Trading-bot price feeds — scheduled, filtered feeds for execution engines.
• Backtesting archives — regular snapshots accumulated into 24h-resolution historical records.
• Portfolio dashboards — value holdings against live USDT-quote prices.
• Tax / accounting — end-of-day or end-of-month snapshots for cost-basis calculations.
• Market research — volume distribution, listing monitoring, cross-quote price comparison.
• Data resellers — a clean upstream Binance spot feed with a flat, consistent row shape to republish.

Cost math

Pricing is pay-per-event — a tiny per-start fee plus a fraction of a cent per result row. A full-universe run emits ~3,500 rows, so each snapshot costs a few cents. Scheduling hourly snapshots for a backtest archive runs into the low tens of dollars per month for a continuous, full-market time series. Because the whole thing is two API calls plus local processing (no browser, no proxy bandwidth), the compute cost is minimal. Versus building and babysitting your own scheduled collector — and risking a rate-limit ban that gaps your archive — the managed route is cheap insurance.

Common pitfalls

• Weight-based rate-limit bans. The all-symbols ticker is a heavy call. Loop it too tightly and Binance bans your IP. One call per scheduled run is the safe pattern.
• String numerics. Forgetting to convert means sorts and comparisons go lexicographic — "9" > "10" — and your “top volume” list is garbage.
• Stale symbol list. New listings appear constantly. Refresh exchangeInfo each run rather than caching a static universe.
• Quote-asset confusion. BTCUSDT and BTCBUSD and BTCFDUSD are different pairs; filter on quote asset deliberately or you’ll double-count BTC liquidity.
• 24h window is rolling, not calendar. The open/close times are a moving 24h window, not midnight-to-midnight. Use the timestamps, don’t assume.

Wrapping up

Binance’s public API is excellent — the value of a scraper here isn’t beating defenses, it’s the glue: joining exchangeInfo with the bulk ticker, converting every numeric string, filtering and sorting into export-ready rows, and scheduling it without tripping the weight-based rate limits. If you need one symbol’s price once, the raw API in two lines is fine. If you want a scheduled, filtered, full-universe snapshot feeding a bot or a backtest archive, a managed actor hands you clean flat rows and keeps the rate-limit discipline so your time series doesn’t gap.

▶ Open the Binance Spot Market Scraper on Apify — 3,500+ pairs, live, flattened and export-ready. Pay per result, start on Apify’s free monthly credit.