Base RPC Nodes & Endpoints

Base RPC URLs you can use right now

Third-party endpoints, free and shared. They hold up fine for reads and prototyping; the ceilings show up as capped eth_getLogs ranges and throttling when a mint or a listing sends everyone to the same URL at once.

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://mainnet.base.org");
const blockNumber = await provider.getBlockNumber();
console.log("Base block:", blockNumber);

The sequencer, soft confirmations, and what your Base RPC actually returns

Base is sequenced by a single Coinbase-operated sequencer, and that shapes what a read means. When a Base RPC returns a transaction as included, you are seeing the sequencer's unsafe head: ordered and executed, but not yet posted to Ethereum. Batches go to L1 afterwards, and only then does the transaction inherit Ethereum's finality. For most consumer flows the unsafe head is exactly what you want, because it is what makes a rollup feel instant.

It stops being what you want the moment money depends on it. An app crediting a deposit, a bridge releasing funds, or an accounting job reconciling balances is reading a state that is fast but not yet settled. The fix is not a different endpoint, it is knowing which head you asked for: query the finalized or safe block tag when the answer has to survive an L1 reorganisation, and reserve the latest tag for the UI. Teams tend to discover this distinction during an incident rather than during design, and a shared endpoint gives you no better visibility into it than a dedicated one does.

Shared Base endpoints and where they stop scaling

The public Base endpoints above are shared by every wallet, script, and indexer that found the same URL, and Base's traffic profile makes that sharing expensive. Activity arrives in bursts: a popular mint, an on-chain social moment, or a meme token launch can multiply request volume within minutes, and shared endpoints respond by throttling exactly when your app needs headroom. If your product depends on reading Base during those spikes, you are competing for capacity with the very crowd that caused them.

A dedicated Base RPC node inverts that. The node serves only your workload, so an eth_getLogs backfill over a busy NFT contract or a websocket subscription following new blocks does not queue behind strangers' traffic. BLAZED.sh goes a step further than renting you a private endpoint: your container runs on the same machine as the node, so the request never leaves the host at all.

Base RPC latency is a distance problem

Base produces a block roughly every two seconds, and public gateways add a round trip over the public internet, typically tens to low hundreds of milliseconds depending on region and load, before your code even sees the new state. On our live Ethereum product, co-locating your code with the node keeps RPC calls under 10 milliseconds because they travel over a local socket instead of the network. Dedicated Base nodes will use the same architecture: the win comes from removing the network path, not from a faster gateway.

What dedicated Base node hosting will cost

BLAZED.sh prices node access in per-request credits granted monthly by your subscription, with a deliberately narrow weight spread: most RPC methods cost a single credit, and only a handful of heavy operations cost more. Dedicated Base nodes will launch on the same credit model, with the waitlist deciding rollout priority.

For a consumer dApp on Base that mostly issues plain reads and log queries, nearly every call is a single credit, so a monthly allowance maps almost one to one to request count.

Perfect for

What is Base?

Base launched in 2023 as an OP-Stack rollup incubated by Coinbase. Because it inherits Ethereum's security and uses ETH for gas, most Ethereum tooling (ethers, viem, Foundry, The Graph) works unchanged: you just point it at a Base RPC URL with chain ID 8453. Base sequences transactions with roughly two-second block times and posts data to Ethereum, so the practical bottleneck for indexers, bots, and high-traffic dApps is RPC throughput and latency rather than the chain itself. Public endpoints are fine for reads and prototyping, but production workloads that hammer eth_getLogs, trace calls, or the mempool benefit from a dedicated node close to your compute.

Base RPC: frequently asked questions