Hyperliquid API Endpoints

Quicknode's Hyperliquid Service

Quicknode provides infrastructure access to Hyperliquid's two-layer architecture: HyperEVM (execution layer) and HyperCore (exchange layer). Each component serves different purposes and provides specialized endpoints.

HyperEVM Service

HyperEVM is Hyperliquid's execution layer that provides standard Ethereum JSON-RPC compatibility for smart contracts, account queries, and transaction operations. Access HyperEVM through a dual-path routing system:

/evm Path - Routes to HyperEVM nodes for standard Ethereum JSON-RPC methods including account balances, blocks, transactions, smart contract calls, and transaction broadcasting.

/nanoreth Path - Routes to specialized nodes that provide transaction tracing and debugging. Supports trace methods that capture internal contract calls, gas usage, and state changes during execution.

HTTP Endpoints

Quicknode's HTTP endpoints provide JSON-RPC API access with multiple performance tiers designed for different application requirements.

https://your-endpoint.quiknode.pro/auth-token/evm
https://your-endpoint.quiknode.pro/auth-token/nanoreth

Best for: Building Web3 applications that interact with HyperEVM's smart contracts and blockchain data. Use these endpoints for deploying contracts, querying account balances and transaction history, calling smart contract functions, broadcasting transactions, and performing blockchain data analysis in development or production environments.

WebSocket (WSS) Endpoints

Quicknode's WebSocket endpoints provide real-time blockchain data streaming through persistent connections.

wss://your-endpoint.quiknode.pro/auth-token/nanoreth

Best for: DeFi applications and analytics platforms that need real-time blockchain updates. Use WebSocket connections to monitor new blocks as they're produced, track transaction confirmations, listen for smart contract events, update price feeds instantly, and build responsive block explorers or portfolio dashboards.

WebSocket Support

On Hyperliquid HyperEVM Service, WebSocket functionality is supported only on the /nanoreth namespace. The /evm namespace does not support WebSockets at this time.

WebSocket Limits: WebSocket responses are capped at a predefined limit, which may change over time. For large responses, it is recommended to use a POST request instead. If the response size exceeds the limit, the returned error code will be -32616.

How to Use HyperEVM Routes

Here are basic examples to get you started with each endpoint. Add /evm to your endpoint URL for standard blockchain operations and /nanoreth when you need transaction tracing.

Standard blockchain query:

curl https://docs-demo.hype-mainnet.quiknode.pro/evm \
  -X POST \
  -H "Content-Type: application/json" \
  --data '{"method":"eth_getBlockByNumber","params":["latest",false],"id":1,"jsonrpc":"2.0"}'

Transaction trace analysis:

curl https://docs-demo.hype-mainnet.quiknode.pro/nanoreth \
  -X POST \
  -H "Content-Type: application/json" \
  --data '{"method":"debug_traceBlockByNumber","params":["0xbdd86d"],"id":1,"jsonrpc":"2.0"}'

WebSocket subscription (real-time new blocks):

const WebSocket = require('ws');

const ws = new WebSocket('wss://your-endpoint.quiknode.pro/your-token/nanoreth');

ws.on('open', () => {
  // Subscribe to new block headers
  ws.send(JSON.stringify({
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_subscribe",
    "params": ["newHeads"]
  }));
});

ws.on('message', (data) => {
  const response = JSON.parse(data);
  console.log('New block:', response);
});

Note:

Use /evm for standard blockchain operations (HTTP only)
Use /nanoreth for transaction tracing, debugging, and WebSocket subscriptions

Method Compatibility

The following table shows which methods are supported on each endpoint and provides recommendations for optimal performance:

Method Category	Method Name	/evm	/nanoreth	Recommended
Standard Queries	eth_getBlockByNumber	✅ Optimized	✅ Available	`/evm`
	eth_getBalance	✅ Optimized	✅ Available	`/evm`
	eth_getTransactionByHash	✅ Optimized	✅ Available	`/evm`
Transaction Ops	eth_sendRawTransaction	✅ Optimized	✅ Available	`/evm`
	eth_call	✅ Fast (latest only)	✅ All blocks	`/nanoreth` for historical data
