Downloadable CSV files

If you prefer accessing historical datasets in CSV format, please see downloadable CSV files docs.

Market data replay API

Follow our API getting started guide to learn more how to access historical data via our HTTP API and client libs that offer tick-level market data replay support data both in exchange-native and normalized formats.

Real-time market data streaming

Consolidated real-time market data streaming API is available via our open source libraries that connect directly to exchanges' WebSocket APIs. We do not provide hosted real-time API, see why.

Available historical market data details

See historical data details to learn exactly what, how and since we collect for each supported exchange and what data is available via our market data API and downloadable CSV files.

Questions?

Refer to our FAQ or contact us via email. We're always here to help you with any questions you have.

BitMEX historical data for all it's instruments is available since 2019-03-30.

Downloadable CSV files

Historical CSV datasets for the first day of each month are available to download without API key. See downloadable CSV files documentation.

How to download all Bitmex datasets for all instruments

See full downloadable CSV files documentation with datasets format spec, data samples and more.

# requires Python >=3.6
# pip install tardis-dev

from tardis_dev import datasets, get_exchange_details
import logging

# optionally enable debug logs
# logging.basicConfig(level=logging.DEBUG)

exchange = 'bitmex'
exchange_details = get_exchange_details(exchange)   

# iterate over and download all data for every symbol
for symbol in exchange_details["datasets"]["symbols"]:
    # alternatively specify datatypes explicitly ['trades', 'incremental_book_L2', 'quotes'] etc
    # see available options https://docs.tardis.dev/downloadable-csv-files#data-types
    data_types = symbol["dataTypes"]  
    symbol_id = symbol["id"]
    from_date =  symbol["availableSince"]
    to_date = symbol["availableTo"]

    # skip groupped symbols
    if symbol_id in ['PERPETUALS', 'SPOT', 'FUTURES']:
        continue

    print(f"Downloading {exchange} {data_types} for {symbol_id} from {from_date} to {to_date}")

    # each CSV dataset format is documented at https://docs.tardis.dev/downloadable-csv-files#data-types
    # see https://docs.tardis.dev/downloadable-csv-files#download-via-client-libraries for full options docs
    datasets.download(
        exchange = exchange,
        data_types = data_types,
        from_date =  from_date,
        to_date = to_date,
        symbols = [symbol_id],
        # TODO set your API key here
        api_key = "YOUR_API_KEY",
        # path where CSV data will be downloaded into
        download_dir = "./datasets",
    )

// npm install tardis-dev
// requires node version >=12
const { downloadDatasets, getExchangeDetails } = require('tardis-dev')

;(async () => {
  const exchange = 'bitmex'
  const exchangeDetails = await getExchangeDetails(exchange)

  // iterate over and download all data for every symbol
  for (const symbol of exchangeDetails.datasets.symbols) {
    // alternatively specify dataTypes explicitly ['trades', 'incremental_book_L2', 'quotes'] etc
    // see available options https://docs.tardis.dev/downloadable-csv-files#data-types
    const dataTypes = symbol.dataTypes
    const symbolId = symbol.id

    const from = symbol.availableSince
    const to = symbol.availableTo

    // skip groupped symbols
    if (['PERPETUALS', 'SPOT', 'FUTURES'].includes(symbolId)) {
      continue
    }

    console.log(`Downloading ${exchange} ${dataTypes} for ${symbolId} from ${from} to ${to}`)

    // each CSV dataset format is documented at https://docs.tardis.dev/downloadable-csv-files#data-types
    // see https://docs.tardis.dev/downloadable-csv-files#download-via-client-libraries for full options docs
    await downloadDatasets({
      exchange,
      dataTypes,
      from,
      to,
      symbols: [symbolId],
      // TODO: set your API key here
      apiKey: 'YOUR_API_KEY',
      //  path where CSV data will be downloaded into
      downloadDir: './datasets'
    })
  }
})()

curl -o bitmex_trades_2019-11-01_XBTUSD.csv.gz https://datasets.tardis.dev/v1/bitmex/trades/2019/11/01/XBTUSD.csv.gz

API Access and data format

Historical data format is the same as provided by real-time BitMEX WebSocket API with addition of local timestamps. If you'd like to work with normalized data format instead (same format for each exchange) see downloadable CSV files or official client libs that can perform data normalization client-side.

# pip install tardis-client
import asyncio
from tardis_client import TardisClient, Channel
tardis_client = TardisClient(api_key="YOUR_API_KEY")

async def replay():
  # replay method returns Async Generator
  messages = tardis_client.replay(
    exchange="bitmex",
    from_date="2019-07-01",
    to_date="2019-07-02",
    filters=[Channel(name="orderBookL2", symbols=["XBTUSD"])]
  )

  # messages as provided by BitMEX real-time stream
  async for local_timestamp, message in messages:
    print(message)


asyncio.run(replay())

// npm install tardis-dev
const { replay } = require('tardis-dev');

async function run() {
  try {
    const messages = replay({
      exchange: 'bitmex',
      from: '2019-07-01',
      to: '2019-07-02',
      filters: [{ channel: 'orderBookL2', symbols: ['XBTUSD'] }],
      apiKey: 'YOUR_API_KEY'
    });

    // messages as provided by BitMEX real-time stream
    for await (const { localTimestamp, message } of messages) {
      console.log(localTimestamp, message);
    }
  } catch (e) {
    console.error(e);
  }
}

run();

curl -g 'https://api.tardis.dev/v1/data-feeds/bitmex?from=2019-07-01&filters=[{"channel":"orderBookL2","symbols":["ETHUSD"]}]&offset=2'

curl -g 'localhost:8000/replay?options={"exchange":"bitmex","filters":[{"channel":"orderBookL2","symbols":["XBTUSD"]}],"from":"2019-07-01","to":"2019-07-02"}'

Captured real-time channels

• trade

• orderBookL2

• liquidation

• connected

• announcement

• chat

• publicNotifications

• instrument partial messages returned via HTTP API may contain data for all BitMEX instruments and require filtering client-side if only selected symbols were requested

• settlement

• funding

• insurance

• orderBookL2_25

• quote

• quoteBin1m

• quoteBin5m

• quoteBin1h

• quoteBin1d

• tradeBin1m

• tradeBin5m

• tradeBin1h

• tradeBin1d

• orderBook10 - available since 2021-02-21

Market data collection details

Market data collection infrastructure for BitMEX is located in GCP europe-west2 region (London, UK). Real-time market data is captured via single WebSocket connection.

General

Data

Billing and Subscriptions

Got other Questions? We're happy to help!

You'll find here per-exchange details about:

• historical data availability date ranges — since when the historical data has been collected and is available

• captured real-time market data channels also described as streams, subscription topics, tables etc in exchanges' docs — available historical raw market data is being sourced from WebSocket real-time APIs provided by the exchanges and can be filtered by channels, e.g.: to get historical trades for BitMEX, channel trade needs to be provided alongside requested instruments symbols (via HTTP API or client libs function args).

• symbols of recorded instruments/currency pairs

• incidents - describing periods where due to internal errors data has been missing for given exchange

