# Hyperliquid Data: Futures Prices, Funding Rates and Positions (`scrapemint/hyperliquid-data`) Actor

Keyless Hyperliquid market data: every live futures market with price, 24 hour volume, open interest and funding rate, the hourly funding history, and the open positions of any wallet address, including leverage and liquidation price.

- **URL**: https://apify.com/scrapemint/hyperliquid-data.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Hyperliquid Data: Futures Prices, Funding Rates and Positions

Market data from **Hyperliquid**, plus something a centralised exchange cannot offer: **positions are public**. Give it a wallet address and it returns what that account is actually holding, at what leverage, and the price at which it gets liquidated.

No API key, no account, no browser.

### Modes

- **Markets** - one row per live futures market: mark, oracle and mid price, 24 hour change and volume, open interest in coins and dollars, funding rate hourly and annualised, maximum leverage. Sorted busiest first.
- **Funding** - one row per funding settlement per market. Funding here settles **every hour**, so a day is 24 rows.
- **Positions** - one row per open position for the wallet addresses you supply: side, size, entry price, leverage, liquidation price, unrealised profit and loss, and the account's total value.
- **Traders** - one row per recent trade with the **counterparty wallet addresses**, which is how you find accounts worth looking up in positions mode without knowing any in advance.

### Example output

```json
{
  "mode": "positions",
  "walletAddress": "0x385e3a707c7b4fa0c0e0778c4ca2868d0a3cbfbd",
  "coin": "ETH",
  "side": "short",
  "sizeCoins": 12,
  "entryPrice": 1895.39,
  "positionValueUsd": 22694.4,
  "leverage": 11,
  "leverageType": "isolated",
  "liquidationPrice": 2026.68,
  "unrealisedPnlUsd": 50.31,
  "returnOnEquityPercent": 2.433
}
```

### Things that will catch you out

- **Funding settles every hour on this exchange.** Most venues settle every eight hours, so the usual "rate times three times 365" annualisation **understates a Hyperliquid rate by a factor of eight**. Every row carries the hourly rate, the correctly annualised figure, and `fundingSettlesEveryHours` so the convention is never in doubt.
- **Delisted markets stay in the response.** 55 of the 232 markets returned are delisted, each still carrying a stale price alongside zero volume and zero open interest, so they read as live markets. They are excluded by default and flagged when you ask for them.
- **The two market arrays are positional.** The list of markets and the list of prices are matched only by index; nothing in the response keys them together, so an off by one attaches every price to the wrong market.
- **Position size is signed.** A negative size is a short. Reporting the absolute value loses the side entirely, so both the signed number and an explicit `side` ship on the row.
- **A flat account and an account that never traded look identical.** Both return no positions, so that case is a free note saying exactly that rather than an empty row implying anything.
- **Trade counterparties are published, but not which side each took.** Both addresses come back unlabelled, so they are reported as a pair rather than guessed at. Look each up in positions mode to see what they hold.
- **Traders mode is a live sample, not a history.** The exchange publishes only the latest handful of trades per market, roughly ten, and most are small. Schedule the run if you want to accumulate addresses over time; a high minimum trade size on a single run will often return nothing.
- Every number arrives as a string and is converted here.

### Who this is for

Traders following funding and open interest across 177 live markets, and anyone who wants to watch what large accounts are actually holding rather than guessing from flow. Because positions are on chain, the liquidation price of a big account is public information.

### Pricing

**$0.004 per row.** The first 2 rows of every run are free, and note rows (a flat wallet, a market with no funding history, a trade filter nothing matched) are never charged.

The default markets snapshot is 50 rows, or **$0.20**. A day of hourly funding for one market is 24 rows. Checking five wallets costs a row per open position.

### Related actors

- **Crypto Order Book Depth** - liquidity and slippage on OKX, Gate, Bitget and KuCoin.
- **Crypto Funding Rates Tracker** - funding on those same centralised venues, for comparison against this one.
- **Crypto Token Security Check** - contract safety checks before buying a token.

### How to run it via API

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapemint~hyperliquid-data/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"markets","maxRows":50}'
```

# Actor input Schema

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

markets = every live futures market with price, volume, open interest and funding. funding = the funding rate history for selected markets. positions = the open positions held by wallet addresses you supply. traders = recent large trades with the wallet addresses behind them, which is how you find accounts to look up.

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

BTC, ETH, SOL and so on. Empty returns every live market in markets mode, and the five busiest in funding mode.

## `walletAddresses` (type: `array`):

Positions mode. Positions on this exchange are public, so any address can be looked up.

## `hoursBack` (type: `integer`):

Funding mode. Funding settles every hour here, so 24 gives 24 rows per market.

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

Markets mode. Skip markets trading less than this in the last 24 hours.

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

Off by default. Delisted markets remain in the exchange response carrying a stale price with no volume, which reads as a live market unless excluded.

## `maxRows` (type: `integer`):

Cap on rows returned, busiest markets first. Controls total cost.

## `minTradeUsd` (type: `integer`):

Traders mode. Only return trades worth at least this much, largest first. The exchange publishes only the latest handful of trades per market, so a high floor often returns nothing.

## Actor input object example

```json
{
  "mode": "markets",
  "coins": [],
  "walletAddresses": [],
  "hoursBack": 24,
  "minDayVolumeUsd": 0,
  "includeDelisted": false,
  "maxRows": 50,
  "minTradeUsd": 1000
}
```

# 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 = {
    "maxRows": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/hyperliquid-data").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 = { "maxRows": 50 }

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

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

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

```

## CLI example

```bash
echo '{
  "maxRows": 50
}' |
apify call scrapemint/hyperliquid-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapemint/hyperliquid-data",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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