polyorderbooks/polymarket-crypto-btc-5min-250ms-price

Website: polyorderbooks.com · GitHub: github.com/polyorderbookslabs · API: api.polyorderbooks.com · Docs: docs.polyorderbooks.com · Python SDK: pypi.org/project/polyorderbooks

Polymarket BTC 5-Minute Up/Down Prices: 250 ms History

The probability history for Polymarket's Bitcoin up/down markets at the 5-minute contract length, recorded on a 250 ms grid and written whenever the price changes. Every market has already settled, so each row carries the winning outcome.

359,790 price points · 862 resolved markets · 1,724 tokens · 2.3 MB

Capture window: 2026-10-03 16:15 to 2026-10-06 16:04 UTC (all 5-minute Bitcoin up/down markets that resolved in a ~3-day window). Coin: BTC only. Contract length: 5 minutes.

File	Rows	Markets	Tokens	Size
btc_prices.parquet	359,790	862	1,724	2.3 MB

This is the price companion to the order-book dataset polyorderbooks/polymarket-crypto-btc-5min-250ms-l2. Both cover the same market type on the same 250 ms grid and join on (market_slug, token_id, captured_at); this file drops the full ladders and keeps the single price series, which is ~4.8× smaller.

---

What "price" means here

price is the same value the live API serves as history: the midpoint of the best bid and best ask when both sides quote, otherwise the last trade price. It is a probability in [0, 1] and moves in one-cent ticks in practice (the warehouse stores six decimals). Because it is a midpoint, it is not a last-traded print — it updates whenever either side of the book moves.

Rows are sparse by design: a point is written only when the price changes. An unchanged price is not rewritten, so a gap longer than 250 ms means the price did not move, not that a sample is missing.

---

Schema

One row per (token, price change). Each market has two tokens, one per outcome.

Column	Type	Meaning
market_slug	string	Polymarket market identifier, e.g. btc-updown-5m-1791044100
coin	string	btc (this file is BTC only)
contract_length	string	5m
token_id	string	Polymarket ERC-1155 token id for this outcome
outcome	string	Outcome label, Up or Down
winner	string	The outcome that settled true, yes or no
is_winning_outcome	bool	Whether this token is the one that won
market_end_at	timestamp[us, UTC]	Settlement time
captured_at	timestamp[us, UTC]	When the price was recorded, floored to a 250 ms bucket
seconds_to_close	double	market_end_at - captured_at, in seconds (0–300)
price	double	Midpoint (two-sided) or last trade price, a probability in [0, 1]

Prices are probabilities in [0, 1]. Both tokens of every market are present. Rows split 49.9% / 50.1% between winning and losing outcomes, and the panel is centred: the median price is 0.500, the 1st percentile is 0.015 and the 99th is 0.985.

---

Loading

import pandas as pd

df = pd.read_parquet("btc_prices.parquet")

# the price 30 seconds before settlement
final = df[df.seconds_to_close <= 30]

# average price path by second-to-close
df.groupby("seconds_to_close").price.mean()

With DuckDB, without downloading the whole file:

