What is the Ethereum RPC URL?

The Ethereum Mainnet RPC URL with BoltRPC is https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum. Replace YOUR_API_KEY with your API key from dashboard.boltrpc.io. The chain ID is 1.

What is the function of Ethereum RPC?

Ethereum RPC allows your application to communicate with the Ethereum blockchain without running your own node. Through the RPC endpoint your app can read balances, query transactions, estimate gas and broadcast signed transactions to the network.

What should I look for in an Ethereum RPC provider?

The most important factors are reliability, pricing model and support. For pricing, look for transparent, published per-method request-unit (RU) pricing so you can predict costs from your call mix. BoltRPC pricing is fixed monthly plans with a published RU weight for every method and no surprise bills. For reliability, look for providers with a verifiable track record and production clients.

How do I add Ethereum to MetaMask?

Ethereum is already built into MetaMask by default. To use BoltRPC as your Ethereum RPC, go to Settings, then Networks, then Ethereum Mainnet, then Edit and replace the RPC URL with https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum.

What is the difference between an Ethereum RPC endpoint and an Ethereum node?

A node is the full Ethereum client software running on a server. An RPC endpoint is the URL you connect to in order to interact with that node. When you use BoltRPC, you get the RPC endpoint. BoltRPC runs and maintains the nodes.

Does BoltRPC support WebSocket for Ethereum?

Yes. BoltRPC provides WebSocket endpoints for Ethereum at wss://endpoints.boltrpc.io/ws/YOUR_API_KEY/ethereum. Use WebSocket for subscribing to real-time events: new blocks, pending transactions and contract event logs via eth_subscribe.

What is the Ethereum finality time?

Ethereum achieves finality after two epochs, which takes approximately 12 to 13 minutes. A transaction appears in a block quickly, but cryptographic finality comes after the epoch boundary. Bridges and cross-chain protocols typically wait for full finality before processing assets.

Ethereum RPC Endpoint

Dedicated Ethereum mainnet RPC built for production reads, writes and event pipelines: HTTPS + WebSocket on one key, request-unit pricing you can forecast before you ship.

chain id · 1JSON-RPC 2.0WebSocket

Start free trial Contact sales

LIVE LATENCY

26ms

LIVE

gateway round-trip · sampled every second

IN PRODUCTION AT Chainlink

Your endpoint, ready in one line.

Drop this URL into your RPC client, HTTP library or wallet config. No SDK install required.

HTTPS

https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum

WEBSOCKET

wss://endpoints.boltrpc.io/ws/YOUR_API_KEY/ethereum

Replace YOUR_API_KEY with your API key. Get a free key →

Pick your stack.

Copy-paste examples for the libraries you already use. Swap the API key, hit run.

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider(
  "https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum"
);

const blockNumber = await provider.getBlockNumber();
console.log("Latest block:", blockNumber);

const { Web3 } = require("web3");

async function main() {
  const web3 = new Web3("https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum");
  const block = await web3.eth.getBlockNumber();
  console.log("Latest block:", block);
}

main();

import { createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";

const client = createPublicClient({
  chain: mainnet,
  transport: http("https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum"),
});

const blockNumber = await client.getBlockNumber();
console.log("Latest block:", blockNumber);

curl https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum \
  -X POST \
  -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

Connect your dApp, bot, or protocol to Ethereum Mainnet with BoltRPC. ISO 27001:2022 certified infrastructure. Entry pricing from $49/mo with transparent, predictable request-unit plans.

Chain at a Glance


Chain ID	1
Protocol	PoS L1
Block time	~12 s
Native token	ETH
Finality	~2 epochs (~12.8 min)
EVM compatible	Yes

What Ethereum is Built For

Ethereum is the reference Layer 1. It holds the largest DeFi TVL of any blockchain, hosts the oldest NFT collections and is the default deployment target for institutional smart contract projects. Every major protocol launches on Ethereum first before expanding to L2s. Enterprise teams, Chainlink oracle networks, MEV searchers and financial infrastructure all depend on reliable Ethereum RPC access as a baseline requirement. Building on Ethereum means your RPC provider is load-bearing infrastructure, not a commodity.

Free Public Ethereum RPC Endpoints

For testing only, not production:

https://eth.llamarpc.com (LlamaNodes, free, rate-limited)
https://cloudflare-eth.com (Cloudflare, free, rate-limited)
https://ethereum.publicnode.com (PublicNode, free, rate-limited)

Why not use public RPCs in production: No SLA, rate-limited to 5-10 req/s, no support, shared infrastructure, unreliable during network congestion.

Common Use Cases on Ethereum

DeFi protocols and their keepers Lending, DEX and stablecoin protocols read state on every 12-second block and react to it. Keepers, liquidators and rebalancers run eth_call polling loops that never stop. Your RPC provider is load-bearing for all of them.

MEV searchers and trading infrastructure Searchers watch the mempool over WebSocket, simulate bundles with eth_call and submit within the block. Latency and an endpoint that tolerates bursts decide the outcome.

Wallets, custody and payment rails Balance lookups, nonce management, gas estimation and receipt polling for every user action. Handling RPC errors gracefully matters, but not hitting them in the first place matters more.

Indexers, analytics and compliance Token trackers and reporting tools replay eth_getLogs over long block ranges and keep streaming new events. Sizing a getLogs pipeline against published request-unit weights makes the backfill budget explicit.

Built for teams that ship on Ethereum.

ISO 27001:2022 certified infrastructure, cheapest entry tier

BoltRPC runs on Matrixed.Link's ISO/IEC 27001:2022 certified node infrastructure. For enterprise teams and compliance-conscious developers, that certification matters. At $49/mo entry pricing, BoltRPC offers ISO 27001 certified infrastructure at a competitive price no comparable provider matches.

Transparent request-unit pricing

Fixed monthly plans priced in request units, with every method assigned a published RU weight and no bill shock. BoltRPC offers fixed monthly plans starting at $49. Visit boltrpc.io/pricing for full plan details.

Built for MEV and high-frequency infrastructure

Ethereum is the primary MEV battleground. Searchers, arbitrage bots and liquidation systems need an endpoint that holds up under high concurrent request volumes. BoltRPC is purpose-built for production Ethereum applications.

Over 5 years of production node operation

Matrixed.Link has operated production blockchain infrastructure for over 5 years, including Chainlink oracle nodes. The same team and infrastructure back BoltRPC's Ethereum endpoint.

WebSocket for real-time subscriptions

Subscribe to new blocks, pending transactions and contract events via WebSocket. Essential for any Ethereum application that needs to react to chain state in real time.

Full JSON-RPC coverage.

Every standard Ethereum method you would expect. Archive-only methods are available on request for qualifying plans.

STANDARD16

eth_blockNumbereth_getBlockByNumbereth_getBlockByHasheth_getTransactionByHasheth_getTransactionReceipteth_getBalanceeth_getCodeeth_getStorageAteth_calleth_estimateGaseth_sendRawTransactioneth_getLogseth_getFilterLogseth_newFilternet_versionweb3_clientVersion

Ethereum, explained.

Common questions about connecting to Ethereum over BoltRPC.

Ask a question →Read the docs

: The Ethereum Mainnet RPC URL with BoltRPC is https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum. Replace YOUR_API_KEY with your API key from dashboard.boltrpc.io. The chain ID is 1.
: Ethereum RPC allows your application to communicate with the Ethereum blockchain without running your own node. Through the RPC endpoint your app can read balances, query transactions, estimate gas and broadcast signed transactions to the network. Every wallet, dApp and trading bot uses an RPC endpoint to interact with Ethereum. The RPC interface follows the JSON-RPC 2.0 specification: each request is a POST call with a method name and parameters and the response contains the result or an error. Common methods include eth_call for reading contract state, eth_sendRawTransaction for submitting signed transactions, eth_getLogs for fetching contract events and eth_blockNumber for tracking the chain head.
: The most important factors are reliability, pricing model and support. For pricing, look for transparent, published per-method request-unit (RU) pricing so you can predict costs from your call mix. Some providers use opaque compute unit weighting where heavy calls multiply your costs unpredictably. BoltRPC uses fixed monthly plans with a published RU weight for every method, no surprise bills. For reliability, look for providers with a verifiable track record and production clients you can reference. For support, look for human access on paid plans, not just documentation links. Infrastructure certifications like ISO 27001:2022 are worth checking if your team has compliance or procurement requirements.
: Ethereum is already built into MetaMask by default. To use BoltRPC as your Ethereum RPC, go to Settings, then Networks, then Ethereum Mainnet, then Edit and replace the RPC URL with https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/ethereum.
: A node is the full Ethereum client software running on a server. An RPC endpoint is the URL you connect to in order to interact with that node. When you use BoltRPC, you get the RPC endpoint. BoltRPC runs and maintains the nodes.
: Yes. BoltRPC provides WebSocket endpoints for Ethereum at wss://endpoints.boltrpc.io/ws/YOUR_API_KEY/ethereum. WebSocket is used for subscribing to real-time Ethereum events: new blocks, pending transactions and contract event logs via eth_subscribe.
: Ethereum achieves finality after two epochs, which takes approximately 12 to 13 minutes. A transaction that appears in a block is included quickly, but cryptographic finality, meaning it cannot be reorganized, comes after the epoch boundary. For most applications, a transaction with several confirmations is sufficient. Applications like bridges and cross-chain protocols typically wait for full finality.

Ship on Ethereum this week.

An API key in under 60 seconds, Ethereum plus 35+ other chains, and a team that answers when you write.

Start free trial View pricing