Hyperliquid RPC providers give trading bots and on-chain applications access to blockchain state, native exchange data, order books and transaction information. The main difference is whether a provider supports HyperCore market-data feeds, HyperEVM contract calls, historical indexing, or a combination of these services. This comparison is based on each provider's official documentation and published features, checked in November 2026; we have not tested the tools hands-on.
Which one to pick
- Need native L2/L4 order books and gRPC fills: Dwellir, with dedicated order-book WebSocket and gRPC interfaces.
- Want HyperCore and HyperEVM under one account: QuickNode, with Info queries, JSON-RPC and plan-gated streaming.
- Need per-block book updates and fill recovery: Alchemy, with incremental L2 data, L4 updates and replay support, although its HyperCore API is beta.
- Need routed native reads and exchange actions: dRPC, which supports both HyperCore /info and /exchange paths.
- Building a historical-data indexer: Envio HyperRPC for read-only MIP-16 queries, with HyperSync for bulk data and HyperIndex for indexing.
- Prefer managed HTTP and EVM access: OnFinality for documented market and account queries, NOWNodes for broader RPC interfaces, Chainstack for private endpoints, or GetBlock for HyperCore system-transaction lookups.
Compare Hyperliquid RPC and trading-data access
| Tool | Type or use case | HyperCore / HyperEVM access | Price |
|---|---|---|---|
| Dwellir | Live books and fill streams | Info, L2/L4 WebSocket, gRPC and EVM | Order Book $199/month or gRPC $299/month, plus API plan |
| QuickNode | Combined HyperCore and HyperEVM infrastructure | /info, HyperCore WebSocket/gRPC and EVM RPC | Free trial; Build from $49/month on monthly billing |
| Alchemy | Block-level market-data subscriptions | HyperCore WebSocket/gRPC and HyperEVM | 30M free CUs/month; PAYG $0.525 per million CUs; HyperCore free during launch week; later pricing unpublished |
| dRPC | Routed HyperCore API access | /info, /exchange and archive flags | Pay-as-you-go; Hyperliquid-specific rate not published |
| OnFinality | HTTP Info queries and EVM RPC | /info market/account reads, EVM HTTPS, WebSocket and archive | Free plan: 400,000 response units/day, up to 40 requests/s |
| NOWNodes | EVM and account-state queries | JSON-RPC, Info, WSS, trace/debug and archive | Start plan: 100,000 requests/month |
| Envio HyperRPC | Read-heavy indexing | Read-only MIP-16 RPC, HyperSync and HyperIndex | $4 per million calls; $1 monthly minimum |
| Chainstack | Private managed endpoints | Private /evm and /info endpoints | Paid plans; Growth from $49/month |
| GetBlock | HyperEVM system-transaction reads | HyperEVM JSON-RPC and system-transaction methods | Free access varies by configuration; some HyperEVM setups are paid-only; plans from $39/month |
The tools
Dwellir
Native market-data streaming
Dwellir combines HyperEVM JSON-RPC with HyperCore Info, a dedicated Order Book WebSocket API and typed gRPC streams. Its reference lists L2 snapshots and diffs, L4 book and order updates, trades, candles and user or all-account fills. The gRPC interface also exposes block-level records and replays retained data from a chosen block or timestamp. The Order Book and gRPC products are add-ons to an API platform plan, with streamed messages consuming credits. A dedicated cluster bundles these interfaces for teams requiring isolated infrastructure.
Choose it when you need native book depth or execution updates delivered through persistent streams rather than repeated HTTP polling.
Watch out for shared-cluster add-ons being billed separately from the underlying API plan and metered by message volume.
QuickNode
Combined HyperCore and HyperEVM infrastructure
QuickNode covers both HyperEVM and HyperCore: its /info endpoint exposes 73 methods, while /hypercore provides JSON-RPC and WebSocket access and gRPC handles live market streams. The free trial includes HyperEVM and /info; native HyperCore JSON-RPC, WebSocket and gRPC require Build or higher. For older EVM state, /nanoreth is documented for archive, debug and trace queries, whereas /evm prunes older state. The separate SQL Explorer product also supports analytical workflows.
Choose it when you want one provider account for Info queries, live streams and contract RPC.
Watch out for stream concurrency, filter caps and credit consumption varying by subscription tier and data volume.
Alchemy
Block-level HyperCore subscriptions
Alchemy provides a separate HyperCore WebSocket endpoint alongside its HyperEVM RPC. Its documentation describes per-block book updates, incremental L2 diffs, order-level L4 updates, multi-market subscriptions and fill replay from a chosen block after reconnecting. Sequence numbers help applications identify missed messages. The subscription API is explicitly marked beta, so payload fields, limits and behavior can change. Standard Alchemy plans use compute-unit billing, while the HyperCore documentation does not provide a settled subscription tariff.
Choose it when block-level book changes or fill recovery justify accepting a beta interface.
Watch out for changing beta behavior and separate connection and subscription limits that require careful production planning.
dRPC
Routed HyperCore API access
dRPC's NodeCloud routes Hyperliquid API traffic through its managed RPC infrastructure. Its July 2026 product update documents full HyperCore routing for both /info and /exchange, together with URL flags to include or exclude native system transactions in block and receipt results on mainnet and testnet. NodeCloud uses pay-as-you-go pricing, but its published update does not provide a Hyperliquid-specific request rate or a dedicated order-book streaming specification.
Choose it when managed routing for both HyperCore read requests and exchange API calls is the priority.
Watch out for assuming that endpoint routing automatically includes gRPC or an independent high-frequency market-data feed.
OnFinality
HTTP market and account queries
OnFinality exposes HyperEVM JSON-RPC and a separate /info route for HyperCore reads. Its supported-method documentation includes l2Book, allMids, openOrders, orderStatus, userFills and portfolio queries, alongside standard EVM methods. The EVM service lists HTTPS, WebSocket and archive support. A public endpoint is available without authentication, while an API key provides higher capacity and usage insights. The provider publishes a free allowance of 400,000 response units per day and up to 40 requests per second.
Choose it when HTTP snapshots and account queries are priorities alongside managed EVM access.
Watch out for the public endpoint's 5-request-per-second restriction and the distinction between EVM WebSocket subscriptions and native HyperCore book streams.
NOWNodes
Multiple RPC and account interfaces
NOWNodes exposes Hyperliquid EVM JSON-RPC and an Info API for account, order, borrow/lend and market-metadata queries. Its documentation also lists WebSocket connections, trace/debug and archive interfaces, with setup through an API key and network selection. The Start tier includes a free monthly request allowance, while paid tiers provide larger quotas and overage arrangements. Its published interface list does not identify a dedicated L2/L4 order-book subscription product, so its documented strengths are managed RPC and account-state access rather than specialized market streaming.
Choose it when standard EVM access, account-state queries and optional trace or archive interfaces are sufficient.
Watch out for the absence of a clearly specified dedicated order-book streaming interface in its published Hyperliquid documentation.
Envio HyperRPC
Read-only data and indexing
Envio HyperRPC is a token-protected, read-only mainnet endpoint for HyperEVM data. It supports standard block, transaction, receipt and log reads, plus MIP-16 methods that filter blocks, transactions and logs at the server. For bulk or continuous indexing, HyperSync supplies selected historical and real-time chain data, while HyperIndex turns contract events into a GraphQL API. The published HyperRPC price is $4 per million JSON-RPC method calls with a $1 monthly minimum. Batch members count as individual calls.
Choose it when you are backfilling or querying historical EVM events and can keep transaction submission elsewhere.
Watch out for its read-only scope and the documented mainnet-only HyperRPC endpoint.
Chainstack
Private managed Hyperliquid endpoints
Chainstack's GEN service lets developers deploy private Hyperliquid endpoints for mainnet or testnet. Its setup guide lists separate /evm and /info URLs and exposes request logs, metrics and access rules in the dashboard. This provides a managed alternative to sharing the public EVM endpoint. The platform bills in request units under its standard plans, and its Growth tier has an included monthly allowance with overage charges. The public guide does not enumerate every Info method, so book depth, fill history and subscription support should be checked against the actual deployment.
Choose it when you need a private EVM endpoint and a separate Info route on a paid plan.
Watch out for assuming that the documented private endpoints establish complete HyperCore streaming or /exchange coverage.
GetBlock
HyperEVM JSON-RPC and system transactions
GetBlock documents a mainnet HyperEVM JSON-RPC endpoint with standard EVM methods and Hyperliquid-specific system-transaction lookups by block hash or block number. Its method table also identifies historical-query restrictions: eth_getLogs is limited to 50 blocks, while several state reads, including balance, code and storage, are latest-block only. Free access depends on network and region; some HyperEVM configurations require a paid plan. Its Hyperliquid reference does not publish a network-specific tariff or a native HyperCore order-book interface.
Choose it when you primarily need HyperEVM contract reads or HyperCore system-transaction inspection.
Watch out for historical state limitations and the need to split broad log queries into smaller ranges.
How to connect a trading bot to Hyperliquid RPC
- Separate your data requirements. Use HyperCore interfaces for native order books, open orders, fills, positions and account state. Use HyperEVM JSON-RPC for smart-contract calls, balances, logs and EVM transactions. An EVM endpoint alone does not provide every native exchange feed.
- Select the provider and transport. Consider Dwellir for L2/L4 WebSocket and gRPC, QuickNode for combined native and EVM access, or Alchemy for its beta book-update and fill-replay interfaces. For routed requests, examine dRPC; for read-heavy indexing, consider Envio.
- Create credentials for the correct environment. Generate an API key, select mainnet or testnet and store the endpoint in a server-side configuration. HyperEVM uses chain ID 999 on mainnet and 998 on testnet. Do not assume that an EVM endpoint and a HyperCore endpoint share identical access permissions.
- Run basic connectivity checks. Query eth_chainId and eth_blockNumber through the EVM endpoint. Through the Info interface, request market metadata, allMids, l2Book and the relevant account state. Confirm that the returned fields and timestamps match your application requirements.
- Establish your live subscriptions. Subscribe to the required book, trade or fill feeds using WebSocket or gRPC where available. Seed an order-book reconstruction with a valid snapshot before applying incremental updates. If using Alchemy, account for its subscription IDs, sequence numbers and fill-replay parameters.
- Keep order execution separate. Sign trading actions in your own controlled environment and submit them through Hyperliquid's native /exchange interface. A HyperEVM JSON-RPC transaction is not the same operation as submitting a native perpetual order. Validate signatures, nonces and responses before updating internal order state.
- Load-test and monitor the connection. Record message gaps, reconnects, stale timestamps, HTTP 429 responses, failed requests and actual provider usage. Add exponential backoff, periodic state reconciliation and a secondary endpoint. Check the provider's stream caps and billing units against your measured workload.
Worked example (illustrative): Suppose a bot watches BTC, ETH and SOL order books and monitors one trading account. It subscribes to three L2 feeds and one user-fill stream through Dwellir or an eligible QuickNode plan, then takes a fresh snapshot whenever the connection needs rebuilding. Signed orders travel through the separate exchange submission path, while a 30-minute test records missing updates, reconnects, stale data and API consumption.
Execution, data and infrastructure risks
Never let a market-data feed trigger a blind order: validate sequence numbers and timestamps, reject stale snapshots, and reconcile fills and positions against account state before changing exposure. Keep signing keys separate from RPC credentials, isolate read-only and execution permissions, and configure usage limits and a fallback endpoint so throttling or provider outages cannot silently leave a bot acting on outdated information.
Frequently asked questions
Does Hyperliquid RPC include the live order book?
HyperCore Info queries return book snapshots; continuous updates require a WebSocket or gRPC subscription. A conventional HyperEVM endpoint handles contract calls and logs but does not automatically deliver native exchange-market updates.
Can I send perpetual orders through HyperEVM JSON-RPC?
No. Native exchange actions use Hyperliquid's signed /exchange interface. EVM transactions interact with smart contracts on HyperEVM and should not be confused with native perpetual order submission.
Which providers document L4 order-book data?
Dwellir documents L4 WebSocket and gRPC methods, QuickNode documents L4 gRPC streams, and Alchemy describes L4 updates through its beta HyperCore API. Check the supported message schema and subscription limits before depending on either feed.
Do I need archive access for a trading bot?
Not necessarily for current order-book snapshots, but archive data is useful for historical event backfills, audits and replay across older blocks. Check historical method restrictions because archive access does not guarantee unrestricted access to every state query.
Are free RPC plans sufficient for production?
They can cover development and light monitoring, but production workloads need capacity planning around method weights, stream bandwidth, connection limits and monthly quotas. A request allowance alone does not describe the cost of continuous market-data subscriptions.
Should I use WebSocket or gRPC for live trading data?
WebSocket is convenient for application-level subscriptions, while gRPC provides typed interfaces for high-volume block, book and fill streams where supported. Both require reconnection handling, state reconciliation and protection against missed updates.
Sources
Show all 17 sources
- Dwellir — Hyperliquid API and pricing documentation
- QuickNode — Hyperliquid API reference
- QuickNode — Hyperliquid plan access and credits
- QuickNode — Platform pricing
- Alchemy — HyperCore subscription and migration documentation
- Alchemy — HyperCore limits
- Alchemy — Official pricing
- dRPC — HyperCore support and platform updates
- OnFinality — Hyperliquid endpoints and pricing
- OnFinality — Supported RPC and Info methods
- NOWNodes — Hyperliquid API documentation
- NOWNodes — Plans and pricing
- Envio — Hyperliquid HyperRPC and indexing
- Chainstack — Hyperliquid RPC setup guide
- Chainstack — Official pricing
- GetBlock — Hyperliquid HyperEVM API reference
- GetBlock — Free and paid plan information