Hugging Face's logo

Datasets:
smf-ulm
/
polymarket-quant-bench

Tasks:
Other
Modalities:
Tabular
Text
Formats:
parquet
Languages:
English
Size:
10M - 100M
Tags:
polymarket
prediction-markets
blockchain
polygon
market-microstructure
ohlcv
Libraries:
Datasets
Dask
Polars
License:
Dataset card Data Studio Files
xet
 Community
1
polymarket-quant-bench / README.md
smf-ulm's picture
smf-ulm
Update README.md
b85406f verified
preview code
|
raw
history blame contribute delete
9.35 kB
metadata 
license: cc-by-4.0
language:
  - en
pretty_name: Polymarket Quant Bench — OHLCV bars for high-liquidity resolved markets
size_categories:
  - 10M<n<100M
task_categories:
  - other
tags:
  - polymarket
  - prediction-markets
  - blockchain
  - polygon
  - market-microstructure
  - ohlcv
  - backtesting
  - quantitative-finance
configs:
  - config_name: markets
    data_files:
      - split: train
        path: polymarket/markets/markets_*.parquet
  - config_name: bars_hourly
    data_files:
      - split: train
        path: polymarket/bars_hourly/bars_*.parquet
  - config_name: bars_daily
    data_files:
      - split: train
        path: polymarket/bars_daily/bars_*.parquet

Polymarket Quant Bench — OHLCV bars for high-liquidity resolved markets

A teaching-grade derivative of the Polymarket on-chain trade history, designed for indicator-engineering and walk-forward back-testing assignments. Polymarket is a decentralised prediction market on the Polygon blockchain; binary contracts settle to one USDC if the underlying event occurs and zero otherwise.

This release replaces the per-trade fill stream of the upstream dataset with per-token OHLCV bars at hourly and daily resolution, restricted to high-liquidity resolved markets so every market has a known outcome for P&L scoring and enough depth for rolling indicators.

Contents

File group Rows Description
polymarket/markets/markets_*.parquet 36,831 One row per resolved market with cumulative volume >= $100,000 and >= 200 on-chain trade fills. Full upstream schema plus a category column.
polymarket/bars_hourly/bars_*.parquet 12,655,266 One row per (token_id, calendar hour) with OHLCV plus trade and direction counts.
polymarket/bars_daily/bars_*.parquet 1,462,282 One row per (token_id, calendar day), aggregated from the hourly bars.

Each file group is chunked into 10,000-row parquet shards.

Provenance and attribution

The raw market metadata and trade events were collected and released by Jon Becker at https://github.com/jon-becker/prediction-market-analysis. This dataset is a derivative: market metadata is restricted to the filter described below and trades are aggregated into OHLCV bars. If you use this dataset, please also cite Jon Becker's release.

How prices are computed

Each on-chain OrderFilled event swaps USDC for an outcome token (or vice versa). Both assets use 6 decimals, so the raw atomic ratio of USDC to token quantity is already a dimensionless probability in [0, 1] -- the price the Polymarket UI shows in cents-per-dollar.

For each trade t:

if t.maker_asset_id == '0':       # maker delivered USDC, taker delivered tokens
    usdc_amount  = t.maker_amount
    token_amount = t.taker_amount
    taker_is_seller = True            # taker handed over tokens -> sold
else:                                  # maker delivered tokens, taker delivered USDC
    usdc_amount  = t.taker_amount
    token_amount = t.maker_amount
    taker_is_seller = False           # taker handed over USDC -> bought

price       = usdc_amount / token_amount             # in [0, 1]
volume_usd  = usdc_amount / 1e6                      # in USD
signed_size = (-1 if taker_is_seller else +1) * token_amount / 1e6

price is the implied probability of the outcome the token represents.

How bars are aggregated

For each (token_id, bar_period) group:

Field Formula
open price of the first trade in the bar (ordered by block_number, log_index)
high MAX(price)
low MIN(price)
close price of the last trade
vwap SUM(price * volume_usd) / SUM(volume_usd)
volume_usd SUM(volume_usd)
n_trades total fills in the bar
n_buys / n_sells fills where the taker bought / sold outcome tokens

Bars are emitted only when at least one trade occurred in the period (sparse representation). Use tidyr::fill() or data.table::nafill() to forward-fill if a dense series is required by your indicator.

The hour boundary is defined by block_number // 1800 (Polygon ~2 s per block; 1 800 blocks = 1 hour). Wall-clock period_start is attached post-aggregation by looking up the first block of each hour in the blocks-timestamp index and extrapolating forward at 2 seconds per block.

