Hyperliquid RPC Node Setup: Public vs Private Endpoints, Performance Optimization & Cost Analysis

Hyperliquid is rapidly becoming the go-to L1 for onchain trading—zero gas fees, native order book, and a custom EVM-compatible VM optimized for high-frequency operations. But as adoption accelerates, developers are discovering that reliable RPC access is non-negotiable infrastructure.

As of August 2025, Hyperliquid's public RPC enforces a 100 requests per minute rate limit on HyperEVM endpoints. For prototyping, this might work. For production trading bots, real-time indexers, or data-intensive analytics, this throttle will break your application.

This guide covers everything you need to know about Hyperliquid RPC nodes: what they are, how to access them, when public endpoints suffice, and when you need private infrastructure. We'll also show you how to set up production-grade RPC access that scales with your application without surprise costs or rate-limit headaches.

What is a Hyperliquid RPC Node?

A Hyperliquid RPC node provides programmatic access to the HyperEVM—Hyperliquid's EVM-compatible execution layer. If you've worked with Ethereum or other EVM chains, the interface will feel familiar: HyperEVM implements a subset of the standard JSON-RPC API used across EVM-compatible networks.

How Hyperliquid RPC Works

When you query a Hyperliquid RPC endpoint, you're reading data or simulating state transitions from the HyperEVM. Unlike traditional blockchain RPCs where you also submit transactions through the same interface, Hyperliquid separates concerns:

RPC layer (read-only):

• Query contract state with eth_call
• Check balances and account data
• Fetch event logs with eth_getLogs
• Simulate transactions
• Read block data

Execution layer (write operations):

• Transaction submission happens through Hyperliquid's separate submission layer
• Functions more like a sequencer than a traditional mempool
• Optimized for low-latency order execution

This architectural split is why choosing the right RPC provider matters even more on Hyperliquid. Your RPC infrastructure directly impacts:

• Trading bot execution speed and slippage
• Indexer completeness and lag
• Real-time dashboard responsiveness
• Order book synchronization accuracy
• Liquidation bot profitability

Public vs Private Hyperliquid RPC Nodes

There are two primary ways to access HyperEVM RPC endpoints: through public infrastructure or private nodes.

Public Hyperliquid RPC Endpoints

Hyperliquid's core team maintains a free public RPC endpoint for mainnet:

Mainnet:

https://rpc.hyperliquid.xyz/evm

This public endpoint supports standard read-only JSON-RPC methods:

• eth_call - Execute contract calls without state changes
• eth_getLogs - Fetch event logs
• eth_blockNumber - Get current block height
• eth_getBlockByNumber - Retrieve block data
• eth_getTransactionReceipt - Get transaction receipts

The critical limitation: Starting August 9, 2025, this endpoint enforces a 100 requests per minute rate limit per IP address.

When Public RPC Works

Public endpoints are sufficient for:

• Prototyping and testing - Building proof-of-concepts or learning HyperEVM
• Low-frequency queries - Occasional contract reads or balance checks
• Educational projects - Tutorials, demos, workshops
• Lightweight dashboards - Simple UIs with infrequent updates

When You Need Private RPC Infrastructure

You'll hit the public rate limit fast if you're running:

Trading bots:

• High-frequency order placement requiring real-time price feeds
• Arbitrage strategies polling multiple contracts per second
• Liquidation bots monitoring positions continuously
• Market-making algorithms with sub-second update requirements

Real-time indexers:

• Event log polling across multiple contracts
• Historical data backfills requiring thousands of requests
• Cross-chain bridge monitoring
• Analytics platforms aggregating onchain activity

Production applications:

• User-facing dashboards with real-time updates
• Portfolio trackers polling multiple accounts
• DeFi aggregators comparing rates across protocols
• Order book mirrors requiring WebSocket streams

For any production use case, you need private RPC infrastructure that eliminates rate limits, reduces latency, and provides reliability guarantees.

Private RPC Options

Private Hyperliquid RPC access comes in two forms:

1. Self-hosted node - Run your own HyperEVM RPC node (non-validator mode)
2. Managed RPC provider - Use infrastructure providers like Dwellir, Chainstack, or others

The total cost of ownership calculation typically favors managed providers unless you have dedicated infrastructure teams. We'll cover both approaches.

How to Get a Private Hyperliquid RPC Node with Dwellir

