Pipeline running — data updated daily

Institutional-Grade
On-Chain Order Flow

Name: Hyperliquid & Polymarket Tick-Level Orderbook Data
Creator: L1 Ticks

High-fidelity tick-level data for Hyperliquid and Polymarket. Captured via proprietary Layer 1 node infrastructure. Delivered in Zstd-compressed Parquet.

Get Free Sample → View Data Catalog

10 Markets

~400ms Resolution

128M+ Orders / Day

1.9B+ Rows Delivered

99.7% Uptime

1000+ Kaggle DLs

Daily Data Updates

What You Can Build

Real use cases. Not hypothetical demos.

Smart Money Detection

Track wallet-level order flow to identify informed traders. Cluster wallets by behavior, detect accumulation/distribution patterns before price moves.

⇄

Execution Quality Analysis

Maker/taker attribution with per-fill fees. Model slippage, measure fill rates, and benchmark execution quality across venues.

ML Signal Engineering

Block-sequenced features with causal ordering guaranteed. Build order flow imbalance, cancel ratios, and toxicity signals for price prediction models.

◈

Market Microstructure Research

20-level orderbook snapshots + funding rate dynamics across 10 assets. Study liquidity provision, OBI signals, and cross-asset correlations on a fully on-chain exchange.

Event Probability Forecasting

Train supervised models on 8,700+ resolved markets with ground-truth YES/NO outcomes. Beat crowd-implied odds using microstructure features.

⇌

Market Making & Spread Analysis

Tick-level L2 depth for liquidity profiling. Analyze bid-ask dynamics, depth imbalance, and optimal quote placement across prediction markets.

∑

Academic Research

1.9B+ rows of prediction market microstructure — one of the largest publicly available datasets. Ideal for papers on information aggregation and market efficiency.

⚙

Feature Engineering Starter Kit

Pre-computed ML features — volatility, OBI, flow imbalance, spread metrics. Skip months of data wrangling and start modeling on day one.

Data Catalog

Every field verified. Every schema documented.

BTC ETH SOL HYPE SPX PAXG XRP LINK AAVE DOGE

Orders

Per-block ~400ms

block_height Int64 timestamp_ms Int64 wallet String coin String action Enum status String (L1 native) is_buy Boolean price Float64 size Float64 order_type String tif String reduce_only Boolean order_id Int64 (100% populated) cloid String

163M+ events/day • 100% order_id coverage

Fills (L1)

Per-trade

block_height Int64 timestamp_ms Int64 wallet String coin String side String role Maker / Taker price Float64 size Float64 fee Float64 is_liquidation Boolean tid Int64 oid Int64

68K+ fills/day • wallet-level tracking

L2 Orderbook

60s snapshots

timestamp_ms Int64 coin String level 1–20 bid_price Float64 bid_size Float64 ask_price Float64 ask_size Float64 obi Float64

20 levels bid + ask • OBI pre-computed

Funding + OI

5 min

timestamp_ms Int64 coin String open_interest Float64 funding_rate Float64 mark_price Float64 oracle_price Float64 premium Float64 day_volume Float64

1.4K+ readings/day • all 10 assets

Tick-Level L2 Book

~40ms latency

timestamp_received DateTime timestamp_created_at DateTime market_id String update_type String data JSON (YES/NO)

1.9+ Billion rows • 250+ GB • expanding daily

Depth Snapshots

1-min intervals

Aggregated L2 orderbook state
at 1-minute resolution.

Processed from raw tick data
for reduced storage + faster queries.

1,046+ Parquet files

Resolved Targets

Ground truth

Ground-truth YES/NO outcome labels
for resolved prediction markets.

Ready for supervised ML training.

8,700+ resolved markets with labels

Trade Executions

Historical fills

Complete trade history for
resolved markets. Includes
price, size, side, timestamp.

Joinable with target labels.

2.7M+ historical trades

ML Features

Pre-computed

bar_volatility
depth_imbalance (OBI)
close_spread
volume_1m
+ more engineered features

Skip the feature engineering phase

Load in One Line

No parsing. No preprocessing. Just Parquet.

orders_sample.py

import polars as pl

# Load 163M+ order events with 100% order_id coverage
orders = pl.read_parquet("orders/*.parquet")
btc = orders.filter(pl.col("coin") == "BTC")

print(btc.head(5))

shape: (5, 14)