SELECT (seconds_to_close // 30) * 30 AS band,
       count(*)                      AS rows,
       avg(price)                    AS mean_price,
       stddev(price)                 AS sd_price
FROM read_parquet('btc_prices.parquet')
GROUP BY 1 ORDER BY 1;

---

How the data was captured

The same websocket collector that powers the order-book dataset writes a price point whenever a token's midpoint or last trade changes. Points are sparse: in this file the median gap between consecutive points within a token is 0.500 s, the 90th percentile is 2.500 s, the 99th is 11.750 s and the longest gap is 178.5 s (a market that sat pinned at an extreme). Every captured_at sits exactly on the 250 ms grid (.000/.250/.500/.750) — verified on all 359,790 rows.

Because the price only moves when the book moves, the series is thinner than the L2 book: it averages 208.7 points per token (median 194, max 635) versus ~1,000 snapshots per token for the full ladders.

Polymarket's feed carries roughly 24,000 events per second across all markets, and the delta stream carries no sequence numbers, so a dropped message cannot be detected from the stream itself. The collector re-reads the full book from Polymarket's REST API every 60 seconds and replaces its in-memory state, which is what bounds drift in the derived price.

---

Known properties, disclosed rather than cleaned

No null prices. Every row has a price. The warehouse column is nullable (it marks rows where the price did not change), but every such row is filtered out at build time, so there is nothing to impute.

Extremes are common and sticky. 0.71% of rows sit at ≤ 0.01 and 0.74% at ≥ 0.99. Prices pin to an extreme as a market resolves, which is why the tail gaps above are long: once one side is effectively decided the midpoint stops moving, so no new point is written.

250 ms precision applies from 2026-09-06 onward. Production began persisting sub-second captured_at values on 2026-09-06 05:45:58 UTC (OTTER_SNAPSHOTS_BUCKET_MILLIS=250). This file was captured on 2026-10-03 to 2026-10-06, so every row benefits from it; there are no whole-second legacy rows mixed in.

Markets are the full population for the window — every BTC 5-minute up/down market that resolved between 2026-10-03 16:20 and 2026-10-06 16:05 UTC is here, not a sample.

---

Verifying the data yourself

Every claim above is reproducible from the file:

import pandas as pd
df = pd.read_parquet("btc_prices.parquet")

len(df)                                          # 359,790
df.market_slug.nunique()                         # 862
df.token_id.nunique()                            # 1,724
df.price.isna().sum()                            # 0
df.price.between(0, 1).all()                     # True
df.seconds_to_close.between(0, 300).all()        # True
df.is_winning_outcome.mean()                     # ≈ 0.499
df.groupby("token_id").is_winning_outcome.nunique().eq(1).all()  # True

The validator used at build time checked, on all 359,790 rows: no null price; price ∈ [0, 1]; seconds_to_close ∈ [0, 300]; every captured_at on the 250 ms grid; every market has both Up and Down and exactly two tokens; exactly one winning outcome per market; and captured_at strictly increasing within each token. All passed.

---

Citation

@dataset{polyorderbooks_btc_5min_250ms_price,
  title     = {Polymarket BTC 5-Minute Up/Down Prices: 250 ms History},
  author    = {PolyOrderbooks},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/polyorderbooks/polymarket-crypto-btc-5min-250ms-price}
}

Companion order-book dataset:

@dataset{polyorderbooks_btc_5min_250ms_l2,
  title     = {Polymarket BTC 5-Minute Up/Down Order Books: 250 ms L2 Depth},
  author    = {PolyOrderbooks},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/polyorderbooks/polymarket-crypto-btc-5min-250ms-l2}
}

---

Licence

Creative Commons Attribution 4.0 International (CC BY 4.0). Use it commercially, modify it, redistribute it — please cite it.

---

Related resources

Live API	polyorderbooks.com
API documentation	docs.polyorderbooks.com
OpenAPI specification	docs.polyorderbooks.com/openapi.json
Python client	pypi.org/project/polyorderbooks — pip install polyorderbooks
250 ms L2 companion	huggingface.co/datasets/polyorderbooks/polymarket-crypto-btc-5min-250ms-l2
1-second L2 dataset	huggingface.co/datasets/polyorderbooks/polymarket-crypto-5min-l2

The live API covers considerably more than this dataset: all Polymarket crypto markets including price thresholds and event questions, with history beyond the capture window here. A free tier queries at the same 250 ms resolution.

---

Contact

• Email — contact@polyorderbooks.com
• X — @polyorderbooks
• Issues — github.com/polyorderbookslabs/polyorderbooks-python/issues

---

Disclaimer

Not affiliated with, endorsed by, or connected to Polymarket. Market data is reproduced for research purposes. Nothing here is financial advice, and past market behaviour does not predict future outcomes.