Hyperliquid RPC for perps trading: best providers and full trading guide 2026

Perpetual futures trading on Hyperliquid is a fundamentally different workload from deploying smart contracts or running dApp frontends. When a trading bot places or cancels an order, every millisecond of round-trip latency directly affects fill quality, slippage, and — at scale — P&L. Hyperliquid processes perpetuals natively at the L1 layer through HyperCore, achieving 200,000 TPS with sub-200ms finality via its custom HyperBFT consensus. The chain generated $2.95 trillion in total trading volume in 2025, averaged $8.34 billion in daily volume, and crossed $6 billion in TVL by year end. That throughput places extraordinary demands on the RPC and API infrastructure that trading systems rely on.

Choosing the wrong provider — or relying on Hyperliquid’s public endpoint — will throttle your strategy before it runs a single trade. Since August 2025 the public rpc.hyperliquid.xyz/evm endpoint has been capped at 100 requests per minute per IP. For any production trading system, that limit is hit within seconds. The best Hyperliquid RPC providers for perps trading give you private endpoints with high request-per-second ceilings, WebSocket feeds for real-time order book and position data, and reliable SLAs that survive volatile market conditions — exactly when infrastructure stability matters most.

This guide covers what perps trading actually requires from your infrastructure layer, which providers deliver it in 2026, and how to get started on Chainstack, which ranks first for teams that need the full stack: HyperCore queries, HyperEVM execution, dedicated throughput, and enterprise compliance posture.

Perps trading on Hyperliquid: RPC and API requirements

Why perps trading is latency-critical

Perpetual futures on Hyperliquid use a fully on-chain central limit order book (CLOB). Every order, modification, and cancellation is committed on-chain in one block. Mark prices update continuously. Funding rates settle every hour. Liquidations are automated by the on-chain liquidation engine.

For a market-making bot, the window to update quotes after a price move is typically under 50 milliseconds. For a directional momentum strategy, latency between signal generation and order submission can be the difference between a fill at the target price and significant negative slippage. For a cross-exchange arbitrage bot, round-trip latency to Hyperliquid directly determines whether the arb opportunity is captured or closed by someone faster.

This means your infrastructure stack has three hard requirements: sub-50ms p99 latency to the API endpoint for order placement and cancellation, sustained high throughput for info queries (order book snapshots, position state, funding data), and stable WebSocket connections for real-time streaming without reconnect loops.

The architecture: HyperCore vs HyperEVM

Hyperliquid has two execution layers, and perps trading touches both:

HyperCore is the native trading engine. All perpetuals live here. The /info and /exchange API endpoints communicate directly with HyperCore. Order placement, cancellation, and account state queries all go through https://api.hyperliquid.xyz. Third-party RPC providers proxy the /info read queries; the /exchange write endpoint (order placement, cancels) must route through the official Hyperliquid API because it requires on-chain signing with validator participation.

HyperEVM is the EVM-compatible execution layer running alongside HyperCore, secured by the same HyperBFT consensus. Perps-adjacent use cases on HyperEVM include: reading on-chain vault positions from EVM contracts, interacting with DeFi protocols that hedge perp exposure, deploying trading automation smart contracts, and reading precompile data that bridges HyperCore state into EVM.

A production perps trading system needs both: HyperCore endpoints for the actual trading operations, and a reliable HyperEVM RPC for the broader execution context.

Key API methods for perps trading

These are the seven endpoint calls that matter most for a perpetual futures trading operation on Hyperliquid:

1. clearinghouseState (info) Returns a user’s open perpetual positions, margin usage, unrealized PnL, and account equity. This is the primary position-state query — called on startup, after fills, and periodically for risk monitoring.

POST https://api.hyperliquid.xyz/info
{"type": "clearinghouseState", "user": "0xYourAddress"}

2. l2Book (info) Returns the current Level 2 order book snapshot for a given market. Used by market-making bots to quote around the mid, and by any strategy that needs bid/ask context before placing orders.

POST https://api.hyperliquid.xyz/info
{"type": "l2Book", "coin": "BTC"}

3. metaAndAssetCtxs (info) Returns full perpetuals metadata combined with real-time mark prices, funding rates, open interest, and oracle prices for all markets. Essential for multi-market strategies and risk dashboards.

4. openOrders (info) Returns all open orders for a user. Used by order management systems to reconcile live state, and by dead man’s switch logic to verify clean state before a restart.

5. order (exchange) Places a new perpetual order. This is the highest-latency-sensitive call in the stack. Action type "order", with fields for asset, direction, price, size, and time-in-force ("Gtc", "Ioc", or "Alo" for post-only).