Some exchanges encode requested symbol in channel name, e.g.: Deribit trades.BTC-PERPETUAL.100ms channel. This is not the case with our API as we always consider channel name and symbol to be separate inputs. In case of Deribit example channel name would be trades and symbol BTC-PERPETUAL. If channel provides option of frequency of updates (e.g.: 100ms vs raw tick by tick) always higher frequency one is being chosen and recorded.

Market data collection overview

• All market data collection is being performed on one of the highly available Google Cloud Platform Kubernetes Clusters - London, UK (europe-west2 region) or Tokyo, Japan (asia-northeast1 region) - information which data center location is used for particular exchange is described on exchange historical data details page.

• When exchange provides choice of real-time data frequency for specific data types (e.g. order book data ) always most granular, non aggregated data feed is being collected.

• Choice if single or multiple WebSocket connections are being used to record full real-time data feed is made on case by case basis - we take into account exchange API limits and latency which may be higher or lower if single connection is being used - detailed information which strategy is used for particular exchange is described on exchange historical data details page.

• WebSocket connection is dynamically re-subscribed (or restarted for some exchanges) at 00:00 UTC every day in order to receive initial order book snapshots.

• Each received message is timestamped with 100ns precision using synchronized clock at arrival time and stored in ISO 8601 format.

• Messages provided by exchanges' WebSocket feeds are being stored without any modifications.

• Checks if there are new instruments available for given exchange are being performed every minute.

• Market data collection services are being constantly monitored both manually and via automated tools (monitoring, alert notifications) and have built-in self-healing capabilities. We also constantly monitor for upcoming exchanges' API changes and adapt to those beforehand.

• There are multiple built-in checks detecting if connection to exchange is healthy during data collection process, such as:

  • validating subscription responses - if exchange does not confirm subscriptions within 20 seconds, connection is being restarted

  • Heartbeat pings

  • order books sequence numbers validation for exchange that provide those

  • validating JSON format as in some unusual circumstances exchanges return data that is invalid JSON

  • stale connection detection - if there are no responses received within certain period (adjusted per exchange) it's most likely stale connection which gets automatically restarted

  • detection of unusually small messages count being received from exchange in given time period which likely means connection is not healthy, e.g.: receiving only 'pings' without data messages

  • and many more

• Any incident that is caused by us (bugs, network errors etc.) is being logged and available via API.

• New market data delay is 6 minutes in relation to real-time (T - 6min).

Collected order book data details

Historical market data available via HTTP API provides order book snapshots at the beginning of each day (00:00 UTC) and every-time WebSocket connection has been closed when recording real-time data feed (connection is restarted and new snapshot provided via fresh connection). It means that in order to be sure to receive initial order book snapshots one must replay historical data from 00:00 UTC time of the day. It also means that there is a tiny gap in historical data (around 300-3000ms range depending on exchange) during re-subscribing to real-time WebSocket feed (every 24 hours) in order to receive order book snapshots.

Some exchanges do not provide initial order book snapshots when subscribing to WebSocket real-time feeds (like Binance, Bitstamp or Coinbase Pro full order book), hence for those there is a 'generated' snapshot available instead (based on REST API call) - details are specific for each exchange and are described in per-exchange historical details pages.

Per-exchange historical data details

• BitMEX

• Deribit

• Binance USDT Futures

• Binance COIN Futures

• Binance

• FTX

• OKX Futures

• OKX Swap

• OKX Options

• OKX Spot

• Huobi Futures

• Huobi COIN Swaps

• Huobi USDT Swaps

• Huobi Global

• Bitfinex Derivatives

• Bitfinex

• Coinbase Pro

• Kraken Futures (Crypto Facilities)

• Kraken

• Bitstamp

• Gemini

• Poloniex

• Bybit

• Bybit Spot

• dYdX

• WOO X

• Kucoin Spot

• Blockchain.com

• Upbit

• Phemex

• Delta

• Ascendex (BitMax)

• FTX US

• Binance US

• Gate.io Futures

• Gate.io

• Bitnomial

• Crypto.com

• OKCoin

• bitFlyer

• HitBTC (high caps)

• CoinFLEX

• Binance Jersey

• Binance DEX

Binance COIN Futures historical data for all it's instruments is available since 2020-06-16.

Downloadable CSV files

Historical CSV datasets for the first day of each month are available to download without API key. See downloadable CSV files documentation.

API Access and data format

Historical data format is the same as provided by real-time Binance COIN Futures WebSocket API with addition of local timestamps. If you'd like to work with normalized data format instead (same format for each exchange) see downloadable CSV files or official client libs that perform data normalization client-side.

# pip install tardis-client
import asyncio
from tardis_client import TardisClient, Channel
tardis_client = TardisClient(api_key="YOUR_API_KEY")

async def replay():
  # replay method returns Async Generator
  messages = tardis_client.replay(
    exchange="binance-delivery",
    from_date="2020-07-01",
    to_date="2020-07-02",
    filters=[Channel(name="depth", symbols=["btcusd_200925"])]
  )

  # messages as provided by Binance COIN Futures real-time stream
  async for local_timestamp, message in messages:
    print(message)


asyncio.run(replay())

// npm install tardis-dev
const { replay } = require('tardis-dev');

async function run() {
  try {
    const messages = replay({
      exchange: 'binance-delivery',
      from: '2020-07-01',
      to: '2020-07-02',
      filters: [{ channel: 'depth', symbols: ['btcusd_200925'] }],
      apiKey: 'YOUR_API_KEY'
    });

    // messages as provided by Binance COIN Futures real-time stream
    for await (const { localTimestamp, message } of messages) {
      console.log(localTimestamp, message);
    }
  } catch (e) {
    console.error(e);
  }
}

run();

curl -g 'https://api.tardis.dev/v1/data-feeds/binance-delivery?from=2020-07-01&filters=[{"channel":"depth","symbols":["btcusd_200925"]}]&offset=0'

curl -g 'localhost:8000/replay?options={"exchange":"binance-delivery","filters":[{"channel":"depth","symbols":["btcusd_200925"]}],"from":"2020-07-01","to":"2020-07-02"}'

Captured real-time channels

• trade

• aggTrade

• ticker

• bookTicker

• forceOrder

• markPrice @1s

• indexPrice @1s

• depth @0ms

• depthSnapshot - generated channel with full order book snapshots Binance COIN Futures real-time WebSocket API does not provide initial order book snapshots. To overcome this issue we fetch initial order book snapshots from REST API and store them together with the rest of the WebSocket messages - top 1000 levels. Such snapshot messages are marked with "stream":"<symbol>@depthSnapshot" and "generated":true fields.

  During data collection integrity of order book incremental updates is being validated using sequence numbers provided by real-time feed (pu and u fields) - in case of detecting missed message WebSocket connection is being restarted. We also validate if initial book snapshot fetched from REST API overlaps with received depth messages.