Debug API	debug_getBadBlocks	❌	✅ Only	`/nanoreth`
	debug_storageRangeAt	❌	✅ Only	`/nanoreth`
	debug_traceBlock	❌	✅ Only	`/nanoreth`
	debug_traceBlockByHash	❌	✅ Only	`/nanoreth`
	debug_traceBlockByNumber	❌	✅ Only	`/nanoreth`
	debug_traceTransaction	❌	✅ Only	`/nanoreth`
Trace API	trace_block	❌	✅ Only	`/nanoreth`
	trace_filter	❌	✅ Only	`/nanoreth`
	trace_rawTransaction	❌	✅ Only	`/nanoreth`
	trace_replayBlockTransactions	❌	✅ Only	`/nanoreth`
	trace_replayTransaction	❌	✅ Only	`/nanoreth`
	trace_transaction	❌	✅ Only	`/nanoreth`

Important Notes

Trace methods like debug_traceTransaction and trace_transaction only work on /nanoreth endpoint
Historical queries for eth_call method require /nanoreth - /evm only supports latest block
Rate limits are lower on debug and trace methods due to their higher computational overhead
Timeouts should be set appropriately for complex trace operations to prevent request failures

Key Implementation Differences

The /evm and /nanoreth endpoints handle Hyperliquid's internal system operations differently, resulting in data variations that developers need to account for in their applications.

Extra System Transactions on /nanoreth:

/nanoreth includes system transactions in block queries (eth_getBlockByNumber, eth_getBlockByHash) that are not present in /evm responses. These transactions handle token transfers between HyperCore and HyperEVM layers.
System transactions can be identified by their gasPrice: 0 value.
Filter requirement: Exclude transactions where gasPrice === 0 when displaying user transactions.

Extra Events on /nanoreth:

/nanoreth includes additional ERC20 transfer events from HyperCore bridging operations in eth_getLogs responses and WebSocket subscriptions.

Transaction Hash Lookups:

System transaction hashes return "transaction not found" on /evm endpoint. Use eth_getSystemTxsByBlockHash and eth_getSystemTxsByBlockNumber methods to access system transactions on /evm.

Cross-Layer Integration

HyperEVM smart contracts can read HyperCore data (such as oracle prices) through precompile addresses. See the HyperCore Oracle Prices guide for implementation details.

HyperCore Service

HyperCore is Hyperliquid's native exchange layer, and Quicknode provides managed infrastructure access to its APIs. HyperCore provides real-time and historical access to trading data, order book updates, and exchange events. Access HyperCore through specialized endpoints supporting Info API, JSON-RPC, gRPC streaming, and WebSocket protocols.

HyperCore Info Endpoint

https://your-endpoint.hype-mainnet.quiknode.pro/your-token/info

Best for: Querying comprehensive market data, user information, and exchange state through specialized info methods. Use this endpoint to retrieve order books, user positions, trading history, vault analytics, funding rates, portfolio data, and real-time market prices. Supports 50+ info methods covering perpetual and spot markets, user accounts, vaults, and delegations.

Example request:

curl -X POST https://your-endpoint.hype-mainnet.quiknode.pro/your-token/info \
  -H "Content-Type: application/json" \
  -d '{
    "type": "allMids"
  }'

Available Info Methods: Access market metadata (meta, spotMeta), user data (clearinghouseState, userFills, portfolio), order information (openOrders, orderStatus, historicalOrders), market data (l2Book, recentTrades, candleSnapshot), vault analytics (vaultDetails, vaultSummaries), funding data (fundingHistory, userFunding), and more. See the Info Endpoints documentation for complete method details.

HyperCore Method Compatibility

Quicknode's /info endpoint proxies the open-source HyperCore node and supports 29 of approximately 50 Hyperliquid info methods natively. Methods that depend on Foundation indexer outputs (including allMids, metaAndAssetCtxs, userFills, userFillsByTime, l2Book, recentTrades, candleSnapshot, portfolio, fundingHistory, orderStatus, and others) are not available from the open-source /info path and return a 422 Failed to deserialize error.

Depending on the method, equivalent data may still be available through:

HyperCore gRPC streaming for real-time data (e.g., StreamL2Book for order book depth, TRADES for recent trades)
Workaround methods library for JSON-RPC and gRPC alternatives to common info methods
Hyperliquid's public API at hyperliquidapi.com (subject to Hyperliquid rate limits)
SQL Explorer for analytical queries on indexed Hyperliquid tables (trades, funding, liquidations, market snapshots)

See the Info Endpoints reference for per-method availability and recommended alternatives.

HyperCore REST API Endpoint

Best for: Trading operations, builder fee management, and market queries. Use this endpoint to build and sign orders, manage builder fee approvals, validate orders before signing, and discover available markets.

Plan Requirement

If you are on a free trial plan, we provide a URL for you to use, but it is not specific to your Quicknode account. Please see hyperliquidapi.com for details and our Discord for support.

Available Method Categories:

Build (no signature) - Build order actions that return hash to sign: orders, market orders, close position, cancel, modify, approve/revoke builder fee
Send (with signature) - Submit signed actions to Hyperliquid: send order, cancel, modify, approval, revocation
Enhanced Endpoints - Check approval status, query open orders with pre-built cancel actions, check order status with plain-English explanation, validate orders (preflight), list markets and DEXes

Example request (build order):

curl -s -X POST https://docs-demo.hype-mainnet.quiknode.pro/hypercore/exchange \
  -H "Content-Type: application/json" \
  -d '{
  "action": {
    "type": "order",
    "orders": [
      {
        "asset": "BTC",
        "side": "buy",
        "price": "100000",
        "size": "0.001",
        "tif": "ioc"
      }
    ]
  }
}'

Example request (list markets):

curl -s https://docs-demo.hype-mainnet.quiknode.pro/hypercore/markets

Example request (open orders):

curl -s -X POST https://docs-demo.hype-mainnet.quiknode.pro/hypercore/openOrders \
  -H "Content-Type: application/json" \
  -d '{
  "user": "0x8ae62e9a4775350022c1577b2eff694e2b72be8d"
}'

HyperCore HTTP/JSON-RPC Endpoint

https://your-endpoint.hype-mainnet.quiknode.pro/your-token/hypercore

Best for: Retrieving historical exchange data and performing on-demand queries. Use this endpoint to backfill missed data during connection interruptions, fetch specific blocks by number, or retrieve batches of up to 200 blocks at once for analysis and archiving purposes.

Example request:

curl -X POST https://your-endpoint.hype-mainnet.quiknode.pro/your-token/hypercore \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "hl_getLatestBlocks",
    "params": {
      "stream": "trades",
      "count": 10
    },
    "id": 1
  }'

HyperCore gRPC Streaming Endpoint

your-endpoint.hype-mainnet.quiknode.pro:10000

HyperCore gRPC streaming provides access to all nine data streams with native zstd compression, reducing bandwidth by approximately 70%. Three streams (BLOCKS, StreamL2Book, StreamL4Book) are available exclusively through gRPC. For web-based applications where gRPC client support is limited, the WebSocket endpoint provides access to six of the nine streams.

Best for: High-performance real-time data streaming applications that require low latency. Ideal for market makers, algorithmic trading systems, and applications that need continuous order book monitoring, live trade feeds, and instant order status updates with minimal overhead.

Example connection (JavaScript):

const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

const endpoint = 'your-endpoint.hype-mainnet.quiknode.pro:10000';
const token = 'your-token';

const credentials = grpc.credentials.combineChannelCredentials(
  grpc.credentials.createSsl(),
  grpc.credentials.createFromMetadataGenerator((params, callback) => {
    const metadata = new grpc.Metadata();
    metadata.add('authorization', `Bearer ${token}`);
    callback(null, metadata);
  })
);

const client = new proto.StreamService(endpoint, credentials);

HyperCore WebSocket Endpoint

wss://your-endpoint.hype-mainnet.quiknode.pro/your-token/hypercore/ws

Best for: Browser-based and JavaScript applications that need real-time exchange data without the complexity of gRPC. Suitable for building trading dashboards, price monitors, portfolio trackers, and event-driven applications using standard WebSocket libraries available in any programming environment.

