# Hyperliquid Funding Rates & Arbitrage Screener (`xtracto/hyperliquid-funding-rates`) Actor

Live perpetual funding rates for every Hyperliquid market, with annualized percentages, open interest and 24h volume. Screen for funding-arbitrage opportunities, compare predicted funding against Binance and Bybit, or pull historical funding series per coin. No account or key needed.

- **URL**: https://apify.com/xtracto/hyperliquid-funding-rates.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Funding Rates & Arbitrage Screener

Track the **funding rate** of every perpetual market on **Hyperliquid** — the fee that longs and shorts pay each other every hour. This actor returns the live rate for all ~230 markets converted to a plain yearly percentage, compares Hyperliquid's next payment against Binance and Bybit, and pulls historical funding series for any coin.

Funding is the cleanest signal of crowded positioning in crypto: when it goes sharply positive, longs are paying shorts and the market is over-long. It is also the basis of the classic cash-and-carry trade — hold the coin, short the perpetual, collect the funding.

### Why use this actor

- **No account, no login, no API key** — just press Run.
- **Every market in one run** — around 230 Hyperliquid perpetual markets with funding, open interest, mark price, premium and 24-hour volume.
- **Annualized, not cryptic** — Hyperliquid quotes funding as a tiny hourly decimal (`0.0000125`). Every record also carries `annualizedFundingPct` (`10.95`), so you can read it like an interest rate.
- **Built-in arbitrage screen** — set one number (`minAnnualizedPct`) and get back only the markets paying above it, ranked by size.
- **Compare venues side by side** — predicted funding for the same coin on Hyperliquid, Binance and Bybit, with the yearly spread against Hyperliquid already calculated (each venue charges funding on its own schedule, and the actor normalizes for that).
- **Full history per coin** — one record per funding hour, going back up to a year.
- **Clean, stable JSON** for spreadsheets, dashboards, databases or alerting. Export to JSON, CSV or Excel and run it on a schedule.

### How it works

1. Pick a **mode**: `current` (all markets right now), `predicted` (compare Hyperliquid against Binance and Bybit) or `history` (past funding for the coins you choose).
2. Optionally set a **minimum funding percentage per year** to keep only the markets worth trading, and a **max records** cap.
3. For history, list the **coins** and how many **hours** to look back.
4. Press **Run**. Records stream into the dataset, ready to export.

No scrapers, servers or blocks to babysit — retries are handled for you, and every failure comes back as a labelled record rather than a silent gap.

### How the yearly percentage is calculated

Hyperliquid charges funding **once every hour**, so an hourly rate becomes a yearly percentage like this:

```
annualizedFundingPct = fundingRate × 24 × 365 × 100
```

A rate of `0.0000125` per hour is therefore `0.0000125 × 24 × 365 × 100 = 10.95%` per year. A positive number means longs pay shorts; a negative number means shorts pay longs.

Binance and Bybit charge funding every 4 or 8 hours instead. In `predicted` mode the actor uses each venue's own interval (`fundingIntervalHours`) in place of the 24, so the venues are directly comparable.

### Modes

| Mode | What it returns | Key inputs |
| --- | --- | --- |
| `current` *(default)* | One record per Hyperliquid market with its live funding rate, ranked by the size of the payment. | `minAnnualizedPct`, `includeDelisted`, `maxItems` |
| `predicted` | One record per coin and venue (Hyperliquid / Binance / Bybit) with the next funding rate and the spread against Hyperliquid. | `maxItems` |
| `history` | One record per funding hour per coin. | `coins`, `lookbackHours`, `maxItems` |

### Input

**Current funding (default):**

```json
{
  "mode": "current",
  "minAnnualizedPct": 20,
  "includeDelisted": false,
  "maxItems": 500
}
```

**Compare venues:**

```json
{
  "mode": "predicted",
  "maxItems": 500
}
```

**Funding history:**

```json
{
  "mode": "history",
  "coins": ["BTC", "ETH"],
  "lookbackHours": 168,
  "maxItems": 500
}
```

| Field | Type | Description |
| --- | --- | --- |
| `mode` | string | `current`, `predicted` or `history`. |
| `minAnnualizedPct` | integer | Current mode: keep only markets paying more than this percentage per year, in either direction. `0` or empty keeps everything. |
| `includeDelisted` | boolean | Current mode: include retired markets (no open interest, no volume, stale rate). Off by default. |
| `coins` | array of strings | History mode: coin symbols exactly as Hyperliquid lists them (`BTC`, `ETH`, `SOL`, `HYPE`, `kPEPE`…). |
| `lookbackHours` | integer | History mode: how far back to go. `168` = 7 days ≈ 168 records per coin. Maximum `8760` (one year). |
| `maxItems` | integer | Max records. Caps total rows in `current` and `predicted`; caps rows **per coin** in `history`. `0` = no cap. |
| `proxyConfiguration` | object | Optional. Not needed — the data is public. |