Dwellir provides high-performance Hyperliquid RPC infrastructure optimized for trading bots, indexers, and data-intensive applications. Unlike public endpoints, Dwellir eliminates rate limits, reduces latency, and provides dedicated infrastructure without enterprise-level costs.

Why Choose Dwellir for Hyperliquid RPC

1. No Compute Unit Confusion

Dwellir uses transparent 1:1 pricing—1 RPC response = 1 API credit. Whether you're making a basic eth_blockNumber call or resource-intensive trace methods, every response costs exactly one credit. No complex formulas, no surprise bills.

Plans start at just $49/month with transparent, predictable scaling as your application grows.

2. Optional: Dedicated Low-Latency Clusters

For ultra-low latency requirements, Dwellir offers an optional add-on: dedicated clusters where you can run your code next to the node. This matters immensely for:

• Trading bots requiring sub-millisecond order book reads
• Arbitrage strategies where every microsecond counts
• Liquidation monitoring with instant state access
• Real-time dashboards needing instant updates

This dedicated infrastructure option eliminates network round-trips entirely by co-locating your application logic with the RPC node.

3. Optional: High-Performance gRPC Infrastructure & Orderbook Server

Beyond standard HTTP JSON-RPC, Dwellir provides gRPC streaming and orderbook server as optional add-ons for Hyperliquid, enabling you to process 70+ blocks per second with sub-second latency. These advanced features are critical for:

• Real-time event processing
• Continuous order book synchronization
• High-throughput data pipelines
• Multi-contract monitoring

4. 150+ Network Support

While specialized for Hyperliquid, Dwellir supports 150+ blockchain networks with the same transparent pricing. If you're building multi-chain applications or comparing Hyperliquid performance to other L1s, you have one provider for everything.

Setting Up Your Dwellir Hyperliquid RPC Endpoint

Step 1: Create Your Account

Visit dashboard.dwellir.com/register to create your account and get started with Hyperliquid RPC.

Step 2: Select Hyperliquid Network

In your dashboard, find and select the Hyperliquid endpoint card.

Step 3: Choose Your Infrastructure Tier

Dwellir offers flexible tiers based on throughput needs:

• Starter tier - Starting at $49/month for production applications
• Scale tier - Higher volume applications with increased request limits
• Optional add-ons:
  • Dedicated clusters - Ultra-low latency with co-located compute where you run your code next to the node
  • gRPC streaming - High-performance block processing (70+ blocks/sec)
  • Orderbook server - Optimized orderbook data access

Step 4: Get Your RPC Endpoint

Your RPC endpoint URL is ready to use immediately—simply copy and paste it. The API key is already included in the URL, so no additional configuration is needed.

Your endpoint will look like:

https://api-hyperliquid-mainnet-evm.n.dwellir.com/YOUR_API_KEY

Step 5: Integrate and Monitor

Use Dwellir's dashboard to:

• Track request usage and costs (remember: 1 response = 1 credit)
• Monitor latency percentiles (p50, p95, p99)
• Set up alerts for quota approaching
• Analyze request patterns for optimization

Code Example: Connecting to Dwellir Hyperliquid RPC

// Standard HTTP JSON-RPC
const { ethers } = require('ethers');

const provider = new ethers.JsonRpcProvider(
  'https://api-hyperliquid-mainnet-evm.n.dwellir.com/YOUR_API_KEY',
  {
    name: 'hyperliquid-mainnet',
    chainId: 42161 // Hyperliquid chain ID
  }
);

// Query current block
const blockNumber = await provider.getBlockNumber();
console.log('Current block:', blockNumber);

// Query contract state
const contract = new ethers.Contract(
  '0xYourContractAddress',
  contractABI,
  provider
);

const result = await contract.someMethod();

# Python example with web3.py
from web3 import Web3

# Connect to Dwellir Hyperliquid RPC
w3 = Web3(Web3.HTTPProvider('https://api-hyperliquid-mainnet-evm.n.dwellir.com/YOUR_API_KEY'))

# Verify connection
print(f"Connected: {w3.is_connected()}")
print(f"Current block: {w3.eth.block_number}")

# Query balance
balance = w3.eth.get_balance('0xYourAddress')
print(f"Balance: {w3.from_wei(balance, 'ether')} ETH")

For gRPC streaming examples (available as an optional add-on) optimized for Hyperliquid, see Dwellir's gRPC documentation.

