How to Build an Order Flow Dashboard for Hyperliquid
Build a Hyperliquid order flow dashboard: buy and sell volume from the trade stream, who is behind each trade, and backfilling the last 24 hours. Tested.
Order flow is who is buying and who is selling, right now, and how hard. Order flow traders watch the tape rather than the chart: aggressive buyers lifting the ask, a burst of selling, the same wallet hitting the market again and again. A dashboard turns that into numbers: buy vs sell volume per minute, cumulative delta, large trades.
Why traders watch it:
• To see pressure before the chart moves. Heavy buying or selling shows up in the tape first.
• To spot a move running out of steam, when price keeps rising but buying dries up.
• To find the big players: large trades, and the same source buying again and again.
• To time entries and exits around where the real buying and selling happens.
Why should you choose to build order flow on Hyperliquid?
• You can see who is trading. On a centralized exchange, you see trades but not who made them. On Hyperliquid, every trade carries both wallet addresses.
• That shows more than volume. The same wallet buying again and again, a known trader flipping short, a cluster of liquidations.
• There's plenty of flow. $2.08B traded on Hyperliquid's main perp markets in 24 hours when we checked, by Hyperliquid's own volume figures, and every trade named its buyer and seller.
• The live feed is free. Hyperliquid's trades stream needs no sign-up or API key.
• Two ways to get paid. Charge a subscription, or put it inside a trading terminal where orders carry your builder code.
How we tested. We built the dashboard's core number, BTC buy and sell volume per minute, on both APIs and ran them side by side on 31 October 2026.
The raw material: every trade, with both wallets
Hyperliquid's trades stream sends each trade with its price, size, the taker's side and both addresses. The REST version, recentTrades, shows the same shape:
import requests
trades = requests.post("https://api.hyperliquid.xyz/info",
json={"type": "recentTrades", "coin": "BTC"}).json()
for t in trades[:3]:
print(t["side"], t["sz"], "@", t["px"], "buyer, seller:", t["users"])
print(len(trades), "trades returned")A 0.00157 @ 77420.0 buyer, seller: ['0x706bb519b05b7dc01d048af9a5e29d1ef5d6d9e3', '0x0c684f333a7e120bce61383da670bbb0157e82d0']
B 0.00031 @ 77421.0 buyer, seller: ['0xe642e0504b53c3d06438e57b90bc8fca6f2fa603', '0xdda7f4805dfdf145a74cd68992d90780f73cf6c7']
A 0.00019 @ 77420.0 buyer, seller: ['0x706bb519b05b7dc01d048af9a5e29d1ef5d6d9e3', '0xde2264ea8cf73e9acb39054fce49dc5e6fe54119']
10 trades returnedside is the taker: B means the aggressor bought, A means it sold. users is [buyer, seller]. That's all a live dashboard needs, and it's free.
Buy vs sell volume and delta
The panels order flow traders look for are all built from the same trades:
• Footprint. Buy and sell volume at each price inside every candle, so you see where the fighting happened.
• Cumulative volume delta (CVD). Buys minus sells, added up over time.
• Imbalance. Prices where one side traded far more than the other.
• Large prints. Single trades, or groups of trades from one taker, above a size you set.
Sum the dollar value of B trades and A trades per minute and you have buy and sell volume. Their difference is delta; add it up over time and you have cumulative delta, the line order flow traders watch for a move running out of steam.
Hyperliquid API
The trades stream has everything a live dashboard needs, and it's free. This prototype listens to BTC for three minutes and adds up each minute:
import json, time, collections
from websockets.sync.client import connect
flow, start = collections.Counter(), time.time()
with connect("wss://api.hyperliquid.xyz/ws") as ws:
ws.send(json.dumps({"method": "subscribe", "subscription":
{"type": "trades", "coin": "BTC"}}))
while time.time() < start + 180:
m = json.loads(ws.recv())
for t in m["data"] if m["channel"] == "trades" else []:
if t["time"] >= start * 1000: # skip trades sent on subscribe
usd = float(t["px"]) * float(t["sz"])
flow[t["time"] // 60000, t["side"]] += usd
for (minute, side), usd in sorted(flow.items()):
print(time.strftime("%H:%M", time.gmtime(minute * 60)), side, round(usd))19:35 A 13063
19:35 B 200368
19:36 A 18142
19:36 B 3545
19:37 A 3454
19:37 B 1859
19:38 A 128
19:38 B 171It works from the moment you connect. The gap is what happened before: when a user opens the dashboard at 3 pm, they want the morning too. Hyperliquid's REST version, recentTrades, returned only the last 10 trades, and the stream sends a short batch of recent trades when you subscribe, not the session. On Hyperliquid alone, a backfill means keeping your own recorder running all day, or downloading its S3 archive (below).
Hydromancer API
tradesByTime pages through the last 24 hours, up to 2,000 trades per page, in the same shape as the stream. This prototype builds the last hour's per-minute flow, then a dashboard switches to the live stream:
import os, time, collections, requests
H = {"Authorization": "Bearer " + os.environ["HYDROMANCER_API_KEY"]}
base = {"type": "tradesByTime", "coin": "BTC", "limit": 2000}
body = {**base, "startTime": int(time.time() * 1000) - 3600000}
flow = collections.Counter()
while body:
r = requests.post("https://api.hydromancer.xyz/info", headers=H,
json=body).json()
for t in r["trades"]:
flow[t["time"] // 60000, t["side"]] += float(t["px"]) * float(t["sz"])
body = r["hasMore"] and {**base, "cursor": r["cursor"]}
for (minute, side), usd in sorted(flow.items()):
print(time.strftime("%H:%M", time.gmtime(minute * 60)), side, round(usd))19:04 A 1000
19:04 B 36
19:05 A 1475532
19:05 B 7544
19:06 A 59270
19:06 B 55356
... (116 more lines)Side by side
| Hyperliquid API | Hydromancer API | |
|---|---|---|
| What you get | Flow from the moment you connect | The last hour at once (up to 24 hours back) |
| Worked | 1 of 1 runs | 3 of 3 runs |
| Time to finish (median) | 181 s (listens live by design) | 0.7 s |
| Requests | 0 (live stream) | 3 |
| Rate-limit cost | none (live stream) | 30 points (limit: 20,000 a minute on the Growth plan) |
| Data received over REST (uncompressed) | not measured (live stream) | 1.1 MB |
They do different jobs, and a real dashboard uses both: Hydromancer to fill the last 24 hours when the page opens, and either live stream after that. Because the shapes match, the same code adds up both.
For older days, Hyperliquid's own S3 archive (node_fills_by_block) and Reservoir's daily files both have every fill with both addresses. Reservoir's files start in August 2025 and cost only AWS download charges.
Who is behind the flow
Because users names both sides, your dashboard can group flow by wallet: the top ten wallets by taker volume in the last hour, or a flag when a wallet that just bought $5M also holds a large position. Pair this with our whale tracker for positions and our liquidation guide for forced selling, which shows up as flow too.
Two cautions for the copy on your dashboard:
• One side of a trade is often a market maker. Big taker flow from a wallet means that wallet was aggressive, not that it's a "whale" making a bet.
• A big market order fills against many resting orders, so it arrives as many small trades with the same taker and time. Group them before you call something a "large trade".
Book-side flow
Trades show what executed. The order book shows what's waiting.
Hyperliquid API
The l2Book stream gives 20 price levels a side, with total size per level. To see individual orders and who placed them, you'd run your own node with --write-raw-book-diffs and rebuild the book with Hyperliquid's example order_book_server.
Hydromancer API
The order-by-order L4 book shows each resting limit order with its owner, so you can see the same wallet pulling and re-placing orders. Hydromancer added this endpoint for builder convenience; it isn't part of Hyperliquid's original API, and orders still go through Hyperliquid.
Side by side
| Hyperliquid API | Hydromancer API | |
|---|---|---|
| Size at each price level | Yes | Yes |
| Each order and its owner | Only with your own node | Yes |
Seeing one wallet pull and re-place a wall of orders is the kind of signal order flow traders pay for. Our orderbook types guide explains the trade-offs.
Sell the dashboard as a subscription, or put these panels inside a trading terminal so users can trade straight from the tape, with your builder code on every order.
FAQ
Can I see who made a trade on Hyperliquid?
Yes. Every trade in the trades stream includes the buyer's and seller's addresses.
How do I tell buys from sells on Hyperliquid?
The side field is the taker's side: B means the aggressor bought, A means it sold.
How do I get the last few hours of trades?
Hyperliquid's recentTrades returns only the most recent handful. Hydromancer's tradesByTime pages through the last 24 hours; Hyperliquid's S3 archive and Reservoir have older days.
Related reading
• Hyperliquid data feeds: every real-time stream
• BBO vs L2Book vs L4Book
• Hyperliquid whale tracker
• How to build a Hyperliquid orderbook heatmap
Sources
- Hyperliquid docs: Subscriptions, Info endpoint
- Hydromancer docs: tradesByTime, L4 orderbook streaming
Read next
How to Build a Hyperliquid TWAP Execution Tool
Build a TWAP execution tool on Hyperliquid: native TWAP orders vs your own slicing, tracking slice fills, and seeing every active TWAP in a market.
How to Build a Trading Terminal on Hyperliquid
Build a Hyperliquid trading terminal: charts, order book, trades and order entry, plus 1-second candles and older chart history. Tested on both APIs.
How to Build a Trading Journal for Hyperliquid
Build a Hyperliquid trading journal: turn fills into closed trades with entry, exit, fees, funding and hold time, and keep history past 10,000 fills.