Hyperliquid historical data: trade history, candles and the order book

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# ask for the link and download the 2026-10-23 fills file in one step
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/url?dataset=fills&date=2026-10-23&redirect=1",
    headers={"X-API-Key": API_KEY},
)
with open("fills-2026-10-23.parquet", "wb") as f:
    f.write(r.content)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# every published day with each file's rows and bytes, newest first
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/datasets",
    headers={"X-API-Key": API_KEY},
)
# then: jq '.dates[:7] | map({date, fills: .streams.fills})'

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# name, type and meaning of every column of the fills files
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/datasets",
    headers={"X-API-Key": API_KEY},
)
# then: jq '.schema.fills'

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# the link alone
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/url?dataset=fills&date=2026-10-23",
    headers={"X-API-Key": API_KEY},
)
# then: jq -r '.url'

import requests

# what the free samples are: the sample day, the files and the schema; no API key
r = requests.get(
    "https://data.vike.io/archive/hl-samples/manifest.json",
)

import requests

# one BTC hour of fills; no API key
r = requests.get(
    "https://data.vike.io/archive/hl-samples/fills-sample.parquet",
)
with open("fills-sample.parquet", "wb") as f:
    f.write(r.content)

import polars as pl

fills = pl.read_parquet("fills-sample.parquet")
print(fills.height, fills.columns)  # 16830 rows on the 2026-10-21 sample
print(fills.filter(~pl.col("is_maker")).select(pl.col("size_usd").sum()))  # taker side: each trade once

import requests

# one BTC snapshot of open positions; no API key
r = requests.get(
    "https://data.vike.io/archive/hl-samples/positions-sample.parquet",
)
with open("positions-sample.parquet", "wb") as f:
    f.write(r.content)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# the archive index: daily files with rows and bytes, the schema, and samples_base
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/datasets",
    headers={"X-API-Key": API_KEY},
)
# then: jq '{samples_base, newest: .dates[0]}'

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# ask for the link and download the current open positions of every asset in one step
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/url?dataset=positions&date=latest&redirect=1",
    headers={"X-API-Key": API_KEY},
)
with open("positions-latest.parquet", "wb") as f:
    f.write(r.content)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# the snapshot, write time, rows, bytes and asset count of the current file
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/datasets",
    headers={"X-API-Key": API_KEY},
)
# then: jq '.latest.positions | {snapshot_ts, generated_at, rows, bytes, assets}'

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# every open BTC position, 5,000 per page, in wallet order
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/positions?symbol=BTC&limit=5000",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# snapshots, rows and rebuilt hours of every published positions day, newest first
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/datasets",
    headers={"X-API-Key": API_KEY},
)
# then: jq '[.dates[] | select(.streams.positions) | {date, snapshots: .streams.positions.snapshots, rows: .streams.positions.rows, reconstructed_hours: .streams.positions.reconstructed_hours}]'

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# the days whose positions file holds fewer than 250 snapshots
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/datasets",
    headers={"X-API-Key": API_KEY},
)
# then: jq -r '.dates[] | select(.streams.positions) | select(.streams.positions.snapshots < 250) | "\(.date) \(.streams.positions.snapshots)"'

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# ask for the link and download the 2026-10-23 positions file in one step
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/url?dataset=positions&date=2026-10-23&redirect=1",
    headers={"X-API-Key": API_KEY},
)
with open("positions-2026-10-23.parquet", "wb") as f:
    f.write(r.content)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# days and GB of the month's fills files
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/datasets",
    headers={"X-API-Key": API_KEY},
)
# then: jq '[.dates[] | select(.date | startswith("2026-09")) | .streams.fills.bytes] | {days: length, gb: (add / 1e9)}'

import os
from pathlib import Path

import polars as pl
import requests

API = "https://data.vike.io/v1/hyperliquid"
H = {"X-API-Key": os.environ["VIKE_API_KEY"]}
MONTH = "2026-09"

index = requests.get(f"{API}/archive/datasets", headers=H, timeout=60).json()
days = sorted(d["date"] for d in index["dates"] if d["date"].startswith(MONTH) and "fills" in d["streams"])
need = sum(d["streams"]["fills"]["bytes"] for d in index["dates"] if d["date"] in days)
print(len(days), "days,", round(need / 1e9, 2), "GB to download")  # one raw day on disk at a time

for day in days:
    out = Path(f"btc-{day}.parquet")
    if out.exists():
        continue  # done on an earlier run: no new link is asked for
    ask = requests.get(f"{API}/archive/url", params={"dataset": "fills", "date": day}, headers=H, timeout=60)
    ask.raise_for_status()  # a 400 names the published range
    raw = Path(f"fills-{day}.parquet")
    with requests.get(ask.json()["url"], stream=True, timeout=(10, 300)) as r:  # the link needs no key
        r.raise_for_status()
        with raw.open("wb") as f:
            for chunk in r.iter_content(1 << 20):
                f.write(chunk)
    pl.scan_parquet(raw).filter(pl.col("asset") == "BTC").sink_parquet(out)  # keep only what you need
    raw.unlink()  # free the disk before the next day