• openInterest - generated channel

  Since Binance COIN Futures does not offer currently real-time WebSocket open interest channel, we simulate it by fetching that info from REST API (https://binance-docs.github.io/apidocs/delivery/en/#open-interest) every 30 seconds for each instrument. Such messages are marked with "stream":"<symbol>@openInterest" and "generated":true fields and data field has the same format as REST API response.

Market data collection details

Market data collection infrastructure for Binance COIN Futures is located in GCP asia-northeast1 (Tokyo, Japan). Real-time market data is captured via multiple WebSocket connections.

Deribit historical data for all it's instruments (including all options) is available since 2019-03-30.

Downloadable CSV files

Historical CSV datasets for the first day of each month are available to download without API key. See downloadable CSV files documentation.

How to download all Deribit datasets for all instruments

See full downloadable CSV files documentation with datasets format spec, data samples and more.

# requires Python >=3.6
# pip install tardis-dev

from tardis_dev import datasets, get_exchange_details
import logging

# optionally enable debug logs
# logging.basicConfig(level=logging.DEBUG)

exchange = 'deribit'
exchange_details = get_exchange_details(exchange)   

# iterate over and download all data for every symbol
for symbol in exchange_details["datasets"]["symbols"]:
    # alternatively specify datatypes explicitly ['trades', 'incremental_book_L2', 'quotes'] etc
    # see available options https://docs.tardis.dev/downloadable-csv-files#data-types
    data_types = symbol["dataTypes"]  
    symbol_id = symbol["id"]
    from_date =  symbol["availableSince"]
    to_date = symbol["availableTo"]

    # skip groupped symbols
    if symbol_id in ['PERPETUALS', 'SPOT', 'FUTURES']:
        continue

    print(f"Downloading {exchange} {data_types} for {symbol_id} from {from_date} to {to_date}")

    # each CSV dataset format is documented at https://docs.tardis.dev/downloadable-csv-files#data-types
    # see https://docs.tardis.dev/downloadable-csv-files#download-via-client-libraries for full options docs
    datasets.download(
        exchange = exchange,
        data_types = data_types,
        from_date =  from_date,
        to_date = to_date,
        symbols = [symbol_id],
        # TODO set your API key here
        api_key = "YOUR_API_KEY",
        # path where CSV data will be downloaded into
        download_dir = "./datasets",
    )

// npm install tardis-dev
// requires node version >=12
const { downloadDatasets, getExchangeDetails } = require('tardis-dev')

;(async () => {
  const exchange = 'deribit'
  const exchangeDetails = await getExchangeDetails(exchange)

  // iterate over and download all data for every symbol
  for (const symbol of exchangeDetails.datasets.symbols) {
    // alternatively specify dataTypes explicitly ['trades', 'incremental_book_L2', 'quotes'] etc
    // see available options https://docs.tardis.dev/downloadable-csv-files#data-types
    const dataTypes = symbol.dataTypes
    const symbolId = symbol.id

    const from = symbol.availableSince
    const to = symbol.availableTo

    // skip groupped symbols
    if (['PERPETUALS', 'SPOT', 'FUTURES'].includes(symbolId)) {
      continue
    }

    console.log(`Downloading ${exchange} ${dataTypes} for ${symbolId} from ${from} to ${to}`)

    // each CSV dataset format is documented at https://docs.tardis.dev/downloadable-csv-files#data-types
    // see https://docs.tardis.dev/downloadable-csv-files#download-via-client-libraries for full options docs
    await downloadDatasets({
      exchange,
      dataTypes,
      from,
      to,
      symbols: [symbolId],
      // TODO: set your API key here
      apiKey: 'YOUR_API_KEY',
      //  path where CSV data will be downloaded into
      downloadDir: './datasets'
    })
  }
})()

curl -o deribit_trades_2019-11-01_BTC-PERPETUAL.csv.gz https://datasets.tardis.dev/v1/deribit/trades/2019/11/01/BTC-PERPETUAL.csv.gz

API Access and data format

Historical data format is the same as provided by real-time Deribit WebSocket v2 API with addition of local timestamps. If you'd like to work with normalized data format instead (same format for each exchange) see downloadable CSV files or official client libs that perform data normalization client-side.

# pip install tardis-client
import asyncio
from tardis_client import TardisClient, Channel
tardis_client = TardisClient(api_key="YOUR_API_KEY")

async def replay():
  # replay method returns Async Generator
  messages = tardis_client.replay(
    exchange="deribit",
    from_date="2019-07-01",
    to_date="2019-07-02",
    filters=[Channel(name="book", symbols=["BTC-PERPETUAL"])]
  )

  # messages as provided by Deribit real-time stream
  async for local_timestamp, message in messages:
    print(message)


asyncio.run(replay())

// npm install tardis-dev
const { replay } = require('tardis-dev');

async function run() {
  try {
    const messages = replay({
      exchange: 'deribit',
      from: '2019-07-01',
      to: '2019-07-02',
      filters: [{ channel: 'book', symbols: ['BTC-PERPETUAL'] }],
      apiKey: 'YOUR_API_KEY'
    });

    // messages as provided by Deribit real-time stream
    for await (const { localTimestamp, message } of messages) {
      console.log(localTimestamp, message);
    }
  } catch (e) {
    console.error(e);
  }
}

run();

curl -g 'https://api.tardis.dev/v1/data-feeds/deribit?from=2019-07-01&filters=[{"channel":"book","symbols":["BTC-PERPETUAL"]}]&offset=0'

curl -g 'localhost:8000/replay?options={"exchange":"deribit","filters":[{"channel":"book","symbols":["BTC-PERPETUAL"]}],"from":"2019-07-01","to":"2019-07-02"}'

Captured real-time channels

• book During data collection integrity of order book incremental updates is being validated using sequence numbers provided by Deribit's real-time feed (prev_change_id) - in case of detecting missed message WebSocket connection is being restarted.

• trades

• deribit_price_index

• deribit_price_ranking

• estimated_expiration_price

• markprice.options

• perpetual

• ticker

• quote

• platform_state - available since 2019-12-31

• deribit_volatility_index - available since 2021-04-01

book, perpetual, ticker, trades channels data was all collected with raw interval - no aggregation was applied.

Market data collection details

Market data collection infrastructure for Deribit is located in GCP europe-west2 region (London, UK). Real-time market data is captured via multiple WebSocket connections.

OKX historical data for all it's futures instruments is available since 2019-03-30.

Downloadable CSV files

Historical CSV datasets for the first day of each month are available to download without API key. See downloadable CSV files documentation.

API Access and data format

Historical data format is the same as provided by real-time OKX WebSocket v5 API with addition of local timestamps (before 2021-12-23 it was v3 API version). If you'd like to work with normalized data format instead (same format for each exchange) see downloadable CSV files or official client libs that can perform data normalization client-side.

# pip install tardis-client
import asyncio
from tardis_client import TardisClient, Channel
tardis_client = TardisClient(api_key="YOUR_API_KEY")

async def replay():
  # replay method returns Async Generator
  messages = tardis_client.replay(
    exchange="okex-futures",
    from_date="2023-01-01",
    to_date="2023-01-02",
    filters=[Channel(name="books-l2-tbt", symbols=[])]
  )

  # messages as provided by OKX real-time stream
  async for local_timestamp, message in messages:
    print(message)


asyncio.run(replay())

// npm install tardis-dev
const { replay } = require('tardis-dev');

async function run() {
  try {
    const messages = replay({
      exchange: 'okex-futures',
      from: '2023-01-01',
      to: '2023-01-02',
      filters: [{ channel: 'books-l2-tbt', symbols: [] }],
      apiKey: 'YOUR_API_KEY'
    });

    // messages as provided by OKX real-time stream
    for await (const { localTimestamp, message } of messages) {
      console.log(localTimestamp, message);
    }
  } catch (e) {
    console.error(e);
  }
}

run();

curl -g 'https://api.tardis.dev/v1/data-feeds/okex-futures?from=2023-01-01&filters=[{"channel":"books-l2-tbt","symbols":[]}]&offset=0'

curl -g 'localhost:8000/replay?options={"exchange":"okex-futures","filters":[{"channel":"books-l2-tbt","symbols":[]}],"from":"2023-01-01","to":"2023-01-02"}'

Captured real-time channels

V3 API channels (recorded until 2021-12-23):

• futures/trade

• futures/depth - available until 2020-01-29

• futures/depth_l2_tbt - available since 2019-12-05

• futures/mark_price

• futures/ticker

• index/ticker - available since 2019-09-21

• system/status - available since 2020-07-05

V5 API channels (recorded since 2021-12-23):

• trades

• trades-all

• books-l2-tbt

• bbo-tbt

• tickers

• open-interest

• mark-price

• price-limit

• status

• instruments

• index-tickers

• long-short-account-ratio

• taker-volume

• estimated-price

• public-block-trades

• public-struc-block-trades

• liquidation-orders

• taker-volume-contract

• long-short-account-ratio-contract-top-trader

• long-short-position-ratio-contract-top-trader

• long-short-account-ratio-contract

Market data collection details

Market data collection infrastructure for OKX Futures since 2022-05-04T16:45 is located in AWS HK region (Hong Kong, China, VPC colo setup), before that, starting since 2020-05-15 it was located in GCP asia-northeast1 (Tokyo, Japan) and initially it was located in GCP europe-west2 region (London, UK). Real-time market data is captured via multiple WebSocket connections.

Binance historical data for high caps currency pairs is available since 2019-03-30, data for all currency pairs is available since 2021-03-05.

Downloadable CSV files

Historical CSV datasets for the first day of each month are available to download without API key. See downloadable CSV files documentation.

API Access and data format

Historical data format is the same as provided by real-time Binance WebSocket API with addition of local timestamps. If you'd like to work with normalized data format instead (same format for each exchange) see downloadable CSV files or official client libs that can perform data normalization client-side.

# pip install tardis-client
import asyncio
from tardis_client import TardisClient, Channel
tardis_client = TardisClient(api_key="YOUR_API_KEY")

async def replay():
  # replay method returns Async Generator
  messages = tardis_client.replay(
    exchange="binance",
    from_date="2019-12-01",
    to_date="2019-12-02",
    filters=[Channel(name="depth", symbols=["btcusdt"])]
  )

  # messages as provided by Binance real-time stream
  async for local_timestamp, message in messages:
    print(message)


asyncio.run(replay())

// npm install tardis-dev
const { replay } = require('tardis-dev');

async function run() {
  try {
    const messages = replay({
      exchange: 'binance',
      from: '2019-12-01',
      to: '2019-12-02',
      filters: [{ channel: 'depth', symbols: ['btcusdt'] }],
      apiKey: 'YOUR_API_KEY'
    });

    // messages as provided by Binance real-time stream
    for await (const { localTimestamp, message } of messages) {
      console.log(localTimestamp, message);
    }
  } catch (e) {
    console.error(e);
  }
}

run();

curl -g 'https://api.tardis.dev/v1/data-feeds/binance?from=2019-12-01&filters=[{"channel":"depth","symbols":["btcusdt"]}]&offset=0'

curl -g 'localhost:8000/replay?options={"exchange":"binance","filters":[{"channel":"depth","symbols":["btcusdt"]}],"from":"2019-12-01","to":"2019-12-02"}'

Captured real-time channels

• trade

• aggTrade - available since 2019-11-19

• ticker

• bookTicker - available since 2019-09-21

• depth Binance depth channel has been recorded with the fastest update speed API allowed at the time. It means until 2019-08-30 it was depth (without @time suffix) - book updates pushed every 1000ms and after that date it was depth@100ms - book updates pushed every 100ms (new API feature).

• depthSnapshot - generated channel with full order book snapshots Binance real-time WebSocket API does not provide initial order book snapshots. To overcome this issue we fetch initial order book snapshots from REST API and store them together with the rest of the WebSocket messages - top 1000 levels. Such snapshot messages are marked with "stream":"<symbol>@depthSnapshot" and "generated":true fields.

  During data collection integrity of order book incremental updates is being validated using sequence numbers provided by real-time feed (U and u fields) - in case of detecting missed message WebSocket connection is being restarted. We also validate if initial book snapshot fetched from REST API overlaps with received depthmessages.

Market data collection details

Market data collection infrastructure for Binance since 2020-05-18 is located in GCP asia-northeast1 (Tokyo, Japan), before that it was located in GCP europe-west2 region (London, UK). Real-time market data is captured via multiple WebSocket connections.

What is Tardis.dev and what is your unique value proposition?

Tardis.dev provides the most comprehensive and granular cryptocurrency market data products in the industry and offers:

• access to high frequency historical data including the most granular tick level order book updates and trades for both derivatives and top spot cryptocurrency exchanges

• non standard data types: historical funding, open interest, indexes, liquidations and more

• fast and convenient data access both via API and downloadable CSV files

• data sourced from real-time WS market data feeds with complete control and transparency how the data is being recorded

• exchange-native and normalized data format support

• time-machine market replay allowing reconstruction of state of the limit order book at any given moment in time across all supported cryptocurrency markets

• always available market data backup

• fair, transparent pricing with discounts for solo trades, small prop shops and academic researchers

• consolidated real-time market data streaming support via Tardis.dev open source libraries that connect directly to exchanges' public WebSocket APIs (no API key required)

• professional support

Data use cases

• market microstructure and order book dynamics research

• trading execution optimization

• tick-level granularity market simulation

• liquidity and lead-lag analysis

• backtesting and optimization of trading strategies

• full historical order book reconstruction at any given point in time

• training machine learning models

• alpha generation

• designing quantitative models

• academics research

• data visualizations

Which exchanges, instruments and currency pairs are supported?

In total over 40 000 distinct instruments & currency pairs across leading derivatives and spot cryptocurrency exchanges is supported. We collect and provide data for all instruments & currency pairs available on given exchange with some exceptions for spot exchanges where we collect high caps currency pairs only (due to exchanges API limitations).

• BitMEX

• Deribit

• Binance

  • USDT Futures

  • COIN Futures

  • Spot

• FTX

• OKX

  • Futures

  • Swap

  • Options

  • Spot

• Huobi

  • Futures

  • COIN Swaps

  • USDT Swaps

  • Global (Spot)

• Bitfinex

  • Derivatives

  • Spot

• Coinbase Pro

• Kraken Futures (Crypto Facilities)

• Kraken

• Bitstamp

• Gemini

• Poloniex

• Bybit

• Bybit Spot

• dYdX

• WOO X

• Kucoin

  • Spot

• Blockchain.com

• Upbit

• Phemex

• Delta

• Ascendex (BitMax)

• FTX US

• Binance US

• Gate.io Futures

• Gate.io (high caps)

• Bitnomial

• Crypto.com

• OKCoin

• bitFlyer

• HitBTC

• CoinFLEX

• Binance Jersey

• Binance DEX

Do you provide discounts?

We do provide discounts in a transparent form via different subscriptions types.

Do you offer free trials?

Yes, if you'd like to test the service (data quality, coverage, API performance etc.) we offer generous free trials. Simply reach out to us and we'll set up trial account for you.

What does professional support mean?

Our support team has in-depth knowledge of market data and exchanges' APIs peculiarities, programming and data analysis expertise. You get the answers straight from people whose day to day job is overseeing and maintaining market data collection process and infrastructure.

For business subscriptions we provide dedicated communication channel (via Telegram Messenger, email or Zoom calls) for your company where our team is on standby every business day (7AM - 3PM UTC) to answer any questions you may have. For pro subscriptions and one-off purchases we do provide email based support with 24-48 business hours initial response time.

For academic and solo subscriptions there is no dedicated support provided, only self-service.

What would I use your services if I can collect data by myself?

Since cryptocurrency exchanges' market data APIs are public anyone can use those to collect the data, but it's a time consuming and resource intensive undertaking (exchanges we support publish ~1000GB of new data every day), that requires investment in proper infrastructure, constant monitoring and oversight (exchanges API changes, rate-limiting monitoring, new exchanges integrations, unexpected connection issues, latency monitoring etc.), not to mention implementation costs of data collection, storage and distribution services. All in all we think our offering is comprehensive, transparent and fair, provides good value and saves you time and money in comparison to in-house solution allowing you to focus on your core objective not on data management intricacies.

How can I download the data?

You can access historical market data via API which provides raw data in exchange native format or download CSV datasets with trades, incremental order book L2 updates, order book snapshots, options chains, quotes, derivative tickers (open interest, funding, mark price, index price) and liquidations. Our client libs provide data in normalized format as well, which can be more flexible than CSV datasets for some use cases but also slower to download due to on-demand, client-side data normalization overhead in comparison to ready to download CSV files.

How far back the historical data is available?

Data is available since 2019-03-30 for majority of the supported exchanges (that existed at that time).

Do you provide historical market data in CSV flat files?

Yes, see downloadable CSV files documentation for more details.

What programming languages are supported?

Any programming language that can communicate using HTTPS can communicate with our HTTP API.

We do provide official Python and Node.js clients that offer fast and convenient access to tick-level historical market data.

Finally, our open source, locally runnable tardis-machine server with built-in local data caching, provides market data normalization, custom order book snapshots capabilities and real-time market data streaming support that connects directly to exchanges' WebSocket APIs. It provides both streaming HTTP and WebSocket endpoints returning market data for whole time periods (in contrast to Tardis.dev HTTP API where single call returns data for single minute time period) and is available via npm and as a Docker Image.

What API protocols can be used to access market data?

Historical market data provided by HTTP API can be accessed via HTTPS.

Locally runnable tardis-machine server provides both HTTP and WebSocket based APIs for accessing both historical and real-time market data.

How time-machine market replay works?

Exchanges' market data WebSocket APIs are designed to publish real-time feeds and not historical ones. Locally runnable tardis-machine server's WebSocket API bridges that gap and allows "replaying" historical market data from any given past point in time with the same data format and 'subscribe' logic as real-time exchanges' APIs. In many cases existing exchanges' WebSocket clients can be used to connect to this endpoint just by changing URL, and receive market data in exchange-native format for date ranges specified in URL query string params.

Do you support consolidated real-time market data streaming?

We do not provide hosted real-time market data API as we think that given everyone can access exchanges' APIs directly for free without restrictions, relaying on 3rd party for such crucial piece of infrastructure does not make sense (additional latency and another SPOF). Instead we developed locally runnable (self hosted) server and open source libraries that offer consolidated real-time normalized market data streaming capabilities, connect directly to exchanges' WebSocket APIs and are completely free to use.

Are there any rate-limits for the API?

There are no API rate limits for downloadable CSV files API.

Raw data replay API for professional level subscriptions is limited to 30 millions requests per day. For business level subscriptions there are no rate limits for raw data replay API as long as your behavior does not negatively impact other customers API usage experience. If that's the case, we'll contact your via email and do our best to help how to sort it out - in most cases it's download client bug that over and over downloads the same data in a loop.

How do I obtain my API key?

API key can be obtained on Tardis.dev website via order form. You'll receive it via email after successful order.

What if my API key was compromised?

Contact us immediately and we will generate new API key for you.

What is your infrastructure setup?

Market data collection

Highly available Google Cloud Platform Kubernetes Clusters located in in London, UK (europe-west2 region) and Tokyo, Japan (asia-northeast1 region)

Market data storage

Two independent, geo-redundant, highly durable storage services

Market data distribution

High performance API servers deployed across network of data centers around the globe

Do you provide SLA?

We do not have a formal SLA in place yet, but all infrastructure is set up to provide highest availability possible on both data collection and distribution side with geo-redundant setup. Both data collection services and public APIs are constantly monitored from multiple locations and our team is immediately notified in case of any issue. We don't practice maintenance that would affect API availability, but in very rare circumstance if that would happen we'll communicate that in advance. If a formal SLA is something that your business require contact us.

What data types do you support?

We provide the most comprehensive and granular market data on the market sourced from real-time WebSocket APIs with complete control and transparency how the data is being recorded.

Via downloadable CSV data files following normalized tick-level data types are available:

• trades

• incremental order book L2 updates

• order book snapshots (top 25 and top 5 levels)

• options_chain

• quotes

• derivative tick info (open interest, funding rate, mark price, index price)

• liquidations

Raw data API that is available for pro and business subscriptions provides data in exchange-native data format. See historical data details to learn about real-time channels captured for each exchange. Each captured channel can be considered a different exchange specific data type (for example Binance bookTicker channel, or BitMEX liquidation channel).

We also provide following normalized data types via our client libs (normalization is done client-side, using raw data API as a data source):

• trades

• order book L2 updates

• order book snapshots (tick-by-tick, 10ms, 100ms, 1s, 10s etc)

• quotes

• derivative tick info (open interest, funding rate, mark price, index price)

• liquidations

• options summary

• OHLCV

• volume/tick based trade bars

What does high frequency historical data mean?

We always collect and provide data with the most granularity that exchange can offer via it's real-time WS feeds. High frequency can mean different things for different exchanges due to exchanges APIs limitations. For example for Coinbase Pro it can mean L3 order book data (market-by-order), for Binance Futures all order book L2 real-time updates and for Binance Spot it means order book updates aggregated in 100ms intervals.

How historical raw market data is being sourced?

Raw market data is sourced from exchanges real-time WebSocket APIs. For cases where exchange lacks WebSocket API for particular data type we fallback to pooling REST API periodically, e.g., Binance Futures open interest data.

Why data source matters and why we use real-time WebSocket feeds as data source vs periodically calling REST endpoints?

Recording exchanges real-time WebSocket feeds allows us preserving and providing the most granular data that exchanges APIs can offer including data that is simply not available via their REST APIs like tick level order book updates. Historical data sourced from WebSocket real-time feeds adheres to what you'll see when trading live and can be used to exactly replicate live conditions even if it means some occasional connection drops causing small data gaps, real-time data publishing delays especially during larger market moves, duplicated trades or crossed books in some edge cases. We find that trade-off acceptable and even if data isn't as clean and corrected as sourced from REST APIs, it allows for more insight into market microstructure and various unusual exchanges behaviors that simply can't be captured otherwise. Simple example would be latency spikes for many exchanges during increased volatility periods where exchange publish trade/order book/quote WebSocket messages with larger than usual latency or simply skip some of the the updates and then return those in one batch. Querying the REST API would result in nice, clean trade history, but such data wouldn't fully reflect real actionable market behavior and would result in unrealistic backtesting results, breaking in the real-time scenarios.

What L2 order book data can be used for?

L2 data (market-by-price) includes bids and asks orders aggregated by price level and can be used to analyze among other things:

• order book imbalance

• average execution cost

• average liquidity away from midpoint

• average spread

• hidden interest (i.e., iceberg orders)

We do provide L2 data both in CSV format as incremental order book L2 updates, tick level order book snapshots (top 25 and top 5 levels) as well as in exchange-native format via API and client libraries that can perform full order book reconstruction client-side.

What L3 order book data can be used for?

L3 data (market-by-order) includes every order book order addition, update, cancellation and match and can be used to analyze among other things:

• order resting time

• order fill probability

• order queue dynamics

Historical L3 data is currently available via API for Bitfinex, Coinbase Pro and Bitstamp - remaining supported exchanges provide L2 data only.

What is the maximum order book depth available for each supported exchange?

We always collect full depth order book data as long as exchange's WebSocket API supports it. Table below shows current state of affairs for each supported exchange.

Which exchanges support liquidations data type?

Liquidations data is sourced from exchanges WebSocket APIs when supported with fallback to pooling REST APIs when WebSockets APIs do not support that data type and can be accessed via raw data APIs (replaying relevant channel) or as normalized data type via CSV downloads.

Do you provide historical options data?

Yes, we do provide historical options data for Deribit and OKEx Options - see options chain CSV data type and Deribit and OKEx Options exchange details pages.

Do you provide historical futures data?

We cover all leading derivatives exchanges such as BitMEX, Deribit, Binance USDT Futures, Binance COIN Futures, FTX, OKEx, Huobi Futures, Huobi Swap, Bitfinex Derivatives, Bybit and many more.

What is the difference between futures and perpetual swaps contracts?

Futures contract is a contract that has expiry date (for example quarter ahead for quarterly futures). Futures contract price converges to spot price as the contract approaches expiration/settlement date. After futures contract expires, exchange settles it and replaces with a new contract for the next period (next quarter for our previous example).

Perpetual swap contract also commonly called "perp", "swap", "perpetual" or "perpetual future" in crypto exchanges nomenclature is very similar to futures contract, but does not have expiry date (hence perpetual). In order to ensure that the perpetual swap contract price stays near the spot price exchanges employ mechanism called funding rate. When the funding rate is positive, Longs pay Shorts. When the funding rate is negative, Shorts pay Longs. This mechanism can be quite nuanced and vary between exchanges, so it's best to study each contract specification to learn all the details (funding periods, mark price mechanisms etc.).

Do you provide time based aggregated data as well?

We are focusing on providing the best possible tick-level historical data for cryptocurrency exchanges and as of now our APIs (both HTTP and CSV datasets) do offer access to tick-level data only and do not offer support for time based aggregated data.

If you're interested in time based aggregated data (OHLC, interval based order book snapshots) see our client libs that provide such capabilities, but with the caveat that data aggregation is performed client-side from tick-level data sourced from the API, meaning it can be relatively slow process in contrast to ready to download aggregated data.

Can you record market data for exchange that's not currently supported?

Yes, we're always open to support new promising exchanges. Contact us and we'll get back to you to discuss the details.

Do you provide market data in normalized format?

Normalized market data (unified data format for every exchange) is available via our official libraries and downloadable CSV files. Our HTTP API provides data only in exchange-native format.

Do you provide normalized contract amounts for derivatives exchanges in your historical data feeds?

Data we provide has contract amounts exactly as provided by exchanges APIs, meaning in some cases it can be tricky to compare across exchanges due to different contract multipliers (like for example OKEx where each contract has $100 value) or different contract types (linear or inverse). We'll keep it this way, but we also provide instrument metadata API that returns contract multipliers, tick sizes and more for each instrument in uniform way, allowing easily normalize the contract amounts client-side without having to go through all kinds of documentation on various exchange to find this information.

What is a difference between exchange-native and normalized data format?

Cryptocurrency markets are very fragmented and every exchange provides data in it's own bespoke data format which we call exchange-native data format. Our HTTP API and client libs can provide market data in this format, meaning data you receive is exactly the same as the live data you would have received from exchanges ("as-is").

For example BitMEX trade message looks like this:

{
  "table": "trade",
  "action": "insert",
  "data": [
    {
      "timestamp": "2019-06-01T00:03:11.589Z",
      "symbol": "ETHUSD",
      "side": "Sell",
      "size": 10,
      "price": 268.7,
      "tickDirection": "ZeroMinusTick",
      "trdMatchID": "ebc230d9-0b6e-2d5d-f99a-f90109a2b113",
      "grossValue": 268700,
      "homeNotional": 0.08555051758063137,
      "foreignNotional": 22.987424073915648
    }
  ]
}

and this is Deribit trade message:

{
  "jsonrpc": "2.0",
  "method": "subscription",
  "params": {
    "channel": "trades.ETH-26JUN20.raw",
    "data": [
      {
        "trade_seq": 18052,
        "trade_id": "ETH-10813935",
        "timestamp": 1577836825724,
        "tick_direction": 0,
        "price": 132.65,
        "instrument_name": "ETH-26JUN20",
        "index_price": 128.6,
        "direction": "buy",
        "amount": 1.0
      }
    ]
  }
}

In contrast, normalized data format means the same, unified format across multiple exchanges. We provide normalized data via our client libs (data normalization is performed client-side) as well as via downloadable CSV files.

Sample normalized trade message:

{
  "type": "trade",
  "symbol": "XBTUSD",
  "exchange": "bitmex",
  "id": "282a0445-0e3a-abeb-f403-11003204ea1b",
  "price": 7996,
  "amount": 50,
  "side": "sell",
  "timestamp": "2019-10-23T10:32:49.669Z",
  "localTimestamp": "2019-10-23T10:32:49.740Z"
}

We support following normalized data types via our client libs:

• tick-by-tick trades

• order book L2 updates

• order book snapshots (tick-by-tick, 10ms, 100ms, 1s, 10s etc)

• quotes

• derivative tick info (open interest, funding rate, mark price, index price)

• liquidations

• OHLCV

• volume/tick based trade bars

and downloadable CSV data files:

• tick-by-tick trades

• incremental order book L2 updates

• tick level order book snapshots (top 25 and top 5 levels)

• options_chain

• quotes

• derivative tick info (open interest, funding rate, mark price, index price)

• liquidations

What is the channel field used in the HTTP API and client libs replay functions?

Exchanges when publishing real-time data messages, always publish those for subscription topics clients have subscribed to. Those subscriptions topics are also very often called "channels" or "streams" in exchanges documentations pages and describe data type given message belongs to - for example BitMEX publishes it's trades data via trade channel and order book L2 updates data via orderBookL2.

Since we collect the data for all the channels described in exchanges' details page (Captured real-time market data channels section) our HTTP API and client libs offer filtering capability by those channels names, so for example to get historical trades for BitMEX, channel trade needs to be provided alongside requested instruments symbols (via HTTP API or client lib replay function args).

What time zone is used in the data?

UTC, always.

Is provided raw market data complete?

We're doing our best to provide the most complete and reliable historical raw data API on the market. To do so amongst many other things, we utilize highly available Kubernetes clusters on Google Cloud Platform that offer best in the class availability, networking and monitoring. However due to exchanges' APIs downtimes (maintenance, deployments, connection drops etc.) we can experience data gaps and cannot guarantee 100% data completeness, but 99.9% (99.99% on most days) which should be more than enough for most of the use cases that tick level data is useful for. In rare circumstances, when exchange's API changes without any notice or we hit new unexpected rate limits we also may fail to record data during such period, it happens very rarely and is very specific for each exchange. Use /exchanges/:exchange API endpoint and check for incidentReports field in order to get most detailed and up to date information on that subject.

How frequently exchanges drop WebSocket connections?

As long as exchange WebSocket API is not 'hidden' behind Cloudflare proxy (causing relatively frequent "CloudFlare WebSocket proxy restarting, Connection reset by peer" errors) connections are stable for majority of supported exchanges and there are almost no connection drops during the day. In cases when there is more volatility in the market some exchanges tend to drop connections more frequently or have larger latency spikes. Overall it's a nuanced matter that changes over time, if you'd have any questions regarding particular exchange, please do not hesitate to contact us.

Can historical order books reconstructed from L2 updates be crossed (bid/ask overlap) occasionally?

Although is should never happen in theory, in practice due to various crypto exchanges bugs and peculiarities it can happen (very occasionally), see some posts from users reporting those issues:

• https://www.reddit.com/r/BitMEX/comments/8lbj9e/bidask_ledger_weirdness/

• https://www.reddit.com/r/KrakenSupport/comments/emu7xc/websocket_bid_sometimes_not_being_deletedupdated/

• https://www.reddit.com/r/KrakenSupport/comments/d1a4nx/websocket_orderbook_receiving_wrong_bid_price_for/

• https://twitter.com/coinarb/status/931260529993170944

We do track sequence numbers of WebSocket L2 order book messages when collecting the data and restart connection when sequence gap is detected for exchanges that do provide those numbers. We observe that even in scenario when sequence numbers are in check, bid/ask overlap can occur. When such scenario occurs, exchanges tend to 'forget' to publish delete messages for the opposite side of the book when publishing new level for given side - we validated that hypothesis by comparing reconstructed order book snapshots that had crossed order book (bid/ask overlap) for which we removed order book levels for the opposite side manually (as exchange didn't publish that 'delete'), with quote/ticker feeds if best bid/ask matches (for exchanges that provide those) - see sample code that implements that manual level removal logic.

Can exchange publish data with non monotonically increasing timestamps for single data channel?

That shouldn't happen in theory, but we've detected that for some exchanges when new connection is established sometimes first message for given channel & symbol has newer timestamp than subsequent message, e.g., order book snapshot has newer timestamp than first order book update. This is why we provide data via API and CSV downloads for given data ranges based on local timestamps (timestamp of message arrival) which are always monotonically increasing.

Are exchanges publishing duplicated trades data messages?

Some exchanges are occasionally publishing duplicated trades (trades with the same ids). Since we collect real-time data we also collect and provide duplicate trades via API if those were published by real-time WebSocket feeds of exchanges. Our client libraries have functionality that when working with normalized data can deduplicate such trades, similarly for downloadable CSV files we deduplicate tick-by-tick trades data.

How order book data snapshots are provided?

Historical market data available via HTTP API provides order book snapshots at the beginning of each day (00:00 UTC) - see details.

We also provide custom order book snapshots with customizable time intervals from tick-by-tick, milliseconds to minutes or hours via client libs in which case custom snapshots are computed client side from raw data provided via HTTP API as well as via downloadable CSV files - book_snapshot_25 and book_snapshot_5 .

Do you collect order books as snapshots or in streaming mode?

Order books are collected in streaming mode - snapshot at the beginning of each day and then incremental updates. See details.

We also provide custom order book snapshots with customizable time intervals from tick-by-tick, milliseconds to minutes or hours via client libs in which case custom snapshots are computed client side from raw data provided via HTTP API as well as via downloadable CSV files - book_snapshot_25 and book_snapshot_5 .

How incremental_book_l2 CSV dataset is built from real-time data?

Cryptocurrency exchanges real-time APIs vary a lot, but for L2 order book data they all tend to follow similar flow, first when WS connection is established and subscription is confirmed, exchanges send initial order book snapshot (all existing price levels or top 'x' levels depending on exchange) and then start streaming 'book update' messages (called frequently deltas as well). Those updates when applied to initial snapshot, result in up to data order book state at given time.

Let's take FTX as an example and start with it's snapshot orderbook message (that is frequently called 'partial' in exchanges API docs as well). Remaining bids and asks levels were removed from this sample message for the sake of clarity.

{
  "channel": "orderbook",
  "market": "ETH/USD",
  "type": "partial",
  "data": {
    "time": 1601510401.2166328,
    "checksum": 204980439,
    "bids": [
      [
        359.72,
        121.259
      ]
    ],
    "asks": [
      [
        359.8,
        8.101
      ]
    ],
    "action": "partial"
  }
}

Such snapshot message maps to the following rows in CSV file:

... and here's a sample FTX orderbook update message.

{
  "channel": "orderbook",
  "market": "ETH/USD",
  "type": "update",
  "data": {
    "time": 1601510427.1840546,
    "checksum": 1377242400,
    "bids": [],
    "asks": [
      [
        360.24,
        4.962
      ],
      [
        361.02,
        0
      ]
    ],
    "action": "update"
  }
}

Let's see how it maps to CSV format.

See this answer if you have doubts how to reconstruct order book state based on data provided in incremental_book_L2 dataset.

How can I reconstruct full order book state from incremental_book_L2 CSV dataset?

In order to reconstruct full order book state correctly from incremental_book_L2 data:

• For each row in the CSV file (iterate in the same order as provided in file):

  • only if local timestamp of current row is larger than previous row local timestamp(local_timestamp column value) it means you can read your local order book state as it's consistent, why? CSV format is flat where each row represents single price level update, but most exchanges real-time feeds publish multiple order book levels updates via single WebSocket message that need to be processed together before reading locally maintained order book state. We use local timestamp value here to detect all price level updates belonging to single 'update' message.

  • if current row is a part of the snapshot (is_snapshot column value set to true) and previous one was not, reset your local order book state object that tracks price levels for each order book side as it means that there was a connection restart and exchange provided full order book snapshot or it was a start of a new day (each incremental_book_L2 file starts with the snapshot)

  • if current row amount is set to zero (amount column value set to 0) remove such price level (row's price column) from your local order book state as such price level does not exist anymore

  • if current row amount is not set to zero update your local order book state price level with new value or add new price level if not exist yet in your local order book state - maintain separately bids and asks order book sides (side column value)

Alternatively we do also provide top 25 and top 5 levels order book snapshots CSV datasets ready to download.

How CSV datasets are split into the files?

CSV datasets are available in daily intervals split by exchange, data type and symbol. In addition to standard currency pairs/instrument symbols, each exchange also has special 'grouped' symbols available depending if it supports given market type: SPOT, FUTURES, OPTIONS and PERPETUALS. That feature is useful if someone is interested in for examples all Deribit's options instruments' trades or quotes data without a need to request data for each symbol separately one by one.

How market data messages are being timestamped?

Each message received via WebSocket connection is timestamped with 100ns precision using synchronized clock at arrival time (before any message processing) and stored in ISO 8601 format.

What is the new historical market data delay in relation to real-time?

For API access it's 15 minutes (T - 15min), downloadable CSV files for given day are available on the next day around 06:00 UTC.

What is the order process?

1. Select data plan and access type that you're interested in via order form on Tardis.dev website.

   • available data plans

     • Individual

     • Perpetuals

     • Derivatives

     • All Exchanges

   • available access types

     • One-off Purchase

     • Subscription

       • Solo

       • Academic

       • Pro

       • Business

2. Proceed to checkout where you provide email address and payment details.

   • accepted payment methods

     • Credit Cards (Mastercard Visa Maestro American Express Discover Diners Club JCB UnionPay)

     • PayPal

     • Apple Pay (one-off purchases only)

     • Wire Transfers (for one-off purchases only)

3. Successfully complete your payment and receive the API key via email that allows you to download CSV datasets and access historical data via API. API key is valid as long as subscription is active or 6 months for one-off purchases.

Do you provide discounts?

We do provide discounts in a transparent form via different subscriptions types.

How one-off purchase based access works?

One-off purchase provides access to specific time periods of historical market data. API key is valid for a year since purchase and allows access to all available data types (trades, order books etc.) for ordered date ranges both via API and downloadable CSV files.

How subscription based access works?

Subscriptions based access model relies on recurring payments at regular intervals (monthly, quarterly, yearly) and offers access to newly collected market data as it becomes available as well as existing historical market data which range depends on chosen billing period.

There are three 'dimensions' you can customize your subscription by:

• Subscription type - Academic, Solo, Pro or Business

• Data plan (which exchanges data you get access to) - Individual, Perpetuals, Derivatives or All Exchanges

• Billing interval (how much of historical data you get access to) - monthly, quarterly or yearly

For example "All Exchanges" Business Subscription with yearly billing period allows accessing all available existing historical data via API and CSV files and one year of new data as it becomes available (for initial payment). API key is valid as long as subscription is active and allows access to all available data types (trades, orders book data, quotes, funding, liquidations etc.) via downloadable CSV files and via raw market data API (for Pro and Business subscriptions types only).

What are the differences between subscriptions types?

Do subscriptions include access to historical data as well?

Yes, depending on chosen billing period, subscriptions include access to existing historical market data as well:

• all available historical data if subscription is billed yearly - historical market data is available since 2019-03-30 for majority of the supported exchanges (see exchange details page for exact date for particular exchange)

• 12 months of historical data if subscription is billed quarterly, e.g., subscription that has started at 2020-04-01, includes access to historical data since 2019-04-01 - it's not a rolling time window, but fixed starting date since when historical data is available for your subscription

• 4 months of historical data if subscription is billed monthly, e.g., subscription that has started at 2020-04-01, includes access to historical data since 2019-12-01 - it's not a rolling time window, but fixed starting date since when historical data is available for your subscription

All subscriptions provide access to all available data types (trades, orders book data, quotes, funding etc.) via downloadable CSV files and raw data replay API (for pro and business subscriptions types).

What is included in "Individual" data plan?

"Individual" data plan provides per-exchange access to market data that includes full feed (all instruments) and data types of selected exchange(s), for example full Coinbase exchange data feed.

"Individual" data plan allows access to all available data types (trades, orders book data, quotes, funding etc.) via downloadable CSV files and raw data replay API (for pro and business subscriptions types). Range of historical data access for "Individual" data plan depends on chosen billing period (for example: access to all existing historical data we collected if subscription is billed yearly).

What is included in "Perpetuals" data plan?

"Perpetuals" data plan provides access to the following perpetual swaps instruments' market data (over 500 perpetual swaps instruments across 13 exchanges):

• BitMEX: all perpetual swaps instruments

• Deribit: all perpetual swaps instruments

• Binance USDT Futures: all perpetual swaps instruments

• Binance COIN Futures: all perpetual swaps instruments

• FTX: all perpetual swaps instruments

• OKX Swap: all perpetual swaps instruments

• Huobi COIN Swaps: all perpetual swaps instruments

• Huobi USDT Swaps: all perpetual swaps instruments

• bitFlyer: FX_BTC_JPY

• Bitfinex Derivatives: all perpetual swaps instruments

• Bybit: all perpetual swaps instruments

• dYdX: all perpetual swaps instruments

• Phemex: all perpetual swaps instruments

• Delta: all perpetual swaps instruments

• Gate.io Futures: all perpetual swaps instruments

• CoinFLEX: all perpetual swaps instruments

• dYdX: all perpetual swaps instruments

• WOO X: all perpetual swaps instruments

• Ascendex: all perpetual swaps instruments

• Crypto.com: all perpetual swaps instruments

"Perpetuals" data plan allows access to all available data types (trades, orders book data, funding etc.) via downloadable CSV files and raw data replay API (for pro and business subscriptions types). Range of historical data access for "Perpetuals" data plan depends on chosen billing period (for example: access to all existing historical data we collected if subscription is billed yearly).

What is included in "Derivatives" data plan?

"Derivatives" data plan provides access to the following derivatives exchanges' market data:

• BitMEX: all exchange's instruments

• Deribit: all exchange's instruments

• Binance USDT Futures: all exchange's instruments

• Binance COIN Futures: all exchange's instruments

• FTX: all exchange's instruments

• OKX Futures: all exchange's instruments

• OKX Swap: all exchange's instruments

• OKX Options: all exchange's instruments

• Huobi Futures: all exchange's instruments

• Huobi COIN Swap: all exchange's instruments

• Huobi USDT Swaps: all exchange's instruments

• Bitfinex Derivatives: all exchange's instruments

• Bybit: all exchange's instruments

• DYdX: all exchange's instruments

• Phemex: all exchange's instruments

• CoinFLEX: : all exchange's instruments

• Delta: all exchange's instruments

• bitFlyer: all exchange's instruments

• Gate.io Futures: all exchange's instruments

• dYdX: all perpetual swaps instruments

• WOO X: all exchange's instruments

• Crypto.com: all exchange's instruments

• Ascendex: all exchange's instruments

"Derivatives" data plan allows access to all available data types (trades, orders book data, quotes, funding etc.) via downloadable CSV files and raw data replay API (for pro and business subscriptions types).

Range of historical data access for "Derivatives" data plan depends on chosen billing period (for example: access to all existing historical data we collected if subscription is billed yearly).