polyorderbooks's picture
Upload README.md with huggingface_hub
30b9193 verified
|
Raw History Blame Contribute Delete
12.1 kB
metadata
pretty_name: Polymarket Sports Prices — Final 5 Minutes (250 ms History)
license: cc-by-4.0
language:
  - en
language_creators:
  - found
annotations_creators:
  - found
multilinguality:
  - monolingual
source_datasets:
  - original
task_categories:
  - time-series-forecasting
  - tabular-regression
  - tabular-classification
task_ids:
  - multivariate-time-series-forecasting
  - tabular-single-column-regression
modality:
  - tabular
  - timeseries
  - text
size_categories:
  - 100K<n<1M
format:
  - parquet
library:
  - datasets
  - pandas
  - polars
  - duckdb
configs:
  - config_name: default
    data_files: sports_prices.parquet
tags:
  - modality:tabular
  - modality:timeseries
  - modality:text
  - format:parquet
  - library:datasets
  - library:pandas
  - library:polars
  - library:duckdb
  - finance
  - financial-data
  - market-data
  - markets
  - polymarket
  - prediction-markets
  - prediction-market
  - event-markets
  - binary-markets
  - sports
  - sports-betting
  - sports-markets
  - prices
  - price
  - price-series
  - price-history
  - midpoint
  - implied-probability
  - probability
  - clob
  - high-frequency
  - tick-data
  - snapshots
  - quantitative-finance
  - backtesting
  - time-series
  - timeseries
  - forecasting
  - probabilistic-forecasting
  - calibration
  - market-efficiency
  - soccer
  - tennis
  - american-football
  - baseball
  - esports
  - polygon
  - erc1155

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

Polymarket Sports Prices — Final 5 Minutes (250 ms History)

The probability history for Polymarket sports markets, recorded on a 250 ms grid and written whenever the price changes, over the final five minutes of each token's price series. Every market has settled, so each row carries the winning outcome.

154,322 price points · 22,298 resolved markets · 40,885 tokens · 3.7 MB

Window: markets that resolved between 2026-10-18 13:56 and 2026-10-20 13:51 UTC. Points are anchored to each token's last price snapshot, so they span up to 14 days before settlement.

File Rows Markets Tokens Size
sports_prices.parquet 154,322 22,298 40,885 3.7 MB

Companions:


Coverage: this is a strict subset of the book universe

The L2 set covers 63,081 markets / 125,311 tokens. This price set covers 22,298 markets / 40,885 tokens — 35.4% of book markets and 32.6% of book tokens.

That gap is expected. A price point is written only when the midpoint or last trade changes. Many thin sports markets have a quoted book but never move in the final five minutes, and some tokens never receive a price snapshot at all. Absence here means "no price change", not "no market".

The two files also anchor on different last events: the books use max(captured_at) in token_orderbook_snapshots, the prices use max(captured_at) in token_price_snapshots. Those timestamps need not be equal. Do not assume a 1:1 join on (token_id, captured_at); joining on token_id and matching by time range (an as-of join) is the reliable approach.


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]. 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.

Null-price tick rows from the warehouse are excluded at build time; there is no imputation and no null price in the file.


Schema

One row per (token, price change).

Column Type Meaning
market_slug string Polymarket market identifier
question string Market question
sport string Derived sport label (see the catalog card)
series_slug string Series identifier, when present
series_title string Series display name
event_slug string Event identifier
event_title string Event display name
token_id string ERC-1155 token id for this outcome
outcome string Outcome display label
outcome_key string Platform key (yes/no, or o0:Name for props)
winner string Stored winning label for the market
is_winning_outcome bool Whether this token won
market_end_at timestamp[us, UTC] Scheduled market end (not the event time)
resolved_at timestamp[us, UTC] Actual settlement time
last_snapshot_at timestamp[us, UTC] max(captured_at) for this token's price series
captured_at timestamp[us, UTC] When the price was recorded, floored to a 250 ms bucket
seconds_to_market_end double market_end_at - captured_at (often negative)
seconds_to_last_snapshot double last_snapshot_at - captured_at, in [0, 300]
price double Midpoint (two-sided) or last trade price, a probability in [0, 1]

