> ## 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.

# l2BookDiffSnapshot | Hyperliquid Info API

> Hyperliquid l2BookDiffSnapshot: fetch a full-depth L2 order book snapshot for one coin, carrying the height, epoch, and per-coin seq needed to bootstrap and align the l2BookDiff2 diff stream.

<CardGroup cols={1}>
  <Card title="Processing"> Realtime</Card>
</CardGroup>

The Hyperliquid info endpoint with `type: "l2BookDiffSnapshot"` is used to fetch a full-depth L2 order book snapshot for one coin, carrying the `height`, `epoch`, and per-coin `seq` needed to bootstrap and align the [`l2BookDiff2`](/docs/api-reference/hyperliquid-websocket/l2-book-diff2) diff stream.

<Info>
  * GoldRush-native. `l2BookDiffSnapshot` is not a `POST api.hyperliquid.xyz/info` method - it is served only by the GoldRush endpoint.
  * **Bootstrap for [`l2BookDiff2`](/docs/api-reference/hyperliquid-websocket/l2-book-diff2).** That WebSocket stream is diff-only; this endpoint provides the initial book to seed from, plus the `height`/`epoch`/`seq` to align the diffs onto it.
  * **Full depth.** Unlike the 20-level [`l2Book`](/docs/api-reference/hyperliquid-info/l2-book) snapshot, this returns the complete resting book for the coin so your reconstruction starts from a complete state.
  * The snapshot already reflects every diff **up to and including** its own `height` (it is taken after that block is applied), so discard any diff at or below it.
</Info>

Returns a point-in-time, full-depth aggregated order book for one `coin` - two arrays of price levels (bids first, then asks), each carrying price, resting size, and order count - together with the `height`, `epoch`, and per-coin `seq` that tie the snapshot to the `l2BookDiff2` stream.

## Endpoint

```
POST https://hypercore.goldrushdata.com/info
Authorization: Bearer <GOLDRUSH_API_KEY>
Content-Type: application/json
```

## Request

<ParamField body="type" type="string" required default="l2BookDiffSnapshot">
  Always `"l2BookDiffSnapshot"`.
</ParamField>

<ParamField body="coin" type="string" required>
  The asset symbol, e.g. `"BTC"`. For HIP-3 markets use the deployer-prefixed form; for spot use the pair symbol or `@<index>`.
</ParamField>

### Example

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://hypercore.goldrushdata.com/info \
    -H "Authorization: Bearer $GOLDRUSH_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "type": "l2BookDiffSnapshot",
      "coin": "HYPE"
    }'
  ```

  ```typescript TypeScript theme={null}
  const response = await fetch("https://hypercore.goldrushdata.com/info", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.GOLDRUSH_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      type: "l2BookDiffSnapshot",
      coin: "HYPE",
    }),
  });

  const snap = await response.json();
  const { height, epoch, seq } = snap;
  const [bids, asks] = snap.levels;
  ```

  ```python Python theme={null}
  import os, requests

  response = requests.post(
      "https://hypercore.goldrushdata.com/info",
      headers={"Authorization": f"Bearer {os.environ['GOLDRUSH_API_KEY']}"},
      json={"type": "l2BookDiffSnapshot", "coin": "HYPE"},
  )

  snap = response.json()
  height, epoch, seq = snap["height"], snap["epoch"], snap["seq"]
  bids, asks = snap["levels"]
  ```
</CodeGroup>

## Response

A single JSON object. `levels` is a two-element array: element 0 is the bid side (descending price), element 1 is the ask side (ascending price). Each level is a `{px, sz, n}` object.

```json theme={null}
{
  "coin": "HYPE",
  "time": 1786379674524,
  "height": 1105178185,
  "epoch": "466bf60f-bb7a-4591-89a3-a2660234fef5",
  "seq": 3669031,
  "levels": [
    [
      { "px": "54.208", "sz": "153.23", "n": 6 },
      { "px": "54.204", "sz": "48.81", "n": 1 }
    ],
    [
      { "px": "54.214", "sz": "12.34", "n": 2 },
      { "px": "54.216", "sz": "80.71", "n": 3 }
    ]
  ]
}
```

### Field descriptions

<Note>
  `px` and `sz` are returned as **decimal strings**, preserving upstream precision. Do not parse them as floats.
</Note>

<ResponseField name="coin" type="string">The asset the book is for - echoes the request `coin`.</ResponseField>
<ResponseField name="time" type="int">Snapshot timestamp in milliseconds since Unix epoch.</ResponseField>
<ResponseField name="height" type="int">HyperCore block height the snapshot was taken at. Discard any `l2BookDiff2` batch whose `block_height` is ≤ this value.</ResponseField>
<ResponseField name="epoch" type="string">Server generation (UUID). Must match the `epoch` on the `l2BookDiff2` batches you apply; a different `epoch` means the stream reset and you should re-fetch.</ResponseField>
<ResponseField name="seq" type="int">The per-coin sequence this snapshot is aligned to. The first `l2BookDiff2` diff you apply for this coin should have `prev_seq == seq`.</ResponseField>

<ResponseField name="levels" type="array<array<object>>">
  Two-element array: `levels[0]` are bids (highest price first), `levels[1]` are asks (lowest price first). Full depth.

  <Expandable title="level properties">
    <ResponseField name="px" type="string">Price of the level.</ResponseField>
    <ResponseField name="sz" type="string">Total resting size at this price.</ResponseField>
    <ResponseField name="n" type="int">Number of individual orders aggregated into this level.</ResponseField>
  </Expandable>
</ResponseField>

## Bootstrapping the l2BookDiff2 stream

Use this snapshot to seed a local book, then keep it current with the [`l2BookDiff2`](/docs/api-reference/hyperliquid-websocket/l2-book-diff2) WebSocket stream:

1. Subscribe to `l2BookDiff2` for your coin(s) and start buffering `Updates`.
2. Fetch this snapshot; note `height`, `epoch`, and `seq`.
3. Drop any buffered batch whose `block_height` ≤ `height`.
4. Confirm each remaining batch's `epoch` equals this snapshot's `epoch` (else re-fetch).
5. Apply diffs in order - the first for the coin has `prev_seq == seq`.
6. Keep checking per-coin `prev_seq` continuity; on a gap or `epoch` change, re-fetch and re-bootstrap.

## Related endpoints

<CardGroup cols={2}>
  <Card title="l2BookDiff2" href="/docs/api-reference/hyperliquid-websocket/l2-book-diff2">The diff-only WebSocket stream this snapshot bootstraps.</Card>
  <Card title="l2Book" href="/docs/api-reference/hyperliquid-info/l2-book">20-level point-in-time L2 order book snapshot.</Card>
</CardGroup>