Should You Use Two RPC Providers? How to Run a Backup Next to Alchemy or QuickNode

Updated November 10, 2026 · Spectrum Nodes
Short answer: Yes, for any app in production. One provider, however good, is a single point of failure: an outage, a lapsed plan, a rate limit, or a node that falls behind the chain all stop your app the same way. Run a second provider on separate infrastructure, and keep it in use: send it a share of your live reads every day, so you know it works before you need it. A backup you never call is a backup you haven't tested, and you'll find its problems in the middle of an outage. Never make a free public endpoint your backup.
Why Isn't One Good Provider Enough?
Every request your app makes goes through one door. When that door sticks, your app stops, even while the chain keeps producing blocks.
The door can stick for reasons that have nothing to do with how good the provider is:
- An outage at the provider, in one region or everywhere
- Your own account: the monthly credits run out on the 28th, a card fails, a key gets rotated
- Rate limits when traffic spikes during a launch or a market move
- A node that falls behind after a chain upgrade, returning old blocks without an error
- A method that breaks, such as traces or a large
eth_getLogsrange, while basic calls still work
Your users don't know which one it was. They see a wallet that won't load or a trade that won't send.
We've written about what happens when an RPC goes down. This guide is the fix on your side.
What's Wrong With a Cold Backup?
Most teams add a second URL to a config file, then never send it a request. That's a cold backup, and it fails in predictable ways:
| What went wrong | When you find out |
|---|---|
| The backup key expired or the plan lapsed | During the outage |
| The backup's plan can't take your full traffic, so it rate limits you | During the outage |
It doesn't support a method you rely on, such as debug_traceTransaction | During the outage |
Its eth_getLogs block range limit is smaller than your primary's | During the outage |
| The URL points at the wrong chain or a testnet | During the outage |
A backup that is always in use carries a slice of real traffic every day. Each of those problems shows up as an error in your logs on a normal Tuesday, when fixing it costs you nothing.
How Much Traffic Should the Backup Carry?
Enough that a problem shows up within minutes, and small enough to keep costs down. A good starting point:
- Reads: send about 10 to 20% to the backup. Everything else goes to the primary first, with the backup as its fallback.
- Writes: send transactions through the primary. If it fails or times out, send the same signed transaction through the backup.
- Plan size: pick a backup plan that can carry 100% of your traffic for a few hours, since that's exactly what it does during an outage.
Sending the same signed transaction twice is safe. It has the same hash, so the chain includes it once. The second node usually answers "already known", which your code can treat as success.
How Do You Split Traffic in Code?
With viem, build two clients over the same pair of URLs in opposite order. Most reads go primary first, and about one in ten goes backup first:
import { createPublicClient, fallback, http } from 'viem' import { mainnet } from 'viem/chains' const primary = http(process.env.PRIMARY_RPC_URL) const backup = http(process.env.BACKUP_RPC_URL) // Primary first, backup if it fails const main = createPublicClient({ chain: mainnet, transport: fallback([primary, backup]) }) // Backup first, so it carries live traffic every day const canary = createPublicClient({ chain: mainnet, transport: fallback([backup, primary]) }) export const reader = () => (Math.random() < 0.1 ? canary : main) // usage: const block = await reader().getBlockNumber()
viem's fallback transport also takes a rank option. It pings each URL on an interval and moves the fastest, most stable one to the front:
transport: fallback([primary, backup], { rank: { interval: 30_000 } })
Ranking is a good health check, but on its own the backup only receives pings. Keep the split above so it serves real requests too.
With ethers v6, give both providers the same priority in a FallbackProvider. ethers shuffles providers that share a priority, so live requests split about evenly between them. That's more than 10%, which suits teams who want both providers fully warm:
import { FallbackProvider, JsonRpcProvider } from 'ethers' const opts = { staticNetwork: true } export const provider = new FallbackProvider( [ { provider: new JsonRpcProvider(process.env.PRIMARY_RPC_URL, 1, opts), priority: 1, weight: 1, stallTimeout: 1500 }, { provider: new JsonRpcProvider(process.env.BACKUP_RPC_URL, 1, opts), priority: 1, weight: 1, stallTimeout: 1500 }, ], 1, { quorum: 1 }, )
How Do You Know the Backup Is Healthy?
Run a small check every minute and alert on three things:
- Both answer. A failed call to either provider is worth a message, even if the other one covered it.
- Both agree on the chain head. If the block numbers drift apart by more than a few blocks, one of them is behind.
- Both still serve your heavy methods. Once a day, call one trace and one
eth_getLogsover the range your app uses.
const [a, b] = await Promise.all([mainClient.getBlockNumber(), backupClient.getBlockNumber()]) const gap = a > b ? a - b : b - a if (gap > 5n) alert(`RPC providers are ${gap} blocks apart`)
When a provider lags, take it out of rotation until it catches up. Serving old blocks is worse than serving an error, because nothing in your code notices.
Should Both Providers Agree Before You Move Money?
For the few reads that release funds, yes. A bridge confirming a burn, a large withdrawal, or a liquidation trigger should act only when two independent providers return the same answer.
The KelpDAO exploit on April 18, 2026 shows why. Attackers poisoned the RPC nodes a verifier trusted and knocked its fallback endpoints offline, so the only answers left were false ones. A backup that takes over only when the primary fails can't catch that. Two providers that must agree can. We broke the attack down in KelpDAO exploit explained.
With ethers v6, set the quorum to 2 for those reads:
// Both providers must return the same result, or the call throws export const strict = new FallbackProvider( [ { provider: new JsonRpcProvider(process.env.PRIMARY_RPC_URL, 1, opts), priority: 1, weight: 1 }, { provider: new JsonRpcProvider(process.env.BACKUP_RPC_URL, 1, opts), priority: 1, weight: 1 }, ], 1, { quorum: 2 }, )
Read at a fixed, finalized block number rather than latest, so a provider that's one block ahead doesn't count as a disagreement.
Can a Free Public Endpoint Be Your Backup?
No. The day your primary fails is the day you most need the backup to be fast, correct, and able to take all your traffic. Public endpoints are rate limited, often refuse traces and large log queries, and are run by operators you haven't vetted. Read are public RPC endpoints safe? for the full list of risks.
What Should You Look for in a Second Provider?
| Check | Why it matters |
|---|---|
| Separate infrastructure | Two providers on the same hardware or network can fail together |
| The same methods | Traces, archive data, and the eth_getLogs range your app needs |
| Regions near your servers | Failover shouldn't add a round trip across an ocean |
| Headroom to carry all your traffic | The backup becomes the primary during an outage |
| An audit you can read | SOC 2 Type II tells you how the provider runs its systems |
| A free plan to test | You can wire it in and send it real traffic before you pay |
Why Run Spectrum as Your Second Provider?
Spectrum Nodes runs on our own servers and routing in Tier III data centers in Malta, the Netherlands, and Canada, plus a bare metal deployment in Singapore, not on rented cloud. If your primary provider rents its infrastructure, the two of you don't share a failure point.
- Over a billion requests a day at 99.99% uptime
- SOC 2 Type II attested, and we've never had a breach
- More than 130 chains, with trace and debug methods on the chains marked for tracing on our networks page
- A free plan with no credit card, so you can add us next to Alchemy or QuickNode today and send us your 10%
You can run us as the primary or as the backup. Either order works, as long as both carry real traffic every day.
FAQ
Is running two RPC providers expensive? Less than you'd think. The backup carries 10 to 20% of reads on a normal day, so most of your spend stays with the primary. Start the backup on a free plan, and size it up before you depend on it for a full outage.
What's the difference between failover and load balancing? Failover moves traffic to the backup only when the primary fails. Load balancing spreads traffic across both all the time. A backup in daily use is a bit of both: a steady share every day, and all of it during an outage.
Will two providers return different data?
For a few seconds they can, because one may see a new block before the other. If a flow reads and then writes, pin it to one provider, or read at a fixed block number instead of latest.
Do I need two providers for WebSockets too?
Yes, if you depend on subscriptions. Reconnect to the backup when a socket drops, then backfill the missed blocks with eth_getLogs so no event is lost.
Should my backup be on a different chain client? It helps. If one client has a bug after an upgrade, a provider running a different client may keep going. Ask your providers which clients they run.
Add Spectrum as your second provider in a few minutes: Start Now. Running production volume and want to plan a failover setup with our engineers? Book a call.
