7 Best Base RPC Providers in 2026, Ranked and Priced

Last updated: 25 October 2026 · Prices, method weights, plan limits and Flashblocks support rechecked on vendor pages on 25 October 2026

The best Base RPC providers in 2026 are Chainstack for overall value, Alchemy for the strongest private free tier and tooling, and GetBlock and QuickNode for reliability and audits. We ranked seven providers on the weights from our main RPC ranking, priced three Base workloads on every meter, checked who documents Flashblocks and tested eight free public Base endpoints ourselves.

Base is not a generic EVM chain anymore. Blocks land every 2 seconds, but its Flashblocks feed exposes pre-confirmed state every 200ms, and only some providers document it. This guide is the Base cut of our ranking of the 12 best RPC node providers. Our methodology page explains how we collect prices and screenshots. For the L1 side, see our ranking of the best Ethereum RPC providers.

The Decision Kernel

Pick a Base provider by what your app does between blocks. Apps that act on pre-confirmed state need a documented Flashblocks endpoint, and indexers need cheap logs and archive. Price your real Base method mix first, because sends cost 1 unit on Chainstack and 500 on CDP Node. The shortcuts below cover the common cases.

• Lowest bill with audits and Flashblocks: Chainstack, at 1 request unit per call, Flashblocks on every Base endpoint and SOC 2 Type II plus ISO 27001.
• Free tier and app tooling: Alchemy, with 30M compute units a month free, Flashblocks on the existing endpoint and its wallet and data APIs.
• Top reliability: GetBlock, with the top reliability score in our main ranking and a documented Flashblocks endpoint.
• Audits, Streams and Base-specific methods: QuickNode, which documents base_transactionStatus and base_sendRawTransactionValidity.
• Cheapest flat meter for logs: dRPC, at $4.80 per million calls whatever the method.
• Paymaster and Coinbase tooling: CDP Node, but only at low volume, because its send and log weights make it the most expensive meter here.

How We Ranked the Base RPC Providers

We scored each provider from 1 to 5 on six weighted criteria, doubled. Weights, reliability, compliance and free tier scores come from our 12-provider RPC ranking. We rescored price, features and coverage for Base, since chain weights, Flashblocks and Base archive support differ by vendor. See our methodology page.

• Price per call, 25%: the price of one million Base calls in a typical app mix on each entry plan, from each vendor’s own Base weights.
• Reliability, 20%: public latency benchmarks, uptime claims, SLAs and support response targets.
• Compliance, 15%: SOC 2, ISO 27001 and other audits stated on the vendor’s own pages.
• Features, 15%: debug and trace APIs, dedicated nodes, streaming, Base-specific transaction methods and data APIs.
• Base access, 15%: mainnet and Sepolia, WebSocket, archive data and a vendor-documented Flashblocks endpoint.
• Free tier, 10%: how many real Base calls a team can make before paying.

Provider	Price (25%)	Reliability (20%)	Compliance (15%)	Features (15%)	Base access (15%)	Free tier (10%)	Score
Chainstack	5	4	5	5	5	3	9.2
Alchemy	3	4	4	5	5	5	8.3
GetBlock	4	5	4	4	4	2	8.0
QuickNode	3	4	5	5	5	2	8.0
dRPC	5	4	2	3	4	4	7.6
Ankr	2	3	4	3	3	4	6.0
Infura	3	3	1	3	4	4	5.9
CDP Node (not ranked)	1	2	1	3	3	3	4.0

Chainstack gains on Base because its flat meter, archive support and Flashblocks docs all land in one plan. QuickNode and Alchemy hold their tooling scores, while dRPC loses a point on Base access because its own docs do not cover Flashblocks.

What Makes Base RPC Different

Base produces a full block every 2 seconds, built from ten 200ms sub-blocks called Flashblocks. A Flashblocks-aware node exposes that pre-confirmed state through the pending tag and three WebSocket subscriptions, per Base’s Flashblocks API overview. A standard node shows a transaction after about 2 seconds, while a Flashblocks-aware node can show it within about 200ms.

