Schema reference

curl -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/hyperliquid/positions?symbol=BTC&limit=10"

# Full history is the Parquet archive, one file per UTC day (any day /archive/datasets
# lists; date=latest is the current open positions, replaced every 5 minutes).
# Ask for a link to the file, then download it: the link needs no key and is
# valid 7 days (expires_in in the answer).
DAY=YYYY-MM-DD
URL=$(curl -s -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/hyperliquid/archive/url?dataset=positions&date=$DAY" | jq -r '.url')
curl -f -o positions.parquet "$URL"

# Or the free sample, no key:
curl -O https://data.vike.io/archive/hl-samples/positions-sample.parquet

import os, requests
import pyarrow.parquet as pq

H = {"X-API-KEY": os.environ["VIKE_API_KEY"]}
day = "YYYY-MM-DD"   # any day https://data.vike.io/v1/hyperliquid/archive/datasets lists
ask = requests.get("https://data.vike.io/v1/hyperliquid/archive/url",
                   params={"dataset": "positions", "date": day}, headers=H, timeout=30)
ask.raise_for_status()

# The link needs no key and is valid 7 days (expires_in): download the file,
# then read it locally.
with requests.get(ask.json()["url"], stream=True, timeout=600) as r:
    r.raise_for_status()
    with open("positions.parquet", "wb") as f:
        for chunk in r.iter_content(1 << 20):
            f.write(chunk)

table = pq.read_table("positions.parquet")
print(table.num_rows, table.schema.names)

import polars as pl

df = pl.read_parquet("positions.parquet")   # downloaded first — see the cURL tab
last = df.filter(pl.col("snapshot_ts") == pl.col("snapshot_ts").max())
bias = (
    last.group_by("asset")
        .agg((pl.col("size_usd") * pl.col("direction")).sum().alias("net_usd"),
             pl.col("size_usd").sum().alias("open_usd"))
        .sort("open_usd", descending=True)
)
print(bias.head())

-- positions.parquet downloaded first (see the cURL tab), then read locally
SELECT asset,
       sum(size_usd * direction) AS net_usd,
       sum(size_usd)             AS open_usd
FROM   'positions.parquet'
WHERE  snapshot_ts = (SELECT max(snapshot_ts) FROM 'positions.parquet')
GROUP  BY asset
ORDER  BY open_usd DESC
LIMIT  10;

# replace each {placeholder} with your own value
curl -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/hyperliquid/wallets/{address}/fills?limit=50"

# Full history is the Parquet archive, one file per UTC day (any day /archive/datasets
# lists).
# Ask for a link to the file, then download it: the link needs no key and is
# valid 7 days (expires_in in the answer).
DAY=YYYY-MM-DD
URL=$(curl -s -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/hyperliquid/archive/url?dataset=fills&date=$DAY" | jq -r '.url')
curl -f -o fills.parquet "$URL"

# Or the free sample, no key:
curl -O https://data.vike.io/archive/hl-samples/fills-sample.parquet

import os, requests
import pyarrow.parquet as pq

H = {"X-API-KEY": os.environ["VIKE_API_KEY"]}
day = "YYYY-MM-DD"   # any day https://data.vike.io/v1/hyperliquid/archive/datasets lists
ask = requests.get("https://data.vike.io/v1/hyperliquid/archive/url",
                   params={"dataset": "fills", "date": day}, headers=H, timeout=30)
ask.raise_for_status()

# The link needs no key and is valid 7 days (expires_in): download the file,
# then read it locally.
with requests.get(ask.json()["url"], stream=True, timeout=600) as r:
    r.raise_for_status()
    with open("fills.parquet", "wb") as f:
        for chunk in r.iter_content(1 << 20):
            f.write(chunk)

table = pq.read_table("fills.parquet")
print(table.num_rows, table.schema.names)

import polars as pl

df = pl.read_parquet("fills.parquet")   # downloaded first — see the cURL tab
# both wallets of a trade are rows: the taker side (crossed) counts a trade once
by_asset = (
    df.group_by("asset")
      .agg(pl.col("size_usd").filter(pl.col("crossed")).sum().alias("taker_volume_usd"),
           pl.len().alias("fills"))
      .sort("taker_volume_usd", descending=True)
)
print(by_asset.head())

-- fills.parquet downloaded first (see the cURL tab), then read locally
-- both wallets of a trade are rows: the taker side (crossed) counts a trade once
SELECT asset,
       count(*)                              AS fills,
       sum(size_usd) FILTER (WHERE crossed)  AS taker_volume_usd
FROM   'fills.parquet'
GROUP  BY asset
ORDER  BY taker_volume_usd DESC
LIMIT  10;

curl -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&interval=1m&market=perp&limit=48"

import os, requests

r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&interval=1m&market=perp&limit=48",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
)
r.raise_for_status()
body = r.json()

import os, requests
import polars as pl

body = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&interval=1m&market=perp&limit=48",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
).json()
rows = body if isinstance(body, list) else next(v for v in body.values() if isinstance(v, list))
df = pl.DataFrame(rows)
print(df.head())

curl -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=1"