month = pl.read_parquet(f"btc-{MONTH}-*.parquet")

pl.read_parquet("btc-2026-09-01.parquet").write_csv("btc-2026-09-01.csv", datetime_format="%Y-%m-%dT%H:%M:%S%.3f%:z")

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# one day of fills straight to disk
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/url?dataset=fills&date=2026-09-01&redirect=1",
    headers={"X-API-Key": API_KEY},
)
with open("fills-2026-09-01.parquet", "wb") as f:
    f.write(r.content)

import requests

# one BTC hour of fills, no API key
r = requests.get(
    "https://data.vike.io/archive/hl-samples/fills-sample.parquet",
)
with open("fills-sample.parquet", "wb") as f:
    f.write(r.content)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# the first page of a backtest window: up to 5,000 BTC minutes from 2026-10-01 00:00 UTC
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&interval=1m&start=2026-10-01T00:00:00Z&limit=5000",
    headers={"X-API-Key": API_KEY},
)

import csv
import os

import requests

H = {"X-API-Key": os.environ["VIKE_API_KEY"]}
URL = "https://data.vike.io/v1/hyperliquid/ohlcv"
start, end = 1788220800000, 1790812800000  # 2026-09-01 to 2026-10-01 UTC, epoch ms, end exclusive

rows = []
while start < end:
    r = requests.get(URL, params={"symbol": "BTC", "interval": "1m", "start": start, "end": end, "limit": 5000},
                     headers=H, timeout=60)
    r.raise_for_status()
    page = r.json()["candles"]
    if not page:
        break
    rows += page
    start = page[-1]["ts"] + 60_000  # one minute after the last bar

with open("btc-1m-2026-09.csv", "w", newline="") as f:
    w = csv.DictWriter(f, fieldnames=["ts", "open", "high", "low", "close", "volume", "volume_usd", "n_trades"])
    w.writeheader()
    w.writerows(rows)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# 5,000 BTC minutes as NDJSON, saved to a file
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv/export?symbol=BTC&interval=1m&start=2026-10-01T00:00:00Z&limit=5000",
    headers={"X-API-Key": API_KEY},
)
with open("btc-1m-page1.ndjson", "wb") as f:
    f.write(r.content)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# 5,000 hourly BTC bars
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&interval=1h&limit=5000",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# BTC hourly close, open interest, funding rate and premium for September 2026
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/symbols/hourly?symbols=BTC&start=2026-09-01T00:00:00Z&end=2026-10-01T00:00:00Z",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# hourly candles of a HIP-3 market: the dex-prefixed symbol and its dex
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=xyz:PLATINUM&dex=XYZ&interval=1h&limit=3",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# a week of hourly HYPE spot candles
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=HYPE&market=spot&interval=1h&limit=168",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# 5,000 BTC minutes from 2026-10-01 as CSV rows: ts, open, high, low, close, volume
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&interval=1m&start=2026-10-01T00:00:00Z&limit=5000",
    headers={"X-API-Key": API_KEY},
)
# then: jq -r '.candles[] | [.ts, .open, .high, .low, .close, .volume] | @csv'

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# 100-trade BTC bars over ten minutes
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&interval=100t&start=2026-10-23T12:00:00Z&end=2026-10-23T12:10:00Z&limit=3",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# the newest 1-minute candle of every spot pair that traded in the last hour
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv/latest?market=spot",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# download one UTC day of every fill: redirect=1 answers with the link and -L follows it
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/url?dataset=fills&date=2026-10-23&redirect=1",
    headers={"X-API-Key": API_KEY},
)
with open("fills-2026-10-23.parquet", "wb") as f:
    f.write(r.content)

import polars as pl

fills = pl.read_parquet("fills-2026-10-23.parquet")  # or the free fills-sample.parquet
bars = (
    fills.filter((pl.col("asset") == "BTC") & ~pl.col("is_maker"))  # the taker row: one row per trade
    .sort("fill_ts", "trade_id")
    .group_by_dynamic("fill_ts", every="1s")
    .agg(
        open=pl.col("price").first(),
        high=pl.col("price").max(),
        low=pl.col("price").min(),
        close=pl.col("price").last(),
        volume=pl.col("size_token").sum(),
        volume_usd=pl.col("size_usd").sum(),
        n_trades=pl.len(),
    )
)
print(bars.head())

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# the API's first three BTC minutes of 2026-10-21
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&interval=1m&start=2026-10-21T00:00:00Z&limit=3",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# 100-trade BTC bars over ten minutes
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&interval=100t&start=2026-10-23T12:00:00Z&end=2026-10-23T12:10:00Z&limit=500",
    headers={"X-API-Key": API_KEY},
)

grid = pl.datetime_range(bars["fill_ts"].min(), bars["fill_ts"].max(), "1s", time_unit="ms", time_zone="UTC", eager=True).alias("fill_ts").to_frame()
full = grid.join(bars, on="fill_ts", how="left").with_columns(
    pl.col("close").forward_fill(),
    pl.col("volume", "volume_usd", "n_trades").fill_null(0),
).with_columns(pl.col("open", "high", "low").fill_null(pl.col("close")))

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# download one UTC day of every fill: redirect=1 answers with the link and -L follows it
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/url?dataset=fills&date=2026-10-23&redirect=1",
    headers={"X-API-Key": API_KEY},
)
with open("fills-2026-10-23.parquet", "wb") as f:
    f.write(r.content)

