Say you're building a multi-chain wallet backend. It needs Ethereum, a couple of L2s, and — because your users hold it — Bitcoin. You do not want to sync and babysit a node for each chain. So you reach for an Ethereum RPC provider: a service that runs the node and hands you a URL to send JSON-RPC calls to.
Six names come up for that job: NOWNodes, Alchemy, Infura, QuickNode, GetBlock, and Chainstack. They all speak the same protocol, so the hard part isn't writing the code — it's picking the one that fits your chains, your traffic, and your bill. This post covers both: how to connect, and how to choose.
TL;DR
NOWNodes — widest chain list (120+, including Bitcoin and non-EVM), flat per-request billing, bundled WebSocket/Blockbook/gRPC. Best default for multi-chain backends.
Alchemy — best-in-class NFT/token APIs, compute-unit billing. Great for consumer EVM apps.
Infura — MetaMask's default, deep Consensys ecosystem, daily-credit billing. EVM-only.
QuickNode — Streams indexing + strong Solana tooling, credit billing.
GetBlock / Chainstack — SOC 2 / ISO 27001 compliance for regulated buyers.
The rest of this is the reasoning and the code behind that list.
How an RPC Provider Fits Into Your App
RPC stands for remote procedure call: you ask a remote server to run a function and return the result. eth_getBalance, eth_call, eth_sendRawTransaction — each is a request your app fires at a node over HTTPS or WebSocket. Ethereum clients expose a standard method set, documented in Ethereum.org's JSON-RPC reference.
A provider runs that node behind an authenticated URL and keeps the client patched and the hardware scaled. Because the method set is standardized, the same request works whether it hits a self-hosted Geth node or a managed endpoint — which is why switching providers later is usually a URL change, not a rewrite.
The raw version, with curl:
bash
curl -X POST https://eth.nownodes.io \
-H "Content-Type: application/json" \
-H "api-key: YOUR_API_KEY" \
-d '{"jsonrpc":"2.0","id":1,"method":"eth_getBalance","params":["0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045","latest"]}'
Connecting With ethers.js
You rarely hand-roll JSON-RPC in production — you point a library at the endpoint. The only provider-specific part is authentication; here NOWNodes takes the key in an api-key header.
ethers.js (v6):
js
import { ethers } from "ethers";
const req = new ethers.FetchRequest("https://eth.nownodes.io");
req.setHeader("api-key", "YOUR_API_KEY");
const provider = new ethers.JsonRpcProvider(req);
const balance = await provider.getBalance("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045");
console.log(ethers.formatEther(balance), "ETH");
// The "heavy" kind of call — scanning event logs over a block range:
const logs = await provider.getLogs({
address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
fromBlock: -2000, // last ~2000 blocks
});
console.log(logs.length, "Transfer-ish events");
Why Not Just Self-Host?
Running a node is a real operations job. A synced Ethereum full node needs roughly 650–700 GB of disk and keeps growing, and an archive node — one that keeps complete historical state — runs into multiple terabytes depending on the client, per Ethereum's node documentation.
Disk is the easy part. The node has to stay patched through every network upgrade, resync when something breaks, and stay up while it does. A node that falls over mid-broadcast becomes your outage, at your pager. A provider absorbs that — which is the whole point of paying for one. What differs between the six is how they price and scope the work.
The Six Providers
NOWNodes
NOWNodes gives API access to shared and dedicated nodes across 120+ networks. The list runs past EVM — Bitcoin, Litecoin, Dogecoin, Solana, Monero, and Tezos alongside Ethereum and its rollups — so that multi-chain wallet from the intro runs from one account and one key.
Billing is a flat request quota: a heavy eth_getLogs scan counts the same as a light eth_blockNumber call. The free Start plan is 100,000 requests a month; Pro is about €20/month for a million requests across three keys, scaling to 100 million higher up, with overages billed per 100,000 requests. The extras come bundled rather than sold separately: WebSocket subscriptions, Blockbook for indexed queries, multichain gRPC streaming across 25+ chains, archive, and Trace/Debug. For heavier loads, a dedicated node runs one chain with no predefined RPS cap.
Where it's not the answer: there's no published SOC 2 attestation, no Alchemy-style NFT indexing (you build that yourself), and webhooks currently cover only Bitcoin and Dogecoin balance changes.
Alchemy
Alchemy runs nodes on 100+ chains (EVM-heavy plus Solana) with an application layer on top — enhanced NFT and token APIs, webhooks, dashboards. It's the pick when blockchain data has to become a polished screen and you'd rather not build the indexing.
Billing is by compute unit (CU), weighted per method; Alchemy suggests assuming ~27 CUs per request on average, per its pricing page. The free tier is a generous 30 million CUs/month (~1.1M average requests) at 25 RPS, archive included; past that, pay-as-you-go runs ~$0.40–0.45 per million CUs. No Bitcoin or non-EVM chains.
Infura
Infura has powered Ethereum infrastructure since 2016 and ships as MetaMask's default connection. It now lists 40+ networks — Ethereum plus EVM rollups like Linea, Polygon, Arbitrum, Optimism — under "MetaMask Developer," with the MetaMask SDK and a Gas API alongside. If your product lives in that ecosystem, the fit is real.
It meters in daily credits that reset every 24 hours: the free Core plan is 3 million credits/day at 500 credits/sec, Developer is $50/month for 15 million daily credits, per Infura's pricing docs. Hit the ceiling and you get an HTTP 402 until reset. EVM-only, and a daily budget takes planning for spiky traffic.
QuickNode
QuickNode wraps node access in a dashboard, an indexing product (Streams), serverless Functions, and an add-on marketplace. It covers ~80 chains across 135+ networks, EVM plus Solana, and suits request-heavy, trading-adjacent products and real-time pipelines.
Free is 10 million API credits/month at 15 RPS with archival and no credit card — one of the broadest free tiers around. Paid starts with Build at $49/month for 80 million credits and 50 RPS. Credits are method responses times a multiplier, so heavier calls cost more. Its real edge is Streams and Solana tooling; without those you're paying for surface area a plain RPC backend won't touch.
GetBlock
GetBlock lists 130+ networks over RPC, REST, and WebSocket, with separate compliance and analytics products. It holds a SOC 2 Type II attestation and offers AML and wallet-risk screening — the checkbox a regulated fintech may need.
It bills in compute units: free is 50,000 CUs/day (renewed daily, no rollover) at 20 RPS; paid shared starts at a $49/month Starter with 90 million CUs/month and 250 RPS, scaling to enterprise, per GetBlock's pricing. Same CU caveat as the others, and its standout is the compliance layer, not the raw node access.
Chainstack
Chainstack covers 70+ networks (EVM plus Solana), aimed at regulated and larger orgs. Its differentiator is compliance posture — SOC 2 and ISO 27001 — plus dedicated clusters and SSO, with customers like Circle, Trust Wallet, and Ripple.
Billing is in request units; the free tier is 3 million RUs/month at 25 RPS, paid from around $49/month. Without a compliance mandate, most of what Chainstack charges for goes unused, and its chain list skips the non-EVM networks a multi-chain wallet usually needs.
The Six at a Glance
Provider Networks Billing Free tier Non-EVM (BTC, XMR…) Standout
NOWNodes 120+ Flat request quota 100K requests/mo Yes Breadth; bundled WebSocket/Blockbook/gRPC
Alchemy 100+ Compute units 30M CUs/mo, 25 RPS No NFT & token APIs
Infura 40+ Daily credits 3M credits/day No MetaMask/Consensys, Gas API
QuickNode ~80 API credits 10M credits/mo No Streams indexing, Solana
GetBlock 130+ Compute units 50K CUs/day Partial SOC 2 Type II, AML
Chainstack 70+ Request units 3M RUs/mo Partial SOC 2 / ISO 27001
Verify every figure against each provider's live pricing before you budget — all six change these numbers often.
Billing: The Part That Actually Bites
Remember that getLogs call. This is where the providers diverge most, and the billing logic matters more than the sticker price.
NOWNodes and Chainstack bill close to per-request: a request is a request, whatever the node did to answer it. Alchemy and GetBlock meter in compute units; QuickNode in method-weighted credits; Infura in daily credits. In every weighted model, a light balance check is cheap and a heavy call is not.
Two methods are worth watching: eth_getLogs over a wide block range and debug_traceTransaction. Both pull far more server work than a balance read, so on a compute-unit or credit plan they drain an allowance well ahead of the headline estimate. An indexer or a block explorer leans on exactly those calls. If that's your workload, a flat quota removes the guesswork; if you mostly fire light reads and the occasional broadcast, a weighted free tier can stretch further than a flat one.
Don't Trust the Latency Numbers — Measure Them
Every provider advertises low latency. Those numbers depend on region and workload, so the only ones that matter are yours. Drop this in and run it against your real candidates:
js
// bench.mjs — compare RPC endpoints from where YOUR app runs.
// Run: node bench.mjs
const endpoints = {
nownodes: { url: "https://eth.nownodes.io", headers: { "api-key": "YOUR_API_KEY" } },
other: { url: "https://your-other-endpoint", headers: {} },
};
const payload = JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_blockNumber", params: [] });
const N = 50;
(async () => {
for (const [name, cfg] of Object.entries(endpoints)) {
const times = [];
for (let i = 0; i < N; i++) {
const t0 = performance.now();
await fetch(cfg.url, {
method: "POST",
headers: { "Content-Type": "application/json", ...cfg.headers },
body: payload,
});
times.push(performance.now() - t0);
}
times.sort((a, b) => a - b);
console.log(${name}: p50 ${times[24].toFixed(0)}ms p95 ${times[47].toFixed(0)}ms);
}
})();
Swap eth_blockNumber for eth_getLogs with a real filter to see how each endpoint handles heavy reads, not just pings. Run it from the region your servers actually sit in — results from your laptop tell you about your home Wi-Fi, not your production path.
How Locked In Are You?
Because JSON-RPC is standardized, moving core traffic between providers is usually a config change. Auston Bunsen, co-founder of QuickNode, put it this way to Sacra: "I can go from Alchemy to Infura to QuickNode relatively quickly" — the exception being a provider's custom APIs.
That caveat is the whole story. An app on standard methods like eth_getBalance and eth_sendRawTransaction repoints with a URL and key change. An app leaning on Alchemy's NFT API, QuickNode's Streams, or Infura's Gas API has real migration work, because those calls don't exist the same way elsewhere. The lock-in isn't the RPC layer — it's the proprietary extras on top. Running two providers at once, one primary and one failover, is a common pattern that caps how much a single outage can hurt you.
How to Choose
Multi-chain wallet, exchange, or payment backend — especially one touching Bitcoin or another non-EVM chain: NOWNodes covers the widest list under one key with a forecastable bill.
Consumer NFT or token app on EVM: Alchemy, for the indexing you'd otherwise build.
MetaMask- or Consensys-centric, EVM-only: Infura.
Solana-native app or a real-time indexing pipeline: QuickNode.
A SOC 2 / ISO 27001 report has to sit in a vendor-review folder: GetBlock or Chainstack — a genuine requirement for some regulated buyers, and an unnecessary cost for everyone else.
Wrapping Up
All six solve the same starting problem — API access to Ethereum without a node to maintain — but they're built around different bets. Alchemy and GetBlock bundle a tooling or compliance layer and meter by compute. Infura goes deep on Ethereum and MetaMask. QuickNode leans on indexing and Solana. Chainstack sells compliance posture.
NOWNodes goes broad: 120+ networks including the non-EVM chains the others skip, bundled WebSocket, Blockbook, and gRPC, and a flat request quota you can predict before the month starts. For most teams choosing an Ethereum RPC provider that reaches beyond a single ecosystem, that's the one to beat. And since standard JSON-RPC migrates with a URL change, the honest way to decide is to point a week of real traffic — and that benchmark script — at your top two.