Mempool channel

Watch Hyperliquid transactions before they are in a block. The mempool channel streams each signed action our Hyperliquid node receives from its peers, such as orders, cancels, modifies, TWAPs, leverage changes and transfers, as soon as it arrives. It covers every Hyperliquid product: perps, HIP-3, HIP-4 and Spot.

Pending is not executed. A transaction on this channel is not yet in a block, and it can still be rejected, expire or never land. For fills and order outcomes, use the trade and L4 order channels for the product; see WebSocket channels.

The channel is live only. It has no replay, no history, no REST route and no export, and it is never stored: a message you miss while not subscribed cannot be fetched later.

Endpoint and plans

Connect to wss://stream.0xarchive.io/ws, the only endpoint that serves mempool. It takes the same API key and the same protocol as wss://api.0xarchive.io/ws: send the key in the opening handshake as Authorization: Bearer $OXARCHIVE_API_KEY, as WebSocket connection describes. A mempool subscribe on wss://api.0xarchive.io/ws returns an error with error_code endpoint_unsupported:

{
  "type": "error",
  "message": "The 'mempool' channel is live only and served on wss://stream.0xarchive.io/ws. Subscribe to it there.",
  "error_code": "endpoint_unsupported"
}

Most other channels are served only on wss://api.0xarchive.io/ws, so a client that also needs them keeps a second connection there. Subscribing to one of them on the stream endpoint returns endpoint_unsupported naming the endpoint to use. The mempool channel is included with the Pro, Scale and Enterprise plans. It is the one channel that is not on every plan: every other channel and route is on every plan, Free included. On Free and Build, a mempool subscribe returns:

{
  "type": "error",
  "message": "The mempool channel is included with the Pro, Scale and Enterprise plans. Upgrade at https://0xarchive.io/pricing.",
  "error_code": "forbidden"
}

Subscribe without a symbol to receive every pending transaction our Hyperliquid node receives:

{ "op": "subscribe", "channel": "mempool" }

Or add symbol to receive only the actions that reference one market:

{ "op": "subscribe", "channel": "mempool", "symbol": "BTC" }

symbol is optional on this channel and on no other. Spell it as on the other channels: BTC for perps, xyz:XYZ100 for HIP-3, HYPE-USDC for Spot (HYPE/USDC is accepted too), and the outcome side coin, such as #49720, for HIP-4. An unknown symbol returns error_code invalid_symbol. A symbol subscription receives every action whose asset ids include that market. An action that references several markets, such as an order batch on BTC and ETH, is sent whole to the subscribers of each. If you hold the unfiltered stream and a symbol subscription on one connection, a matching action arrives on both. The server confirms each subscription. The unfiltered stream is confirmed with null in coin and symbol:

{ "type": "subscribed", "channel": "mempool", "coin": null, "symbol": null }

A symbol subscription is confirmed with the canonical spelling in both fields, such as HYPE-USDC for a subscribe sent as HYPE/USDC:

{ "type": "subscribed", "channel": "mempool", "coin": "HYPE-USDC", "symbol": "HYPE-USDC" }

To stop, send unsubscribe with the same fields. Without symbol, it stops the unfiltered stream; with symbol, it stops that symbol’s subscription. The server answers unsubscribed with the same coin and symbol.

{ "op": "unsubscribe", "channel": "mempool", "symbol": "BTC" }

Run a first subscription

This Node.js script subscribes to mempool for BTC, prints ten pending actions, then unsubscribes and closes. It needs a key on the Pro, Scale or Enterprise plan and the ws package (npm install ws).

import WebSocket from "ws";

const apiKey = process.env.OXARCHIVE_API_KEY;
if (!apiKey) throw new Error("Set OXARCHIVE_API_KEY");

const ws = new WebSocket("wss://stream.0xarchive.io/ws", {
  headers: { Authorization: `Bearer ${apiKey}` }
});
let seen = 0;

ws.on("open", () => {
  ws.send(JSON.stringify({ op: "subscribe", channel: "mempool", symbol: "BTC" }));
});

ws.on("message", (raw) => {
  const message = JSON.parse(raw);
  if (message.type === "subscribed") console.log("subscribed", message.channel, message.symbol);
  if (message.type === "error") {
    console.error(message.error_code, message.message);
    ws.close();
    return;
  }
  if (message.type !== "data" || seen >= 10) return;
  for (const item of message.data) {
    console.log(item.received_at, item.action.type, item.symbols.join(","));
    seen += 1;
    if (seen === 10) {
      ws.send(JSON.stringify({ op: "unsubscribe", channel: "mempool", symbol: "BTC" }));
      ws.close();
      break;
    }
  }
});

ws.on("close", (code, reason) => console.log("closed", code, String(reason)));

The messages on this page work with any WebSocket client.

Data messages

Each data message carries one batch of transactions, sent as soon as the node receives it from a peer. coin and symbol are the subscription’s symbol, or null on the unfiltered stream, and data holds one item per signed action:

{
  "type": "data",
  "channel": "mempool",
  "coin": "BTC",
  "symbol": "BTC",
  "data": [
    {
      "received_at": "2026-10-08T01:57:23.548737209Z",
      "received_at_ms": 1791424643548,
      "symbols": ["BTC"],
      "action": {
        "type": "order",
        "orders": [
          {
            "a": 0,
            "b": true,
            "p": "83276",
            "s": "0.40011",
            "r": false,
            "t": { "limit": { "tif": "Alo" } },
            "c": "0x7849acc2c6c2f6f0fe4bc80ef13d1504"
          }
        ],
        "grouping": "na"
      },
      "nonce": 1791424643400,
      "vault_address": null,
      "expires_after_ms": null,
      "signature": {
        "r": "0x5afc29701358e4082d744d4332915079664d27d0244565b94b7966adfd2776d9",
        "s": "0x57e2d718fa45c0c191dc0f0c1ad6e6e0fc3e026cdfc4148c3ae8b3b32fd02c8d",
        "v": 28
      }
    }
  ]
}

Each item has these fields, in this order:

Field	Meaning
`received_at`	When our Hyperliquid node received the transaction, as an RFC 3339 UTC string with nanosecond precision. It is not a block time.
`received_at_ms`	The same time in Unix milliseconds.
`symbols`	The markets the action’s asset ids reference, in the canonical spelling, in first-seen order and without repeats. `[]` for an action with no market, such as a transfer, `noop`, `scheduleCancel` or a validator action.
`action`	The action exactly as it was signed, in Hyperliquid’s exchange-action format: markets are asset ids (`a` or `asset`), not symbols, and prices and sizes are strings (`p`, `s`).
`nonce`	The action’s nonce, an integer.
`vault_address`	The vault or subaccount the action acts for, or `null`.
`expires_after_ms`	The action’s `expiresAfter` time in Unix milliseconds, or `null`.
`signature`	The action’s signature, as `r`, `s` and `v`.

action and signature are passed through byte for byte. The signer’s address is not included; you can recover it from the signed fields (action, nonce, vault_address, expires_after_ms) and signature with Hyperliquid’s signing scheme. action.type names the action. Common types are order, cancel, cancelByCloid, modify, batchModify, scheduleCancel, twapOrder, twapCancel, updateLeverage, updateIsolatedMargin, noop, evmRawTx, and transfers such as usdSend, spotSend, usdClassTransfer and sendAsset. Hyperliquid adds types over time, so pass over a type you do not recognize instead of failing on it. The same signed action can occasionally arrive twice. Deduplicate on signature when you count or store actions.

Volume and limits

The unfiltered stream carries every pending transaction our Hyperliquid node receives, several megabytes per second before compression. Use a client that negotiates permessage-deflate compression, as most WebSocket libraries do by default, and subscribe with a symbol where the job allows it.

Unfiltered capacity: unfiltered subscriptions are limited across the service. When they are full, a subscribe without symbol returns error_code rate_limited with The unfiltered mempool stream is at capacity. Subscribe with a symbol, or try again later. Symbol subscriptions are not limited this way.
Slow consumers: as on any channel, a connection that reads too slowly is closed after an error with error_code slow_consumer. Read each message off the socket promptly and do heavy work elsewhere.
Plan limits: the unfiltered stream and each symbol count as one subscription toward your plan’s limit per connection, and a connection accepts at most 10 subscribe or unsubscribe operations per second. See WebSocket limits.
Credits: each data message is billed like any other WebSocket message; see Credits. The unfiltered stream sends many messages, so check its usage in the dashboard after a short run.

Errors

Errors arrive as error messages with a stable error_code. The connection stays open after each of these except slow_consumer.

`error_code`	Cause and next step
`forbidden`	Your plan does not include `mempool`. Move to Pro, Scale or Enterprise on the pricing page.
`endpoint_unsupported`	You subscribed on `wss://api.0xarchive.io/ws`. Connect to `wss://stream.0xarchive.io/ws` and subscribe there.
`invalid_symbol`	The symbol is not a Hyperliquid market. Check its spelling for the product family.
`rate_limited`	The unfiltered stream is at capacity, or the connection reached its subscription or operation limit. Subscribe with a symbol, unsubscribe from something, or slow down.
`upstream_unavailable`	`The mempool channel is temporarily unavailable. Please try again shortly.` Retry with capped backoff.
`slow_consumer`	The connection fell behind and is closed. Reconnect, subscribe to less, and read faster.

The channel has no replay: a replay command for mempool returns an error. Errors lists every code.

Next step

Size subscriptions and consumers for the stream with WebSocket limits.

Connect

Channels and modes

Replay and backtesting

Message reference

Endpoint and plans

Run a first subscription

Data messages

Volume and limits

Errors

Next step

​Endpoint and plans

​Subscribe

​Run a first subscription

​Data messages

​Volume and limits

​Errors

​Next step

Endpoint and plans

Subscribe

Run a first subscription

Data messages

Volume and limits

Errors

Next step