import polars as pl

fills = pl.read_parquet("fills-2026-10-23.parquet")  # or the free fills-sample.parquet

side = pl.when(pl.col("side") == "buy").then(1).otherwise(-1)
start, end = pl.col("start_position"), pl.col("end_position")
classified = (
    fills.filter(start.is_not_null() & ~pl.col("asset").str.contains("^[@#]"))  # perps; NULL before 2026-09-29
    .with_columns(end_position=start + side * pl.col("size_token"))
    .with_columns(
        action=pl.when(start.abs() < 1e-9).then(pl.lit("open"))
        .when(end.abs() < 1e-9).then(pl.lit("close"))
        .when(start * end < 0).then(pl.lit("flip"))
        .when(end.abs() > start.abs()).then(pl.lit("add"))
        .otherwise(pl.lit("reduce"))
    )
)
print(classified.group_by("action").agg(pl.len().alias("fills")).sort("fills", descending=True))

import requests

# one BTC hour of fills, no API key
r = requests.get(
    "https://data.vike.io/archive/hl-samples/fills-sample.parquet",
)
with open("fills-sample.parquet", "wb") as f:
    f.write(r.content)

orders = classified.group_by("wallet", "order_id").agg(
    pl.col("action").unique().alias("actions"),
    pl.col("size_token").sum(),
)
print(orders.filter(pl.col("actions").list.len() > 1))  # orders that, for example, closed and then reopened

print(classified.filter(pl.col("action") == "flip").select("fill_ts", "wallet", "side", "size_token", "start_position", "end_position", "closed_pnl"))

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# download one UTC day of every fill: redirect=1 answers with the link and -L follows it
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/url?dataset=fills&date=2026-10-23&redirect=1",
    headers={"X-API-Key": API_KEY},
)
with open("fills-2026-10-23.parquet", "wb") as f:
    f.write(r.content)

import polars as pl

fills = pl.read_parquet("fills-2026-10-23.parquet")  # or the free fills-sample.parquet
key = ["asset", "fill_ts", "trade_id"]
buys = fills.filter(pl.col("side") == "buy").select(*key, "price", "size_token", buyer="wallet", buyer_maker="is_maker")
sells = fills.filter(pl.col("side") == "sell").select(*key, seller="wallet")
trades = buys.join(sells, on=key)
print(trades.height, "trades from", fills.height, "fills")

pairs = (
    trades.group_by("buyer", "seller")
    .agg(usd=(pl.col("price") * pl.col("size_token")).sum(), trades=pl.len())
    .sort("usd", descending=True)
)
print(pairs.head(10))  # the wallet pairs that traded the most notional with each other

print(trades.filter(pl.col("buyer") == pl.col("seller")).height)  # 0 on the sample
both_ways = pairs.join(pairs, left_on=["buyer", "seller"], right_on=["seller", "buyer"], suffix="_back")
print(both_ways.sort("usd", descending=True).head(10))

w = "0xa62b923a112d50d03e1e096bbd53422490dac104"
mine = trades.filter((pl.col("buyer") == w) | (pl.col("seller") == w))
other = pl.when(pl.col("buyer") == w).then(pl.col("seller")).otherwise(pl.col("buyer"))
print(mine.group_by(other.alias("counterparty")).agg(pl.len().alias("trades")).sort("trades", descending=True).head(10))

import requests

# one BTC hour of fills, no API key
r = requests.get(
    "https://data.vike.io/archive/hl-samples/fills-sample.parquet",
)
with open("fills-sample.parquet", "wb") as f:
    f.write(r.content)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# every open BTC position in the snapshots between 12:00 and 12:05 UTC on 2026-10-01
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/positions?symbol=BTC&start=2026-10-01T12:00:00Z&end=2026-10-01T12:05:00Z&limit=3",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# everything one wallet held in the last snapshot of the 12:00 UTC hour on 2026-10-01
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/positions?wallet=0x25773676902085225ae5751075e4161369334897&start=2026-10-01T12:00:00Z&end=2026-10-01T13:00:00Z&limit=500",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# next page: the first page's nextCursor, sent back with the same start and end
URL = "https://data.vike.io/v1/hyperliquid/positions?symbol=BTC&start=2026-10-01T12:00:00Z&end=2026-10-01T12:05:00Z&limit=5000"
NEXT = requests.get(URL, headers={"X-API-Key": API_KEY}).json()["nextCursor"]
r = requests.get(
    f"{URL}&cursor={NEXT}",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# the BTC positions of the 3x smart wallets at that time
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/positions?symbol=BTC&axis=pnl&cohort=3x_smart&start=2026-10-01T12:00:00Z&end=2026-10-01T12:05:00Z&limit=1000",
    headers={"X-API-Key": API_KEY},
)