block_height	timestamp_ms	wallet	coin	action	status	is_buy	price	size	order_type	tif	reduce_only	order_id	cloid
i64	i64	str	str	str	str	bool	f64	f64	str	str	bool	i64	str
0	1774396843090	0xce71..5a42	BTC	Rejected	badAloPxRejected	false	70525.0	0.12282	Limit	Alo	false	360336907743	0x0000..
0	1774396843090	0xf36c..e1a4	PAXG	Filled	filled	false	4548.0	0.56	Limit	Alo	false	360336907286	0x1490..
0	1774396843090	0x5483..a6b2	SOL	PlaceOrder	open	true	90.282	88.34	Limit	Alo	false	359298802930	0xc71b..

polymarket_ml.py

import polars as pl

# Load ground-truth targets & trades
targets = pl.read_parquet("targets/*.parquet")
trades = pl.read_parquet("trades/*.parquet")

# Join 2.7M+ trades with resolution outcomes
df = trades.join(targets, on="market_id", how="left")
print(df.head(5))

shape: (5, 8)

timestamp	market_id	side	price	size	market	outcome	resolved
datetime[ms, UTC]	str	str	f64	f64	str	str	bool
2026-02-28 14:22:01	0x4a8f..c2e1	Buy	0.72	150	BTC >70K	YES	true
2026-02-28 14:22:03	0x4a8f..c2e1	Sell	0.71	80	BTC >70K	YES	true
2026-02-28 14:22:05	0x7b2d..a9f3	Buy	0.45	200	ETH >4K	NO	true

Why This Data

Built for quants, not dashboards.

100% Order Lifecycle Tracking

Every order carries an exchange-assigned order_id. Deterministic place-to-fill linkage with no fuzzy matching. Track the full lifecycle: placement, rejection, fill, cancellation.

Wallet-Level Order Flow

Track individual accounts across executions. See who's placing, canceling, and getting filled.

Maker / Taker Attribution

Every fill tagged with execution role. Know who initiated each trade at the protocol level.

L1 Native Status Stream

14 granular status enums direct from the exchange engine. Distinguish accepted orders from ALO rejections, partial fills from full fills, triggered stops from manual cancels.

Parquet-Native

Zstd-compressed, columnar storage. One line of Python to load. No JSON parsing, no CSV headers.

Cross-Asset Coverage

Crypto majors, DeFi protocols, memecoins, and index perps are fully available on decentralized order books. This provides an incredibly rare dataset.

Deterministic Clock Alignment

Data is snapped to strict UTC clock boundaries with zero drift. Delivered in mathematically perfect daily grids (e.g., exactly 1,440 order files/day at 60s intervals).

Zero Midnight Leakage

State persistence routing guarantees a 23:59:59 payload never contaminates the next day's partition, saving your quants hours of manual resampling.

Frequently Asked Questions

Everything you need to know about the data.

What is L1 Ticks?

L1 Ticks provides institutional-grade on-chain order flow data from Hyperliquid and Polymarket. Data is captured directly from Layer 1 blockchain infrastructure at ~400ms block resolution. It is not scraped from public APIs. Every order placement, cancellation, fill, and book state change is recorded per-block and delivered in Zstd-compressed Apache Parquet format.

How is the data captured?

We operate proprietary L1 node infrastructure that reads native order status streams in real-time. A Hyperliquid node streams order lifecycle events through our pipeline, which extracts every placement, rejection, fill, and cancellation with the exchange-assigned order_id. Every order receives a deterministic identifier — no fuzzy matching, no probabilistic linking. No public API scraping — data comes directly from the blockchain.

What format is the data in?

All data ships as Apache Parquet files with Zstd level 3 compression. One line of Python loads the entire dataset: polars.read_parquet("orders/*.parquet"). Columnar storage means you can scan billions of rows in seconds. No JSON parsing, no CSV header issues, no data type guessing.

What markets are covered?

Hyperliquid: BTC, ETH, SOL, HYPE, SPX, PAXG, XRP, LINK, AAVE, and DOGE perpetual futures — spanning crypto majors, DeFi, TradFi-bridge, and meme sectors.

Polymarket: Full L2 orderbook for prediction markets with 1.9B+ tick-level rows across thousands of resolved markets.

Is there a free sample?

Yes. A free 7-day BTC sample with orders, fills, book, and funding data is available on Kaggle. Polymarket starter data is also included. No sign-up is required. You can download and explore immediately.

Pricing

Start free. Scale when ready.

Free

7-day BTC sample with all 4 data streams. Request via Telegram for instant delivery.

7 days of BTC orders, fills, book, funding
All 13 columns per stream
Delivered via Google Drive
Just message @l1ticks on Telegram

Request Free Sample →

Starter

$69 / month

Daily Parquet delivery for all 10 Hyperliquid perps. 30-day rolling access from your start date.

Daily Parquet delivery for 30 days
All 10 perpetual markets
Orders, fills, book, funding streams
Auto-renews for continuous access

Get Started →

Institutional-GradeOn-Chain Order Flow