How to Track Hyperliquid TWAP Orders

A TWAP order splits one large trade into small slices over a set time, so it moves the price less than one market order would. On Hyperliquid, an onchain crypto exchange, TWAPs are a native order type, and every one is public from the moment it starts. This guide builds a tracker that lists the large TWAPs running in a market right now, groups them by wallet, follows one wallet's history and alerts you when a known wallet starts a new one. Every request ran on 8 November 2026 between 16:12 and 16:17 UTC, and every output is what came back.

Short answer

• Every TWAP in a market: GET /v1/hyperliquid/twap/{symbol} on 0xArchive. Eight days of HYPE, 4,584 events covering 2,330 TWAPs, came back in 5 requests and 0.7 seconds. Group the events by twap_id to get each order's start, size and status.
• Running right now in HYPE: 30 TWAPs, $2.04 million of planned buys against $3.20 million of planned sells. One wallet ran four identical sells worth $2.72 million, 85% of the sell side.
• One wallet's TWAPs: Hyperliquid's own twapHistory works for any address, free. Hyperliquid has no call that lists every TWAP in a market, so you need 0xArchive to find the wallets.
• Planned size overstates what trades. Of 2,290 HYPE TWAPs that ended in eight days, 985 were terminated early, and those filled a median 14.5% of their size.

Why track TWAPs on Hyperliquid

A Hyperliquid TWAP runs for 5 minutes to 7 days, with a $100 minimum. Hyperliquid splits it into suborders at least 30 seconds apart, and no suborder can slip more than 3%. Each TWAP shows the wallet, the side, the total size and the duration when it starts, before most of it has traded. A 7-day buy of 10,000 HYPE is visible on day one, while the slices are still to come. That makes the TWAP feed an early read on size that has not reached the tape. For a long study of HYPE buyers built on this data, see Who is TWAP-buying HYPE on Hyperliquid.

What you need

• Python 3 with requests, and a 0xArchive API key in OXARCHIVE_API_KEY.
• No key for Hyperliquid's own API at https://api.hyperliquid.xyz/info.
• History: perpetual TWAP events start 17 June 2026 at 18:00 UTC and spot TWAPs on 5 May 2026 at 13:05 UTC, per capabilities. The Free plan covers the last 30 days. See pricing.

The snippets are short prototypes with no retry logic.

Step 1: read a market's TWAP events

/v1/hyperliquid/twap/{symbol} returns status events for one perpetual market, oldest first. A TWAP emits activated when it starts, then one of finished, terminated, stopped or error when it ends. waitingForTrigger means it has not started. Every event carries the TWAP's twap_id, wallet, side, total size, the size and notional executed so far, the duration in minutes and started_at.

import os, time, requests

H = {"X-API-Key": os.environ["OXARCHIVE_API_KEY"]}
B = "https://api.0xarchive.io/v1/hyperliquid"

end = int(time.time() * 1000)
j = requests.get(f"{B}/twap/HYPE", headers=H, timeout=30,
                 params={"start": end - 24 * 3600 * 1000, "end": end, "limit": 1000}).json()
print(len(j["data"]), j["meta"]["has_more"])
print(j["data"][0])

254 False
{'timestamp': '2026-11-07T16:13:45.014Z', 'block_time': '2026-11-07T16:13:45.014Z', 'block_number': 1212686729, 'twap_id': 2574544, 'status': 'activated', 'coin': 'HYPE', 'user_address': '0x58dece3264ae8bbb990336694454ddd2638f5d12', 'side': 'B', 'size': 3.28, 'executed_size': 0.0, 'executed_notional': 0.0, 'minutes': 30, 'reduce_only': False, 'randomize': False, 'started_at': '2026-11-07T16:13:45.014Z'}

One request in 0.09 seconds returned 254 events for the last 24 hours of HYPE: 124 activations, 56 finished, 57 terminated, 12 errors and 5 waiting for a trigger. The first is a 3.28 HYPE buy over 30 minutes. Most TWAPs are small, and the route does not filter by size, so the next step does.

Step 2: list the large TWAPs running now

The route returns events, not a table of open orders. To get what is running, group events by twap_id, drop any TWAP with an ending status, and keep the ones whose planned end (started_at plus minutes) is still ahead. Look back further than the longest TWAP in the market. HYPE had TWAPs of 10,080 minutes (7 days), so this looks back 8 days.

import os, time, datetime, requests
from collections import defaultdict

H = {"X-API-Key": os.environ["OXARCHIVE_API_KEY"]}
B = "https://api.0xarchive.io/v1/hyperliquid"
SYMBOL, LOOKBACK_DAYS = "HYPE", 8
ENDED = {"finished", "terminated", "stopped", "error"}

now = int(time.time() * 1000)
events, params = [], {"start": now - LOOKBACK_DAYS * 86_400_000, "end": now, "limit": 1000}
while True:
    j = requests.get(f"{B}/twap/{SYMBOL}", headers=H, params=params, timeout=30).json()
    events += j["data"]
    if not j["meta"].get("has_more"):
        break
    params["cursor"] = j["meta"]["next_cursor"]