6. cancel / cancelByCloid (exchange) Cancels an existing order by order ID or client order ID. In volatile markets, cancel latency is as important as placement latency. The scheduleCancel action implements a dead man’s switch — an automated cancel-all that fires at a scheduled timestamp, protecting against connection loss.

7. WebSocket: l2Book, trades, userFills, userEvents Real-time subscriptions via wss://api.hyperliquid.xyz/ws. Market makers subscribe to l2Book for streaming order book deltas, trades for execution confirmation, userFills for position update notifications, and userEvents for margin call and liquidation warnings. The connection requires graceful reconnect handling, as the server periodically disconnects.

Infrastructure requirements summary

Requirement	Minimum	Production grade
API latency (p50)	< 100ms	< 30ms
API latency (p99)	< 200ms	< 50ms
Throughput (RPS)	100+	400–1,000+
WebSocket streams	Info queries	Full order book + position events
HyperEVM access	Shared	Dedicated
SLA	None	99.99%+
Uptime monitoring	Manual	Provider dashboard

Chainstack for perps trading on Hyperliquid

Chainstack supports both HyperCore (info query routing) and HyperEVM on all paid plans, with Dedicated Nodes available for teams that need isolated throughput and a hard SLA.

What you get on Chainstack:

• Private HyperCore /info endpoint with no shared rate limit
• Private HyperEVM RPC (HTTPS + WSS) on both /evm and /nanoreth paths
• HyperEVM archive node access (2 RU per request)
• WebSocket connections for HyperEVM event streaming
• Global Nodes distributed across multiple regions for latency optimization
• Dedicated Nodes with isolated compute from $803/month for high-frequency strategies
• 99.99%+ uptime SLA on dedicated infrastructure
• SOC 2 Type II and ISO 27001 certification
• Unified console with request monitoring and alerting

The Chainstack endpoint URL format for Hyperliquid:

https://hyperliquid-mainnet.core.chainstack.com/<YOUR_KEY>/info
wss://hyperliquid-mainnet.core.chainstack.com/<YOUR_KEY>/ws

Important note on order placement: The /exchange endpoint for placing and canceling orders must always route to https://api.hyperliquid.xyz/exchange — this is a protocol-level constraint. No third-party provider proxies the signed trading actions. Your private Chainstack endpoint handles the read workload (position state, order book, funding data), while write actions go directly to the official API. This is the standard architecture for all Hyperliquid trading systems.

Code example: perps position monitoring with Chainstack

import requests
import json

CHAINSTACK_URL = "https://hyperliquid-mainnet.core.chainstack.com/<YOUR_KEY>/info"
TRADER_ADDRESS = "0xYourWalletAddress"

headers = {"Content-Type": "application/json"}

def get_positions(address: str) -> dict:
    """Fetch open perpetual positions and margin state."""
    payload = {
        "type": "clearinghouseState",
        "user": address
    }
    response = requests.post(CHAINSTACK_URL, json=payload, headers=headers)
    response.raise_for_status()
    return response.json()

def get_order_book(coin: str, depth: int = 5) -> dict:
    """Fetch L2 order book snapshot."""
    payload = {
        "type": "l2Book",
        "coin": coin,
        "nSigFigs": 5
    }
    response = requests.post(CHAINSTACK_URL, json=payload, headers=headers)
    response.raise_for_status()
    return response.json()

def get_market_context() -> dict:
    """Fetch all perpetuals metadata with mark prices and funding rates."""
    payload = {
        "type": "metaAndAssetCtxs"
    }
    response = requests.post(CHAINSTACK_URL, json=payload, headers=headers)
    response.raise_for_status()
    return response.json()

# Example: check positions and print open PnL
state = get_positions(TRADER_ADDRESS)
for position in state.get("assetPositions", []):
    pos = position.get("position", {})
    if float(pos.get("szi", 0)) != 0:
        print(f"{pos['coin']}: size={pos['szi']}, unrealizedPnl={pos['unrealizedPnl']}")

# Example: check BTC order book spread
book = get_order_book("BTC")
best_bid = book["levels"][0][0]["px"]
best_ask = book["levels"][1][0]["px"]
print(f"BTC spread: {best_bid} / {best_ask}")

WebSocket example: streaming order book updates

import asyncio
import json
import websockets

CHAINSTACK_WSS = "wss://hyperliquid-mainnet.core.chainstack.com/<YOUR_KEY>/ws"

