Data Format Reference

Overview

ImpliedData provides historical prediction market data from Polymarket, Manifold, and Myriad in a unified schema. All prices are normalized to win probability (0 to 1) — not dollars, not percentages. All timestamps are UTC. All platforms use the same column names.

There are three types of files you can download:

File Formats

Understanding Prices (0–1)

All price fields (open, high, low, close, price) are win probability expressed as a decimal between 0 and 1, not dollars or percentages.

To convert to percentage: price × 100. To convert to implied odds: 1 / price.

Multi-outcome markets (e.g. “Who wins the 2024 election?” with 10 candidates): each candidate is a separate market_id/outcome row. Prices across all outcomes in an event should sum to approximately 1.0 (the difference is the platform’s margin).

Gaps & Sparse Markets

Candle files do not insert rows for empty periods. If no trades occurred during a 1h bucket, that bucket simply does not exist in the file. This is by design — inserting NULL rows would inflate file sizes by 10–100× for low-volume markets.

Manifold markets are especially sparse — many have only a handful of trades over their entire lifetime. A market open for 6 months may have only 20–30 candles at 1d resolution if trading was infrequent.

How to handle gaps in your analysis:

import pandas as pd

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

# Forward-fill missing hours (last known price)
df = df.set_index("timestamp").sort_index()
full_range = pd.date_range(df.index.min(), df.index.max(), freq="1h", tz="UTC")
df = df.reindex(full_range)
df["close"] = df["close"].ffill()   # carry last close forward
df["volume"] = df["volume"].fillna(0)  # no trades = zero volume

Candles Schema

OHLCV candle data. Files are named implieddata_{platform}_{resolution}.parquet (e.g. implieddata_polymarket_1h.parquet). One row per time bucket per market. All resolutions (1m, 5m, 15m, 1h, 1d) are available to every signed-in account.

Note: Bulk 1m/5m/15m downloads for Polymarket markets before December 2022 may return no data for markets not yet backfilled into the continuous aggregate. Per-market downloads (selecting a specific market) always fall back to on-demand computation from raw trades and are not affected by this gap.

Trades Schema

Raw tick-level trades. Files are named implieddata_{platform}_trades.parquet. One row per individual transaction. Use this for microstructure analysis, custom aggregations, or building your own candle resolution.

Multi-Outcome Markets

Most markets are binary (Yes/No) — one number matters: P(YES), the close value in the candle schema above. But some markets have several mutually-exclusive outcomes — a football match (1 / X / 2), a multi-candidate election, a “which option wins” market. These ship as a separate dataset with one extra column, outcome — they are never mixed into the clean binary 0–1 files.

The grain becomes (market_id, outcome, timestamp) — one row per outcome per time bucket — and close is now the implied probability of that specific outcome. So for “Arsenal vs Chelsea” you get three rows at each timestamp:

Every other column is identical to the binary candle schema (open/high/low/close/volume/trade_count). What to know:

• One outcome’s price path: filter market_id = 123 AND outcome = '1'.
• The whole market: filter market_id = 123 → every outcome at every timestamp.
• Prices ≈ sum to 1 across a market’s outcomes (they’re mutually exclusive) — but not exactly: prices are sampled from an order book with a spread, so the sum drifts a few percent around 1.0. We report observed prices and do not renormalize (divide by the row-sum yourself if you want a clean distribution).
• Outcome labels are the raw traded labels — for Azuro football, betting convention: 1 = home win, X = draw, 2 = away win. Join market_id → the markets file (outcomes column) for the full human meaning.
• At resolution the winning outcome converges to ~1, the losers to ~0 — same convergence guarantee as the binary set.

Raw trades for these markets follow the same rule: the trades schema gains the same outcome column, with price = that outcome’s probability at the fill. Coverage at launch: Azuro (sports, 2023–2025 historical archive), multi-candidate Polymarket, and multi-option Myriad.

Markets Schema

Market metadata catalog. Files named implieddata_{platform}_markets.parquet. Join against candles or trades on platform_market_id = market_id.

Code Examples

import pandas as pd

# Load 1h candles for Polymarket
df = pd.read_parquet("implieddata_polymarket_1h.parquet")

# Basic info
print(df.dtypes)
print(df.head())

# Filter to a single market
market = df[df["market_id"] == "0x1234abcd..."]

# Plot the close probability over time
import matplotlib.pyplot as plt
market.set_index("timestamp")["close"].plot(title=market["market_title"].iloc[0])

import polars as pl

