README.md

---
license: cc-by-4.0
task_categories:
- time-series-forecasting
- tabular-classification
language:
- en
tags:
- forecasting
- prediction-markets
- polymarket
- probability-calibration
- crowd-belief
pretty_name: Polymarket Resolved Events — Crowd-Belief & Volume Trajectories
size_categories:
- 10K<n<100K
configs:
- config_name: default
  data_files: full.jsonl
---

# Polymarket Resolved Events — Crowd-Belief & Volume Trajectories

**~29,600 fully-resolved Polymarket events, each with its complete daily crowd-belief
probability trajectory, daily trading volume, and ground-truth outcome — crawled directly
from the Polymarket APIs.**

The data is provided as-is from the crawl: every event whose full tradeable lifetime falls
inside the collection window is included, with no quality/liquidity/signal selection
applied. You can apply your own filtering downstream.

## What the dataset contains

- **One file, `full.jsonl`** — JSON Lines, one event per line (~29,600 lines).
- Every event is **resolved** (`ground_truth_status == "resolved"`): the outcome is known,
  so it can be used for supervised forecasting and backtesting.
- Each record bundles four things for one event:
  1. **Event metadata** — title, description, dates, tags, volume.
  2. **Per-option markets** — the underlying binary YES/NO books (1 for a binary event,
     K for a multi-outcome event).
  3. **Daily crowd-belief trajectory** — the market-implied probability for each day of
     the event's tradeable life.
  4. **Daily trading volume** — trades, share volume, and notional per day, aligned to
     the same daily grid.

### Coverage
- **Time window:** events whose entire tradeable lifetime — market open (`start_date`)
  through on-chain resolution (`closed_time`) — falls inside `[2025-06-01, 2026-06-01)` (UTC).
- **Event types:**
  - `binary` — a single YES/NO market.
  - `multi_neg_risk` — a multi-outcome event modeled as K mutually-exclusive, linked
    binary YES/NO books ("neg-risk").
- **Domains:** primarily sports, games, and weather (soccer, cricket, daily temperature),
  plus politics, finance, and others. See each record's `tags`. The domain mix reflects
  Polymarket's activity and is not balanced.

## How it was collected

Crawled from the public Polymarket APIs in four stages:

1. **Metadata** — `GET gamma-api.polymarket.com/events` (`closed=true`). Enumerate resolved
   events; derive ground truth from each market's final `outcomePrices` (YES wins if the
   final price ≥ 0.99).
2. **Window-fit** — keep only events whose full lifetime (`start_date` → `closed_time`)
   lies inside the collection window.
3. **Crowd belief** — `GET clob.polymarket.com/prices-history` (`fidelity=60`),
   re-aggregated to UTC days, to build each option's daily probability series.
4. **Daily volume** — Goldsky Polymarket "orderbook-subgraph" GraphQL (fallback:
   `data-api.polymarket.com/trades`), aggregated per day and aligned to the belief grid.

## Record schema

Each line is one event. Fields:

### Event metadata
| Field | Type | Meaning |
|---|---|---|
| `event_id` | str | Polymarket event id |
| `slug`, `title`, `body` | str | Identifiers / description |
| `creation_date` | str (ISO) | DB-insert moment (before publish; *not* trading open) |
| `start_date` | str (ISO) | Order book open — **left edge of the trajectory** |
| `end_date` | str (ISO) | Resolution *deadline* (often much later than actual resolution) |
| `close_date` / `closed_time` | str (ISO) | Actual on-chain resolution — **right edge of the trajectory** |
| `resolution_date` | str (ISO) | Gamma `endDate` |
| `active`, `closed`, `archived` | bool | Lifecycle flags |
| `neg_risk` | bool | `true` ⇒ multi-outcome (K linked binary books) |
| `total_volume` | float | Total traded volume (USDC), from Gamma metadata |
| `tags` | list | Domain/category tags |
| `category` | str | Category |
| `num_markets` | int | Number of option markets (1 = binary) |