• Methods that read pre-confirmed state: eth_call, eth_getBalance, eth_getTransactionCount, eth_estimateGas, eth_simulateV1, eth_getBlockByNumber and eth_getLogs with the pending tag, plus preconfirmed receipts.
• WebSocket subscriptions: newFlashblocks, newFlashblockTransactions and pendingLogs through eth_subscribe.
• No free public WebSocket: Base’s Flashblocks FAQ says it runs no free public WebSocket endpoint and that mainnet.base.org is explicitly rate limited, so production apps need a provider or their own node.
• Reorg risk: Base targets a Flashblock reorg rate below 0.1%, so treat a preconfirmation as a strong signal, not finality.

Base also plans to retire Flashblocks. Its docs say the Denim hardfork will replace them with canonical 200ms blocks and that the plan is not final. Chainstack reports that Denim activated on Base Sepolia on 21 October 2026 and that Base Mainnet keeps Flashblocks until Denim activates there, with November 2026 as Base’s target. Code that reads pending state will need to move to newHeads, logs and regular calls after that.

Flashblocks Support by Provider

We checked each vendor’s own docs for a Base Flashblocks endpoint on 25 October 2026. Four of the seven ranked providers publish their own Flashblocks guide, and none charges an add-on fee for it. Base’s FAQ names QuickNode, Alchemy, Infura and dRPC as Flashblocks providers.

Provider	Own Flashblocks docs	Endpoint	Extra methods documented
Chainstack	Yes	Every Base Mainnet endpoint	eth_sendRawTransactionSync, pending reads, subscriptions
Alchemy	Yes	Existing Base Mainnet endpoint	eth_simulateV1, pending reads, subscriptions
GetBlock	Yes	Shared Frankfurt (eu-central-1) endpoint	base_transactionStatus, eth_simulateV1, subscriptions
QuickNode	Yes	Existing Base endpoint, no add-on	base_transactionStatus, base_sendRawTransactionValidity
dRPC	Named by Base, no vendor guide found	Public node served Flashblocks state in our test	Not documented
Infura	Named by Base, no vendor guide found	Base Mainnet and Sepolia, HTTPS and WebSocket	Not documented
Ankr	No	Base on paid plans	Not documented
CDP Node	No	Base Mainnet and Sepolia only	eth_simulateV1 priced as a standard method

Base RPC Providers at a Glance

The table lines up each provider’s Base billing unit, free tier and entry plan. Fixed plans include a monthly allowance with overage above it, while Alchemy, Ankr and CDP Node bill pure usage. A credit on one vendor is not a credit on another, so check the unit first.

Provider	Base billing unit	Free tier	Entry paid plan
Chainstack	1 request unit per call, 2 for archive and debug	3M RU a month, 25 rps	Growth $49, 20M RU, 250 rps
Alchemy	Compute units per method, 10 to 60 for common calls	30M CU a month, 15 rps	Pay as you go, $0.525 per 1M CU
GetBlock	20 CU per Base call, x2 for archive and debug	50K CU	Starter $49, 90M CU, 250 rps
QuickNode	20 credits per Base call, any method	10M credits, one-month trial	Build $49, 80M credits, 50 rps
dRPC	Flat price per request	210M CU on public nodes, 100 rps	Pro $49, about 10M requests, 300 rps
Ankr	200 API credits per EVM call	200M credits a month, 30 rps	Pay as you go from $10 per 100M credits
Infura	80 credits for most reads, daily quota	3M credits a day	Developer $50, 15M credits a day
CDP Node	30, 100 or 500 billing units per method	10M BU a month	$0.50 per 1M BU, card required

What One Million Base Calls Cost

We converted each entry plan into the price of one million Base calls for three method mixes, using each vendor’s own weights. QuickNode and dRPC charge the same for every mix, while Alchemy, GetBlock, Infura and CDP Node get pricier as logs and sends grow.

• App mix: 40% eth_call, 15% balances, 15% block numbers, 10% receipts, 10% logs, 5% sends and 5% gas estimates.
• Trading bot mix: 45% eth_call, 15% receipts, 10% nonces, 10% balances, 10% sends, 5% gas estimates and 5% blocks.
• Indexer mix: 45% eth_getLogs, 25% blocks, 20% receipts and 10% eth_call over history, at archive rates where vendors charge them.

Entry plan	App mix, per 1M	Trading bot mix, per 1M	Indexer mix, per 1M
Chainstack, Growth	$2.45	$2.45	$4.90
dRPC, Pro	$4.80	$4.80	$4.80
GetBlock, Starter	$10.89	$10.89	$21.78
Infura, Developer	$12.06	$10.11	$17.64
QuickNode, Build	$12.25	$12.25	$12.25
Alchemy, Pay as you go	$13.60	$12.97	$20.27
Ankr, Pay as you go	$20.00	$20.00	$20.00
CDP Node, Pay as you go	$35.50	$47.25	$46.50

