polyorderbooks/polymarket-sports-markets

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

Polymarket Sports Markets — Full Catalog

One row per Polymarket sports market known to the warehouse on 2026-10-20: the question, its event and series, the derived sport, the platform's tags, volume and liquidity, resolution state, and every outcome token.

1,473,954 markets · 1,222,893 resolved · 85,011 events · 182 MB

This is the join table for the sports order-book and price datasets. It covers all sports markets in the warehouse, including markets that opened or resolved before book capture began on 2026-09-08, so it is deliberately broader than the two time-series files.

File	Rows	Resolved	Size
sports_markets.parquet	1,473,954	1,222,893	182 MB

Companions:

• polyorderbooks/polymarket-sports-250ms-l2 — final-5-minute L2 books for markets resolved in a 2-day window.
• polyorderbooks/polymarket-sports-250ms-price — the matching price series.

Join on market_slug and token_ids / token_id.

---

What is in here

Markets	1,473,954
Resolved	1,222,893 (83.0%)
With a resolved winning token	1,222,893 (100% of resolved)
Events	85,011
Series	268
Outcomes per market	2 for 1,473,950 markets; 3 for 4
Market end dates	2026-08-11 to 2029-01-01 UTC
Sports	36 distinct labels, led by Soccer (842,043), Tennis (169,601), American Football (168,644), Baseball (114,611), Table Tennis (75,178), Esports (58,055)

The catalog is sports-only: Polymarket's market_type and crypto_asset columns are empty throughout this warehouse, and every market carries a sports event or series. It is not a filtered subset of a larger mixed database.

---

Schema

Column	Type	Meaning
market_slug	string	Polymarket market identifier (unique in this file)
question	string	Market question as shown by Polymarket
sport	string	Derived sport label (see below)
series_slug	string	Series identifier, when the event belongs to a series
series_title	string	Series display name
event_slug	string	Event identifier
event_title	string	Event display name
tags	list	Platform tags, from the event, else the series
status	string	Raw platform status string
is_resolved	bool	Whether the market has settled
winner	string	Stored winning label: a team/player name, Over/Under, or yes/no
winning_token_id	string	Outcome token matching winner, or null
volume	double	Platform lifetime volume, as stored (not normalised)
liquidity	double	Platform liquidity, as stored (not normalised)
market_end_at	timestamp[us, UTC]	Administrative market end/deadline
resolved_at	timestamp[us, UTC]	Actual settlement time
n_outcomes	int32	Number of outcomes
outcome_names	list	Outcome display labels, in outcome_index order
outcome_keys	list	Platform outcome keys (yes/no, or o0:Name for props)
token_ids	list	ERC-1155 token ids, aligned with the outcome arrays

market_end_at is the scheduled market end, not the settlement time. It usually precedes resolved_at by hours, but the lag ranges from days before to weeks after, and for long-dated markets it can be in the future. Use resolved_at for settlement, and the book/price timestamps for the actual end of quoting.

winner is a label, not an index. Resolve it with lower(winner) = lower(outcome_name) or lower(winner) = lower(outcome_key); winning_token_id was built with exactly that rule and is populated for every resolved market.

---

Sport labels

sport is derived from the event's tags (falling back to the series' tags) with this priority:

Soccer (Soccer, football) · Basketball · Tennis · Table Tennis · Baseball (baseball, MLB) · American Football (NFL, NFL (All), CFB, CFB (All)) · Ice Hockey (Hockey, NHL) · Esports · Cricket · Volleyball · Rugby · Handball · Golf · Darts · Boxing · MMA (UFC) · Lacrosse · Pickleball (Pickleball, MLP)

If none of those tags is present, the first non-generic tag is used. That fallback is intentionally transparent rather than clever: it can surface league or competition names instead of a sport (for example Serie A, CFL, Formula 1, Nascar), which is why the file has 34 labels rather than 18. The generic tags Sports, Games, Recurring, Hide From New and Season stats are skipped. Treat sport as a convenient grouping, not a controlled taxonomy.

---

Loading

import pandas as pd

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