async def stream_order_book(coin: str):
    async with websockets.connect(CHAINSTACK_WSS) as ws:
        # Subscribe to L2 order book
        sub = {
            "method": "subscribe",
            "subscription": {"type": "l2Book", "coin": coin}
        }
        await ws.send(json.dumps(sub))

        # Subscribe to live trades
        trade_sub = {
            "method": "subscribe",
            "subscription": {"type": "trades", "coin": coin}
        }
        await ws.send(json.dumps(trade_sub))

        while True:
            try:
                msg = await ws.recv()
                data = json.loads(msg)
                channel = data.get("channel", "")

                if channel == "l2Book":
                    levels = data["data"]["levels"]
                    best_bid = levels[0][0]["px"] if levels[0] else "N/A"
                    best_ask = levels[1][0]["px"] if levels[1] else "N/A"
                    print(f"[{coin}] Bid: {best_bid} | Ask: {best_ask}")

                elif channel == "trades":
                    for trade in data["data"]:
                        print(f"[TRADE] {trade['coin']} {trade['side']} "
                              f"size={trade['sz']} @ {trade['px']}")

            except websockets.exceptions.ConnectionClosed:
                print("Connection closed — reconnecting...")
                break

asyncio.run(stream_order_book("BTC"))

Best Hyperliquid RPC providers for perps trading: full comparison

The provider landscape for Hyperliquid in 2026 is more developed than it was at launch, but not all providers are equal for trading workloads. The key split is between providers that support HyperCore query routing (essential for trading data) and those that only proxy HyperEVM JSON-RPC (useful for DeFi/EVM work but not for perps).

Chainstack

Chainstack provides private HyperCore info endpoint routing alongside full HyperEVM access, with Global Nodes for shared throughput and Dedicated Nodes for isolated compute. The Unlimited Node add-on removes per-request billing entirely, which matters when your trading bot is making thousands of info queries per hour.

Plans start at free (3M RU/month) and scale through Growth ($49/month, 20M RU), Pro ($199/month, 80M RU), Business ($499/month, 200M RU), and Enterprise ($990+/month, 400M+ RU). Dedicated nodes start at $803/month. SOC 2 Type II and ISO 27001 certified. 99.99%+ uptime SLA on dedicated infrastructure.

Quicknode

Quicknode entered the Hyperliquid ecosystem in mid-2025 and launched HyperCore public beta in January 2026. Notably, Quicknode is the only managed provider that delivers all seven HyperCore data streams through gRPC, Streams, JSON-RPC, and WebSocket from a single unified endpoint that also serves HyperEVM — a meaningful differentiator for teams building advanced trading infrastructure. Rate limits scale to ~400 RPS on paid plans. Pricing uses a credit-based model with no permanent free tier (30-day trial only).

Alchemy

Alchemy’s Hyperliquid support as of 2026 is HyperEVM-only. It does not offer HyperCore query routing or dedicated HyperCore infrastructure. For teams building EVM-native applications on HyperEVM (DeFi protocols, vault strategies, EVM smart contracts that interface with perps), Alchemy’s generous free tier (30M compute units/month) and mature developer tooling are a strong starting point. For direct perps trading data, Alchemy is not the right fit.

Ankr

Ankr launched HyperEVM RPC support in February 2026, running geo-distributed nodes on its own global fiber network with bare-metal hardware. Like Alchemy, Ankr’s current Hyperliquid offering is HyperEVM-focused. The infrastructure runs on dedicated bare-metal nodes rather than cloud VMs, which translates to lower baseline latency for EVM calls. Ankr does not currently offer HyperCore query routing for perps data.

dRPC

dRPC supports Hyperliquid with a straightforward flat pricing model ($6 per million requests) and handles up to 5,000 RPS at peak — the highest raw throughput ceiling of any provider in this comparison. The decentralized failover architecture provides redundancy that centralized providers can’t match. dRPC is a strong fit for cost-sensitive high-volume operations. The trade-off is a newer platform with community-based support rather than enterprise SLAs, and limited Hyperliquid-specific documentation.

GetBlock

GetBlock added HyperEVM Dedicated Node support in September 2025. Access is via standard JSON-RPC and WebSocket APIs on dedicated infrastructure. GetBlock positions itself as a straightforward, fast-to-onboard option for teams that want a dedicated EVM node without complex pricing tiers. HyperCore query routing is not part of the current offering.

Provider comparison table

Provider	HyperCore queries	HyperEVM RPC	Dedicated nodes	Max RPS	Free tier	SOC 2	Starting price
Chainstack	Yes	Yes	Yes	600+ (dedicated)	3M RU/month	Yes (Type II)	Free → $49/mo
Quicknode	Yes (gRPC + WS)	Yes	Yes	~400	30-day trial	Yes	Custom
Alchemy	No	Yes	No	N/A	30M CU/month	Yes	Free
Ankr	No	Yes	No	N/A	Yes	No	Free
dRPC	Partial	Yes	No	5,000	Yes	No	$6/M req
GetBlock	No	Yes (dedicated)	Yes	N/A	No	No	Custom

