# Ironflow: Hyperliquid data (remote · mcp.ironflow.sh) Hyperliquid data and liquidation alerts for AI agents: fills, candles, funding, wallet analytics. - Trust score: 66/100 (medium) - Registry status: active - Liveness: live - Owner verified: no - Last scored: 2026-11-05 > **Recent critical change**: Authorization (2026-11-05). See the changelog below before you install this server. ## Components - remote · `mcp.ironflow.sh`: 66/100 (this document), [markdown](https://verifymcp.io/servers/ironflowsh-hyperliquid/mcp.md), [page](https://verifymcp.io/servers/ironflowsh-hyperliquid/mcp) - npm · `@ironflowsh/mcp`: 54/100, [markdown](https://verifymcp.io/servers/ironflowsh-hyperliquid/ironflowsh-mcp.md), [page](https://verifymcp.io/servers/ironflowsh-hyperliquid/ironflowsh-mcp) ## Channel facts - Endpoint: `https://mcp.ironflow.sh/mcp` - Transports: `streamable-http` - Auth: `none` - Version: `0.14.0` ## Trust breakdown How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog) Scored 2026-11-05. - **Endpoint Security**: 63/100 - The endpoint's TLS certificate is valid, in date, and uses a strong key. - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (delete_liquidation_alert). - HTTPS is enforced; there's no plaintext access path. - The HSTS (Strict-Transport-Security) header is present. - DNSSEC check failed: this domain isn't protected by DNSSEC. - **Transport & Reachability**: 100/100 - Verified streamable-http transport via a live MCP handshake. - **Schema Quality & AI Usability**: 67/100 - AI-judged instruction clarity (excellent). - Context-footprint check failed: tool/resource definitions use about 7189 tokens (~159/item across 45 items; 45 tools + 0 resources), over budget; trim descriptions and params. - Usage-examples check failed: none of the tools include examples. - **Stability & Change Management**: 7/100 - Stability observed for 2 of 30 days with no destabilising changes; credit accrues until the full window elapses. - **Tool Coverage**: 100/100 - 100% of tools have a non-trivial description (not blank, and not just the tool's name). - 100% of tool parameters carry a description. - Structured output schemas are declared (100% of tools); any adoption earns full credit. - **Tool Safety**: 100/100 - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured. - All 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation. - An AI judge read all 46 captured unit(s) of tool text and found none that tries to manipulate the model reading it. - **Capabilities**: 100/100 - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28. ## Install ### How do I install the Ironflow: Hyperliquid data MCP server? Ironflow: Hyperliquid data is a hosted endpoint at https://mcp.ironflow.sh/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation. ### Claude ```bash claude mcp add --transport http ironflowsh-hyperliquid 'https://mcp.ironflow.sh/mcp' ``` ### Cursor ```json { "mcpServers": { "ironflowsh-hyperliquid": { "url": "https://mcp.ironflow.sh/mcp" } } } ``` ### VS Code ```json { "servers": { "ironflowsh-hyperliquid": { "type": "http", "url": "https://mcp.ironflow.sh/mcp" } } } ``` ### Codex ```toml [mcp_servers.ironflowsh-hyperliquid] url = "https://mcp.ironflow.sh/mcp" ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "ironflowsh-hyperliquid": { "type": "remote", "url": "https://mcp.ironflow.sh/mcp", "enabled": true } } } ``` ### OpenClaw ```bash openclaw mcp add ironflowsh-hyperliquid --url 'https://mcp.ironflow.sh/mcp' --transport streamable-http ``` ### Hermes ```yaml mcp_servers: ironflowsh-hyperliquid: url: "https://mcp.ironflow.sh/mcp" ``` ### Netclaw ```json { "McpServers": { "ironflowsh-hyperliquid": { "Transport": "http", "Url": "https://mcp.ironflow.sh/mcp" } } } ``` ### Vellum ```bash assistant mcp add ironflowsh-hyperliquid -t streamable-http -u 'https://mcp.ironflow.sh/mcp' ``` ### Other ```json { "mcpServers": { "ironflowsh-hyperliquid": { "type": "http", "url": "https://mcp.ironflow.sh/mcp" } } } ``` The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs. ## Changelog Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims. ### 2026-11-05 (score 66, −7) - [critical regression] Authorization: partial → fail - [security] The server rewrote its instructions, which are the text every model session reads - [security] New tool “delete_liquidation_alert”, which the server declares destructive - [security] Tool “describe_data” rewrote its description, which is the text the model reads - [security] Tool “run_query” rewrote its description, which is the text the model reads - [security] Tool “get_user_funding” rewrote its description, which is the text the model reads - [security] Tool “get_liquidation_levels” rewrote its description, which is the text the model reads - [security] Tool “get_auto_deleveraging” rewrote its description, which is the text the model reads - [functional regression] Schema quality: 6169 → 7189 - [functional] Destructive annotations: pass → 100 - [functional] Server version: 0.13.2 → 0.14.0 - [functional] Server version: 0.13.0 → 0.13.2 - [functional] Server version: 0.12.0 → 0.13.0 - [functional] New tool “test_liquidation_alert” - [functional] New tool “list_liquidation_alerts” - [functional] New tool “create_liquidation_alert” - [functional] New tool “get_outcome_markets” ### 2026-11-04 (score 73, +1) - [security] Tool “get_liquidation_summary” rewrote its description, which is the text the model reads - [functional regression] Schema quality: 5263 → 6169 - [functional improvement] Stability: unverified → 0.03 - [functional] Schema quality: good → excellent - [functional] Server version: 0.11.5 → 0.12.0 - [functional] Server version: 0.11.3 → 0.11.5 - [functional] New tool “get_premium” - [functional] New tool “get_auto_deleveraging” - [functional] New tool “get_open_interest_changes” - [functional] New tool “get_positions_at” - [cosmetic] “get_liquidation_summary” added an optional parameter “window” - [cosmetic] “get_liquidation_summary” reworded the description of “market” - [cosmetic] “get_liquidation_summary” reworded the description of “minutes” ### 2026-11-03 (score 72) First indexed and scored. ## MCP tools (45) ### `describe_data` (~90 tokens) Describe SQL tables Returns the SQL tables of Ironflow's Hyperliquid data (every fill and trade, per-market hourly volume and liquidation totals, per-wallet daily totals, wallet behaviour labels, funding rates and per-wallet funding payments, mark and oracle prices, open interest, liquidations, builder-code fills, transfers, vault flows), their columns, how far back each goes, query tips, worked examples and your own limits. Output parameters: - `dialect`: SQL dialect and database name - `examples` (array): Worked examples - `limits`: Your tier's limits: history_days, max_execution_seconds, max_rows, budget_seconds_per_hour - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `tables` (array): Queryable tables - `tiers` (array): Every tier's limits - `tips` (array): Query tips ### `run_query` (~225 tokens) Run SQL query Run one read-only ClickHouse SELECT over Ironflow's Hyperliquid tables (hl.fills, hl.trades, hl.wallet_fills, hl.wallet_daily, hl.wallet_behavior, hl.market_hourly, hl.funding, hl.funding_payments, hl.mark_prices, hl.oracle_prices, hl.open_interest, hl.liquidations, hl.builder_fills, hl.transfers, hl.vault_operations). For volume, taker flow or liquidation totals per market over hours to months read hl.market_hourly, not hl.fills; call describe_data for columns. Aggregate in SQL: results are capped (1,000 rows keyless). Keyless: last 24 hours, 5 s per query, 60 query seconds per hour per IP; a free key from https://ironflow.sh/key gives 30 days of history. Input parameters: - `max_rows` (number): Most rows to return (default 200, capped by your tier) - `sql` (string, required): One ClickHouse SELECT (or WITH ... SELECT) over hl.* tables, without a FORMAT clause Output parameters: - `budget_remaining_seconds`: Query seconds left this hour - `column_types` (array): ClickHouse types in row order - `columns` (array): Column names in row order - `limits`: Your tier's limits - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `row_count`: Rows returned - `rows` (array): Rows as positional arrays - `stats`: elapsed_ms, rows_read, bytes_read - `truncated`: true when more rows existed than were returned ### `get_wallet_behavior` (~196 tokens) Wallet behavior labels How Hyperliquid wallets trade, from their last 30 days: labels (market_maker, high_frequency, whale, directional, consistent_winner, big_loser, revenge_sizing, often_liquidated, hip3_trader, spot_trader, prediction_trader) and the numbers behind them (maker share, buy/sell imbalance, fills per day, green-day share, profit factor, liquidations). Look up specific addresses, or list wallets with one label. Input parameters: - `addresses` (string): Comma-separated wallet addresses (up to 50). Omit to list wallets instead. - `label` (string): Only wallets carrying this label - `limit` (number): Wallets to return (default 20, max 100) - `min_volume_usd` (number): Only wallets with at least this 30-day volume - `sort_by` (string): Sort order when listing (default volume) Output parameters: - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `wallets` (array): Wallets - `window_days`: Days the features cover ### `get_price` (~131 tokens) Market price Latest mark price of one Hyperliquid market as a single number: native perps, HIP-3 builder perps (e.g. xyz:NVDA-PERP) and spot. The quickest answer to 'what is X trading at'. For the oracle price and funding use get_mark_prices; for price history use get_candles; to compare many markets at once use get_markets_snapshot. Input parameters: - `market` (string, required): Market: BTC-PERP, xyz:NVDA-PERP, HYPE/USDC, or a Hyperliquid name (BTC, @107, xyz:NVDA) Output parameters: - `market`: Display symbol, e.g. "BTC-PERP" or "xyz:NVDA-PERP" - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `price`: Price in USD ### `get_recent_trades` (~114 tokens) Recent trades Latest tick-level trades on a Hyperliquid market from our own nodes: price, size, side and block time. Covers native perps, HIP-3 builder markets, HIP-4 outcomes and spot. Input parameters: - `limit` (number): Number of trades to return (1-100, default 20) - `market` (string, required): Market: BTC-PERP, xyz:NVDA-PERP, HYPE/USDC, or a Hyperliquid name (BTC, @107, xyz:NVDA) Output parameters: - `data` (array): Trades, newest first - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `pagination` (object): Cursor pagination ### `get_candles` (~196 tokens) Candles (OHLCV) OHLCV candles for one Hyperliquid market, built from every trade: open, high, low, close, volume and trade count per candle, oldest first. Returns the latest 24 candles by default (up to 500), at 1m to 1d intervals. Use it for price history, ranges and charts. For only the current price use get_price; for individual trades use get_recent_trades. Input parameters: - `interval` (string): Candle interval (1m, 5m, 15m, 1h, 4h, 1d). Default: 1h - `limit` (number): Number of candles to return (1-500, default 24) - `market` (string, required): Market: BTC-PERP, xyz:NVDA-PERP, HYPE/USDC, or a Hyperliquid name (BTC, @107, xyz:NVDA) Output parameters: - `data` (array): OHLCV candles - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `pagination` (object): Cursor pagination ### `get_funding_rates` (~100 tokens) Funding rate history Hourly funding rate history for a Hyperliquid perp, including HIP-3 builder perps. A positive rate means longs pay shorts. Input parameters: - `limit` (number): Number of funding rate entries (1-100, default 10) - `market` (string, required): Market: BTC-PERP, xyz:NVDA-PERP, HYPE/USDC, or a Hyperliquid name (BTC, @107, xyz:NVDA) Output parameters: - `data` (array): Hourly funding rates - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `pagination` (object): Cursor pagination ### `get_open_interest` (~122 tokens) Open interest Latest open interest of one Hyperliquid perp in units of the base asset (BTC for BTC-PERP), with its 24-hour traded volume in USD and the time of the reading. Multiply by get_price for open interest in USD. To compare open interest across markets use get_markets_snapshot; for its history use run_query (see describe_data). Input parameters: - `market` (string, required): Market: BTC-PERP, xyz:NVDA-PERP, HYPE/USDC, or a Hyperliquid name (BTC, @107, xyz:NVDA) Output parameters: - `data` (array): Open interest samples - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `pagination` (object): Cursor pagination ### `get_open_interest_changes` (~245 tokens) Open interest movers Hyperliquid perps ranked by how their open interest moved over the last 1h, 4h, 24h or 7d: open interest at the start and now (in coins), the change in USD at the latest mark and in percent. Sorted by the size of the USD change by default, or by percent. Filter to one HIP-3 dex (xyz) or to native perps only. Markets with less than $100k of open interest at both ends are left out unless you lower min_oi_usd. Use it for 'where is money flowing in or out'. For one market's latest open interest use get_open_interest. Input parameters: - `dex` (string): Optional: a HIP-3 dex such as xyz, or native for validator-run perps - `limit` (number): Number of markets (1-200, default 25) - `min_oi_usd` (number): Leave out markets below this open interest in USD (default 100000) - `sort` (string): Rank by USD change (default) or percent change - `window` (string): Lookback window (default 24h) Output parameters: - `count`: Markets returned - `data` (array): Markets - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `sort`: usd or pct - `window`: Lookback window: 1h, 4h, 24h or 7d ### `get_outcome_markets` (~193 tokens) HIP-4 outcome markets overview Hyperliquid HIP-4 outcome markets (prediction markets on sports, central bank decisions, IPOs and daily BTC price contracts) over the last 4 hours, 1 day or 1 week: total volume, fills, wallets and active markets, plus the most traded outcomes with their last price (the implied probability, 0 to 1) and last-24-hour volume. Each outcome has a Yes and a No side whose prices sum to 1. For one outcome's trades or candles pass its symbol to get_recent_trades or get_candles; settled outcomes stay queryable. For per-wallet outcome activity use run_query on hl.wallet_daily with market_class = 'prediction'. Input parameters: - `limit` (number): Number of outcomes to return, most traded first (1-200, default 20) - `window` (string): Lookback window for the totals (default 1d) Output parameters: - `computed_at`: When the summary was computed, Unix seconds - `fills_total`: Fills over the window - `markets_active`: Outcome markets listed now - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `notional_total`: Volume in USD over the window - `top_markets` (array): Most traded outcomes, highest 24h volume first - `wallets_total`: Wallets that traded over the window - `window_hours`: Window of the totals, in hours ### `get_premium` (~212 tokens) Mark against oracle premium A Hyperliquid perp's mark price against its oracle price over time, with the premium in basis points ((mark / oracle - 1) x 10,000) per bucket and a summary (latest, mean, min, max). On HIP-3 stock, index and commodity perps such as xyz:NVDA-PERP, xyz:GOLD-PERP or xyz:SP500-PERP the oracle follows the underlying, so this shows how far the perp trades from what it tracks, weekends included. Default 1h buckets over the last 7 days. For funding payments use get_funding_rates. Input parameters: - `days` (number): How many days back (default 7; limited by your key's history window) - `interval` (string): Bucket size (default 1h) - `market` (string, required): Market: BTC-PERP, xyz:NVDA-PERP, HYPE/USDC, or a Hyperliquid name (BTC, @107, xyz:NVDA) Output parameters: - `data` (array): Buckets, oldest first - `interval`: Bucket size - `market`: Display symbol, e.g. "BTC-PERP" or "xyz:NVDA-PERP" - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `summary` (object): Premium over the window, in basis points ### `get_liquidations` (~108 tokens) Liquidations Liquidations on a Hyperliquid perp, read from our own nodes: price, size, side and the liquidated wallet. Hyperliquid's public API has no liquidation feed. Input parameters: - `limit` (number): Number of liquidation events (1-100, default 20) - `market` (string, required): Market: BTC-PERP, xyz:NVDA-PERP, HYPE/USDC, or a Hyperliquid name (BTC, @107, xyz:NVDA) Output parameters: - `data` (array): Liquidations - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `pagination` (object): Cursor pagination ### `create_liquidation_alert` (~371 tokens) Create liquidation alert Have Ironflow post Hyperliquid liquidations to the user's Discord channel, Slack channel, Telegram chat or HTTPS webhook as they happen (within seconds), filtered by market, side, size and wallet. It keeps running after the conversation: use it when the user wants to be told about liquidations, not just to see them now. Needs an API key (free key: 1 alert; Explorer 5; Builder 20). Give url (a Discord channel webhook from channel settings, Integrations, Webhooks, Copy Webhook URL; a Slack incoming webhook; or any public https URL) or telegram_chat (then tell the user to add the bot named in the result's setup to that chat). A plain webhook gets signed JSON, and its signing_secret appears only in this result, so pass it on. Then call test_liquidation_alert to check that it arrives. Input parameters: - `address` (string): Only this wallet's liquidations (0x...) - `markets` (string): Comma-separated markets, e.g. BTC,ETH-PERP,xyz:NVDA (Hyperliquid names work); omit for every market - `min_usd` (number): Smallest liquidation to report, in USD (default 0; 100000 keeps a channel readable) - `name` (string): Label shown in each message, e.g. BTC whales - `side` (string): Which positions: long = longs liquidated (default any) - `telegram_chat` (string): A Telegram chat instead of url: @channel or group name, or a numeric chat id (-100...) - `url` (string): Where to post: https://discord.com/api/webhooks/..., https://hooks.slack.com/services/... or a public https URL (or use telegram_chat) Output parameters: - `address`: Only this wallet, when set - `created_at`: Creation time, RFC 3339 - `destination`: Host it posts to, without the secret part of the URL - `failures`: Failed deliveries in a row - `id`: Alert id (UUID) - `last_error`: The destination's last error - `last_sent_at`: Last delivery, RFC 3339; null before the first - `markets`: Markets watched; empty means every market - `min_usd`: Smallest liquidation reported, USD - `name`: Label shown in each message - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `sent_count`: Liquidations delivered so far - `setup`: What to do before the first message arrives (Telegram: the bot to add to the chat) - `side`: any, long (longs liquidated) or short - `signing_secret`: Webhooks only: HMAC key for the X-Ironflow-Signature header, shown only here - `status`: active or disabled (after 20 failed deliveries in a row) - `type`: webhook, discord, slack or telegram ### `list_liquidation_alerts` (~92 tokens) List liquidation alerts The Hyperliquid liquidation alerts on this API key's account: where each posts (host only), its filter, whether it is active, failed deliveries in a row with the last error, liquidations sent so far, and how many alerts the tier allows. An alert is disabled after 20 failed deliveries in a row; test_liquidation_alert re-enables it once the destination works again. Output parameters: - `alerts` (array): Alerts - `limit`: Alerts this tier allows - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key ### `test_liquidation_alert` (~89 tokens) Test liquidation alert Send a sample Hyperliquid liquidation, marked as a test, to an alert's destination now and report whether it arrived (delivered true or false, with the destination's answer). A delivered test switches a disabled alert back on. One test per alert every 10 seconds. Input parameters: - `id` (string, required): Alert id from create_liquidation_alert or list_liquidation_alerts Output parameters: - `delivered`: Whether the destination accepted the test message - `error`: The destination's answer when it was not delivered - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `status`: The alert's status afterwards ### `delete_liquidation_alert` (~51 tokens) Delete liquidation alert Stop and remove one Hyperliquid liquidation alert from this API key's account; nothing more is sent to its destination. Input parameters: - `id` (string, required): Alert id from list_liquidation_alerts Output parameters: - `deleted`: true - `id`: The deleted alert's id - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key ### `get_auto_deleveraging` (~177 tokens) Auto-deleveraging fills Hyperliquid auto-deleveraging (ADL) fills, newest first, across all markets or one: profitable positions Hyperliquid closed to cover a liquidation its backstop could not absorb. Per fill: wallet, market, side, price, size, notional, realized PnL, trade id (shared with the liquidated side) and transaction hash. Recorded from 2026-08-01; the default window is the last 7 days. For the liquidated side use get_liquidations. Input parameters: - `days` (number): How many days back (default 7) - `limit` (number): Number of fills (1-1000, default 100) - `market` (string): Optional market filter: BTC-PERP or a Hyperliquid name (BTC, xyz:NVDA) Output parameters: - `count`: Fills returned - `data` (array): ADL fills - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `recorded_from`: First moment recorded, Unix milliseconds ### `get_liquidation_summary` (~211 tokens) Liquidation summary Liquidations on Hyperliquid over a trailing window, totalled across every market or the ones named: count, wallets, notional, longs vs shorts liquidated, the top markets and the largest single liquidation with its price. Use it for 'who got liquidated in the last hour?' or 'how much was liquidated today?'. For the individual liquidations use get_liquidations; for liquidation prices still ahead use get_liquidation_levels. Windows from 15m to 24h without a key, 7d with one. Totals are computed by the API over every liquidation, not sampled. Input parameters: - `market` (string): Optional: one market or a comma list (BTC-PERP,ETH-PERP); Hyperliquid names work (BTC, xyz:NVDA) - `minutes` (number): Older form of window, rounded up to the next one (90 becomes 4h) - `window` (string): Trailing window. Default 1h Output parameters: - `by_market` (array): Top markets by liquidated notional - `complete`: Always true: totals cover every liquidation in the window - `count`: Number of liquidations - `from`: Window start, Unix milliseconds - `largest` (object): Largest single liquidation, or null when there were none - `longs_liquidated_usd`: Notional of liquidated longs in USD - `market`: Market filter, or null for all markets - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `notional_usd`: Liquidated notional in USD - `shorts_liquidated_usd`: Notional of liquidated shorts in USD - `to`: Window end, Unix milliseconds - `wallets`: Distinct wallets liquidated - `window`: Trailing window, e.g. 1h ### `get_fills` (~121 tokens) Wallet fills Every fill for one Hyperliquid wallet, optionally for one market, from indexed history: price, size, side, fee and realized PnL. Hyperliquid's own userFills endpoints stop at the 10,000 most recent fills. Input parameters: - `address` (string, required): Wallet address (e.g. 0x...) - `limit` (number): Number of fills (1-100, default 20) - `market` (string): Optional market filter: BTC-PERP or a Hyperliquid name (BTC, xyz:NVDA) Output parameters: - `data` (array): Fills for one wallet, newest first - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `pagination` (object): Cursor pagination ### `get_mark_prices` (~153 tokens) Mark and oracle price Latest mark price, oracle price and current hourly funding rate of one Hyperliquid perp, with the time of the reading. The funding rate is a fraction per hour (0.0000125 = 0.00125%); positive means longs pay shorts. Use it when you need the oracle price or funding next to the mark, for example for basis or premium. For only the price use get_price, for funding history get_funding_rates, and for many markets at once get_markets_snapshot. Input parameters: - `market` (string, required): Market: BTC-PERP, xyz:NVDA-PERP, HYPE/USDC, or a Hyperliquid name (BTC, @107, xyz:NVDA) Output parameters: - `data` (array): Mark price samples - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `pagination` (object): Cursor pagination ### `get_vault_operations` (~117 tokens) Vault deposits and withdrawals Deposits into and withdrawals from one Hyperliquid vault or one depositor. Pass vault, address, or both; at least one is required (HLP is 0xdfc24b077bc1425ad1dea75bcb6f8158e10df303). Input parameters: - `address` (string): Depositor address (vault or address is required) - `limit` (number): Number of events (1-100, default 20) - `vault` (string): Vault address (vault or address is required) Output parameters: - `data` (array): Vault deposits and withdrawals - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `pagination` (object): Cursor pagination ### `get_liquidation_levels` (~141 tokens) Liquidation levels Liquidated notional on a Hyperliquid perp bucketed by price: where longs and shorts were wiped out. Needs an API key (a free key works, https://ironflow.sh/key); keyless calls return 403. Input parameters: - `bucket_size` (string): Price bucket size (1, 5, 10, 50, 100, 500, 1000, 5000). Default: 100 - `market` (string, required): Market: BTC-PERP, xyz:NVDA-PERP, HYPE/USDC, or a Hyperliquid name (BTC, @107, xyz:NVDA) Output parameters: - `data` (array): Price buckets - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key ### `get_vault_leaderboard` (~87 tokens) Vault leaderboard Hyperliquid vaults ranked by net deposits (deposits minus withdrawals) over the last 7 days, with depositor counts. Keyless calls see the last 24 hours; a free key from https://ironflow.sh/key gives the full 7 days. Input parameters: - `limit` (number): Number of vaults (default 10, max 1000) Output parameters: - `data` (array): Vaults - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `window_days`: Days covered (keyless: 1); absent when served by the Builder endpoint ### `get_funding_stats` (~123 tokens) Funding statistics Funding statistics per time bucket for a Hyperliquid perp: average, minimum, maximum and annualized rate. Input parameters: - `interval` (string): Time interval (1h, 4h, 8h, 1d, 7d). Default: 1d - `limit` (number): Number of data points (default 7) - `market` (string, required): Market: BTC-PERP, xyz:NVDA-PERP, HYPE/USDC, or a Hyperliquid name (BTC, @107, xyz:NVDA) Output parameters: - `data` (array): Buckets - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key ### `get_user_state` (~66 tokens) Wallet positions Open positions and unrealized PnL for a Hyperliquid wallet right now, across native and HIP-3 perps. Use it for questions like 'is this wallet long or short?' Input parameters: - `address` (string, required): 0x-prefixed 20-byte hex address Output parameters: - `address`: Wallet address (0x…) - `as_of_ts`: Snapshot time, Unix milliseconds - `asset_positions` (array): Open positions - `margin_summary` (object): Account totals - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key ### `get_positions_at` (~191 tokens) Wallet positions at a past time Exact perp positions one Hyperliquid wallet held at a past moment, up to 90 days back: market, side, signed size, mark price and notional at that moment, plus today's size and how many fills it made since. Built from Hyperliquid's live positions minus the wallet's fills after that moment, so sizes are exact across native and HIP-3 perps. Needs a free API key; how far back you can go follows the key's history window. Use it for questions like 'what was this wallet holding before the crash'. For positions right now use get_user_state; for trades in between use get_fills. Input parameters: - `address` (string, required): 0x-prefixed 20-byte hex address - `at` (string, required): The past moment: ISO 8601 (2026-11-01T12:00:00Z), unix seconds or unix milliseconds Output parameters: - `address`: Wallet address (0x…) - `at`: The moment, Unix milliseconds - `count`: Positions returned - `method`: How the sizes were rebuilt - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `positions` (array): Positions, largest notional first ### `get_user_funding` (~221 tokens) Wallet funding payments Funding a Hyperliquid wallet paid or received, per market per bucket: Hyperliquid's own ledger, every hourly payment back to September 2025 (Hyperliquid's API returns only daily totals that far back). Positive means received, negative means paid. bucket=1d gives daily totals, 1h the hourly payments. Input parameters: - `address` (string, required): 0x-prefixed 20-byte hex address - `bucket` (string): Aggregation bucket; default 1d - `from` (string): Window start: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z) - `limit` (number): Most recent rows to return (default 200) - `market` (string): Optional market filter: BTC-PERP or a Hyperliquid name (BTC, xyz:NVDA) - `to` (string): Window end: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z) Output parameters: - `address`: Wallet address (0x…) - `bucket`: Bucket size - `data` (array): Buckets - `from`: Window start, Unix milliseconds - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `returned`: Rows in data, most recent first - `to`: Window end, Unix milliseconds - `total_rows`: Rows in the window before the limit ### `get_user_maker_taker` (~159 tokens) Wallet maker/taker split Maker vs taker breakdown of a Hyperliquid wallet's fills per market: volume, fees and rebates. A high maker share with negative maker fees marks a market maker. Input parameters: - `address` (string, required): 0x-prefixed 20-byte hex address - `from` (string): Window start: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z) - `market` (string): Optional market filter: BTC-PERP or a Hyperliquid name (BTC, xyz:NVDA) - `to` (string): Window end: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z) Output parameters: - `address`: Wallet address (0x…) - `data` (array): Per market - `from`: Window start, Unix milliseconds - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `to`: Window end, Unix milliseconds - `total` (object): All markets ### `get_user_ledger` (~185 tokens) Wallet ledger Vault deposits, withdrawals and transfers for a Hyperliquid wallet. Positive amounts go into the account. Account deposits and withdrawals are recorded only up to 2026-06-06. Input parameters: - `address` (string, required): 0x-prefixed 20-byte hex address - `event_types` (string): Comma-separated type filter (deposit,withdrawal,vault_deposit,vault_withdraw,vault_transfer_in,vault_transfer_out) - `from` (string): Window start: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z) - `limit` (number): Max entries, default 1000, cap 10000 - `to` (string): Window end: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z) Output parameters: - `address`: Wallet address (0x…) - `data` (array): Ledger entries - `from`: Window start, Unix milliseconds - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `to`: Window end, Unix milliseconds ### `get_pnl_leaderboard` (~152 tokens) PnL leaderboard Every Hyperliquid wallet ranked by realized PnL, biggest losses or volume over a window. Wallets with fewer than 5 fills in the window are left out. Input parameters: - `from` (string): Window start: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z). Default 30 days ago - `limit` (number): Number of rows, max 200, default 50 - `sort_by` (string): Ranking metric - `to` (string): Window end: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z). Default now Output parameters: - `data` (array): Wallets - `from`: Window start, Unix milliseconds - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `sort_by`: Ranking metric - `to`: Window end, Unix milliseconds ### `get_market_top_wallets` (~180 tokens) Top wallets in a market Top wallets on one Hyperliquid market by volume or realized PnL, up to 200 rows. Input parameters: - `from` (string): Window start: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z). Default 24 hours ago - `limit` (number): Number of rows, max 200, default 25 - `market` (string, required): Market: BTC-PERP, xyz:NVDA-PERP, HYPE/USDC, or a Hyperliquid name (BTC, @107, xyz:NVDA) - `sort_by` (string): Ranking metric - `to` (string): Window end: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z). Default now Output parameters: - `data` (array): Wallets - `from`: Window start, Unix milliseconds - `market`: Display symbol, e.g. "BTC-PERP" or "xyz:NVDA-PERP" - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `sort_by`: Ranking metric - `to`: Window end, Unix milliseconds ### `get_markets_snapshot` (~201 tokens) Markets snapshot Active Hyperliquid markets ranked in one call: mark price, 24h change, 24h volume, open interest and current hourly funding. Sort by abs_funding for the most extreme funding, abs_change_24h for the biggest movers, or volume (default). Use min_volume_usd to skip illiquid markets. Returns the top 25 unless limit is set. Input parameters: - `issuer` (string): HIP-3 builder code (e.g. 'xyz'). Omit to include every issuer. - `limit` (number): Rows to return (1-200, default 25) - `market_class` (string): Filter to one class - `min_volume_usd` (number): Skip markets with less 24h volume than this (USD) - `order` (string): desc (default) or asc - `sort_by` (string): Ranking key (default volume). funding_rate is hourly; positive means longs pay shorts. Output parameters: - `data` (array): Ranked markets - `matched`: Markets past the volume floor - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `order`: desc or asc - `returned`: Rows in data - `sort_by`: Ranking key used - `total_markets`: Active markets before filtering ### `get_user_summary` (~212 tokens) Wallet summary Totals for one Hyperliquid wallet over a time range (default the last 24 hours): fill count, volume in USD, realized PnL, fees, wins, losses, win rate and maker versus taker share, plus its current account state (open positions and margin). Use it for questions like 'how much did this wallet trade or make this week'. For a scored record with profit factor, drawdown and a per-market breakdown use get_trader_profile; for PnL over time use get_user_pnl_series. Input parameters: - `address` (string, required): 0x-prefixed 20-byte hex address - `from` (string): Window start: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z). Default 24 hours ago - `to` (string): Window end: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z). Default now Output parameters: - `address`: Wallet address (0x…) - `from`: Window start, Unix milliseconds - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `state` (object): Open positions right now - `to`: Window end, Unix milliseconds - `window` (object): Window totals ### `get_wallet_labels` (~120 tokens) Wallet labels Labels for notable Hyperliquid wallets: top whales by 24h volume, top traders by 30-day realized PnL, vaults and vault leaders. Pass addresses to check specific wallets; without them it lists the whales and smart money. Input parameters: - `addresses` (string): Comma-separated wallet addresses to look up - `smart_top_n` (number): Top N smart-money wallets to include (max 500, default 100) - `whale_top_n` (number): Top N whales to include (max 500, default 100) Output parameters: - `counts`: Wallets per label kind - `generated_at`: Unix milliseconds - `labels` (object): Address to its labels - `note`: What the labels map includes - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `source`: Venue, always hyperliquid - `ttl_seconds`: Cache lifetime ### `get_user_pnl_series` (~209 tokens) Wallet PnL curve Realized PnL of one Hyperliquid wallet over time: buckets with realized PnL and fees paid in each, by default daily over the last 30 days. Add the buckets up for a running PnL curve. Realized only: unrealized PnL on open positions is in get_user_state. For totals over a range use get_user_summary. Input parameters: - `address` (string, required): 0x-prefixed 20-byte hex address - `bucket_ms` (number): Bucket size in milliseconds: 3600000 for hourly, 86400000 for daily (default) - `from` (string): Window start: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z). Default 30 days ago - `to` (string): Window end: Unix ms or seconds, or ISO 8601 (2026-10-01T00:00:00Z). Default now Output parameters: - `address`: Wallet address (0x…) - `bucket`: Bucket size - `data` (array): Buckets - `from`: Window start, Unix milliseconds - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `to`: Window end, Unix milliseconds ### `get_top_traders` (~118 tokens) Top traders Hyperliquid traders ranked across all markets by results over 7, 30 or 90 days: win rate, profit factor, realized PnL, max drawdown and best markets. sort=top ranks by realized PnL, lowrisk by smallest max drawdown, new by most recently first seen. Input parameters: - `limit` (number): Number of traders (1-50, default 20) - `sort` (string): Ranking. Default top - `window` (string): Lookback window. Default 30d Output parameters: - `aggregate` (object): Totals - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `sort`: Ranking used - `traders` (array): Traders - `window`: Lookback window, e.g. "30d" ### `get_market_leaders` (~114 tokens) Market leaders The best traders on one Hyperliquid market, ranked by profit factor then win rate, among wallets with at least 5 closed trades there. Input parameters: - `limit` (number): Number of traders (1-50, default 20) - `market` (string, required): Market: BTC-PERP, xyz:NVDA-PERP, HYPE/USDC, or a Hyperliquid name (BTC, @107, xyz:NVDA) - `window` (string): Lookback window. Default 30d Output parameters: - `market`: Display symbol, e.g. "BTC-PERP" or "xyz:NVDA-PERP" - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `traders` (array): Traders - `window`: Lookback window, e.g. "30d" ### `get_early_movers` (~242 tokens) Early movers Wallets whose large orders (at least $10k) on one Hyperliquid market tended to come before price moved their way within 30 minutes, over the last 7 or 30 days. Per wallet: the number of scored orders, their total notional, a lead score (notional-weighted average 30-minute move in the order's direction, in basis points), a hit rate (share of orders followed by a move their way), the last order time and the share of its large orders cancelled without a fill. Needs at least 5 scored orders per wallet; the response states the formulas. Use it to find wallets worth watching on one market, then check them with get_trader_profile or get_user_state. Past activity does not predict future results. Input parameters: - `limit` (number): Number of wallets (1-25, default 10) - `market` (string, required): Market: BTC-PERP, xyz:NVDA-PERP, HYPE/USDC, or a Hyperliquid name (BTC, @107, xyz:NVDA) - `window` (string): Lookback window. Default 30d Output parameters: - `formula`: How the lead score is computed - `market`: Display symbol, e.g. "BTC-PERP" or "xyz:NVDA-PERP" - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `signals` (array): Wallets - `window`: Lookback window, e.g. "30d" ### `get_trader_profile` (~173 tokens) Trader profile How good and how risky one Hyperliquid trader is over 7, 30 or 90 days, rebuilt from its fills: overall win rate, profit factor, trade count, realized PnL and max drawdown; the same numbers per market; its liquidations; and its trades from open to close with direction, timing and peak size. Use it to vet a wallet before following it. For plain totals over any time range use get_user_summary; for positions open right now use get_user_state; for style labels such as market_maker use get_wallet_behavior. A 90d window on a very active wallet can take several seconds. Input parameters: - `address` (string, required): 0x-prefixed 20-byte hex address - `window` (string): Lookback window. Default 30d Output parameters: - `address`: Wallet address (0x…) - `liquidation_count`: Liquidations in the window - `markets` (array): Best markets, ranked - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `overall` (object): Headline stats - `trades`: Recent round-trip trades - `window`: Lookback window, e.g. "30d" ### `list_cohorts` (~61 tokens) List cohorts List available address cohorts: six predefined groups (top_pnl_30d, high_volume_30d, whale_fills, net_withdrawers_7d, liquidation_prone, vault_whales) plus any custom cohorts the caller has created Output parameters: - `data` (array): Cohorts - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key ### `get_cohort_addresses` (~159 tokens) Cohort addresses Wallet addresses in one named cohort: up to 100, each with the value the cohort ranks by (realized PnL in USD for top_pnl_30d, volume in USD for high_volume_30d), and fetched_at, when the cohort was last computed. Call list_cohorts first for the names and what each one selects. Feed the addresses to get_user_summary, get_trader_profile or get_wallet_behavior to look at each wallet. Input parameters: - `name` (string, required): Cohort name from list_cohorts: top_pnl_30d, high_volume_30d, whale_fills, net_withdrawers_7d, liquidation_prone, vault_whales, or a custom cohort you created Output parameters: - `addresses` (array): Wallets - `fetched_at`: Unix milliseconds - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key ### `get_status` (~26 tokens) API status Ironflow service status right now: overall state, data freshness per venue and component health. Output parameters: - `components`: data_pipeline, rest_api and streaming health - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `platform`: Event and market counts - `status`: operational, degraded or down - `timestamp`: Unix milliseconds - `uptime`: Time since the last incident - `venues`: Freshness per venue ### `get_status_metrics` (~29 tokens) API performance metrics Ironflow performance over rolling windows: API latency and error rate, ingestion lag and synthetic probe timings. Output parameters: - `api`: Latency and error rate - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `pipeline`: Ingestion latency and throughput - `synthetic`: Synthetic probe latencies - `timestamp`: Unix milliseconds ### `get_status_history` (~115 tokens) API uptime history Ironflow's own uptime over the last 24 hours (default) or 7 days: points over the period, each with the service status and how fresh the data was in seconds, plus the overall uptime percent. Use it to check whether a gap or odd value in other results came from an Ironflow outage. For the status right now use get_status; for API latency and error rates use get_status_metrics. Input parameters: - `period` (string): Lookback window. '24h' (default) or '7d'. Output parameters: - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `period`: 24h or 7d - `points` (array): Hourly buckets - `uptime_percent`: Share of operational hours ### `list_markets` (~253 tokens) List markets Find how a Hyperliquid market is named: perps (native and HIP-3), spot and live HIP-4 outcomes, with symbol, class, issuer, base asset and Hyperliquid coin. Search with q (q=nvda finds xyz:NVDA-PERP and the other NVDA perps). Pages of up to 100 rows; pass pagination.next_cursor as cursor for the next page. Input parameters: - `cursor` (string): pagination.next_cursor from the previous page, with the same filters - `include_inactive` (boolean): Also return closed markets (delisted, settled HIP-4 outcomes), which carry active_to_ms. Default false. - `issuer` (string): HIP-3 issuer code (e.g. 'xyz'). '' returns native markets only. Omit for every issuer. - `limit` (number): Rows per page (default 100, max 100) - `market_class` (string): Only this class. 'prediction' is HIP-4 outcomes. Omit for all. - `q` (string): Case-insensitive search over symbol, base asset, Hyperliquid coin and issuer - `source` (string): Venue. Default 'hyperliquid'. Output parameters: - `data` (array): Markets - `matched`: Markets matching the filters and search, across all pages - `notice`: Present when the API added a note: how a market name was read, that data starts later than asked because of the history window, or a next step such as a free key - `pagination` (object): Cursor pagination - `returned`: Rows in data ## Diagnostics Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/ironflowsh-hyperliquid/mcp#diagnostics ## Score history - 2026-11-05: 66 - 2026-11-04: 73 - 2026-11-03: 72 ## Common questions ### What is the Ironflow: Hyperliquid data MCP server? Ironflow: Hyperliquid data is an MCP server listed in the public MCP registry as io.github.ironflowsh/hyperliquid. Hyperliquid data and liquidation alerts for AI agents: fills, candles, funding, wallet analytics. This page covers its hosted endpoint (https://mcp.ironflow.sh/mcp). ### Is the Ironflow: Hyperliquid data MCP server safe to use? Ironflow: Hyperliquid data scores 66 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm. ### What tools does the Ironflow: Hyperliquid data MCP server expose? Ironflow: Hyperliquid data exposes 45 tools: describe_data, run_query, get_wallet_behavior, get_price, get_recent_trades, and 40 more. Their descriptions and schemas cost roughly 6,851 tokens of context every time the server is loaded. ### Does the Ironflow: Hyperliquid data MCP server require authentication? No. We connected to Ironflow: Hyperliquid data without credentials and it answered, so anything it exposes is reachable by anyone who knows the address. ### Is the Ironflow: Hyperliquid data MCP server still maintained? Ironflow: Hyperliquid data is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced. ### What did VerifyMCP test on the Ironflow: Hyperliquid data MCP server? VerifyMCP ran 13 checks on Ironflow: Hyperliquid data, covering TLS certificate, Authorization, HTTPS, HSTS header and 9 more. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out. ## Links - Remote endpoint: https://mcp.ironflow.sh/mcp - Repository: https://github.com/ironflowsh/mcp - Changelog RSS feed: https://verifymcp.io/servers/ironflowsh-hyperliquid/mcp.xml - Changelog JSON feed: https://verifymcp.io/servers/ironflowsh-hyperliquid/mcp/changelog.json - Trust report (JSON): https://verifymcp.io/servers/ironflowsh-hyperliquid/mcp.json - HTML version of this page: https://verifymcp.io/servers/ironflowsh-hyperliquid/mcp