CDP Node is the outlier. Its trading bot mix averages 94.5 billing units per call because each eth_sendRawTransaction costs 500 units, which works out to $47.25 per million calls. Fixed plans only reach these rates when you use the whole allowance.

What Three Base Workloads Cost

We built three Base traffic patterns, converted each into every vendor’s unit and picked the cheapest public plan that covers the volume and a peak of three times the average rate. Chainstack had the lowest bill in all three workloads, from $49 for the app to $499 for the indexer.

Provider	Base consumer app, 10M	Base trading bot, 60M	Base indexer backfill, 100M
Chainstack	$49 (Growth)	$199 (Pro)	$499 (Business)
Alchemy	$136 (Pay as you go)	$778 (Pay as you go)	$2,026 (Pay as you go)
GetBlock	$199 (Advanced)	$579 (Pro)	$1,539 (Premium)
QuickNode	$123 (Build)	$632 (Scale)	$999 (Business)
dRPC	$49 (Pro)	$277 (Scale)	$517 (Scale)
Ankr	$200 (Pay as you go)	$900 (Deal ($500))	$1,567 (Deal ($500))
Infura	$225 (Team)	Enterprise quote	Enterprise quote
CDP Node	$350 (Pay as you go)	$2,830 (Pay as you go, rate raise needed)	$4,645 (Pay as you go, rate raise needed)

• Base consumer app, 10M requests: the app mix above with a peak of 12 requests per second.
• Base trading bot, 60M requests: the bot mix with a peak of 69 requests per second.
• Base indexer backfill, 100M requests: the indexer mix with a peak of 116 requests per second.

Plan limits moved several answers. The trading bot needs 1.2B GetBlock CU, which lands on Pro at $499 plus $80 of overage. Infura’s daily quota rules out its public plans for the bot and the indexer, so both need an Enterprise quote. CDP Node’s 7,500 billing units per 5 seconds, about 1,500 per second, cannot carry the bot or the indexer at peak without a rate raise.

Free Public Base Endpoints, Tested

We tested eight free public Base endpoints on 25 October 2026 from one cloud server. We timed 12 eth_blockNumber calls each, polled the pending block every 150ms for Flashblocks growth, and probed eth_getLogs limits. Five endpoints served live Flashblocks state, with up to seven distinct transaction counts inside one pending block.

Endpoint	Median, p90	Flashblocks state	eth_getLogs	Archive at block 1M
mainnet.base.org	114 ms, 123 ms	Yes	HTTP 429 even at 100 blocks	Yes
base.drpc.org	97 ms, 108 ms	Yes	100 blocks ok, 500 refused	Yes
base-rpc.publicnode.com	127 ms, 131 ms	Yes	20,000-result cap	No (403)
base.gateway.tenderly.co	149 ms, 168 ms	Yes	20,000-result cap	Yes
base.public.blockpi.network	254 ms, 268 ms	Yes	5,000-block cap	No (pruned)
1rpc.io/base	126 ms, 165 ms	No, pending 712 blocks behind	50-block cap	Not tested
rpc.ankr.com/base	No answer	n/a	API key now required	n/a
base.llamarpc.com	No answer	n/a	HTTP 525 on every call	n/a

Two findings matter for production. Base’s own endpoint is fast but throttled, which matches its FAQ, and Ankr’s public Base endpoint now requires an API key. Latency from one server says little about your users’ regions, so repeat the test from where your backend runs.

1. Chainstack

Chainstack runs Global Nodes and dedicated nodes for Base and bills in request units, so a Base call costs 1 RU whatever the method. Growth costs $49 for 20M request units, or $2.45 per million Base calls, and every Base endpoint is Flashblocks-aware.

• Plans: Developer free (3M RU, 25 rps), Growth $49 (20M, 250 rps), Pro $199 (80M, 400 rps), Business $499 (200M, 600 rps), Enterprise $990 (400M). Overage runs $15, $12.50, $10 and $5 per 1M RU.
• Meter: 1 RU per full-node call and 2 RU for archive and debug_* or trace_* calls, per its request unit rules.
• Base depth: archive data, Debug and Trace APIs, dedicated nodes and a private transaction submission path, per its Base page. Its Flashblocks guide expects 300 to 500ms confirmations against about 2,000ms and supports eth_sendRawTransactionSync.
• Weaknesses: the free tier is smaller than Alchemy’s, and Growth overage costs six times the included rate.