Provider scoring for perps trading

The scoring chart below evaluates each provider against five criteria weighted for a latency-sensitive perps trading workload.

Scoring categories:

• Latency and throughput (25 points): HyperCore query performance, RPS ceiling, WebSocket stream stability
• Dedicated nodes (25 points): Availability, isolation, pricing transparency for dedicated compute
• Pricing transparency (20 points): Clear per-request costs, plan structure, no hidden fees
• Uptime and SLA (20 points): Guaranteed uptime, monitoring, enterprise SLA availability
• SOC 2 compliance (10 points): Security certification relevant for institutional and regulated trading operations

Real-world performance benchmark

Chainstack maintains a public performance dashboard tracking node response times across supported chains: Chainstack performance dashboard.

The dashboard reports live p50 and p99 latency for Hyperliquid HyperEVM endpoints, measured from multiple global regions. For a perps trading system, the metrics to watch are:

• p50 response time: The median latency for info endpoint queries under normal load — target under 30ms for production trading
• p99 response time: The worst-case tail latency that your trading system will occasionally experience — this determines your worst-case order placement delay
• Error rate: Any non-zero error rate on the info endpoint will cause gaps in position state tracking and order book data

Chainstack’s dedicated Hyperliquid nodes are tuned for consistent p99 performance under sustained query load. For market-making strategies where you are continuously querying the L2 book and position state, the p99 matters more than the p50 — a single slow response can cause your quote refresh to miss the window.

The dashboard is publicly accessible and updates in real time. Use it alongside your own latency monitoring to validate endpoint performance from your specific deployment region.

Institutional and enterprise trading on Hyperliquid

Hyperliquid has attracted institutional and professional trading operations alongside retail. The chain’s non-custodial architecture, fully on-chain order book, and transparent liquidation engine make it auditable in ways that centralized venues are not — a property that matters to compliance teams. For institutional deployments, infrastructure requirements go beyond raw latency:

Dedicated throughput isolation. A shared node means your request queue competes with other tenants during volatile markets — precisely when you need guaranteed capacity. Chainstack’s Dedicated Nodes provide isolated compute with a hard 99.99%+ uptime SLA, eliminating the tail-latency spikes caused by noisy neighbors on shared infrastructure.

Security certification. Trading operations that handle customer funds or operate under any regulatory framework need infrastructure vendors with verifiable security controls. Chainstack’s SOC 2 Type II certification and ISO 27001 compliance mean that an independent auditor has verified Chainstack’s security, availability, and confidentiality controls over a sustained audit period — not just a point-in-time snapshot.

Enterprise SLA and support. The Chainstack Enterprise plan provides dedicated account management, custom SLA terms, and direct engineering support — useful when you’re debugging a latency issue at 3 AM during a high-volatility market event.

Compliance-friendly infrastructure. Unlike some providers that run solely on shared cloud, Chainstack supports deployment across multiple cloud providers (AWS, Azure, GCP) and bare-metal colocation, enabling data residency and network topology choices that compliance policies may require.

Getting started with Hyperliquid on Chainstack

Getting a private Hyperliquid RPC endpoint on Chainstack takes under five minutes:

1. Create a Chainstack account

Go to console.chainstack.com and sign up. The Developer plan is free, requires no credit card, and includes 3M request units per month — enough to test your trading system end to end.

2. Deploy a Hyperliquid node

In the console, create a new project, select Hyperliquid as the protocol, choose mainnet or testnet, and select your preferred cloud region. Chainstack provisions the node and generates your private endpoint URL within a few minutes.

3. Configure your endpoints

You will receive:

• A private HyperCore info endpoint: https://hyperliquid-mainnet.core.chainstack.com//info
• A private HyperEVM RPC endpoint: https://hyperliquid-mainnet.core.chainstack.com//evm
• A WebSocket endpoint: wss://hyperliquid-mainnet.core.chainstack.com//ws

Replace the public api.hyperliquid.xyz/info URL in your trading bot’s config with your private Chainstack endpoint. The /exchange endpoint for order placement remains at api.hyperliquid.xyz/exchange (protocol constraint — not routed through third-party nodes).

4. Scale to dedicated infrastructure

When your strategy is live and you need guaranteed throughput, upgrade to a Dedicated Node or the Unlimited Node add-on. The Unlimited Node removes per-request billing entirely — at high query volumes this is significantly cheaper than paying per million RUs.

Conclusion: choosing your infrastructure by trading strategy

