What is orderbook depth data and how is it different from OHLCV?

OHLCV (Open-High-Low-Close-Volume) candles only show price and volume at a surface level. Orderbook depth data reveals the actual bid and ask liquidity sitting at multiple price levels — showing you how much buying and selling pressure exists and how far from the market price. Our dataset provides 10 levels of depth on both sides, measured in cumulative volume and basis-point distance from mid-price. This is the raw material that institutional traders and quantitative researchers use to detect order flow, predict short-term price movements, and model realistic execution costs.

Which instruments and timeframe does the dataset cover?

The current release covers 24 major crypto perpetual futures sourced from the leading L1 Perpetual Decentralized Exchange: BTC, ETH, SOL, BNB, XRP, DOGE, ADA, AVAX, LINK, DOT, NEAR, SUI, OP, ARB, SEI, TIA, INJ, APT, FIL, LTC, ETC, WIF, XLM, and ATOM. All data is aggregated into 5-minute bars spanning from March 2025 to February 2026 — approximately 12 months of continuous coverage. Each instrument has ~96,000 bars with 47 derived columns per row, including OHLCV, bid/ask volumes, and bid/ask distances at 10 depth levels.

Can I use this data for machine learning and deep learning?

Absolutely. The dataset is specifically designed for ML workflows. The 47-column schema feeds directly into LSTM networks, Transformer architectures, reinforcement learning environments (like Gymnasium/Stable-Baselines3), and gradient-boosted models (XGBoost, LightGBM). Common derived features include bid-ask imbalance ratios, depth-weighted pressure scores, liquidity concentration metrics, and spread dynamics — all computable in a few lines of Python from our raw columns.

Can you create custom datasets with different instruments, timeframes, or depth levels?

Yes. We can generate orderbook depth data for any cryptocurrency available on major derivatives DEXs and CEXs, at any candle interval (1-minute, 5-minute, 15-minute, 1-hour, etc.), covering any historical time period. We also support extended depth up to 30 levels. Contact us at imbalancelabs@gmail.com with your requirements for a custom quote.

Is this data legally safe to use?

Yes. Our datasets are classified as Derived Data — an Aggregated Liquidity and Orderbook Depth Index. All raw order book snapshots have been aggregated across time intervals, normalized, and transformed through statistical computations. The original tick-level data is not recoverable from our product. This classification places it outside the scope of most exchange data redistribution restrictions.

What format is the data delivered in?

All datasets are delivered as compressed CSV files (.csv.gz), which can be loaded directly by Python pandas, R, DuckDB, Apache Spark, and most data analysis tools. Each file is named by instrument (e.g., BTC_5m_depth10_derived.csv.gz). The full dataset ZIP containing all 24 instruments is approximately 300 MB.

Crypto Slippage Calculation in Python: L2 Orderbook Data

Executive Summary

Liquidity Illusion: Simulating execution on OHLCV close prices generates phantom profits that vanish in live trading due to empty orderbook depth.
VWAP Execution: Realistic backtesting requires sweeping the Level 2 orderbook to calculate the exact Volume-Weighted Average Price (VWAP) for your intended trade size.
Data Infrastructure: Parsing raw L2 snapshots is computationally expensive; using pre-flattened Parquet depth datasets allows executing vectorized VWAP calculations in milliseconds.

The Liquidity Illusion in Crypto Backtesting

You have built a mean-reversion strategy on TradingView. The backtest equity curve is a perfect 45-degree angle. You deploy it live, and within three days, the account is bleeding money. This is the classic Liquidity Illusion.

Standard OHLCV (Open, High, Low, Close, Volume) data assumes infinite liquidity at a single price point. If your model decides to buy 50 BTC at $60,000, OHLCV backtests fill the entire 50 BTC at $60,000. In reality, the top of the orderbook might only hold 2 BTC at that price. The remaining 48 BTC will sweep deeper into the orderbook, suffering massive market impact and slippage. To accurately model this, you must analyze the BTC L2 dataset.

Mathematical Definition of Orderbook Slippage (VWAP)

When executing a market order of size $ V_{target} $, the execution price is not the best bid/ask. It is the Volume-Weighted Average Price (VWAP) across all depth levels required to fill $ V_{target} $.

VWAP =

∑_i=1ⁿ (Price_i × Volume_i)

∑_i=1ⁿ Volume_i

, where ∑ Volume_i = V_target

Vectorized Slippage Calculation in Python

Iterating row-by-row in Python is too slow for tick data. By utilizing our structured Parquet format, we can vectorize the orderbook sweep. Below is a function that calculates the exact execution slippage for a $100,000 market buy order using Imbalance Labs' naming conventions.

slippage_calculator.pyPython

import pandas as pd
import numpy as np

# Load 5m depth data from Imbalance Labs
# Product: SOL Historical Orderbook
df = pd.read_parquet('sol_l2_depth_5m.parquet')

def calculate_buy_vwap(row, target_notional=100000):
    remaining_notional = target_notional
    total_cost = 0
    filled_volume = 0
    
    # Sweep through 10 levels of the ask side
    for i in range(1, 11):
        ask_price = row[f'ask_price_level_{i}']
        ask_vol = row[f'ask_volume_level_{i}']
        
        level_notional = ask_price * ask_vol
        
        if remaining_notional <= level_notional:
            # Partial fill at this level completes the order
            fill_vol = remaining_notional / ask_price
            total_cost += remaining_notional
            filled_volume += fill_vol
            break
        else:
            # Fully consume this level
            total_cost += level_notional
            filled_volume += ask_vol
            remaining_notional -= level_notional
            
    # If order is not filled after 10 levels, we hit max slippage
    return total_cost / filled_volume if filled_volume > 0 else np.nan

# Vectorized execution simulation across the dataset
df['execution_vwap'] = df.apply(calculate_buy_vwap, axis=1)
df['slippage_bps'] = ((df['execution_vwap'] - df['ask_price_level_1']) / df['ask_price_level_1']) * 10000

print(f"Average Slippage for $100k Order: {df['slippage_bps'].mean():.2f} bps")

Why This Matters for Specific Assets

Slippage is not uniform across assets. A $100,000 order on Bitcoin might induce 0.5 bps of slippage. The exact same order might induce 12 bps of slippage if you analyze the Ethereum L2 dataset, and over 45 bps on altcoins like Solana during periods of low liquidity.

Stop Guessing Your Slippage

Get exactly what you need to calculate VWAP and test market impact. Our Level 2 datasets provide millisecond snapshots flattened into Parquet files for Pandas and DuckDB.

Browse Datasets View 1M Pro ($149)

Frequently Asked Questions

Why is OHLCV data insufficient for calculating slippage?

OHLCV assumes infinite liquidity at the close price. It ignores the actual orderbook depth, leading to a "Liquidity Illusion" where large orders appear profitable in backtests but fail in live execution due to market impact.

How does Level 2 data improve execution modeling?

Level 2 data provides the exact available liquidity at various price levels. By sweeping the orderbook, you can compute the Volume-Weighted Average Price (VWAP) for any order size, giving you the true execution cost and exact slippage.