import os, requests

r = requests.get(
    "https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=1",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
)
r.raise_for_status()
body = r.json()
# list routes page by keyset: pass body["nextCursor"] back as cursor=… until it is null

import os, requests
import polars as pl

body = requests.get(
    "https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=1",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
).json()
rows = body if isinstance(body, list) else next(v for v in body.values() if isinstance(v, list))
df = pl.DataFrame(rows)
print(df.head())

curl -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/hyperliquid/liquidations?limit=20"

import os, requests

r = requests.get(
    "https://data.vike.io/v1/hyperliquid/liquidations?limit=20",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
)
r.raise_for_status()
body = r.json()
# list routes page by keyset: pass body["nextCursor"] back as cursor=… until it is null

import os, requests
import polars as pl

body = requests.get(
    "https://data.vike.io/v1/hyperliquid/liquidations?limit=20",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
).json()
rows = body if isinstance(body, list) else next(v for v in body.values() if isinstance(v, list))
df = pl.DataFrame(rows)
print(df.head())

# replace each {placeholder} with your own value
curl -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/polymarket/events?token_id={token_id}&from_ms={from_ms}&to_ms={to_ms}&event_type=price_change&limit=50"

# Full history is the Parquet archive. Pick a date from manifest.json (no key needed),
# download the whole file, then read it locally:
DAY=YYYY-MM-DD
curl -H "X-API-KEY: $VIKE_API_KEY" -O \
  "https://data.vike.io/archive/venue=polymarket/date=$DAY/book_events.parquet"

# Or the free sample — one complete market, no key:
curl -O https://data.vike.io/archive/samples/book_events.parquet

import os, requests
import pyarrow.parquet as pq

H = {"X-API-KEY": os.environ["VIKE_API_KEY"]}
day = "YYYY-MM-DD"   # any date listed in https://data.vike.io/archive/manifest.json
url = f"https://data.vike.io/archive/venue=polymarket/date={day}/book_events.parquet"

# Download the whole file once, then read it locally — a remote Parquet
# reader re-fetches the footer and column chunks on every query.
with requests.get(url, headers=H, stream=True, timeout=600) as r:
    r.raise_for_status()
    with open("book_events.parquet", "wb") as f:
        for chunk in r.iter_content(1 << 20):
            f.write(chunk)

table = pq.read_table("book_events.parquet")
print(table.num_rows, table.schema.names)

import polars as pl

df = pl.read_parquet("book_events.parquet")   # downloaded first — see the cURL tab
df = df.with_columns(pl.from_epoch("ts", time_unit="ms").alias("time"))
print(df.group_by("event_type").len().sort("len", descending=True))

-- book_events.parquet downloaded first (see the cURL tab), then read locally
SELECT event_type,
       count(*)              AS events,
       count(DISTINCT token_id) AS tokens
FROM   'book_events.parquet'
GROUP  BY event_type
ORDER  BY events DESC;

# replace each {placeholder} with your own value
curl -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/polymarket/events?token_id={token_id}&from_ms={from_ms}&to_ms={to_ms}&event_type=trade&limit=50"

# Full history is the Parquet archive. Pick a date from manifest.json (no key needed),
# download the whole file, then read it locally:
DAY=YYYY-MM-DD
curl -H "X-API-KEY: $VIKE_API_KEY" -O \
  "https://data.vike.io/archive/venue=polymarket/date=$DAY/trades.parquet"

# Or the free sample — one complete market, no key:
curl -O https://data.vike.io/archive/samples/trades.parquet

import os, requests
import pyarrow.parquet as pq

H = {"X-API-KEY": os.environ["VIKE_API_KEY"]}
day = "YYYY-MM-DD"   # any date listed in https://data.vike.io/archive/manifest.json
url = f"https://data.vike.io/archive/venue=polymarket/date={day}/trades.parquet"

# Download the whole file once, then read it locally — a remote Parquet
# reader re-fetches the footer and column chunks on every query.
with requests.get(url, headers=H, stream=True, timeout=600) as r:
    r.raise_for_status()
    with open("trades.parquet", "wb") as f:
        for chunk in r.iter_content(1 << 20):
            f.write(chunk)

table = pq.read_table("trades.parquet")
print(table.num_rows, table.schema.names)

import polars as pl

df = pl.read_parquet("trades.parquet")   # downloaded first — see the cURL tab
df = df.with_columns(pl.from_epoch("ts", time_unit="ms").alias("time"))
vwap = (
    df.group_by("token_id")
      .agg(((pl.col("price") * pl.col("size")).sum() / pl.col("size").sum()).alias("vwap"),
           pl.len().alias("prints"))
      .sort("prints", descending=True)
)
print(vwap.head())

-- trades.parquet downloaded first (see the cURL tab), then read locally
SELECT token_id,
       count(*)                      AS prints,
       sum(size)                     AS shares,
       sum(price * size) / sum(size) AS vwap,
       epoch_ms(min(ts))             AS first_print
FROM   'trades.parquet'
GROUP  BY token_id
ORDER  BY prints DESC
LIMIT  10;