### Output

Every record carries a small header (`_input`, `_source`, `_scrapedAt`, `recordType`) plus Hyperliquid's own field names, unchanged. Calculated conveniences are added alongside and are always suffixed `Num`, `Pct` or `Iso`, so you can tell them apart at a glance.

#### `CURRENT_FUNDING` — mode `current`

The top hit of a real run: `ACE` was paying shorts at an extreme rate, which is exactly what the screen is meant to surface.

```json
{
  "_input": "current minAnnualizedPct=20.0 top=10",
  "_source": "S1-current",
  "_scrapedAt": "2026-08-08T05:27:05Z",
  "recordType": "CURRENT_FUNDING",
  "coin": "ACE",
  "fundingIntervalHours": 1,
  "fundingRateNum": -0.0014696917,
  "annualizedFundingPct": -1287.449929,
  "markPxNum": 0.1127,
  "oraclePxNum": 0.1143,
  "midPxNum": 0.113,
  "premiumNum": -0.009623797,
  "openInterestNum": 12404770.339999994,
  "openInterestUsd": 1398017.62,
  "dayNtlVlmNum": 9666219.117398016,
  "priceChangePct24h": -23.281144,
  "szDecimals": 2,
  "name": "ACE",
  "maxLeverage": 3,
  "marginTableId": 3,
  "funding": "-0.0014696917",
  "openInterest": "12404770.3399999943",
  "prevDayPx": "0.1469",
  "dayNtlVlm": "9666219.1173980162",
  "premium": "-0.009623797",
  "oraclePx": "0.1143",
  "markPx": "0.1127",
  "midPx": "0.113",
  "impactPxs": ["0.1127", "0.1132"],
  "dayBaseVlm": "76843854.5900000483"
}
```

And a calm, liquid market from the same run:

```json
{
  "coin": "BTC",
  "fundingRateNum": 0.0000062651,
  "annualizedFundingPct": 5.488228,
  "markPxNum": 64988.0,
  "openInterestNum": 34835.30156,
  "openInterestUsd": 2263876577.78,
  "dayNtlVlmNum": 1221862446.9225917,
  "priceChangePct24h": 1.307893,
  "maxLeverage": 40,
  "funding": "0.0000062651",
  "premium": "-0.0004460372",
  "prevDayPx": "64149.0"
}
```

| Field | Type | Description |
| --- | --- | --- |
| `coin` / `name` | string | Market symbol. |
| `funding` / `fundingRateNum` | string / number | The hourly funding rate, as text and as a number. |
| `annualizedFundingPct` | number | The same rate as a percentage per year. Positive = longs pay shorts. |
| `fundingIntervalHours` | integer | How often funding is charged (always `1` on Hyperliquid). |
| `openInterest` / `openInterestNum` | string / number | Open interest in coins. |
| `openInterestUsd` | number | Open interest in US dollars (open interest × mark price). |
| `markPx`, `oraclePx`, `midPx` | string | Mark, oracle and mid price (numeric twins: `markPxNum`, `oraclePxNum`, `midPxNum`). |
| `premium` / `premiumNum` | string / number | How far the perpetual is trading above or below the oracle price. |
| `prevDayPx`, `priceChangePct24h` | string / number | Price 24 hours ago and the change since. |
| `dayNtlVlm` / `dayNtlVlmNum` | string / number | 24-hour trading volume in US dollars. |
| `dayBaseVlm` | string | 24-hour trading volume in coins. |
| `maxLeverage` | integer | Maximum leverage allowed on this market. |
| `szDecimals`, `marginTableId`, `impactPxs` | mixed | Market settings passed straight through. |

Records are ranked by the size of the funding payment, biggest first.

#### `PREDICTED_FUNDING` — mode `predicted`

Three real records for `BTC` from one run — Hyperliquid, Binance and Bybit side by side. Note how each venue charges on a different schedule (`fundingIntervalHours`), and that the comparison is already done for you.

