# Hyperliquid Perp Funding Scraper (`parseforge/hyperliquid-perp-funding-scraper`) Actor

Snapshot Hyperliquid perpetual futures with coin, funding\_rate, open\_interest, premium, oracle\_px, mark\_px, and day\_volume. Pass a coin filter like BTC,ETH,SOL or leave empty for the full board. Useful for funding arbitrage, basis trading, and on chain derivatives analytics.

- **URL**: https://apify.com/parseforge/hyperliquid-perp-funding-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Integrations, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 💰 Hyperliquid Perp Funding & Open Interest Scraper

> 🚀 **Export Hyperliquid perpetual futures funding rates, open interest, premium, and oracle prices in seconds, straight from the public api.hyperliquid.xyz info endpoint.**

> 🕒 **Last updated:** 2026-05-29 · **📊 9 fields** per record · 150+ perp markets · Real-time on-chain DEX data

The Hyperliquid Perp Funding Scraper turns Hyperliquid's public `info` endpoint into a clean, structured dataset. It calls `metaAndAssetCtxs`, pairs each coin in the universe with its current asset context, and emits one row per market with funding rate, open interest, mark price, oracle price, premium and 24h volume.

Hyperliquid is a fully on-chain perpetual futures DEX. The funding payments are paid every hour and are critical for basis traders, market-neutral strategies, and on-chain dashboards.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| 📊 Crypto quant teams | Pull live funding curves for delta-neutral strategies |
| 💱 Basis traders | Compare Hyperliquid funding vs Binance/Bybit/dYdX |
| 🏢 On-chain analytics | Build dashboards of perp open interest |
| 🤖 ML researchers | Train funding-rate prediction models |
| 📰 Crypto journalists | Snapshot DEX market state for stories |
| 👩‍💻 DeFi developers | Mirror Hyperliquid market data into your own DB |

### 📋 What the Hyperliquid Perp Funding Scraper does

- Calls the public `https://api.hyperliquid.xyz/info` endpoint with `metaAndAssetCtxs`.
- Joins each coin in the universe with its current asset context.
- Casts every numeric string to a number for clean BI imports.
- Optionally filters down to a comma-separated list of coin symbols.
- Exports as CSV, Excel, JSON, JSONL, XML, RSS, or HTML.

> 💡 **Why it matters:** Hyperliquid is the largest on-chain perp DEX. Its funding rates often diverge from CEX venues, creating real basis-trading opportunities. This actor gives you the full snapshot in one API call.

### 🎬 Full Demo

_🚧 Coming soon._

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td>Free users: 10. Paid users: up to 1,000,000. Prefill: 10.</td></tr>
<tr><td><code>coinFilter</code></td><td>string</td><td>No</td><td>Comma-separated list of coin symbols (e.g. <code>BTC,ETH,SOL</code>).</td></tr>
</table>

