Hyperliquid long/short ratio — whales, smart money and retail, every hour
Who is long and who is short on Hyperliquid, split by cohort: whales and shrimp by account size, smart money and rekt traders by realized PnL. The long/short ratio of BTC, ETH, SOL and HYPE live, what each of 25 cohorts holds, the Smart Money and Whale-vs-Shrimp indices and the large fills, with every number on one free key: ask Claude or ChatGPT, or call the API.
“Are Hyperliquid whales long or short BTC right now?”
hl_cohort_metrics“Which Hyperliquid cohorts hold the most right now, and is each net long or net short?”
hl_segments“Is the Smart Money Index for HYPE rising or falling over the last 24 hours?”
hl_marketHyperliquid long/short ratio: BTC, ETH, SOL and HYPE by cohort
The coin's long/short ratio at the latest hour, and each cohort's bias beside it. Switch the coin and the ladder: size (whales to shrimp), tier (position size) or pnl (smart money to rekt).
Long/short by cohort · /symbols/{symbol}/cohort-metrics
/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=1https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=1Whales, smart money and retail: what each cohort holds now
Every cohort of the account-size and realized-PnL ladders at the latest 5-minute snapshot, summed over every coin: long and short, bias, wallets, how many are in profit, leverage on equity and unrealized PnL. Each card opens that cohort on vike.io.
Account size: whales to shrimp
4x whaleaccount value $10M or more
- Bias
- leans short · −0.41
- Long / short
- $1.2B / $2.8B
- Wallets
- 79
- In profit
- 71%
- Exposure on equity
- 2.1×
- Unrealized PnL
- $353M
3x whaleaccount value $5M to $10M
- Bias
- balanced · −0.01
- Long / short
- $810M / $826M
- Wallets
- 111
- In profit
- 50%
- Exposure on equity
- 1.8×
- Unrealized PnL
- −$31.4M
2x whaleaccount value $2.5M to $5M
- Bias
- slightly long · +0.06
- Long / short
- $724M / $643M
- Wallets
- 196
- In profit
- 52%
- Exposure on equity
- 1.9×
- Unrealized PnL
- −$28.4M
whaleaccount value $1M to $2.5M
- Bias
- slightly long · +0.11
- Long / short
- $852M / $686M
- Wallets
- 438
- In profit
- 53%
- Exposure on equity
- 2.1×
- Unrealized PnL
- −$18.0M
2x sharkaccount value $500k to $1M
- Bias
- leans long · +0.23
- Long / short
- $564M / $357M
- Wallets
- 573
- In profit
- 47%
- Exposure on equity
- 2.1×
- Unrealized PnL
- −$36.3M
sharkaccount value $250k to $500k
- Bias
- leans long · +0.27
- Long / short
- $466M / $269M
- Wallets
- 892
- In profit
- 46%
- Exposure on equity
- 2.1×
- Unrealized PnL
- −$26.3M
2x dolphinaccount value $100k to $250k
- Bias
- leans long · +0.36
- Long / short
- $526M / $246M
- Wallets
- 2,004
- In profit
- 43%
- Exposure on equity
- 2.2×
- Unrealized PnL
- −$42.1M
dolphinaccount value $50k to $100k
- Bias
- leans long · +0.44
- Long / short
- $317M / $123M
- Wallets
- 2,402
- In profit
- 37%
- Exposure on equity
- 2.4×
- Unrealized PnL
- −$27.6M
2x fishaccount value $25k to $50k
- Bias
- leans long · +0.47
- Long / short
- $242M / $86.5M
- Wallets
- 3,239
- In profit
- 35%
- Exposure on equity
- 2.6×
- Unrealized PnL
- −$25.8M
fishaccount value $10k to $25k
- Bias
- leans long · +0.49
- Long / short
- $222M / $76.5M
- Wallets
- 6,407
- In profit
- 36%
- Exposure on equity
- 2.6×
- Unrealized PnL
- −$22.0M
2x shrimpaccount value $1k to $10k
- Bias
- leans long · +0.57
- Long / short
- $256M / $69.3M
- Wallets
- 25,967
- In profit
- 33%
- Exposure on equity
- 3.3×
- Unrealized PnL
- −$26.1M
shrimpaccount value under $1k
- Bias
- leans long · +0.53
- Long / short
- $57.2M / $17.7M
- Wallets
- 93,801
- In profit
- 36%
- Exposure on equity
- 4.3×
- Unrealized PnL
- −$4.6M
Realized PnL: smart money to rekt
3x smartthe top 1% of traders by cumulative realized PnL (10+ closed trades)
- Bias
- slightly short · −0.15
- Long / short
- $2.9B / $3.9B
- Wallets
- 2,358
- In profit
- 41%
- Exposure on equity
- 2.3×
- Unrealized PnL
- $136M
2x smarttraders ranked 1% to 5% from the top by cumulative realized PnL (10+ closed trades)
- Bias
- leans long · +0.34
- Long / short
- $511M / $249M
- Wallets
- 6,796
- In profit
- 30%
- Exposure on equity
- 1.9×
- Unrealized PnL
- −$36.4M
smarttraders ranked 5% to 10% from the top by cumulative realized PnL (10+ closed trades)
- Bias
- leans long · +0.31
- Long / short
- $110M / $57.2M
- Wallets
- 7,600
- In profit
- 30%
- Exposure on equity
- 1.8×
- Unrealized PnL
- −$6.9M
3x winnertraders ranked 10% to 20% from the top by cumulative realized PnL (10+ closed trades)
- Bias
- leans long · +0.28
- Long / short
- $50.8M / $28.4M
- Wallets
- 11,653
- In profit
- 32%
- Exposure on equity
- 1.7×
- Unrealized PnL
- −$7.6M
2x winnertraders ranked 20% to 30% from the top by cumulative realized PnL (10+ closed trades)
- Bias
- slightly long · +0.13
- Long / short
- $7.0M / $5.4M
- Wallets
- 8,147
- In profit
- 35%
- Exposure on equity
- 1.4×
- Unrealized PnL
- −$91.1k
winnertraders ranked 30% to 40% from the top by cumulative realized PnL (10+ closed trades)
- Bias
- leans long · +0.50
- Long / short
- $1.4M / $476k
- Wallets
- 4,225
- In profit
- 40%
- Exposure on equity
- 1.4×
- Unrealized PnL
- −$50.6k
losertraders ranked 40% to 60% from the top by cumulative realized PnL (10+ closed trades)
- Bias
- slightly short · −0.02
- Long / short
- $6.6M / $6.9M
- Wallets
- 9,415
- In profit
- 46%
- Exposure on equity
- 1.8×
- Unrealized PnL
- −$191k
2x losertraders ranked 60% to 70% from the top by cumulative realized PnL (10+ closed trades)
- Bias
- leans long · +0.25
- Long / short
- $5.0M / $3.0M
- Wallets
- 6,304
- In profit
- 42%
- Exposure on equity
- 1.5×
- Unrealized PnL
- −$324k
3x losertraders ranked 70% to 80% from the top by cumulative realized PnL (10+ closed trades)
- Bias
- leans long · +0.33
- Long / short
- $16.5M / $8.3M
- Wallets
- 7,968
- In profit
- 39%
- Exposure on equity
- 1.9×
- Unrealized PnL
- −$1.0M
rekttraders ranked 80% to 90% from the top by cumulative realized PnL (10+ closed trades)
- Bias
- leans long · +0.40
- Long / short
- $60.0M / $25.6M
- Wallets
- 10,223
- In profit
- 36%
- Exposure on equity
- 1.9×
- Unrealized PnL
- −$3.0M
2x rekttraders ranked 90% to 95% from the top by cumulative realized PnL (10+ closed trades)
- Bias
- leans long · +0.43
- Long / short
- $213M / $85.0M
- Wallets
- 6,135
- In profit
- 35%
- Exposure on equity
- 2.5×
- Unrealized PnL
- $5.6M
3x rektthe bottom 5% of traders by cumulative realized PnL (10+ closed trades)
- Bias
- slightly long · +0.08
- Long / short
- $2.0B / $1.7B
- Wallets
- 7,244
- In profit
- 36%
- Exposure on equity
- 1.9×
- Unrealized PnL
- −$41.5M
unknownwallets with fewer than 10 closed trades, too few to rank by realized PnL
- Bias
- leans long · +0.42
- Long / short
- $388M / $159M
- Wallets
- 48,029
- In profit
- 36%
- Exposure on equity
- 2.2×
- Unrealized PnL
- $19.3M
Captured 2026-11-13 22:55:51 UTC: each card is the answer of GET /v1/hl-cohorts/segments/4x_whale/summary?axis=size and its 24 siblings, at /data/showcase/ds_hl_cohorts_live.json.
The four cohort ladders and their bounds
Three ladders grade a wallet, one grades a position. The labels are the exact strings the API returns; a path takes the slug. GET /v1/hl-cohorts/segments returns these rows, each with axis, cohort, slug, rank, basis, applies_to, groupable, min_usd, max_usd, percentile_min, percentile_max, min_closed_trades; groupable is false on the position ladder, which /segments names trade_size.
Account size axis=size13 buckets
The wallet's account value in USD; bounds are [min, max).
| 1 | 4x whale 4x_whale | account value $10M or more |
| 2 | 3x whale 3x_whale | account value $5M to $10M |
| 3 | 2x whale 2x_whale | account value $2.5M to $5M |
| 4 | whale | account value $1M to $2.5M |
| 5 | 2x shark 2x_shark | account value $500k to $1M |
| 6 | shark | account value $250k to $500k |
| 7 | 2x dolphin 2x_dolphin | account value $100k to $250k |
| 8 | dolphin | account value $50k to $100k |
| 9 | 2x fish 2x_fish | account value $25k to $50k |
| 10 | fish | account value $10k to $25k |
| 11 | 2x shrimp 2x_shrimp | account value $1k to $10k |
| 12 | shrimp | account value under $1k |
unknown | account value not known for that hour (only an hour rebuilt from fills has it) |
unknown: the wallet's account value is not known for that hour: the hour was rebuilt from the fill stream after a snapshot gap, which recovers positions but not the cash behind them, and the wallet was not in the real snapshot the rebuild started from. Only stored hours carry it (cohort-metrics with axis=size); the live snapshot knows every wallet's account value, so it is not a filter value. Keep its rows: a coin's ladder sums to its total only with them.
Realized PnL rank axis=pnl13 buckets
The percentile of the wallet's cumulative realized PnL among ranked wallets; 0% is the best.
| 1 | 3x smart 3x_smart | the top 1% of traders by cumulative realized PnL (10+ closed trades) |
| 2 | 2x smart 2x_smart | traders ranked 1% to 5% from the top by cumulative realized PnL (10+ closed trades) |
| 3 | smart | traders ranked 5% to 10% from the top by cumulative realized PnL (10+ closed trades) |
| 4 | 3x winner 3x_winner | traders ranked 10% to 20% from the top by cumulative realized PnL (10+ closed trades) |
| 5 | 2x winner 2x_winner | traders ranked 20% to 30% from the top by cumulative realized PnL (10+ closed trades) |
| 6 | winner | traders ranked 30% to 40% from the top by cumulative realized PnL (10+ closed trades) |
| 7 | loser | traders ranked 40% to 60% from the top by cumulative realized PnL (10+ closed trades) |
| 8 | 2x loser 2x_loser | traders ranked 60% to 70% from the top by cumulative realized PnL (10+ closed trades) |
| 9 | 3x loser 3x_loser | traders ranked 70% to 80% from the top by cumulative realized PnL (10+ closed trades) |
| 10 | rekt | traders ranked 80% to 90% from the top by cumulative realized PnL (10+ closed trades) |
| 11 | 2x rekt 2x_rekt | traders ranked 90% to 95% from the top by cumulative realized PnL (10+ closed trades) |
| 12 | 3x rekt 3x_rekt | the bottom 5% of traders by cumulative realized PnL (10+ closed trades) |
unknown | wallets with fewer than 10 closed trades, too few to rank by realized PnL |
Stable in population: the top rung is always the top 1% of ranked wallets.
Realized PnL in dollars axis=pnl_abs9 buckets
The same cumulative realized PnL, banded in dollars; bounds are [min, max).
| 1 | $1m+ 1m_plus | realized PnL $1M or more |
| 2 | $100k-$1m 100k_to_1m | realized PnL $100k to $1M |
| 3 | $10k-$100k 10k_to_100k | realized PnL $10k to $100k |
| 4 | $0-$10k 0_to_10k | realized PnL $0 to $10k |
| 5 | -$10k-$0 neg10k_to_0 | realized PnL −$10k to $0 |
| 6 | -$100k--$10k neg100k_to_neg10k | realized PnL −$100k to −$10k |
| 7 | -$1m--$100k neg1m_to_neg100k | realized PnL −$1M to −$100k |
| 8 | <-$1m below_neg1m | realized PnL under −$1M |
unknown | not in the realized-PnL record yet |
Stable in meaning: $1M is $1M in any month.
Position size axis=tier10 buckets
One position's notional, not the wallet's: a small account can hold a large position at leverage.
| 1 | >$2.5m above_2_5m | positions of $2.5M or more |
| 2 | $1m-$2.5m 1m_to_2_5m | positions of $1M to $2.5M |
| 3 | $500k-$1m 500k_to_1m | positions of $500k to $1M |
| 4 | $250k-$500k 250k_to_500k | positions of $250k to $500k |
| 5 | $100k-$250k 100k_to_250k | positions of $100k to $250k |
| 6 | $50k-$100k 50k_to_100k | positions of $50k to $100k |
| 7 | $25k-$50k 25k_to_50k | positions of $25k to $50k |
| 8 | $10k-$25k 10k_to_25k | positions of $10k to $25k |
| 9 | $1k-$10k 1k_to_10k | positions of $1k to $10k |
| 10 | <$1k below_1k | positions of under $1k |
Ask for it as axis=tier on cohort-metrics, or read /symbols/{symbol}/size-breakdown.
Smart Money Index and Whale-vs-Shrimp Index
SMI is the long share of the smart rungs (3x smart, 2x smart, smart) minus that of the rekt rungs (rekt, 2x rekt, 3x rekt); WSI is the long share of the whale rungs (4x whale to whale) minus that of shrimp and 2x shrimp. Both run from −1 to +1.
SMI and WSI · /symbols/{symbol}/indices
/v1/hl-cohorts/symbols/BTC/indices?hours=24Every coin × every cohort: who leans long, who leans short
Each cohort's bias on each coin at the latest snapshot, on the size or the pnl ladder. An empty cell is blank, never 0.
Coin × cohort · /heatmap
/v1/hl-cohorts/heatmap?axis=sizeLarge fills by cohort
The newest 20 fills of $50,000 or more on each coin, with the account-size and realized-PnL cohort of the wallet behind each.
BTC fills of $50,000 or more · /symbols/BTC/large-fills
/v1/hl-cohorts/symbols/BTC/large-fills?limit=20ETH fills of $50,000 or more · /symbols/ETH/large-fills
/v1/hl-cohorts/symbols/ETH/large-fills?limit=20SOL fills of $50,000 or more · /symbols/SOL/large-fills
/v1/hl-cohorts/symbols/SOL/large-fills?limit=20HYPE fills of $50,000 or more · /symbols/HYPE/large-fills
/v1/hl-cohorts/symbols/HYPE/large-fills?limit=20Everything free on one key
REST, the WebSocket, alerts and webhooks, MCP, the CLI and the Parquet archive.
11 routes under /v1/hl-cohorts
Every cohort, every coin, hourly or at the latest 5-minute snapshot, as JSON.
Every route →4 live channels
Cohort flow, bias, leverage and the indices pushed as they are made, at wss://stream.vike.io/v1/stream/hl-cohorts.
hl.cohort_biashl.cohort_flowhl.cohort_leveragehl.indices
3 no-code cohort alerts
By e-mail or to your webhook, made on your account page, by your AI or with the CLI.
hl_cohort_biashl_cohort_fillhl_liquidation
Ask in Claude, ChatGPT or Cursor
Your AI picks the tool and answers with live numbers; hl_cohort_metrics 1 credit, hl_segments 1 credit a call.
hl_cohort_metricshl_segments
vike-data on your terminal
The same data from a shell: npm install -g @vike-io/cli, then vike-data init.
vike-data hl cohort-metricsvike-data hl segments
Every snapshot, labelled
The positions archive carries each row's size cohort and point-in-time PnL cohort, one file per UTC day.
positions
hl_cohort_biasA cohort index crosses your line
An index of one coin (smi, wsi, smart_bias, whale_bias, smi_wsi_gap) crosses your threshold: one e-mail or webhook per crossing, re-armed once it retreats by your band.
hl_cohort_fillA cohort fills big
Every fill by wallets of the cohorts you pick, from $10,000 up.
hl_liquidationA cohort gets liquidated
Every liquidation above your floor, of the cohorts you pick or of one coin.
Every route, channel, tool and alert in full: AI & API →
The five HL Cohorts datasets
Fields, real rows from the API and the code to load each one.
Cohort positioning
What one cohort holds across every symbol: long and short notional, bias, wallets in profit and leverage over native perp equity at the latest snapshot, or long, short and bias hour by hour from 2026-04-07 (axis=size or pnl), with the leverage ratios on request.
- Routes
/v1/hl-cohorts/segments/{cohort}/summary,/v1/hl-cohorts/segments/{cohort}/history- Built on
- Position snapshots
- MCP
hl_segments
Real rows
Cohort positioning · rows
Fields of /segments/{cohort}/summary
| Field | Type | Description |
|---|---|---|
axis | string | size | pnl | pnl_abs |
cohort | string | The API label, e.g. whale or 3x smart |
opened_within | string | The openedWithin window asked for: 24h | 7d | 30d | all |
snapshot_ts | string | The 5-minute snapshot read, ISO-8601 UTC |
total_long_usd | number | Long notional, USD |
total_short_usd | number | Short notional, USD |
bias | number | (long − short) / (long + short); null when the cohort holds nothing |
n_wallets | integer | Wallets of the cohort with an open position |
n_wallets_in_profit | integer | Of those, the wallets whose open positions are in profit |
pct_wallets_in_profit | number | Share of those wallets whose open positions are in profit, 0–1 |
n_positions | integer | Open positions |
total_unrealized_pnl | number | Unrealized PnL of the open positions, USD |
equity_exposure | number | (long + short) / native perp equity of the counted wallets: leverage on equity |
perp_bias | number | (long − short) / that equity |
total_margin_used | number | Margin the open positions use, USD |
exposure_ratio | number | Notional / margin used |
total_equity | number | The cohort's account value, USD |
n_wallets_with_equity | integer | Wallets of the cohort with a non-zero account value |
by_side | object | long and short: value_usd, share, n_positions, n_wallets, margin_used, unrealized_pnl |
Fields of /segments/{cohort}/history (each row of series)
| Field | Type | Description |
|---|---|---|
ts | string | Hour, ISO-8601 UTC, newest first |
long_usd | number | Long notional, USD |
short_usd | number | Short notional, USD |
bias | number | (long − short) / (long + short) |
position_count | integer | Open positions: (wallet, symbol) pairs |
The envelope of /segments/{cohort}/history
| Field | Type | Description |
|---|---|---|
axis | string | size | pnl |
cohort | string | The API label |
label_basis | string | point_in_time on both axes |
data_from | string | The first hour served, ISO-8601 UTC |
series | array | The rows above, newest first |
has_more | boolean | Older hours exist beyond limit |
label_computed | object | On axis=pnl: when the labels were computed |
leverage | object | With include=leverage: data_from, scope and note (hours rebuilt from fills are null) |
Load it
GET /v1/hl-cohorts/segments/{cohort}/summary · What one cohort holds now
- CLI
- —
- MCP
hl_segments· 1 credit- Cost
- 1 credit, one request of the hourly limit
Aggregate positioning for one cohort at the latest snapshot.
perp_bias = (long - short) / equity and equity_exposure = (long + short) / equity: positions on the main dex over the equity of the wallets holding them, each wallet counted once: the native perp account value, plus for a unified or portfolio-margin wallet the USDC it holds outside it (its margin draws on it; the native account alone is about margin-sized). Builder-DEX positions and accounts are not included, and wallets without a known positive equity are left out of perp_bias, equity_exposure and the numerator of equity_covered_share (main-dex notional of the counted wallets / main-dex notional of the whole cohort). Unbounded ratios (above 1 = more than 1x of equity), null when that equity <= 0. That equity is not total_equity, so perp_bias x total_equity is not total_long_usd - total_short_usd. Under openedWithin long/short are the qualifying positions and the equity the whole native account of every wallet holding one. exposure_ratio stays notional / margin used.
Parameters
| Parameter | In | Description |
|---|---|---|
cohortrequired | path | A label or slug from /cohorts / /segments |
axis | query | size | pnl | pnl_abs. Default size. Per-wallet ladders only — trade_size is per-position and is rejected here; see the groupable field on /segments. |
openedWithin | query | 24h | 7d | 30d | all. Default all |
Call it
curl -H "X-API-KEY: $VIKE_API_KEY" \
"https://data.vike.io/v1/hl-cohorts/segments/whale/summary?axis=size"
import os, requests
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/whale/summary?axis=size",
headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
)
print(r.json())
# any MCP client; or from the terminal:
vike-data call hl_segments --args '{"view": "summary", "cohort": "whale", "axis": "size"}'
GET /v1/hl-cohorts/segments/{cohort}/history · One cohort, hour by hour
- CLI
- —
- MCP
hl_segments· 1 credit- Cost
- 1 credit, one request of the hourly limit
One cohort's long / short / bias per hour, summed over every symbol. Ratios in [-1, +1]. A 404 names the axis only. axis=size groups positions by the size cohort stored on each position; axis=pnl by the realized-PnL cohort frozen at that hour (hourly from 2026-08-06, daily before it; see label_computed). Per hour: long_usd and short_usd in USD, bias = (long - short) / (long + short), null when both are 0, and position_count, which counts open positions ((wallet, symbol) pairs), not wallets. Newest first, settled hours only. include=leverage adds the three equity ratios described on that parameter. Data from 2026-04-07 (the first hour cohort labels are correct): an older start is served from there, and the envelope says data_from.
Parameters
| Parameter | In | Description |
|---|---|---|
cohortrequired | path | A label or slug of axis, from /cohorts / /segments |
axisrequired | query | size | pnl: this endpoint serves history for these two only. Required. |
start | query | ISO-8601 UTC. Oldest edge. Omit it for the hours newest hours. |
end | query | ISO-8601 UTC. Newest edge; with no start, the window is the hours newest hours at or before it. |
hours | query | Window length in hours when start is omitted. Default 168, max 8760. |
limit | query | Max rows, newest first, default and max 5000; has_more says there are older ones (page back with end = the oldest ts minus 1 second; end is inclusive). |
include | query | Comma list; only leverage, default none (nothing extra is read). Adds to every row perp_bias = (long - short) / equity, equity_exposure = (long + short) / equity and equity_covered_share = main-dex notional of the counted wallets / main-dex notional of the whole cohort: unbounded ratios (above 1 = more than 1x of equity), main-dex positions of wallets with a known positive equity, each wallet once, over that equity: the native perp account, plus from the 2026-11-07 20:00 UTC hour on the USDC a unified or portfolio-margin wallet holds outside it (earlier hours stay native, so the two ratios step down there); builder-DEX positions are not included. An hour with no stored row, and any hour before leverage.data_from (2026-08-11), is null on all three (never 0). perp_bias and equity_exposure are also null when no counted wallet has a positive equity; equity_covered_share is null when the cohort holds no main-dex notional and a real 0 when it holds some but no wallet is counted. Hours rebuilt from fills rather than read from snapshots are null. An unknown token is a 400. |
Call it
curl -H "X-API-KEY: $VIKE_API_KEY" \
"https://data.vike.io/v1/hl-cohorts/segments/3x_smart/history?axis=pnl&hours=168"
import os, requests
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/3x_smart/history?axis=pnl&hours=168",
headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
)
print(r.json())
# any MCP client; or from the terminal:
vike-data call hl_segments --args '{"view": "history", "cohort": "3x smart", "axis": "pnl", "hours": 168}'
Cohort heatmap
Every symbol against every cohort of one ladder (size, pnl or pnl_abs) at the latest 5-minute snapshot: the whole positioning board in one call.
- Routes
/v1/hl-cohorts/heatmap- Built on
- Position snapshots
- MCP
hl_segments
Real rows
Cohort heatmap · rows
Fields of /heatmap (each row of heatmap)
| Field | Type | Description |
|---|---|---|
symbol | string | The coin |
total_value | number | Open notional, USD |
total_long_value | number | Long notional, USD |
total_short_value | number | Short notional, USD |
bias | number | (long − short) / (long + short) |
count | integer | Open positions |
count_long | integer | …of which long |
count_short | integer | …of which short |
n_wallets | integer | Wallets holding the coin |
segments | array | One cell per cohort: cohort, rank, the same values, share_of_symbol; an empty cell is left out, never 0 |
The envelope of /heatmap
| Field | Type | Description |
|---|---|---|
axis | string | size | pnl | pnl_abs |
opened_within | string | The openedWithin window asked for: 24h | 7d | 30d | all |
snapshot_ts | string | The 5-minute snapshot read, ISO-8601 UTC |
source | string | Where the board was read: the latest position snapshot |
totals | object | The whole board: total_value, total_long_value, total_short_value, bias, count, n_symbols (coins on the board), n_wallets and n_wallets_source |
heatmap | array | The coin rows above |
Load it
GET /v1/hl-cohorts/heatmap · Every coin x every cohort, now
- CLI
- —
- MCP
hl_segments· 1 credit- Cost
- 1 credit, one request of the hourly limit
Coin x cohort positioning matrix — the whole board in one call.
Parameters
| Parameter | In | Description |
|---|---|---|
axis | query | size | pnl | pnl_abs. Default size. Per-wallet ladders only — trade_size is per-position and is rejected here; see the groupable field on /segments. |
openedWithin | query | 24h | 7d | 30d | all. Default all |
Call it
curl -H "X-API-KEY: $VIKE_API_KEY" \
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=size"
import os, requests
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=size",
headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
)
print(r.json())
# any MCP client; or from the terminal:
vike-data call hl_segments --args '{"view": "heatmap", "axis": "size"}'
Large fills
One symbol's fills of $50,000 or more from the last 24 hours, newest first, with the wallet's size and PnL cohort; the feed keeps the newest 200 per symbol, so on a busy symbol it reaches back minutes.
- Routes
/v1/hl-cohorts/symbols/{symbol}/large-fills- Built on
- Fills, Position snapshots
- MCP
hl_market
Real rows
Large fills · rows
Fields of /symbols/{symbol}/large-fills (each row of fills)
| Field | Type | Description |
|---|---|---|
ts | string | Fill time, ISO-8601 UTC |
wallet | string | The wallet |
direction | string | buy | sell |
size_usd | number | Notional, USD |
size_token | number | Size in coin units |
price | number | Fill price |
order_type | string | market (crossed the book) | limit (rested) |
size_cohort | string | The wallet's account-size cohort |
pnl_cohort | string | The wallet's realized-PnL cohort |
pnl_cohort_basis | string | point_in_time (graded at the fill's hour) | current |
Load it
GET /v1/hl-cohorts/symbols/{symbol}/large-fills · A coin's large fills, newest first
- CLI
- —
- MCP
hl_market· 1 credit- Cost
- 1 credit, one request of the hourly limit
The asset page's Whale Activity feed: a symbol's large fills, newest first. The feed keeps only the newest 200 fills over $50k per symbol of the last 24 hours, so on a busy symbol that is minutes, not a day: covered_from is how far back the answer reaches, truncated says that cap may have cut older fills inside the window, has_more that limit cut rows. Each row has ts, wallet, direction (buy | sell), size_token, size_usd, price, order_type (market = crossed the book, limit = rested), size_cohort (the wallet's size rung on its latest snapshot) and pnl_cohort (graded at the fill's own hour where that hour is labelled, else today; pnl_cohort_basis says which). Liquidations are not flagged.
Parameters
| Parameter | In | Description |
|---|---|---|
symbolrequired | path | HL ticker |
min_usd | query | Smallest fill in USD. Default and MINIMUM 50000: the feed behind this route holds nothing smaller. |
hours | query | How far back, in hours. Default and max 24: the feed holds a day. |
limit | query | Max rows, newest first. Default 200 (all the feed holds per symbol), max 1000; has_more says a lower limit cut rows. |
Call it
curl -H "X-API-KEY: $VIKE_API_KEY" \
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/large-fills?limit=20"
import os, requests
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/large-fills?limit=20",
headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
)
print(r.json())
# any MCP client; or from the terminal:
vike-data call hl_market --args '{"view": "large_fills", "symbol": "BTC", "limit": 20}'
Cohort metrics
One coin's positioning across every cohort of a ladder, hourly — all history since April 2026 in one request.
- Route
/v1/hl-cohorts/symbols/{symbol}/cohort-metrics- Cadence
- Hourly buckets
- Coverage
- One coin, every cohort on an axis (size, tier, pnl, pnl_abs, pnl_unrealized), hourly from 2026-04-07, all of it in one request, paged by hour. axis=size, axis=tier and axis=pnl_unrealized are always point_in_time; axis=pnl takes labelBasis=point_in_time (each hour's label as it was then — point-in-time labels from 2026-04-07) or current; every response declares which in label_basis and label_computed. /segments publishes every ladder's bounds.
- Rows
- MCP
hl_cohort_metrics
Real rows
Cohort metrics · rows
Fields
| Field | Type | Description |
|---|---|---|
ts | string | Hour bucket, ISO-8601 UTC |
cohort | string | Rung on the chosen axis, e.g. whale, 3x smart, $1m-$2.5m |
position_count | integer | Open positions in the cohort |
position_count_long | integer | …of which long |
n_wallets | integer | Wallets in the cohort holding the coin that hour, on every axis and grading (a wallet holds one position per coin, so it equals position_count wherever that is not null) |
total_position_value | number | Notional, USD |
total_position_value_long | number | Long notional, USD |
total_unrealized_pnl | number | Unrealized PnL, USD |
total_position_size | number | Size in coin units |
total_position_size_long | number | Long size in coin units |
bias | number | (long − short) / (long + short), by notional |
label_basis | string | point_in_time | current — the basis actually used |
grading | string | On axis=pnl rows: which PnL grading labelled the wallet (realized by default) |
Load it
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()
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()
df = pl.DataFrame(body["metrics"])
print(df.head())
/v1/hl-cohorts/symbols/{symbol}/cohort-metrics?axis={axis}&hours=1&labelBasis={labelBasis}GET /v1/hl-cohorts/symbols/{symbol}/cohort-metrics · One coin, every cohort, hourly
- CLI
- —
- MCP
hl_cohort_metrics· 1 credit- Cost
- 1 credit, one request of the hourly limit
The full cohort matrix for one coin — every bucket on an axis, hourly.
Data from 2026-04-07 (the first hour cohort labels are correct), on every axis: an older start is served from there (never a 400), paging stops there, and the envelope says data_from. Every row carries n_wallets, the wallets in the cohort holding the coin that hour.
/symbols/{symbol}/metrics returns one row per hour, either all cohorts summed or a single cohort. Rebuilding the matrix from it costs one request per cohort (12 for size, 13 for pnl); this returns all of them in one.
axis=tier is the PER-POSITION ladder — each position row's own notional bucket, DERIVED from the row's size_usd: the canonical ten dollar-range buckets, largest first, the website's spellings verbatim (>$2.5m, $1m-$2.5m, $500k-$1m, $250k-$500k, $100k-$250k, $50k-$100k, $25k-$50k, $10k-$25k, $1k-$10k, <$1k — /cohorts and /segments publish the ladder with bounds). Rows have the same shape as axis=size, the bucket in the cohort field. It is a grouping only here: this endpoint aggregates position rows, so each row sits in exactly one bucket, while the per-wallet endpoints (/heatmap, /segments/{cohort}/summary) keep rejecting it — a wallet straddles buckets. (The retired micro/small/medium/large/mega vocabulary is gone; sending one of those as a cohort filter anywhere returns a 400 naming this ladder.)
Paginated by HOUR, not by row — a row limit would cut a bucket in half and return an hour whose cohorts do not sum to its total. hours bounds the buckets; every cohort in a returned bucket comes with it.
No provisional row: this is bulk history, and a partial hour inside a matrix that will be differenced or z-scored produces a fake move at the right edge. Use /symbols/{symbol}/metrics for the current value.
include=volume,median_pnl adds two per-cohort columns to the rows of the newest bucket, volume_24h_usd and median_realized_pnl_usd (size and pnl only; see the parameter). They are computed at request time, so they describe the book now, not the bucket's hour.
⚠️ labelBasis matters for research. By default the pnl cohort is resolved from the dictionary AT QUERY TIME, so a historical row carries TODAY's grading — correct for "who is smart right now", lookahead for a backtest, because a wallet under the 10-closed-trade floor back then may be graded now. Pass labelBasis=point_in_time to get each row's label as it was that hour. Every field is served (unavailable_fields is empty) while each hour of the window carries that label on its rows: every hour from 2026-08-06 09:00 UTC, and most earlier ones. A window that reaches an hour without it (all of April 2026, about 365 hours from May to 2026-08-06 08:00) is served as one aggregate for all of its hours, and its position_count, position_count_long, total_unrealized_pnl, total_position_size and total_position_size_long are null (listed in unavailable_fields); so are those five fields under grading=unrealized and grading=realized-pit. Point-in-time matrices are stored aggregates and refuse openedWithin (400).
axis=size is always point-in-time (a stored column), axis=tier is always point-in-time (a pure function of the stored size_usd), axis=pnl_unrealized is always point-in-time (the HOURLY rollup stores it, see below) and axis=pnl_abs is always current (no frozen source exists); all four reject a conflicting labelBasis rather than silently ignoring it. Every row and the envelope carry label_basis so the answer is self-describing.
⚠️ grading selects WHICH PnL grading; label_computed says WHEN it was computed. The two are independent and the response carries both, on the envelope and on every row. A grading name is neutral by design — realized does not say whether the label is today's or the hour's — so the endpoint refuses to let the name travel alone.
* grading=realized (default on axis=pnl) — the percentile ladder over cumulative realized PnL. With the default labelBasis this is resolved at QUERY time, so every historical hour carries TODAY's grading: label_computed.lookahead is true and says so. With labelBasis=point_in_time it is the frozen ladder, and label_computed names the 2026-08-06 seam — before it the labels come from the 2026-08-17 point-in-time rebuild (daily resolution), from it they come from the row's own pnl_cohort_realized (hourly). Both halves are honest; a series crossing the seam changes label RESOLUTION, which a turnover count will read as a regime change that is an artefact. * grading=realized-pit — the same ladder graded point-in-time across the WHOLE window (day D on the cumulative as of the end of D-1), which is what makes it the control for a study crossing that seam. Rebuilt once a DAY: it is extended just after 00:00 UTC through 23:00 of the last complete UTC day, so a window reaching the present comes back 1 to 25 hours short rather than wrong. * grading=unrealized — "currently onside": hour H's rank over the wallet's last snapshot strictly before H. axis=pnl_unrealized is the legacy spelling of exactly this and keeps working; both reach one branch.
grading is refused on size, tier and pnl_abs, which rank no PnL, and realized-pit/unrealized refuse labelBasis=current rather than silently overriding it.
⚠️ freshness is how a REALTIME caller checks it is not trading a stale book. On any window that reaches the present the envelope carries {newest_ts, behind_hours, settled_lag_ceiling_hours, stale}. stale is the pre-computed verdict, so a consumer does not have to re-derive the rollup's cadence — the rollup writes hour H at H+1:00–H+1:30, so a bucket up to two hours old is healthy and the ceiling sits an hour above that.
It exists because prose was not enough. grading=realized-pit reads a table rebuilt once a DAY; ask it the way a poller does (?grading=realized-pit&hours=1, no start) and it returns its own newest bucket — identical in shape to a current one, and hours old. That gap is not a constant: the newest hour is 23:00 of the last complete UTC day, so it runs from 1 to 25 hours over each day and stale is true for most of it. Read the age off freshness.behind_hours rather than from any number written in prose.
For live trading use grading=realized with labelBasis=point_in_time: honest labels, and one hour behind the clock rather than up to a day.
A window that ends in the PAST gets no freshness — "the newest bar is four months old" answers a question a historical query did not ask, and would make every backtest fetch look broken.
axis=pnl_unrealized grades positioning, not skill. Each wallet is ranked by the unrealized PnL of its open positions as a share of account value — "currently onside" — over its last snapshot STRICTLY BEFORE hour H, and that rank labels hour H. The grading turns over ~44% of wallets per day (the realized ladder: ~2.4%), which is the point: it is a different axis, not a re-spelling. Twelve rungs, no unknown (eligibility is a positive-equity snapshot, not a trade count), the same five null fields as a point-in-time pnl window served as one aggregate. Account values read zero from 2026-06-26 07:04 to 2026-06-30 06:31 UTC. For 2026-06-26 13:00 to 2026-06-30 06:00 UTC the share is taken of the wallet's last positive account value since 2026-06-23 07:00, and for 2026-04-13 15:00 and 2026-04-16 04:00 to 08:00 UTC of its last positive value in the 72 hours before the hour. These hours rank a different set of wallets, so cohort totals can step at their edges. On 2026-04-25 09:00 to 19:00 and 2026-05-02 09:00 to 11:00 UTC most wallets' unrealized PnL reads 0, so the rung within those hours is arbitrary.
Parameters
| Parameter | In | Description |
|---|---|---|
symbolrequired | path | HL ticker |
axis | query | size | pnl | pnl_abs | tier | pnl_unrealized. Default size. trade_size (the name /segments gives the ladder) is accepted as an alias of tier; the response still says axis: tier |
start | query | ISO-8601 UTC. Oldest edge of the window. Omit it and the window is the hours newest hourly buckets at or before end. |
end | query | ISO-8601 UTC. Newest edge. With no start: the hours newest hourly buckets at or before end, the same buckets as start = end - hours. A bucket counts when its hour starts at or before end, so an end exactly on the hour includes that hour's bucket. An end at or after the newest data (a future one included) is the same as no end; one older than all data returns an empty series. |
openedWithin | query | 24h | 7d | 30d | all. Default all. Refused (400) with axis=pnl and labelBasis=point_in_time, with grading=unrealized or realized-pit and with axis=pnl_unrealized: those matrices are stored aggregates with position age summed away. Use axis=size, tier, pnl_abs or pnl with the default basis. |
hours | query | Number of hourly buckets. Default 168, max 8760. Sizes the window when start is omitted; with start, it caps how many buckets come back (newest first). |
cursor | query | Cursor over hours |
grading | query | realized | realized-pit | unrealized. Which PnL grading labels each wallet, for the axes that carry one (axis=pnl, axis=pnl_unrealized). Default realized on axis=pnl; refused on size, tier, pnl_abs. Every response declares in label_computed WHEN the label was computed — the grading name alone cannot say it. |
labelBasis | query | current | point_in_time. Default depends on the axis: size, tier and pnl_unrealized are always point_in_time, pnl_abs always current. point_in_time (axis=pnl) returns each row's cohort label AS IT WAS that hour. Every field is served while each hour of the window carries that label on its rows (every hour from 2026-08-06 09:00 UTC, and most earlier ones); a window reaching an hour without it (all of April 2026, about 365 hours from May to 2026-08-06 08:00) is served as one aggregate whose five position fields are null (listed in unavailable_fields). Use it for backtests. Refused (400) with openedWithin. |
include | query | Comma list of volume and median_pnl; default none (nothing extra is read). Adds to every row of the NEWEST bucket volume_24h_usd (USD the cohort's wallets filled in this symbol over the last 24 hours; on axis=size only wallets holding the symbol now count; null when they filled nothing or the cohort is empty) and/or median_realized_pnl_usd (median cumulative realized PnL, USD, over the DISTINCT wallets holding the symbol now; null when none does). The median is a sampled quantile: exact up to 8,192 wallets in a cohort, an estimate above it. The asset page's pnl-axis "Med Lifetime" counts positions rather than wallets, so it can differ slightly. Both are CURRENT figures (request time, newest 5-minute snapshot), not the bucket hour's, and null on unknown. axis=size and axis=pnl with grading=realized only; refused (400) on any other axis or grading, with openedWithin, with cursor and with an end in the past. |
Call it
curl -H "X-API-KEY: $VIKE_API_KEY" \
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=24"
import os, requests
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=24",
headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
)
print(r.json())
# any MCP client; or from the terminal:
vike-data call hl_cohort_metrics --args '{"symbol": "BTC", "axis": "size", "hours": 24}'
Symbol cohort series
One symbol's hourly open interest, position count and bias (all cohorts or one), its current split by position-size bucket, and the Smart Money and Whale-vs-Shrimp indices as ratios.
- Routes
/v1/hl-cohorts/symbols/{symbol}/metrics,/v1/hl-cohorts/symbols/{symbol}/size-breakdown,/v1/hl-cohorts/symbols/{symbol}/indices- Built on
- Position snapshots
- MCP
hl_market
Real rows
Symbol cohort series · rows
Fields of /symbols/{symbol}/metrics, /indices and /size-breakdown
| Field | Type | Description |
|---|---|---|
ts | string | /metrics: the hour; /indices: the hour or the latest snapshot |
symbol | string | /indices: the coin as stored, whatever case was sent (btc → BTC, kpepe → kPEPE) |
total_position_value | number | /metrics, /size-breakdown: open notional, USD |
total_position_value_long | number | …of which long, USD |
position_count | integer | Open positions |
bias | number | (long − short) / (long + short) |
provisional | boolean | /metrics: true on the newest, still-moving hour |
smi | number | /indices: Smart Money Index, −1 to +1 |
wsi | number | /indices: Whale-vs-Shrimp Index, −1 to +1 |
whale_bias | number | /indices latest: bias of the whale rungs |
smart_bias | number | /indices latest: bias of the smart rungs |
tier | string | /size-breakdown: the position-size bucket |
min_size | number | /size-breakdown: the bucket's lower bound, USD |
max_size | number | /size-breakdown: its upper bound, USD; null on the largest bucket |
value_close_to_liquidation | number | /size-breakdown: notional near liquidation, USD |
Load it
GET /v1/hl-cohorts/symbols/{symbol}/metrics · One coin, hourly, all cohorts or one
- CLI
- —
- MCP
- —
- Cost
- 1 credit, one request of the hourly limit
Hourly open-interest / position-count / bias series for one coin, optionally sliced to a single cohort.
Hourly by construction: the 5-minute snapshot table summed into hour buckets over-counts open interest ~12x, which is what forced the previous cohort aggregate to be rebuilt.
Every row carries provisional. It is True on at most one row — the newest, covering the hour still in progress — because the hourly rollup lands 60-120 minutes late and a "current positioning" read would otherwise be silently that stale. Its ts is a snapshot instant rather than an hour boundary and it changes on every poll; drop it when persisting a series. Present only on the first page of a window reaching the present.
With a cohort: data from 2026-04-07 (the first hour cohort labels are correct); an older start is served from there and the envelope says data_from. Without one (all cohorts combined) the series does not depend on any label and keeps its whole history.
Parameters
| Parameter | In | Description |
|---|---|---|
symbolrequired | path | HL ticker |
start | query | ISO-8601 UTC. Oldest edge of the window. Omit it and the window is the limit newest hourly rows at or before end. |
end | query | ISO-8601 UTC. Newest edge. With no start: the limit newest hourly rows at or before end, the same rows as start = end - limit hours. A row counts when its hour starts at or before end, so an end exactly on the hour includes that hour. An end at or after the newest data (a future one included) is the same as no end; one older than all data returns no rows. |
axis | query | size | pnl | pnl_abs. Omit for all cohorts combined |
cohort | query | One label on that axis |
openedWithin | query | 24h | 7d | 30d | all. Default all. Rolling per bucket, not relative to now — each hour counts positions opened in the window before THAT hour. |
limit | query | Default 500, max 5000. One row per hour, so also the window length in hours when start is omitted |
cursor | query | Keyset cursor |
labelBasis | query | current only. This endpoint resolves the cohort label from the wallet dictionary at QUERY time, so on the pnl ladders it can only serve current, and it REFUSES point_in_time by name instead of ignoring it. Every response declares label_basis and, for a pnl axis, label_computed.lookahead. |
Call it
curl -H "X-API-KEY: $VIKE_API_KEY" \
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/metrics?limit=24"
import os, requests
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/metrics?limit=24",
headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
)
print(r.json())
GET /v1/hl-cohorts/symbols/{symbol}/size-breakdown · One coin by position size
- CLI
- —
- MCP
hl_market· 1 credit- Cost
- 1 credit, one request of the hourly limit
Positioning split by canonical position-size bucket for one coin.
Ten dollar-range buckets (largest first), derived from each row's size_usd — the same ladder, spellings and bounds as axis=tier on /symbols/{symbol}/cohort-metrics and the /cohorts catalogue. Empty buckets come back zero-filled so the table shape is stable.
Parameters
| Parameter | In | Description |
|---|---|---|
symbolrequired | path | HL ticker |
Call it
curl -H "X-API-KEY: $VIKE_API_KEY" \
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/size-breakdown"
import os, requests
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/size-breakdown",
headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
)
print(r.json())
# any MCP client; or from the terminal:
vike-data call hl_market --args '{"view": "size_breakdown", "symbol": "BTC"}'
GET /v1/hl-cohorts/symbols/{symbol}/indices · Smart Money and Whale-vs-Shrimp indices
- CLI
- —
- MCP
hl_market· 1 credit- Cost
- 1 credit, one request of the hourly limit
Smart Money Index, Whale-vs-Shrimp Index, whale / smart bias: the website's numbers as RATIOS in [-1, +1] (the site multiplies by 100). latest is the newest 5-minute snapshot (its pnl rungs graded by today's PnL grading, latest.label_basis: current), series the settled hourly rows, newest first. smi = long share of the 3x smart / 2x smart / smart wallets minus long share of the rekt / 2x rekt / 3x rekt wallets; wsi = long share of the 4x whale .. whale wallets minus long share of the 2x shrimp / shrimp wallets; whale_bias and smart_bias (latest only) = (long - short) / (long + short) over those whale / smart wallets. A value is null, never 0, when a cohort holds no positions. series: data from 2026-04-07 (the first hour cohort labels are correct); an older start is served from there, and the envelope says data_from.
Parameters
| Parameter | In | Description |
|---|---|---|
symbolrequired | path | HL ticker |
start | query | ISO-8601 UTC. Oldest edge. Omit it for the hours newest hours. |
end | query | ISO-8601 UTC. Newest edge; with no start, the window is the hours newest hours at or before it. |
hours | query | Window length in hours when start is omitted. Default 168, max 8760. |
limit | query | Max series rows, newest first, default and max 5000; has_more says there are older ones (page back with end = the oldest ts minus 1 second; end is inclusive). |
Call it
curl -H "X-API-KEY: $VIKE_API_KEY" \
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/indices?hours=24"
import os, requests
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/indices?hours=24",
headers={"X-API-KEY": os.environ["VIKE_API_KEY"]},
)
print(r.json())
# any MCP client; or from the terminal:
vike-data call hl_market --args '{"view": "indices", "symbol": "BTC", "hours": 24}'
Questions about Hyperliquid cohorts, answered with code
Each with the sentence to ask your AI instead, and a measured finding where there is one. Every block was run against the live API on 2026-11-04.
- Are Hyperliquid whales long or short BTC right now?
- What are profitable Hyperliquid traders doing on a coin?
- How are crypto speculators positioned? A Commitments-of-Traders view for crypto
- Whales vs retail: alert when their positioning diverges
- Do whales rotate between BTC, ETH and HYPE? (cross-asset cohort drift)
- When funding spikes, how do whale and retail cohorts split?
- Feed Hyperliquid cohort bias into a trading bot as an external signal
- Most crowded trade on Hyperliquid (cohort × coin heatmap)
- Rank every Hyperliquid coin by smart-money conviction and liquidation risk
- Build a Hyperliquid fear-and-greed gauge from the Smart Money and Whale-vs-Shrimp indices
- Smart-money (top-PnL cohort) long/short on a coin
- What does "whale" or "3x smart" mean? Cohort bounds
- What one cohort holds right now
- How many wallets are in each tier (wallet and PnL distribution)
- Long/short bias history of a cohort over time
- How leveraged are whales compared with shrimp over time?
- Threshold alert: a cohort is more than 70% long a coin
- Show whale fills above $100k on a Hyperliquid coin in the last hour, with each buyer's cohort
- Which coins have one-sided whale flow right now?
- Are Hyperliquid whales taking or making? Market versus limit share of large fills
- Alert on any single Hyperliquid fill over $1M
- Did cohort leverage rise before the last liquidation cascade?
- Daily 60-second Hyperliquid brief (cohorts + liquidations + movers)
- Alert me when smart money and whales disagree on a coin
- Which coin do smart wallets like and rekt wallets hate?
- Is notional bias or equity-adjusted bias the better signal?
- Did cohort positioning predict price? A backtest on labels as they were · Backtests
- Fade the losing cohort: mean reversion on extreme bias · Backtests
- Smart Money Index versus price: does it lead? · Backtests
- Are Whale-vs-Shrimp extremes a contrarian signal? · Backtests
- Hyperliquid net flow by cohort, hour by hour · Backtests
- Backtest following smart money with point-in-time cohort labels from the positions archive · Backtests
- Do smart-money wallets' large fills precede price moves? · Backtests
- How do I check Hyperliquid cohort data is fresh before I trade on it? · AI & API
Are Hyperliquid whales long or short BTC right now?
See how Hyperliquid accounts of $1m and up lean on BTC in the newest settled hour: each of the four whale rungs carries a bias from -1 (all short) to +1 (all long).
- Uses
/symbols/{…}/cohort-metrics,/symbols/{…}/indices- Verified
- live API, 2026-11-04: 4 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# BTC positioning by account-value cohort, newest settled hour
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=1",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# whale bias over every account of $1m and more, at the newest 5-minute snapshot
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/indices?hours=1",
headers={"X-API-Key": API_KEY},
)
# then: jq '.latest'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# how whale positioning on BTC moved over the last day
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=24",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.metrics[] | select(.cohort | test("whale")) | {ts, cohort, bias}]'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the same matrix for ETH
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/ETH/cohort-metrics?axis=size&hours=1",
headers={"X-API-Key": API_KEY},
)
What are profitable Hyperliquid traders doing on a coin?
Read the coin's realized-PnL cohort matrix; the 3x smart, 2x smart and smart rows show how the top 10% of wallets by lifetime realized PnL are positioned and how much they traded in 24 hours.
- Uses
/symbols/{…}/cohort-metrics,/symbols/{…}/indices- Verified
- live API, 2026-11-04: 4 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# HYPE by realized-PnL cohort, newest settled hour, with 24 h volume and median PnL
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/HYPE/cohort-metrics?axis=pnl&labelBasis=point_in_time&hours=1&include=volume,median_pnl",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# HYPE smart-money bias and Smart Money Index now
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/HYPE/indices?hours=1",
headers={"X-API-Key": API_KEY},
)
# then: jq '.latest | {ts, smart_bias, smi}'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# a week of hourly smart-money positioning on HYPE, labelled point-in-time
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/HYPE/cohort-metrics?axis=pnl&labelBasis=point_in_time&hours=168",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.metrics[] | select(.cohort == "3x smart") | {ts, bias, total_position_value}]'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# HYPE positioning of wallets by realized PnL in dollar bands
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/HYPE/cohort-metrics?axis=pnl_abs&hours=1",
headers={"X-API-Key": API_KEY},
)
How are crypto speculators positioned? A Commitments-of-Traders view for crypto
Split one Hyperliquid market's open interest into long and short by account-size category with one call, then repeat it with an earlier end for the weekly change.
- Uses
/segments/{…}/summary,/symbols/{…}/cohort-metrics- Verified
- live API, 2026-11-04: 4 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# BTC open interest by account-size category, long and short, newest settled hour
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=1",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the same report at an earlier hour: end is ISO-8601 UTC
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&end=2026-10-17T16:59:59Z&hours=1",
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 reports for BTC, newest first
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=168",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# what the $10m-and-up accounts hold across all of Hyperliquid
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/4x_whale/summary?axis=size",
headers={"X-API-Key": API_KEY},
)
Whales vs retail: alert when their positioning diverges
Poll a coin's Whale-vs-Shrimp Index, the whales' long share minus the small accounts' long share, and alert when it crosses your threshold.
- Uses
/symbols/{…}/cohort-metrics,/symbols/{…}/indices- Verified
- live API, 2026-11-04: 4 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# BTC whale-vs-shrimp divergence now, plus the last 24 settled hours
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/indices?hours=24",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the current divergence and the snapshot it was read at
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/indices?hours=1",
headers={"X-API-Key": API_KEY},
)
# then: jq '{ts: .latest.ts, wsi: .latest.wsi}'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# 90 days of hourly readings, newest first
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/indices?hours=2160",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.series[].wsi | select(. != null)] | {n: length, min: min, max: max}'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# every account-size cohort on BTC for the newest settled hour, with freshness
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=1",
headers={"X-API-Key": API_KEY},
)
# then: jq '{freshness, rows: [.metrics[] | {cohort, bias}]}'
Do whales rotate between BTC, ETH and HYPE? (cross-asset cohort drift)
Pull the same 30 days of hourly size-cohort positioning for each coin, sum the whale rows per hour, and compare their long notional and bias across the three coins.
- Uses
/heatmap,/symbols/{…}/cohort-metrics- Verified
- live API, 2026-11-04: 6 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# 30 days of hourly BTC positioning by account-size cohort
r1 = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=720",
headers={"X-API-Key": API_KEY},
)
# the same 30 days for ETH
r2 = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/ETH/cohort-metrics?axis=size&hours=720",
headers={"X-API-Key": API_KEY},
)
# the same 30 days for HYPE
r3 = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/HYPE/cohort-metrics?axis=size&hours=720",
headers={"X-API-Key": API_KEY},
)
import os
from datetime import datetime, timedelta
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the 720 hours before the newest 720: END is the first call's oldest ts minus 1 second
first = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=720",
headers={"X-API-Key": API_KEY},
).json()
oldest = min(row["ts"] for row in first["metrics"])
END = (datetime.fromisoformat(oldest) - timedelta(seconds=1)).strftime("%Y-%m-%dT%H:%M:%SZ")
r = requests.get(
f"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=720&end={END}",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# whale cells for the three coins at the newest snapshot
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=size",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.heatmap[] | select(.symbol == "BTC" or .symbol == "ETH" or .symbol == "HYPE") | {symbol, whales: [.segments[] | select(.cohort | test("whale")) | {cohort, total_long_value, bias}]}]'
When funding spikes, how do whale and retail cohorts split?
Pull a coin's hourly funding rate and its hourly size-cohort matrix over the same window, join them on the hour, and compare whale and shrimp bias in the high-funding hours.
- Uses
/symbols/{…}/cohort-metrics,/v1/hyperliquid/symbols/hourly- Verified
- live API, 2026-11-04: 5 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# BTC hourly close, open interest and funding rate for 30 days
r1 = requests.get(
"https://data.vike.io/v1/hyperliquid/symbols/hourly?symbols=BTC&days=30",
headers={"X-API-Key": API_KEY},
)
# the same 720 hours of BTC positioning by account-size cohort
r2 = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=720",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# funding for BTC, ETH and HYPE over 30 days
r = requests.get(
"https://data.vike.io/v1/hyperliquid/symbols/hourly?symbols=BTC,ETH,HYPE&days=30",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# 720 hours of BTC positioning by realized-PnL cohort, labelled point-in-time
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=pnl&labelBasis=point_in_time&hours=720",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# funding for a fixed September window
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},
)
Feed Hyperliquid cohort bias into a trading bot as an external signal
Poll the newest settled hour of a coin's realized-PnL cohort matrix with point-in-time labels, and trade only when its freshness block says the hour is not stale.
- Uses
/symbols/{…}/cohort-metrics,/symbols/{…}/indices- Verified
- live API, 2026-11-04: 4 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# BTC smart-money matrix for the newest settled hour, labels as they were at that hour
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=pnl&labelBasis=point_in_time&hours=1",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# stale flag plus smart-cohort bias, nothing else
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=pnl&labelBasis=point_in_time&hours=1",
headers={"X-API-Key": API_KEY},
)
# then: jq '{stale: .freshness.stale, smart: [.metrics[] | select(.cohort | test("smart")) | {cohort, bias}]}'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# smart-money bias at the newest 5-minute snapshot
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/indices?hours=1",
headers={"X-API-Key": API_KEY},
)
# then: jq '.latest | {ts, smart_bias, smi}'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# 30 days of the same matrix for calibration
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=pnl&labelBasis=point_in_time&hours=720",
headers={"X-API-Key": API_KEY},
)
Most crowded trade on Hyperliquid (cohort × coin heatmap)
One call to the heatmap returns every coin split by every cohort at the newest snapshot; rank the cells by net notional or by bias times share to find the most crowded trade.
- Uses
/heatmap- Verified
- live API, 2026-11-04: 4 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# every coin by account-size cohort at the newest snapshot
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=size",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the ten cells with the largest net long or short notional
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=size",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.heatmap[] | .symbol as $s | .segments[] | {symbol: $s, cohort, bias, share_of_symbol, net: (.total_long_value - .total_short_value)}] | sort_by(if .net < 0 then .net else -.net end) | .[:10]'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the board by realized-PnL cohort
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=pnl",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# crowding among positions opened in the last day
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=size&openedWithin=24h",
headers={"X-API-Key": API_KEY},
)
Rank every Hyperliquid coin by smart-money conviction and liquidation risk
Take smart-money bias per coin from the realized-PnL heatmap and the share of open interest near liquidation from the risk ranking, join them on symbol, and sort.
- Uses
/heatmap,/symbols/{…}/indices,/v1/hyperliquid/liquidations/risk- Verified
- live API, 2026-11-04: 6 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# every coin by realized-PnL cohort at the newest snapshot
r1 = requests.get(
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=pnl",
headers={"X-API-Key": API_KEY},
)
# every coin's share of open notional near liquidation, the most at risk first
r2 = requests.get(
"https://data.vike.io/v1/hyperliquid/liquidations/risk?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
# risk ranking for coins with at least $50M of open notional
r = requests.get(
"https://data.vike.io/v1/hyperliquid/liquidations/risk?limit=500",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.[] | select(.total_value_usd >= 50000000) | {symbol, percent_risk, total_value_usd}] | .[:10]'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# smart-money long, short and bias per coin
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=pnl",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.heatmap[] | {symbol, l: ([.segments[] | select(.cohort | test("smart")) | .total_long_value] | add), s: ([.segments[] | select(.cohort | test("smart")) | .total_short_value] | add)} | select(.l != null) | . + {bias: ((.l - .s) / (.l + .s))}] | sort_by(-.bias) | .[:10]'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# how close the top 1% by realized PnL are to liquidation, per coin
r = requests.get(
"https://data.vike.io/v1/hyperliquid/liquidations/risk?axis=pnl&cohort=3x_smart&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
# BTC Smart Money Index now and for the last week
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/indices",
headers={"X-API-Key": API_KEY},
)
Build a Hyperliquid fear-and-greed gauge from the Smart Money and Whale-vs-Shrimp indices
Read latest.smi and latest.wsi from /indices for the largest coins by open interest, average them and multiply by 100; the gauge runs from -100 to +100 and is yours to define, not a published index.
- Uses
/symbols/{…}/indices,/v1/hyperliquid/positions/symbols- Verified
- live API, 2026-11-04: 3 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# BTC's two indices now; hours=1 keeps the hourly series to one row
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/indices?hours=1",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the ten largest crypto perps by open interest
r = requests.get(
"https://data.vike.io/v1/hyperliquid/positions/symbols",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.[] | select(.symbol | contains(":") | not)][:10] | map(.symbol)'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# 168 hourly readings of ETH's two indices
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/ETH/indices?hours=168",
headers={"X-API-Key": API_KEY},
)
Smart-money (top-PnL cohort) long/short on a coin
List the biggest open positions on one coin held by the 3x smart cohort (top 1% of wallets by realized PnL) with /v1/hyperliquid/positions?axis=pnl&cohort=3x_smart&sort=size.
- Uses
/symbols/{…}/cohort-metrics,/v1/hyperliquid/positions- Verified
- live API, 2026-11-04: 4 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the five biggest BTC positions of 3x smart wallets right now
r = requests.get(
"https://data.vike.io/v1/hyperliquid/positions?symbol=BTC&axis=pnl&cohort=3x_smart&sort=size&limit=5",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# BTC positioning per pnl cohort, newest hour
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=pnl&hours=1",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# all current 3x smart BTC positions, first page
r = requests.get(
"https://data.vike.io/v1/hyperliquid/positions?symbol=BTC&axis=pnl&cohort=3x_smart&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
# the ten biggest HYPE positions of 2x smart wallets
r = requests.get(
"https://data.vike.io/v1/hyperliquid/positions?symbol=HYPE&axis=pnl&cohort=2x_smart&sort=size&limit=10",
headers={"X-API-Key": API_KEY},
)
What does "whale" or "3x smart" mean? Cohort bounds
The segments catalogue lists every cohort on every ladder with its bounds; a whale is an account worth $1m to $2.5m, and 3x smart is the top 1% of wallets by lifetime realized PnL.
- Uses
/cohorts,/segments- Verified
- live API, 2026-11-04: 4 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# every cohort on every ladder, with its bounds
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# label lists per ladder, in ladder order
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/cohorts",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# account-value tiers, largest first
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.[] | select(.axis == "size") | {cohort, slug, min_usd, max_usd}]'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# ladders accepted as axis= by /heatmap and /segments/{cohort}/summary
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.[] | select(.groupable) | .axis] | unique'
What one cohort holds right now
The cohort summary returns one cohort's long and short notional, bias, wallet and position counts, margin, equity and unrealized PnL across every coin at the newest snapshot.
- Uses
/heatmap,/segments/{…}/summary- Verified
- live API, 2026-11-04: 4 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# what the top 1% by realized PnL hold right now, across every coin
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/3x_smart/summary?axis=pnl",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# what accounts of $10m and up hold right now
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/4x_whale/summary?axis=size",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# what the top 1% opened in the last day
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/3x_smart/summary?axis=pnl&openedWithin=24h",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the top 1% by realized PnL, coin by coin
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=pnl",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.heatmap[] | .symbol as $s | .segments[] | select(.cohort == "3x smart") | {symbol: $s, total_value, bias}] | .[:10]'
How many wallets are in each tier (wallet and PnL distribution)
Call the cohort summary once per tier and read n_wallets; it counts the wallets with at least one open position, and the heatmap's totals give the denominator.
- Uses
/heatmap,/segments,/segments/{…}/summary- Verified
- live API, 2026-11-04: 5 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# how many wallets in the smallest account tier hold an open position now
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/shrimp/summary?axis=size",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the size tiers, largest first, with their account-value bounds
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.[] | select(.axis == "size") | {slug, min_usd, max_usd}]'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# wallets in the $1m to $2.5m tier holding a position
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/whale/summary?axis=size",
headers={"X-API-Key": API_KEY},
)
# then: jq '{cohort, n_wallets, n_positions}'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# wallets in the top 1% by realized PnL holding a position
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/3x_smart/summary?axis=pnl",
headers={"X-API-Key": API_KEY},
)
# then: jq '{cohort, n_wallets, n_positions}'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# every wallet with an open position, once
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=size",
headers={"X-API-Key": API_KEY},
)
# then: jq '.totals | {n_wallets, n_wallets_source}'
Long/short bias history of a cohort over time
One call returns a size or PnL cohort's long and short notional and bias (-1 to +1) for each hour, summed over all coins, newest first. Cohort labels are correct from 7 April 2026.
- Uses
/segments/{…}/history- Verified
- live API, 2026-11-04: 5 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the last week of whale positioning across the whole book, newest hour first
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/whale/history?axis=size",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# every hour of the top 1% by realized PnL over the last 90 days
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/3x_smart/history?axis=pnl&hours=2160",
headers={"X-API-Key": API_KEY},
)
# then: jq '{has_more, rows: (.series | length), oldest: .series[-1], newest: .series[0]}'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# 4x whale positioning hour by hour in September
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/4x_whale/history?axis=size&start=2026-09-01T00:00:00Z&end=2026-09-30T23:00:00Z",
headers={"X-API-Key": API_KEY},
)
import os
from datetime import datetime, timedelta
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the 24 hours before the newest 24: END is the first page's oldest ts minus 1 second
first = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/whale/history?axis=size&limit=24",
headers={"X-API-Key": API_KEY},
).json()
END = (datetime.fromisoformat(first["series"][-1]["ts"]) - timedelta(seconds=1)).strftime("%Y-%m-%dT%H:%M:%SZ")
r = requests.get(
f"https://data.vike.io/v1/hl-cohorts/segments/whale/history?axis=size&limit=24&end={END}",
headers={"X-API-Key": API_KEY},
)
How leveraged are whales compared with shrimp over time?
Add include=leverage to a cohort's hourly history: every hour from 2026-08-11 carries its notional over equity (equity_exposure), its net lean over equity (perp_bias) and the share of its book the two cover. One call for whale and one for shrimp set them side by side.
- Uses
/segments/{…}/history,/segments/{…}/summary- Verified
- live API, 2026-11-04: 6 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the whale cohort's hourly leverage over the last 90 days
r1 = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/whale/history?axis=size&include=leverage&hours=2160",
headers={"X-API-Key": API_KEY},
)
# the shrimp cohort's hourly leverage over the same 90 days
r2 = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/shrimp/history?axis=size&include=leverage&hours=2160",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# hourly leverage of the $10m-and-up accounts beside their long and short notional
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/4x_whale/history?axis=size&include=leverage",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the 2x shrimp cohort's hourly leverage since leverage data begins
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/2x_shrimp/history?axis=size&include=leverage&start=2026-08-11T00: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
# a month of hourly leverage for the top 1% by realized PnL
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/3x_smart/history?axis=pnl&hours=720&include=leverage",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# current leverage of the whale cohort
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/whale/summary?axis=size",
headers={"X-API-Key": API_KEY},
)
# then: jq '{snapshot_ts, equity_exposure, perp_bias, exposure_ratio, equity_covered_share}'
Threshold alert: a cohort is more than 70% long a coin
Poll the coin's metrics for one cohort, compute its long share from the newest row, and fire when it passes 0.70; the heatmap checks every coin at once.
- Uses
/heatmap,/segments/{…}/summary,/symbols/{…}/metrics- Verified
- live API, 2026-11-04: 4 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# whale positioning on BTC: the current hour first, then the settled ones
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/metrics?axis=size&cohort=whale&limit=2",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# current long share of the whale cohort on BTC
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/metrics?axis=size&cohort=whale&limit=1",
headers={"X-API-Key": API_KEY},
)
# then: jq '.metrics[0] | {ts, provisional, long_share: (.total_position_value_long / .total_position_value)}'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# whale cells more than 70% long on any coin
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=size",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.heatmap[] | .symbol as $s | .segments[] | select(.cohort == "whale" and .total_long_value / .total_value > 0.7) | {symbol: $s, total_value, long_share: (.total_long_value / .total_value)}]'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the top 1% by realized PnL: long share across all coins
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/3x_smart/summary?axis=pnl",
headers={"X-API-Key": API_KEY},
)
# then: jq '{snapshot_ts, long_share: .by_side.long.share}'
Show whale fills above $100k on a Hyperliquid coin in the last hour, with each buyer's cohort
Ask the coin's large-fills feed for min_usd=100000 and hours=1; each fill carries the wallet, side, size, order type and the wallet's size and realized-PnL cohorts, and covered_from says how far back the answer reaches.
- Uses
/symbols/{…}/large-fills- Verified
- live API, 2026-11-04: 4 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# BTC fills of $100k and more in the last hour, with each wallet's cohorts
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/large-fills?min_usd=100000&hours=1",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# who bought $100k or more of BTC, and their cohorts
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/large-fills?min_usd=100000&hours=1",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.fills[] | select(.direction == "buy") | {ts, wallet, size_usd, order_type, size_cohort, pnl_cohort}]'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# aggressive buyers and sellers of $100k and more on ETH
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/ETH/large-fills?min_usd=100000&hours=1",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.fills[] | select(.order_type == "market") | {ts, direction, size_usd, pnl_cohort}]'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# how far back the answer reaches on HYPE
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/HYPE/large-fills?min_usd=100000&hours=1",
headers={"X-API-Key": API_KEY},
)
# then: jq '{covered_from, truncated, has_more, fills: (.fills | length)}'
Which coins have one-sided whale flow right now?
Call /large-fills?min_usd=100000&hours=2 per coin and net the taker rows (order_type market) by direction; netting every row gives zero, because both sides of each trade are in the feed.
- Uses
/symbols/{…}/large-fills,/v1/hyperliquid/positions/symbols- Verified
- live API, 2026-11-04: 3 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# HYPE fills of $100,000 or more from the last two hours
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/HYPE/large-fills?min_usd=100000&hours=2",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the 20 symbols with the most open interest
r = requests.get(
"https://data.vike.io/v1/hyperliquid/positions/symbols",
headers={"X-API-Key": API_KEY},
)
# then: jq '.[:20] | map(.symbol)'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# taker buys, taker sells, the imbalance, and how far back the answer reaches
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/ETH/large-fills?hours=2",
headers={"X-API-Key": API_KEY},
)
# then: jq '{covered_from, truncated, buy: ([.fills[] | select(.order_type == "market" and .direction == "buy") | .size_usd] | add // 0), sell: ([.fills[] | select(.order_type == "market" and .direction == "sell") | .size_usd] | add // 0)} | .imbalance = (if .buy + .sell > 0 then (.buy - .sell) / (.buy + .sell) else null end)'
Are Hyperliquid whales taking or making? Market versus limit share of large fills
Group a coin's /large-fills by size_cohort and order_type; a cohort's market share above 50% means it takes liquidity more than it provides, since every trade in the feed has one market and one limit side.
- Uses
/symbols/{…}/large-fills- Verified
- live API, 2026-11-04: 3 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# every ETH fill over $50,000 the feed holds
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/ETH/large-fills",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# every BTC fill over $50,000 the feed holds
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/large-fills",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# HYPE fills of $250,000 or more from the last 24 hours
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/HYPE/large-fills?min_usd=250000",
headers={"X-API-Key": API_KEY},
)
Alert on any single Hyperliquid fill over $1M
Poll /large-fills?min_usd=1000000 once a minute for each coin you watch, alert on rows you have not seen, and read covered_from, because an empty answer only covers the minutes the feed reaches back.
- Uses
/symbols/{…}/large-fills- Verified
- live API, 2026-11-04: 3 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# BTC fills of $1M or more still in the feed
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/large-fills?min_usd=1000000&limit=50",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# ETH: the largest fill the feed holds and how far back it reaches; an empty $1M answer covers only that window
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/ETH/large-fills",
headers={"X-API-Key": API_KEY},
)
# then: jq '{covered_from, truncated, largest_usd: ([.fills[].size_usd] | max)}'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# BTC fills of $100,000 or more, to rebuild the orders behind them
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/large-fills?min_usd=100000",
headers={"X-API-Key": API_KEY},
)
Did cohort leverage rise before the last liquidation cascade?
Find the hour of the drop, then read the cohort's hourly equity_exposure and perp_bias for the hours before it from /segments/{cohort}/history with include=leverage.
- Uses
/segments/{…}/history,/v1/hyperliquid/liquidations,/v1/hyperliquid/ohlcv- Verified
- live API, 2026-11-04: 5 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the whale cohort's hourly leverage over the six hours up to BTC's 01:00 UTC drop on 2026-10-22
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/whale/history?axis=size&include=leverage&start=2026-10-21T19:00:00Z&end=2026-10-22T01: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
# 168 hourly BTC candles, oldest first
r = requests.get(
"https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&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
# every BTC liquidation of the 01:00 hour; end is inclusive
r = requests.get(
"https://data.vike.io/v1/hyperliquid/liquidations?symbol=BTC&start=2026-10-22T01:00:00Z&end=2026-10-22T01:59:59Z&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
# the 3x rekt cohort's leverage before the same drop
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/3x_rekt/history?axis=pnl&include=leverage&start=2026-10-21T19:00:00Z&end=2026-10-22T01: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
# the whale cohort's leverage over the week up to the drop
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/whale/history?axis=size&include=leverage&hours=168&end=2026-10-22T01:00:00Z",
headers={"X-API-Key": API_KEY},
)
Daily 60-second Hyperliquid brief (cohorts + liquidations + movers)
Three calls make the brief; the realized-PnL heatmap for where smart money leans, the last 24 hours of liquidations, and an hourly price panel for the coins you follow.
- Uses
/heatmap,/v1/hyperliquid/liquidations,/v1/hyperliquid/symbols/hourly- Verified
- live API, 2026-11-04: 7 calls, all 200
The code
import os
from datetime import datetime, timedelta, timezone
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# where each realized-PnL cohort leans on every coin, at the newest snapshot
r1 = requests.get(
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=pnl",
headers={"X-API-Key": API_KEY},
)
# the last 24 hours of liquidations
SINCE = (datetime.now(timezone.utc) - timedelta(hours=24)).strftime("%Y-%m-%dT%H:%M:%SZ") # 24 hours ago, UTC
r2 = requests.get(
f"https://data.vike.io/v1/hyperliquid/liquidations?start={SINCE}&limit=5000",
headers={"X-API-Key": API_KEY},
)
# one day of hourly closes for the coins you follow
r3 = requests.get(
"https://data.vike.io/v1/hyperliquid/symbols/hourly?symbols=BTC,ETH,SOL,HYPE&days=1",
headers={"X-API-Key": API_KEY},
)
import os
from datetime import datetime, timedelta, timezone
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# count and USD of longs and shorts liquidated in the last 24 hours
SINCE = (datetime.now(timezone.utc) - timedelta(hours=24)).strftime("%Y-%m-%dT%H:%M:%SZ") # 24 hours ago, UTC
r = requests.get(
f"https://data.vike.io/v1/hyperliquid/liquidations?start={SINCE}&limit=5000",
headers={"X-API-Key": API_KEY},
)
# then: jq '.liquidations | group_by(.side) | map({side: .[0].side, n: length, usd: (map(.size_usd) | add)})'
import os
from datetime import datetime, timedelta, timezone
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the second page of the last 24 hours of liquidations: NEXT is the first page's nextCursor
SINCE = (datetime.now(timezone.utc) - timedelta(hours=24)).strftime("%Y-%m-%dT%H:%M:%SZ") # 24 hours ago, UTC
first = requests.get(
f"https://data.vike.io/v1/hyperliquid/liquidations?start={SINCE}&limit=5000",
headers={"X-API-Key": API_KEY},
).json()
NEXT = first["nextCursor"] # null when the first page already held every liquidation
if NEXT:
r = requests.get(
f"https://data.vike.io/v1/hyperliquid/liquidations?start={SINCE}&limit=5000&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
# top-1% positioning on the ten coins with the most open notional
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/heatmap?axis=pnl",
headers={"X-API-Key": API_KEY},
)
# then: jq '[.heatmap[:10][] | .symbol as $s | .segments[] | select(.cohort == "3x smart") | {symbol: $s, bias, share_of_symbol}]'
Alert me when smart money and whales disagree on a coin
Poll /indices every 5 minutes and compare latest.smart_bias with latest.whale_bias; alert when their signs differ by more than your threshold, and skip a null, which means the cohort holds nothing on the coin.
- Uses
/symbols/{…}/indices,/v1/hyperliquid/positions/symbols- Verified
- live API, 2026-11-04: 3 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# HYPE's whale and smart bias at the newest snapshot
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/HYPE/indices?hours=1",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the 20 symbols with the most open interest
r = requests.get(
"https://data.vike.io/v1/hyperliquid/positions/symbols",
headers={"X-API-Key": API_KEY},
)
# then: jq '.[:20] | map(.symbol)'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# BTC's smart and whale bias, with the snapshot time
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/BTC/indices?hours=1",
headers={"X-API-Key": API_KEY},
)
# then: jq '.latest | {ts, smart_bias, whale_bias}'
Which coin do smart wallets like and rekt wallets hate?
Call /indices for each coin and rank by latest.smi, the long share of smart wallets minus the long share of rekt wallets; the top coin is where the two disagree most in the smart wallets' favour.
- Uses
/symbols/{…}/cohort-metrics,/symbols/{…}/indices,/v1/hyperliquid/positions/symbols- Verified
- live API, 2026-11-04: 4 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# HYPE's indices at the newest snapshot
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/HYPE/indices?hours=1",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the 20 symbols with the most open interest
r = requests.get(
"https://data.vike.io/v1/hyperliquid/positions/symbols",
headers={"X-API-Key": API_KEY},
)
# then: jq '.[:20] | map(.symbol)'
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# HYPE's newest settled hour, one row per realized-PnL rung
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/HYPE/cohort-metrics?axis=pnl&hours=1",
headers={"X-API-Key": API_KEY},
)
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# HYPE's last 24 settled hours
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/symbols/HYPE/indices?hours=24",
headers={"X-API-Key": API_KEY},
)
Is notional bias or equity-adjusted bias the better signal?
One /segments/{cohort}/history call with include=leverage returns both bias (long minus short over notional) and perp_bias (long minus short over equity) per hour since 2026-08-11; score each against the forward return from /ohlcv.
- Uses
/segments/{…}/history,/v1/hyperliquid/ohlcv- Verified
- live API, 2026-11-04: 3 calls, all 200
The code
import os
import requests
API_KEY = os.environ["VIKE_API_KEY"] # your key, read from the environment
# the 3x smart cohort's hourly bias and perp_bias since the equity ratios begin
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/3x_smart/history?axis=pnl&include=leverage&start=2026-08-11T00: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
# BTC hourly candles over the same span
r = requests.get(
"https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&interval=1h&start=2026-08-11T00:00:00Z&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
# whales' hourly bias and perp_bias since 2026-08-11
r = requests.get(
"https://data.vike.io/v1/hl-cohorts/segments/whale/history?axis=size&include=leverage&start=2026-08-11T00:00:00Z",
headers={"X-API-Key": API_KEY},
)