Ai Overview
RPC benchmarking sounds simple until a team tries to do it properly. If your app performs 95% light reads, you should not let a trace-heavy benchmark drive the decision. Nadcab Cloud starts at $10 with no rate tiers: you pay $0. You can review pricing at the pricing page, where pay-as-you-go is listed at $0.
Key Takeaways
- RPC benchmarking should measure your real workload mix, not just a single fast method like eth_blockNumber.
- The most useful metrics are P50, P95, P99 latency, data freshness, and error rate by method and region.
- WebSocket tests are essential for live apps because delivery lag, reconnect behavior, and dropped events often matter more than raw HTTPS speed.
- Archive, trace, and debug calls should be benchmarked separately from user-facing reads because they stress infrastructure differently.
- The best migration decision comes from a weighted matrix tied to product needs, followed by a gradual rollout and ongoing synthetic checks.
RPC benchmarking sounds simple until a team tries to do it properly. Most benchmark claims focus on average latency from one region, one method, or one short time window. Real applications are messier. They mix hot reads, pending writes, WebSocket subscriptions, retries, and occasional archive calls across multiple user regions. That is why RPC benchmarking should be tied to your own workload before you switch infrastructure.
For developers and technical founders, the question is not “who won a headline benchmark?” The real question is “which RPC setup gives our app the best latency, consistency, and operational safety for the methods we actually use?” A wallet, indexer, trading bot, bridge, and back office tool can all produce very different results against the same gateway.
This guide gives you a neutral framework to evaluate RPC performance in a repeatable way. It covers the workloads to test, the metrics that matter, common mistakes, and how to turn benchmark data into a migration decision. If you want a single multi-chain test target while designing your harness, Nadcab RPC exposes 70+ networks and 150+ endpoints behind one API key, which makes it practical to keep your test logic consistent across chains.
One API key. 70+ blockchains. Production-grade RPC.
Nadcab RPC gives you HTTPS and WebSocket endpoints across 150+ chain endpoints with smart routing and a 99.99% gateway uptime target. Pay as you go from $0.375 per 1M compute units.
Why RPC benchmarking matters before you switch providers
An RPC gateway is part transport layer, part data plane, and part failure domain. If you change it, you are not only changing median response time. You may also change how your app behaves under burst traffic, how quickly new blocks appear, how often requests are retried, and whether long-tail methods fail during peak periods.
That is why benchmark design matters more than benchmark screenshots. If your app performs 95% light reads, you should not let a trace-heavy benchmark drive the decision. If your users are split across North America, Europe, and Asia, a single-region test can hide routing problems. If you need pending transactions and event streams, HTTPS-only tests are incomplete.
Before testing, write down three things:
- Which chains matter now and in the next 6 to 12 months.
- Which RPC methods your app calls most often.
- What failure looks like for your product: stale data, missing events, slow confirmations, or outright errors.
Teams that skip this step usually optimize for the wrong number. A DeFi frontend may care about fresh state and burst tolerance. An analytics backend may care about archive depth and deterministic pagination. A wallet may care about broad chain coverage and stable transaction broadcast. For background on how RPC fits the wider stack, see Nadcab Labs’ Web3 Infrastructure Explained – Nodes, RPCs, and APIs.
Which RPC workloads to test: reads, writes, subscriptions, history
A useful RPC benchmark includes the workloads your product actually runs. The easiest way to get misleading results is to test only eth_blockNumber and then assume the winner will also perform best for logs, transactions, and archive state.
Read-heavy workloads
These are the methods most apps call continuously:
eth_blockNumbereth_getBalanceeth_calleth_getLogseth_getTransactionReceipteth_getBlockByNumber
Split reads into two groups: hot-path reads and expensive reads. Hot-path reads are things like current block number, balance, or small contract calls. Expensive reads include wide log ranges, large blocks with full transactions, and calls against contracts with heavy execution paths.
Write and broadcast workloads
Write benchmarking is often ignored because teams assume “a raw transaction is a raw transaction.” In practice, the user experience depends on gateway queueing, mempool propagation, duplicate handling, and timeout behavior. Test at least:
eth_sendRawTransaction- Time to first acknowledgment
- Time to receipt visibility via
eth_getTransactionReceipt - Behavior when the same signed transaction is submitted more than once
If transaction privacy matters on major EVM chains, include scenarios where MEV protection is relevant. Nadcab RPC offers MEV protection on Ethereum, BNB Smart Chain, Polygon, Arbitrum, Optimism, and Base, so it can be part of a realistic write-path evaluation for those networks. Product details are on the RPC home page.
Subscription workloads
For live apps, subscriptions are often more important than single request latency. Test:
newHeadsfor block freshnesslogssubscriptions for contract events- Pending transaction feeds if your app depends on mempool visibility
- Reconnect behavior after a forced disconnect
A gateway can look great on HTTPS and still produce dropped or delayed WebSocket events. That matters for trading interfaces, monitoring systems, and real-time notifications.
Archive and historical workloads
Historical access changes the benchmark. If you need old state, test with old block tags or deep block ranges. Archive access is available through Nadcab RPC on major EVM chains including Ethereum, BNB Smart Chain, Polygon, Arbitrum, Optimism, and Base. If your app depends on historical state reconstruction, do not benchmark only latest-state methods.
| Workload | Methods to include | What to watch |
|---|---|---|
| Hot reads | eth_blockNumber, eth_getBalance, eth_call |
P50/P95 latency, stale responses, timeout rate |
| Log scanning | eth_getLogs |
Range limits, consistency, pagination behavior |
| Writes | eth_sendRawTransaction |
Ack time, duplicate handling, receipt visibility |
| Subscriptions | newHeads, logs |
Delivery lag, disconnects, resubscribe correctness |
| Archive/history | Old block reads, historical calls | Availability, latency under depth, correctness |
Latency vs consistency vs error rate: the metrics that matter
The most common benchmark mistake is over-valuing average latency. A gateway with a low average and poor consistency can feel slower to users than a slightly higher average with tighter tails and fewer failures.
Latency distribution, not just averages
Track at least P50, P95, and P99 latency per method and per region. A gateway with a good P50 and bad P99 usually creates support tickets because the slowest requests cluster around user-visible actions.
Consistency and freshness
Measure whether the response is current, not just fast. Two practical checks:
- For
eth_blockNumber, compare the reported block against a reference stream over time. - For
newHeads, measure delay from block arrival to event delivery.
Freshness matters because some gateways can return a fast answer that is one or more blocks behind. For wallets and trading flows, that can be worse than a slightly slower but more current response.
Error rate by class
Track transport and JSON-RPC failures separately:
- HTTP 4xx and 5xx
- Timeouts and connection resets
- JSON-RPC errors such as invalid params, method not available, or internal errors
- Rate-limit style behavior if you are intentionally load testing
Group failures by method. A provider can be excellent for simple reads and weak on wide log scans or traces.
Operational signals
Your benchmark should also record:
- Success rate during traffic bursts
- Recovery time after upstream instability
- Regional differences
- Status transparency and incident communication
When you need a gateway with visible operational signals, a live page like Nadcab RPC status helps your team correlate app errors with infrastructure events during testing.
Stop overpaying for RPC requests
Nadcab Cloud starts at $10 with no rate tiers: you pay $0.375 per 1M compute units and scale up or down without contracts. Every plan includes archive and WebSocket access on supported networks.
How to design a fair multi-region RPC benchmark
A fair benchmark is boring in the best way. It removes accidental advantages and makes the results repeatable.
Use the same request set everywhere
Build one canonical suite and run it unchanged across all test targets. Keep request payloads identical, especially for:
- Block tags
- Contract addresses and calldata
- Log filters and block ranges
- Concurrency levels
If one endpoint is tested with tiny log ranges and another with large ones, your numbers are already compromised.
Test from more than one region
Run clients from the regions where users actually are. At minimum, separate your tests by geography and by environment:
- User-facing regions
- Backend job regions
- CI or batch regions if they generate meaningful load
Smart routing can materially change results by location. Nadcab RPC routes across providers and regions behind the gateway, so a multi-region test is the only fair way to judge how routing helps your own workload.
Warm-up and steady-state windows
Use a warm-up phase to avoid startup artifacts, then measure a steady-state window long enough to include minor chain and network noise. Also schedule repeated runs at different times of day. A benchmark that runs only once can be more anecdote than evidence.
Keep authentication and endpoint structure simple
Reducing test harness differences lowers human error. Nadcab RPC uses a straightforward endpoint pattern:
https://rpc.nadcab.com/<network-slug>/<your-api-key>
Supported networks and slugs are listed on the chain list. One API key across many networks is useful when your benchmark spans Ethereum, Arbitrum, Base, Solana, Sui, or other chains in the same harness.
Example benchmark script with ethers.js
The following Node.js example measures simple latency for repeated block number reads on Ethereum. It is intentionally small; in production you would add region labels, percentiles, retries, and output to a metrics store.
import { JsonRpcProvider } from "ethers";
import { performance } from "node:perf_hooks";
const RPC_URL = "https://rpc.nadcab.com/ethereum/<your-api-key>";
const provider = new JsonRpcProvider(RPC_URL);
async function benchmark(methodName, fn, iterations = 50) {
const times = [];
for (let i = 0; i < iterations; i++) {
const start = performance.now();
try {
const result = await fn();
const end = performance.now();
times.push(end - start);
console.log(`${methodName} ok`, result);
} catch (err) {
const end = performance.now();
times.push(end - start);
console.error(`${methodName} failed`, err.message);
}
}
times.sort((a, b) => a - b);
const p50 = times[Math.floor(times.length * 0.50)];
const p95 = times[Math.floor(times.length * 0.95)];
const p99 = times[Math.floor(times.length * 0.99)];
console.log({ methodName, iterations, p50, p95, p99 });
}
benchmark("eth_blockNumber", async () => {
return await provider.getBlockNumber();
});
For setup details, see the Nadcab RPC docs or Nadcab Labs’ guide to Web3 API integration, authentication, and RPC setup.
WebSocket benchmarking for mempool, events, and live apps
HTTPS benchmarks miss a lot of real-world pain. If your app streams blocks, logs, or pending transactions, benchmark WebSocket behavior directly.
What to measure on WebSockets
- Time from block production to
newHeadsdelivery - Time from on-chain event to
logsdelivery - Dropped messages during bursty blocks
- Reconnect success after disconnects
- Message ordering and duplicate event behavior
In a production app, message loss can be more damaging than modest latency. A monitoring service can backfill. A live trading or alerting system often cannot.
How to test reconnect logic
Do not assume the connection stays healthy. Force disconnects and verify that your client:
- Reconnects automatically
- Resubscribes to all filters
- Backfills missed blocks or logs using HTTPS
- Deduplicates overlap after recovery
This is where benchmarking becomes architecture review. The best RPC choice still needs correct client behavior. If your app uses mixed protocols, read Nadcab Labs’ guide to node infrastructure for dApps for broader design context.
Pick the RPC setup that fits your stage
- Nadcab Cloud: shared, auto-scaling endpoints for dApps and wallets
- Nadcab Core: bring your own nodes and add our smart routing engine
- Nadcab Craft: dedicated clusters, custom auth, compliance logging and enterprise SLA
- Nadcab for Chains: RPC infrastructure for new L1 and L2 networks
How archive, trace, and debug methods change results
Not all RPC methods are equal. Teams often benchmark only cheap requests and then get surprised when advanced methods behave differently in production.
Archive access is a separate class
Historical state lookups can be slower and less widely available than latest-state reads. If your indexer, wallet, or forensic tooling uses old block tags, benchmark those exact calls. Archive support should be treated as a capability and a performance dimension.
Trace and debug methods are expensive
Trace and debug style methods can stress the gateway and the backing nodes differently from standard calls. Even if your app uses them only for support tooling or simulations, they deserve a separate test profile. Do not let trace-heavy tests distort the decision for a user-facing frontend that rarely calls them.
Separate user path from operator path
A practical pattern is to create two benchmark suites:
- User path: reads, writes, and subscriptions that affect customer experience
- Operator path: archive, trace, and debug methods used by internal systems
If these paths have different needs, you may choose different infrastructure products. For example, shared auto-scaling on Nadcab Cloud may fit broad application traffic, while a team needing its own nodes behind managed routing may prefer Nadcab Core or dedicated clusters on Nadcab Craft.
Common benchmark mistakes that mislead engineering teams
Most bad benchmark conclusions come from a short list of avoidable errors.
Mistake 1: testing only one easy method
If you benchmark only eth_blockNumber, you are measuring a heartbeat, not application performance.
Mistake 2: ignoring tail latency
User pain often sits in P95 and P99. Do not ship based on averages.
Mistake 3: mixing correctness and infrastructure bugs
Bad client retry logic, no connection pooling, or missing backfill can make a good RPC service look bad. Validate your harness first.
Mistake 4: comparing different regions or time windows
Run the same tests, from the same places, over overlapping periods.
Mistake 5: not separating chain effects
Network behavior differs by chain. Benchmark Ethereum separately from Solana, Sui, or Starknet. Even among EVM chains, log density and block behavior vary enough to change results.
Mistake 6: treating rate limits as pure latency issues
If a benchmark silently triggers protective behavior, the result is not a latency comparison anymore. It is a concurrency and quota test.
| Benchmark mistake | Why it misleads | Better approach |
|---|---|---|
| Single-method testing | Misses real workload complexity | Use mixed read/write/subscription suites |
| Average-only reporting | Hides user-visible slow requests | Report P50, P95, P99 and errors |
| One-region tests | Misses routing and geography effects | Run from your user and backend regions |
| No archive scenarios | Overstates performance for history-heavy apps | Include historical reads if you need them |
| No reconnect tests | Misses live app failure modes | Force WebSocket disconnects and backfill |
If you are evaluating newer chains or app-specific workloads, Nadcab Labs also has useful chain-focused reading such as Sui node options, gRPC, and pruning and what to compare in HyperEVM vs EVM L2 RPC.
Turning benchmark data into an RPC migration decision
Benchmarking is only useful if it changes an engineering decision. After you collect data, score options against product needs instead of declaring one universal winner.
Build a weighted decision matrix
Use weighted categories such as:
- Latency on hot-path reads
- Consistency and data freshness
- Write-path reliability
- WebSocket delivery quality
- Archive capability
- Chain coverage
- Operational visibility and support model
- Cost model fit
For example, a cross-chain wallet may rank network coverage and steady read performance above trace support. A compliance-heavy financial workflow may care more about dedicated infrastructure, custom auth, and logging controls.
Do a low-risk migration first
Do not cut over all traffic at once. Start with one chain, one region, or one workload class. Common rollout patterns include:
- Shadow read traffic and compare responses
- Move non-critical backend jobs first
- Shift a small percentage of live reads
- Move WebSocket consumers after validating reconnect and backfill
- Migrate write traffic last
Nadcab RPC is useful here because one API key and consistent endpoint structure make partial migration easier across many supported chains. You can review pricing at the pricing page, where pay-as-you-go is listed at $0.375 per 1M compute units and Nadcab Cloud starts from $10 without rate tiers.
Match the product to the benchmark outcome
If your benchmark shows that shared, auto-scaling access is sufficient, a managed gateway can reduce operational work. If you need your own nodes with managed routing, or dedicated clusters with enterprise controls, map that requirement to the infrastructure shape instead of forcing one product to fit every team. Nadcab’s lineup spans Cloud, Core, Craft, and RPC for chains launching new L1 or L2 networks on Nadcab for Chains.
Keep the benchmark running after migration
The best teams do not treat benchmarking as a one-time bake-off. They keep synthetic checks running after cutover to watch drift in latency, error rate, and freshness. That turns procurement-style testing into an ongoing reliability practice.
Related guides from Nadcab Labs
Final Thoughts
Good RPC benchmarking is less about proving a winner and more about measuring fit. Test the methods you actually use, from the regions that matter, across both HTTPS and WebSocket paths. Track latency distributions, freshness, and failure classes together. Separate hot user flows from archive or operator-heavy workloads.
When you evaluate infrastructure this way, migration decisions become clearer and less emotional. You can see whether a gateway improves your app’s real experience instead of just its benchmark headline. If you want a practical multi-chain target for building and repeating that harness, get a Nadcab RPC API key and use the same test structure across supported networks while comparing results against your own acceptance criteria.
Ship faster on infrastructure you don’t have to babysit
Get one API key for 70+ networks, HTTPS and WebSocket endpoints, smart routing and a live status page. Building something bigger? Our blockchain team can design and run the full stack with you.
Get Your Free API Key →Talk to Our Experts
Pay as you go · No rate tiers · 99.99% gateway uptime target
Frequently Asked Questions
Q1.What is RPC benchmarking in blockchain development?
RPC benchmarking is the process of measuring how well an RPC endpoint handles the methods your application actually uses. That includes response latency, data freshness, WebSocket delivery, error rates, and behavior under concurrency. A good benchmark is tied to real app workflows rather than a generic speed test.
Q2.Which RPC methods should I benchmark first?
Start with the methods that drive user experience and backend cost in your app. For many EVM teams that means eth_call, eth_getBalance, eth_getLogs, eth_getTransactionReceipt, eth_blockNumber, and eth_sendRawTransaction. If you use subscriptions, include newHeads and logs over WebSockets from the beginning.
Q3.How do I benchmark RPC performance fairly across regions?
Use the same request payloads, concurrency, and time windows in each location. Run tests from the regions where your users and backend systems actually operate. Report results separately by region, because routing, physical distance, and network conditions can make an endpoint perform very differently across geographies.
Q4.Why is average latency not enough for RPC benchmarking?
Average latency hides the slow requests that users notice most. A provider can have a good average while still producing poor P95 or P99 times, stale responses, or intermittent failures. Tail latency and consistency usually matter more for production UX than a single average number.
Q5.When should a team test archive or historical RPC data separately?
Test archive access separately whenever your product reads old state, scans deep history, audits transactions, or supports analytics and forensic workflows. Historical calls can behave very differently from latest-state reads, so a benchmark that ignores them may look strong during testing and fail later in production.
Explore Services
Related Services
Reviewed by

Aman Vaths
Founder of Nadcab Labs
Aman Vaths is the Founder & CTO of Nadcab Labs, a global digital engineering company delivering enterprise-grade solutions across AI, Web3, Blockchain, Big Data, Cloud, Cybersecurity, and Modern Application Development. With deep technical leadership and product innovation experience, Aman has positioned Nadcab Labs as one of the most advanced engineering companies driving the next era of intelligent, secure, and scalable software systems. Under his leadership, Nadcab Labs has built 2,000+ global projects across sectors including fintech, banking, healthcare, real estate, logistics, gaming, manufacturing, and next-generation DePIN networks. Aman’s strength lies in architecting high-performance systems, end-to-end platform engineering, and designing enterprise solutions that operate at global scale.


