How can I get historical futures data from Binance?

Binance provides free historical futures data via API with OHLC, volume, and more for backtesting and analysis.

Aug 12, 2025 at 04:49 am

Understanding Binance Futures Historical Data

Historical futures data from Binance is essential for traders and analysts who engage in technical analysis, backtesting trading strategies, or building algorithmic trading systems. This data typically includes information such as open, high, low, close (OHLC) prices, volume, number of trades, and timestamps at various intervals (e.g., 1-minute, 1-hour, 1-day). Binance offers this data through its public API, which allows programmatic access to a vast array of market information.

The futures market on Binance includes both USDT-margined and COIN-margined contracts. Each contract type has its own endpoint in the API. The historical data is available for all actively traded and delisted futures pairs, though data retention policies may limit access to very old records. To retrieve this data, you must use the correct API endpoint and format your requests properly.

Accessing the Binance API Endpoints

To retrieve historical futures data, you need to interact with Binance’s REST API. The primary endpoints for futures data are:

• USDT-Margined Futures: https://fapi.binance.com/fapi/v1/klines
• COIN-Margined Futures: https://dapi.binance.com/dapi/v1/klines

Each endpoint returns kline/candlestick data in JSON format. The required parameters include:

• symbol: The trading pair (e.g., BTCUSDT for USDT futures).
• interval: The candlestick interval (e.g., 1m, 5m, 1h, 1d).
• startTime and endTime: Optional Unix timestamps to specify a time range.
• limit: Maximum number of data points (default is 500, maximum is 1500 per request).

For example, to get 1-hour BTCUSDT futures data from January 1, 2023, to January 2, 2023:

GET https://fapi.binance.com/fapi/v1/klines?symbol=BTCUSDT&interval=1h&startTime=1672531200000&endTime=1672617600000&limit=1000

Ensure timestamps are in milliseconds. You can convert human-readable dates to Unix timestamps using online tools or programming functions.

Using Python to Fetch Historical Futures Data

A common method to automate data retrieval is using Python with the requests library. Below is a step-by-step guide:

• Install the required library:

  pip install requests

• Import necessary modules:

  import requests
  import pandas as pd
  from datetime import datetime

• Define the API endpoint and parameters:

  url = "https://fapi.binance.com/fapi/v1/klines"
  params = {
  'symbol': 'BTCUSDT',
  'interval': '1h',
  'limit': 1000
  }

• Send the GET request:

  response = requests.get(url, params=params)
  data = response.json()

• Convert to a DataFrame:

  df = pd.DataFrame(data, columns=[
  'Open time', 'Open', 'High', 'Low', 'Close', 'Volume',
  'Close time', 'Quote asset volume', 'Number of trades',
  'Taker buy base volume', 'Taker buy quote volume', 'Ignore'
  ])

• Convert timestamps to readable dates:

  df['Open time'] = pd.to_datetime(df['Open time'], unit='ms')
  df['Close time'] = pd.to_datetime(df['Close time'], unit='ms')

• Save to CSV (optional):

  df.to_csv('btcusdt_1h_futures_data.csv', index=False)

This script retrieves the most recent 1,000 one-hour candles. To fetch data over a broader range, implement pagination by adjusting startTime and endTime in a loop.

Handling Rate Limits and Pagination

Binance imposes rate limits on API usage. For the futures API, the limit is typically 2400 requests per minute per IP. Exceeding this limit results in HTTP 429 errors. To avoid this:

• Add delays between requests using time.sleep(0.25) for frequent calls.
• Use larger limits (up to 1500) to minimize the number of requests.
• Implement error handling to retry failed requests.

When retrieving long time series, split the timeframe into chunks. For example, to get daily data for a year:

• Calculate the total time range in milliseconds.
• Divide it into segments that yield ≤1500 data points each.
• Loop through each segment, updating startTime and endTime accordingly.

Example logic:

• Start timestamp: January 1, 2023 (in ms)
• End timestamp: Start + (interval in ms × 1500)
• After each request, set new start time to the last received Close time + 1

This ensures no gaps or duplicates in the dataset.

Alternative Tools and Libraries

Besides raw API calls, several tools simplify data retrieval:

• CCXT: A cryptocurrency trading library supporting Binance and many other exchanges.
  
  Install: pip install ccxt
  
  Usage:

  import ccxt
  exchange = ccxt.binance({
  'options': {'defaultType': 'future'}
  })
  ohlcv = exchange.fetch_ohlcv('BTC/USDT', '1h', limit=1000)

• Binance.py: A Python wrapper specifically for Binance APIs. Offers higher-level functions for futures data.

• Pandas-TA or Backtrader: These can integrate with data fetchers for direct strategy testing.

Using these libraries reduces boilerplate code and handles common issues like timestamp conversion and pagination.

Frequently Asked Questions

How far back does Binance provide futures data?

Binance typically retains up to 1.5 years of historical kline data for most futures pairs. The exact depth depends on the symbol and interval. Very old or delisted contracts may have limited availability.

Can I get historical mark price or funding rate data?

Yes. Use the endpoint https://fapi.binance.com/fapi/v1/fundingRate with symbol and startTime parameters to retrieve funding rates. For mark price klines, use https://fapi.binance.com/fapi/v1/markPriceKlines.

Is API access free?

Yes, accessing public data via Binance API is free and does not require an API key. However, authenticated endpoints (e.g., account data) need key-based authentication.

What should I do if I receive an empty response?

Verify the symbol name is correct (e.g., BTCUSDT, not BTC-USDT). Check that the interval is supported. Confirm timestamps are in milliseconds. Test the URL directly in a browser to isolate issues.