Example subscription:

const ws = new WebSocket('wss://your-endpoint.hype-mainnet.quiknode.pro/your-token/hypercore/ws');

ws.send(JSON.stringify({
  "method": "hl_subscribe",
  "params": {
    "streamType": "trades",
    "filters": {
      "coin": ["BTC", "ETH"]
    }
  }
}));

Available Data Streams

HyperCore endpoints provide access to ten data streams (nine on mainnet, one testnet-only):

Stream Type	Description	API Support
TRADES	Executed trades with price and size	gRPC + JSON-RPC/WSS
ORDERS	Order lifecycle events (18+ status types)	gRPC + JSON-RPC/WSS
BOOK_UPDATES	Order book changes	gRPC + JSON-RPC/WSS
TWAP	TWAP execution data	gRPC + JSON-RPC/WSS
EVENTS	Balance changes, transfers, deposits, withdrawals	gRPC + JSON-RPC/WSS
WRITER_ACTIONS	HyperCore ↔ HyperEVM bridge data	gRPC + JSON-RPC/WSS
BLOCKS	Raw blockchain data with all transaction types	gRPC only
StreamL2Book	Aggregated price-level depth (full snapshot every block)	gRPC only
StreamL4Book	Individual order book (snapshot + diffs per block)	gRPC only
MEMPOOL_TXS	Pending mempool transactions (testnet only)	gRPC only

For complete details on data streams, filtering, and examples, see the Hyperliquid Data Streams documentation.

HyperCore Endpoints at a Glance

/hypercore : Hyperliquid's JSON-RPC API for historical block queries and WebSocket subscriptions
/hypercore/exchange : Hyperliquid's REST API for trading operations (build/send orders, manage approvals)
/hypercore/markets, /hypercore/openOrders, /hypercore/orderStatus : REST query endpoints for market and order data
/hypercore/ws : WebSocket endpoint for real-time data stream subscriptions
/info : Hyperliquid's market data and user query API (POST with {"type": "methodName"})
:10000 (gRPC) : HyperCore gRPC streaming for real-time exchange data (separate port, not a URL path)

Choosing an API

With multiple access paths available, use the following guide to select the right API for your use case:

Goal	Recommended API	Why
Query market data, user positions, order books	`/info` endpoint	Simple POST requests, 29+ natively supported methods (see method compatibility note)
Stream real-time trades, orders, book updates (browser/web apps)	`/hypercore/ws` WebSocket	Browser-compatible, JSON-based, 6 data streams
Stream real-time data (high-performance/trading systems)	HyperCore gRPC streaming (port 10000)	Sub-millisecond latency, zstd compression, 9 data streams including L2/L4 book
Backfill historical exchange data	`/hypercore` JSON-RPC	Batch queries up to 200 blocks
Build and submit trades	`/hypercore/exchange` REST API	Order lifecycle management with signature support
Monitor HyperEVM contract events (push-based)	Quicknode Streams	Webhook delivery, filter by address/topic
Run analytical queries on historical Hyperliquid data	SQL Explorer	SQL interface to indexed tables
Deploy and interact with smart contracts	`/evm` or `/nanoreth`	Standard Ethereum JSON-RPC
Debug or trace transactions	`/nanoreth`	`debug_` and `trace_` methods

Support & Resources

For technical support, visit Quicknode Support. For Hyperliquid protocol details, see the official documentation.

Credit Usage

Different methods consume different amounts of credits: View Hyperliquid API credit costs →

Rate Limits

Rate limits vary by plan tier: View detailed pricing and limits →

Quicknode's Hyperliquid Service​

HyperEVM Service​

HTTP Endpoints​

WebSocket (WSS) Endpoints​

How to Use HyperEVM Routes​

Method Compatibility​

Key Implementation Differences​

HyperCore Service​

HyperCore Info Endpoint​

HyperCore REST API Endpoint​

HyperCore HTTP/JSON-RPC Endpoint​

HyperCore gRPC Streaming Endpoint​

HyperCore WebSocket Endpoint​

Available Data Streams​

Choosing an API​

Support & Resources​

Credit Usage​

Rate Limits​