> ## Documentation Index
> Fetch the complete documentation index at: https://goldrush.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# allFills | Hyperliquid WebSocket API
> Hyperliquid allFills: stream every fill on HyperCore in real time for global market analytics and cross-wallet order-flow monitoring.
1 per minute
Realtime
Estimate your monthly cost for this API using the [Pricing Calculator](/pricing-calculator?endpoint=%2Fapi-reference%2Fhyperliquid-websocket%2Fall-fills).
* GoldRush-native: No `wss://api.hyperliquid.xyz/ws` equivalent.
* Filters `coin` and `aggregateByTime` are both optional. Omit `coin` to stream every market.
* Live-only: No historical snapshot on subscribe. For windowed history, use the Info API `userFillsByTime`.
* Same per-fill shape as `userFills`; channel name in messages is `allFills`.
Subscribe once and receive every fill on HyperCore as it executes, batched per block as `[address, fill]` tuples. Optional `coin` filter narrows the stream to a single market; `aggregateByTime` merges partial fills of the same order in a block.
## Endpoint
```
wss://hypercore.goldrushdata.com/ws?key=
```
Your GoldRush API key. Passed as a query parameter at connection time - no `Authorization` header is used.
## Subscribe
Send this JSON message after the connection is established:
Always `"subscribe"`.
Always `"allFills"`.
Restrict the stream to a single market (e.g. `"BTC"`, `"ETH"`, or spot `@N` form). Omit to receive every market on one subscription.
When `true`, partial fills of the same order within the same block are merged into one. Default `false`.
### Example
```bash wscat theme={null}
wscat -c "wss://hypercore.goldrushdata.com/ws?key=$GOLDRUSH_API_KEY"
> {"method":"subscribe","subscription":{"type":"allFills"}}
```
```typescript TypeScript theme={null}
import WebSocket from "ws";
const ws = new WebSocket(
`wss://hypercore.goldrushdata.com/ws?key=${process.env.GOLDRUSH_API_KEY}`,
);
ws.on("open", () => {
ws.send(JSON.stringify({
method: "subscribe",
subscription: {
type: "allFills",
},
}));
});
ws.on("message", (raw) => {
const msg = JSON.parse(raw.toString());
if (msg.channel === "allFills") {
for (const [address, fill] of msg.fills) {
console.log(address, fill.coin, fill.side, fill.sz, "@", fill.px);
}
}
});
```
```python Python theme={null}
import asyncio, json, os
import websockets
async def main():
uri = f"wss://hypercore.goldrushdata.com/ws?key={os.environ['GOLDRUSH_API_KEY']}"
async with websockets.connect(uri) as ws:
await ws.send(json.dumps({
"method": "subscribe",
"subscription": {"type": "allFills"},
}))
async for raw in ws:
msg = json.loads(raw)
if msg.get("channel") == "allFills":
for address, fill in msg["fills"]:
print(address, fill["coin"], fill["side"], fill["sz"], "@", fill["px"])
asyncio.run(main())
```
## Unsubscribe
Send the same `subscription` body with `method: "unsubscribe"`:
```json theme={null}
{
"method": "unsubscribe",
"subscription": {
"type": "allFills"
}
}
```
Unsubscribe matches subscriptions by **exact body**. A subscription created with `{"type": "allFills", "coin": "BTC"}` is a different subscription from a wildcard `{"type": "allFills"}` - they must be unsubscribed independently.
## Streamed message
Each push has `channel: "allFills"` and a `fills` array of `[address, fill]` tuples - every fill from the same HyperCore block that matches the optional `coin` filter, with the executing wallet as the first element of each tuple.
```json theme={null}
{
"channel": "allFills",
"fills": [
[
"0x742d35cc6634c0532925a3b844bc9e7595f7f2e2",
{
"coin": "ETH",
"px": "2150.5",
"sz": "1.5",
"side": "B",
"time": 1704067200000,
"startPosition": "1.5",
"dir": "Open Long",
"closedPnl": "125.5",
"hash": "0xabc...def",
"oid": 12345678,
"crossed": false,
"fee": "2.5",
"tid": 87654321,
"feeToken": "USDC",
"twapId": null
}
]
]
}
```
Always `"allFills"`.
Tuples of `[address, fill]`. The `address` is the wallet that executed the fill; the `fill` object carries the trade details.
Asset symbol - e.g. `"BTC"`, `"ETH"` for perps; spot pairs use the `@N` form (e.g. `"@107"`).
Fill execution price (decimal string).
Fill size (decimal string).
`"B"` for buy/long, `"A"` for ask/short.
Unix timestamp in milliseconds when the fill executed.
Signed position size on the same coin immediately before this fill.
Human-readable direction label - `"Open Long"`, `"Open Short"`, `"Close Long"`, `"Close Short"`, `"Buy"`, `"Sell"`, or position-flip labels `"Long > Short"` / `"Short > Long"`.
Realized PnL in USDC attributable to this fill (zero when the fill opens or extends a position).
L1 transaction hash that included this fill.
Parent order ID.
`true` when the fill came from the taker side of the order, `false` when it was the maker side.
Trading fee paid for this fill, denominated in `feeToken`.
Unique trade ID.
Symbol the fee was paid in - typically `"USDC"`.
Parent TWAP order ID if this fill is a slice of a TWAP, otherwise `null`.
Optional. Client order ID (`0x`-prefixed 32-character hex) if one was set at order placement.
Optional. Builder address the order was routed through.
Optional. Builder fee paid for this fill, denominated in `feeToken`.
Optional. Present only when this fill closed a position as part of a liquidation event.
The wallet whose position was liquidated.
Mark price at the time of liquidation.
Liquidation method - `"market"` or `"backstop"`.
## Related endpoints
stream live attributed fills for one or more builder addresses in real time.
stream a global, market-wide feed of every liquidation fill on HyperCore.
stream real-time trade fills for one or more wallets as they execute on HyperCore.
*Last reviewed: 2026-06-19*