2. Alchemy

Alchemy pairs Base node access with wallet, token and account abstraction tooling, and it has the strongest free tier on a private endpoint. Free covers 30M compute units a month, about 1.2M Base calls in our app mix, with Flashblocks on the same endpoint.

• Plans: Free (30M CU, 15 rps) and Pay as you go at $0.525 per 1M CU, with Enterprise for higher throughput and SLAs, per its pricing page.
• Meter: 10 CU for eth_blockNumber, 20 for balances and receipts, 26 for eth_call, 40 for sends and 60 for eth_getLogs, per its compute unit table.
• Flashblocks: supported on Base Mainnet and Sepolia with the existing endpoint, including eth_simulateV1, per its Flashblocks quickstart.
• Weaknesses: $13.60 per million app calls and $20.27 per million indexer calls on pay as you go, and throughput is capped per account.

3. GetBlock

GetBlock sells shared and dedicated nodes across 130+ chains and holds the top reliability score in our main ranking. A Base call costs 20 CU, doubled for archive and debug calls. Its Base Flashblocks endpoint documents pending reads, WebSocket subscriptions and base_transactionStatus.

• Plans: Starter $49 (90M CU, 250 rps), Growth $99 (185M), Advanced $199 (385M), Scale $349 (700M), Pro $499 (1B CU, 800 rps, $0.40 per 1M overage) and Premium $699 (1.6B, $0.35). The free tier has 50K CU.
• Meter: chain multiplier 20 for Base, method multiplier 2 for debug and trace, and x2 for archive, per its CU rules.
• Flashblocks: documented on a shared Frankfurt (eu-central-1) endpoint, per its Base Flashblocks guide.
• Weaknesses: archive doubling put our indexer at $1,539, and lower plans have no overage, so you must size the plan up front.

4. QuickNode

QuickNode serves Base Mainnet and Sepolia with archive data, Debug and Trace APIs, Streams and the widest audit set in our main ranking. Every Base method costs 20 API credits, so its bill does not jump when logs or sends grow.

• Plans: Build $49 (80M credits, 50 rps), Accelerate $249 (450M, 125 rps), Scale $499 (950M, 250 rps) and Business $999 (2B, 500 rps). Overage runs $0.62 to $0.50 per 1M credits. The free trial gives 10M credits for one month.
• Meter: 20 credits for every Base method, per its Base credit page, or $12.25 per million calls on Build.
• Flashblocks: on the existing endpoint with no add-on, plus base_transactionStatus and base_sendRawTransactionValidity, per its Flashblocks docs.
• Weaknesses: Build caps throughput at 50 requests per second, and our trading bot needed Scale at $632.

5. dRPC

dRPC routes Base calls across many node operators and charges the same for every method. Its public Base node was the fastest endpoint in our test at a 97ms median and served live Flashblocks state.

• Plans: Free on public nodes (210M CU, 100 rps), Pro $49 (about 10M requests, 300 rps), Scale $199 (about 47M requests, 600 rps), Enterprise from $990. Overage and pay as you go cost $6 per 1M requests.
• Meter: $0.30 per 1M CU, flat across methods, per its compute unit page, or $4.80 per million calls on Pro.
• Base access: Mainnet and Sepolia over HTTPS and WebSocket with archive, per its Base chain page. Base’s FAQ names dRPC as a Flashblocks provider.
• Weaknesses: no audit report on its own pages, no vendor Flashblocks guide, and its public node refused a 500-block log query.

6. Ankr

Ankr runs a large multi-chain RPC network on prepaid API credits with a high rate ceiling. Every Base call costs 200 credits, or $20 per million, and its public Base endpoint now requires an API key.

• Plans: Freemium (200M credits a month, 30 rps), Pay as you go from $10 per 100M credits at 1,500 rps, Deal from $500 for 6B credits plus 20% extra, and Enterprise, per its service plans.
• Strengths: one price for all methods, the highest pay as you go rate limit here, and SOC 2 Type II through its operator Asphere on its trust page.
• Weaknesses: the highest flat rate in this list, no Flashblocks docs, and a $900 bill for our trading bot.

7. Infura

