How to View Entire Trader Positioning on Hyperliquid

Want to know whether Hyperliquid traders are leaning long or short on BTC right now? Where the biggest positions sit, how much leverage they're using, or at what price they'd be liquidated? Or how that same crowd looked a month ago?

All of it is public. Hyperliquid runs on-chain, so every open position, with its size, entry price and leverage, is visible to anyone. The hard part is seeing them all at once. The official Hyperliquid API shows positions one wallet at a time, and it has no list of wallets to start from.

There are three ways to get the whole picture, depending on what you need:

1. In your browser: Flowscan Terminal shows every position in a market, with no login.
2. In your own app or script: Hydromancer's perpSnapshots endpoint returns every open position, in one market or all of them, in a single request.
3. For history: Reservoir, Hydromancer's free archive on Amazon S3, keeps a daily snapshot of every position from July 2025.

Trader, not a developer? The table below and the Flowscan section are all you need; skip the code. Developer? The Python examples need pip install requests msgpack zstandard and a Hydromancer API key. The Reservoir examples use DuckDB.

Which option fits your question?

Why the official Hyperliquid API can't show every position

The official API's clearinghouseState request returns the open perp positions of one wallet. You pass an address and get back that address's positions, margin and liquidation prices. There is no request that lists every trader, or every position in a market.

So to see a whole market, you'd first need the address of everyone with a position open, and then a separate request for each one. Each lookup costs 2 points from a budget of 1,200 points a minute per IP address (see our rate limits guide), so one server tops out at about 600 wallets a minute.

For scale: when we looked at Flowscan Terminal on the evening of 17 October 2026, it counted 412,775 open positions across all markets, 39,905 of them on BTC alone. By the time a wallet-by-wallet scan finished, the positions at the start would have moved. That's why all three options below work from a snapshot of every position at once.

1. See all positions in your browser with Flowscan Terminal

Flowscan Terminal is a free Hyperliquid explorer that runs on Hydromancer data. Open it, pick a market, and the panel under the chart lists the open positions in that market. You don't need to sign up or connect a wallet.

Each row shows the trader (an address, or a name where the wallet is publicly known), long or short, leverage, entry price, size, profit or loss on the open position, liquidation price, account value, all-time profit and funding. Many wallets also carry a tag, such as market maker, new wallet, or a trading style like swing trader or day trader.

The tabs and filters under the chart give you different cuts of the same data:

• Positions: every position, sortable, with long and short filters and an address search. A bar above the table shows how the market's open positions split between longs and shorts.
• Who's included: a dropdown switches between all traders and narrower groups: the top 10,000 accounts on Hyperliquid's leaderboard, the top traders by 7-day, 30-day or all-time profit, and the best 30-day win rates.
• Distribution: long and short exposure grouped by leverage (1x, 2–5x, 5–10x and up) and by position size.
• Changes: what changed since the previous snapshot, or over the last hour, 4 hours, 24 hours or 7 days: positions opened, added to, trimmed, closed or flipped, and the net change in longs and shorts.
• All markets: open interest, the long/short split, the number of traders and median leverage for every market side by side.
• Liqs: a chart view that draws the liquidation prices of large positions over the price chart, with a minimum size filter from $100K to $10M.

When we checked BTC on 17 October 2026, the all-traders view showed 39,905 positions worth $3.36B, split almost exactly 50/50 between longs and shorts. Narrowing it to the top 10,000 leaderboard accounts left 645 positions worth $1.82B, with shorts holding 60% of it. Spotting a gap like that, between the whole crowd and the biggest accounts, is what this view is for.

Good for: traders and researchers who want to look rather than code. The panel shows how old the current snapshot is, so check that before reading too much into a number. If you want the rows in your own tool, use the API below.

2. Get every position in code with perpSnapshots

perpSnapshots is a Hydromancer endpoint that returns every open perp position on Hyperliquid in the markets you ask for, including each one's entry price, leverage and liquidation price. It isn't part of Hyperliquid's own API, and it's a paid add-on on top of a Hydromancer API plan. Flowscan Terminal is built on the same data.

You send one request with a list of markets:

{"type": "perpSnapshots", "market_names": ["BTC"]}

market_names also covers HIP-3 markets, the perps that outside teams launch on their own DEXes, often on stocks or commodities. Write them as dex:market:

You can mix them, for example ["ALL", "ALL:xyz"] for every market on the main DEX and on xyz.

The reply isn't JSON. It's MessagePack, a compact binary format, compressed with zstd. Even so, a snapshot can run from about 1 MB to more than 13 MB, so ask for the markets you need rather than everything.

