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.

HyperCore Service

HyperCore is Hyperliquid's exchange layer that provides real-time and historical access to trading data, order book updates, and exchange events. Access HyperCore through specialized endpoints supporting JSON-RPC, gRPC streaming, and WebSocket protocols.

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

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 seven different data streams:

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
BLOCKS	Raw blockchain data with all transaction types	gRPC only
WRITER_ACTIONS	HyperCore ↔ HyperEVM bridge data	gRPC + JSON-RPC/WSS

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

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 →