lokima/polymarket-btc-eth-5m-updown-8h

Polymarket BTC/ETH 5-Minute Up/Down — Full-Depth Microstructure Capture (8h)

A tick-level, nanosecond-timestamped capture of 96 consecutive Polymarket 5-minute binary up/down windows on both BTC and ETH, together with every venue feed needed to model them: the Chainlink settlement oracle, Coinbase, Binance spot and Binance futures.

52,007,792 events. 8 hours. 192 labelled symbol-windows. Zero dropped records.

Coverage	2026-07-29T20:40:00Z → 2026-07-30T04:40:00Z (8h, contiguous)
Windows	96 × 300 s, no gaps — both BTC and ETH legs of each
Events	52,007,792 rows across 400 Parquet files
Size	3.57 GB Parquet+zstd (from 53.23 GB raw NDJSON, 14.9×)
Labels	192/192 complete, every one independently cross-verified
Quality gates	28/28 passed, 1 limitation recorded — metadata/quality_report.json

Why this capture is unusual

Dual redundant order-book capture. Every window's CLOB websocket was recorded twice over two independent simultaneous connections (poly_a, poly_b). Message loss can therefore be measured rather than assumed absent. Measured payload-set Jaccard agreement across all 192 symbol-windows: median 0.99998, 5th percentile 0.9919, minimum 0.9855.

Verbatim payloads. Each row is a typed envelope plus the venue's own frame carried byte-for-byte in payload_raw, unparsed. No decoding decision is baked into the archive, so no downstream analysis inherits a packaging bug.

Two-source labels. Consecutive 5-minute windows share one Chainlink print, giving the invariant strike(N) == close(N-1). All 190/190 consecutive pairs match exactly. The 17 symbol-windows whose strike was lost to REST throttling during the live run were recovered offline and accepted only where an unhurried REST re-read and the boundary chain agreed exactly.

Nanosecond clock discipline. Host clock chrony-disciplined to stratum 2 at capture: system time 161 ns fast of NTP, last offset −536 ns, RMS offset 754 ns, root delay 129 µs. Every row carries both CLOCK_REALTIME and a monotonic clock.

Drop detection by construction. stream_seq is a per-file monotonic counter. All 1,735 source streams verified contiguous from 1 with no gaps and no duplicates — an end-to-end proof that no record was lost between socket and disk.

Contents

labels/labels.parquet                     192 rows — the supervised target + full label provenance
data/clob_ws/{btc,eth}/{window_ts}/       Polymarket CLOB websocket, dual capture (3.32 GB, 384 files)
     poly_a.parquet, poly_b.parquet
data/clob_rest/book_rest.parquet           REST book snapshots, both legs (20,736 rows)
data/trades/trades_live.parquet            in-window trade polls (5,952 responses)
data/trades/trades_final.parquet           post-close authoritative drain (594 responses)
data/reference/discovery.parquet           slug → condition_id → token_ids (384)
data/reference/strike.parquet              every strike poll incl. all 429s (1,514)
data/reference/resolution.parquet          both close paths per window (4,777)
data/reference/holders.parquet             pre-open holder snapshots (768)
data/venue/rtds.parquet                    Chainlink settlement oracle, ~1 Hz (28,719)
data/venue/coinbase_tape.parquet           trades + ticker + candles (350,662)
data/venue/binance_spot.parquet            BTC+ETH aggTrade/trade/bookTicker/kline_1m (7,524,661)
data/venue/binance_fut_market.parquet      BTC aggTrade/markPrice@1s/forceOrder (366,642)
data/venue/binance_depth_snap.parquet      REST depth @ limit=5000 (100)
data/venue/backfill.parquet                pre-run historical candles (3)
data/venue/clock.parquet                   venue /time probes with RTT (7)
metadata/                                  manifests, per-window integrity, quality report
SCHEMA.md                                  full data dictionary
PROVENANCE.md                              how it was captured, and what to distrust

Every file in data/ shares one 56-column schema, so the whole tree loads as a single table. See SCHEMA.md for every column and every channel.

Quick start

import pyarrow.dataset as ds
import pyarrow.parquet as pq
from huggingface_hub import snapshot_download

# labels only — small
p = snapshot_download("lokima/polymarket-btc-eth-5m-updown-8h",
                      repo_type="dataset", allow_patterns=["labels/*"])
labels = pq.read_table(f"{p}/labels/labels.parquet").to_pandas()
print(labels[["window_ts", "sym", "strike", "close_used",
              "terminal_logret_bps", "outcome"]].head())

# one window's order book, both redundant legs
p = snapshot_download("lokima/polymarket-btc-eth-5m-updown-8h", repo_type="dataset",
                      allow_patterns=["data/clob_ws/btc/1785357600/*"])
book = ds.dataset(f"{p}/data/clob_ws/btc/1785357600").to_table()

# the settlement oracle series
import json
rt = pq.read_table(f"{p}/data/venue/rtds.parquet")  # after downloading venue/
ticks = [json.loads(x)["payload"] for x, c in
         zip(rt["payload_raw"].to_pylist(), rt["channel"].to_pylist())
         if c == "crypto_prices_chainlink" and x]

payload_raw is a JSON string. Parse it yourself — that is the point.

The market being captured