by_twap = defaultdict(list)
for e in events:
    by_twap[e["twap_id"]].append(e)

mid = float(requests.post("https://api.hyperliquid.xyz/info", json={"type": "allMids"}, timeout=30).json()[SYMBOL])
ms = lambda s: datetime.datetime.fromisoformat(s.replace("Z", "+00:00")).timestamp() * 1000

active = []
for evs in by_twap.values():
    evs.sort(key=lambda e: e["timestamp"])
    first = evs[0]
    if any(e["status"] in ENDED for e in evs) or (first["status"] == "waitingForTrigger" and len(evs) == 1):
        continue
    if ms(first["started_at"]) + first["minutes"] * 60_000 < now:
        continue
    active.append({**first, "usd": first["size"] * mid,
                   "elapsed": (now - ms(first["started_at"])) / 60_000 / first["minutes"]})

print(len(events), "events,", len(by_twap), "TWAPs,", len(active), "active; mid", mid)
for side, name in (("B", "buys"), ("A", "sells")):
    print(name, round(sum(a["usd"] for a in active if a["side"] == side) / 1e6, 2), "M USD planned")
for a in sorted(active, key=lambda a: -a["usd"])[:6]:
    w = a["user_address"]
    print(a["twap_id"], w[:6] + ".." + w[-4:], "buy" if a["side"] == "B" else "sell",
          f"{a['size']:,.0f}", f"${a['usd']:,.0f}", a["minutes"], "min", f"{min(a['elapsed'], 1):.1%} elapsed")

4584 events, 2330 TWAPs, 30 active; mid 77.3185
buys 2.04 M USD planned
sells 3.2 M USD planned
2548540 0xd93d..ae3f buy 10,000 $773,185 10080 min 40.4% elapsed
2583679 0xd0b9..1199 sell 8,796 $680,074 1440 min 28.6% elapsed
2583682 0xd0b9..1199 sell 8,796 $680,074 1440 min 28.6% elapsed
2583686 0xd0b9..1199 sell 8,796 $680,074 1440 min 28.6% elapsed
2583691 0xd0b9..1199 sell 8,796 $680,074 1440 min 28.6% elapsed
2575339 0xa404..8c2f buy 5,000 $386,592 1470 min 92.0% elapsed

Five requests took 0.7 seconds. The largest TWAP was one 10,000 HYPE buy, $773,000, running for seven days. The next four rows share a wallet, a size and an end time: wallet 0xd0b9..1199 started four identical 24-hour sells, $2.72 million together. Ranked by order, that looks like four sellers. Ranked by wallet, one account holds 85% of the active planned sell side.

Elapsed is clock time, not fill progress. The feed records status changes, so a running TWAP's only event is its activation, with executed_size at 0. The size it traded arrives on the event that ends it. Until then, read planned size as a ceiling. Time left is the start time plus minutes, minus now. Show reduce_only next to the side: a reduce-only sell is closing a long, not opening a short.

Step 3: rank by wallet, not by order

Add this to the end of Step 2 to fold active TWAPs into one row per wallet and side:

by_wallet = defaultdict(lambda: {"usd": 0.0, "n": 0})
for a in active:
    k = (a["user_address"], a["side"])
    by_wallet[k]["usd"] += a["usd"]
    by_wallet[k]["n"] += 1
sells = sum(v["usd"] for (w, s), v in by_wallet.items() if s == "A")
for (w, s), v in sorted(by_wallet.items(), key=lambda kv: -kv[1]["usd"])[:3]:
    share = f", {v['usd'] / sells:.0%} of sells" if s == "A" else ""
    print(w[:6] + ".." + w[-4:], "buy" if s == "B" else "sell", f"{v['n']} TWAP" + "s" * (v["n"] > 1), f"${v['usd']:,.0f}{share}")

0xd0b9..1199 sell 4 TWAPs $2,720,297, 85% of sells
0xd93d..ae3f buy 2 TWAPs $972,053
0xa404..8c2f buy 1 TWAP $386,592

The largest buyer also runs a second, smaller TWAP, which the order list in Step 2 cut off. Grouped, it plans $972,000 of buys.

Step 4: follow one wallet

/v1/hyperliquid/twap/user/{user} returns the same events for one wallet across every perpetual market. Page it the same way.

W = "0xd0b9..."   # the full 42-character address
rows, params = [], {"start": 1781654400000, "end": int(time.time() * 1000), "limit": 1000}   # from 17 Jun 2026
while True:
    j = requests.get(f"{B}/twap/user/{W}", headers=H, params=params, timeout=30).json()
    rows += j["data"]
    if not j["meta"].get("has_more"):
        break
    params["cursor"] = j["meta"]["next_cursor"]
print(len(rows), "events,", len({r["twap_id"] for r in rows}), "TWAPs")

278 events, 141 TWAPs

