In correlated Polymarket markets, not all prices are equal. Some markets lead price discovery; others follow with a delay. This post lays out a practical lead–lag workflow (cross-correlation plus a simplified causality check) you can reproduce using public price endpoints—then shows how to turn “leader flow” into actionable trades.
Explore structured research pillars and internal link paths.
Visit Research SeriesPolymarket markets are often correlated by design:
In theory, they should move together.
In practice, they don’t move together. They move in sequence:
If you can measure that lead–lag relationship, you stop watching the wrong chart—and you stop treating whale flow as random.
Internal links:
Lead–lag is microstructure, not mysticism.
Two markets can encode a similar belief but differ on:
The “leader” is usually the market that is:
The follower is often the market with:
If you want to go deeper on regime shifts, read:
Polymarket documents three public API families:
For lead–lag, you only need:
Token IDs are discoverable from Gamma market objects.
External source: https://docs.polymarket.com/developers/gamma-markets-api/get-markets
We’ll do two checks:
Work with returns, not raw prices:
r_t = p_t - p_{t-1}
Then for each lag k, compare:
corr(r_A(t), r_B(t + k))
If correlation peaks at positive k, A tends to lead B by k time steps.
Now the key: repeat the test.
You need the relationship to persist:
If “the leader” changes every hour, you don’t have price discovery—you have noise.
Polymarket’s endpoints overview lists public CLOB pricing endpoints, including price history.
External source: https://docs.polymarket.com/quickstart/reference/endpoints
This script fetches two price histories, resamples to a fixed interval, then computes cross-correlation across lags.
import json
import math
import urllib.request
from statistics import mean
TOKEN_A = "TOKEN_ID_A"
TOKEN_B = "TOKEN_ID_B"
INTERVAL_SECONDS = 60
MAX_LAG = 30 # 30 minutes if interval is 60s
def get_json(url: str):
with urllib.request.urlopen(url) as r:
return json.loads(r.read().decode("utf-8"))
def fetch_prices(token_id: str):
data = get_json(f"https://clob.polymarket.com/prices-history?token_id={token_id}")
points = []
for row in data:
ts = int(row.get("t") or row.get("timestamp") or row.get("time"))
px = float(row.get("p") or row.get("price"))
points.append((ts, px))
points.sort(key=lambda x: x[0])
return points
def resample(points, interval):
buckets = {}
for ts, px in points:
b = (ts // interval) * interval
buckets[b] = px
if not buckets:
return []
t0 = min(buckets.keys())
t1 = max(buckets.keys())
out = []
cur = None
for t in range(t0, t1 + interval, interval):
if t in buckets:
cur = buckets[t]
if cur is None:
continue
out.append((t, cur))
return out
def returns(series):
return [series[i][1] - series[i-1][1] for i in range(1, len(series))]
def corr(x, y):
n = min(len(x), len(y))
if n < 10:
return 0.0
x = x[:n]
y = y[:n]
mx = mean(x)
my = mean(y)
vx = mean([(a - mx) ** 2 for a in x])
vy = mean([(b - my) ** 2 for b in y])
if vx <= 1e-12 or vy <= 1e-12:
return 0.0
cov = mean([(x[i] - mx) * (y[i] - my) for i in range(n)])
return cov / math.sqrt(vx * vy)
pa = resample(fetch_prices(TOKEN_A), INTERVAL_SECONDS)
pb = resample(fetch_prices(TOKEN_B), INTERVAL_SECONDS)
ra = returns(pa)
rb = returns(pb)
results = []
for lag in range(-MAX_LAG, MAX_LAG + 1):
if lag >= 0:
c = corr(ra, rb[lag:])
else:
c = corr(ra[-lag:], rb)
results.append((lag, c))
best = max(results, key=lambda x: x[1])
lag, c = best
relation = "A leads B" if lag > 0 else "B leads A" if lag < 0 else "synchronous"
print({"best_relation": relation, "lag_steps": lag, "corr": c, "all": results})
Use it like a filter:
Once you identify the leader:
Common playbooks:
This is where wallet context matters:
Lead–lag analysis breaks when:
If you can’t explain why a market leads, don’t trust the statistic.
Research Series
Follow related research articles or jump to the full pillar library.