HyperRPC: Ultra-Fast Read-Only RPC

HyperRPC is an extremely fast read-only RPC designed specifically for data-intensive blockchain tasks. Built from the ground up to optimize performance, it offers a simple drop-in solution with dramatic speed improvements over traditional nodes.

HyperSync vs. HyperRPC

For most use cases, we recommend using HyperSync over HyperRPC.

HyperSync provides significantly faster performance and much greater flexibility in how you query and filter blockchain data. Behind the scenes, HyperRPC actually uses HyperSync to fulfill requests. If you want a full indexing framework with schema management, event handlers, and a hosted GraphQL API on top of HyperSync, see HyperIndex.

When to use HyperRPC:

When you need a simple drop-in replacement for existing RPC-based code
When you don't have time for a deeper integration
When you're working with tools that expect standard JSON-RPC interfaces

When to use HyperSync:

When performance is critical (HyperSync is much faster)
When you need advanced filtering capabilities
When you want more control over data formatting and field selection
For new projects where you're designing the data access layer

What is HyperRPC?
Performance Advantages
Supported Methods
Supported Networks
Getting Started
Billing
Development Status

What is HyperRPC?

HyperRPC is a specialized JSON-RPC endpoint that focuses exclusively on read operations to deliver exceptional performance. By optimizing specifically for data retrieval workflows, HyperRPC can significantly outperform traditional nodes for data-intensive applications.

Key characteristics:

Read-only: Optimized for data retrieval (cannot send transactions)
Drop-in compatible: Works with existing tooling that uses standard RPC methods
Specialized: Designed specifically for data-intensive operations like eth_getLogs
Cryptographically verified: As each block is ingested, its transactions and receipts are used to recompute the transactionsRoot and receiptsRoot in the block header, and data that doesn't match is refetched from another source. See Nodes silently miss events.

Performance Advantages

Early benchmarks show that HyperRPC can deliver up to 5x performance improvement for data-intensive operations compared to traditional nodes like geth, erigon, and reth.

This performance boost is particularly noticeable for:

Historical data queries
Log event filtering
Block and transaction retrievals
Analytics applications

Supported Methods

HyperRPC currently supports the following Ethereum JSON-RPC methods:

Category	Methods
Chain Data	`eth_chainId` `eth_blockNumber` `eth_gasPrice` `net_version` `web3_clientVersion`
Block Data	`eth_getBlockByNumber` `eth_getBlockByHash` `eth_getBlockReceipts`
Transaction Data	`eth_getTransactionByHash` `eth_getTransactionByBlockHashAndIndex` `eth_getTransactionByBlockNumberAndIndex` `eth_getTransactionReceipt`
Event Logs	`eth_getLogs`
Log Filters	`eth_newFilter` `eth_getFilterLogs` `eth_getFilterChanges` `eth_uninstallFilter`
Traces	`trace_block` (only on select chains)

HyperRPC also serves the MIP-16 query methods eth_queryBlocks, eth_queryTransactions and eth_queryLogs. See MIP-16 query methods.

Any other method outside MIP-16, including state reads such as eth_call, eth_getBalance and eth_getCode and writes such as eth_sendRawTransaction, returns JSON-RPC error -32601 with Method not found: <method>.

Limits and Errors

Block parameters: block numbers, latest and earliest. pending is not supported by most methods, and safe and finalized are not accepted.
Batches: up to 500 calls per batch request. A larger batch fails with -32000 Limit exceeded: More than 500 requests.
eth_getLogs: there is no block-range cap, but one call returns at most 50,000 logs. Above that it fails with -32000 Limit exceeded: More than 50000 logs returned; this block range should work: [0x..., 0x...], which suggests a smaller range to retry with.
Response size: a response larger than 150 MB fails with -32000 Limit exceeded: Response size larger than 150 MB.
Filters: eth_newFilter creates log filters only. Filters are not persisted and can disappear without notice. Poll with eth_getLogs if you can't afford to miss data.
Traces: on an endpoint without traces, trace_block returns -32004 with a message that points to the chain's traces endpoint, or to Discord support if there is none.

Supported Networks

HyperRPC is available across numerous EVM-compatible networks. For the most up-to-date list of supported chains, please see our Supported Networks page.

Getting Started

To start using HyperRPC:

Get Access:
- Visit our Supported Networks page to find all available HyperRPC endpoints
- Each network has a ready-to-use URL that you can start using immediately
Add Your API Token (required):
- Requests without an API token are rejected. See API Tokens for how to create one and common errors.
- Append your token to the endpoint URL. Example:
```
https://100.rpc.hypersync.xyz/<api-token>
```
- If you don't have a token yet, you can generate one on the HyperRPC Tokens page of the Envio Dashboard. A token from a HyperSync-only package gets HTTP 403 Your token does not have access to this product.

Use Like a Standard RPC:

// Example: Fetching logs with HyperRPC
const response = await fetch("https://100.rpc.hypersync.xyz/<api-token>", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "eth_getLogs",
    params: [
      {
        fromBlock: "0x1000000",
        toBlock: "0x1000100",
        address: "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d", // WXDAI on Gnosis
      },
    ],
  }),
});

Provide Feedback: Your testing and feedback are incredibly valuable as we continue to improve HyperRPC. Let us know about your experience in our Discord.

Billing

A free tier with rate-limited endpoints is available for development, at no cost. See HyperRPC pricing.

Beyond the free tier, HyperRPC usage is billed monthly in arrears at $4 per million JSON-RPC method calls, with a $1 monthly minimum. Each method in a JSON-RPC batch request counts as one call.

Sub-month invoicing

Invoices normally cover a full calendar month, but usage may occasionally be invoiced for a sub-period of the month, for example a mid-month invoice when usage is substantial, with the remainder of the month invoiced at month end. Split invoices never overlap, so no usage is ever billed twice, and the $1 monthly minimum applies at most once per calendar month.

Development Status

Important Notice

HyperRPC is under active development to further improve performance and stability
It is designed for read-only operations and does not support all standard RPC methods
It has not yet undergone formal security audits
We welcome questions and feedback in our Discord

Table of Contents​

What is HyperRPC?​

Performance Advantages​

Supported Methods​

Limits and Errors​

Supported Networks​

Getting Started​

Billing​

Development Status​

Table of Contents