HostDeFi › Library › EVM RPC endpoints, explained

EVM RPC endpoints — one dialect, every chain

Ethereum, Base, Arbitrum, BNB Chain, Polygon and thirty more networks all speak the same JSON-RPC dialect. What that shared wire actually is, which chain IDs matter, what a read lane should answer — and where a free endpoint ends and infrastructure begins.

Infra explainer · 9 min read · updated September 2026 · not financial advice

"EVM RPC" is shorthand for the Ethereum JSON-RPC specification — the method family that starts with eth_ and answers everything a wallet or backend asks a chain: eth_chainId, eth_blockNumber, eth_call, eth_getBalance, eth_getLogs, eth_getTransactionReceipt, eth_estimateGas, eth_sendRawTransaction. Every chain running an EVM — the Ethereum Virtual Machine — speaks this dialect, which is why the same client library works on dozens of networks. The endpoint URL plus the chain ID is the whole contract between you and a node.

The chain ID is the real identifier

Every EVM network has an EIP-155 chain ID — the number returned by eth_chainId and baked into signed transactions for replay protection. A URL is just a string; the chain ID is proof of which network the node is actually synced to. These are the mainnet lanes our relay serves today, with the IDs each endpoint must answer — the full list including testnet twins lives on /rpc/:

Each per-chain page shows the live upstream ladder that lane falls back across. The same engine also serves the testnet rehearsal networks — Sepolia (11155111), Base Sepolia (84532), Arbitrum Sepolia (421614), Monad testnet (10143) and the rest — so a deployment can be drilled end-to-end before it touches mainnet value.

What a read lane answers — and refuses

The EVM surface splits into three honest buckets. Reads are the bulk of all traffic: state reads (eth_call, eth_getBalance, eth_getCode, eth_getStorageAt), block and transaction reads (eth_getBlockByNumber, eth_getTransactionByHash, eth_getTransactionReceipt, eth_getBlockReceipts), fee reads (eth_gasPrice, eth_maxPriorityFeePerGas, eth_feeHistory, eth_blobBaseFee), log scans (eth_getLogs plus the filter family), and node metadata (net_version, web3_clientVersion). A good lane also passes through provider extensions per-call — simulate APIs, asset/metadata reads, single-transaction trace_/debug_ — where an upstream supports them.

Sends are one method: eth_sendRawTransaction — an already-signed payload. And then there's the bucket a free lane must never open: signing and enumeration. eth_sendTransaction, eth_sign, eth_signTransaction hand the node an unsigned payload or ask it to sign — refused on any sane relay, because a relay that accepts them is asking to hold your keys. Txpool/debug enumeration and whole-world scans are refused for a different reason: they burn an upstream's quota wholesale. An open relay that never gates methods is one billing alert away from vanishing — the worst time to find out is mid-incident.

Our lane enforces this as an explicit method allowlist per chain, with the mechanics that make a shared lane survivable: health-aware rotation (a failing upstream cools with exponential backoff instead of eating every request's latency), method-refusal memory (a node that can't serve a method is skipped for that method only), a micro-cache for immutable reads, and in-flight dedupe with id re-stamping so identical concurrent reads share one upstream call without leaking each other's request ids.

Sends are a different lane

A signed transaction is where "which endpoint" stops being about speed and starts being about ordering. Broadcast into a public mempool, a swap is observable before it lands — the sandwich surface every Ethereum user has met. Our relay treats sends as first-class: on Ethereum a raw transaction races rpc.flashbots.net (Flashbots Protect) and rpc.mevblocker.io first, with the read pool fanning out behind so a protected-path hiccup can't lose it. BNB Chain sends take MEV Blocker's BSC path the same way. On L2s like Base, Arbitrum and Optimism the sequencer model leaves no public mempool worth sandwiching, so sends fan out across the read pool — landing is what matters there.

The invariant underneath: the relay never sees a key. Only raw, already-signed payloads cross it, and signing-shaped methods are refused before they're ever attempted upstream.

When public suffices — and when you need your own lane

Public keyless endpoints are how the whole ecosystem onboards, and for a person clicking in a wallet they're usually right. The honest deal: shared quota, best-effort freshness, occasional 429s at peak. The moment a stall costs you — a trading bot that missed a block, a backend serving stale balances, an agent mid-task — you've crossed into infrastructure: a keyed provider tier, a paid relay lane, or your own node.

Three tripwires mark the crossing in practice: rate limits (429s under load), archive depth (free tiers serve recent state; old receipts and historical state reads need archival capacity that costs real money to store), and accountability (a free endpoint owes you nothing; a paid lane has a commitment someone answers for). On our relay the same split shows up as free keyless reads versus x402 metered lanes — the paid read where the 402 response carries the price and settlement rides the request itself.

Multi-chain in practice

Because the dialect is shared, multi-chain work is mostly bookkeeping: one method set, N endpoints, N chain IDs to keep straight. The failure modes are bookkeeping too — a wallet pointed at a Base URL while configured for Arbitrum, a bot broadcasting a chain-1-signed transaction to a chain-56 endpoint (it bounces: the signature commits to the ID). Keep the table above as ground truth, verify eth_chainId on any new endpoint before wiring it in, and when you're doing the same read across chains — portfolio snapshots, price checks, log scans — a single relay that speaks one URL shape per chain beats maintaining nineteen provider accounts. Ours is /rpc/; /networks/ shows which of those chains we also run nodes and validators on.

curl -X POST https://hostdefi.com/api/rpc/ethereum \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId"}'
# → "0x1" — Ethereum mainnet, proven not claimed

Frequently asked