# Hyperliquid Perp & Spot Markets: Price, Funding, Open Interest (`yadroo/hyperliquid-markets`) Actor

One row per Hyperliquid market from the exchange's public info API: mark, mid and oracle price, 24h volume, open interest in USD, hourly funding and its yearly rate, spot pairs with readable names. Two extra modes give an order-book snapshot with USD depth and past funding samples per coin.

- **URL**: https://apify.com/yadroo/hyperliquid-markets.md
- **Developed by:** [Samat Makatov](https://apify.com/yadroo) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 market row returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Hyperliquid Perp & Spot Markets: Price, Funding, Open Interest

Market data from Hyperliquid as flat rows: every perpetual contract with mark, mid and oracle price, 24h volume, open interest in USD, the hourly funding rate and the same rate per year — and every spot pair with a readable name (`HYPE/USDC`), supply and market cap. Two extra modes answer the questions a price table cannot: an order-book snapshot with the spread in basis points and the USD resting near the mid, and the funding settlements of a contract hour by hour.

No API key, no wallet, no proxy, no browser: the actor reads the exchange's own public info endpoint. It never touches trader, position, vault or leaderboard data — this is a market-data actor only.

### Use cases

- **Venue screener** — the busiest contracts right now: `mode=markets`, `sortBy=dayVolumeUsd`, `maxItems=25`, straight into a dashboard or a daily note.
- **Funding carry / basis desk** — `sortBy=fundingApr` with `minDayVolumeUsd` to skip thin listings, and `includePredictedFunding=true` to see the rate other perp venues are about to charge for the same coin in the same row.
- **Watchlist refresh** — `coins=["BTC","ETH","SOL"]` on a schedule: three rows with price, 24h change and open interest for an alert rule or a spreadsheet.
- **Spot token research** — `marketType=spot` gives pair names rebuilt from the token table, price, volume, circulating supply and market cap for tokens that trade here before they show up elsewhere.
- **Sizing and slippage checks** — `mode=orderBook` returns best bid and ask, the spread in bps and how many USD sit within a chosen band of the mid, plus the raw levels for your own slippage curve.
- **Funding series for a backtest** — `mode=fundingHistory` with `sinceHours=720` collects a month of hourly settlements per coin, with the rate as paid and the premium over the oracle price.
- **One tool call for an agent** — `marketType=both` plus `fields` returns a compact snapshot of the whole venue in a single run.

### Input

Every field is optional. `coins` is prefilled with three majors (a prefill, not a default: clear it and `markets` mode returns the whole table).

| Field | Type | Default | Allowed values / notes |
|---|---|---|---|
| `mode` | string | `markets` | `markets`, `orderBook`, `fundingHistory` — see [Modes](#modes). |
| `marketType` | string | `perp` | `perp`, `spot`, `both`. `markets` mode only; the other two modes read perpetuals. |
| `coins` | string\[] | prefill `["BTC","ETH","HYPE"]` | Base symbols as the exchange writes them (`BTC`, `HYPE`, `SOL`). Case is ignored, a leading `$` is dropped, obvious typos are corrected (`hpye` → `HYPE`). Empty = every market, in `markets` mode only; **required** in `orderBook` and `fundingHistory`. Spot rows also match on the pair (`HYPE/USDC`) or its handle (`@107`). |
| `minDayVolumeUsd` | integer | — | Drop markets that traded less than this in the last 24 hours. `markets` mode only. |
| `includePredictedFunding` | boolean | `false` | One extra call: adds `predictedFundingHl`, `predictedFundingBinance`, `predictedFundingBybit`, `nextFundingTime` and `fundingIntervalHours` to perpetual rows. |
| `includeDelisted` | boolean | `false` | The exchange keeps delisted contracts in its table with a frozen price and no volume; they are skipped unless you ask for them (`isDelisted` marks them). |
| `sortBy` | string | `dayVolumeUsd` | `dayVolumeUsd`, `openInterestUsd`, `fundingApr`, `dayChangePct`, `marketCapUsd`, `symbol` — see [Sort keys](#sort-keys). |
| `sortDesc` | boolean | `true` | `false` = smallest first (e.g. the most negative funding). |
| `bookDepth` | integer | `10` | 1–20 price levels per side kept in `bids`/`asks`; the summary numbers are computed from the levels kept. `orderBook` mode. |
| `depthUsdWindowPct` | number | `0.5` | 0.01–10. Half-width of the band behind `bidDepthUsd`/`askDepthUsd`: `0.5` = half a percent below and above the mid. `orderBook` mode. |
| `sinceHours` | integer | `24` | 1–2160 hours back from the start of the run, in UTC. `fundingHistory` mode. |
| `maxItems` | integer | `50` | 1–5000 dataset rows, applied after sorting. |
| `fields` | string\[] | all | Keep only these fields, in this order. `symbol`, `coin`, `marketType` and `fetchedAt` are always kept. |

### Reference

#### Modes

| `mode` | Calls to the source | One row is | Uses |
|---|---|---|---|
| `markets` | 1 (perp), 1 (spot) or 2 (`both`), +1 with `includePredictedFunding` | one perpetual contract or one spot pair | `marketType`, `coins`, `minDayVolumeUsd`, `includeDelisted`, `sortBy`, `sortDesc` |
| `orderBook` | 1 + 1 per coin | one coin: top of book, spread, depth, raw levels | `coins`, `bookDepth`, `depthUsdWindowPct` |
| `fundingHistory` | 1 + 1 per coin per 480 hours of window | one funding settlement of one coin | `coins`, `sinceHours` |

#### The symbol dictionary

Perpetual listings change every few weeks, so the actor ships no symbol list: run `markets` with an empty `coins` list and `sortBy=symbol` to get the current one (≈ 230 perpetuals and ≈ 330 spot pairs in September 2026). A symbol the exchange does not list and that cannot be read as a typo comes back as one row with `found: false` and a note — never as a silently empty run.

#### Spot pair names

Only a handful of spot pairs carry a readable name upstream; the rest are internal handles like `@107`. The actor resolves the pair's two token indexes through the exchange's token table and builds `symbol` = `BASE/QUOTE` (`HYPE/USDC`), keeping the raw handle in `pairId` (that is also what the market link uses). `isCanonical` mirrors the exchange's own flag for the pair.

#### Funding math

`fundingHourly` is the rate as the exchange publishes it: a fraction charged once an hour (`0.0000125` = 0.00125 % per hour). `fundingApr = fundingHourly × 24 × 365 × 100`, i.e. percent per year (`0.0000125` → `10.95`). Positive means longs pay shorts. `premium` is the contract's premium over the oracle price, the input to the next rate.

#### Sort keys

`dayVolumeUsd` (notional traded in 24h), `openInterestUsd` (perps), `fundingApr` (perps; combine with `sortDesc=false` to find where shorts pay longs), `dayChangePct`, `marketCapUsd` (spot), `symbol` (alphabetical). Rows without the value always go last, in both directions.

### Examples

**Busiest perpetuals right now**

```json
{ "mode": "markets", "marketType": "perp", "coins": [], "sortBy": "dayVolumeUsd", "maxItems": 25 }
```

**Funding screener: liquid perps, highest yearly rate, with the cross-venue rate**

```json
{ "mode": "markets", "coins": [], "sortBy": "fundingApr", "sortDesc": true, "minDayVolumeUsd": 1000000, "includePredictedFunding": true, "maxItems": 25 }
```

**Three-coin watchlist for a scheduled task**

```json
{ "mode": "markets", "coins": ["BTC", "ETH", "SOL"], "maxItems": 10 }
```

**Spot pairs by volume, with market cap**

```json
{ "mode": "markets", "marketType": "spot", "coins": [], "sortBy": "dayVolumeUsd", "maxItems": 20 }
```

**Book snapshot: spread and USD depth within 0.5 % of the mid**

```json
{ "mode": "orderBook", "coins": ["BTC", "ETH", "SOL"], "bookDepth": 10, "depthUsdWindowPct": 0.5, "maxItems": 5 }
```

**A week of HYPE funding settlements**

```json
{ "mode": "fundingHistory", "coins": ["HYPE"], "sinceHours": 168, "maxItems": 50 }
```

**Whole venue above a volume floor, trimmed for an agent**

```json
{ "mode": "markets", "marketType": "both", "coins": [], "minDayVolumeUsd": 100000, "maxItems": 40, "fields": ["symbol", "marketType", "markPx", "dayChangePct", "dayVolumeUsd", "openInterestUsd", "fundingApr", "marketCapUsd"] }
```

### Output

A perpetual row from a real run (`mode=markets`, `marketType=perp`, `includePredictedFunding=true`):

```json
{
  "symbol": "BTC",
  "coin": "BTC",
  "marketType": "perp",
  "markPx": 83988,
  "midPx": 83988.5,
  "oraclePx": 84027.3,
  "prevDayPx": 83965,
  "dayChangePct": 0.0274,
  "dayVolumeUsd": 858327129.3264494,
  "dayVolumeBase": 10220.38512,
  "openInterest": 37308.15674,
  "openInterestUsd": 3133437468.28,
  "fundingHourly": 3.7326e-06,
  "fundingApr": 3.2698,
  "premium": -0.0004558042,
  "maxLeverage": 40,
  "szDecimals": 5,
  "onlyIsolated": false,
  "isDelisted": false,
  "impactBidPx": 83988,
  "impactAskPx": 83989,
  "url": "https://app.hyperliquid.xyz/trade/BTC",
  "fetchedAt": "2026-09-26T19:48:36.818Z",
  "predictedFundingHl": 3.6954e-06,
  "predictedFundingBinance": 2.2e-07,
  "predictedFundingBybit": 7.612e-05,
  "nextFundingTime": "2026-09-26T19:00:00.000Z",
  "fundingIntervalHours": 1
}
```

A spot row (`marketType=spot`), and an order-book row (`mode=orderBook`, levels trimmed):

```json
{
  "symbol": "HYPE/USDC",
  "coin": "HYPE",
  "marketType": "spot",
  "pairId": "@107",
  "baseToken": "HYPE",
  "quoteToken": "USDC",
  "markPx": 91.582,
  "midPx": 91.5825,
  "prevDayPx": 91.604,
  "dayChangePct": -0.024,
  "dayVolumeUsd": 25525595.54017999,
  "dayVolumeBase": 277337.31,
  "circulatingSupply": 298715709.2679536,
  "totalSupply": 998906501.7914867,
  "marketCapUsd": 27356982086.18,
  "isCanonical": false,
  "url": "https://app.hyperliquid.xyz/trade/@107",
  "fetchedAt": "2026-09-26T19:47:41.121Z"
}
```

```json
{
  "symbol": "BTC",
  "coin": "BTC",
  "marketType": "perp",
  "found": true,
  "midPx": 83977.5,
  "bestBid": 83977,
  "bestAsk": 83978,
  "spread": 1,
  "spreadBps": 0.119,
  "bidDepthUsd": 574012.44,
  "askDepthUsd": 1997992.36,
  "depthWindowPct": 0.5,
  "bookImbalance": 0.2232,
  "bidLevels": 10,
  "askLevels": 10,
  "bookTime": "2026-09-26T19:47:40.757Z",
  "bids": [
    { "px": 83977, "sz": 0.21279, "n": 7 },
    { "px": 83976, "sz": 0.77419, "n": 1 },
    { "px": 83975, "sz": 0.52394, "n": 15 }
  ],
  "asks": [
    { "px": 83978, "sz": 7.88955, "n": 35 },
    { "px": 83979, "sz": 0.94494, "n": 4 },
    { "px": 83980, "sz": 1.82516, "n": 4 }
  ],
  "url": "https://app.hyperliquid.xyz/trade/BTC",
  "fetchedAt": "2026-09-26T19:47:40.962Z"
}
```

A symbol the exchange does not list (real row from the same run that read `hpye` as `HYPE`):

```json
{
  "symbol": "NOTACOIN2",
  "coin": "NOTACOIN2",
  "marketType": "perp",
  "found": false,
  "note": "The exchange does not list \"NOTACOIN2\" as a perpetual. Run mode \"markets\" with an empty coin list for the current symbol dictionary.",
  "url": "https://app.hyperliquid.xyz/trade/NOTACOIN2",
  "fetchedAt": "2026-09-26T19:48:36.889Z"
}
```

#### Fields

Always present: `symbol`, `coin`, `marketType`, `url`, `fetchedAt`.

| Field | Type | Meaning |
|---|---|---|
| `symbol` | string | Market name: the coin for a perpetual, `BASE/QUOTE` for a spot pair. |
| `coin` | string | Base symbol (`BTC`, `HYPE`) — what you put into `coins`. |
| `marketType` | string | `perp` or `spot`. |
| `markPx` | number | Mark price the exchange uses for margin. |
| `midPx` | number | Middle of the book; filled from the mid-price endpoint when a snapshot omits it. |
| `prevDayPx`, `dayChangePct` | number | Price 24 hours ago and the change from it in percent. |
| `dayVolumeUsd`, `dayVolumeBase` | number | 24h notional volume in USD and in base coins. |
| `url` | string | Market page of the exchange's web app. |
| `fetchedAt` | string | When the run read the source, ISO 8601 UTC. |

Perpetual rows add:

| Field | Type | Meaning |
|---|---|---|
| `oraclePx` | number | Oracle price — the external index funding is measured against. |
| `openInterest`, `openInterestUsd` | number | Open contracts in base coins, and `openInterest × markPx`. |
| `fundingHourly`, `fundingApr` | number | Hourly funding rate and the same rate in percent per year. |
| `premium` | number | Premium of the contract over the oracle price. |
| `maxLeverage`, `szDecimals`, `onlyIsolated` | number, number, boolean | Contract settings: leverage cap, size precision, isolated margin only. |
| `impactBidPx`, `impactAskPx` | number | The exchange's impact prices, the basis of its premium calculation. |
| `isDelisted` | boolean | Contract kept in the table but no longer traded (hidden unless `includeDelisted`). |
| `predictedFundingHl`, `predictedFundingBinance`, `predictedFundingBybit` | number | Rate each venue is about to charge for this coin, as this exchange publishes it; empty when a venue does not list the coin. With `includePredictedFunding` only. |
| `nextFundingTime`, `fundingIntervalHours` | string, number | Next settlement here (UTC) and its interval. With `includePredictedFunding` only. |

Spot rows add: `pairId` (internal handle, e.g. `@107`), `baseToken`, `quoteToken`, `circulatingSupply`, `totalSupply`, `marketCapUsd` (= `circulatingSupply × markPx`) and `isCanonical`.

`mode=orderBook` rows: `bestBid`, `bestAsk`, `midPx`, `spread`, `spreadBps`, `bidDepthUsd`, `askDepthUsd`, `depthWindowPct`, `bookImbalance` (bid share of the depth in the window, 0–1), `bidLevels`, `askLevels`, `bookTime` (UTC of the snapshot) and `bids[]`/`asks[]` with `{px, sz, n}` — price, size in base coins, number of orders.

`mode=fundingHistory` rows: `time` (settlement, UTC), `fundingHourly`, `fundingApr`, `premium` — newest first, one row per hour.

Dataset views: **Markets** (prices, volume, open interest, funding, market cap), **Funding** (hourly and yearly rate, premium, cross-venue rates, next settlement), **Order book** (top of book, spread, USD depth, imbalance).

Every run also writes a `SUMMARY` record to the default key-value store: `mode`, `marketType`, `coinsRequested`, `rows`, `apiCalls`, `sinceHours`, `notes` (typo corrections, unknown symbols, clamped inputs) and `fetchedAt`.

### Use it from code / agents

**Apify API (curl)**

```bash
curl -X POST "https://api.apify.com/v2/acts/yadroo~hyperliquid-markets/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"mode":"markets","coins":["BTC","ETH"],"maxItems":10}'
```

**JavaScript (`apify-client`)**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('yadroo/hyperliquid-markets').call({ mode: 'markets', coins: [], sortBy: 'fundingApr', minDayVolumeUsd: 1000000, maxItems: 25 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python (`apify-client`)**

```python
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("yadroo/hyperliquid-markets").call(run_input={"mode": "fundingHistory", "coins": ["HYPE"], "sinceHours": 168, "maxItems": 50})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

**MCP / agents** — connect `https://mcp.apify.com` and call the `yadroo/hyperliquid-markets` tool with the same JSON. The row shape is stable enough to feed a tool call directly, and `fields` keeps the answer small (`["symbol","markPx","fundingApr"]` is three numbers per market).

### Pricing

Pay per event: **$0.001 per run start + $0.002 per dataset row**. The start event is charged on every run, including a run that returns nothing.

| Run | Rows | Cost at list price |
|---|---|---|
| Three-coin watchlist | 3 | $0.001 + 3 × $0.002 = **$0.007** |
| Funding screener | 25 | $0.001 + 25 × $0.002 = **$0.051** |
| Default limit, busiest markets | 50 | $0.001 + 50 × $0.002 = **$0.101** |
| A week of hourly funding for one coin | 168 | $0.001 + 168 × $0.002 = **$0.337** |

Apify plan tiers discount the row price (Bronze −10 %, Silver −20 %, Gold and above −30 %); the start event is flat. Runs are small — 256 MB, no browser, one to a handful of HTTP calls — so platform compute stays a fraction of a cent.

### Limits & FAQ

- **Freshness** — every row is read live and stamped with `fetchedAt`; `markets` mode is one snapshot per run, not a stream. Schedule the task (every few minutes is cheap for a short coin list) if you need a series.
- **Funding granularity** — this venue settles funding hourly, so history has hourly resolution and nothing finer exists upstream. `nextFundingTime` is the timestamp the exchange publishes for the coming settlement; it can already be a few minutes old when a run starts.
- **Cross-venue funding** — `predictedFundingBinance` and `predictedFundingBybit` are what *this* exchange publishes about those venues, not values read from them. A venue that does not list the coin leaves the field empty, and funding intervals differ (often 8 hours elsewhere against 1 hour here), so compare rates per hour, not per interval.
- **Order book** — a point-in-time snapshot of up to 20 levels per side; spot pairs are not covered by this mode. `bidDepthUsd` and `askDepthUsd` count only the levels kept (`bookDepth`) inside `depthUsdWindowPct`, so a wide window with few levels understates real depth.
- **Market cap** — `marketCapUsd` uses the supply figure the exchange reports for the token. For wrapped or bridged tokens that figure is often the maximum supply, which makes the market cap look far too large; treat it as the exchange's number, not as a verified float.
- **Long funding windows** — the source answers at most 500 hourly samples per call, so `sinceHours=2160` costs up to five calls per coin. Keep coin lists short in scheduled runs: the endpoint budgets request weight per IP.
- **Numbers as strings** — the source sends every price and rate as a JSON string; the actor parses them to numbers and derives `dayChangePct`, `openInterestUsd`, `fundingApr`, `marketCapUsd`, `spreadBps` and the depth figures itself. Timestamps arrive as epoch milliseconds and are converted to ISO 8601 UTC.
- **Bad input** — an unknown symbol yields a row with `found: false`; an obvious typo is corrected and reported in the log, the status message and `SUMMARY`. A wrong `mode`, `marketType` or `sortBy` is corrected when it is clearly a typo, otherwise the run fails with the list of allowed values. A request is never silently widened.
- **What is not here** — no trader, wallet, position, fill, vault or leaderboard data, by design. No trading and no authentication: the actor only reads public market endpoints.
- **Source availability** — retries with backoff on rate limits and 5xx; if the endpoint stays unavailable the run fails with a message saying so instead of writing half a table. Not affiliated with the exchange.

***

Made by **Yadroo**. Related actors: [coingecko-markets](https://apify.com/yadroo/coingecko-markets), [dexscreener-tokens](https://apify.com/yadroo/dexscreener-tokens), [defillama-protocols](https://apify.com/yadroo/defillama-protocols), [polymarket-markets](https://apify.com/yadroo/polymarket-markets), [base-token-intel](https://apify.com/yadroo/base-token-intel).

# Actor input Schema

## `mode` (type: `string`):

`markets` reads the whole market table in two calls and writes a row per market. `orderBook` takes a book snapshot for each coin in *Coins* and condenses it into one row (plus the raw levels). `fundingHistory` walks the funding payments of each coin in *Coins* backwards over *Hours back* and writes one row per sample (funding settles hourly).

## `marketType` (type: `string`):

Which side of the exchange to read in `markets` mode. Funding, open interest, oracle price and leverage exist only on perpetuals; supply and market cap only on spot. `orderBook` and `fundingHistory` always use perpetuals.

## `coins` (type: `array`):

Base symbols as the exchange writes them, e.g. BTC, ETH, HYPE, SOL, XRP. Required for `orderBook` and `fundingHistory`; in `markets` mode it narrows the table and an empty list returns every market. Case is ignored; a symbol the exchange does not list is reported as a row with `found: false`. Run `markets` with an empty list once to see the full symbol dictionary.

## `minDayVolumeUsd` (type: `integer`):

Drop markets that traded less than this in the last 24 hours. Useful to skip the long tail of thin listings. Empty = keep everything. `markets` mode only.

## `includePredictedFunding` (type: `boolean`):

Adds one extra call that returns the funding rate each venue is about to charge for the same coin, so every perpetual row also carries the rate expected on other perp venues and the next funding timestamp in UTC. This is what a funding-spread screen needs.

## `includeDelisted` (type: `boolean`):

The exchange keeps delisted contracts in its market table with a frozen price and no volume. They are skipped by default; turn this on to see them too (`isDelisted` marks them). `markets` mode only.

## `sortBy` (type: `string`):

Order of the rows before *Max rows* cuts the list, so sorting by volume with a small limit gives you the busiest markets.

## `sortDesc` (type: `boolean`):

Off = smallest first. Turn it off with *Sort rows by* = funding rate to find the most negative funding, where shorts pay longs.

## `bookDepth` (type: `integer`):

How many price levels of bids and of asks to keep in the `bids` and `asks` arrays of an `orderBook` row. The summary numbers (spread, depth, imbalance) are computed from the levels kept.

## `depthUsdWindowPct` (type: `number`):

Width of the band used for `bidDepthUsd` and `askDepthUsd`: with 0.5 the row tells you how many USD of resting size sit within half a percent below and above the mid price. That is the number behind "how big a market order can this book absorb".

## `sinceHours` (type: `integer`):

Window for `fundingHistory`, counted back from the moment the run starts, in UTC. Funding settles once an hour, so 24 gives about 24 rows per coin and 720 covers a month. Schedule the actor hourly with a small window to keep a funding table up to date.

## `maxItems` (type: `integer`):

Hard cap on dataset rows. The exchange lists a few hundred perpetuals and several hundred spot pairs, so raise this when you want the complete table.

## `fields` (type: `array`):

Keep only these fields, in this order, e.g. \["symbol", "markPx", "fundingApr"]. Empty = every field the mode produces.

## Actor input object example

```json
{
  "mode": "markets",
  "marketType": "perp",
  "coins": [
    "BTC",
    "ETH",
    "HYPE"
  ],
  "includePredictedFunding": false,
  "includeDelisted": false,
  "sortBy": "dayVolumeUsd",
  "sortDesc": true,
  "bookDepth": 10,
  "depthUsdWindowPct": 0.5,
  "sinceHours": 24,
  "maxItems": 50
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "coins": [
        "BTC",
        "ETH",
        "HYPE"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("yadroo/hyperliquid-markets").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "coins": [
        "BTC",
        "ETH",
        "HYPE",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("yadroo/hyperliquid-markets").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "coins": [
    "BTC",
    "ETH",
    "HYPE"
  ]
}' |
apify call yadroo/hyperliquid-markets --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yadroo/hyperliquid-markets"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ojPDaduvCf2jGNu6w/builds/CpzkQ4NYJIPGU2q0e/openapi.json