Bars are emitted per token rather than per market. A Polymarket market has two complementary tokens (YES and NO); the markets table exposes both via clob_token_ids. If you want a single market-level mid-price series, pair the two token series yourself.

Filter applied to upstream markets

A market is included iff all of the following hold:

  1. The market is resolved (one outcome price closed above 0.99 in the upstream snapshot).
  2. Cumulative trading volume >= $100,000 -- removes the long tail of dust markets.
  3. At least 200 on-chain trade fills -- ensures enough depth to compute rolling indicators meaningfully.

This intentionally trades coverage for per-market depth. About 36,831 markets remain out of the ~409 k in the upstream snapshot.

Schemas

markets/markets_*.parquet

Upstream columns from Jon Becker's release plus category. Notable ones:

column type description
id string Polymarket market id (primary key).
condition_id string Parent CTF condition id.
question string The question prompt.
slug string URL slug.
outcomes string JSON outcome labels, e.g. ["Yes","No"].
outcome_prices string JSON outcome prices at snapshot time. The winning outcome closes near 1.
clob_token_ids string JSON [yes_token_id, no_token_id]. Use to join bars to a market.
volume double Cumulative USDC traded.
liquidity double Snapshot depth.
end_date timestamp Useful as resolution_date for held-out cohorts.
created_at timestamp Market creation.
category string Best-effort topic label. Use cautiously.

bars_hourly/bars_*.parquet and bars_daily/bars_*.parquet

column type description
token_id string CTF outcome-token id.
period_start timestamp Bar start, UTC.
period_end timestamp period_start + 1 hour (or + 1 day).
open / high / low / close double Implied probability in [0, 1].
vwap double Volume-weighted average price.
volume_usd double Total USDC traded in the bar.
n_trades int64 Number of OrderFilled events in the bar.
n_buys / n_sells int64 Taker-side direction counts.

Quick start in R

Setup 

install.packages(c("arrow", "dplyr", "jsonlite", "lubridate", "slider",
                   "TTR", "PerformanceAnalytics", "glmnet"))
library(arrow)
library(dplyr)
library(slider)

Build a per-token feature frame 

markets <- open_dataset("polymarket/markets/")
bars    <- open_dataset("polymarket/bars_hourly/")

# Pick a large market and grab its YES token id.
m <- markets %>% filter(volume > 1e6) %>% head(1) %>% collect()
yes_token_id <- jsonlite::fromJSON(m$clob_token_ids)[1]

ts <- bars %>%
  filter(token_id == yes_token_id) %>%
  collect() %>%
  arrange(period_start) %>%
  mutate(
    sma_24h = slide_dbl(close, mean, .before = 24, .complete = TRUE),
    ema_24h = TTR::EMA(close, n = 24),
    ret_1h  = log(close / lag(close)),
    rsi_14  = TTR::RSI(close, n = 14),
    boll    = TTR::BBands(close, n = 20, sd = 2)[, "pctB"],
    days_to_resolution = as.numeric(difftime(m$end_date, period_start, units = "days"))
  )

Walk-forward elastic net + back-test 

library(glmnet)
library(PerformanceAnalytics)

fit    <- cv.glmnet(X_train, y_train, alpha = 0.5)
signal <- predict(fit, newx = X_test, s = "lambda.min")

# 1% per-trade cost, threshold-based position.
pos <- sign(signal) * (abs(signal) > threshold)
ret <- pos * y_test - 0.01 * abs(diff(c(0, pos)))
charts.PerformanceSummary(ret)

Streaming via the HuggingFace datasets library 

from datasets import load_dataset
markets     = load_dataset("smf-ulm/polymarket-quant-bench", "markets",     split="train")
bars_hourly = load_dataset("smf-ulm/polymarket-quant-bench", "bars_hourly", split="train", streaming=True)
bars_daily  = load_dataset("smf-ulm/polymarket-quant-bench", "bars_daily",  split="train")

License

CC-BY-4.0. Please cite both this release and Jon Becker's upstream repository.

Citation 

@misc{polymarket_quant_bench_2026,
  author       = {Padmaperuma, Oliver},
  title        = {Polymarket Quant Bench: OHLCV bars for high-liquidity resolved markets},
  year         = {2026},
  howpublished = {HuggingFace dataset, smf-ulm/polymarket-quant-bench},
  note         = {Derived from Jon Becker's polymarket-data release at
                  \url{https://github.com/jbecker19/polymarket-data}}
}