# resolved soccer markets with a winner
soccer = df[(df.sport == "Soccer") & df.is_resolved]

# outcomes and tokens for one market
row = df[df.market_slug == "col-twe-thu-2026-10-15-shots-justin-roth-90076438-gte1"].iloc[0]
row.outcome_names, row.token_ids

# the winning token, when the label resolved
row.winning_token_id

With DuckDB:

SELECT sport, count(*) AS markets,
       avg(is_resolved::int) AS resolved_share,
       sum(volume) AS volume
FROM read_parquet('sports_markets.parquet')
GROUP BY 1 ORDER BY markets DESC;

Join the books or prices:

SELECT b.market_slug, m.sport, count(*) AS rows
FROM read_parquet('sports_books.parquet') b
JOIN read_parquet('sports_markets.parquet') m USING (market_slug)
GROUP BY 1, 2 ORDER BY rows DESC;

---

How it was built

The catalog is exported directly from the sports warehouse (markets, market_outcomes, events, series) with one COPY … TO STDOUT and converted to Parquet in the same run. Nothing is imputed or dropped: markets without an event, series, tags or volume are retained with nulls.

The platform's own tags table was empty at build time. Tags therefore come from the events.tags and series.tags arrays, which are the maintained source. A market with neither has an empty tags list; its sport then falls back to Other, and such cases are visible rather than silently relabelled.

Outcome arrays are built with array_agg(… ORDER BY outcome_index), so they are positionally aligned with each other. winning_token_id is the token whose outcome_name or outcome_key matches the stored winner, case-insensitively.

---

Known properties, disclosed rather than cleaned

Volume and liquidity are raw platform values. They are not adjusted for token decimals, not USD-normalised across market types, and may be stale, zero or null. Do not compare them across venues without checking the platform's definitions.

Four markets have three outcomes. All other 1,473,950 are binary. The schema carries arrays precisely so the rare non-binary market does not break consumers; do not assume exactly two outcomes when iterating.

A winner label can fail to match an outcome. The stored label is usually an outcome name or key, but a small number of historical markets store a label that matches neither (for example a team name that was later renamed). Those markets are resolved but have winning_token_id = null. The order-book set carries is_winning_outcome = false on both tokens for the same reason; this is 0.6% of markets there.

market_end_at is not the event time. It is the scheduled market end, and it usually falls before the actual end of quoting: in the companion order-book set 91.5% of rows are captured after end_at, with a median gap of 4.0 hours, because markets stay open until they are resolved. The lag can run from days before the final book to weeks after. Use resolved_at for settlement and the book/price timestamps for in-play timing.

The catalog is a snapshot. It reflects the warehouse on 2026-10-20. Markets created or resolved after that date are not present; counts will differ from a later export.

---

Verifying the data yourself

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

len(df)                                            # 1,473,954
df.market_slug.is_unique                           # True
int(df.is_resolved.sum())                          # 1,222,893
df.n_outcomes.value_counts().to_dict()             # {2: 1473950, 3: 4}
(df.outcome_names.str.len() == df.n_outcomes).all()  # True
(df.token_ids.str.len() <= df.n_outcomes).all()    # True
df.loc[df.is_resolved, "winning_token_id"].notna().all()  # True
(df[["volume", "liquidity"]].fillna(0) >= 0).all().all()  # True

The build-time validator checked, on all 1,473,954 rows: unique market_slug; outcome array lengths equal to n_outcomes; no duplicate token ids within a market; winning_token_id (when present) is one of token_ids; every resolved market has resolved_at; and volume/liquidity are non-negative. All passed.

---

Citation

@dataset{polyorderbooks_sports_markets,
  title     = {Polymarket Sports Markets — Full Catalog},
  author    = {PolyOrderbooks},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/polyorderbooks/polymarket-sports-markets}
}

---

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
Sports L2 books	huggingface.co/datasets/polyorderbooks/polymarket-sports-250ms-l2
Sports prices	huggingface.co/datasets/polyorderbooks/polymarket-sports-250ms-price

---

Contact

• Email — [email protected]
• 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.