Recurring card billing is here. Subscribe once and you're covered every month

Get started
Spectrum Nodes

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

Featured image for: Should You Use Two RPC Providers? How to Run a Backup Next to Alchemy or QuickNode
Share

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_getLogs range, 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 wrongWhen you find out
The backup key expired or the plan lapsedDuring the outage
The backup's plan can't take your full traffic, so it rate limits youDuring the outage
It doesn't support a method you rely on, such as debug_traceTransactionDuring the outage
Its eth_getLogs block range limit is smaller than your primary'sDuring the outage
The URL points at the wrong chain or a testnetDuring 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:

  1. Both answer. A failed call to either provider is worth a message, even if the other one covered it.
  2. Both agree on the chain head. If the block numbers drift apart by more than a few blocks, one of them is behind.
  3. Both still serve your heavy methods. Once a day, call one trace and one eth_getLogs over 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?

CheckWhy it matters
Separate infrastructureTwo providers on the same hardware or network can fail together
The same methodsTraces, archive data, and the eth_getLogs range your app needs
Regions near your serversFailover shouldn't add a round trip across an ocean
Headroom to carry all your trafficThe backup becomes the primary during an outage
An audit you can readSOC 2 Type II tells you how the provider runs its systems
A free plan to testYou 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.