**Example 1 - All markets, top 10:**
```json
{ "maxItems": 10 }
````

**Example 2 - BTC and ETH only:**

```json
{ "coinFilter": "BTC,ETH", "maxItems": 50 }
```

> ⚠️ **Good to Know:** The Hyperliquid info endpoint is fully public and free. Funding rates are hourly and refresh in real time, so you can schedule this actor every hour to track the funding curve.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🪙 `coin` | string | Perp market ticker (BTC, ETH, ...). |
| 💰 `funding_rate` | number | Current 1h funding rate (decimal). |
| 📊 `open_interest` | number | Open interest in base units. |
| 📈 `premium` | number | Mark vs oracle premium. |
| 🔮 `oracle_px` | number | Oracle price. |
| 🎯 `mark_px` | number | Mark price. |
| 📦 `day_volume` | number | 24h notional volume USD. |
| 🕒 `scrapedAt` | string | When this row was fetched. |
| ❌ `error` | string | Set if the upstream response failed. |

**Sample record:**

```json
{
  "coin": "BTC",
  "funding_rate": 0.0000125,
  "open_interest": 38201.45,
  "premium": 0.0001,
  "oracle_px": 67230.5,
  "mark_px": 67235.2,
  "day_volume": 1820391284.5,
  "scrapedAt": "2026-05-29T13:00:00.000Z",
  "error": null
}
```

### ✨ Why choose this Actor

| 🆓 | Public Hyperliquid endpoint, no key needed. |
| ⛓️ | True on-chain DEX state, not aggregated. |
| 🔢 | Numeric casting on every numeric field. |
| 🛟 | Errors surfaced as a clean `error` record. |
| 🔌 | Optional coin filter. |
| 💾 | CSV / Excel / JSON / XML / RSS / HTML export. |

### 📈 How it compares to alternatives

| Approach | Setup time | Numeric casting? | Filter support? | Error handling? |
|---|---|---|---|---|
| Raw `fetch` to info endpoint | 15 min | ❌ | ❌ | ❌ |
| Python Hyperliquid SDK | 30 min | partial | partial | partial |
| **This Actor** | 5 sec | ✅ | ✅ | ✅ |

### 🚀 How to use

1. Click **Try for free**.
2. Optionally type a `coinFilter` like `BTC,ETH,SOL`.
3. Click **Start**. Your dataset is ready in seconds.

### 💼 Business use cases

**📊 Basis trading.** Pull Hyperliquid funding and compare against Binance funding to find profitable basis trades.

**💼 Risk dashboards.** Snapshot open interest across 150+ perps every hour for a desk-wide risk view.

**📰 Newsroom.** Verify on-chain perp metrics for crypto stories.

**🤖 ML.** Train funding-rate predictors on a clean historical series.

### 🔌 Automating Hyperliquid Perp Funding Scraper

- **Make / Zapier**: every hour, push funding to Airtable or Slack.
- **Cron schedule**: native Apify scheduler.
- **Webhooks**: POST to your endpoint on completion.
- **Pipe to BigQuery / Snowflake / Postgres**: native Apify integrations.

### 🌟 Beyond business use cases

**🎓 Education.** Teach a DeFi class with real on-chain data.

**🧪 Personal research.** Track funding on your favourite coins.

**🤝 Open data.** Publish a public Hyperliquid dashboard.

**🧰 Prototyping.** Spin up a feed in seconds.

### 🤖 Ask an AI assistant about this scraper

Drop this README into ChatGPT, Claude, or any AI assistant and ask it to map your workflow to the actor's inputs.

### ❓ Frequently Asked Questions

**❓ Do I need an API key?** No - the Hyperliquid info endpoint is fully public.

**❓ How often does funding refresh?** Hourly on-chain.

**❓ Can I filter coins?** Yes - use `coinFilter` with a comma-separated list.

**❓ Are numbers cast?** Yes, all numeric strings become real numbers.

**❓ What if the API is down?** A clean `{error}` record is pushed instead.

**❓ Can I schedule runs?** Yes - native Apify scheduler.

**❓ Is this scraping or API?** API. Public Hyperliquid endpoint.

**❓ Will the schema change?** Core fields are stable.

**❓ What format can I download?** CSV, Excel, JSON, JSONL, XML, RSS, HTML.

**❓ How many markets?** 150+, growing.

### 🔌 Integrate with any app

Apify ships native integrations with Make, Zapier, Slack, Discord, Google Drive, Google Sheets, Gmail, Airbyte, Keboola, Telegram, GitHub, and any REST API or webhook endpoint.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [ParseForge dYdX Markets Scraper](https://apify.com/parseforge/dydx-markets-scraper) | dYdX v4 perpetual markets snapshot. |
| [ParseForge Drift Protocol Markets Scraper](https://apify.com/parseforge/drift-protocol-markets-scraper) | Drift on-chain perps on Solana. |
| [ParseForge GMX Arbitrum Stats Scraper](https://apify.com/parseforge/gmx-arbitrum-stats-scraper) | GMX prices and open interest. |
| [ParseForge Alpha Vantage Public Scraper](https://apify.com/parseforge/alpha-vantage-public-scraper) | Stocks, FX, crypto, indicators. |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 900+ production-grade scrapers.

***

**Disclaimer:** This actor scrapes only publicly available data. ParseForge is not affiliated with, endorsed by, or sponsored by any of the third-party services referenced. Users are responsible for complying with the target site's terms of service and applicable law. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `coinFilter` (type: `string`):

Comma-separated list of coin symbols to include (e.g. BTC,ETH,SOL). Leave empty for all coins.

## Actor input object example

```json
{
  "maxItems": 10
}
```

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/hyperliquid-perp-funding-scraper").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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/hyperliquid-perp-funding-scraper").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 '{
  "maxItems": 10
}' |
apify call parseforge/hyperliquid-perp-funding-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hyperliquid Perp Funding Scraper",
        "description": "Snapshot Hyperliquid perpetual futures with coin, funding_rate, open_interest, premium, oracle_px, mark_px, and day_volume. Pass a coin filter like BTC,ETH,SOL or leave empty for the full board. Useful for funding arbitrage, basis trading, and on chain derivatives analytics.",
        "version": "0.1",
        "x-build-id": "nfdXLgTO8Uj3BPHEI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~hyperliquid-perp-funding-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-hyperliquid-perp-funding-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~hyperliquid-perp-funding-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-hyperliquid-perp-funding-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~hyperliquid-perp-funding-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-hyperliquid-perp-funding-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "coinFilter": {
                        "title": "Coin filter (optional)",
                        "type": "string",
                        "description": "Comma-separated list of coin symbols to include (e.g. BTC,ETH,SOL). Leave empty for all coins."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
