---
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](https://polymarket.com)
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](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

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

### Build a per-token feature frame

```r
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

```r
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

```python
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](https://creativecommons.org/licenses/by/4.0/). Please cite
both this release and Jon Becker's upstream repository.

## Citation

```bibtex
@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}}
}
```