Not every perps trading strategy has the same infrastructure requirements. Here is a recommendation matrix based on workload type:

Strategy type	Latency requirement	Recommended setup
Market making	Sub-30ms p99	Chainstack Dedicated Node, co-located region
Directional / momentum	Sub-50ms p99	Chainstack Pro/Business, nearest region
Arbitrage (cross-venue)	Sub-20ms p99	Chainstack Dedicated Node, premium colocation
Portfolio risk monitoring	Sub-200ms	Chainstack Growth, any region
Strategy backtesting	Throughput-focused	Chainstack with archive access
EVM DeFi + perps hedging	EVM latency focused	Chainstack HyperEVM + HyperCore

For most professional trading operations, the decision is between Chainstack and Quicknode. Quicknode has the edge in HyperCore data stream breadth (gRPC streams). Chainstack has the edge in pricing transparency, dedicated node options at clear price points, compliance certification, and the Unlimited Node option that removes per-request cost at scale.

If you are running a latency-critical market-making or arbitrage strategy, the choice between providers matters less than co-location — placing your trading server in the same cloud region as your RPC endpoint cuts round-trip latency more than any provider-level optimization. Chainstack’s multi-cloud, multi-region deployment supports this architecture directly.

FAQ

Q: Can I place orders through a third-party RPC provider like Chainstack?

No. The /exchange endpoint for signing and submitting orders is a protocol-level function that routes through api.hyperliquid.xyz. No managed RPC provider proxies this endpoint. Your private Chainstack endpoint handles the read workload — position state, order book snapshots, funding data, and open order queries. Order placement and cancellation go directly to the official Hyperliquid API. This is the standard architecture for all Hyperliquid trading bots.

Q: What is the rate limit on the public Hyperliquid endpoint and why does it matter for trading?

Since August 2025, the public HyperEVM RPC at rpc.hyperliquid.xyz/evm is capped at 100 requests per minute per IP address. A trading bot that queries the order book and position state on every tick will exhaust this limit within seconds under normal market conditions. A private RPC endpoint from a provider like Chainstack removes this ceiling and provides consistent throughput at your plan’s RPS limit.

Q: What is the difference between HyperCore and HyperEVM for a perps trader?

HyperCore is the native trading engine where all perpetual markets live. Your trading bot interacts with HyperCore through the /info and /exchange APIs. HyperEVM is the EVM-compatible layer that runs alongside HyperCore. For most perps trading bots, HyperCore queries are the primary workload. HyperEVM becomes relevant if your strategy uses EVM smart contracts (e.g., automated vault rebalancing, cross-protocol hedging, or reading on-chain position data from EVM contracts).

Q: Do I need a dedicated node for perps trading, or is a shared node sufficient?

It depends on your strategy’s latency sensitivity and query volume. Shared nodes (Global Nodes) are appropriate for low-frequency strategies, backtesting, and monitoring dashboards. For market-making, high-frequency directional strategies, or any use case where consistent p99 latency matters, a Dedicated Node provides isolated compute that eliminates the latency spikes caused by shared traffic. The threshold is roughly 60+ requests per minute sustained, or any strategy where a 200ms spike would cause a meaningful missed fill.

Q: How does WebSocket data from a private RPC endpoint compare to the public one?

A private WebSocket endpoint on Chainstack provides the same subscription types (l2Book, trades, userFills, userEvents) as the public endpoint, but with a significantly higher connection and message throughput ceiling. The public WebSocket also disconnects periodically under load. A private endpoint provides more stable connections and the ability to run multiple concurrent subscriptions without hitting shared connection limits.

Q: Is Hyperliquid suitable for institutional trading given its decentralized architecture?

Hyperliquid’s fully on-chain order book is auditable in ways centralized venues are not. Every trade, liquidation, and funding payment is recorded on-chain with one-block finality. The non-custodial architecture means funds are user-controlled at all times. For institutional operations, the infrastructure layer — not the protocol — is where compliance requirements land. Chainstack’s SOC 2 Type II certification, ISO 27001 compliance, and enterprise SLA tier provide the security and contractual posture that institutional trading operations require from their infrastructure vendors.

Additional resources

• Hyperliquid API documentation — official reference for all info and exchange endpoints
• Hyperliquid rate limits and user limits — official rate limit documentation
• Chainstack Hyperliquid infrastructure FAQ — HyperCore vs HyperEVM, endpoint paths, technical details
• Chainstack Hyperliquid developer resources — tutorials, guides, and API reference
• Chainstack performance dashboard — live latency benchmarks for Hyperliquid and 70+ chains
• Chainstack traders page — trading infrastructure overview across all supported chains