At window open, $Q of collateral splits into Q Up shares + Q Down shares, together always worth exactly $1 at resolution. The window settles on a single comparison against a Chainlink print: Up iff close >= strike, where strike is the window's own openPrice. As the underlying moves, the losing leg decays toward zero. Polymarket charges a 7% taker fee on s·(1−s), so selling a leg at $0.05 nets 0.046675 — which makes 0.046675 the break-even probability for that trade and the payoff ratio 20.4:1.

This dataset was built to study that asymmetry: order flow, book depth, oracle lag and cross-venue lead-lag around the moment a leg collapses.

Label distribution

	windows	Up	Down
BTC	96	52	44
ETH	96	51	45
Total	192	103	89

Terminal displacement |1e4·ln(close/strike)|: median 7.2 bps, p90 20.0 bps, max 38.5 bps. This is a calm 8-hour sample — worth knowing before treating it as representative of volatile regimes.

Known limitations

Read these before using the data. All are recorded machine-readably in metadata/quality_report.json under findings.

1. No ETH settlement-oracle series (material). All 5 RTDS connections sent a subscribe frame requesting {"symbol":"eth/usd"}, and the venue returned connect-time snapshots only — 0 live ETH ticks against 28,689 for BTC. ETH labels are unaffected and complete (the strike and close come from the crypto-price REST endpoint, not this stream), but there is no intra-window oracle path for ETH. Any oracle-based work is BTC-only.

2. BTC oracle coverage is 96.96%, not 100%. 28,810 distinct seconds over a 29,713-second span: 903 seconds missing across 734 gaps, largest 61 s (during the one silence-watchdog reconnect at 22:15:10Z). Most gaps are 1–7 s. The RTDS socket was closed by the server 3 times (Going away ×2, Service restarting ×1) and reconnected 5 times total. Do not assume a uniform 1 Hz grid; check timestamps.

3. Heavy REST throttling is part of the record. 1,067 REST errors over the run, predominantly HTTP 429 on the crypto-price endpoint. data/reference/strike.parquet retains every 429 with its error body. This throttling is what made the label backfill necessary; it is preserved rather than cleaned so the failure mode stays visible.

4. 17 labels are backfilled, not live. Marked label_source = backfill_rest+chain in labels.parquet. Each required exact agreement between an offline REST re-read and the boundary chain. Two of the 17 show a last-digit float difference between the two sources (e.g. …047167 vs …047169); the acceptance tolerance is 1e-9 absolute, not bit-exact. This is JSON float round-tripping, not disagreement about price.

5. window_clean_live_capture is historical. It records the live run's verdict (79 of 96 windows clean). It is deliberately not updated post-backfill, so the original state stays auditable. For current label status use label_source.

6. Binance futures is BTC-only. The futures subscription covers btcusdt only (aggTrade, markPrice@1s, forceOrder). Spot covers both symbols.

7. Calm regime, short horizon. 8 hours, 96 windows. Far too small to certify a trading edge on 5-minute binaries, where rare-event statistics scale with the number of reversals rather than windows. Treat it as a microstructure-quality sample, not a backtest corpus.

Verification

metadata/quality_report.json holds all 28 checks with supporting detail. Highlights:

check	result
conversion.line_accounting	52,007,792 source lines → 52,007,792 rows, 0 blank, 0 parse failures
conversion.no_unknown_envelope_keys	0 rows needed the extra_fields_json escape hatch
conversion.every_source_hashed	1,735/1,735 source files sha256'd
streams.stream_seq_contiguous_no_gaps_no_dupes	1,735 streams, 0 violations
labels.boundary_chain_consistent	190/190 consecutive pairs exact
labels.outcome_reproducible_from_columns	every label recomputable from shipped columns
labels.close_slow_fast_within_1usd	two independent close paths agree on all 192
dual_capture.median_payload_jaccard_gt_0.99	median 0.99998 across 192 symbol-windows
time.arrival_monotonic_by_stream_seq	0 backwards steps
clock.ntp_synchronised	stratum 2, RMS offset 754 ns, leap status Normal

The row count is also an independent cross-check: the collector's own records_written counter reads 52,007,792, matching the Parquet row total exactly.

Re-verify locally:

import json, pyarrow.parquet as pq
q = json.load(open("metadata/quality_report.json"))
assert q["all_passed"], [c for c in q["checks"] if not c["pass"]]

# every source file's sha256 and the row count it produced
m = json.load(open("metadata/conversion_manifest.json"))
assert sum(f["dest_rows"] for f in m["files"]) == 52_007_792

checksums/parquet_sha256.txt covers every shipped file.

Provenance

Captured by a purpose-built Rust collector (market_capture, schema_version 1) on a single EC2 host, writing append-only NDJSON. The archive here is a lossless Parquet re-encoding of that raw capture: envelope fields typed, venue frames verbatim, nothing dropped, nothing inferred. Raw NDJSON checksums are in metadata/conversion_manifest.json so the re-encoding is auditable against the original.

See PROVENANCE.md for endpoints, subscription frames, the capture timeline, and the reasoning behind each packaging decision.

Terms

The compilation, schema, labels and documentation are released under ODC-BY 1.0. The underlying market data was observed from public Polymarket, Coinbase, Binance and Chainlink endpoints; users are responsible for their own compliance with those venues' terms of service. Nothing here is investment advice.

Citation

@misc{polymarket_btc_eth_5m_updown_8h,
  title  = {Polymarket BTC/ETH 5-Minute Up/Down: Full-Depth Microstructure Capture (8h)},
  author = {Lokesh, Masa},
  year   = {2026},
  publisher = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/lokima/polymarket-btc-eth-5m-updown-8h}}
}