Each market comes back in four parts: the snapshot ID, the market name, a list of positions and a matching list of wallet addresses. Every position is eight numbers, in this order:

A helper to download and decode a snapshot

Every example below uses this function. Save it as positions.py and set HYDROMANCER_API_KEY in your environment (how to get a key). It handles one market or many, and turns each position into a dictionary with the field names above.

import os
import struct

import msgpack
import requests
import zstandard

URL = "https://api.hydromancer.xyz/info"
HEADERS = {"Authorization": f"Bearer {os.environ['HYDROMANCER_API_KEY']}"}
FIELDS = ["size", "notional_size", "funding_pnl", "entry_price",
          "leverage_type_flag", "leverage_multiplier",
          "liquidation_price", "account_value"]

def unzstd(blob):
    try:
        return zstandard.ZstdDecompressor().decompress(
            blob, max_output_size=2_000_000_000)
    except zstandard.ZstdError:
        return blob                       # already decompressed by requests

def decode(content, payload_format):
    if payload_format == "multi-zstd":    # several markets, one block each
        (count,) = struct.unpack_from("<I", content, 0)
        blocks, pos = [], 4
        for _ in range(count):
            (length,) = struct.unpack_from("<I", content, pos)
            blocks.append(content[pos + 4:pos + 4 + length])
            pos += 4 + length
    else:                                 # a single market
        blocks = [content]

    rows = []
    for block in blocks:
        data = msgpack.unpackb(unzstd(block))
        if isinstance(data, dict):        # older {i, m, p, a} layout
            data = [data["i"], data["m"], data["p"], data["a"]]
        snapshot_id, market, positions, addresses = data[:4]
        for address, values in zip(addresses, positions):
            rows.append({"snapshot_id": snapshot_id, "market": market,
                         "user": address, **dict(zip(FIELDS, values))})
    return rows

def get_positions(market_names):
    """Every open position in the given markets, one dict per position."""
    r = requests.post(URL, headers=HEADERS, timeout=120,
                      json={"type": "perpSnapshots", "market_names": market_names})
    r.raise_for_status()
    return decode(r.content, r.headers.get("x-payload-format"))

Before you download a snapshot, you can check whether there's a new one. {"type": "perpSnapshotTimestamp"} returns just the latest snapshot_id and its timestamp, in about a millisecond. Hydromancer's docs suggest checking every 5 to 10 seconds and downloading only when the ID changes.

Find the biggest positions and how close they are to liquidation

Sort a market by notional_size and you have its whales. Compare each liquidation price with the current price from the free official API, and you can see how much of a move it would take to force them out.

import math
import requests
from positions import get_positions

rows = get_positions(["BTC"])
price = float(requests.post("https://api.hyperliquid.xyz/info",
                            json={"type": "allMids"}, timeout=30).json()["BTC"])

rows.sort(key=lambda r: abs(r["notional_size"]), reverse=True)
print(f"{len(rows):,} open BTC positions, mid price ${price:,.0f}\n")
for r in rows[:10]:
    side = "LONG " if r["size"] > 0 else "SHORT"
    margin = "isolated" if r["leverage_type_flag"] == 1 else "cross"
    liq = r["liquidation_price"]
    if liq and math.isfinite(liq) and liq > 0:
        where = f"liq ${liq:,.0f} ({abs(liq - price) / price:.1%} away)"
    else:
        where = "no liquidation price"
    print(f"{r['user'][:10]}  {side}  ${abs(r['notional_size']):>13,.0f}  "
          f"{r['leverage_multiplier']:.0f}x {margin:<8}  {where}")

A liquidation price is an estimate, not a forecast. It moves when a trader adds margin or their other positions change, and for unified and portfolio-margin accounts it's worked out from collateral held across the account. Some positions have no meaningful liquidation price at all, which is why the code checks for one.

Good for: whale watchlists, liquidation heatmaps and "how crowded is this trade?" dashboards. Our liquidation data guide covers what happens once those prices are hit.

See which way every market leans

Add up long and short value per market and you get the long/short split for the whole exchange, the same numbers as Flowscan's All markets tab.

from collections import defaultdict
from positions import get_positions

markets = defaultdict(lambda: {"long": 0.0, "short": 0.0, "positions": 0})
for r in get_positions(["ALL"]):           # every market on the main DEX
    m = markets[r["market"]]
    m["long" if r["size"] > 0 else "short"] += abs(r["notional_size"])
    m["positions"] += 1

ranked = sorted(markets.items(),
                key=lambda kv: kv[1]["long"] + kv[1]["short"], reverse=True)
