> ## Documentation Index
> Fetch the complete documentation index at: https://docs.beta.b3os.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Hyperliquid (read-only)

The io.b3os/hyperliquid pack: 10 actions with call snippets, fixture outputs, connection setup and error codes, generated from version 1.0.0.

`io.b3os/hyperliquid` 1.0.0 · `crypto`, `market-data`, `derivatives`, `hyperliquid` · MIT

Read-only data from the Hyperliquid perpetuals exchange through its public info API: markets and their parameters, mid prices, order books, candles, funding rates (with Binance and Bybit for comparison) and funding history, and any account's positions, margin, open orders, fills and transfers. Keyless; no trading, no signing. Hyperliquid rate-limits by IP and the node shares one IP, so poll gently.

Every call's result carries `upstream_status` and `timing`: `validate_ms`, `inject_ms`, `render_ms`, `upstream_ms`, `map_ms` and `total_ms`. `upstream` is the service's time; the others are B3OS's own ([call actions](/actions/call)). The snippets below show no timing values, because a fixture records none.

## Connection

No credential: a keyless public API. Calls name no connection.

Hosts it reaches: `api.hyperliquid.xyz`.

## Actions

| Action | Effect | MCP tool | Title |
|---|---|---|---|
| [`get-markets`](/actions/catalog/hyperliquid#hyperliquid-get-markets) | read | `hyperliquid__get-markets` | Hyperliquid Get Markets |
| [`get-mids`](/actions/catalog/hyperliquid#hyperliquid-get-mids) | read | `hyperliquid__get-mids` | Get mid prices |
| [`get-order-book`](/actions/catalog/hyperliquid#hyperliquid-get-order-book) | read | `hyperliquid__get-order-book` | Get order book |
| [`get-candles`](/actions/catalog/hyperliquid#hyperliquid-get-candles) | read | `hyperliquid__get-candles` | Get candles |
| [`get-funding-rates`](/actions/catalog/hyperliquid#hyperliquid-get-funding-rates) | read | `hyperliquid__get-funding-rates` | Hyperliquid Get Funding Rates |
| [`get-funding-history`](/actions/catalog/hyperliquid#hyperliquid-get-funding-history) | read | `hyperliquid__get-funding-history` | Get funding history |
| [`get-account`](/actions/catalog/hyperliquid#hyperliquid-get-account) | read | `hyperliquid__get-account` | Hyperliquid Get Account |
| [`get-open-orders`](/actions/catalog/hyperliquid#hyperliquid-get-open-orders) | read | `hyperliquid__get-open-orders` | Get open orders |
| [`get-fills`](/actions/catalog/hyperliquid#hyperliquid-get-fills) | read | `hyperliquid__get-fills` | Get fills |
| [`get-transfer-history`](/actions/catalog/hyperliquid#hyperliquid-get-transfer-history) | read | `hyperliquid__get-transfer-history` | Hyperliquid Get Transfer History |

get-markets

**Hyperliquid Get Markets.** Every perpetual market on Hyperliquid (or on a HIP-3 DEX) with its coin symbol, size decimals, maximum leverage and whether only isolated margin is allowed. Use the coin names with the other actions.

Ref `io.b3os/hyperliquid/get-markets@1.0.0` · effect `read` · no connection · MCP tool `hyperliquid__get-markets`

**curl**

```bash
    curl -s https://beta-api.b3os.org/v1/actions/call \
      -H "Authorization: Bearer $B3OS_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"ref": "io.b3os/hyperliquid/get-markets@1", "input": {}}'
    ```
  **TypeScript**

```ts
    import { B3OS } from "@b3os/sdk";

    const b3os = new B3OS();
    const result = await b3os.actions.call({ ref: "io.b3os/hyperliquid/get-markets@1", input: {} });
    console.log(result.output);
    ```
  **Python**

```python
    from b3os import B3OS

    b3os = B3OS()
    result = b3os.actions.call({"ref": "io.b3os/hyperliquid/get-markets@1", "input": {}})
    print(result["output"])
    ```
  **MCP**

```json
    {
      "method": "tools/call",
      "params": {"name": "hyperliquid__get-markets", "arguments": {}}
    }
    ```

    Expose the pack as tools with `--packs hyperliquid` on the local server or `?packs=hyperliquid` on the remote URL, and the agent calls `hyperliquid__get-markets` with the action's input. The tool needs no connection. Without exposing the pack, `actions_call` takes the same input with `ref`.

Output, labeled `fixture`: Hyperliquid Get Markets (response recorded 2026-10-26). From the bundle's `fixtures/get-markets.json`, not a live call.

```json
{
  "markets": [
    {
      "coin": "BTC",
      "szDecimals": 5,
      "maxLeverage": 40,
      "onlyIsolated": false,
      "dex": null
    },
    {
      "coin": "ETH",
      "szDecimals": 4,
      "maxLeverage": 25,
      "onlyIsolated": false,
      "dex": null
    },
    {
      "coin": "ATOM",
      "szDecimals": 2,
      "maxLeverage": 5,
      "onlyIsolated": false,
      "dex": null
    }
  ]
}
```

When the service answers with an error, the call fails with [`upstream_error`](/errors#upstream_error) and `pack_error.code` is one of:

| `pack_error.code` | Service status | Retryable | Message |
|---|---|---|---|
| `rate_limited` | 429 | yes | Hyperliquid rate limit reached (weight-based, per IP; the node shares one IP across callers). Retry shortly. |
| `invalid_request` | 400, 422 | no | Hyperliquid rejected the request; check the coin, address and times. |

get-mids

**Get mid prices.** Current mid price of every Hyperliquid market as a map from coin to price string (BTC, ETH, ...; spot pairs appear as @index and outcome sides as #index). One cheap call when you need many prices.

Ref `io.b3os/hyperliquid/get-mids@1.0.0` · effect `read` · no connection · MCP tool `hyperliquid__get-mids`

**curl**

```bash
    curl -s https://beta-api.b3os.org/v1/actions/call \
      -H "Authorization: Bearer $B3OS_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"ref": "io.b3os/hyperliquid/get-mids@1", "input": {}}'
    ```
  **TypeScript**

```ts
    import { B3OS } from "@b3os/sdk";

    const b3os = new B3OS();
    const result = await b3os.actions.call({ ref: "io.b3os/hyperliquid/get-mids@1", input: {} });
    console.log(result.output);
    ```
  **Python**

```python
    from b3os import B3OS

    b3os = B3OS()
    result = b3os.actions.call({"ref": "io.b3os/hyperliquid/get-mids@1", "input": {}})
    print(result["output"])
    ```
  **MCP**

```json
    {
      "method": "tools/call",
      "params": {"name": "hyperliquid__get-mids", "arguments": {}}
    }
    ```

    Expose the pack as tools with `--packs hyperliquid` on the local server or `?packs=hyperliquid` on the remote URL, and the agent calls `hyperliquid__get-mids` with the action's input. The tool needs no connection. Without exposing the pack, `actions_call` takes the same input with `ref`.

Output, labeled `fixture`: Get mid prices (response recorded 2026-10-26). From the bundle's `fixtures/get-mids.json`, not a live call.

```json
{
  "mids": {
    "#114910": "0.5",
    "#114911": "0.5",
    "#114920": "0.179575",
    "#114921": "0.820425",
    "#114930": "0.214425",
    "#114931": "0.785575",
    "#114940": "0.069435",
    "#114941": "0.930565",
    "#114950": "0.104765",
    "#114951": "0.895235",
    "#114960": "0.079755",
    "#114961": "0.920245",
    "#114970": "0.06479",
    "#114971": "0.93521",
    "#114980": "0.025075",
    "#114981": "0.974925",
    "#114990": "0.01432",
    "#114991": "0.98568",
    "#143530": "0.01172",
    "#143531": "0.98828",
    "#143540": "0.501275",
    "#143541": "0.498725",
    "#143550": "0.49997",
    "#143551": "0.50003",
    "#143560": "0.379025",
    "#143561": "0.620975",
    "#143610": "0.49997",
    "#143611": "0.50003",
    "#143620": "0.49997",
    "#143621": "0.50003",
    "#143630": "0.49846",
    "#143631": "0.50154",
    "#143640": "0.524665",
    "#143641": "0.475335",
    "#143650": "0.50003",
    "#143651": "0.49997",
    "#143660": "0.50006",
    "#143661": "0.49994",
```

The first 40 of 1402 lines; the fixture file has the rest.

When the service answers with an error, the call fails with [`upstream_error`](/errors#upstream_error) and `pack_error.code` is one of:

| `pack_error.code` | Service status | Retryable | Message |
|---|---|---|---|
| `rate_limited` | 429 | yes | Hyperliquid rate limit reached (weight-based, per IP; the node shares one IP across callers). Retry shortly. |
| `invalid_request` | 400, 422 | no | Hyperliquid rejected the request; check the coin, address and times. |

get-order-book

**Get order book.** Level-2 order book of one market: up to 20 bid and ask levels with price, size and order count, best levels first. Optionally aggregate prices to 2 to 5 significant figures for a coarser view.

Ref `io.b3os/hyperliquid/get-order-book@1.0.0` · effect `read` · no connection · MCP tool `hyperliquid__get-order-book`

**curl**

```bash
    curl -s https://beta-api.b3os.org/v1/actions/call \
      -H "Authorization: Bearer $B3OS_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
          "ref": "io.b3os/hyperliquid/get-order-book@1",
          "input": {"coin": "BTC", "sig_figs": 5}
        }'
    ```
  **TypeScript**

```ts
    import { B3OS } from "@b3os/sdk";

    const b3os = new B3OS();
    const result = await b3os.actions.call({
      ref: "io.b3os/hyperliquid/get-order-book@1",
      input: { coin: "BTC", sig_figs: 5 },
    });
    console.log(result.output);
    ```
  **Python**

```python
    from b3os import B3OS

    b3os = B3OS()
    result = b3os.actions.call({
        "ref": "io.b3os/hyperliquid/get-order-book@1",
        "input": {"coin": "BTC", "sig_figs": 5},
    })
    print(result["output"])
    ```
  **MCP**

```json
    {
      "method": "tools/call",
      "params": {
        "name": "hyperliquid__get-order-book",
        "arguments": {"coin": "BTC", "sig_figs": 5}
      }
    }
    ```

    Expose the pack as tools with `--packs hyperliquid` on the local server or `?packs=hyperliquid` on the remote URL, and the agent calls `hyperliquid__get-order-book` with the action's input. The tool needs no connection. Without exposing the pack, `actions_call` takes the same input with `ref`.

Output, labeled `fixture`: Get order book (response recorded 2026-10-26). From the bundle's `fixtures/get-order-book.json`, not a live call.

```json
{
  "coin": "BTC",
  "time": 1793000615574,
  "bids": [
    {"price": "80114.0", "size": "10.53497", "orders": 32},
    {"price": "80113.0", "size": "0.82918", "orders": 4},
    {"price": "80112.0", "size": "3.39915", "orders": 6}
  ],
  "asks": [
    {"price": "80115.0", "size": "1.59109", "orders": 10},
    {"price": "80116.0", "size": "0.00017", "orders": 1},
    {"price": "80117.0", "size": "0.22682", "orders": 3}
  ]
}
```

When the service answers with an error, the call fails with [`upstream_error`](/errors#upstream_error) and `pack_error.code` is one of:

| `pack_error.code` | Service status | Retryable | Message |
|---|---|---|---|
| `rate_limited` | 429 | yes | Hyperliquid rate limit reached (weight-based, per IP; the node shares one IP across callers). Retry shortly. |
| `invalid_request` | 400, 422 | no | Hyperliquid rejected the request; check the coin, address and times. |

get-candles

**Get candles.** OHLCV candles for one market between two times, at 1m, 5m, 15m, 1h, 4h, 1d or 1w: open, high, low and close prices, volume in coins and trade count. Hyperliquid serves at most the 5,000 most recent candles of an interval.

Ref `io.b3os/hyperliquid/get-candles@1.0.0` · effect `read` · no connection · MCP tool `hyperliquid__get-candles`

**curl**

```bash
    curl -s https://beta-api.b3os.org/v1/actions/call \
      -H "Authorization: Bearer $B3OS_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
          "ref": "io.b3os/hyperliquid/get-candles@1",
          "input": {
            "coin": "ETH",
            "interval": "1d",
            "start_time": 1792700000000,
            "end_time": 1792990000000
          }
        }'
    ```
  **TypeScript**

```ts
    import { B3OS } from "@b3os/sdk";

    const b3os = new B3OS();
    const result = await b3os.actions.call({
      ref: "io.b3os/hyperliquid/get-candles@1",
      input: {
        coin: "ETH",
        interval: "1d",
        start_time: 1792700000000,
        end_time: 1792990000000,
      },
    });
    console.log(result.output);
    ```
  **Python**

```python
    from b3os import B3OS

    b3os = B3OS()
    result = b3os.actions.call({
        "ref": "io.b3os/hyperliquid/get-candles@1",
        "input": {
            "coin": "ETH",
            "interval": "1d",
            "start_time": 1792700000000,
            "end_time": 1792990000000,
        },
    })
    print(result["output"])
    ```
  **MCP**

```json
    {
      "method": "tools/call",
      "params": {
        "name": "hyperliquid__get-candles",
        "arguments": {
          "coin": "ETH",
          "interval": "1d",
          "start_time": 1792700000000,
          "end_time": 1792990000000
        }
      }
    }
    ```

    Expose the pack as tools with `--packs hyperliquid` on the local server or `?packs=hyperliquid` on the remote URL, and the agent calls `hyperliquid__get-candles` with the action's input. The tool needs no connection. Without exposing the pack, `actions_call` takes the same input with `ref`.

Output, labeled `fixture`: Get candles (response recorded 2026-10-26). From the bundle's `fixtures/get-candles.json`, not a live call.

```json
{
  "candles": [
    {
      "open_time": 1792627200000,
      "close_time": 1792713599999,
      "open": "2473.1",
      "high": "2481.8",
      "low": "2359.1",
      "close": "2388.1",
      "volume": "410759.0288",
      "trades": 145183
    },
    {
      "open_time": 1792713600000,
      "close_time": 1792799999999,
      "open": "2388.2",
      "high": "2416.7",
      "low": "2349.4",
      "close": "2386.5",
      "volume": "247739.012",
      "trades": 116739
    },
    {
      "open_time": 1792800000000,
      "close_time": 1792886399999,
      "open": "2386.5",
      "high": "2389.4",
      "low": "2281.5",
      "close": "2358.2",
      "volume": "373769.5544",
      "trades": 135072
    }
  ]
}
```

When the service answers with an error, the call fails with [`upstream_error`](/errors#upstream_error) and `pack_error.code` is one of:

| `pack_error.code` | Service status | Retryable | Message |
|---|---|---|---|
| `rate_limited` | 429 | yes | Hyperliquid rate limit reached (weight-based, per IP; the node shares one IP across callers). Retry shortly. |
| `invalid_request` | 400, 422 | no | Hyperliquid rejected the request; check the coin, address and times. |

get-funding-rates

**Hyperliquid Get Funding Rates.** Predicted next funding rate of every Hyperliquid perp (or one coin), with Binance and Bybit predictions for the same coin when they list it. Rates are per funding interval (Hyperliquid pays hourly); annualizedRate is the Hyperliquid rate times the intervals in a year.

Ref `io.b3os/hyperliquid/get-funding-rates@1.0.0` · effect `read` · no connection · MCP tool `hyperliquid__get-funding-rates`

**curl**

```bash
    curl -s https://beta-api.b3os.org/v1/actions/call \
      -H "Authorization: Bearer $B3OS_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
          "ref": "io.b3os/hyperliquid/get-funding-rates@1",
          "input": {"coin": "2Z"}
        }'
    ```
  **TypeScript**

```ts
    import { B3OS } from "@b3os/sdk";

    const b3os = new B3OS();
    const result = await b3os.actions.call({
      ref: "io.b3os/hyperliquid/get-funding-rates@1",
      input: { coin: "2Z" },
    });
    console.log(result.output);
    ```
  **Python**

```python
    from b3os import B3OS

    b3os = B3OS()
    result = b3os.actions.call({
        "ref": "io.b3os/hyperliquid/get-funding-rates@1",
        "input": {"coin": "2Z"},
    })
    print(result["output"])
    ```
  **MCP**

```json
    {
      "method": "tools/call",
      "params": {
        "name": "hyperliquid__get-funding-rates",
        "arguments": {"coin": "2Z"}
      }
    }
    ```

    Expose the pack as tools with `--packs hyperliquid` on the local server or `?packs=hyperliquid` on the remote URL, and the agent calls `hyperliquid__get-funding-rates` with the action's input. The tool needs no connection. Without exposing the pack, `actions_call` takes the same input with `ref`.

Output, labeled `fixture`: Hyperliquid Get Funding Rates (response recorded 2026-10-26). From the bundle's `fixtures/get-funding-rates.json`, not a live call.

```json
{
  "fundingRates": [
    {
      "coin": "2Z",
      "fundingRate": 0.0000125,
      "intervalHours": 1,
      "annualizedRate": 0.1095,
      "nextFundingTime": 1792998000000,
      "binanceRate": 0.00005,
      "bybitRate": 0.00005
    }
  ]
}
```

When the service answers with an error, the call fails with [`upstream_error`](/errors#upstream_error) and `pack_error.code` is one of:

| `pack_error.code` | Service status | Retryable | Message |
|---|---|---|---|
| `rate_limited` | 429 | yes | Hyperliquid rate limit reached (weight-based, per IP; the node shares one IP across callers). Retry shortly. |
| `invalid_request` | 400, 422 | no | Hyperliquid rejected the request; check the coin, address and times. |

get-funding-history

**Get funding history.** Hourly funding payments of one Hyperliquid perp since a start time: rate per hour and premium at each payment. Hyperliquid returns at most 500 points per call; page by passing the last time plus one as start_time.

Ref `io.b3os/hyperliquid/get-funding-history@1.0.0` · effect `read` · no connection · MCP tool `hyperliquid__get-funding-history`

**curl**

```bash
    curl -s https://beta-api.b3os.org/v1/actions/call \
      -H "Authorization: Bearer $B3OS_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
          "ref": "io.b3os/hyperliquid/get-funding-history@1",
          "input": {
            "coin": "ETH",
            "start_time": 1792900000000,
            "end_time": 1792910000000
          }
        }'
    ```
  **TypeScript**

```ts
    import { B3OS } from "@b3os/sdk";

    const b3os = new B3OS();
    const result = await b3os.actions.call({
      ref: "io.b3os/hyperliquid/get-funding-history@1",
      input: { coin: "ETH", start_time: 1792900000000, end_time: 1792910000000 },
    });
    console.log(result.output);
    ```
  **Python**

```python
    from b3os import B3OS

    b3os = B3OS()
    result = b3os.actions.call({
        "ref": "io.b3os/hyperliquid/get-funding-history@1",
        "input": {
            "coin": "ETH",
            "start_time": 1792900000000,
            "end_time": 1792910000000,
        },
    })
    print(result["output"])
    ```
  **MCP**

```json
    {
      "method": "tools/call",
      "params": {
        "name": "hyperliquid__get-funding-history",
        "arguments": {
          "coin": "ETH",
          "start_time": 1792900000000,
          "end_time": 1792910000000
        }
      }
    }
    ```

    Expose the pack as tools with `--packs hyperliquid` on the local server or `?packs=hyperliquid` on the remote URL, and the agent calls `hyperliquid__get-funding-history` with the action's input. The tool needs no connection. Without exposing the pack, `actions_call` takes the same input with `ref`.

Output, labeled `fixture`: Get funding history (response recorded 2026-10-26). From the bundle's `fixtures/get-funding-history.json`, not a live call.

```json
{
  "history": [
    {
      "time": 1792900800022,
      "funding_rate": "0.0000125",
      "premium": "-0.0003069994"
    },
    {
      "time": 1792904400016,
      "funding_rate": "0.0000125",
      "premium": "-0.0003084392"
    },
    {
      "time": 1792908000030,
      "funding_rate": "0.0000125",
      "premium": "-0.0002612955"
    }
  ]
}
```

When the service answers with an error, the call fails with [`upstream_error`](/errors#upstream_error) and `pack_error.code` is one of:

| `pack_error.code` | Service status | Retryable | Message |
|---|---|---|---|
| `rate_limited` | 429 | yes | Hyperliquid rate limit reached (weight-based, per IP; the node shares one IP across callers). Retry shortly. |
| `invalid_request` | 400, 422 | no | Hyperliquid rejected the request; check the coin, address and times. |

get-account

**Hyperliquid Get Account.** An account's perpetuals state: account value, margin used, total position notional, withdrawable balance, and every open position with size (negative for shorts), entry price, value, unrealized PnL, return on equity, leverage, liquidation price and funding since open. Open orders are in get-open-orders.

Ref `io.b3os/hyperliquid/get-account@1.0.0` · effect `read` · no connection · MCP tool `hyperliquid__get-account`

**curl**

```bash
    curl -s https://beta-api.b3os.org/v1/actions/call \
      -H "Authorization: Bearer $B3OS_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
          "ref": "io.b3os/hyperliquid/get-account@1",
          "input": {"address": "0xdfc24b077bc1425ad1dea75bcb6f8158e10df303"}
        }'
    ```
  **TypeScript**

```ts
    import { B3OS } from "@b3os/sdk";

    const b3os = new B3OS();
    const result = await b3os.actions.call({
      ref: "io.b3os/hyperliquid/get-account@1",
      input: { address: "0xdfc24b077bc1425ad1dea75bcb6f8158e10df303" },
    });
    console.log(result.output);
    ```
  **Python**

```python
    from b3os import B3OS

    b3os = B3OS()
    result = b3os.actions.call({
        "ref": "io.b3os/hyperliquid/get-account@1",
        "input": {"address": "0xdfc24b077bc1425ad1dea75bcb6f8158e10df303"},
    })
    print(result["output"])
    ```
  **MCP**

```json
    {
      "method": "tools/call",
      "params": {
        "name": "hyperliquid__get-account",
        "arguments": {"address": "0xdfc24b077bc1425ad1dea75bcb6f8158e10df303"}
      }
    }
    ```

    Expose the pack as tools with `--packs hyperliquid` on the local server or `?packs=hyperliquid` on the remote URL, and the agent calls `hyperliquid__get-account` with the action's input. The tool needs no connection. Without exposing the pack, `actions_call` takes the same input with `ref`.

Output, labeled `fixture`: Hyperliquid Get Account (response recorded 2026-10-26). From the bundle's `fixtures/get-account.json`, not a live call.

```json
{
  "accountValue": "34244238.2164419964",
  "totalMarginUsed": "477.867397",
  "totalPositionValue": "0.0",
  "withdrawable": "34243760.349045001",
  "positions": [],
  "time": 1793000618774
}
```

When the service answers with an error, the call fails with [`upstream_error`](/errors#upstream_error) and `pack_error.code` is one of:

| `pack_error.code` | Service status | Retryable | Message |
|---|---|---|---|
| `rate_limited` | 429 | yes | Hyperliquid rate limit reached (weight-based, per IP; the node shares one IP across callers). Retry shortly. |
| `invalid_request` | 400, 422 | no | Hyperliquid rejected the request; check the coin, address and times. |

get-open-orders

**Get open orders.** An account's resting orders: coin, side, limit price, remaining and original size, order id and placement time.

Ref `io.b3os/hyperliquid/get-open-orders@1.0.0` · effect `read` · no connection · MCP tool `hyperliquid__get-open-orders`

**curl**

```bash
    curl -s https://beta-api.b3os.org/v1/actions/call \
      -H "Authorization: Bearer $B3OS_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
          "ref": "io.b3os/hyperliquid/get-open-orders@1",
          "input": {"address": "0x0000000000000000000000000000000000000001"}
        }'
    ```
  **TypeScript**

```ts
    import { B3OS } from "@b3os/sdk";

    const b3os = new B3OS();
    const result = await b3os.actions.call({
      ref: "io.b3os/hyperliquid/get-open-orders@1",
      input: { address: "0x0000000000000000000000000000000000000001" },
    });
    console.log(result.output);
    ```
  **Python**

```python
    from b3os import B3OS

    b3os = B3OS()
    result = b3os.actions.call({
        "ref": "io.b3os/hyperliquid/get-open-orders@1",
        "input": {"address": "0x0000000000000000000000000000000000000001"},
    })
    print(result["output"])
    ```
  **MCP**

```json
    {
      "method": "tools/call",
      "params": {
        "name": "hyperliquid__get-open-orders",
        "arguments": {"address": "0x0000000000000000000000000000000000000001"}
      }
    }
    ```

    Expose the pack as tools with `--packs hyperliquid` on the local server or `?packs=hyperliquid` on the remote URL, and the agent calls `hyperliquid__get-open-orders` with the action's input. The tool needs no connection. Without exposing the pack, `actions_call` takes the same input with `ref`.

Output, labeled `fixture`: One resting sell order (documented response shape, example values). From the bundle's `fixtures/get-open-orders.json`, not a live call.

```json
{
  "orders": [
    {
      "coin": "BTC",
      "side": "sell",
      "price": "29792.0",
      "size": "0.0",
      "original_size": "5.0",
      "order_id": 91490942,
      "timestamp": 1681247412573
    }
  ]
}
```

When the service answers with an error, the call fails with [`upstream_error`](/errors#upstream_error) and `pack_error.code` is one of:

| `pack_error.code` | Service status | Retryable | Message |
|---|---|---|---|
| `rate_limited` | 429 | yes | Hyperliquid rate limit reached (weight-based, per IP; the node shares one IP across callers). Retry shortly. |
| `invalid_request` | 400, 422 | no | Hyperliquid rejected the request; check the coin, address and times. |

get-fills

**Get fills.** An account's trade fills, newest first: coin, side, price, size, direction (Open Long, Close Short, ...), closed PnL, fee and transaction hash. Without start_time you get the most recent fills (Hyperliquid caps this at 2,000); with start_time, the fills in that window.

Ref `io.b3os/hyperliquid/get-fills@1.0.0` · effect `read` · no connection · MCP tool `hyperliquid__get-fills`

**curl**

```bash
    curl -s https://beta-api.b3os.org/v1/actions/call \
      -H "Authorization: Bearer $B3OS_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
          "ref": "io.b3os/hyperliquid/get-fills@1",
          "input": {"address": "0x0000000000000000000000000000000000000001"}
        }'
    ```
  **TypeScript**

```ts
    import { B3OS } from "@b3os/sdk";

    const b3os = new B3OS();
    const result = await b3os.actions.call({
      ref: "io.b3os/hyperliquid/get-fills@1",
      input: { address: "0x0000000000000000000000000000000000000001" },
    });
    console.log(result.output);
    ```
  **Python**

```python
    from b3os import B3OS

    b3os = B3OS()
    result = b3os.actions.call({
        "ref": "io.b3os/hyperliquid/get-fills@1",
        "input": {"address": "0x0000000000000000000000000000000000000001"},
    })
    print(result["output"])
    ```
  **MCP**

```json
    {
      "method": "tools/call",
      "params": {
        "name": "hyperliquid__get-fills",
        "arguments": {"address": "0x0000000000000000000000000000000000000001"}
      }
    }
    ```

    Expose the pack as tools with `--packs hyperliquid` on the local server or `?packs=hyperliquid` on the remote URL, and the agent calls `hyperliquid__get-fills` with the action's input. The tool needs no connection. Without exposing the pack, `actions_call` takes the same input with `ref`.

Output, labeled `fixture`: One opening buy fill (documented response shape, example values). From the bundle's `fixtures/get-fills.json`, not a live call.

```json
{
  "fills": [
    {
      "coin": "AVAX",
      "side": "buy",
      "price": "18.435",
      "size": "93.53",
      "direction": "Open Long",
      "closed_pnl": "0.0",
      "fee": "0.01",
      "fee_token": "USDC",
      "time": 1681222254710,
      "hash": "0xa166e3fa63c25663024b03f2e0da011a00307e4017465df020210d3d432e7cb8",
      "order_id": 90542681
    }
  ]
}
```

When the service answers with an error, the call fails with [`upstream_error`](/errors#upstream_error) and `pack_error.code` is one of:

| `pack_error.code` | Service status | Retryable | Message |
|---|---|---|---|
| `rate_limited` | 429 | yes | Hyperliquid rate limit reached (weight-based, per IP; the node shares one IP across callers). Retry shortly. |
| `invalid_request` | 400, 422 | no | Hyperliquid rejected the request; check the coin, address and times. |

get-transfer-history

**Hyperliquid Get Transfer History.** An account's ledger updates other than funding since a start time: deposits, withdrawals, USDC sends, spot transfers, vault deposits and withdrawals, liquidations and rewards. Each entry has the time, transaction hash, type and the type's details (amounts, counterparties).

Ref `io.b3os/hyperliquid/get-transfer-history@1.0.0` · effect `read` · no connection · MCP tool `hyperliquid__get-transfer-history`

**curl**

```bash
    curl -s https://beta-api.b3os.org/v1/actions/call \
      -H "Authorization: Bearer $B3OS_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
          "ref": "io.b3os/hyperliquid/get-transfer-history@1",
          "input": {
            "address": "0xdfc24b077bc1425ad1dea75bcb6f8158e10df303",
            "startTime": 1790000000000,
            "endTime": 1790001000000
          }
        }'
    ```
  **TypeScript**

```ts
    import { B3OS } from "@b3os/sdk";

    const b3os = new B3OS();
    const result = await b3os.actions.call({
      ref: "io.b3os/hyperliquid/get-transfer-history@1",
      input: {
        address: "0xdfc24b077bc1425ad1dea75bcb6f8158e10df303",
        startTime: 1790000000000,
        endTime: 1790001000000,
      },
    });
    console.log(result.output);
    ```
  **Python**

```python
    from b3os import B3OS

    b3os = B3OS()
    result = b3os.actions.call({
        "ref": "io.b3os/hyperliquid/get-transfer-history@1",
        "input": {
            "address": "0xdfc24b077bc1425ad1dea75bcb6f8158e10df303",
            "startTime": 1790000000000,
            "endTime": 1790001000000,
        },
    })
    print(result["output"])
    ```
  **MCP**

```json
    {
      "method": "tools/call",
      "params": {
        "name": "hyperliquid__get-transfer-history",
        "arguments": {
          "address": "0xdfc24b077bc1425ad1dea75bcb6f8158e10df303",
          "startTime": 1790000000000,
          "endTime": 1790001000000
        }
      }
    }
    ```

    Expose the pack as tools with `--packs hyperliquid` on the local server or `?packs=hyperliquid` on the remote URL, and the agent calls `hyperliquid__get-transfer-history` with the action's input. The tool needs no connection. Without exposing the pack, `actions_call` takes the same input with `ref`.

Output, labeled `fixture`: Hyperliquid Get Transfer History (response recorded 2026-10-26). From the bundle's `fixtures/get-transfer-history.json`, not a live call.

```json
{
  "transfers": [
    {
      "time": 1790000239150,
      "hash": "0x8b96711daa7a1c4e8d100444e4d5f1020ca20003457d3b202f5f1c70697df639",
      "type": "vaultWithdraw",
      "delta": {
        "type": "vaultWithdraw",
        "vault": "0xdfc24b077bc1425ad1dea75bcb6f8158e10df303",
        "user": "0xa607c6b3c52521743d84f6622b805b5764a77785",
        "requestedUsd": "10030.692954",
        "commission": "0.0",
        "closingCost": "0.0",
        "basis": "9999.999999",
        "netWithdrawnUsd": "10030.692954"
      }
    },
    {
      "time": 1790000489139,
      "hash": "0x8d44bc6ecabf2d3a8ebe0444e4e3760204ed005465b24c0c310d67c189b30725",
      "type": "vaultDeposit",
      "delta": {
        "type": "vaultDeposit",
        "vault": "0xdfc24b077bc1425ad1dea75bcb6f8158e10df303",
        "usdc": "100.0"
      }
    }
  ]
}
```

When the service answers with an error, the call fails with [`upstream_error`](/errors#upstream_error) and `pack_error.code` is one of:

| `pack_error.code` | Service status | Retryable | Message |
|---|---|---|---|
| `rate_limited` | 429 | yes | Hyperliquid rate limit reached (weight-based, per IP; the node shares one IP across callers). Retry shortly. |
| `invalid_request` | 400, 422 | no | Hyperliquid rejected the request; check the coin, address and times. |