# replace each {placeholder} with your own value
curl -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/polymarket/markets/{condition_id}/trades?limit=50"

import os, requests

r = requests.get(
    "https://data.vike.io/v1/polymarket/markets/{condition_id}/trades?limit=50",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
)
r.raise_for_status()
body = r.json()

import os, requests
import polars as pl

body = requests.get(
    "https://data.vike.io/v1/polymarket/markets/{condition_id}/trades?limit=50",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
).json()
rows = body if isinstance(body, list) else next(v for v in body.values() if isinstance(v, list))
df = pl.DataFrame(rows)
print(df.head())

curl -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/polymarket/archive/datasets?limit=1000"

# Full history is the Parquet archive. Pick a date from manifest.json (no key needed),
# download the whole file, then read it locally:
DAY=YYYY-MM-DD
curl -H "X-API-KEY: $VIKE_API_KEY" -O \
  "https://data.vike.io/archive/venue=polymarket/date=$DAY/l1_quotes.parquet"

# Or the free sample — one complete market, no key:
curl -O https://data.vike.io/archive/samples/l1_quotes.parquet

import os, requests
import pyarrow.parquet as pq

H = {"X-API-KEY": os.environ["VIKE_API_KEY"]}
day = "YYYY-MM-DD"   # any date listed in https://data.vike.io/archive/manifest.json
url = f"https://data.vike.io/archive/venue=polymarket/date={day}/l1_quotes.parquet"

# Download the whole file once, then read it locally — a remote Parquet
# reader re-fetches the footer and column chunks on every query.
with requests.get(url, headers=H, stream=True, timeout=600) as r:
    r.raise_for_status()
    with open("l1_quotes.parquet", "wb") as f:
        for chunk in r.iter_content(1 << 20):
            f.write(chunk)

table = pq.read_table("l1_quotes.parquet")
print(table.num_rows, table.schema.names)

import polars as pl

df = pl.read_parquet("l1_quotes.parquet")   # downloaded first — see the cURL tab
df = df.with_columns(pl.from_epoch("ts", time_unit="ms").alias("time"))
spread = (
    df.with_columns((pl.col("ask") - pl.col("bid")).alias("spread"))
      .group_by("token_id")
      .agg(pl.len().alias("changes"), pl.col("spread").mean().alias("avg_spread"))
      .sort("changes", descending=True)
)
print(spread.head())

-- l1_quotes.parquet downloaded first (see the cURL tab), then read locally
SELECT token_id,
       count(*)          AS changes,
       avg(ask - bid)    AS avg_spread,
       epoch_ms(min(ts)) AS first_quote,
       epoch_ms(max(ts)) AS last_quote
FROM   'l1_quotes.parquet'
GROUP  BY token_id
ORDER  BY changes DESC
LIMIT  10;

curl -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/polymarket/markets?active=true&limit=25"

import os, requests

r = requests.get(
    "https://data.vike.io/v1/polymarket/markets?active=true&limit=25",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
)
r.raise_for_status()
body = r.json()

import os, requests
import polars as pl

body = requests.get(
    "https://data.vike.io/v1/polymarket/markets?active=true&limit=25",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
).json()
rows = body if isinstance(body, list) else next(v for v in body.values() if isinstance(v, list))
df = pl.DataFrame(rows)
print(df.head())

curl -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/onchain/tokens/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/transfers?period=24h&chain=ethereum"

import os, requests

r = requests.get(
    "https://data.vike.io/v1/onchain/tokens/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/transfers?period=24h&chain=ethereum",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
)
r.raise_for_status()
body = r.json()

import os, requests
import polars as pl

body = requests.get(
    "https://data.vike.io/v1/onchain/tokens/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/transfers?period=24h&chain=ethereum",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
).json()
rows = body if isinstance(body, list) else next(v for v in body.values() if isinstance(v, list))
df = pl.DataFrame(rows)
print(df.head())

# replace each {placeholder} with your own value
curl -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/onchain/labels/{address}/provenance"

import os, requests

r = requests.get(
    "https://data.vike.io/v1/onchain/labels/{address}/provenance",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
)
r.raise_for_status()
body = r.json()

import os, requests
import polars as pl

body = requests.get(
    "https://data.vike.io/v1/onchain/labels/{address}/provenance",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
).json()
rows = body if isinstance(body, list) else next(v for v in body.values() if isinstance(v, list))
df = pl.DataFrame(rows)
print(df.head())

curl -H "X-API-KEY: $VIKE_API_KEY" \
  "https://data.vike.io/v1/onchain/tokens/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/holders?chain=ethereum&limit=10"

import os, requests

r = requests.get(
    "https://data.vike.io/v1/onchain/tokens/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/holders?chain=ethereum&limit=10",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
)
r.raise_for_status()
body = r.json()

import os, requests
import polars as pl

body = requests.get(
    "https://data.vike.io/v1/onchain/tokens/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48/holders?chain=ethereum&limit=10",
    headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
    timeout=30,
).json()
rows = body if isinstance(body, list) else next(v for v in body.values() if isinstance(v, list))
df = pl.DataFrame(rows)
print(df.head())