One request in 0.22 seconds: 141 perpetual TWAPs since 17 June, all in HYPE, 124 finished and 13 terminated. The same wallet ran 158 spot TWAPs, served by /v1/hyperliquid/spot/twap/user/{user}. HIP-3 markets have their own routes under /v1/hyperliquid/hip3/twap/. A wallet that has placed 141 TWAPs in five months has a habit, and a habit is a stronger signal than one order.

Step 5: discount planned size by how TWAPs end

Of the 2,330 HYPE TWAPs in the 8-day pull, 2,290 had ended:

The feed reports how a TWAP ended, not why. Hyperliquid's docs describe one way an order falls short: when suborders do not fill (price past the order's max or min price, a wide spread, thin liquidity), later suborders try to catch up but are capped at 3 times normal size, so the order can reach its end time unfilled. What matters for a tracker: 54% of ended TWAPs were terminated or ended in an error before finishing, so planned notional is a ceiling. Show executed_notional next to planned size, and weight the planned remainder by how often orders like it finish. Concentration was high too: 472 wallets planned $347 million across the 2,330 TWAPs, and the top five held 39.5% of it.

Step 6: get an alert when a known wallet starts a TWAP

For one address you already know, Hyperliquid's own WebSocket is free: twapStates streams its open TWAPs, userTwapHistory its status changes and userTwapSliceFills each slice as it fills, which is the live progress the history routes do not carry. The 0xArchive TWAP routes are REST only. To be told without holding a connection open, register wallets as watched addresses and subscribe to the account.twap_lifecycle webhook event. It fires on every status above and can filter by venue, symbol and address, and on size, executed_notional, fill_pct, minutes and status. Its latency class is minutes, and webhook delivery starts on the Build plan. Setup, limits and signature checks are in the whale tracker guide. To catch large TWAPs from wallets you do not know yet, run Step 2 on a schedule: keep the twap_id of every TWAP you have already alerted on, alert only on new activations above your size, and record the event time, not the time you polled.

Side by side: Hyperliquid's API and 0xArchive

The same jobs, run on 8 November 2026:

Use Hyperliquid's own API when you already have the address. For this wallet it reached ten days further back than our perpetual feed, and it found the 12 TWAPs we lack. Use 0xArchive when you need to find the addresses: it is the only one of the two that answers which TWAPs are running in a market. For more on where each source stops, see Hyperliquid's native API vs 0xArchive.

What to know before you build

• Coverage starts 17 June 2026 at 18:00 UTC for perpetuals. A window before that returns an empty page. The market route adds meta.coverage_from and a notice. The wallet route returns an empty page with no notice, so check the date yourself.
• Events, not orders. Group by twap_id. executed_size and executed_notional are the fill so far as of each event.
• Look back past the longest TWAP. A 24-hour lookback misses a 7-day TWAP that started on day two.
• Pages can be short. A page never splits a millisecond, so it can hold fewer rows than limit. Follow the cursor until has_more is false.
• One market per request. Activity varies widely: in 24 hours BTC started 50 TWAPs, ETH 25, HYPE 123 and DOGE more than 500.
• Perpetuals, spot and HIP-3 are separate routes. Spot coins appear as names like @107 in Hyperliquid's own API.
• An address is an account, not a person. Do not publish one next to a claim about who owns it.

FAQ

Can you see other traders' TWAP orders on Hyperliquid?

Yes. TWAPs are public. Hyperliquid's twapHistory returns them for any address, and 0xArchive lists every TWAP in a market.

How do I find large TWAP orders running in a market?

Read /v1/hyperliquid/twap/{symbol} over a window longer than the longest TWAP, group events by twap_id, drop the ones that ended, then rank by wallet on size times price.

How far back does Hyperliquid TWAP history go?

On 0xArchive, perpetuals from 17 June 2026 at 18:00 UTC and spot from 5 May 2026 at 13:05 UTC. Hyperliquid's own twapHistory can reach earlier for a single address.

How does a Hyperliquid TWAP order work?

It splits one order into suborders sent at least 30 seconds apart over a duration from 5 minutes to 7 days, with a $100 minimum. Each suborder can slip at most 3%. Options: randomize suborder sizes by up to 20%, start on a trigger price, and set a max or min price that no suborder fills past. Over the API it is the twapOrder action, cancelled with twapCancel. The order's account, side and size are public from the start, and anyone can stream its fills by address while it runs.

Do Hyperliquid TWAP orders always complete?

No. Of 2,290 HYPE TWAPs that ended in eight days, 1,053 finished, 985 were terminated and 252 ended in an error.

Next steps

• The study built on this data: Who is TWAP-buying HYPE on Hyperliquid.
• Follow wallets and set up alerts: How to Build a Hyperliquid Whale Tracker.
• See where every trader sits in a market: How to See Every Trader's Positioning on Hyperliquid.
• Reference: Hyperliquid REST API, webhook events and Hyperliquid data.

Tested on 8 November 2026. The code is prototype code, and live numbers move by the minute.