> **Date note:** markets often settle well before `end_date`, so use `closed_time` — not
> `end_date` — as the true right edge of a trajectory to avoid look-ahead leakage.

### Ground truth
| Field | Type | Meaning |
|---|---|---|
| `ground_truth_status` | str | `"resolved"` for every record here |
| `resolved_label` | str | Winning outcome label (or `"yes"`/`"no"` for binary) |
| `winner_market_index` | int | Index into `markets[]` of the winning option |

### Per-option markets — `markets` (list)
One entry for a binary event; one per option for a multi-outcome event. Each object:
`market_id`, `question`, `label`, `condition_id`, `outcomes` (`["Yes","No"]`),
`outcome_prices_final`, `clob_token_ids`, `yes_token_id`, `yes_outcome_index`,
`yes_resolved` (1/0/None), `closed`, `active`, `archived`, `umaResolutionStatus`,
`volume`, `end_date`, `created_at`, `start_date`, `closed_time`.

### Daily crowd-belief trajectory
| Field | Type | Meaning |
|---|---|---|
| `belief_kind` | str | `"binary"` or `"multi_neg_risk"` |
| `daily_index` | list[str] | ISO UTC day midnights — the time axis all series align to |
| `probability_start_date`, `probability_end_date` | str | Span of the series |
| `raw_yes_history` | dict | `{label: [p_yes per day]}` — daily-avg YES price ∈ [0,1] |
| `raw_no_history` | dict | `{label: [1 - p_yes per day]}` (binary only) |
| `normalized_history` | dict | `{label: [p per day]}` — per-day normalized K-way distribution (multi only) |
| `daily_probability_sum` | list | `Σ_k YES_k(t)` per day (multi only; the normalizer) |
| `missingness` | dict | Per-option `{days_total, days_with_value, days_missing}` |

> **Multi-outcome note:** per-option YES prices do **not** sum to 1 (each YES book has
> one-sided liquidity). The implied distribution per day is `p_i / Σ_k p_k` — that's what
> `normalized_history` already stores.
>
> Days inside the active lifetime with no trade tick are explicit `null` in the belief
> series (the grid spans the true tradeable lifetime, not just observed ticks).

### Daily trading volume
| Field | Type | Meaning |
|---|---|---|
| `daily_volume_by_market` | dict | `{market_id: [{date, trades, share_volume, notional}]}` |
| `daily_volume` | list | Event-level daily volume (sum across markets) |
| `winner_daily_volume` | list | The winning market's own daily volume series |
| `total_volume_metadata` | float | Gamma's reported `market.volume` (USDC) |
| `daily_volume_meta` | dict | Method used, per-market stats, truncation flags, window |
| `diagnostics` | dict | Coverage ratios (`ratio_notional_to_metadata ≈ 1.0` ⇒ complete) |

Per-day volume metrics: `trades` (fill count), `share_volume` (conditional tokens
transacted), `notional` (USDC that changed hands). All are densified onto `daily_index`
(days with no trades → `0`). Note the asymmetry: **missing belief days are `null`; missing
volume days are `0`.**

## Quick start

```python
import json

records = [json.loads(line) for line in open("full.jsonl")]
print(len(records), "events")

ev = records[0]
print(ev["title"], "->", ev["resolved_label"])

# Reconstruct the winner's probability trajectory
days = ev["daily_index"]
if ev["belief_kind"] == "binary":
    label = next(iter(ev["raw_yes_history"]))
    p_yes = ev["raw_yes_history"][label]
    p_winner = p_yes if ev["resolved_label"] == "yes" else [
        1 - p if p is not None else None for p in p_yes
    ]
else:  # multi_neg_risk
    p_winner = ev["normalized_history"][ev["resolved_label"]]

for d, p in zip(days, p_winner):
    print(d, p)
```

With the `datasets` library:

```python
from datasets import load_dataset
ds = load_dataset("<your-username>/<dataset-name>", data_files="full.jsonl", split="train")
```

## License & attribution

Data derived from the public Polymarket Gamma / CLOB APIs and the Goldsky-hosted
Polymarket subgraph. Please respect Polymarket's terms of service.