Joseph3222/polymarket-orderbook

Polymarket Orderbook Archive

Tick-by-tick Polymarket CLOB (central limit order book) event stream for every market, 2026-02-22 → 2026-08-10, plus a query-ready 1-minute full-depth L2 snapshot rollup derived from it. Parquet, partitioned by UTC day, one file per day.

Config	What	Days	Size	Typical file
orderbook	raw WebSocket event stream (book, price_change, last_trade_price, tick_size_change)	164	~1.18 TB	8 GB (max 14 GB)
orderbook_1min	full L2 book at the end of every minute an asset had activity	164	~192 GB	1.2 GB (max 2.5 GB)

Layout: <config>/date=YYYY-MM-DD/data_0.parquet.

Coverage and known gaps

• Days: 2026-02-22 through 2026-08-10. 2026-06-12 → 2026-06-17 are absent (ingest box outage). 2026-08-10 is partial (only the first hours; the source archive stopped publishing that morning and has not resumed).
• Two source eras. 2026-02-22 → 2026-04-12 comes from pmxt's v1 archive, which only covered roughly half of all markets (incomplete WebSocket subscriptions). 2026-04-13 onward comes from the v2 archive with full market coverage. The source_archive column says which. In the Apr 13-16 overlap the v2 feed was preferred.
• Missing hours inside a day. Roughly 5-15% of the source's hourly files were unreadable (404 or corrupt footer) and were skipped, so a day can have an hour or two of silence. orderbook_1min carries the last known book across such gaps only within a day; do not assume every minute is present.
• Sub-second ordering. Source timestamps are 1-second resolution. event_ts_ms is millisecond-precise, but events inside the same millisecond keep file order, which is not guaranteed to be the true exchange order. This produced ~10-15% crossed books at end-of-day in naive replays; treat crossed books as noise.

Source and attribution

The raw stream mirrors the free hourly archive published by pmxt (v1 at r2.pmxt.dev, v2 at r2v2.pmxt.dev), which is licensed CC BY 4.0. This dataset normalizes both eras into one schema and adds the 1-minute rollup; it is released under the same license. Please credit pmxt when you use it.

Schema: orderbook

One row per CLOB WebSocket event. Reconstruct the book at any moment T by taking the most recent book event for the asset before T and applying every price_change between it and T.

column	type	meaning
event_ts	UBIGINT	Unix epoch seconds UTC (floor of source timestamp).
event_ts_ms	UBIGINT	Unix epoch milliseconds UTC. Use this for ordering.
condition_id	VARCHAR	Market id, 0x + 64 lowercase hex chars.
asset_id	VARCHAR	Outcome token id (77-digit ERC-1155 id). One market has two.
outcome	VARCHAR	YES / NO for v1 rows; NULL for v2 rows (resolve via Gamma /markets?clob_token_ids=).
event_type	VARCHAR	book / price_change / last_trade_price / tick_size_change.
bids_json	VARCHAR	[[price, size], ...] as strings. Only on book events. Not sorted; sort at read time.
asks_json	VARCHAR	Same shape. Only on book events.
price	DOUBLE	Price in [0, 1]. On price_change and last_trade_price.
size	DOUBLE	On price_change: the level's new absolute total (0 = level removed), not a delta. On last_trade_price: trade size.
side	VARCHAR	BUY (bid side) / SELL (ask side).
best_bid	DOUBLE	Source-emitted top of book at event time (may be NULL).
best_ask	DOUBLE	Source-emitted lowest ask at event time (may be NULL).
transaction_hash	VARCHAR	Only on last_trade_price; 0x + 64 hex.
old_tick_size	DOUBLE	Only on tick_size_change.
new_tick_size	DOUBLE	Only on tick_size_change.
source_archive	VARCHAR	v1 or v2.
date	DATE	Partition column, UTC date of event_ts.

Reconstruction semantics match Polymarket's reference client (nevuamarkets/poly-websockets OrderBookCache.ts): a book event replaces the asset's whole book; price_change with size > 0 sets that level's total; size == 0 removes it; last_trade_price does not modify the book (a follow-up price_change does).

Event frequency differs by era: v1 emitted a book snapshot about every 10 minutes per token; v2 emits one only on subscription start or resync (a few per asset per day), so a v2 reconstruction may replay hundreds of price_change rows after the last book.

Schema: orderbook_1min

One row per (asset_id, minute) for every minute the asset had at least one event, holding the full-depth book at the end of that minute. Minutes with no events have no row; carry the previous snapshot forward.

column	type	meaning
asset_id	VARCHAR	Outcome token id.
condition_id	VARCHAR	Market id.
minute_ts	BIGINT	Unix epoch seconds UTC, floored to the minute.
bids_json	VARCHAR	[[price, size], ...], sorted descending by price, native floats.
asks_json	VARCHAR	[[price, size], ...], sorted ascending by price.
n_bid_levels	UINTEGER	Bid price levels.
n_ask_levels	UINTEGER	Ask price levels.
best_bid	DOUBLE	NULL if no bids.
best_ask	DOUBLE	NULL if no asks.
mid	DOUBLE	(best_bid + best_ask) / 2; NULL if either side empty.
spread	DOUBLE	best_ask - best_bid; NULL if either side empty.
date	DATE	Partition column.

How to read it

DuckDB (reads straight from the Hub; a token is optional and only raises the request rate limit):

INSTALL httpfs; LOAD httpfs;
-- CREATE SECRET hf (TYPE huggingface, TOKEN 'hf_...');   -- optional

SELECT minute_ts, best_bid, best_ask, spread
FROM read_parquet('hf://datasets/Joseph3222/polymarket-orderbook/orderbook_1min/date=2026-05-01/data_0.parquet')
WHERE asset_id = '<token id>'
ORDER BY minute_ts;

Whole-day scans are much faster if you download the file first than if you stream it through httpfs (the Hub serves many small range requests slowly):

from huggingface_hub import hf_hub_download
path = hf_hub_download("Joseph3222/polymarket-orderbook", "orderbook/date=2026-05-01/data_0.parquet", repo_type="dataset")
import duckdb; duckdb.sql(f"SELECT event_type, count(*) FROM '{path}' GROUP BY 1").show()

Joining to markets. asset_id is the CLOB token id and condition_id the market id used by Polymarket's public APIs. Gamma's https://gamma-api.polymarket.com/markets?clob_token_ids=<asset_id> returns the market row, including which outcome the token is (note the endpoint defaults to closed=false; query both states).

Provenance

Built by the polypipe ingest pipeline: hourly source files were validated (HTTP HEAD plus a PAR1 footer check), normalized with DuckDB into the schema above, and written one parquet per UTC day. The 1-minute rollup was produced by a Rust state machine replaying each day's events with the semantics described above. Moved from the pipeline's Cloudflare R2 lake to this repo on 2026-09-02.