# BlockReq Docs (full text)

> BlockReq serves JSON-RPC endpoints for 26 published networks. Each network has its own hostname: a private URL is `https://<network hostname>/v1/rpc/<API key>`, and `/v1/rpc/public` on the same host is a rate-limited public trial. These docs cover setup, API keys, Request Counting and plans, and a JSON-RPC reference for 25 EVM networks.

This file concatenates the English BlockReq docs. Per-network method pages are summarized by the capability table and one entry per JSON-RPC method. Proof, debug, and trace methods are documented only for archive networks in the ethereum, bsc, arbitrum, base, polygon families. Links to every page: https://blockreq.com/docs/llms.txt

# Welcome to BlockReq!

BlockReq is a multi-chain Web3 RPC platform with public HTTPS and WSS endpoints. Sign up to register an account, then create authenticated endpoints for Ethereum, Base, BSC, Arbitrum, and more.

## Why BlockReq?

- **Multi-Chain Support** — Access Ethereum, Base, BSC, Arbitrum and more through a unified API.
- **Low Latency** — Cloudflare Edge entry and provider-aware routing reduce global response times.
- **Pay-As-You-Go** — One-time Request Packs plus PAYG at $3.90 per 1M Requests used.
- **Easy Integration** — Standard JSON-RPC and WebSocket endpoints, compatible with all Web3 libraries.
- **Real-Time Analytics** — Monitor Requests and Requests used in the Dashboard.

## Quick Start

