Blockchain infrastructure

Top 9 Hyperliquid RPC Providers (2026)

Compare QuickNode, Dwellir, Alchemy, dRPC and others for HyperCore feeds, HyperEVM RPC, indexing, pricing and trading-bot integration.

Tools at a glance

9 listed tools
  1. Dwellir
  2. QuickNode
  3. Alchemy
  4. dRPC
  5. OnFinality
  6. NOWNodes
  7. Envio HyperRPC
  8. Chainstack
  9. GetBlock

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

ToolType or use caseHyperCore / HyperEVM accessPrice
DwellirLive books and fill streamsInfo, L2/L4 WebSocket, gRPC and EVMOrder Book $199/month or gRPC $299/month, plus API plan
QuickNodeCombined HyperCore and HyperEVM infrastructure/info, HyperCore WebSocket/gRPC and EVM RPCFree trial; Build from $49/month on monthly billing
AlchemyBlock-level market-data subscriptionsHyperCore WebSocket/gRPC and HyperEVM30M free CUs/month; PAYG $0.525 per million CUs; HyperCore free during launch week; later pricing unpublished
dRPCRouted HyperCore API access/info, /exchange and archive flagsPay-as-you-go; Hyperliquid-specific rate not published
OnFinalityHTTP Info queries and EVM RPC/info market/account reads, EVM HTTPS, WebSocket and archiveFree plan: 400,000 response units/day, up to 40 requests/s
NOWNodesEVM and account-state queriesJSON-RPC, Info, WSS, trace/debug and archiveStart plan: 100,000 requests/month
Envio HyperRPCRead-heavy indexingRead-only MIP-16 RPC, HyperSync and HyperIndex$4 per million calls; $1 monthly minimum
ChainstackPrivate managed endpointsPrivate /evm and /info endpointsPaid plans; Growth from $49/month
GetBlockHyperEVM system-transaction readsHyperEVM JSON-RPC and system-transaction methodsFree access varies by configuration; some HyperEVM setups are paid-only; plans from $39/month

The tools

Dwellir

Native market-data streaming

Type or use caseLive books and fill streamsPriceOrder Book $199/month or gRPC $299/month, plus API plan

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

Type or use caseCombined HyperCore and HyperEVM infrastructurePriceFree trial; Build from $49/month on monthly billing

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

Type or use caseBlock-level market-data 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

Type or use caseRouted HyperCore API accessPricePay-as-you-go; Hyperliquid-specific rate not published

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

Type or use caseHTTP Info queries and EVM RPCPriceFree plan: 400,000 response units/day, up to 40 requests/s

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

Type or use caseEVM and account-state queriesPriceStart plan: 100,000 requests/month

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

Type or use caseRead-heavy indexingPrice$4 per million calls; $1 monthly minimum

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

Type or use casePrivate managed endpointsPricePaid plans; Growth from $49/month

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

Type or use caseHyperEVM system-transaction reads

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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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