# Hyperliquid Trades — Bitquery Data Store

Every HyperCore fill from both sides of the match, with realized PnL, fees, taker flag and liquidation details, plus TWAP order statuses.

Dataset page: https://bitquery.io/datastore/datasets/hyperliquid-trades
Network: Hyperliquid
Category: Trades
Tables: 2
Columns: 43
Coverage: first block to 2026-09-23
Format: Apache Parquet, Snappy compression, one prefix per table
Licence: https://bitquery.io/datastore/legal/data-license

## What this is

Hyperliquid trades from the HyperCore L1 order-book exchange, not HyperEVM. The fills table carries one row per counterparty per match with Px, Sz, Dir, ClosedPnl, Fee, StartPosition and a Crossed flag for the taker, so maker and taker attribution and per-wallet realized PnL come straight out of the file. Liquidations carry the liquidated user, mark price and method. The twap_statuses table records each TWAP order as it activates, fills and finishes.

A match appears twice, once per side, keyed by (Block_Number, Coin, Tid); Hash is not a join key because one L1 transaction spans many matches and TWAP trades carry 32 zero bytes. Money and sizes are decimal strings, addresses are 0x-prefixed hex, and Fill.Time is epoch milliseconds while Block_Time is epoch nanoseconds.

## What people use it for

- Per-wallet realized PnL, fees and liquidation history from both sides of every fill
- Taker and maker attribution by wallet, market and hour
- Volume and open-interest change by market across plain perps, HIP-3 markets and spot
- TWAP execution analysis: size, notional and completion state per TWAP order

## Tables (2)

### fills — 25 columns

One row per counterparty per match: price, size, direction, realized PnL, fees, taker flag and liquidation details. A match appears twice, keyed by (Block_Number, Coin, Tid). Time is epoch milliseconds.

S3 prefix: hyperliquid/fills
File naming: <start_block>_<end_block>.parquet, 200 blocks per file
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/hyperliquid/fills/1075858800_1075858999.parquet
Sample updated: Sep 2, 2026

