Skip to main content

Hyperliquid RPC

With Quicknode, you get access to our global Hyperliquid network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.
Try freeSend Your First Request

Hyperliquid runs a full exchange onchain, final in one block, across two layers that share one consensus and one state. HyperCore is the exchange layer: order books, matching, positions, and account state. HyperEVM is the smart contract layer: Ethereum-compatible, and able to read the books and trade on them directly. One Quicknode endpoint reaches both layers' RPC and streaming APIs. SQL Explorer uses a separate query endpoint and API key, and dedicated sentry peering for a node you run yourself is a flat monthly add-on.

What are you building?​

Most jobs on Hyperliquid can be done more than one way. Trades arrive over gRPC, WebSocket, or as SQL history. Candles come from an endpoint or are built from fills. Each card lists the ways in.

Trade
Orders

Build and sign HyperCore orders, check them with preflight, then submit or cancel them and follow order status updates.

Exchange APISDKsOrder status stream
HIP-4 Outcome Markets

Explore binary and multi-price outcome markets, inspect their metadata, and find the Exchange API actions used to trade them.

Outcome metadataList outcomesTrade an outcome
HIP-3 Perp DEXs

Inspect builder-deployed perp DEXes, their market limits, and deployment auctions, then analyze DEX trades in SQL.

List perp DEXsDEX limitsDEX trades in SQL
TP/SL Triggers

Monitor resting stop-loss and take-profit orders through add and remove updates before they appear in regular order book streams.

gRPC method & examples
Market data
Trades & Order Flow

Follow executed fills and order updates through live streams, or query indexed trades in SQL to analyze past market activity.

gRPC streamWebSocketRecent trades in SQL
Order Book

Choose aggregated L2 depth, individual L4 resting orders, or best bid and ask prices; use book diffs to track changes.

L2 depthL4 ordersBest bid and askWebSocket diffs
Candles

Fetch venue candlesticks from an info endpoint, or build custom intervals and OHLCV history from indexed fills in SQL.

candleSnapshotExact bars from fills in SQLHourly OHLCV in SQL
Mempool

Watch pending HyperCore transactions and priority-fee orders before block inclusion, or use peering for the full mempool on your node.

Raw transactionsPriority fee ordersFull mempool on your own node
Accounts and analytics
Portfolios & PnL

Read positions and margin for one account, batch portfolio state for many users, or analyze fills and realized PnL in SQL.

One accountUp to 500 accounts per callFull portfolio in SQL
Liquidations

Identify accounts currently at risk, follow liquidation-related events as they arrive, and inspect recent liquidations in SQL.

Accounts at riskLive eventsRecent liquidations in SQL
Funding, Vaults & Staking

Inspect funding history and rates, vault details, staking delegations, and rewards through info methods or indexed SQL data.

Funding historyVault detailsDelegationsFunding rates in SQL
Historical SQL

Query across 40+ indexed HyperCore tables to analyze trades, positions, funding, and ledger activity with SQL or the REST API.

Query cookbookSchema referenceREST API
Infrastructure
HyperCore

Use the exchange layer to read market and account state, submit trading actions, query blocks, and stream live activity.

Info APIExchange APIJSON-RPCWebSocketgRPC streams
HyperEVM

Use Ethereum JSON-RPC for contracts and transactions, with the archive route for historical state, traces, and debug requests.

JSON-RPCTraceDebug
Backfill Blocks

Retrieve available HyperCore blocks by number for recovery or analysis, or stream raw and aggregated block activity into your pipeline.

Batch by numbergRPC block streamAggregated block dataset
Run Your Own Node

Connect a non-validating Hyperliquid node you operate to three dedicated Quicknode sentry peers for blocks and full mempool data.

For HyperCore spot tokens and liquidity concepts, see the HyperCore overview.

Supported Hyperliquid Products​

Streams

Deliver filtered HyperCore activity or HyperEVM blocks and logs to Postgres, S3, Kafka, or a webhook for downstream processing.

Webhooks

Subscribe to selected HyperEVM events and receive matching activity as HTTP notifications at your application endpoint.

SQL Explorer

Query 40+ indexed HyperCore tables with SQL to analyze trades, positions, funding, and ledger activity without running an indexer.

Peering

Connect your own non-validating Hyperliquid node to three dedicated sentry peers for raw blocks and full mempool data.

API surfaces​

One Quicknode endpoint exposes every surface below. Start with the Quickstart, then use the HyperCore and HyperEVM overviews for endpoint routes, authentication, and examples.

HyperCore Info

Use /info to read market metadata, prices, exchange status, and user account state without sending a trade. It is the read-only entry point for market and portfolio views.

Mainnet availableTestnet available
HyperCore Exchange API

Build a trading action, sign it with your wallet, and submit it to HyperCore. The REST API also covers cancellations, preflight checks, and market discovery.

Mainnet availableTestnet unavailable
HyperCore JSON-RPC

Use /hypercore to fetch historical HyperCore blocks, including raw replica_cmds, and batch account or order queries. It serves backfills and bulk portfolio reads.

Mainnet availableTestnet available
HyperCore WebSocket

Connect to /hypercore/ws for live trades, order updates, and book changes in a browser. Other streams cover TWAP, events, and writer actions.

Mainnet availableTestnet available
HyperCore gRPC

Stream trades, order books, blocks, and mempool data over port 10000. Typed protobuf messages and zstd compression support low-latency, high-volume feeds.

Mainnet availableTestnet available
HyperEVM JSON-RPC

Call contracts and read recent HyperEVM state through /evm. Use /nanoreth for historical queries, transaction traces, and debugging.

Mainnet availableTestnet available

Which protocol serves which stream, and the gRPC versus WebSocket versus JSON-RPC decision, is in the available data streams reference.

For Python, TypeScript, Go, and Rust packages, see SDKs & Libraries.

Networks​

Mainnet
Type:Production
Chain ID:
999
HTTP:
WSS:
Archive:Yes
Pruning:See comment below*
Testnet
Type:Testnet
Chain ID:
998
HTTP:
WSS:
Archive:Yes
Pruning:See comment below*
HyperEVM history and pruning

/evm provides HTTP access to recent blocks and state. Older block data is pruned approximately every 12 hours; requests outside the retained range return invalid block height.

Use /nanoreth for historical queries, debug and trace methods, and HyperEVM WebSocket connections. Mainnet has full history; testnet history starts at block 34112653, not genesis.

Plans​

HyperEVM and all 73 /info methods are on every plan, including the free trial. /hypercore JSON-RPC, WebSocket, and gRPC need a Build plan or higher. HyperCore method credits, stream limits, and plan access are on one page: Pricing & Plans.

Credit Usage​

For RPC method credit costs, see the Hyperliquid API Credits table. That table does not include SQL Explorer queries or metered gRPC and WebSocket data. See Pricing & Plans for HyperCore gRPC and WebSocket streaming rates.

Rate Limits​

Rate limits vary by plan tier. See the Hyperliquid rate limits and Quicknode plan pricing.

Specifications​

Download the machine-readable API specifications for use with compatible tooling (e.g. OpenRPC Playground).


Last updated on