1. [Sign up](https://blockreq.com) for a free account
2. [Create an endpoint](https://blockreq.com/docs/getting-started/create-endpoint/index.md) for your target blockchain
3. Copy the RPC URL and start building!

```bash
# Example: Query latest block on Ethereum
curl -X POST https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'
```

## Try It Now — Public Endpoints

No API key needed! Use our free public endpoints (5 req/s per IP):

```bash
curl -X POST https://ethereum-rpc.blockreq.com/v1/rpc/public \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'
```

See [Public Endpoints](https://blockreq.com/docs/build/public-endpoints/index.md) for all available networks.

## Developer Resources

| Resource                                         | Description                              |
| ------------------------------------------------ | ---------------------------------------- |
| [Supported Networks](https://blockreq.com/docs/build/supported-networks/index.md) | Full list of supported blockchains       |
| [API Reference](https://blockreq.com/docs/build/api-reference/index.md)           | Complete JSON-RPC method documentation   |
| [Public Endpoints](https://blockreq.com/docs/build/public-endpoints/index.md)     | Free rate-limited public RPC access      |
| [Request Counting](https://blockreq.com/docs/pricing/request-counting/index.md)   | How distinguishable Requests are counted |
| [FAQ](https://blockreq.com/docs/support/faq/index.md)                             | Common questions answered                |

## Get in Touch

- Email: [support@blockreq.com](mailto:support@blockreq.com)
- GitHub: [github.com/blockreq](https://github.com/blockreq)

Source: https://blockreq.com/docs/welcome/

# About BlockReq

## What is BlockReq?

BlockReq is a Web3 RPC infrastructure provider. We offer blockchain node access over HTTPS and WebSocket, entering through the Cloudflare edge and served from regional origins with automatic failover.

## Our Mission

To make blockchain data access simple, affordable, and reliable for every developer — from independent hackers to enterprise teams.

## Key Features

### Multi-Chain Support

Access every served network through one API, including Ethereum, Base, BSC, Arbitrum, Polygon, Optimism, Avalanche, and Gnosis. See [Supported Networks](https://blockreq.com/docs/build/supported-networks/index.md) for the current list.

### Reliability

- Cloudflare edge entry with regional origins and automatic failover
- Archive, debug, and trace methods where the network supports them

### Fair Pricing

- **Free grant**: 3M Requests with a 30-day validity window
- **Pay-as-you-go**: $3.90 per 1M Requests used after prepaid Requests are exhausted
- **Request Packs**: One-time packs for higher volume

### Developer-Friendly

- Standard JSON-RPC over HTTPS and WSS
- Compatible with ethers.js, viem, web3.py, Foundry, Hardhat, and other major SDKs
- One-click MetaMask integration
- Built-in RPC testing tools

### Analytics Dashboard

- Real-time Request Count monitoring
- Requests used breakdown by method class
- API key management
- Billing and transaction history

Source: https://blockreq.com/docs/welcome/about/

# Glossary

| Term                   | Definition                                                                                                                         |
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| **Request Counting**   | How BlockReq counts distinguishable customer Requests and Requests used.                                                           |
| **Requests**           | Customer JSON-RPC items and successfully delivered WSS events or notifications.                                                    |
| **Requests used**      | Requests after the method multiplier is applied.                                                                                   |
| **Requests remaining** | Spendable prepaid Requests across active free-grant and Request Pack lots.                                                         |
| **Request Pack**       | A one-time prepaid request lot (Starter, Growth, Professional, or Business) with its own validity window.                          |
| **PAYG**               | Billing mode that accrues at $3.90 per 1M Requests used after prepaid Requests are exhausted.                                      |
| **Wallet balance**     | Settled USD value used to fund PAYG and eligible purchases; separate from Requests remaining.                                      |
| **Endpoint**           | A chain-specific RPC access point with credential and policy metadata.                                                             |
| **API Key**            | A credential used to authenticate endpoint requests.                                                                               |
| **Chain**              | A blockchain network such as Ethereum Mainnet, Base, or BSC.                                                                       |
| **JSON-RPC**           | The request/response protocol used by supported blockchain nodes.                                                                  |
| **HTTPS**              | Secure HTTP transport for standard request-response RPC calls.                                                                     |
| **WSS**                | WebSocket Secure transport for persistent connections and real-time subscriptions such as `eth_subscribe`.                         |
| **Archive Data**       | Historical blockchain state for deep-history reads. Availability depends on chain and route capability, not only the billing tier. |
| **Rate Limit**         | Sustained and burst request limits from the effective plan.                                                                        |
| **Free grant**         | A 3M-Request lot with a 30-day validity window.                                                                                    |

Source: https://blockreq.com/docs/welcome/glossary/

# Registration & Login

## Prerequisites

- A modern web browser
- An email address or Web3 wallet for registration

## Steps

1. **[Registration & Login](#registration--login)** — Create your BlockReq account
2. **[Create an Endpoint](https://blockreq.com/docs/getting-started/create-endpoint/index.md)** — Set up your first RPC endpoint
3. **[Wallet Setup](https://blockreq.com/docs/getting-started/wallet-setup/index.md)** — Add BlockReq RPC to MetaMask

---

## Registration & Login

1. Visit [blockreq.com](https://blockreq.com)
2. Click **Get Started** in the top navigation
3. Sign up with your email or connect a Web3 wallet
4. You'll be redirected to the Dashboard automatically

> **Free grant included**: Every eligible new account can receive 3M Requests with a 30-day validity window — no credit card required.

## Next Steps

Once registered, head to [Create Your First Endpoint](https://blockreq.com/docs/getting-started/create-endpoint/index.md) to start making RPC calls.

Source: https://blockreq.com/docs/getting-started/

# API Keys & Applications

API keys are used to authenticate your requests to BlockReq's RPC endpoints. Each endpoint you create comes with its own API key.

## Getting Your API Key

### From the Dashboard

1. Sign in to [BlockReq Dashboard](https://blockreq.com/dashboard)
2. Go to **[Settings](https://blockreq.com/dashboard/settings)** in the left sidebar
3. Your API keys are listed under the **API Keys** section
4. Click the copy icon to copy any key

### From an Endpoint

Each endpoint displays its API key, HTTPS URL, and WSS URL. Navigate to **[Endpoints](https://blockreq.com/dashboard/endpoint)** to view all your endpoints.

## Creating an Application (Endpoint)

An endpoint is your gateway to a specific blockchain network. To create one:

1. Go to **[Endpoints](https://blockreq.com/dashboard/endpoint)**
2. Click **+ Add Endpoint**
3. Select a blockchain network
4. (Optional) Give it a descriptive name
5. Your endpoint is ready — copy the RPC URL and start building

See [Create Your First Endpoint](https://blockreq.com/docs/getting-started/create-endpoint/index.md) for a detailed walkthrough with code examples.

## Using Your API Key

Replace `BRQ1P0000000000000000000000000000000000000000000000000000000` in the endpoint URL:

```
HTTPS: https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000
WSS:   wss://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000
```

### Quick Example

```bash
curl -X POST https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'
```

## Programmatic Management

Management REST lives on Web. Use a Management API Key as `Authorization: Bearer akv1_...` — the same owner as a dashboard session. See the [BlockReq API](https://blockreq.com/docs/build/api-reference/blockreq-api/index.md).

| Operation       | Path                                 |
| --------------- | ------------------------------------ |
| List networks   | `GET /api/dashboard/chains`          |
| Create endpoint | `POST /api/dashboard/endpoints`      |
| List endpoints  | `GET /api/dashboard/endpoints`       |
| Delete endpoint | `DELETE /api/dashboard/endpoints`    |
| Usage stats     | `GET /api/dashboard/endpoints/stats` |

## Security Best Practices

- **Never expose API keys in client-side code** — use a backend proxy
- **Rotate keys** by creating a new endpoint and updating your configuration
- **Use separate endpoints** for development, staging, and production
- **Monitor usage** on the [Dashboard](https://blockreq.com/dashboard) to detect unusual activity

Source: https://blockreq.com/docs/getting-started/api-keys/

# Create Your First Endpoint

An **endpoint** is your gateway to a blockchain network. Each endpoint includes:

- An **HTTPS** RPC URL for standard calls
- A **WSS** URL for WebSocket subscriptions
- A unique **API Key**

## Steps

### 1. Navigate to Endpoints

From the Dashboard, click **Endpoints** in the left sidebar (or visit `/dashboard/endpoint`).

### 2. Click "Add Endpoint"

Click the **+ Add Endpoint** button in the top right corner.

### 3. Select a Blockchain

Choose from the available networks:

| Network      | Chain ID | Slug               | Features                                  |
| ------------ | -------- | ------------------ | ----------------------------------------- |
| Ethereum     | 1        | `ethereum-rpc`     | Full; archive verification varies         |
| Base         | 8453     | `base-rpc`         | Full; archive verification varies         |
| BSC          | 56       | `bsc-rpc`          | Full; archive verification varies         |
| Arbitrum One | 42161    | `arbitrum-one-rpc` | Full; archive verification varies         |
| Polygon      | 137      | `polygon-bor-rpc`  | Keyed archive; public trial is restricted |

### 4. Name Your Endpoint (Optional)

Give your endpoint a descriptive name, e.g., "My DeFi Bot" or "Production Backend".

### 5. Start Using Your Endpoint

After creation, you'll see your RPC URLs:

```
HTTPS: https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000
WSS:   wss://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000
```

### Example Usage

**cURL**

```bash
curl -X POST https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'
```

**ethers.js**

```javascript
import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000");
const blockNumber = await provider.getBlockNumber();
console.log("Latest block:", blockNumber);
```

**viem**

```typescript
import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000"),
});
const blockNumber = await client.getBlockNumber();
console.log(blockNumber);
```

**web3.py**

```python
from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000"))
print("Latest block:", w3.eth.block_number)

```

**Foundry**

```bash
cast rpc --rpc-url https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000 eth_blockNumber
```

**Hardhat**

```javascript
const { ethers } = require("hardhat");

async function main() {
  const provider = new ethers.JsonRpcProvider("https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000");
  console.log(await provider.send("eth_blockNumber", []));
}

main();
```

## Built-in RPC Tester

Each endpoint includes a built-in RPC tester. Click the **Test** button to open it, select an RPC method, and run it directly from your browser.

```

```

Source: https://blockreq.com/docs/getting-started/create-endpoint/

# Wallet Setup

Add BlockReq's RPC endpoint to your browser wallet for a faster, more reliable Web3 experience.

## MetaMask

### Automatic (One-Click)

1. Go to your **Endpoints** page in the Dashboard
2. Find the endpoint for the desired network
3. Click the **Add to Wallet** button
4. MetaMask will prompt you to approve the network addition
5. Click **Approve** — done!

### Manual

1. Open MetaMask → **Settings** → **Networks** → **Add a Network**
2. Fill in the details:

| Field | Value |
|-------|-------|
| Network Name | Ethereum (BlockReq) |
| New RPC URL | `https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| Chain ID | 1 |
| Currency Symbol | ETH |
| Block Explorer URL | `https://etherscan.io` |

3. Click **Save**

> Repeat for other chains, using the appropriate Chain ID and RPC URL from your endpoint.

## Other Wallets

BlockReq endpoints use standard JSON-RPC, so they work with any EVM-compatible wallet:

- **Rabby** — Settings → Custom RPC
- **Trust Wallet** — Settings → Network → Custom RPC
- **Coinbase Wallet** — Settings → Network → Custom RPC

Simply paste your BlockReq HTTPS endpoint URL as the custom RPC URL.

Source: https://blockreq.com/docs/getting-started/wallet-setup/

# Public Endpoints

Public endpoints are a restricted trial. They do not promise deep history, debug, or trace. Create a private endpoint for keyed archive access where the network supports it.

> [!WARNING]
> Solana / SVM public RPC and Geyser WSS are temporarily offline. Config stays; we’ll announce when they’re back. EVM chains (BSC, Robinhood Chain, etc.) remain available.

| Network | HTTPS | WSS |
| --- | --- | --- |
| Ethereum | `https://ethereum-rpc.blockreq.com/v1/rpc/public` | `wss://ethereum-rpc.blockreq.com/v1/rpc/public` |
| Base | `https://base-rpc.blockreq.com/v1/rpc/public` | `wss://base-rpc.blockreq.com/v1/rpc/public` |
| Arbitrum One | `https://arbitrum-one-rpc.blockreq.com/v1/rpc/public` | `wss://arbitrum-one-rpc.blockreq.com/v1/rpc/public` |
| Polygon | `https://polygon-bor-rpc.blockreq.com/v1/rpc/public` | `wss://polygon-bor-rpc.blockreq.com/v1/rpc/public` |
| BSC | `https://bsc-rpc.blockreq.com/v1/rpc/public` | `wss://bsc-rpc.blockreq.com/v1/rpc/public` |
| Robinhood Chain Mainnet | `https://robinhood-mainnet-rpc.blockreq.com/v1/rpc/public` | `wss://robinhood-mainnet-rpc.blockreq.com/v1/rpc/public` |
| Optimism | `https://optimism-rpc.blockreq.com/v1/rpc/public` | `wss://optimism-rpc.blockreq.com/v1/rpc/public` |
| Scroll | `https://scroll-rpc.blockreq.com/v1/rpc/public` | `wss://scroll-rpc.blockreq.com/v1/rpc/public` |
| Linea | `https://linea-rpc.blockreq.com/v1/rpc/public` | `wss://linea-rpc.blockreq.com/v1/rpc/public` |
| Unichain | `https://unichain-rpc.blockreq.com/v1/rpc/public` | `wss://unichain-rpc.blockreq.com/v1/rpc/public` |
| Blast | `https://blast-rpc.blockreq.com/v1/rpc/public` | `wss://blast-rpc.blockreq.com/v1/rpc/public` |
| opBNB | `https://opbnb-rpc.blockreq.com/v1/rpc/public` | `wss://opbnb-rpc.blockreq.com/v1/rpc/public` |
| Avalanche | `https://avalanche-rpc.blockreq.com/v1/rpc/public` | `wss://avalanche-rpc.blockreq.com/v1/rpc/public` |
| Gnosis | `https://gnosis-rpc.blockreq.com/v1/rpc/public` | `wss://gnosis-rpc.blockreq.com/v1/rpc/public` |
| Berachain | `https://berachain-rpc.blockreq.com/v1/rpc/public` | `wss://berachain-rpc.blockreq.com/v1/rpc/public` |
| Celo | `https://celo-rpc.blockreq.com/v1/rpc/public` | `wss://celo-rpc.blockreq.com/v1/rpc/public` |
| Sonic | `https://sonic-rpc.blockreq.com/v1/rpc/public` | `wss://sonic-rpc.blockreq.com/v1/rpc/public` |
| Cronos | `https://cronos-rpc.blockreq.com/v1/rpc/public` | `wss://cronos-rpc.blockreq.com/v1/rpc/public` |
| Arc | `https://arc-rpc.blockreq.com/v1/rpc/public` | `wss://arc-rpc.blockreq.com/v1/rpc/public` |
| Ethereum Beacon Chain | `https://ethereum-beacon-rpc.blockreq.com` | HTTP only |
| Ethereum Sepolia | `https://ethereum-sepolia-rpc.blockreq.com/v1/rpc/public` | `wss://ethereum-sepolia-rpc.blockreq.com/v1/rpc/public` |
| Base Sepolia | `https://base-sepolia-rpc.blockreq.com/v1/rpc/public` | `wss://base-sepolia-rpc.blockreq.com/v1/rpc/public` |
| Arbitrum Sepolia | `https://arbitrum-sepolia-rpc.blockreq.com/v1/rpc/public` | `wss://arbitrum-sepolia-rpc.blockreq.com/v1/rpc/public` |
| Polygon Amoy | `https://polygon-amoy-bor-rpc.blockreq.com/v1/rpc/public` | `wss://polygon-amoy-bor-rpc.blockreq.com/v1/rpc/public` |
| Optimism Sepolia | `https://optimism-sepolia-rpc.blockreq.com/v1/rpc/public` | `wss://optimism-sepolia-rpc.blockreq.com/v1/rpc/public` |
| Gnosis Chiado | `https://gnosis-chiado-rpc.blockreq.com/v1/rpc/public` | `wss://gnosis-chiado-rpc.blockreq.com/v1/rpc/public` |

Source: https://blockreq.com/docs/build/public-endpoints/

# Core RPC API

BlockReq exposes JSON-RPC on published EVM networks.

## Base URL

```text
Public HTTPS:  https://{hostname}/v1/rpc/public
Private HTTPS: https://{hostname}/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000
Public WSS:    wss://{hostname}/v1/rpc/public
Private WSS:   wss://{hostname}/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000
```

## Published API references

- [Ethereum](https://blockreq.com/docs/build/api-reference/ethereum/index.md)
- [Base](https://blockreq.com/docs/build/api-reference/base/index.md)
- [Arbitrum One](https://blockreq.com/docs/build/api-reference/arbitrum/index.md)
- [Polygon](https://blockreq.com/docs/build/api-reference/polygon/index.md)
- [BSC](https://blockreq.com/docs/build/api-reference/bsc/index.md)
- [Robinhood Chain Mainnet](https://blockreq.com/docs/build/api-reference/robinhood/index.md)
- [Optimism](https://blockreq.com/docs/build/api-reference/optimism/index.md)
- [Scroll](https://blockreq.com/docs/build/api-reference/scroll/index.md)
- [Linea](https://blockreq.com/docs/build/api-reference/linea/index.md)
- [Unichain](https://blockreq.com/docs/build/api-reference/unichain/index.md)
- [Blast](https://blockreq.com/docs/build/api-reference/blast/index.md)
- [opBNB](https://blockreq.com/docs/build/api-reference/opbnb/index.md)
- [Avalanche](https://blockreq.com/docs/build/api-reference/avalanche/index.md)
- [Gnosis](https://blockreq.com/docs/build/api-reference/gnosis/index.md)
- [Berachain](https://blockreq.com/docs/build/api-reference/berachain/index.md)
- [Celo](https://blockreq.com/docs/build/api-reference/celo/index.md)
- [Sonic](https://blockreq.com/docs/build/api-reference/sonic/index.md)
- [Cronos](https://blockreq.com/docs/build/api-reference/cronos/index.md)
- [Arc](https://blockreq.com/docs/build/api-reference/arc/index.md)
- [Ethereum Sepolia](https://blockreq.com/docs/build/api-reference/ethereum-sepolia/index.md)
- [Base Sepolia](https://blockreq.com/docs/build/api-reference/base-sepolia/index.md)
- [Arbitrum Sepolia](https://blockreq.com/docs/build/api-reference/arbitrum-sepolia/index.md)
- [Polygon Amoy](https://blockreq.com/docs/build/api-reference/polygon-amoy/index.md)
- [Optimism Sepolia](https://blockreq.com/docs/build/api-reference/optimism-sepolia/index.md)
- [Gnosis Chiado](https://blockreq.com/docs/build/api-reference/gnosis-chiado/index.md)
- [EVM JSON-RPC methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md)
- [BlockReq API](https://blockreq.com/docs/build/api-reference/blockreq-api/index.md)

Source: https://blockreq.com/docs/build/api-reference/

# BlockReq API

BlockReq provides a **REST API on Web** (`https://blockreq.com/api/...`) to manage your account, RPC endpoints, Request Count, usage stats, wallet value, API keys, notifications, and settings. Management calls never go to `*-rpc.blockreq.com`.

## Getting Started

1. Go to **Dashboard → Settings** to create an API Key
2. Use the API Key as a Bearer token in the `Authorization` header
3. Refer to the public OpenAPI documentation for all available endpoints

<p><a href="https://blockreq.com/docs/api"><strong>Interactive API Docs</strong></a> — View the deterministic public OpenAPI reference for BlockReq REST API endpoints</p>

<p><a href="https://blockreq.com/dashboard/settings"><strong>Dashboard Settings</strong></a> — Create and manage your API Keys</p>

## Authentication

Use a **Management API Key** (`akv1_...`) from Dashboard → Settings. It is the same owner as a signed-in dashboard session. RPC Endpoint Keys in `{chain}-rpc.blockreq.com/v1/rpc/...` URLs only authorize JSON-RPC traffic.

```bash
curl -H "Authorization: Bearer akv1_YOUR_MANAGEMENT_API_KEY" \
  https://blockreq.com/api/dashboard/credits
```

## Available Resources

| Resource | Description |
|----------|-------------|
| **Endpoints** | [List](https://blockreq.com/docs/build/api-reference/blockreq/blockreq-listendpoints/index.md), [create](https://blockreq.com/docs/build/api-reference/blockreq/blockreq-createendpoint/index.md), [delete](https://blockreq.com/docs/build/api-reference/blockreq/blockreq-deleteendpoint/index.md) |
| **Networks** | [Supported chains](https://blockreq.com/docs/build/api-reference/blockreq/blockreq-supportednetworks/index.md) |
| **Usage** | [Stats, analytics, overview](https://blockreq.com/docs/build/api-reference/blockreq/usage-stats/index.md) |
| **Request Count & wallet** | [Balances and Request Pack lots](https://blockreq.com/docs/build/api-reference/blockreq/blockreq-walletbalance/index.md) |
| **Billing** | View payment history and manage payment methods |
| **Teams** | Manage team members and invitations |
| **API Keys** | Create and revoke API keys |
| **Plans** | View the effective plan and switch self-serve billing modes |

> [!NOTE]
> For the full list of public endpoints and request/response schemas, visit the [Interactive API Docs](https://blockreq.com/docs/api). Use [Dashboard Settings](https://blockreq.com/dashboard/settings) to create or rotate API keys.

Source: https://blockreq.com/docs/build/api-reference/blockreq-api/

# Create endpoint

## Description

`POST /api/dashboard/endpoints` creates (or reuses) an endpoint for the Management API Key owner on BlockReq Web.

## Request

| Item | Value |
| --- | --- |
| Method | `POST` |
| URL | `https://blockreq.com/api/dashboard/endpoints` |
| Header | `Authorization: Bearer akv1_...` |
| Body | `{ "chain": "ethereum", "name": "optional" }` |

Use `GET /api/dashboard/chains` for supported `chain` values.

## Code

**cURL**

```bash
curl -X POST https://blockreq.com/api/dashboard/endpoints \
  -H "Authorization: Bearer akv1_YOUR_MANAGEMENT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"chain":"ethereum"}'
```

**JavaScript**

```javascript
const response = await fetch("https://blockreq.com/api/dashboard/endpoints", {
  method: "POST",
  headers: {
    Authorization: "Bearer akv1_YOUR_MANAGEMENT_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ chain: "ethereum" }),
});
```

## Try It

`POST https://blockreq.com/api/dashboard/endpoints`

Source: https://blockreq.com/docs/build/api-reference/blockreq/blockreq-createendpoint/

# Delete endpoint

## Description

`DELETE /api/dashboard/endpoints` deletes an endpoint by `endpointId` for the Management API Key owner.

## Request

| Item | Value |
| --- | --- |
| Method | `DELETE` |
| URL | `https://blockreq.com/api/dashboard/endpoints` |
| Header | `Authorization: Bearer akv1_...` |
| Body | `{ "endpointId": "..." }` |

## Code

**cURL**

```bash
curl -X DELETE https://blockreq.com/api/dashboard/endpoints \
  -H "Authorization: Bearer akv1_YOUR_MANAGEMENT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"endpointId":"YOUR_ENDPOINT_ID"}'
```

**JavaScript**

```javascript
await fetch("https://blockreq.com/api/dashboard/endpoints", {
  method: "DELETE",
  headers: {
    Authorization: "Bearer akv1_YOUR_MANAGEMENT_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ endpointId: "YOUR_ENDPOINT_ID" }),
});
```

## Try It

`DELETE https://blockreq.com/api/dashboard/endpoints`

Source: https://blockreq.com/docs/build/api-reference/blockreq/blockreq-deleteendpoint/

# List endpoints

## Description

`GET /api/dashboard/endpoints` lists endpoints for the Management API Key owner. This is a **Web REST** call on `blockreq.com`, not a JSON-RPC method on `ethereum-rpc.blockreq.com`.

Authenticate with `Authorization: Bearer akv1_...` from [Dashboard Settings](https://blockreq.com/docs/getting-started/api-keys/index.md). That key is the same owner as a signed-in dashboard session.

## Request

| Item | Value |
| --- | --- |
| Method | `GET` |
| URL | `https://blockreq.com/api/dashboard/endpoints` |
| Header | `Authorization: Bearer akv1_...` |

Optional query: `page`, `limit`, `includeInactive`, `sortKey`, `sortDir`, `sortPeriod`.

## Code

**cURL**

```bash
curl -H "Authorization: Bearer akv1_YOUR_MANAGEMENT_API_KEY" \
  https://blockreq.com/api/dashboard/endpoints
```

**JavaScript**

```javascript
const response = await fetch("https://blockreq.com/api/dashboard/endpoints", {
  headers: { Authorization: "Bearer akv1_YOUR_MANAGEMENT_API_KEY" },
});
const body = await response.json();
console.log(body.data.pagination.total);
```

Full schema: [Interactive API Docs](https://blockreq.com/docs/api).

## Try It

`GET https://blockreq.com/api/dashboard/endpoints`

Source: https://blockreq.com/docs/build/api-reference/blockreq/blockreq-listendpoints/

# Request Pack lots

## Description

Request Pack remaining Requests and expiration are fields on `GET /api/dashboard/credits` (`creditState` lots). There is no separate JSON-RPC package method and no chain-RPC host.

See [Request and wallet balances](https://blockreq.com/docs/build/api-reference/blockreq/blockreq-walletbalance/index.md).

## Code

**cURL**

```bash
curl -H "Authorization: Bearer akv1_YOUR_MANAGEMENT_API_KEY" \
  https://blockreq.com/api/dashboard/credits
```

**JavaScript**

```javascript
const response = await fetch("https://blockreq.com/api/dashboard/credits", {
  headers: { Authorization: "Bearer akv1_YOUR_MANAGEMENT_API_KEY" },
});
const lots = response.ok ? (await response.json()).data.creditState : null;
console.log(lots);
```

## Try It

`GET https://blockreq.com/api/dashboard/credits`

Source: https://blockreq.com/docs/build/api-reference/blockreq/blockreq-packageexpiration/

# Supported networks

## Description

`GET /api/dashboard/chains` returns the served-chain catalog used when creating endpoints. Call BlockReq Web, not a chain RPC host.

## Request

| Item | Value |
| --- | --- |
| Method | `GET` |
| URL | `https://blockreq.com/api/dashboard/chains` |
| Header | `Authorization: Bearer akv1_...` |

## Code

**cURL**

```bash
curl -H "Authorization: Bearer akv1_YOUR_MANAGEMENT_API_KEY" \
  https://blockreq.com/api/dashboard/chains
```

**JavaScript**

```javascript
const response = await fetch("https://blockreq.com/api/dashboard/chains", {
  headers: { Authorization: "Bearer akv1_YOUR_MANAGEMENT_API_KEY" },
});
```

## Try It

`GET https://blockreq.com/api/dashboard/chains`

Source: https://blockreq.com/docs/build/api-reference/blockreq/blockreq-supportednetworks/

# Request and wallet balances

## Description

`GET /api/dashboard/credits` returns Request balance, Wallet balance, and request lots (including remaining Requests and expiry). This replaces the old JSON-RPC wallet/package examples.

## Request

| Item | Value |
| --- | --- |
| Method | `GET` |
| URL | `https://blockreq.com/api/dashboard/credits` |
| Header | `Authorization: Bearer akv1_...` |

## Code

**cURL**

```bash
curl -H "Authorization: Bearer akv1_YOUR_MANAGEMENT_API_KEY" \
  https://blockreq.com/api/dashboard/credits
```

**JavaScript**

```javascript
const response = await fetch("https://blockreq.com/api/dashboard/credits", {
  headers: { Authorization: "Bearer akv1_YOUR_MANAGEMENT_API_KEY" },
});
```

## Try It

`GET https://blockreq.com/api/dashboard/credits`

Source: https://blockreq.com/docs/build/api-reference/blockreq/blockreq-walletbalance/

# Usage stats

## Description

Usage APIs are the same Dashboard REST handlers. Authenticate with a Management API Key. Do not send these to `*-rpc.blockreq.com`.

| Operation | Path |
| --- | --- |
| Per-endpoint counts | `GET /api/dashboard/endpoints/stats` |
| Hourly analytics | `GET /api/dashboard/analytics` |
| Aggregated overview | `GET /api/dashboard/overview` |

`stats` accepts `period=24h` or `period=30d`. `analytics` / `overview` accept `windowMinutes` and `limit`.

## Code

**cURL**

```bash
curl -H "Authorization: Bearer akv1_YOUR_MANAGEMENT_API_KEY" \
  "https://blockreq.com/api/dashboard/endpoints/stats?period=24h"

curl -H "Authorization: Bearer akv1_YOUR_MANAGEMENT_API_KEY" \
  "https://blockreq.com/api/dashboard/analytics?windowMinutes=1440"

curl -H "Authorization: Bearer akv1_YOUR_MANAGEMENT_API_KEY" \
  https://blockreq.com/api/dashboard/overview
```

**JavaScript**

```javascript
const headers = { Authorization: "Bearer akv1_YOUR_MANAGEMENT_API_KEY" };
const stats = await fetch("https://blockreq.com/api/dashboard/endpoints/stats?period=24h", { headers });
const analytics = await fetch("https://blockreq.com/api/dashboard/analytics?windowMinutes=1440", { headers });
```

Schemas: [Interactive API Docs](https://blockreq.com/docs/api).

## Try It

`GET https://blockreq.com/api/dashboard/endpoints/stats`

`GET https://blockreq.com/api/dashboard/analytics`

`GET https://blockreq.com/api/dashboard/overview`

Source: https://blockreq.com/docs/build/api-reference/blockreq/usage-stats/

# Request Counting

BlockReq meters authenticated JSON-RPC by **distinguishable Requests**. Archive or historical reads are not a separate bill. The Dashboard shows **Requests used**, **Requests remaining**, and **Wallet balance**.

## What counts as one Request

- One authenticated HTTP JSON-RPC item that was executed or served counts as **1 Request**. That includes success, empty-but-valid results, cache hits, and execution exceptions such as revert.
- Each item in a customer batch is forwarded as its own request and counted on its own method. Mixed-method batches are not combined onto one method.
- One WSS JSON-RPC request, including subscribe or unsubscribe, counts as **1 Request**.
- Each delivered WSS event or notification counts as **1 Request**. This includes EVM `eth_subscription` pushes and Solana subscription messages. WSS notification counting is not replaced by the HTTP rule.

## What counts as zero

- HTTP JSON-RPC method not found and other non-execution application errors.
- Protocol, transport, rate-limit, or cancellation failures, and unrouted early errors.
- Local admission rejection.
- WSS ping and pong frames.
- Notifications that were not delivered to the customer.
- Authentication or policy rejections.
- Rate-limit responses (`429`) and gateway failures (`5xx`).
- Public unauthenticated HTTP or WSS traffic does not decrement a customer request balance.

## HTTP and WSS logs

- HTTP `eth_getLogs` counts as **1 Request**, regardless of block range.
- WSS log and subscription traffic counts each delivered event as **1 Request**.

## Method multipliers

Each distinguishable Request starts as **1 Request**. Some method families then count as N Requests used:

| Method family                         | Counts as | Methods                                                                                                                                                                                                                             |
| ------------------------------------- | --------: | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Ordinary chain, net, and web3 calls   |         1 | `eth_*` such as `eth_blockNumber`, `eth_call`, `eth_getBalance`, `eth_getBlockByNumber`, `eth_sendRawTransaction`, `eth_getLogs`; `net_*`; `web3_*`; `eth_subscribe` / `eth_unsubscribe`; each delivered EVM or Solana notification |
| Proof and block receipts              |         3 | `eth_getProof`, `eth_getBlockReceipts`                                                                                                                                                                                              |
| Single-call debug and trace           |         5 | `debug_traceCall`, `debug_traceTransaction`, `trace_call`, `trace_callMany`, `trace_transaction`, `trace_filter`, `trace_get`, `trace_rawTransaction`, `trace_replayTransaction`                                                    |
| Block-level debug, replay, and txpool |        20 | `debug_traceBlockByNumber`, `debug_traceBlockByHash`, other `debug_traceBlock*`; `trace_block`; `trace_replayBlockTransactions`; `txpool_status`, `txpool_inspect`, `txpool_content`, and other `txpool_*`                          |

Free does not include `debug_*`, `trace_*`, or `txpool_*`. Paid plans do not distinguish those families from each other.

Archive or historical state reads use the same multiplier as the method itself.

## Examples

| Customer event                               | Requests used |
| -------------------------------------------- | ------------: |
| `eth_blockNumber`                            |             1 |
| Historical `eth_getBalance`                  |             1 |
| HTTP `eth_getLogs` (any block range)         |             1 |
| One delivered `eth_subscription` event       |             1 |
| One delivered Solana subscription message    |             1 |
| `eth_getProof`                               |             3 |
| `debug_traceCall`                            |             5 |
| `debug_traceBlockByNumber`                   |            20 |
| `eth_call` revert                            |             1 |
| HTTP method not found                        |             0 |
| WSS ping/pong or an undelivered notification |             0 |

## Balance and PAYG

Free grants and Request Packs hold **Requests remaining** in independently expiring lots. Settlement debits eligible lots using FEFO (earliest expiry first). If PAYG is enabled after prepaid Requests are exhausted, additional Requests used accrue at **$3.90 per 1M Requests used**.

The Dashboard shows Request volume and wallet value separately:

- **Request** remaining (prepaid balance)
- **Requests** 24h / 30d
- **Wallet balance**

See [Plans & Pricing](https://blockreq.com/docs/pricing/plans/index.md) for pack sizes, validity, availability, and rate limits.

Source: https://blockreq.com/docs/pricing/request-counting/

# Plans & Pricing

BlockReq meters authenticated HTTP JSON-RPC and WSS with **Request Counting**. Paid products are one-time **Request Packs**, not monthly subscriptions. After prepaid Requests are exhausted, **PAYG is $3.90 per 1M Requests used**. There is no pack-specific overage price and no minimum top-up.

## Plan comparison

| Product | Price | Included Requests | Validity | Sustained / burst RPS | Batch | HTTP / WSS | debug / trace / txpool |
| --- | --- | --- | --- | --- | --- | --- | --- |
| free | $0 | 3,000,000 | 30d | 10 / 30 | 5 | HTTP + WSS | No |
| payg | $0 | 0 | Contract / continuous | 100 / 500 | 20 | HTTP + WSS | Yes |
| starter | $9 | 5,000,000 | 60d | 100 / 500 | 25 | HTTP + WSS | Yes |
| growth | $39 | 25,000,000 | 60d | 500 / 2500 | 50 | HTTP + WSS | Yes |
| professional | $149 | 100,000,000 | 90d | 1500 / 5000 | 100 | HTTP + WSS | Yes |
| business | $399 | 300,000,000 | 90d | 5000 / 10000 | 200 | HTTP + WSS | Yes |
| enterprise | Contract | 500,000,000 | Contract / continuous | 0 / 0 | 0 | HTTP + WSS | Yes |

PAYG is $3.90 per 1M Requests used.

## Free grant

Eligible accounts receive **3M Requests** with a 30-day validity window:

- 10 sustained / 30 burst requests per second
- Batch size 5
- 2 WSS connections / 5 active subscriptions
- Full chain catalog subject to Free entitlement limits
- `debug_*`, `trace_*`, and `txpool_*` are not included on Free

## debug, trace, and txpool

Paid plans do not distinguish `debug_*`, `trace_*`, or `txpool_*`. If the chain route supports the method, every paid plan can call it. The Free grant does not include these methods.

## Request Packs

Each one-time purchase creates an independently expiring request lot. An unexpired pack can continue to set the effective tier after its Requests remaining reach zero, until the pack expires.

| Pack         | Price | Included Requests | Validity |
| ------------ | ----: | ----------------: | -------: |
| Starter      |    $9 |                5M |  60 days |
| Growth       |   $39 |               25M |  60 days |
| Professional |  $149 |              100M |  90 days |
| Business     |  $399 |              300M |  90 days |

## PAYG and wallet balance

PAYG is a billing mode, not a prepaid pack. When PAYG is enabled and prepaid Requests are exhausted, additional Requests used accrue at **$3.90 per 1M**. **Wallet balance** funds settlement; it is displayed separately from Requests remaining.

## Enterprise

Enterprise starts at **500M+ Requests** with custom limits, validity, and support. Contact sales for access.

## See also

- [Request Counting](https://blockreq.com/docs/pricing/request-counting/index.md)

Source: https://blockreq.com/docs/pricing/plans/

# Supported Networks

BlockReq documents only networks that are already published for production RPC. PATH or Pocket registration alone is not publication.

| Network | Architecture | Identity | HTTP | WSS | Hostname |
| --- | --- | --- | --- | --- | --- |
| Ethereum | evm | `0x1` | Published | Published | `ethereum-rpc.blockreq.com` |
| Base | evm | `0x2105` | Published | Published | `base-rpc.blockreq.com` |
| Arbitrum One | evm | `0xa4b1` | Published | Published | `arbitrum-one-rpc.blockreq.com` |
| Polygon | evm | `0x89` | Published | Published | `polygon-bor-rpc.blockreq.com` |
| BSC | evm | `0x38` | Published | Published | `bsc-rpc.blockreq.com` |
| Robinhood Chain Mainnet | evm | `0x1237` | Published | Published | `robinhood-mainnet-rpc.blockreq.com` |
| Optimism | evm | `0xa` | Published | Published | `optimism-rpc.blockreq.com` |
| Scroll | evm | `0x82750` | Published | Published | `scroll-rpc.blockreq.com` |
| Linea | evm | `0xe708` | Published | Published | `linea-rpc.blockreq.com` |
| Unichain | evm | `0x82` | Published | Published | `unichain-rpc.blockreq.com` |
| Blast | evm | `0x13e31` | Published | Published | `blast-rpc.blockreq.com` |
| opBNB | evm | `0xcc` | Published | Published | `opbnb-rpc.blockreq.com` |
| Avalanche | evm | `0xa86a` | Published | Published | `avalanche-rpc.blockreq.com` |
| Gnosis | evm | `0x64` | Published | Published | `gnosis-rpc.blockreq.com` |
| Berachain | evm | `0x138de` | Published | Published | `berachain-rpc.blockreq.com` |
| Celo | evm | `0xa4ec` | Published | Published | `celo-rpc.blockreq.com` |
| Sonic | evm | `0x92` | Published | Published | `sonic-rpc.blockreq.com` |
| Cronos | evm | `0x19` | Published | Published | `cronos-rpc.blockreq.com` |
| Arc | evm | `0x13b2` | Published | Published | `arc-rpc.blockreq.com` |
| Ethereum Beacon Chain | beacon | `0x1` | Published | HTTP only | `ethereum-beacon-rpc.blockreq.com` |
| Ethereum Sepolia | evm | `0xaa36a7` | Published | Published | `ethereum-sepolia-rpc.blockreq.com` |
| Base Sepolia | evm | `0x14a34` | Published | Published | `base-sepolia-rpc.blockreq.com` |
| Arbitrum Sepolia | evm | `0x66eee` | Published | Published | `arbitrum-sepolia-rpc.blockreq.com` |
| Polygon Amoy | evm | `0x13882` | Published | Published | `polygon-amoy-bor-rpc.blockreq.com` |
| Optimism Sepolia | evm | `0xaa37dc` | Published | Published | `optimism-sepolia-rpc.blockreq.com` |
| Gnosis Chiado | evm | `0x27d8` | Published | Published | `gnosis-chiado-rpc.blockreq.com` |

Private URL shape: `https://{hostname}/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000`.

Source: https://blockreq.com/docs/build/supported-networks/

# Use BlockReq with AI Assistants

BlockReq publishes its docs in forms that AI assistants and coding agents can read directly. Everything below is generated from the same catalogs and templates as these pages, so it stays in sync with them.

## Machine-readable docs

| Resource                                                 | What it holds                                                                                                                                                     |
| -------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [llms.txt](https://blockreq.com/docs/llms.txt)           | An index of every docs page, grouped by topic, following the llmstxt.org format                                                                                   |
| [llms-full.txt](https://blockreq.com/docs/llms-full.txt) | The core docs in one Markdown file, with a network capability table and every JSON-RPC method once                                                                |
| Markdown pages                                           | Every page is also available as Markdown: add `index.md` to its URL, for example `https://blockreq.com/docs/build/api-reference/ethereum/eth_getBalance/index.md` |
| [networks.json](https://blockreq.com/docs/networks.json) | Every published network with its host, public URL, private URL pattern, WSS, and archive and proof/debug/trace flags                                              |
| [OpenRPC](https://blockreq.com/docs/openrpc/index.json)  | One OpenRPC document per EVM network, listing exactly the methods documented for it                                                                               |

Point a general-purpose agent at `https://blockreq.com/docs/llms.txt` and let it follow the links it needs.

## The blockreq-rpc Agent Skill

The `blockreq-rpc` skill teaches a coding agent how to call BlockReq: endpoint URLs, how to pick the network host, which methods need archive data or are limited to proof/debug/trace networks, `eth_subscribe` over WSS, Request Counting and plan limits, short viem, ethers, curl, and web3.py examples, and common pitfalls.

- Browse it: [SKILL.md](https://blockreq.com/docs/agent-skills/blockreq-rpc/SKILL.md), with [networks](https://blockreq.com/docs/agent-skills/blockreq-rpc/reference/networks.md) and [methods](https://blockreq.com/docs/agent-skills/blockreq-rpc/reference/methods.md) references.
- Download it: [blockreq-rpc.zip](https://blockreq.com/docs/agent-skills/blockreq-rpc.zip).

### Claude Code

Install it for your user, so every project can use it:

```bash
mkdir -p ~/.claude/skills && cd ~/.claude/skills
curl -fsSLO https://blockreq.com/docs/agent-skills/blockreq-rpc.zip
unzip -o blockreq-rpc.zip && rm blockreq-rpc.zip
```

Or install it for one project by unzipping into that project's `.claude/skills/` folder, so it is committed with the code. Either way the skill lives in a `blockreq-rpc/` folder, and Claude Code loads it when a task involves BlockReq RPC.

### Claude.ai

Download `blockreq-rpc.zip` and upload it as a custom skill in Claude.ai. Custom skills need a Pro, Max, Team, or Enterprise plan with code execution enabled; see Anthropic's [Using Skills in Claude](https://support.claude.com/en/articles/12512180-using-skills-in-claude) for where to upload.

### Other agents

Agents that do not read Agent Skills can use `https://blockreq.com/docs/llms.txt`, or load `SKILL.md` and its reference files as instructions.

## What is next

An MCP server for BlockReq is planned. It is not available yet, and this page will say so when it is.

Source: https://blockreq.com/docs/build/ai-assistants/

# EVM JSON-RPC Methods

BlockReq supports standard EVM JSON-RPC over HTTPS and WebSocket. The table below is organized by common Core RPC API categories and marks methods that require archive, trace, debug, txpool, or WSS capability.

> [!NOTE]
> Archive support is chain-specific. Use the public chain page and dashboard chain list to confirm whether a route is archive-capable before relying on old-block state, proof, debug, or trace calls.

Request Counting is documented on [Request Counting](https://blockreq.com/docs/pricing/request-counting/index.md). This page describes method availability and capability only.

## Chain and Web3

| Method                                                      | Scope     | Notes                                         |
| ----------------------------------------------------------- | --------- | --------------------------------------------- |
| [`eth_chainId`](https://blockreq.com/docs/build/api-reference/ethereum/eth_chainId/index.md) | HTTPS/WSS | Returns the current chain ID.                 |
| `eth_syncing`                                               | HTTPS/WSS | Returns sync state.                           |
| `net_version`                                               | HTTPS/WSS | Returns network ID.                           |
| `net_listening`                                             | HTTPS/WSS | Returns listening status.                     |
| `net_peerCount`                                             | HTTPS/WSS | Returns peer count when the chain exposes it. |
| `web3_clientVersion`                                        | HTTPS/WSS | Returns the client/version string.            |
| `web3_sha3`                                                 | HTTPS/WSS | Returns Keccak-256 hash.                      |

## Account and State

| Method                                                                              | Scope             | Notes                                           |
| ----------------------------------------------------------------------------------- | ----------------- | ----------------------------------------------- |
| [`eth_getBalance`](https://blockreq.com/docs/build/api-reference/ethereum/eth_getBalance/index.md)                   | Latest or archive | Old block tags require archive-capable routing. |
| [`eth_getCode`](https://blockreq.com/docs/build/api-reference/ethereum/eth_getCode/index.md)                         | Latest or archive | Old block tags require archive-capable routing. |
| [`eth_getStorageAt`](https://blockreq.com/docs/build/api-reference/ethereum/eth_getStorageAt/index.md)               | Latest or archive | Reads a storage slot at a block tag.            |
| [`eth_getProof`](https://blockreq.com/docs/build/api-reference/ethereum/eth_getProof/index.md)                       | Archive/proof     | Returns account and storage Merkle proofs.      |
| [`eth_getTransactionCount`](https://blockreq.com/docs/build/api-reference/ethereum/eth_getTransactionCount/index.md) | Latest or archive | Old block tags require archive-capable routing. |
| [`eth_call`](https://blockreq.com/docs/build/api-reference/ethereum/eth_call/index.md)                               | Latest or archive | Historical calls require archive state.         |

## Blocks

| Method                                                                        | Scope          | Notes                                                       |
| ----------------------------------------------------------------------------- | -------------- | ----------------------------------------------------------- |
| [`eth_blockNumber`](https://blockreq.com/docs/build/api-reference/ethereum/eth_blockNumber/index.md)           | HTTPS/WSS      | Latest block number.                                        |
| [`eth_getBlockByNumber`](https://blockreq.com/docs/build/api-reference/ethereum/eth_getBlockByNumber/index.md) | HTTPS/WSS      | Block by number or tag.                                     |
| [`eth_getBlockByHash`](https://blockreq.com/docs/build/api-reference/ethereum/eth_getBlockByHash/index.md)     | HTTPS/WSS      | Block by hash.                                              |
| `eth_getBlockTransactionCountByNumber`                                        | HTTPS/WSS      | Transaction count for a block number.                       |
| `eth_getBlockTransactionCountByHash`                                          | HTTPS/WSS      | Transaction count for a block hash.                         |
| [`eth_getBlockReceipts`](https://blockreq.com/docs/build/api-reference/ethereum/eth_getBlockReceipts/index.md) | Heavy/history  | Returns all receipts in a block when the chain supports it. |
| `eth_getUncleCountByBlockHash`                                                | Chain-specific | Returns uncle count by block hash.                          |
| `eth_getUncleCountByBlockNumber`                                              | Chain-specific | Returns uncle count by block number.                        |
| `eth_getUncleByBlockHashAndIndex`                                             | Chain-specific | Returns uncle block by hash and index.                      |
| `eth_getUncleByBlockNumberAndIndex`                                           | Chain-specific | Returns uncle block by number and index.                    |

## Transactions

| Method                                                                                  | Scope     | Notes                                  |
| --------------------------------------------------------------------------------------- | --------- | -------------------------------------- |
| [`eth_getTransactionByHash`](https://blockreq.com/docs/build/api-reference/ethereum/eth_getTransactionByHash/index.md)   | HTTPS/WSS | Transaction by hash.                   |
| `eth_getTransactionByBlockNumberAndIndex`                                               | HTTPS/WSS | Transaction by block number and index. |
| `eth_getTransactionByBlockHashAndIndex`                                                 | HTTPS/WSS | Transaction by block hash and index.   |
| [`eth_getTransactionReceipt`](https://blockreq.com/docs/build/api-reference/ethereum/eth_getTransactionReceipt/index.md) | HTTPS/WSS | Transaction receipt.                   |
| [`eth_sendRawTransaction`](https://blockreq.com/docs/build/api-reference/ethereum/eth_sendRawTransaction/index.md)       | HTTPS     | Broadcasts a signed transaction.       |

## Logs and Filters

| Method                                                      | Scope         | Notes                                                                      |
| ----------------------------------------------------------- | ------------- | -------------------------------------------------------------------------- |
| [`eth_getLogs`](https://blockreq.com/docs/build/api-reference/ethereum/eth_getLogs/index.md) | History/index | HTTP counts as 1 Request. A chain may still limit the allowed block range. |
| `eth_newFilter`                                             | HTTPS         | Creates a log filter when the chain supports it.                           |
| `eth_newBlockFilter`                                        | HTTPS         | Creates a block filter.                                                    |
| `eth_newPendingTransactionFilter`                           | HTTPS         | Creates a pending transaction filter.                                      |
| `eth_getFilterChanges`                                      | HTTPS         | Returns changes for a filter.                                              |
| `eth_getFilterLogs`                                         | HTTPS         | Returns logs for a filter.                                                 |
| `eth_uninstallFilter`                                       | HTTPS         | Removes a filter.                                                          |

## Gas and Fees

| Method                                                              | Scope          | Notes                                       |
| ------------------------------------------------------------------- | -------------- | ------------------------------------------- |
| [`eth_gasPrice`](https://blockreq.com/docs/build/api-reference/ethereum/eth_gasPrice/index.md)       | HTTPS/WSS      | Legacy gas price.                           |
| [`eth_estimateGas`](https://blockreq.com/docs/build/api-reference/ethereum/eth_estimateGas/index.md) | HTTPS          | Estimates gas for a transaction.            |
| `eth_feeHistory`                                                    | HTTPS          | EIP-1559 fee history.                       |
| `eth_maxPriorityFeePerGas`                                          | HTTPS          | Priority fee suggestion.                    |
| `eth_createAccessList`                                              | Chain-specific | Available only where the chain supports it. |

## WebSocket Subscriptions

| Method                                                          | Scope    | Notes                                                                   |
| --------------------------------------------------------------- | -------- | ----------------------------------------------------------------------- |
| [`eth_subscribe`](https://blockreq.com/docs/build/api-reference/ethereum/eth_subscribe/index.md) | WSS only | Supports subscription types such as `newHeads` and `logs` when enabled. |
| `eth_unsubscribe`                                               | WSS only | Cancels an active subscription.                                         |

## Debug and Trace

| Method                                                                                | Scope        | Notes                                                          |
| ------------------------------------------------------------------------------------- | ------------ | -------------------------------------------------------------- |
| [`debug_traceTransaction`](https://blockreq.com/docs/build/api-reference/ethereum/debug_traceTransaction/index.md)     | Paid / debug | Returns an execution trace for a transaction.                  |
| `debug_traceBlockByHash`                                                              | Paid / debug | Traces all transactions in a block by hash.                    |
| [`debug_traceBlockByNumber`](https://blockreq.com/docs/build/api-reference/ethereum/debug_traceBlockByNumber/index.md) | Paid / debug | Traces all transactions in a block by number or tag.           |
| [`debug_traceCall`](https://blockreq.com/docs/build/api-reference/ethereum/debug_traceCall/index.md)                   | Paid / debug | Traces a call without submitting a transaction.                |
| [`trace_block`](https://blockreq.com/docs/build/api-reference/ethereum/trace_block/index.md)                           | Paid / trace | Returns traces for a block.                                    |
| `trace_call`                                                                          | Paid / trace | Executes and traces a call.                                    |
| `trace_callMany`                                                                      | Paid / trace | Executes and traces multiple calls when the chain supports it. |
| [`trace_filter`](https://blockreq.com/docs/build/api-reference/ethereum/trace_filter/index.md)                         | Paid / trace | Returns traces matching block/address filters.                 |
| `trace_get`                                                                           | Paid / trace | Returns a trace by transaction hash and trace address.         |
| `trace_rawTransaction`                                                                | Paid / trace | Traces a raw transaction.                                      |
| [`trace_transaction`](https://blockreq.com/docs/build/api-reference/ethereum/trace_transaction/index.md)               | Paid / trace | Returns traces for a transaction.                              |
| `trace_replayBlockTransactions`                                                       | Paid / trace | Heavy replay method for every transaction in a block.          |
| `trace_replayTransaction`                                                             | Paid / trace | Heavy replay method; use only when required.                   |

## Txpool

| Method           | Scope         | Notes                                            |
| ---------------- | ------------- | ------------------------------------------------ |
| `txpool_status`  | Paid / txpool | Pending pool status when the chain supports it.  |
| `txpool_inspect` | Paid / txpool | Pending pool summary when the chain supports it. |
| `txpool_content` | Paid / txpool | Pending pool content when the chain supports it. |

> [!NOTE]
> Free endpoints do not include `debug_*`, `trace_*`, or `txpool_*` methods. Method multipliers are documented on [Request Counting](https://blockreq.com/docs/pricing/request-counting/index.md).

Source: https://blockreq.com/docs/build/api-reference/evm-methods/

# Contact Us

Have questions, feedback, or need enterprise support? We'd love to hear from you.

## Channels

| Channel          | Contact                                              | Response Time |
| ---------------- | ---------------------------------------------------- | ------------- |
| General Support  | [support@blockreq.com](mailto:support@blockreq.com)  | < 24 hours    |
| Enterprise Sales | [sales@blockreq.com](mailto:sales@blockreq.com)      | < 12 hours    |
| Telegram         | [Join our community](https://t.me/+fo3nmF_obr85ZGQ9) | Community     |
| GitHub           | [github.com/blockreq](https://github.com/blockreq)   | Community     |

## Enterprise Inquiries

For enterprise plans including dedicated nodes, custom SLA, and private deployment, contact our sales team:

[sales@blockreq.com](mailto:sales@blockreq.com)

Please include:

- Your company name
- Expected monthly request volume
- Required blockchain networks
- Any specific SLA requirements

## Bug Reports

Found a bug? Please open an issue on our [GitHub repository](https://github.com/blockreq) with:

- Description of the issue
- Steps to reproduce
- Expected vs actual behavior
- Your endpoint network and method

Source: https://blockreq.com/docs/support/contact/

# FAQ

## General

### What is BlockReq?

BlockReq is a Web3 RPC infrastructure platform that provides blockchain node access through a simple API.

### Do I need to run my own node?

No. Create an endpoint and use its RPC URL and credential.

### Is there a free tier?

Yes. Eligible accounts receive **3M Requests** with a 30-day validity window. No credit card is required to start.

---

## Billing & Request Counting

### What is Request Counting?

Request Counting meters distinguishable customer **Requests**, then applies method multipliers to **Requests used**. See [Request Counting](https://blockreq.com/docs/pricing/request-counting/index.md) for HTTP, batch, and WSS rules.

### What happens when I run out of prepaid Requests?

With **PAYG** enabled, additional Requests used accrue at **$3.90 per 1M**. Without Requests remaining and without PAYG capacity, authenticated calls may be rejected. You can:

1. Wait for the next free grant window if eligible.
2. Buy a self-service Request Pack from the Dashboard.
3. Top up Wallet balance and enable PAYG.

### Do unused Requests roll over?

- **Free grant**: valid for its 30-day lot window.
- **Request Packs**: valid for 60 or 90 days from activation, depending on the pack.
- **PAYG**: usage accrues while enabled; it is not a prepaid rollover balance.

### How do I check my balance?

Open the Dashboard. **Requests remaining** and **Wallet balance** are shown separately on billing and endpoint surfaces.

---

## Technical

### Which chains are supported?

See [Supported Networks](https://blockreq.com/docs/build/supported-networks/index.md).

### Do you support WebSocket?

Yes. A WSS subscribe or unsubscribe request counts once. Each delivered EVM `eth_subscription` event or Solana subscription message counts once. Ping/pong and undelivered notifications count zero.

### Do JSON-RPC errors count?

For authenticated HTTP, execution exceptions such as revert still count. HTTP method not found and other non-execution JSON-RPC application errors do not. Authentication or policy rejection, `429`, and gateway `5xx` count zero. WSS request and notification counting is unchanged.

Source: https://blockreq.com/docs/support/faq/

# Ethereum API

Ethereum endpoints use the EVM JSON-RPC Core API over HTTPS and, when enabled for the route, WSS.

## Endpoint

| Item | Value |
| --- | --- |
| Network | Ethereum Mainnet |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `1` (`0x1`) |
| Public HTTPS | `https://ethereum-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| WSS | `wss://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` when enabled |

## Core Methods

Use the [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) catalog for request shapes and [Request Counting](https://blockreq.com/docs/pricing/request-counting/index.md) for billing.

| Category | Methods |
| --- | --- |
| Chain and blocks | `eth_chainId`, `eth_blockNumber`, `eth_getBlockByNumber`, `eth_getBlockByHash` |
| State and archive | `eth_getBalance`, `eth_getCode`, `eth_getStorageAt`, `eth_call`, `eth_getProof` |
| Logs and transactions | `eth_getLogs`, `eth_getTransactionByHash`, `eth_getTransactionReceipt` |
| All history / execution replay | `debug_traceCall`, `debug_traceTransaction`, `debug_traceBlockByNumber`, `trace_block`, `trace_call`, `trace_filter`, `trace_transaction` |
| Subscriptions | `eth_subscribe`, `eth_unsubscribe` over WSS |

## Archive and All History

Ethereum historical state calls require an archive-capable route. This includes old-block `eth_call`, old-block balance/code/storage/nonce reads, `eth_getProof`, and `debug_*` or `trace_*` replay methods. `eth_getLogs` is history-oriented but is usually served by log/index-capable lanes rather than full archive state.

```bash
curl -X POST https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_getProof","params":["0x0000000000000000000000000000000000000000",[],"latest"],"id":1}'
```

## Debug and Trace

`debug_*`, `trace_*`, and `txpool_*` are available on every paid plan when the Ethereum route supports the method. The Free grant does not include them.

```bash
curl -X POST https://ethereum-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"debug_traceCall","params":[{"to":"0xdac17f958d2ee523a2206206994597c13d831ec7","data":"0x313ce567"},"latest",{"tracer":"callTracer"}],"id":1}'
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/

# Base API

Base endpoints use EVM JSON-RPC.

## Endpoint

| Item | Value |
| --- | --- |
| Network | Base Mainnet |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `8453` (`0x2105`) |
| Public HTTPS | `https://base-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://base-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| WSS | `wss://base-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` when enabled |

## Core Methods

Base uses the shared [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) catalog.

| Capability | Methods |
| --- | --- |
| Latest state | `eth_chainId`, `eth_blockNumber`, `eth_call`, `eth_getBalance` |
| Archive/proof | `eth_getProof`, old-block `eth_getCode`, old-block `eth_getStorageAt` |
| Logs | `eth_getLogs`, `eth_getFilterLogs` |
| Trace/debug | `trace_block`, `trace_filter`, `trace_transaction`, `debug_traceCall`, `debug_traceTransaction` |

Archive and trace methods require a route with matching provider capability.

Source: https://blockreq.com/docs/build/api-reference/base/

# Arbitrum API

Arbitrum One endpoints use EVM JSON-RPC, including trace and debug methods where available.

## Endpoint

| Item | Value |
| --- | --- |
| Network | Arbitrum One |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `42161` (`0xa4b1`) |
| Public HTTPS | `https://arbitrum-one-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://arbitrum-one-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| WSS | `wss://arbitrum-one-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` when enabled |

## Core Methods

See [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) for the complete method catalog.

| Capability | Methods |
| --- | --- |
| Latest state | `eth_chainId`, `eth_blockNumber`, `eth_call`, `eth_getBalance` |
| Archive/all history | `eth_getProof`, old-block `eth_call`, old-block `eth_getStorageAt` |
| Trace | `trace_block`, `trace_call`, `trace_filter`, `trace_get`, `trace_transaction`, `trace_replayTransaction` |
| Debug | `debug_traceCall`, `debug_traceTransaction`, `debug_traceBlockByNumber`, `debug_traceBlockByHash` |
| WSS | `eth_subscribe`, `eth_unsubscribe` |

## Trace and Debug Examples

`trace_block` and `debug_traceCall` require a trace/debug-capable provider lane. For `debug_traceCall`, include a tracer object.

```bash
curl -X POST https://arbitrum-one-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"trace_block","params":["latest"],"id":1}'
```

```bash
curl -X POST https://arbitrum-one-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"debug_traceCall","params":[{"to":"0x000000000000000000000000000000000000006e"},"latest",{"tracer":"callTracer"}],"id":1}'
```

Source: https://blockreq.com/docs/build/api-reference/arbitrum/

# Polygon API

Polygon PoS remains an archive product on keyed private endpoints. The public trial at `/v1/rpc/public` does not promise deep history, debug, or trace.

## Endpoint

| Item | Value |
| --- | --- |
| Network | Polygon PoS Mainnet |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `137` (`0x89`) |
| Public HTTPS | `https://polygon-bor-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://polygon-bor-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| WSS | `wss://polygon-bor-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` when enabled |

## Access tiers

| Access | What it provides |
| --- | --- |
| Keyed / private (`/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000`) | Archive: deep history, `eth_getProof`, and debug/trace where supported |
| Public trial (`/v1/rpc/public`) | Restricted trial. No deep history, debug, or trace. Filter methods are rejected. History is limited to about 1024 blocks, including historical `eth_getProof`. [Create an endpoint](https://blockreq.com/docs/getting-started/create-endpoint/index.md) for full archive access. |

## Core Methods

Use [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) for the shared catalog. Archive, debug, and trace rows below document the keyed product.

| Capability | Methods | Access |
| --- | --- | --- |
| Latest state | `eth_chainId`, `eth_blockNumber`, `eth_call`, `eth_getBalance` | Public trial or keyed |
| All history | old-block `eth_call`, `eth_getCode`, `eth_getStorageAt`, `eth_getProof` | API key / private endpoint |
| Logs and blocks | `eth_getLogs`, `eth_getBlockByNumber`, `eth_getBlockReceipts` | Public trial is window-limited; keyed archive for deep ranges |
| Trace/debug | `debug_traceCall`, `debug_traceTransaction`, `trace_block`, `trace_filter`, `trace_transaction` | API key / private endpoint |

Public trial example:

```bash
curl -X POST https://polygon-bor-rpc.blockreq.com/v1/rpc/public \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'
```

Keyed archive example (`eth_getProof` requires an API key; it is not available on `/v1/rpc/public`):

```bash
curl -X POST https://polygon-bor-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_getProof","params":["0x0000000000000000000000000000000000000000",[],"latest"],"id":1}'
```

Source: https://blockreq.com/docs/build/api-reference/polygon/

# BNB Smart Chain API

BNB Smart Chain endpoints use EVM JSON-RPC.

## Endpoint

| Item | Value |
| --- | --- |
| Network | BNB Smart Chain Mainnet |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `56` (`0x38`) |
| Public HTTPS | `https://bsc-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://bsc-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| WSS | `wss://bsc-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` when enabled |

## Core Methods

Use [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) for the shared method catalog.

| Capability | Methods |
| --- | --- |
| Latest state | `eth_chainId`, `eth_blockNumber`, `eth_call`, `eth_getBalance` |
| Archive/proof | `eth_getProof`, old-block `eth_getCode`, old-block `eth_getStorageAt` |
| Logs and receipts | `eth_getLogs`, `eth_getBlockReceipts`, `eth_getTransactionReceipt` |
| Trace/debug | `trace_block`, `trace_filter`, `trace_transaction`, `debug_traceCall`, `debug_traceTransaction` |

Free does not include `debug_*`, `trace_*`, or `txpool_*`. Paid plans do not distinguish those families.

Source: https://blockreq.com/docs/build/api-reference/bsc/

# Optimism API

Optimism endpoints use the EVM JSON-RPC Core API. The route keeps Optimism's EVM method surface separate from non-EVM protocols.

## Endpoint

| Item | Value |
| --- | --- |
| Network | Optimism Mainnet |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `10` (`0xa`) |
| Public HTTPS | `https://optimism-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://optimism-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| WSS | `wss://optimism-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` when enabled |

## Core Methods

Optimism supports the shared [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) set for core reads, transactions, filters, subscriptions, and archive state.

| Capability | Methods |
| --- | --- |
| Latest state | `eth_chainId`, `eth_blockNumber`, `eth_call`, `eth_getBalance` |
| Historical state | old-block `eth_call`, `eth_getStorageAt`, `eth_getTransactionCount` |
| History/index | `eth_getLogs`, `eth_getTransactionByHash`, `eth_getTransactionReceipt` |

## Proof, Debug, and Trace

BlockReq does not currently document or guarantee `eth_getProof`, `debug_*`, or `trace_*` on Optimism.

Source: https://blockreq.com/docs/build/api-reference/optimism/

# Avalanche API

Avalanche C-Chain endpoints use the EVM JSON-RPC Core API over HTTPS and WSS.

## Endpoint

| Item | Value |
| --- | --- |
| Network | Avalanche C-Chain Mainnet |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `43114` (`0xa86a`) |
| Public HTTPS | `https://avalanche-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://avalanche-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| Public WSS | `wss://avalanche-rpc.blockreq.com/v1/rpc/public` |
| Private WSS | `wss://avalanche-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |

These URLs use the product path `/v1/rpc` plus `/public` or `BRQ1P0000000000000000000000000000000000000000000000000000000`.

## Core Methods

Avalanche C-Chain uses the shared [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) catalog.

| Capability | Methods |
| --- | --- |
| Latest state | `eth_chainId`, `eth_blockNumber`, `eth_call`, `eth_getBalance` |
| Archive | old-block state reads |
| Logs | `eth_getLogs`, `eth_newFilter`, `eth_getFilterChanges` |

Archive calls may require a private endpoint. BlockReq does not currently document or guarantee `eth_getProof`, `debug_*`, or `trace_*` on Avalanche C-Chain.

Source: https://blockreq.com/docs/build/api-reference/avalanche/

# Gnosis API

Gnosis endpoints use the EVM JSON-RPC Core API over HTTPS and WSS.

## Endpoint

| Item | Value |
| --- | --- |
| Network | Gnosis Mainnet |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `100` (`0x64`) |
| Public HTTPS | `https://gnosis-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://gnosis-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| Public WSS | `wss://gnosis-rpc.blockreq.com/v1/rpc/public` |
| Private WSS | `wss://gnosis-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |

These URLs use the product path `/v1/rpc` plus `/public` or `BRQ1P0000000000000000000000000000000000000000000000000000000`.

## Core Methods

Gnosis uses the shared [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) catalog.

BlockReq does not currently document or guarantee `eth_getProof`, `debug_*`, or `trace_*` on Gnosis.

Source: https://blockreq.com/docs/build/api-reference/gnosis/

# Berachain API

Berachain endpoints use the EVM JSON-RPC Core API over HTTPS and WSS.

## Endpoint

| Item | Value |
| --- | --- |
| Network | Berachain Mainnet |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `80094` (`0x138de`) |
| Public HTTPS | `https://berachain-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://berachain-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| Public WSS | `wss://berachain-rpc.blockreq.com/v1/rpc/public` |
| Private WSS | `wss://berachain-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |

These URLs use the product path `/v1/rpc` plus `/public` or `BRQ1P0000000000000000000000000000000000000000000000000000000`.

## Core Methods

Berachain uses [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) for latest-state reads, transactions, logs, and archive state.

Archive and all-history calls such as old-block `eth_call` require provider capability and plan access. BlockReq does not currently document or guarantee `eth_getProof`, `debug_*`, or `trace_*` on Berachain.

Source: https://blockreq.com/docs/build/api-reference/berachain/

# Celo API

Celo endpoints use the EVM JSON-RPC Core API over HTTPS and WSS.

## Endpoint

| Item | Value |
| --- | --- |
| Network | Celo Mainnet |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `42220` (`0xa4ec`) |
| Public HTTPS | `https://celo-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://celo-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| Public WSS | `wss://celo-rpc.blockreq.com/v1/rpc/public` |
| Private WSS | `wss://celo-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |

These URLs use the product path `/v1/rpc` plus `/public` or `BRQ1P0000000000000000000000000000000000000000000000000000000`.

## Core Methods

Celo uses [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) for `eth_*` reads and writes, archive-sensitive state calls, logs, and WSS subscriptions.

Old-block `eth_call` requires archive routing. BlockReq does not currently document or guarantee `eth_getProof`, `debug_*`, or `trace_*` on Celo.

Source: https://blockreq.com/docs/build/api-reference/celo/

# Sonic API

Sonic endpoints use the EVM JSON-RPC Core API over HTTPS and WSS.

## Endpoint

| Item | Value |
| --- | --- |
| Network | Sonic Mainnet |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `146` (`0x92`) |
| Public HTTPS | `https://sonic-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://sonic-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| Public WSS | `wss://sonic-rpc.blockreq.com/v1/rpc/public` |
| Private WSS | `wss://sonic-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |

These URLs use the product path `/v1/rpc` plus `/public` or `BRQ1P0000000000000000000000000000000000000000000000000000000`.

## Core Methods

Sonic uses [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) for `eth_*`, logs, transactions, WSS subscriptions, and archive state.

BlockReq does not currently document or guarantee `eth_getProof`, `debug_*`, or `trace_*` on Sonic.

Source: https://blockreq.com/docs/build/api-reference/sonic/

# Cronos API

Cronos endpoints use the EVM JSON-RPC Core API over HTTPS and WSS.

## Endpoint

| Item | Value |
| --- | --- |
| Network | Cronos Mainnet |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `25` (`0x19`) |
| Public HTTPS | `https://cronos-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://cronos-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| Public WSS | `wss://cronos-rpc.blockreq.com/v1/rpc/public` |
| Private WSS | `wss://cronos-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |

These URLs use the product path `/v1/rpc` plus `/public` or `BRQ1P0000000000000000000000000000000000000000000000000000000`.

## Core Methods

Cronos uses the shared [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) catalog.

BlockReq does not currently document or guarantee `eth_getProof`, `debug_*`, or `trace_*` on Cronos.

Source: https://blockreq.com/docs/build/api-reference/cronos/

# Arc API

Arc endpoints use the EVM JSON-RPC Core API over HTTPS and WSS.

## Endpoint

| Item | Value |
| --- | --- |
| Network | Arc Mainnet |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `5042` (`0x13b2`) |
| Public HTTPS | `https://arc-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://arc-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| Public WSS | `wss://arc-rpc.blockreq.com/v1/rpc/public` |
| Private WSS | `wss://arc-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |

These URLs use the product path `/v1/rpc` plus `/public` or `BRQ1P0000000000000000000000000000000000000000000000000000000`. Callers use BlockReq HTTP and WSS on this host.

## Core Methods

Arc uses the shared [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) catalog.

BlockReq does not currently document or guarantee `eth_getProof`, `debug_*`, or `trace_*` on Arc.

Source: https://blockreq.com/docs/build/api-reference/arc/

# Gnosis Chiado API

Gnosis Chiado endpoints use the EVM JSON-RPC Core API over HTTPS and WSS.

## Endpoint

| Item | Value |
| --- | --- |
| Network | Gnosis Chiado Testnet |
| Protocol | EVM JSON-RPC 2.0 |
| Chain ID | `10200` (`0x27d8`) |
| Public HTTPS | `https://gnosis-chiado-rpc.blockreq.com/v1/rpc/public` |
| Private HTTPS | `https://gnosis-chiado-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |
| Public WSS | `wss://gnosis-chiado-rpc.blockreq.com/v1/rpc/public` |
| Private WSS | `wss://gnosis-chiado-rpc.blockreq.com/v1/rpc/BRQ1P0000000000000000000000000000000000000000000000000000000` |

These URLs use the product path `/v1/rpc` plus `/public` or `BRQ1P0000000000000000000000000000000000000000000000000000000`.

## Core Methods

Gnosis Chiado uses the shared [EVM JSON-RPC Methods](https://blockreq.com/docs/build/api-reference/evm-methods/index.md) catalog.

BlockReq does not currently document or guarantee `eth_getProof`, `debug_*`, or `trace_*` on Gnosis Chiado.

Source: https://blockreq.com/docs/build/api-reference/gnosis-chiado/

# EVM network capabilities

| Chain | Chain ID | Type | Hostname | Data | WSS | Proof / debug / trace | Keyed public trial | Methods |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| [Ethereum](https://blockreq.com/docs/build/api-reference/ethereum/index.md) | `1` (`0x1`) | mainnet | `ethereum-rpc.blockreq.com` | archive | yes | yes | no | 42 |
| [Base](https://blockreq.com/docs/build/api-reference/base/index.md) | `8453` (`0x2105`) | mainnet | `base-rpc.blockreq.com` | archive | yes | yes | no | 42 |
| [Arbitrum One](https://blockreq.com/docs/build/api-reference/arbitrum/index.md) | `42161` (`0xa4b1`) | mainnet | `arbitrum-one-rpc.blockreq.com` | archive | yes | yes | no | 42 |
| [Polygon](https://blockreq.com/docs/build/api-reference/polygon/index.md) | `137` (`0x89`) | mainnet | `polygon-bor-rpc.blockreq.com` | archive | yes | yes | yes | 42 |
| [BSC](https://blockreq.com/docs/build/api-reference/bsc/index.md) | `56` (`0x38`) | mainnet | `bsc-rpc.blockreq.com` | archive | yes | yes | no | 48 |
| [Robinhood Chain Mainnet](https://blockreq.com/docs/build/api-reference/robinhood/index.md) | `4663` (`0x1237`) | mainnet | `robinhood-mainnet-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [Optimism](https://blockreq.com/docs/build/api-reference/optimism/index.md) | `10` (`0xa`) | mainnet | `optimism-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [Scroll](https://blockreq.com/docs/build/api-reference/scroll/index.md) | `534352` (`0x82750`) | mainnet | `scroll-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [Linea](https://blockreq.com/docs/build/api-reference/linea/index.md) | `59144` (`0xe708`) | mainnet | `linea-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [Unichain](https://blockreq.com/docs/build/api-reference/unichain/index.md) | `130` (`0x82`) | mainnet | `unichain-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [Blast](https://blockreq.com/docs/build/api-reference/blast/index.md) | `81457` (`0x13e31`) | mainnet | `blast-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [opBNB](https://blockreq.com/docs/build/api-reference/opbnb/index.md) | `204` (`0xcc`) | mainnet | `opbnb-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [Avalanche](https://blockreq.com/docs/build/api-reference/avalanche/index.md) | `43114` (`0xa86a`) | mainnet | `avalanche-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [Gnosis](https://blockreq.com/docs/build/api-reference/gnosis/index.md) | `100` (`0x64`) | mainnet | `gnosis-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [Berachain](https://blockreq.com/docs/build/api-reference/berachain/index.md) | `80094` (`0x138de`) | mainnet | `berachain-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [Celo](https://blockreq.com/docs/build/api-reference/celo/index.md) | `42220` (`0xa4ec`) | mainnet | `celo-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [Sonic](https://blockreq.com/docs/build/api-reference/sonic/index.md) | `146` (`0x92`) | mainnet | `sonic-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [Cronos](https://blockreq.com/docs/build/api-reference/cronos/index.md) | `25` (`0x19`) | mainnet | `cronos-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [Arc](https://blockreq.com/docs/build/api-reference/arc/index.md) | `5042` (`0x13b2`) | mainnet | `arc-rpc.blockreq.com` | full | yes | no | no | 35 |
| [Ethereum Sepolia](https://blockreq.com/docs/build/api-reference/ethereum-sepolia/index.md) | `11155111` (`0xaa36a7`) | testnet | `ethereum-sepolia-rpc.blockreq.com` | archive | yes | yes | no | 42 |
| [Base Sepolia](https://blockreq.com/docs/build/api-reference/base-sepolia/index.md) | `84532` (`0x14a34`) | testnet | `base-sepolia-rpc.blockreq.com` | archive | yes | yes | no | 42 |
| [Arbitrum Sepolia](https://blockreq.com/docs/build/api-reference/arbitrum-sepolia/index.md) | `421614` (`0x66eee`) | testnet | `arbitrum-sepolia-rpc.blockreq.com` | archive | yes | yes | no | 42 |
| [Polygon Amoy](https://blockreq.com/docs/build/api-reference/polygon-amoy/index.md) | `80002` (`0x13882`) | testnet | `polygon-amoy-bor-rpc.blockreq.com` | archive | yes | yes | yes | 42 |
| [Optimism Sepolia](https://blockreq.com/docs/build/api-reference/optimism-sepolia/index.md) | `11155420` (`0xaa37dc`) | testnet | `optimism-sepolia-rpc.blockreq.com` | archive | yes | no | no | 35 |
| [Gnosis Chiado](https://blockreq.com/docs/build/api-reference/gnosis-chiado/index.md) | `10200` (`0x27d8`) | testnet | `gnosis-chiado-rpc.blockreq.com` | archive | yes | no | no | 35 |

# EVM JSON-RPC methods

## debug_traceBlockByNumber

Returns traces for all transactions in a block

Available on 9 of 25 served EVM networks: Ethereum, Base, Arbitrum One, Polygon, BSC, Ethereum Sepolia, Base Sepolia, Arbitrum Sepolia, Polygon Amoy.

Counts as 20 requests. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

> **Tier**: Paid plan required. Not available on Free.

### Description

Returns traces for all transactions in a block.

### Parameters

| Parameter      | Type       | Required | Description         |
| -------------- | ---------- | -------- | ------------------- |
| `block`        | `blockTag` | Yes      | Block number or tag |
| `tracerConfig` | `object`   | No       | Tracer config       |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "debug_traceBlockByNumber",
  "params": [
    "latest",
    {
      "tracer": "callTracer"
    }
  ],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/debug_traceBlockByNumber/

## debug_traceCall

Traces a call without submitting a transaction

Available on 9 of 25 served EVM networks: Ethereum, Base, Arbitrum One, Polygon, BSC, Ethereum Sepolia, Base Sepolia, Arbitrum Sepolia, Polygon Amoy.

Counts as 5 requests. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

`debug_traceCall` executes a call against a selected block context and returns execution trace data. It is a paid debug method, not available on Free. Historical block contexts require historical state on that chain.

### Parameters

1. `Object` - Call object with `from`, `to`, `gas`, `gasPrice`, `value`, and `data` fields as needed.
2. `QUANTITY|TAG` - Block number or tag.
3. `Object` - Optional tracer configuration such as `{ "tracer": "callTracer" }`.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "debug_traceCall",
  "params": [
    {
      "to": "0x0000000000000000000000000000000000000000",
      "data": "0x"
    },
    "latest",
    {
      "tracer": "callTracer"
    }
  ],
  "id": 1
}
```

### Notes

- Not available on Free endpoints.
- Tracer support depends on the chain.
- Old-block execution context requires historical state on that chain.

Source: https://blockreq.com/docs/build/api-reference/ethereum/debug_traceCall/

## debug_traceTransaction

Returns the detailed trace of a transaction execution

Available on 9 of 25 served EVM networks: Ethereum, Base, Arbitrum One, Polygon, BSC, Ethereum Sepolia, Base Sepolia, Arbitrum Sepolia, Polygon Amoy.

Counts as 5 requests. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

> **Tier**: Paid plan required. Not available on Free.

### Description

Returns the detailed trace of a transaction execution.

### Parameters

| Parameter         | Type     | Required | Description      |
| ----------------- | -------- | -------- | ---------------- |
| `transactionHash` | `hex`    | Yes      | Transaction hash |
| `tracerConfig`    | `object` | No       | Tracer config    |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "debug_traceTransaction",
  "params": [
    "0x02b39a7c1f83eebf04e785ffc31a13543cc77353461e02f30f4ea48ef5db368e",
    {
      "tracer": "callTracer"
    }
  ],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/debug_traceTransaction/

## eth_blockNumber

Returns the latest block number

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Returns the number of the most recent block.

### Parameters

None.

### Returns

`QUANTITY` — Integer of the current block number the client is on.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_blockNumber",
  "params": [],
  "id": 1
}
```

### Response

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x134e82a"
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_blockNumber/

## eth_call

Executes a new message call without creating a transaction

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Executes a new message call immediately without creating a transaction on the blockchain. Commonly used to read data from smart contracts.

### Parameters

1. `Object` — The transaction call object:
   | Field | Type | Required | Description |
   |-------|------|----------|-------------|
   | from | DATA | No | Sender address |
   | to | DATA | **Yes** | Contract address |
   | gas | QUANTITY | No | Gas limit |
   | gasPrice | QUANTITY | No | Gas price |
   | value | QUANTITY | No | Value sent |
   | data | DATA | No | ABI-encoded function call |

2. `QUANTITY|TAG` — Block number, or `"latest"`, `"earliest"`, `"pending"`.

### Returns

`DATA` — The return value of the executed contract function.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_call",
  "params": [
    {
      "to": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      "data": "0x18160ddd"
    },
    "latest"
  ],
  "id": 1
}
```

The example reads ERC-20 `totalSupply()` (selector `0x18160ddd`). Replace `to` with a token contract on Ethereum.

### Response

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x0000000000000000000000000000000000000000000000000000001234567890"
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_call/

## eth_chainId

Returns the chain ID of the current network

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Returns the chain ID used for signing replay-protected transactions (EIP-155).

### Parameters

None.

### Returns

`QUANTITY` — The current chain ID.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_chainId",
  "params": [],
  "id": 1
}
```

### Response

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1"
}
```

> `0x1` = 1 (Ethereum)

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_chainId/

## eth_estimateGas

Estimates gas needed for a transaction

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Generates and returns an estimate of how much gas is necessary to allow the transaction to complete. The transaction will not be added to the blockchain.

### Parameters

1. `Object` — Transaction call object (same as `eth_call`):
   | Field | Type | Required | Description |
   |-------|------|----------|-------------|
   | from | DATA | No | Sender address |
   | to | DATA | No | Recipient address |
   | gas | QUANTITY | No | Gas limit |
   | gasPrice | QUANTITY | No | Gas price |
   | value | QUANTITY | No | Value in wei |
   | data | DATA | No | Call data |

2. `QUANTITY|TAG` — (Optional) Block number, or `"latest"`.

### Returns

`QUANTITY` — The estimated amount of gas.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_estimateGas",
  "params": [
    {
      "from": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
      "to": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      "value": "0x0",
      "data": "0xa9059cbb0000000000000000000000001234567890abcdef1234567890abcdef1234567800000000000000000000000000000000000000000000000000000000000f4240"
    }
  ],
  "id": 1
}
```

### Response

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0xc350"
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_estimateGas/

## eth_feeHistory

Returns base fee per gas and effective priority fee history

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Returns base fee per gas and effective priority fee history.

### Parameters

| Parameter           | Type       | Required | Description            |
| ------------------- | ---------- | -------- | ---------------------- |
| `blockCount`        | `hex`      | Yes      | Number of blocks (hex) |
| `newestBlock`       | `blockTag` | Yes      | Newest block           |
| `rewardPercentiles` | `array`    | No       | Reward percentiles     |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_feeHistory",
  "params": ["0x4", "latest", [25, 75]],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_feeHistory/

## eth_gasPrice

Returns the current gas price in wei

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Returns the current price per gas in wei.

### Parameters

None.

### Returns

`QUANTITY` — Integer of the current gas price in wei.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_gasPrice",
  "params": [],
  "id": 1
}
```

### Response

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x3b9aca00"
}
```

> `0x3b9aca00` = 1,000,000,000 wei = 1 Gwei

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_gasPrice/

## eth_getBalance

Returns the balance of an account

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Returns the balance of the account of a given address.

### Parameters

1. `DATA` (20 bytes) — Address to check for balance.
2. `QUANTITY|TAG` — Block number, or `"latest"`, `"earliest"`, `"pending"`.

### Returns

`QUANTITY` — Integer of the current balance in wei.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getBalance",
  "params": ["0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045", "latest"],
  "id": 1
}
```

### Response

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x6c6b935b8bbd400000"
}
```

> The result is in **wei**. `0x6c6b935b8bbd400000` = 2000 × 10^18 wei, or 2,000 units of the Ethereum native token.

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getBalance/

## eth_getBlobSidecarByTxHash

Returns blob sidecars for a transaction hash

Available on 1 of 25 served EVM networks: BSC.

Counts as 1 request. Example values below are for BSC (`bsc-rpc.blockreq.com`).

### Description

Returns blob sidecars for a transaction hash.

### Parameters

| Parameter         | Type  | Required | Description                |
| ----------------- | ----- | -------- | -------------------------- |
| `transactionHash` | `hex` | Yes      | Transaction hash with blob |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getBlobSidecarByTxHash",
  "params": ["0x..."],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/bsc/eth_getBlobSidecarByTxHash/

## eth_getBlobSidecars

Returns all blob sidecars for a block

Available on 1 of 25 served EVM networks: BSC.

Counts as 1 request. Example values below are for BSC (`bsc-rpc.blockreq.com`).

### Description

Returns all blob sidecars for a block.

### Parameters

| Parameter | Type       | Required | Description         |
| --------- | ---------- | -------- | ------------------- |
| `block`   | `blockTag` | Yes      | Block number or tag |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getBlobSidecars",
  "params": ["latest"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/bsc/eth_getBlobSidecars/

## eth_getBlockByHash

Returns information about a block by hash

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Returns information about a block by block hash.

### Parameters

1. `DATA` (32 bytes) — Hash of a block.
2. `Boolean` — If `true`, returns full transaction objects; if `false`, returns only transaction hashes.

### Returns

`Object|null` — A block object (same structure as `eth_getBlockByNumber`), or `null` when no block was found.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getBlockByHash",
  "params": ["0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae", false],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getBlockByHash/

## eth_getBlockByNumber

Returns information about a block by block number

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Returns information about a block by block number.

### Parameters

1. `QUANTITY|TAG` — Integer of a block number, or the string `"earliest"`, `"latest"`, `"safe"`, `"finalized"`, or `"pending"`.
2. `Boolean` — If `true`, returns full transaction objects; if `false`, returns only transaction hashes.

### Returns

`Object|null` — A block object, or `null` when no block was found.

| Field         | Type     | Description                   |
| ------------- | -------- | ----------------------------- |
| number        | QUANTITY | Block number                  |
| hash          | DATA     | Block hash                    |
| parentHash    | DATA     | Parent block hash             |
| timestamp     | QUANTITY | Unix timestamp                |
| gasUsed       | QUANTITY | Gas used                      |
| gasLimit      | QUANTITY | Gas limit                     |
| baseFeePerGas | QUANTITY | Base fee (EIP-1559)           |
| transactions  | Array    | Transaction hashes or objects |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getBlockByNumber",
  "params": ["latest", false],
  "id": 1
}
```

### Response

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "number": "0x134e82a",
    "hash": "0xabc...def",
    "parentHash": "0x123...456",
    "timestamp": "0x65a1b2c3",
    "gasUsed": "0x1234",
    "gasLimit": "0x1c9c380",
    "baseFeePerGas": "0x3b9aca00",
    "transactions": ["0x..."]
  }
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getBlockByNumber/

## eth_getBlockReceipts

Returns all transaction receipts in a block

Available on every served EVM network (25).

Counts as 3 requests. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

`eth_getBlockReceipts` returns receipts for every transaction in a block when the chain supports the method. It is a heavy history method and may be chain-specific.

### Parameters

1. `QUANTITY|TAG|DATA` - Block number, block tag, or block hash, depending on chain support.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getBlockReceipts",
  "params": ["latest"],
  "id": 1
}
```

### Notes

- Use this method for block-level receipt ingestion when available.
- Availability and accepted parameter form can vary by chain and provider.
- Large blocks can return large payloads.

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getBlockReceipts/

## eth_getBlockTransactionCountByHash

Returns the number of transactions in a block by hash

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Returns the number of transactions in a block by hash.

### Parameters

| Parameter   | Type  | Required | Description |
| ----------- | ----- | -------- | ----------- |
| `blockHash` | `hex` | Yes      | Block hash  |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getBlockTransactionCountByHash",
  "params": ["0x..."],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getBlockTransactionCountByHash/

## eth_getBlockTransactionCountByNumber

Returns the number of transactions in a block by number

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Returns the number of transactions in a block by number.

### Parameters

| Parameter | Type       | Required | Description         |
| --------- | ---------- | -------- | ------------------- |
| `block`   | `blockTag` | Yes      | Block number or tag |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getBlockTransactionCountByNumber",
  "params": ["latest"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getBlockTransactionCountByNumber/

## eth_getCode

Returns the code at a given address

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Returns code at a given address. Used to check if an address is a smart contract.

### Parameters

1. `DATA` (20 bytes) — Address to get code from.
2. `QUANTITY|TAG` — Block number, or `"latest"`, `"earliest"`, `"pending"`.

### Returns

`DATA` — The code from the given address. Returns `0x` for EOA (non-contract) accounts.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getCode",
  "params": ["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "latest"],
  "id": 1
}
```

### Response

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x6080604052..."
}
```

Replace the example address with a contract on Ethereum.

> If the result is `"0x"`, the address is an EOA (externally owned account), not a contract.

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getCode/

## eth_getFilterChanges

Polls for changes since last call

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Polls for changes since last call.

### Parameters

| Parameter  | Type  | Required | Description |
| ---------- | ----- | -------- | ----------- |
| `filterId` | `hex` | Yes      | Filter ID   |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getFilterChanges",
  "params": ["0x1"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getFilterChanges/

## eth_getFilterLogs

Returns all logs for a filter

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Returns all logs for a filter.

### Parameters

| Parameter  | Type  | Required | Description |
| ---------- | ----- | -------- | ----------- |
| `filterId` | `hex` | Yes      | Filter ID   |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getFilterLogs",
  "params": ["0x1"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getFilterLogs/

## eth_getFinalizedBlock

Returns the latest finalized block

Available on 1 of 25 served EVM networks: BSC.

Counts as 1 request. Example values below are for BSC (`bsc-rpc.blockreq.com`).

### Description

Returns the latest finalized block.

### Parameters

| Parameter          | Type      | Required | Description               |
| ------------------ | --------- | -------- | ------------------------- |
| `finalityType`     | `string`  | No       | "fast" or "probabilistic" |
| `fullTransactions` | `boolean` | No       | Include full tx objects   |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getFinalizedBlock",
  "params": ["fast", false],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/bsc/eth_getFinalizedBlock/

## eth_getFinalizedHeader

Returns the latest finalized block header (BSC fast finality)

Available on 1 of 25 served EVM networks: BSC.

Counts as 1 request. Example values below are for BSC (`bsc-rpc.blockreq.com`).

### Description

Returns the latest finalized block header (BSC fast finality).

### Parameters

| Parameter      | Type     | Required | Description               |
| -------------- | -------- | -------- | ------------------------- |
| `finalityType` | `string` | No       | "fast" or "probabilistic" |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getFinalizedHeader",
  "params": ["fast"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/bsc/eth_getFinalizedHeader/

## eth_getLogs

Returns logs matching a filter

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Returns an array of all logs matching a given filter object. This is one of the most commonly used methods for indexing and monitoring smart contract events.

### Parameters

1. `Object` — Filter options:
   | Field | Type | Description |
   |-------|------|-------------|
   | fromBlock | QUANTITY\|TAG | Start block (default: `"latest"`) |
   | toBlock | QUANTITY\|TAG | End block (default: `"latest"`) |
   | address | DATA\|Array | Contract address(es) to filter |
   | topics | Array | Topic filters (indexed event params) |
   | blockHash | DATA | Restricts to a single block |

### Returns

`Array` — Array of log objects:

| Field           | Type          | Description                   |
| --------------- | ------------- | ----------------------------- |
| address         | DATA          | Contract that emitted the log |
| topics          | `Array<DATA>` | Indexed event parameters      |
| data            | DATA          | Non-indexed event parameters  |
| blockNumber     | QUANTITY      | Block number                  |
| transactionHash | DATA          | Transaction hash              |
| logIndex        | QUANTITY      | Log index in block            |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getLogs",
  "params": [
    {
      "fromBlock": "0x134E800",
      "toBlock": "0x134E810",
      "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      "topics": ["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"]
    }
  ],
  "id": 1
}
```

The example filters ERC-20 `Transfer` events for one token contract. Replace `address` and the block range with values on Ethereum.

> The topic `0xddf252ad...` is the keccak-256 hash of `Transfer(address,address,uint256)`.

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getLogs/

## eth_getProof

Returns account and storage Merkle proofs for an address at a block

Available on 9 of 25 served EVM networks: Ethereum, Base, Arbitrum One, Polygon, BSC, Ethereum Sepolia, Base Sepolia, Arbitrum Sepolia, Polygon Amoy.

Counts as 3 requests. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

`eth_getProof` returns an account proof plus optional storage proofs for an address at a block tag. Historical block tags require historical state on that chain.

### Parameters

1. `DATA` - 20-byte account address.
2. `Array<DATA>` - Storage slot keys to prove.
3. `QUANTITY|TAG` - Block number or tag.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getProof",
  "params": ["0x0000000000000000000000000000000000000000", [], "0x1"],
  "id": 1
}
```

### Notes

- Available only on EVM chains that support account proofs.
- Use paid endpoints for production proof workloads and old-block state access.
- If a chain page does not list historical state, treat historical proof support as unavailable.

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getProof/

## eth_getStorageAt

Returns the value from a contract storage slot

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

`eth_getStorageAt` reads a storage slot for an address at a block tag. Latest-state reads work on standard EVM routes; old-block reads require archive-capable routing.

### Parameters

1. `DATA` - 20-byte contract address.
2. `QUANTITY` - Storage position.
3. `QUANTITY|TAG` - Block number or tag.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getStorageAt",
  "params": ["0x0000000000000000000000000000000000000000", "0x0", "latest"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getStorageAt/

## eth_getTransactionByBlockHashAndIndex

Returns transaction by block hash and index

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Returns transaction by block hash and index.

### Parameters

| Parameter   | Type  | Required | Description             |
| ----------- | ----- | -------- | ----------------------- |
| `blockHash` | `hex` | Yes      | Block hash              |
| `index`     | `hex` | Yes      | Transaction index (hex) |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByBlockHashAndIndex",
  "params": ["0x...", "0x0"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getTransactionByBlockHashAndIndex/

## eth_getTransactionByBlockNumberAndIndex

Returns transaction by block number and index

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Returns transaction by block number and index.

### Parameters

| Parameter | Type       | Required | Description             |
| --------- | ---------- | -------- | ----------------------- |
| `block`   | `blockTag` | Yes      | Block number or tag     |
| `index`   | `hex`      | Yes      | Transaction index (hex) |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByBlockNumberAndIndex",
  "params": ["latest", "0x0"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getTransactionByBlockNumberAndIndex/

## eth_getTransactionByHash

Returns transaction details by hash

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Returns the information about a transaction requested by transaction hash.

### Parameters

1. `DATA` (32 bytes) — Hash of a transaction.

### Returns

`Object|null` — A transaction object, or `null` when no transaction was found.

| Field            | Type     | Description                      |
| ---------------- | -------- | -------------------------------- |
| hash             | DATA     | Transaction hash                 |
| nonce            | QUANTITY | Sender nonce                     |
| from             | DATA     | Sender address                   |
| to               | DATA     | Recipient address                |
| value            | QUANTITY | Value transferred (wei)          |
| gas              | QUANTITY | Gas provided                     |
| gasPrice         | QUANTITY | Gas price (wei)                  |
| input            | DATA     | Call data                        |
| blockHash        | DATA     | Block hash (null if pending)     |
| blockNumber      | QUANTITY | Block number (null if pending)   |
| transactionIndex | QUANTITY | Index in block (null if pending) |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionByHash",
  "params": ["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"],
  "id": 1
}
```

### Response

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "hash": "0x88df...",
    "from": "0x...",
    "to": "0x...",
    "value": "0xde0b6b3a7640000",
    "blockNumber": "0x134e82a",
    "gasPrice": "0x3b9aca00"
  }
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getTransactionByHash/

## eth_getTransactionCount

Returns the number of transactions sent from an address (nonce)

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Returns the number of transactions sent from an address.

### Parameters

1. `DATA` (20 bytes) — Address.
2. `QUANTITY|TAG` — Block number, or `"latest"`, `"earliest"`, `"pending"`.

### Returns

`QUANTITY` — Integer of the number of transactions sent from this address.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionCount",
  "params": ["0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045", "latest"],
  "id": 1
}
```

### Response

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x29d"
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getTransactionCount/

## eth_getTransactionReceipt

Returns the receipt of a transaction by hash

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Returns the receipt of a transaction by transaction hash. Receipts are not available for pending transactions.

### Parameters

1. `DATA` (32 bytes) — Hash of a transaction.

### Returns

`Object|null` — A transaction receipt object, or `null` when no receipt was found.

| Field             | Type     | Description                               |
| ----------------- | -------- | ----------------------------------------- |
| transactionHash   | DATA     | Transaction hash                          |
| blockHash         | DATA     | Block hash                                |
| blockNumber       | QUANTITY | Block number                              |
| from              | DATA     | Sender address                            |
| to                | DATA     | Recipient (null for contract creation)    |
| contractAddress   | DATA     | Created contract address (null otherwise) |
| gasUsed           | QUANTITY | Gas used by this tx                       |
| cumulativeGasUsed | QUANTITY | Total gas in block up to this tx          |
| status            | QUANTITY | `0x1` (success) or `0x0` (failure)        |
| logs              | Array    | Log objects generated by this tx          |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionReceipt",
  "params": ["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_getTransactionReceipt/

## eth_getTransactionsByBlockNumber

Returns all transactions for a block number

Available on 1 of 25 served EVM networks: BSC.

Counts as 1 request. Example values below are for BSC (`bsc-rpc.blockreq.com`).

### Description

Returns all transactions for a block number.

### Parameters

| Parameter | Type       | Required | Description         |
| --------- | ---------- | -------- | ------------------- |
| `block`   | `blockTag` | Yes      | Block number or tag |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_getTransactionsByBlockNumber",
  "params": ["latest"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/bsc/eth_getTransactionsByBlockNumber/

## eth_health

Returns node health status

Available on 1 of 25 served EVM networks: BSC.

Counts as 1 request. Example values below are for BSC (`bsc-rpc.blockreq.com`).

### Description

Returns node health status.

### Parameters

None

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_health",
  "params": [],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/bsc/eth_health/

## eth_maxPriorityFeePerGas

Returns a suggestion for a priority fee (tip)

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Returns a suggestion for a priority fee (tip).

### Parameters

None

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_maxPriorityFeePerGas",
  "params": [],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_maxPriorityFeePerGas/

## eth_newBlockFilter

Creates a filter for new blocks

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Creates a filter for new blocks.

### Parameters

None

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_newBlockFilter",
  "params": [],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_newBlockFilter/

## eth_newFilter

Creates a new log filter

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Creates a new log filter.

### Parameters

| Parameter   | Type       | Required | Description      |
| ----------- | ---------- | -------- | ---------------- |
| `fromBlock` | `blockTag` | No       | Start block      |
| `toBlock`   | `blockTag` | No       | End block        |
| `address`   | `address`  | No       | Contract address |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_newFilter",
  "params": [
    {
      "fromBlock": "latest",
      "toBlock": "latest",
      "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
    }
  ],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_newFilter/

## eth_newPendingTransactionFilter

Creates a filter for pending transactions

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Creates a filter for pending transactions.

### Parameters

None

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_newPendingTransactionFilter",
  "params": [],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_newPendingTransactionFilter/

## eth_sendRawTransaction

Submits a pre-signed transaction for broadcast

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

Submits a pre-signed transaction for broadcast to the network. You must sign the transaction offline first.

### Parameters

1. `DATA` — The signed transaction data (hex-encoded).

### Returns

`DATA` (32 bytes) — The transaction hash, or the zero hash if the transaction is not yet available.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_sendRawTransaction",
  "params": ["0xf86c808504a817c80082520894..."],
  "id": 1
}
```

> This method requires a **private endpoint** (API key). It is not available on public endpoints.

### Response

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331"
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_sendRawTransaction/

## eth_subscribe

Subscribes to EVM events over WebSocket

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

`eth_subscribe` is available over WSS endpoints only. It creates a live subscription for event streams such as new heads or logs when the chain route has WSS enabled.

### Parameters

1. `String` - Subscription type, such as `newHeads`, `logs`, or `newPendingTransactions`.
2. `Object` - Optional filter object for subscription types such as `logs`.

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_subscribe",
  "params": ["newHeads"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_subscribe/

## eth_uninstallFilter

Uninstalls a filter

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Uninstalls a filter.

### Parameters

| Parameter  | Type  | Required | Description |
| ---------- | ----- | -------- | ----------- |
| `filterId` | `hex` | Yes      | Filter ID   |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_uninstallFilter",
  "params": ["0x1"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_uninstallFilter/

## eth_unsubscribe

Unsubscribe from a previously created subscription

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

> **Protocol**: WebSocket (WSS) only

### Description

Unsubscribe from a previously created subscription.

### Parameters

| Parameter        | Type  | Required | Description     |
| ---------------- | ----- | -------- | --------------- |
| `subscriptionId` | `hex` | Yes      | Subscription ID |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "eth_unsubscribe",
  "params": ["0x1"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/eth_unsubscribe/

## net_listening

Returns `true` if the client is actively listening for network connections

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Returns `true` if the client is actively listening for network connections.

### Parameters

None

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "net_listening",
  "params": [],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/net_listening/

## net_peerCount

Returns the number of peers currently connected to the client

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Returns the number of peers currently connected to the client.

### Parameters

None

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "net_peerCount",
  "params": [],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/net_peerCount/

## net_version

Returns the current network ID as a string

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Returns the current network ID as a string.

On Ethereum the network ID is normally the decimal chain ID, `1`.

### Parameters

None

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "net_version",
  "params": [],
  "id": 1
}
```

### Response

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "1"
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/net_version/

## trace_block

Returns all traces for a block (Erigon format)

Available on 9 of 25 served EVM networks: Ethereum, Base, Arbitrum One, Polygon, BSC, Ethereum Sepolia, Base Sepolia, Arbitrum Sepolia, Polygon Amoy.

Counts as 20 requests. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

> **Tier**: Paid plan required. Not available on Free.

### Description

Returns all traces for a block (Erigon format).

### Parameters

| Parameter | Type       | Required | Description         |
| --------- | ---------- | -------- | ------------------- |
| `block`   | `blockTag` | Yes      | Block number or tag |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "trace_block",
  "params": ["latest"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/trace_block/

## trace_filter

Returns traces matching block and address filters

Available on 9 of 25 served EVM networks: Ethereum, Base, Arbitrum One, Polygon, BSC, Ethereum Sepolia, Base Sepolia, Arbitrum Sepolia, Polygon Amoy.

Counts as 5 requests. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

`trace_filter` returns trace entries that match a block range and optional address filters. It is a paid trace method, not available on Free, and can be expensive for broad historical ranges.

### Parameters

1. `Object` - Filter object:

| Field         | Type            | Description                  |
| ------------- | --------------- | ---------------------------- |
| `fromBlock`   | `QUANTITY\|TAG` | Start block.                 |
| `toBlock`     | `QUANTITY\|TAG` | End block.                   |
| `fromAddress` | `Array<DATA>`   | Optional sender addresses.   |
| `toAddress`   | `Array<DATA>`   | Optional receiver addresses. |
| `after`       | `QUANTITY`      | Optional pagination offset.  |
| `count`       | `QUANTITY`      | Optional page size.          |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "trace_filter",
  "params": [
    {
      "fromBlock": "0x1",
      "toBlock": "0x10",
      "count": "0x10"
    }
  ],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/trace_filter/

## trace_transaction

Returns trace for a single transaction (Erigon format)

Available on 9 of 25 served EVM networks: Ethereum, Base, Arbitrum One, Polygon, BSC, Ethereum Sepolia, Base Sepolia, Arbitrum Sepolia, Polygon Amoy.

Counts as 5 requests. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

> **Tier**: Paid plan required. Not available on Free.

### Description

Returns trace for a single transaction (Erigon format).

### Parameters

| Parameter         | Type  | Required | Description      |
| ----------------- | ----- | -------- | ---------------- |
| `transactionHash` | `hex` | Yes      | Transaction hash |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "trace_transaction",
  "params": ["0x02b39a7c1f83eebf04e785ffc31a13543cc77353461e02f30f4ea48ef5db368e"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/trace_transaction/

## web3_clientVersion

Returns the client software version

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Returns the client software version.

### Parameters

None

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "web3_clientVersion",
  "params": [],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/web3_clientVersion/

## web3_sha3

Returns the Keccak-256 hash of the given data

Available on every served EVM network (25).

Counts as 1 request. Example values below are for Ethereum (`ethereum-rpc.blockreq.com`).

### Description

Returns the Keccak-256 hash of the given data.

### Parameters

| Parameter | Type  | Required | Description                |
| --------- | ----- | -------- | -------------------------- |
| `data`    | `hex` | Yes      | Data to hash (hex-encoded) |

### Request

```json
{
  "jsonrpc": "2.0",
  "method": "web3_sha3",
  "params": ["0x68656c6c6f"],
  "id": 1
}
```

Source: https://blockreq.com/docs/build/api-reference/ethereum/web3_sha3/