```json
[
  {
    "_input": "predicted top=500",
    "_source": "S1-predicted",
    "_scrapedAt": "2026-08-08T05:27:33Z",
    "recordType": "PREDICTED_FUNDING",
    "coin": "BTC",
    "venue": "HlPerp",
    "venueLabel": "Hyperliquid",
    "fundingRateNum": 0.0000062561,
    "annualizedFundingPct": 5.480344,
    "hyperliquidAnnualizedPct": 5.480344,
    "spreadVsHyperliquidPct": 0.0,
    "nextFundingTimeIso": "2026-08-08T05:00:00Z",
    "venuesCovered": ["BinPerp", "HlPerp", "BybitPerp"],
    "fundingRate": "0.0000062561",
    "nextFundingTime": 1786165200000,
    "fundingIntervalHours": 1
  },
  {
    "coin": "BTC",
    "venue": "BinPerp",
    "venueLabel": "Binance",
    "fundingRateNum": 0.00003471,
    "annualizedFundingPct": 3.800745,
    "hyperliquidAnnualizedPct": 5.480344,
    "spreadVsHyperliquidPct": -1.679599,
    "nextFundingTimeIso": "2026-08-08T08:00:00Z",
    "fundingRate": "0.00003471",
    "nextFundingTime": 1786176000000,
    "fundingIntervalHours": 8
  },
  {
    "coin": "BTC",
    "venue": "BybitPerp",
    "venueLabel": "Bybit",
    "fundingRateNum": 0.0,
    "annualizedFundingPct": 0.0,
    "hyperliquidAnnualizedPct": 5.480344,
    "spreadVsHyperliquidPct": -5.480344,
    "nextFundingTimeIso": "2026-08-08T08:00:00Z",
    "fundingRate": "0.0",
    "nextFundingTime": 1786176000000,
    "fundingIntervalHours": 8
  }
]
```

| Field | Type | Description |
| --- | --- | --- |
| `coin` | string | Market symbol. |
| `venue` / `venueLabel` | string | `HlPerp` / `BinPerp` / `BybitPerp`, and the readable name (Hyperliquid / Binance / Bybit). |
| `fundingRate` / `fundingRateNum` | string / number | The next funding rate on that venue, for that venue's own interval. |
| `fundingIntervalHours` | integer | How often that venue charges funding (1, 4 or 8 hours). |
| `annualizedFundingPct` | number | That rate as a percentage per year, adjusted for the venue's interval. |
| `hyperliquidAnnualizedPct` | number | Hyperliquid's figure for the same coin, repeated on every row for easy comparison. |
| `spreadVsHyperliquidPct` | number | This venue minus Hyperliquid, in percent per year — the cross-venue signal. |
| `nextFundingTime` / `nextFundingTimeIso` | number / string | When the next funding payment happens. |
| `venuesCovered` | array | Which venues actually list this coin. |

Coins are ordered by their widest spread against Hyperliquid, with each coin's venues grouped together.

#### `FUNDING_HISTORY` — mode `history`

One record per funding hour. A real `BTC` record from a 7-day run:

```json
{
  "_input": "BTC",
  "_source": "S1-history",
  "_scrapedAt": "2026-08-08T05:28:02Z",
  "recordType": "FUNDING_HISTORY",
  "fundingIntervalHours": 1,
  "fundingRateNum": 0.000006837,
  "annualizedFundingPct": 5.989212,
  "premiumNum": -0.0004453039,
  "timeIso": "2026-08-01T06:00:00Z",
  "coin": "BTC",
  "fundingRate": "0.000006837",
  "premium": "-0.0004453039",
  "time": 1785564000017
}
```

Over that week, `BTC` funding ranged from `-9.19%` to `+10.95%` per year across 168 hourly records.

| Field | Type | Description |
| --- | --- | --- |
| `coin` | string | Market symbol. |
| `fundingRate` / `fundingRateNum` | string / number | The rate charged in that hour. |
| `annualizedFundingPct` | number | The same rate as a percentage per year. |
| `premium` / `premiumNum` | string / number | How far the perpetual traded above or below the oracle price at that time. |
| `time` / `timeIso` | number / string | When funding was charged (milliseconds since 1970, and readable UTC). |

If anything fails, the actor emits a `{_input, _source, _scrapedAt, _error, _errorDetail}` record instead of quietly skipping — for example an unknown coin symbol in history mode.

### Notes & limits

- Around 230 markets are live at any time. Roughly 55 retired markets are hidden by default; their last funding rate no longer moves. Turn on **Include retired markets** if you want them.
- History is returned in blocks of 500 records; the actor keeps going automatically until it reaches your lookback window or your record cap, so a 30-day pull for one coin returns all 720 hours.
- `maxItems` caps **total** rows in `current` and `predicted` mode, and rows **per coin** in `history` mode. With three venues per coin, `predicted` can produce roughly 600 rows in total — raise the cap (or set `0`) to see them all.
- Venue comparison covers Hyperliquid, Binance and Bybit. Not every coin is listed everywhere; rows only appear for venues that actually list it, and `venuesCovered` tells you which ones did.
- All data is public — no account, no key, no proxy required.
- Funding changes every hour. Run it hourly to build your own history, or daily for a positioning snapshot.

### Other actors in this collection

| Actor | What it does |
| --- | --- |
| **Hyperliquid Whale Wallet Copier** | Ranks the most profitable traders on Hyperliquid and shows their live positions and recent trades. |

# Actor input Schema

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