Prices are probabilities in [0, 1]. The panel is centred: median 0.500, mean 0.498, min 0.001, max 0.999. Extremes are common: 3.19% of rows are ≤ 0.01 and 6.47% are ≥ 0.99.


Loading

import pandas as pd

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

# the last 30 seconds of each token's price series
final = df[df.seconds_to_last_snapshot <= 30]

# mean price path by time-to-last-snapshot
df.groupby("seconds_to_last_snapshot").price.mean()

# join the catalog for labels
catalog = pd.read_parquet("sports_markets.parquet")
df.merge(catalog[["market_slug", "sport", "event_title"]], on="market_slug")

With DuckDB:

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

As-of join to the books (illustrative, one row per book snapshot):

SELECT b.market_slug, b.token_id, b.captured_at AS book_at,
       (SELECT p.price
        FROM read_parquet('sports_prices.parquet') p
        WHERE p.token_id = b.token_id AND p.captured_at <= b.captured_at
        ORDER BY p.captured_at DESC LIMIT 1) AS last_price
FROM read_parquet('sports_books.parquet') b
LIMIT 1000;

How the data was captured

The same websocket collector that powers the L2 dataset writes a price point whenever a token's midpoint or last trade changes. Points are sparse: the median gap between consecutive points within a token is 5.75 s, the 90th percentile is 66 s, the 99th is 231 s, and the longest is 300 s (the window boundary). Every captured_at sits exactly on the 250 ms grid.

The series is thin: median 1 point per token in the window, mean 3.77, max 243. The final-five-minute window frequently contains a single observation, because the price sat still.

Sub-second captured_at values are persisted from 2026-09-06 05:45:58 UTC (OTTER_SNAPSHOTS_BUCKET_MILLIS=250); every row here is on that grid.


Known properties, disclosed rather than cleaned

No null prices. Every row has a price in [0, 1]. The warehouse marks no-change rows with null, and those are filtered out.

Extremes are common and sticky. 3.19% of rows sit at ≤ 0.01 and 6.47% at ≥ 0.99. Prices pin to an extreme as a market resolves; once one side is decided the midpoint stops moving, which is also why many tokens have a single point.

Most tokens have one point. The median row count per token is 1, and the mean is 3.77. This is a sparse event series, not a dense grid. If you need a regular panel, resample onto the 250 ms grid and carry the last price forward.

The price and book anchors differ. last_snapshot_at here is the last price change, not the last book snapshot. The two can be minutes apart, so exact timestamp joins are unreliable. Use an as-of/range join on token_id.

market_end_at is the scheduled market end, not the settlement time. Markets stay open until they are resolved, so the last price usually comes after it. Use resolved_at for settlement or seconds_to_last_snapshot for the final minutes of trading.

Winner labels can be unresolved. As in the L2 set, a small number of markets store a winner that matches neither outcome, so is_winning_outcome is false on both tokens. Do not treat all-false as "no winner".


Verifying the data yourself

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

len(df)                                             # 154,322
df.market_slug.nunique()                            # 22,298
df.token_id.nunique()                               # 40,885
df.price.isna().sum()                               # 0
df.price.between(0, 1).all()                        # True
df.seconds_to_last_snapshot.between(0, 300).all()   # True
df.price.median()                                   # 0.500
df.groupby("token_id").size().median()              # 1.0

The build-time validator checked, on all 154,322 rows: no null price; price ∈ [0, 1]; seconds_to_last_snapshot ∈ [0, 300]; last_snapshot_at constant per token; captured_at <= last_snapshot_at; every captured_at on the 250 ms grid; is_winning_outcome constant per token; at most one winning token per market; and captured_at strictly increasing within each token. All passed.


Citation

@dataset{polyorderbooks_sports_250ms_price,
  title     = {Polymarket Sports Prices — Final 5 Minutes (250 ms History)},
  author    = {PolyOrderbooks},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/polyorderbooks/polymarket-sports-250ms-price}
}

Licence

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


Related resources


Contact


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.