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.

Need it tailored to your workflow? Missing a field, a filter, another source or a different output format? Open an issue and describe what you need — we read every request and adapt the actor.

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.
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, kPEPE). Letter case, spaces and a leading $ are ignored; nothing else is guessed — a symbol the exchange does not list, a near miss like hpye included, comes back as a found: false row whose note names the closest listed symbols (Did you mean "HYPE"?), because tickers one letter apart are often different coins. 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.
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. found: false rows count too.
fields	string[]	all	Keep only these fields, in this order. symbol, coin, marketType and fetchedAt are always kept. Letter case is fixed; a name this mode does not write, or no field at all, is left out with a warning (with "did you mean"); a list with no name this mode writes is refused before any request, so nothing is billed.

Reference

Modes

mode	Calls to the source (request weight)	One row is	Uses
markets	1 (perp), 1 (spot) or 2 (both), +1 with includePredictedFunding (20 each), +1 when a mid price is missing (2)	one perpetual contract or one spot pair	marketType, coins, minDayVolumeUsd, includeDelisted, sortBy, sortDesc
orderBook	1 (20) + 1 per coin (2 each)	one coin: top of book, spread, depth, raw levels	coins, bookDepth, depthUsdWindowPct
fundingHistory	1 (20) + 1 per coin per page; a page covers only the hours still wanted for that coin, at most 480 (20 + 1 per 20 samples)	one funding settlement of one coin	coins, sinceHours

Request budget and run time

The exchange publishes a request budget per IP address: all REST requests share 1,200 weight per minute (l2Book and the mid-price list weigh 2, every other market-data request 20, and a funding page adds 1 per 20 settlements it returns). The actor keeps every run at or below 1,000 weight in any 60 seconds (other clients can share the egress IP) and never spreads the load over several IPs. It does not burst and then fail: when the budget is used up it waits, and after an HTTP 429 it pauses a full minute and goes on. What that means in practice:

• markets — 20 to 62 weight, a few seconds, whatever the table size.
• orderBook — 2 weight per coin: every listed perpetual in well under a minute.
• fundingHistory — about 45 coins per minute with a 24-hour window (22 weight per coin), and about 22 pages per minute for long windows (a 480-hour page weighs 44). The heaviest run — every listed perpetual (≈ 230) with a short window — spends about 5,000 weight and takes about 5 minutes; a few coins with long windows finish in under a minute.

Rows are saved as they are read (per coin, per funding page). A run that nears its timeout stops starting new requests, keeps every row read so far and ends with Stopped before the run timeout: N rows saved and the coins it did not reach (notRead in SUMMARY). A run the platform restarts (migration, reboot) stores and bills no row twice; it reads the coins again and, since the exchange still counts the last minute before the restart, starts with a smaller share of the budget.

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 comes back as one row with found: false and a note naming the closest listed symbols — never as a silently empty run, and never as another coin's data.

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

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

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

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

Three-coin watchlist for a scheduled task

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

Spot pairs by volume, with market cap

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

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

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

A week of HYPE funding settlements

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

Whole venue above a volume floor, trimmed for an agent

{ "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):

{
  "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):

{
  "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"
}

{
  "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 (coins: ["BTC", "hpye"] in markets mode):

{
  "symbol": "HPYE",
  "coin": "HPYE",
  "marketType": "perp",
  "found": false,
  "note": "The exchange does not list \"HPYE\". Did you mean \"HYPE\"? Run mode \"markets\" with an empty coin list for the current symbol dictionary.",
  "url": "https://app.hyperliquid.xyz/trade/HPYE",
  "fetchedAt": "2026-09-26T19:48:36.889Z"
}

Fields

Every row has symbol, coin, marketType, url and fetchedAt (with fields set, url only when listed). A found: false row carries only these, found and note — and keeps found and note whatever fields says.

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 (linked from the run's output as summary): mode, marketType, coinsRequested, rows / delivered (rows saved and charged), apiCalls, requestWeight (weight spent against the exchange's budget), throttled (HTTP 429 answers), sinceHours, unknownCoins (with suggestions), notRead (coins not reached and why, in status), failures (per-coin errors), notes (clamped inputs, fields warnings, empty books), stoppedBy (limit, timeout or empty), status and fetchedAt.

Use it from code / agents

Apify API (curl)

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)

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)

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 the same on every plan. Platform usage is included: you pay only these two events.

The actor respects your maximum cost per run: it stops requesting once the rows it has saved use up the limit and ends with Stopped at your spending limit: N rows delivered — it never fetches rows it cannot deliver.

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 pages per coin; each page asks only for the hours still wanted, so a small maxItems costs one small page per coin. See Request budget and run time for how long large runs take.
• 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, a near miss included, yields a row with found: false that names the closest listed symbols; it is never read as another coin. The status message and SUMMARY list them. mode, marketType and sortBy take only the listed values: Apify checks them before the run starts and refuses a misspelled one 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 — an HTTP 429 gets a full-minute pause and a new try (a fourth 429 in a row ends the attempt), a 5xx or timeout two short retries. If the market table or the symbol list cannot be read, the run fails with the reason. If a per-coin request keeps failing, the run stops there, keeps every row already saved and names the coins not read; a definitive error for one coin (HTTP 4xx) is reported and the next coin is read. Not affiliated with the exchange.

---

Made by Yadroo. Related actors: coingecko-markets, dexscreener-tokens, defillama-protocols, polymarket-markets, base-token-intel.