df = pl.read_parquet("implieddata_polymarket_1h.parquet")

# Filter markets that resolved YES and had high volume
winners = (
    df.filter(pl.col("resolution_result") == "YES")
    .group_by("market_id")
    .agg([
        pl.col("close").last().alias("final_price"),
        pl.col("volume").sum().alias("total_volume"),
        pl.col("market_title").first(),
    ])
    .filter(pl.col("total_volume") > 10_000)
    .sort("total_volume", descending=True)
)
print(winners.head(20))

-- Install: pip install duckdb
-- Then in Python:

import duckdb

# Query directly from file — DuckDB reads only the columns/rows it needs
result = duckdb.query("""
    SELECT
        market_id,
        market_title,
        MIN(low)  AS min_prob,
        MAX(high) AS max_prob,
        LAST(close ORDER BY timestamp) AS final_price,
        SUM(volume) AS total_volume_usd
    FROM 'implieddata_polymarket_1h.parquet'
    WHERE market_title ILIKE '%election%'
      AND timestamp >= '2024-01-01'
    GROUP BY market_id, market_title
    ORDER BY total_volume_usd DESC
    LIMIT 20
""").df()

print(result)

# install.packages("arrow")
library(arrow)
library(dplyr)

df <- read_parquet("implieddata_polymarket_1h.parquet")

# Summary by market
summary <- df |>
  group_by(market_id, market_title) |>
  summarise(
    first_price  = first(open),
    last_price   = last(close),
    total_volume = sum(volume),
    n_candles    = n()
  ) |>
  arrange(desc(total_volume))

head(summary, 20)

import pandas as pd

candles = pd.read_parquet("implieddata_polymarket_1h.parquet")
markets = pd.read_parquet("implieddata_polymarket_markets.parquet")

# Join on the platform market identifier
merged = candles.merge(
    markets[["platform_market_id", "title", "category", "resolution_result"]],
    left_on="market_id",
    right_on="platform_market_id",
    how="left"
)

# Filter to politics markets only
politics = merged[merged["category"] == "politics"]

import pandas as pd

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

# Prices are 0–1 probabilities. Convert:
df["close_pct"]         = df["close"] * 100       # e.g. 0.62 → 62.0%
df["close_implied_odds"]= 1 / df["close"]         # e.g. 0.62 → 1.61x
df["close_decimal_odds"]= 1 / df["close"]         # same as implied odds for binary markets

# For a YES/NO market, the NO probability is:
df["no_prob"] = 1 - df["close"]

API Reference

Programmatic access is free and open to every signed-in account. Generate a key in your account (shown once — store it securely), then authenticate every request with a Bearer header. API downloads count towards the same fair-use export ceiling as website downloads.

# Catalog: newest open Polymarket politics markets
curl -H "Authorization: Bearer idk_live_YOUR_KEY" \
  "https://api.implieddata.com/v1/markets?platform=polymarket&category=politics&status=open&limit=50"

# Candles: 1-minute resolution for one market
curl -H "Authorization: Bearer idk_live_YOUR_KEY" \
  "https://api.implieddata.com/v1/candles?platform=polymarket&market_id=12345&resolution=1m&start=2026-05-01&end=2026-06-01"

# Bulk export: all Manifold 1h candles for May as Parquet
curl -OJ -H "Authorization: Bearer idk_live_YOUR_KEY" \
  "https://api.implieddata.com/v1/download?platform=manifold&resolution=1h&start=2026-05-01&end=2026-06-01&fmt=parquet"

# Multi-outcome (e.g. the Azuro sports archive): per-outcome candles for one market
curl -OJ -H "Authorization: Bearer idk_live_YOUR_KEY" \
  "https://api.implieddata.com/v1/outcome-download?market_id=49021136&resolution=1h&fmt=csv"

# Check your remaining monthly volume
curl -H "Authorization: Bearer idk_live_YOUR_KEY" "https://api.implieddata.com/v1/usage"

import io, requests, pandas as pd

KEY = "idk_live_YOUR_KEY"
H = {"Authorization": f"Bearer {KEY}"}
BASE = "https://api.implieddata.com"

# Download straight into a DataFrame
r = requests.get(f"{BASE}/v1/download", headers=H, params={
    "platform": "polymarket", "resolution": "1h",
    "start": "2026-01-01", "end": "2026-06-01", "fmt": "parquet",
})
r.raise_for_status()
df = pd.read_parquet(io.BytesIO(r.content))
print(df.head())

Common Gotchas

Data Sources & Attribution