for name, m in ranked[:10]:
    total = m["long"] + m["short"]
    print(f"{name:<8} ${total:>15,.0f}  long {m['long'] / total:.0%}  "
          f"short {m['short'] / total:.0%}  {m['positions']:,} positions")

["ALL"] covers the main DEX only. Use ["ALL:ALL_DEXES"] to include HIP-3 markets too. On HIP-3 DEXes, values are in that DEX's collateral token, which isn't always USDC, so convert before adding them to main-DEX totals.

See what top traders are holding

The whole crowd and the best traders don't always agree. To see what proven traders hold, rank wallets with userPnlLeaderboard (another add-on), then keep only their rows from the snapshot. minHumanScore filters out wallets that look like bots, on a 0 to 100 scale.

import requests
from positions import URL, HEADERS, get_positions

board = requests.post(URL, headers=HEADERS, timeout=60, json={
    "type": "userPnlLeaderboard", "window": "30d", "sortBy": "totalPnl",
    "limit": 200, "minTrades": 20, "minHumanScore": 70,
}).json()
top = {u["user"].lower() for u in board["users"]}

long_usd = short_usd = 0.0
holders = set()
for r in get_positions(["BTC"]):
    if r["user"].lower() in top:
        holders.add(r["user"].lower())
        if r["size"] > 0:
            long_usd += abs(r["notional_size"])
        else:
            short_usd += abs(r["notional_size"])

total = (long_usd + short_usd) or 1
print(f"{len(holders)} of the top {len(top)} traders hold BTC")
print(f"long  ${long_usd:,.0f} ({long_usd / total:.0%})")
print(f"short ${short_usd:,.0f} ({short_usd / total:.0%})")

Past profit doesn't promise future profit, and a big short can be a hedge against a long held elsewhere. Treat this as a picture of what good traders hold, not a signal to copy. Our whale tracker guide shows how to get an alert when those wallets trade.

Track how positioning changes

One snapshot shows where everyone stands. Two show who moved. This script waits for a new snapshot, then counts the positions that were opened, closed or flipped from long to short in between.

import time
import requests
from positions import URL, HEADERS, get_positions

def latest_snapshot_id():
    r = requests.post(URL, headers=HEADERS, timeout=10,
                      json={"type": "perpSnapshotTimestamp"})
    r.raise_for_status()
    return r.json()["snapshot_id"]

def sizes(rows):
    return {(r["user"], r["market"]): r["size"] for r in rows}

seen = latest_snapshot_id()
before = sizes(get_positions(["BTC"]))
while latest_snapshot_id() == seen:          # cheap check, nothing downloaded
    time.sleep(10)
after = sizes(get_positions(["BTC"]))

opened = [k for k in after if k not in before]
closed = [k for k in before if k not in after]
flipped = [k for k in after if k in before and (after[k] > 0) != (before[k] > 0)]
print(f"{len(opened)} opened, {len(closed)} closed, {len(flipped)} flipped")

From there you can rank the biggest changes, or alert when a large account flips.

3. Look back in time with Reservoir's daily snapshots

The two options above show positioning now. To see how it looked before a crash, or how the long/short split moved over a month, you need history. Reservoir is Hydromancer's free archive of Hyperliquid data on Amazon S3, and it keeps a snapshot of every open position for each day from July 2025.

It's built with the same pipeline as the live perpSnapshots endpoint, from one on-chain state per UTC day. You don't need a Hydromancer plan or API key. The bucket is set to requester pays, so AWS charges your account its normal fees for requests and data transfer.

A few things to know before you query it:

• One snapshot a day, not the close. The file name gives the block and the exact time the state was taken, which isn't necessarily the end of the day. Check it before you line a snapshot up with an event.
• Some days are missing. There's a known gap from late October to mid-December 2025, and other dates can be missing too, so check the S3 listing.
• HIP-3 has its own folders. Values are in each DEX's collateral token, as in the live API.

The files are Parquet, a compressed table format that DuckDB, pandas and Spark read directly. One day's positions on the main DEX live here:

s3://hydromancer-reservoir/by_dex/hyperliquid/snapshots/perp/date=YYYY-MM-DD/{block}_{timestamp}.parquet

Every DEX together is under global/snapshots/perp/all/, and each HIP-3 DEX under by_dex/{dex}/snapshots/perp/. Each row is one wallet's position in one market:

With AWS access set up (our Reservoir guide walks through it), this DuckDB query lists the 20 largest BTC positions on 1 October 2026:

INSTALL httpfs; LOAD httpfs;
CREATE SECRET (TYPE s3, PROVIDER credential_chain, REGION 'ap-northeast-1');
SET s3_requester_pays = true;

SELECT "user", size, notional, entry_price, liquidation_price, leverage_type, leverage
FROM read_parquet('s3://hydromancer-reservoir/by_dex/hyperliquid/snapshots/perp/date=2026-10-01/*.parquet')
WHERE market = 'BTC'
ORDER BY abs(notional) DESC
LIMIT 20;

And this one tracks BTC's long/short split across every day in October that's available:

SELECT "date",
       sum(abs(notional)) FILTER (WHERE size > 0) AS long_value,
       sum(abs(notional)) FILTER (WHERE size < 0) AS short_value,
       count(*) AS positions
FROM read_parquet('s3://hydromancer-reservoir/by_dex/hyperliquid/snapshots/perp/date=2026-10-*/*.parquet',
                  hive_partitioning = true)
WHERE market = 'BTC'
GROUP BY "date"
ORDER BY "date";

The * in a path needs permission to list the bucket, and every file it matches is read, so AWS bills for each one. Keep the date range and the columns to what you need. The same archive also has daily spot balances and account values; the snapshot schema lists every column.

Good for: research, backtests that use positioning, and "what did the crowd hold before the drop?" questions. For anything inside the last day, use the live endpoint.

Flowscan Terminal vs perpSnapshots vs Reservoir

What positioning data can and can't tell you

• A wallet isn't a bet. Market makers hold both sides, and a short on Hyperliquid can hedge a long somewhere else. Flowscan's tags help separate them; in code, the leaderboard's filters do.
• One person can have many wallets. Sub-accounts and vaults have their own addresses, so the same trader can show up several times.
• Liquidation prices move. They shift whenever margin or other positions change, so read them as levels to watch, not prices that will definitely trigger.
• A snapshot is a moment. Check its time, and compare two snapshots before deciding anything changed.

How much does it cost?

Flowscan Terminal is free. Reservoir's data is free, and you pay AWS for the requests and data you pull. Hydromancer API plans start at $300 a month for 500,000 tokens, and perpSnapshots is an add-on purchased separately, as is the trader leaderboard. Public-goods projects such as dashboards and alert bots, and early-stage builder-code teams, can apply for free infrastructure access.

FAQ

Can you see all open positions on Hyperliquid?

Yes. Every Hyperliquid position is on-chain, and Hydromancer's perpSnapshots endpoint returns all of them, across every market and DEX, in one request. Flowscan Terminal shows the same view in a browser.

Does the official Hyperliquid API return all positions?

No. The official API's clearinghouseState returns positions for one wallet at a time, and there is no public endpoint that lists every trader.

How do I find the biggest positions on Hyperliquid?

Pull a market with perpSnapshots and sort by notional_size. Each row also includes leverage and liquidation price, so you can see how close each whale position is to liquidation.

How can I see what top traders on Hyperliquid are doing?

Rank wallets with userPnlLeaderboard, then filter the full position snapshot to those addresses and sum their exposure per market. Without code, use Flowscan Terminal at flowscan.xyz/terminal.

Is there a free way to see Hyperliquid trader positioning?

Yes. flowscan.xyz/terminal shows entire Hyperliquid positioning with no login, and Reservoir's daily snapshots need no API key (AWS charges its normal fees for the data you pull).

Does perpSnapshots cover HIP-3 markets?

Yes. Use dex:market names such as xyz:BTC, ALL:xyz for one DEX, or ALL:ALL_DEXES for every DEX at once.

Can I get historical Hyperliquid positioning?

Yes. Reservoir publishes daily Parquet snapshots of every position from July 2025 onward (a few dates are missing), queryable with DuckDB, Spark or pandas.

How much does perpSnapshots cost?

Hydromancer API plans start at $300 per month, and perpSnapshots is an add-on purchased separately. Public-goods and early-stage teams can apply for free infrastructure access.

Related reading

• How to build a Hyperliquid whale tracker
• Hyperliquid vs Hydromancer API: when to upgrade?
• How to query Reservoir's Hyperliquid data
• Building with liquidation data on Hyperliquid
• How to get Hyperliquid data

Sources

[1] Hydromancer docs: perpSnapshots
[2] Reservoir schema: snapshots
[3] Hydromancer docs: userPnlLeaderboard
[4] Hydromancer docs: pricing
[5] Hyperliquid docs: perpetuals info endpoint
[6] Hyperliquid docs: rate limits
[7] Flowscan Terminal