polyorderbooks/polymarket-crypto-5min-l2

Polymarket Crypto 5-Minute Markets — 1-Second L2 Order Books

Full bid and ask ladders, captured once per second, for Polymarket's five-minute crypto up/down markets. Every market in here has already resolved, so each row carries the winning outcome.

The interesting part of these markets is the last few minutes, so that is what this covers: the window from market open to settlement, for both outcome tokens.

How this differs from other Polymarket datasets

Several Polymarket order book datasets exist on the Hub. The differences that matter for microstructure work:

	Typical	This dataset
Snapshot interval	10 seconds	1 second
Ladder depth	top 10 levels	the full ladder — median 39 bid levels
Winning outcome	sometimes	on every row
Citable	no	DOI 10.5281/zenodo.22084114
Known defects	not stated	crossed and one-sided rates published

A ten-second interval is not a smaller version of one-second data. A five-minute contract gets 30 observations instead of 300, and the final ten seconds — where 94% of snapshots have an empty side — collapse to one.

Top-of-ten is likewise not a smaller version of the full book. It is enough for spread, and not enough for the cost of an order that walks past level ten.

A larger version, with three contract lengths

This repository holds the 5-minute contracts. The full research release adds 15-minute and 4-hour contracts — 897,192 snapshots across 805 markets — and carries a DOI so it can be cited in a paper:

https://doi.org/10.5281/zenodo.22084114

Same schema, same capture, same licence. Use that one if you want scale or a citation; use this one if you want load_dataset and 5-minute markets.

What is in it

Rows	158,745
Resolved markets	352
Outcome tokens	704
Coins	BTC, ETH, SOL, XRP, BNB, DOGE, HYPE, ZEC
Window	2026-08-23 09:10 to 12:50 UTC
Capture interval	1 second, median gap 1.0s
Ladder depth	median 96 levels per row, max 168
Licence	CC BY 4.0

One Parquet file per coin. Load one, or all of them.

import duckdb

con = duckdb.connect()
df = con.execute("""
    SELECT * FROM read_parquet('btc.parquet')
    WHERE seconds_to_close < 60
""").df()

from datasets import load_dataset

ds = load_dataset("polyorderbooks/polymarket-crypto-5min-l2", split="train")

Schema

Column	Type	Notes
market_slug	string	e.g. btc-updown-5m-1787478600
coin	string	btc, eth, sol, xrp, bnb, doge, hype, zec
token_id	string	Polymarket CLOB token, one per outcome
outcome	string	Up or Down
winner	string	yes or no — which side the market settled on
is_winning_outcome	bool	whether this row's token was the winner
market_end_at	timestamp	settlement time, UTC
captured_at	timestamp	when this snapshot was taken, UTC
seconds_to_close	double	market_end_at - captured_at, so it counts down
bid_prices	double[]	descending, best first
bid_sizes	double[]	aligned with bid_prices
ask_prices	double[]	ascending, best first
ask_sizes	double[]	aligned with ask_prices
best_bid	double	bid_prices[0], null if no bids
best_ask	double	ask_prices[0], null if no asks
crossed	bool	best_bid >= best_ask — see below

Two things you will notice immediately

Both are properties of the data, and both are disclosed here rather than left for you to discover.

One side of the book empties out near settlement

As a binary market resolves, nobody offers the losing side and nobody bids the winning one. By the final minute, 78.9% of rows have an empty bid or ask side. This is real market behaviour, not missing data, but it will break any code that assumes two-sided books.

Seconds to close	Rows	One side empty
240–300	29,859	0.0%
180–240	30,683	0.5%
120–180	28,557	3.4%
60–120	27,144	19.8%
0–60	24,897	78.9%

3.078% of rows are crossed

A crossed book has a bid at or above the best ask, which cannot happen in a real order book. These rows are kept and flagged, not silently dropped, because knowing the rate is more useful than a filtered file that looks perfect.

Seconds to close	Crossed or touching
240–300	3.8%
180–240	4.4%
120–180	3.3%
60–120	2.9%
0–60	1.4%

Filter them if you need strictly consistent books:

clean = df[~df.crossed]

Crossing peaks mid-market and falls towards settlement, largely because a book with only one side cannot be crossed.

How it was captured

A websocket collector subscribed to every market, writing a row whenever the book changed. Polymarket's feed carries roughly 24,000 events a second across all markets, and at that rate any collector drops messages — a dropped cancellation leaves a level in the book that the venue has already removed.

To bound that, the collector re-reads the full book from Polymarket's REST API every 60 seconds and replaces its in-memory state. Anything that drifted since the last read is corrected then.

This matters because the alternative — reconstructing books by replaying a delta stream after the fact — does not work. Replaying a public Polymarket archive's own deltas against its own snapshots diverged at 67.8% of 381,093 checkpoints, and 6.4% of the reconstructions were crossed. There is no way to re-read a book that closed months ago, which is why order book depth has to be recorded live or not at all.

Verifying it yourself

The dataset ships with the flag, but do not take the number on trust:

import duckdb

duckdb.sql("""
    SELECT count(*) FILTER (WHERE best_bid >= best_ask) * 100.0 / count(*) AS pct_crossed
    FROM read_parquet('*.parquet')
    WHERE best_bid IS NOT NULL AND best_ask IS NOT NULL
""").show()

Run the same check on any order book dataset you are offered.

What it is good for

• Slippage and fill-cost modelling against real ladders
• Liquidity behaviour into a known resolution
• Execution-aware backtests where the outcome is already known
• Studying how depth migrates to the winning side before settlement

What it is not

Not every Polymarket market — crypto up/down only. Not a live feed. Not sufficient on its own for strategy research: less than four hours of markets. Larger windows and other market types are available through the API this was exported from.

Source

Captured and published by PolyOrderbooks. Not affiliated with Polymarket.

If you use this in published work, a citation is appreciated but not required under CC BY 4.0.

---

About PolyOrderbooks

We capture Polymarket order book depth at 1-second resolution and serve it over a REST API. Polymarket archives no order book history of its own — its /book endpoint returns the current state and nothing stores it — so this data exists only because it was recorded while the markets traded.

API	polyorderbooks.com
Documentation	docs.polyorderbooks.com — endpoints, parameters, response shapes
Free tier	polyorderbooks.com/signup — 1-second resolution, no card
All open datasets	polyorderbooks.com/datasets
Python client	pip install polyorderbooks
MCP server	@polyorderbooks/mcp-server — for Claude, Cursor and other MCP clients

The citable release

For a paper, cite the DOI-carrying release rather than this repository — 897,192 snapshots across 805 resolved markets and three contract lengths, same schema, same licence:

PolyOrderbooks. (2026). Polymarket Crypto Up/Down Order Books: 1-Second L2 Depth Across Three Contract Lengths [Dataset]. Zenodo. https://doi.org/10.5281/zenodo.22084114

Questions

Open a discussion on this dataset for anything about the data itself.

For the API — a window these files do not reach, a coverage question, a plan — email contact@polyorderbooks.com. Corrections to the data are welcome and taken seriously; if you find something wrong here we would rather know.

Not affiliated with, endorsed by, or connected to Polymarket.