Alternative: Self-Hosting a Hyperliquid RPC Node

For teams with dedicated infrastructure resources, running your own Hyperliquid RPC node is possible. This gives you maximum control and data ownership but comes with significant operational costs.

Requirements for Self-Hosted Hyperliquid Node

Hardware specifications (minimum):

• CPU: 8+ cores (16+ recommended for production)
• RAM: 32GB minimum (64GB+ for archive node)
• Storage: 1TB+ NVMe SSD (grows over time)
• Network: 1Gbps+ with low latency to Hyperliquid validators
• Uptime: 99.9%+ target requires redundancy and monitoring

Operational requirements:

• 24/7 monitoring and alerting
• Automated failover and backup systems
• Security hardening and regular updates
• Performance tuning and optimization
• Data backup and disaster recovery

Cost Analysis: Self-Hosted vs Managed Provider

Let's calculate the real total cost of ownership:

Self-hosted monthly costs:

• Server hardware/cloud instances: $200-500
• Network bandwidth: $50-200
• DevOps engineering time (maintenance, monitoring, updates): $500-2,000
• Monitoring and alerting tools: $20-100
• Backup storage: $20-100
• Total: $790-2,900/month

Managed provider (Dwellir):

• Starting at: $49/month
• Typical production usage: $100-500/month
• High-volume applications: $500-2,000/month
• No operational overhead
• Built-in monitoring, alerting, and support
• Automatic scaling and failover
• Optional add-ons for dedicated clusters, gRPC, orderbook server

Conclusion: For most teams, managed RPC providers like Dwellir deliver 3-10x cost savings while providing better reliability and performance. Even high-volume Dwellir plans are often cheaper than basic self-hosted infrastructure when you account for engineering time.

When Self-Hosting Makes Sense

Consider running your own node only if:

• You have a dedicated infrastructure team with blockchain expertise
• Data sovereignty is legally required
• You're running validators and need co-located RPC access
• Your request volume exceeds millions per day and you can optimize costs through scale
• You require custom node modifications not available from providers

For 95% of development teams, managed RPC infrastructure is the pragmatic choice.

Hyperliquid RPC Use Case Examples

Let's look at real-world applications and their infrastructure requirements:

Trading Bot (High-Frequency)

Requirements:

• Ultra-low latency (sub-10ms p95)
• High throughput (100-1,000 RPS)
• Minimal downtime (99.99%+ uptime)
• Real-time order book access

Recommended setup:

• Dwellir standard RPC starting at $49/month
• Optional: Dedicated cluster add-on with co-located compute for ultra-low latency
• Optional: gRPC streaming add-on for order book updates
• WebSocket for real-time events
• Request batching for multi-contract queries

Estimated costs (Dwellir):

• Base RPC: $49-200/month depending on volume
• Optional dedicated cluster premium: Contact for pricing
• Total: Starting at $49/month, scales with requirements

Compare to:

• Self-hosted: $790-2,900/month
• Enterprise provider: $500-3,000/month

Real-Time Indexer

Requirements:

• Complete event log coverage (no missed blocks)
• Historical backfill capability
• Moderate latency tolerance (1-5s acceptable)
• Very high volume (millions of requests/day)

Recommended setup:

• Managed RPC with high request limits
• WebSocket subscriptions for new blocks
• HTTP JSON-RPC for historical backfills
• Caching layer for repeated queries

Estimated costs (Dwellir):

• Starting at $49/month
• High-volume (100M+ requests/month): $500-1,500/month
• No compute unit surprises
• Predictable scaling with simple 1:1 pricing

Portfolio Dashboard

Requirements:

• User-facing UI with responsive feel
• Moderate request volume per user
• Burst tolerance during high activity
• Cost efficiency for freemium model

Recommended setup:

• Shared RPC infrastructure with rate limits
• Client-side caching of static data
• Request batching for multi-account queries
• WebSocket for balance updates

Estimated costs (Dwellir):

• Starting at $49/month
• Typical usage (10M requests/month): $100-300/month
• Scales predictably with user growth
• Transparent per-request pricing (1 response = 1 credit)

Advanced Topics: Hyperliquid RPC Optimization

Understanding HyperEVM's Unique Architecture

Hyperliquid's architecture differs from typical EVM chains in ways that impact RPC usage:

Execution model:

• Native order book operations bypass EVM entirely
• Only smart contract interactions use HyperEVM
• This creates unique optimization opportunities

State access patterns:

• Order book state updates don't generate EVM events
• Smart contract events require RPC monitoring
• Efficient apps combine both data sources

Optimal strategy:

• Use native Hyperliquid APIs for order book data (Dwellir offers an optional orderbook server add-on for optimized access)
• Use RPC for smart contract monitoring
• Combine both for complete market picture

Troubleshooting Common Issues

Rate Limiting on Public RPC

Symptom: 429 (Too Many Requests) errors

Diagnosis:

try {
  await provider.getBlockNumber();
} catch (error) {
  if (error.code === 429) {
    console.log('Hit rate limit - time to upgrade to private RPC');
  }
}

Solution: Migrate to private RPC infrastructure. Public rate limits are not temporary—they're permanent infrastructure constraints.

High Latency Spikes

Symptom: Occasional very slow responses (>1 second)

Diagnosis: Check p95 and p99 latencies, not just averages

Solutions:

1. Switch to geographically closer RPC provider
2. Use dedicated infrastructure (Dwellir clusters)
3. Implement request batching to reduce round-trips
4. Consider gRPC for lower protocol overhead

Incomplete Event Logs

Symptom: Missing events in eth_getLogs results

Diagnosis:

// Check for gaps in block processing
let lastBlock = startBlock;
for (const log of logs) {
  if (log.blockNumber > lastBlock + 1) {
    console.warn(`Gap detected: blocks ${lastBlock + 1} to ${log.blockNumber - 1}`);
  }
  lastBlock = log.blockNumber;
}

Solutions:

1. Reduce block range per query (try 1000 blocks max)
2. Implement gap detection and backfill logic
3. Use WebSocket subscriptions for real-time monitoring
4. Consider managed indexing solutions

Connection Timeouts

Symptom: Requests hanging or timing out

Diagnosis: Network connectivity or provider health issues

Solutions:

// Implement timeout and retry logic
async function rpcCallWithTimeout(callFunction, timeoutMs = 5000) {
  const timeout = new Promise((_, reject) => 
    setTimeout(() => reject(new Error('RPC timeout')), timeoutMs)
  );
  
  return Promise.race([callFunction(), timeout]);
}

Consider provider failover if timeouts are frequent.

Conclusion: Choosing Your Hyperliquid RPC Strategy

For most developers building on Hyperliquid, the decision tree is straightforward:

Use public RPC if:

• You're prototyping or learning
• Request volume is under 100/minute
• Latency isn't critical
• No budget for infrastructure

Use managed private RPC (Dwellir) if:

• Building production applications
• Need predictable performance and costs
• Want to avoid operational complexity
• Value transparent pricing (no compute unit confusion)
• Need affordable entry point (starting at $49/month)
• Want optional upgrades for ultra-low latency (dedicated clusters where you run code next to the node)
• Want optional high-performance add-ons (gRPC streaming, orderbook server)

Self-host only if:

• You have dedicated infrastructure teams
• Legal requirements mandate data sovereignty
• Scale exceeds millions of requests/day with custom optimizations

For 95% of teams, managed RPC with transparent pricing delivers the best value. Dwellir's combination of simple 1:1 pricing starting at $49/month, optional dedicated low-latency clusters (where you can run your code next to the node), optional gRPC infrastructure, and optional orderbook server makes it particularly compelling for Hyperliquid applications—especially for teams that want flexibility to scale from basic RPC to advanced features as needs grow.

The public RPC's 100 requests/minute limit was never meant for production use. If you're serious about building on Hyperliquid, private RPC infrastructure isn't optional—it's foundational.

Get Started with Dwellir's Hyperliquid RPC

Ready to eliminate rate limits and optimize performance?

• Sign up: Create your account
• Documentation: Hyperliquid RPC docs
• Network details: Hyperliquid infrastructure
• gRPC examples: GitHub code samples
• Pricing: Transparent, no-compute-unit pricing

Additional Resources

• Hyperliquid Developer Documentation
• HyperEVM RPC Specification
• Dwellir gRPC Performance Guide
• Best Hyperliquid RPC Providers Comparison
• RPC Providers Without Compute Units

This guide is for informational purposes only. RPC infrastructure requirements vary by application. Always conduct load testing before production deployment. Pricing and rate limits subject to change—verify current details with providers.