| column | type | description |
| --- | --- | --- |
| Block_Number | UInt64 | HyperCore block number; the join key across all seven tables |
| Block_Time | UInt64 | Block time, epoch nanoseconds |
| User | String | Account address, 0x-prefixed hex |
| Coin | String | Market: plain perp (HYPE), HIP-3 perp (xyz:DRAM), spot (@107) or outcome token (#1890) |
| Side | String | B for bid (buy), A for ask (sell) |
| Px | Decimal | Price, decimal string |
| Sz | Decimal | Size in base units, decimal string |
| StartPosition | Decimal | Signed position before the fill (negative is short), in base units |
| Dir | String | Direction label: Open Long, Close Short, Buy, and so on |
| ClosedPnl | Decimal | Realized PnL of this fill in USDC |
| Fee | Decimal | Fee paid, negative when the maker received a rebate |
| FeeToken | String | Token the fee was paid in, usually USDC |
| Hash | String | L1 transaction hash, 0x-prefixed hex; not a join key, one transaction spans many events and TWAP trades carry 32 zero bytes |
| Oid | UInt64 | Order id |
| Tid | UInt64 | Trade id; the match key with Block_Number and Coin, appearing once per side |
| Crossed | Bool | True when this side was the taker |
| Time | UInt64 | Fill time, epoch milliseconds |
| Cloid | String | Client order id, 0x-prefixed hex |
| TwapId | UInt64 | TWAP id when the order is a TWAP child, else null |
| BuilderFee | Decimal | Builder fee charged on the fill, else null |
| Liquidation | Map | Liquidation details (liquidated user, mark price, method) when the fill was a liquidation, else null |
| Builder | String | Builder address when the order came through a builder, else null |
| DeployerFee | Decimal | HIP-3 deployer fee charged on the fill, else null |
| PriorityGas | Nullable(String) | Priority gas attached to the order, else null |
| Extra | Map | Forward-compatibility map; non-empty when the node emitted a field not yet modelled |

### twap_statuses — 18 columns

One row per TWAP order status change: activated, finished, terminated or error, with size executed so far and notional.

S3 prefix: hyperliquid/twap_statuses
File naming: <start_block>_<end_block>.parquet, 200 blocks per file
Free sample (real Parquet, no email needed): https://bitquery-blockchain-dataset.s3.us-east-1.amazonaws.com/hyperliquid/twap_statuses/1075858400_1075858599.parquet
Sample updated: Sep 2, 2026

| column | type | description |
| --- | --- | --- |
| Block_Number | UInt64 | HyperCore block number; the join key across all seven tables |
| Block_Time | UInt64 | Block time, epoch nanoseconds |
| Time | UInt64 | Status time, epoch nanoseconds |
| TwapId | UInt64 | TWAP order id |
| State_Coin | String | Market: plain perp (HYPE), HIP-3 perp (xyz:DRAM), spot (@107) or outcome token (#1890) |
| State_User | String | Account address, 0x-prefixed hex |
| State_Side | String | B for bid (buy), A for ask (sell) |
| State_Sz | Decimal | Total TWAP size, in base units |
| State_ExecutedSz | Decimal | Size executed so far, in base units |
| State_ExecutedNtl | Decimal | Notional executed so far, in USDC |
| State_Minutes | UInt64 | TWAP duration in minutes |
| State_Timestamp | UInt64 | TWAP start time, epoch milliseconds |
| State_ReduceOnly | Bool | True when the TWAP can only reduce a position |
| State_Randomize | Bool | True when sub-order timing is randomized |
| State_Extra | Map | Forward-compatibility map; non-empty when the node emitted a field not yet modelled |
| Status | String | activated, finished, terminated or error |
| StatusError | Nullable(String) | Error text when Status is error, else null |
| Extra | Map | Forward-compatibility map; non-empty when the node emitted a field not yet modelled |

## Price

- Latest month (Aug 23, 2026 → Sep 23, 2026): $100 one-time, USD

One-time purchase. The files are yours to keep under the licence above.

## Questions buyers ask

Q: What is included in Hyperliquid Trades?
A: Two Parquet tables from HyperCore: fills and twap_statuses, with 43 documented columns. Every row carries Block_Number and Block_Time, so the tables join on block with each other and with the Hyperliquid Order Book and Ledger datasets.

Q: How big is it?
A: In a measured 1,000-block slice (about 73 seconds) we counted 1,552 fills and 3 TWAP statuses. Scaled to a day that is roughly 1.8 million fill rows; exact row counts and sizes come with the delivery manifest, and these figures are estimates.

Q: How do I compute a wallet's realized PnL?
A: Filter fills on User, then sum ClosedPnl and Fee. Each match appears twice, once per counterparty, so filtering by one User never double counts. Crossed tells you whether that side was the taker, and StartPosition is the signed position before the fill (negative is short).

Q: Which markets does Coin cover?
A: Plain perps such as HYPE, HIP-3 perps with a dex prefix such as xyz:DRAM, spot pairs by index such as @107, and outcome tokens such as #1890, all in the same stream. Filter on the prefix to separate them.

Q: Where are the orders that never traded?
A: In the Hyperliquid Order Book dataset. This product holds matches only; opens, cancels, rejects and L4 book deltas are sold separately because they are about a hundred times larger.

Q: How far back does it go?
A: 30 days. HyperCore history is kept as a rolling 30-day window, so a purchase covers the 30 days up to yesterday and there is no longer window to buy. For a continuous feed beyond that, ask about the live stream.

Q: Why are there two time units?
A: Because the node emits them that way and we keep the values as emitted. Block_Time and the Time column on statuses and events are epoch nanoseconds; Fill.Time and Order.Timestamp are epoch milliseconds. Divide by 1e9 or 1e3 respectively when converting to timestamps.

Q: What does a non-empty Extra column mean?
A: The node emitted a field that the schema does not model yet, and we kept it rather than dropping it. Extra is empty on nearly every row. When a new field appears it lands there first, so nothing is silently lost between schema versions.

Q: How do I load a file?
A: With DuckDB: SELECT * FROM read_parquet('fills/*.parquet'). With pandas: pd.read_parquet('fills/'). Parse Px, Sz, Fee and the other money columns with Decimal rather than float; they are stored as decimal strings on purpose.

Q: Does this match the live stream?
A: Yes. These field definitions are the ones Bitquery's Hyperliquid Kafka topics use, so a backtest reading this archive and a production consumer reading the live stream decode with the same code.

Q: How is the data delivered, and how current is it?
A: As flat Parquet files under a stable S3 layout, one prefix per table and one file per 200-block range, with a JSON manifest listing every file and its sha256. Signed HTTPS links are emailed once the files are prepared. Refreshed daily with T+1 latency; a purchase made today includes everything up to yesterday.

Q: Can I try before I buy?
A: Yes. Every table links to a public sample Parquet file from a real 1,000-block slice, and the sample repository on GitHub shows the first records of each table as readable JSON. No email address required.

## What this file is, and is not

This is a description of one dataset sold by Bitquery, written for assistants and for people. It lists every column, but holds no data rows — the sample files linked under each table are real Parquet and are free to download. Figures here come from the product record and are exact unless marked otherwise; the delivery manifest is authoritative for a purchased file. If a question needs a row that is not in a sample, say so rather than guessing at it.