Infura serves Base Mainnet and Sepolia over HTTPS and WebSocket, and Base’s FAQ lists it as a Flashblocks provider. A daily credit quota rules out its public plans for our trading bot and indexer.

• Plans: Core free (3M credits a day), Developer $50 (15M a day) and Team $225 (75M a day), with Enterprise above.
• Meter: 80 credits for eth_call and most reads, 255 for eth_getLogs, 300 for gas estimates and 1,000 for debug_traceTransaction, per its credit cost table.
• Base access: Mainnet and Sepolia endpoints on its Base reference.
• Weaknesses: requests fail once the daily quota is used, no vendor Flashblocks guide, and no SOC 2 or ISO 27001 report on its pages.

Why CDP Node Is Not in the Ranking

CDP Node is Coinbase’s own Base RPC, bundled with Paymaster and wallet history. It bills in billing units by method tier, per its pricing page. A single eth_sendRawTransaction costs 500 billing units, so CDP Node is the costliest meter in this guide for any app that writes.

• Tiers: 30 BU for standard reads such as eth_call and balances, 100 BU for receipts, logs, blocks and gas estimates, and 500 BU for debug, trace and sends.
• Price: 10M BU free each month, then $0.50 per 1M BU, and a card has been required since January 2026.
• Limits: 7,500 BU per 5 seconds per project, about 50 standard calls per second, on Base Mainnet and Sepolia only.
• Our math: $35.50 per million app calls, $47.25 per million bot calls and $2,830 for our 60M-request trading bot.

Providers We Left Out

Dwellir, BlockPI and Tenderly serve Base, but they are not in our main ranking yet, so we have no comparable scores. Helius, Tatum, NOWNodes and Lava appear in our RPC node provider ranking, but Helius is Solana only and the rest scored too low or could not be priced on 25 October 2026.

Running your own Base node is the other route. Base publishes a Flashblocks-aware Reth build, but you then own storage, upgrades and the Denim migration. Our dedicated nodes hub covers when that starts to pay off.

Final Ranking

Chainstack wins on Base because it pairs the lowest meter with Flashblocks, archive, trace and audits on one plan, with no add-on fees for any of them. Alchemy and QuickNode trade price for tooling, GetBlock for uptime, and dRPC for a flat price without audits.

1. Chainstack, 9.2: lowest bill in every workload, Flashblocks on every endpoint.
2. Alchemy, 8.3: biggest free tier and app tooling, mid-priced at volume.
3. GetBlock, 8.0: top reliability with a documented Flashblocks endpoint.
4. QuickNode, 8.0: audits, Streams and Base-specific transaction methods.
5. dRPC, 7.6: cheapest flat meter and the fastest public node we tested.
6. Ankr, 6.0: high rate ceiling on prepaid credits.
7. Infura, 5.9: Base over HTTPS and WebSocket with a daily quota.

How to Set Up a Base RPC Fallback

Two providers behind one client cover outages, rate limits and the odd lagging node. In ethers v6, a FallbackProvider sends each call to the highest-priority healthy endpoint and fails over when it stalls. Put your cheapest Flashblocks-aware provider first and a second vendor behind it.

import { FallbackProvider, JsonRpcProvider } from "ethers";

const base = { chainId: 8453, name: "base" };
const provider = new FallbackProvider([
  { provider: new JsonRpcProvider(process.env.PRIMARY_BASE_URL, base, { staticNetwork: true }), priority: 1, weight: 2, stallTimeout: 400 },
  { provider: new JsonRpcProvider(process.env.BACKUP_BASE_URL, base, { staticNetwork: true }), priority: 2, weight: 1, stallTimeout: 800 },
], base, { quorum: 1 });

const pendingNonce = await provider.getTransactionCount(wallet, "pending");

To check that an endpoint serves Flashblocks state, poll the pending block a few times inside 2 seconds. If the transaction count grows while the block number stays the same, the node is Flashblocks-aware.

curl -s -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_getBlockByNumber","params":["pending",false]}' \
  "$BASE_RPC_URL" | jq '.result.number, (.result.transactions | length)'

For streaming, open a WebSocket to your provider and subscribe to pre-confirmed blocks. Keep a newHeads subscription alongside it, because that is the path that survives Denim.

{"jsonrpc":"2.0","id":1,"method":"eth_subscribe","params":["newFlashblocks"]}

Frequently Asked Questions