What exactly is order-book depth data?

Every bid and ask price level with its size, captured at each change. Not just the last traded price or the top of book, but the full ladder, so you can measure spreads, slippage, and real liquidity.

How is this different from free hourly archives?

Hourly snapshots are useless for a 5-minute market. On Polymarket we record every book and price-change event in real time over the CLOB websocket; on Kalshi we poll the full depth continuously (roughly every 1.5s). Either way it is orders of magnitude finer than hourly archives, so short-dated markets stay backtestable.

What format is the data delivered in?

The full book ships as whole-day, zstd-compressed Parquet — the exact columns you reconstruct a book from: bid/ask price and size arrays plus exchange and receive timestamps in epoch-millis. A REST API (Bearer key) handles market discovery and metadata. Bulk pulls have no rate-limit surprises.

Can I cancel anytime?

Yes. Paid plans are month to month, and the free Explorer tier needs no card to start. Cancel anytime from the dashboard.

Backtest prediction markets on the full order book.

The full bid/ask book for Polymarket, Kalshi, and Limitless — captured tick by tick. Chart the depth, backtest against real liquidity, or pull whole-day Parquet. The data nobody else keeps, and the platform to trade on it.

Start free See the data

Why depth beats the last price Read the API docs

BTC up · 5m

full book · 10 lvls

best bid

0.612

mid

0.6135

best ask

0.615

spread

0.003

bid depth

39k

ask depth

35k

imbalance

53 / 47

cumulative depthbidask

0.5780.606mid 0.61350.6220.651

bidsize · Σ

0.6122.3k2

0.6102.9k5

0.6083.6k9

0.6063.3k12

0.6034.4k16

0.6005.0k21

0.5964.0k26

0.5914.7k30

asksize · Σ

0.6152.1k2

0.6172.7k5

0.6192.5k7

0.6223.6k11

0.6253.3k14

0.6294.5k19

0.6333.0k22

0.6384.2k26

event-driven · full book, both sidesexch_ts → recv_ts

Backtests are only honest on real depth. A mid-price hides the spread, the size resting at each level, and the slippage your order would actually pay. DepthFeed keeps the whole book.

venues

Polymarket · Kalshi · Limitless

assets

BTC · ETH · SOL · XRP · DOGE · BNB · HYPE

Full

book depth

every level, both sides

Parquet

+ REST API

whole-day bulk or live discovery

01What you get

The book, not just the last price.

Full bid/ask book depth

Every price level with its size, on both sides, at every change. Measure real slippage and liquidity, not a single mid-price.

sub-sec

Event-driven cadence

Recorded on every book and price-change event, not sampled. Short-dated markets stay backtestable.

API + Parquet bulk

Query recent windows over REST, or pull whole-day zstd Parquet for bulk backtests.

Underlying price, time-synced

A high-frequency reference price series — Binance spot/futures plus Chainlink settlement marks — that joins to any Polymarket, Kalshi, and Limitless snapshot by epoch-millis timestamp, so you can line up book state with the spot move that drove it.

02The platformBeta

Not just the data — the platform to backtest it.

Most depth data is a pile of Parquet you have to wire up yourself. DepthFeed adds the layer on top: chart the book like a terminal and backtest against real liquidity, on the same dataset, without leaving the page.

Depth overview

Chart the full book and the underlying side by side — spread, the size resting at each level, and the price move that drove it. A terminal view of the depth, not a CSV you have to draw yourself.

Backtest on real fills

Replay a market tick by tick and size a strategy against the liquidity that was actually there. Real spreads, real slippage — the fills you could have gotten, not a mid-price fantasy.

One dataset, no export

The overview and the backtest run on the exact data you can also download. Nothing to scrape or wire up — explore it in the platform, then pull whole-day Parquet when you want it in your own stack.

03Coverage

Polymarket, Kalshi, and Limitless coverage, growing with demand.

We collect what matters for short-dated markets: the full book across the assets and time windows traders actually use.

Assets

BTCETHSOLXRPDOGEBNBHYPE

Market windows

5m15m1h4h24h

04Quickstart

From key to backtest in minutes.

Pull a whole day of full-depth book as zstd Parquet, or hit the REST API to discover live markets. Clean columnar schema, epoch-millis timestamps, no scraping.

Stable columnar schema
Exchange + receive timestamps
No rate-limit surprises on bulk

quickstart.sh

# 1 · Discover live markets — REST API, Bearer key
$ curl -s "https://api.depthfeed.com/v3/btc/markets?type=5m" \
    -H "Authorization: Bearer $DEPTHFEED_KEY"
# {"data":[{"slug":"btc-updown-5m-1780824900",
#           "market_type":"5m","clob_token_up":"0x…"}], …}

# 2 · Backtest on the full book — whole-day zstd Parquet
import pandas as pd

book = pd.read_parquet("polymarket_book/btc/5m/2026-06-05.parquet")
book["best_bid"] = book["bid_prices"].str[0]   # full ladder in bid_prices[]
book["best_ask"] = book["ask_prices"].str[0]
book["spread"]   = book["best_ask"] - book["best_bid"]

print(book[["exch_ts_ms", "best_bid", "best_ask", "spread"]].head())

Order-book depth, and the platform to backtest it

Backtesting a prediction-market strategy needs the order book it would have traded against — full depth on both sides, captured finely enough to replay. That data is expensive to record and impossible to backfill, so almost nobody keeps it. DepthFeed keeps it, then lets you backtest on it.

Three venues, one schema

Polymarket, Kalshi, and Limitless in a single, stable columnar format. Event-driven websocket capture on Polymarket and Limitless; continuous full-depth polling on Kalshi. Bid/ask price and size arrays, epoch-millis exchange and receive timestamps — the columns you actually reconstruct a book from.

Depth, not the last price

The mid-price hides spread, size, and the slippage a real order pays. Full order-book depth lets you measure the liquidity that was genuinely there, so your prediction-market backtest reflects fills you could have actually gotten.

Chart it, replay it, backtest it

Explore the book in an in-platform overview, replay a whole session tick by tick, and backtest a strategy against the depth it would have hit — without leaving the platform. Or pull whole-day zstd Parquet and run it in your own stack. Live markets stream over the REST API when you are ready to go forward.

05Pricing

Simple plans. Start without a card.

Explorer

$0free, no card

Kick the tires on real depth data.

7-day rolling history
Read-only API, 1 req/sec
Sub-second event-driven snapshots
BTC markets (latest, capped)

Start free

Quant

Popular

$29per month

For traders building a real track record.

60-day rolling history, all assets
Both venues: Polymarket + Kalshi
Full bid/ask book depth
API 25 req/sec, 1,000 req/min + Parquet bulk
Underlying price stamped per snapshot

Choose Quant

Desk

$200per month

Dedicated throughput for systematic desks.

Everything in Quant
90-day rolling history
Dedicated infrastructure, 100 req/sec
S3 / R2 direct bulk delivery
Priority backfill requests

Choose Desk

Questions, answered.

Yes — that's the point. You get the full historical order book to replay a market and size fills against the liquidity that was actually there, plus an in-platform backtester (beta) to do it without exporting anything. Prefer your own stack? Pull whole-day Parquet and backtest locally.

Start backtesting Polymarket, Kalshi, and Limitless on real depth.

Free to start, no card. Upgrade when your strategy is ready for the full book.

Start free