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, supporting up to 200,000 orders per second 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 HyperEVM execution, the supported HyperCore info queries, dedicated throughput, and an 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) is not proxied by Chainstack, so those requests go to the official Hyperliquid API.

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 serves HyperEVM plus 46 HyperCore /info query methods (account and state queries such as clearinghouseState and openOrders), while proprietary market-data methods such as l2Book, allMids, and recentTrades and the /exchange actions stay on Hyperliquid’s public API. Dedicated Nodes are available for teams that need isolated throughput and a contractual SLA.

What you get on Chainstack:

• Private HyperCore /info endpoint for the 46 supported query methods, 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 $810/month (testnet) and $1,489/month (mainnet archive) for high-frequency strategies
• 99.99%+ measured uptime, with a contractual SLA (99.9% quarterly, service credits) on Enterprise
• 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>/evm

Important note on order placement: The /exchange endpoint for placing and canceling orders goes to https://api.hyperliquid.xyz/exchange when you use Chainstack, which does not proxy signed trading actions. Your private Chainstack endpoint handles the account and state reads it serves (positions, open orders, margin), while market-data methods such as l2Book and funding history, and all write actions, go to the official API or a streaming provider. 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"
# l2Book and metaAndAssetCtxs are proprietary methods served only by the public Hyperliquid API
PUBLIC_URL = "https://api.hyperliquid.xyz/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(PUBLIC_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(PUBLIC_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

# HyperCore subscriptions (l2Book, trades) are served by Hyperliquid's public WebSocket;
# Chainstack's WSS endpoint carries HyperEVM eth_subscribe streams (newHeads, logs)
PUBLIC_WSS = "wss://api.hyperliquid.xyz/ws"

async def stream_order_book(coin: str):
    async with websockets.connect(PUBLIC_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 $810/month (testnet) and $1,489/month (mainnet archive). SOC 2 Type II and ISO 27001 certified. 99.99%+ measured uptime, with a contractual SLA (99.9% quarterly, service credits) on Enterprise.

Dwellir

Dwellir is a Swedish RPC provider with a long Polkadot track record that now serves 150+ networks, Hyperliquid among them. HyperEVM (chain ID 999) is served over HTTPS and WebSocket with debug and trace enabled on every API plan, and HyperCore data is sold as separate products: a gRPC streaming API with raw node feeds (blocks, fills, order statuses, book diffs) and replay, from $299/month plus usage, and an Order Book API for L2, L4, BBO, and trades served from Singapore and Tokyo, from $199/month plus usage. Archive node files are also published to S3, and direct Hyperliquid peering is available from $500/month per slot.

Shared plans bill one credit per response regardless of method: Free covers 20 responses/second and 100,000 responses per day, Developer is $49/month (25M responses, 100/second), Growth $299/month (150M, 500/second), and Scale $999/month (500M, 5,000/second). A Dedicated Node Cluster for Hyperliquid starts at $4,000/month, unmetered, with gRPC and the Order Book API included and no usage fees. The trade-offs for a perps team: the HyperCore products are add-ons billed on top of the RPC plan, and we found no SOC 2 or ISO 27001 attestation on its public pricing and dedicated-cluster pages.

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 — among the highest raw throughput ceilings 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.

Quicknode

Quicknode entered the Hyperliquid ecosystem in mid-2025 and launched HyperCore public beta in January 2026. Notably, Quicknode 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).

Provider comparison table

Provider	HyperCore queries	HyperEVM RPC	Dedicated nodes	Max RPS	Free tier	SOC 2	Starting price
Chainstack	Partial (46 /info methods)	Yes	Yes	600+ (dedicated)	3M RU/month	Yes (Type II)	Free → $49/mo
Dwellir	Yes (gRPC streaming + Order Book API add-ons)	Yes	Yes (cluster from $4,000/mo)	5,000 responses/s (Scale)	100k responses/day	Not published	Free → $49/mo
Alchemy	No	Yes	No	N/A	30M CU/month	Yes	Free
Ankr	No	Yes	No	N/A	Yes	Type II (report under NDA)	Free
dRPC	Partial	Yes	No	5,000	Yes	Not published	$6/M req
Quicknode	Yes (gRPC + WS)	Yes	Yes	~500	30-day trial	Yes	From $49/mo

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 (Ankr’s SOC 2 Type II report is available only under NDA and was scored as unpublished)

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 99.99%+ measured uptime and a contractual SLA on Enterprise, 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/<YOUR_KEY>/info
• A private HyperEVM RPC endpoint: https://hyperliquid-mainnet.core.chainstack.com/<YOUR_KEY>/evm
• A HyperEVM WebSocket endpoint: wss://hyperliquid-mainnet.core.chainstack.com/<YOUR_KEY>/evm

Point the account and state queries in your trading bot’s config at your private Chainstack endpoint; market-data methods such as l2Book stay on the public api.hyperliquid.xyz/info URL. The /exchange endpoint for order placement remains at api.hyperliquid.xyz/exchange (not proxied by Chainstack).

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. Market makers that need live order book or trade streams should pair Chainstack’s HyperEVM and account-state endpoints with Hyperliquid’s public API or a streaming provider such as Quicknode or Dwellir. Quicknode has the edge in HyperCore data stream breadth (gRPC streams); Dwellir is the third option when you want gRPC streaming and an Order Book API with a dedicated-cluster path, though it publishes no compliance attestation. 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 served by api.hyperliquid.xyz; Chainstack does not proxy this endpoint. Your private Chainstack endpoint handles the account and state reads it serves — position state, open orders, and margin queries — while market-data methods such as order book snapshots and funding history come from the official API or a streaming provider. 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 a sustained request rate that approaches your plan’s RPS limit, 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?

Chainstack’s private WebSocket carries HyperEVM subscriptions (eth_subscribe for newHeads, logs, and syncing) without the public endpoint’s per-IP limits. HyperCore subscriptions such as l2Book, trades, userFills, and userEvents come from Hyperliquid’s public WebSocket, which caps connections and subscriptions per IP and disconnects periodically under load. Providers such as Quicknode (HyperCore gRPC streaming) and Dwellir (gRPC and Order Book add-ons) offer private HyperCore streams.

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