Which funding data to pull. 'current' returns the live funding rate of every Hyperliquid market. 'predicted' returns the next funding rate per market on Hyperliquid, Binance and Bybit so you can compare venues. 'history' returns the past funding rates of the coins you list.

## `minAnnualizedPct` (type: `integer`):

Current mode only. Keep only markets whose funding, expressed as a percentage per year, is bigger than this in either direction. Leave empty for all markets. Set to 20 for a quick shortlist of markets paying above 20% per year.

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

Current mode only. Retired markets (no open interest and no trading volume) are hidden by default because their last funding rate is stale. Turn this on to include them.

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

History mode only. Coin symbols to pull funding history for, exactly as Hyperliquid lists them (BTC, ETH, SOL, HYPE, kPEPE...). One record per funding hour per coin.

## `lookbackHours` (type: `integer`):

History mode only. How far back to go, in hours. Funding is charged once an hour, so 168 hours gives 7 days and about 168 records per coin. Maximum 8760 (one year).

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

Maximum records to return. In current and predicted mode this caps the total rows (best-ranked first). In history mode it caps the records per coin. Use 0 for no cap.

## `proxyConfiguration` (type: `object`):

Optional. Hyperliquid's data is public and open, so no proxy is required — leave this off unless your network needs one.

## Actor input object example

```json
{
  "mode": "current",
  "includeDelisted": false,
  "coins": [
    "BTC",
    "ETH"
  ],
  "lookbackHours": 168,
  "maxItems": 500,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `coin` (type: `string`):

Coin as reported by the source.

## `annualizedFundingPct` (type: `string`):

Annualized Funding Pct as reported by the source.

## `fundingRateNum` (type: `string`):

Funding Rate Num as reported by the source.

## `openInterestUsd` (type: `string`):

Open Interest Usd as reported by the source.

## `markPxNum` (type: `string`):

Mark Px Num as reported by the source.

## `dayNtlVlmNum` (type: `string`):

Day Ntl Vlm Num as reported by the source.

## `recordType` (type: `string`):

Which kind of row this is.

## `_scrapedAt` (type: `string`):

UTC timestamp of the scrape, ISO 8601.

## `fundingIntervalHours` (type: `string`):

Funding Interval Hours.

## `oraclePxNum` (type: `string`):

Oracle Px Num as reported by the source.

## `midPxNum` (type: `string`):

Mid Px Num as reported by the source.

## `premiumNum` (type: `string`):

Premium Num as reported by the source.

## `openInterestNum` (type: `string`):

Open Interest Num as reported by the source.

## `priceChangePct24h` (type: `string`):

Price Change Pct24h as reported by the source.

## `szDecimals` (type: `string`):

Sz Decimals.

## `name` (type: `string`):

Name of the item.

## `maxLeverage` (type: `string`):

Max Leverage as reported by the source.

## `marginTableId` (type: `string`):

Margin Table Id as reported by the source.

## `funding` (type: `string`):

Funding as reported by the source.

## `openInterest` (type: `string`):

Open Interest as reported by the source.

## `prevDayPx` (type: `string`):

Prev Day Px as reported by the source.

## `dayNtlVlm` (type: `string`):

Day Ntl Vlm as reported by the source.

## `premium` (type: `string`):

Premium as reported by the source.

## `oraclePx` (type: `string`):

Oracle Px as reported by the source.

## `markPx` (type: `string`):

Mark Px as reported by the source.

## `midPx` (type: `string`):

Mid Px as reported by the source.

## `impactPxs` (type: `string`):

Impact Pxs.

## `dayBaseVlm` (type: `string`):

Day Base Vlm as reported by the source.

## `venue` (type: `string`):

Venue as reported by the source.

## `venueLabel` (type: `string`):

Venue Label as reported by the source.

## `hyperliquidAnnualizedPct` (type: `string`):

Hyperliquid Annualized Pct as reported by the source.

## `spreadVsHyperliquidPct` (type: `string`):

Spread Vs Hyperliquid Pct as reported by the source.

# 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 = {
    "mode": "current",
    "minAnnualizedPct": 0,
    "coins": [
        "BTC",
        "ETH"
    ],
    "lookbackHours": 168,
    "maxItems": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/hyperliquid-funding-rates").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 = {
    "mode": "current",
    "minAnnualizedPct": 0,
    "coins": [
        "BTC",
        "ETH",
    ],
    "lookbackHours": 168,
    "maxItems": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/hyperliquid-funding-rates").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 '{
  "mode": "current",
  "minAnnualizedPct": 0,
  "coins": [
    "BTC",
    "ETH"
  ],
  "lookbackHours": 168,
  "maxItems": 500
}' |
apify call xtracto/hyperliquid-funding-rates --silent --output-dataset

```

## MCP server setup

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

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/t6MSYy6E1k1Ry3PXg/builds/4jg98y8LfyUOSN3c4/openapi.json