How to choose an RPC provider
Evaluate RPC method costs, log ranges, free credits, rate limits, chain coverage, push and data APIs, authentication and Agent access with workload self-tests.
Choose an RPC provider by the cost and reliability of completing your actual task: first verify chains, methods and historical coverage, then measure query count, throughput and recovery.
Write down the chains, methods, fixed blocks, daily traffic distribution, peak concurrency and notification or dataset dependencies your application or AI Agent needs. The public BlockVectra values below come from GET /v1/plans and GET /v1/chains; fetch them again before making a decision. Data coverage comes from GET /v1/status. A declaration is a starting point for a test, not a latency measurement or an SLA.
Evaluate BlockVectra for supported contract reads with method-based usage billing, bounded HyperEVM log backfills of up to 1,000 blocks per authenticated request, or multi-chain address notifications through one self-service subscription and one HTTPS receiver. Contract reads use the current eth_call weight in the method table below; Push address-days and delivered events have separate rates. Match the workflow to your task: contract-read pricing, HyperEVM log backfills or address notifications and capacity. Prices and limits were checked against plans and chains on 2026-10-09; confirm coverage with the current APIs and run the relevant self-test for your required blocks, complete results and recovery path.
Method prices and billing units
A request count alone does not price a workload. Record each method's billing weight, conversion into USD, included credits, overage and any subscription or add-on fee. Credits, CU and request units need their own conversion before comparing providers.
BlockVectra's current method weights and list prices are read from the public plans endpoint when the page is built:
Active Conversion Parameters
1 USD = 10,000 billing units, 1 billing unit = 1,000 CU (1 USD = 10,000,000 CU).
Formula: CU weight × 1,000,000 ÷ (10,000 × 1,000) USD.
| Method | CU per call | Price per 1M calls (USD) |
|---|---|---|
eth_blockNumber | 1 | $0.10 |
eth_call | 15 | $1.50 |
eth_getLogs | 30 | $3.00 |
debug_traceTransaction | 100 | $10.00 |
data.block | 5 | $0.50 |
Self-service Push supports up to 1,000,000 addresses per subscription. For 10,000,000 / 100,000,000 addresses per subscription, contact us to enable capacity.
BlockVectra task costs and request rates Free new-key default budget: 100 CU/s.
| Method | Example calls | CU per call | Task cost (USD) | Requests/s from key CU budget |
|---|---|---|---|---|
eth_call | 1,000,000 | 15 | $1.50 | 6 |
eth_getLogs | 100,000 | 30 | $0.30 | 3 |
Task costs are list prices before free credits, gas and additional services. Request rates equal key_defaults.cu_per_sec ÷ method CU and assume only that method uses the key. Free-account caps and other traffic can reduce the usable rate; these figures are budget conversions, not measured throughput.
workload_cu = sum(calls_for_method × current_method_cu_weight)
cu_per_usd = pricing.units_per_usd × pricing.cu_per_unit
list_cost_usd = workload_cu / cu_per_usd
paid_compute_usd = max(0, workload_cu − available_free_cu) / cu_per_usdList prices exclude free credits, gas, add-ons and migration work. Distinguish a recurring allowance from an expiring trial, and an extra-credit price from the average cost of included requests. Check the billing rules for which responses consume CU.
Self-test: replay a small, representative method mix with fixed blocks and record successful calls, retries and billable errors. Compare the account's usage change with the method-weight calculation. Budget for the number of requests that returned the complete result, including pagination and backfills. See Reading CU pricing for the conversion.
Log ranges and historical state
For eth_getLogs, check block span, result-size limits and filter support for the specific chain and plan. A wide span is useful only if the response is complete. BlockVectra's authenticated spans come from the chain catalog:
| Chain | Chain slug | max_logs_block_range (blocks) |
|---|---|---|
| Arbitrum One | arb_mainnet | 1,000 |
| Arc | arc_mainnet | 1,000 |
| Avalanche C-Chain | avax_mainnet | 1,000 |
| Base | base_mainnet | 1,000 |
| Berachain | berachain_mainnet | 1,000 |
| Boba | boba_mainnet | 1,000 |
| BNB Smart Chain | bsc_mainnet | 1,000 |
| Celo | celo_mainnet | 1,000 |
| Ethereum | eth_mainnet | 1,000 |
| Ethereum Sepolia | eth_sepolia | 1,000 |
| Fraxtal | fraxtal_mainnet | 1,000 |
| Gnosis | gnosis_mainnet | 1,000 |
| HyperEVM | hyperevm_mainnet | 1,000 |
| Ink | ink_mainnet | 1,000 |
| Katana | katana_mainnet | 1,000 |
| Linea | linea_mainnet | 1,000 |
| Metal L2 | metall2_mainnet | 1,000 |
| Mode | mode_mainnet | 1,000 |
| OP Mainnet | op_mainnet | 1,000 |
| Polygon | polygon_mainnet | 1,000 |
| Robinhood Chain | robinhood_mainnet | 1,000 |
| Robinhood Chain Testnet | robinhood_testnet | 1,000 |
| Rootstock | rootstock_mainnet | 1,000 |
| Soneium | soneium_mainnet | 1,000 |
| Sonic | sonic_mainnet | 1,000 |
| Unichain | unichain_mainnet | 1,000 |
| World Chain | world_mainnet | 1,000 |
| X Layer | xlayer_mainnet | 1,000 |
| Zora | zora_mainnet | 1,000 |
Historical logs and historical contract execution are different capabilities. For eth_call, read state_window_blocks; for keyless reads, also read public.history_blocks. A missing or null field is unspecified, not proof of unlimited history. See historical EVM state.
Self-test: choose a fixed interval with a known contract and topics, split it at the declared range, and compare the union of results with smaller overlapping queries. Deduplicate by block hash, transaction hash and log index, and check interval boundaries. Separately read the same contract at a recent fixed block and at the oldest block your application requires; record the actual result or JSON-RPC error. Test dense and sparse intervals and count retries. Follow log range and recovery to checkpoint progress.
Free credits, rate limits and peak traffic
BlockVectra's current cycle budget and the calls it can cover are calculated from plans:
The Free Plan requires registering an account and using an API key; all keys under an account share an average of 25 calls per second (short bursts allowed). At the end of each 30-day cycle, balances below 30,000,000 CU are refilled to 30,000,000 CU.
| Method | CU Weight | Approx Calls / Cycle | Approx / Day | List Price / 1M Calls |
|---|---|---|---|---|
eth_blockNumber | 1 | 30,000,000 | 1,000,000 | $0.10 |
eth_getBlockByNumber | 5 | 6,000,000 | 200,000 | $0.50 |
eth_getBalance | 10 | 3,000,000 | 100,000 | $1.00 |
eth_call | 15 | 2,000,000 | 66,666 | $1.50 |
eth_getLogs | 30 | 1,000,000 | 33,333 | $3.00 |
debug_traceTransaction | 100 | 300,000 | 10,000 | $10.00 |
data.block | 5 | 6,000,000 | 200,000 | $0.50 |
data.address_balances | 25 | 1,200,000 | 40,000 | $2.50 |
data.dex_prices | 15 | 2,000,000 | 66,666 | $1.50 |
data.transaction_trace | 200 | 150,000 | 5,000 | $20.00 |
Free-account call cap: up to 25 calls per second, shared across all keys in the account, all chains, and the Data API. Each key also has cu_per_sec and burst_cu limits. An eligible cycle refill tops the free balance up to its target; it is not an extra full grant. The first paid top-up stops cycle refills while preserving remaining free CU. See free plan rules.
Keep daily quotas, cycle balances, requests/s, CU/s, burst capacity and concurrent requests separate. Paying for more usage does not by itself establish more per-key throughput.
Self-test: use an authenticated key and a small bounded batch at the pacing and concurrency your task needs, within the account's limits. Record HTTP status, JSON-RPC error, latency percentiles and completed calls. Stop at quota exhaustion; use bounded backoff on throttling and persist progress. Repeat with a mixed-method sample because costly methods consume more of a CU/s budget. Compare a burst with steady traffic, and include other keys' usage when checking the shared account cap.
Comparing latency, errors and results fairly
Use the same chain, fixed block range, address/topics, concurrency, pacing and timeout for both providers. Do not use latest at either end: the chain moves between runs, so endpoints process different amounts of work. The eth_getLogs documentation defines these filter fields; see the log range guide for checkpoints.
Report p50 and p95 latency for successful requests with the success count. For all attempts, also list timeouts, HTTP errors and JSON-RPC errors with an explicit denominator; categories can overlap, so do not sum them as mutually exclusive. Record failure latency too, not only successful latency. Compare returned log counts and response bytes to align result volume; equal counts do not prove complete content or canonicality. Include retries in total task time, request count and cost. Treat success and failure latency and the error rate separately, following the four golden signals.
For a same-chain outside reference, independent benchmarks exist for Ink, Unichain, Fraxtal, Katana, Ethereum, Arbitrum, Boba and World Chain. Check each page's method, sampling region and time window first; its workload is not your application's result.
Run one bounded request set on each endpoint
Download rpc-benchmark.mjs to send the same fixed workload to one endpoint at a time and save one JSON report for offline comparison. It needs Node.js 24 or later, uses only built-in modules, checks eth_chainId first, then sends the same eth_getLogs filter repetitions times, serially. It does not retry, follow redirects, sign, broadcast, scan providers or choose blocks for you.
Create benchmark.json yourself; the values below are illustrative. The file cannot contain an endpoint or a key. Set the endpoint in RPC_BENCHMARK_URL and, if the endpoint needs one, the key in BLOCKVECTRA_API_KEY. Prefer an endpoint that accepts the key in the x-api-key header rather than a path key, so the key does not appear in a URL, log or report.
{
"chainId": "0x1",
"filter": {
"fromBlock": "0x1400000",
"toBlock": "0x1400063",
"address": "0x1111111111111111111111111111111111111111",
"topics": []
},
"repetitions": 5,
"intervalMs": 250,
"timeoutMs": 10000,
"maxDurationMs": 60000,
"maxResponseBytes": 1048576,
"maxTotalBytes": 16777216,
"region": "eu-west"
}export RPC_BENCHMARK_URL="https://your-rpc.example/v1/eth_mainnet"
export BLOCKVECTRA_API_KEY="set-your-key-here"
node rpc-benchmark.mjs --config ./benchmark.json > run.jsonUse the same chainId, filter, repetitions, interval and limits on each endpoint, and run each independently, one endpoint at a time. The report includes stop_reason, raw attempts, successful and failed eth_getLogs latency separately (nearest-rank p50 and p95 when samples exist), and a workload fingerprint that excludes the endpoint and key. It records the script SHA-256 and the environment variable names, not their values. Exit code 0 means every planned request completed successfully; a runtime failure still writes JSON and exits 1; an invalid config exits 2 before any request.
maxResponseBytes, maxTotalBytes and maxDurationMs are application-side stop thresholds, not network limits or a hard cap on CU or provider billing. A small sample is not an SLA, not evidence of complete or canonical results, and not customer traffic. Verify the fixed block hash independently before comparing results. The User-Agent ends with BlockVectraQA/1.
Chain, method and protocol coverage
Use the chain catalog to check network identity, jsonrpc, methods.allow, methods.deny, public.methods, ws and subscriptions. A chain name does not establish that every method or protocol is available. Keyless methods and authenticated methods can have different limits.
Self-test: copy the chosen network's public.url and call a method in public.methods. For the Ethereum example below, inspect the network ID, then run the application’s required methods with an authenticated key and the same fixed blocks. Check deny rules as well as allow rules; compare block hashes when comparing results across endpoints.
curl --fail-with-body -sS --max-time 15 https://api.blockvectra.com/v1/eth_mainnet/public \
-H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'This checks a public method, not archive coverage or authenticated capacity. If your application needs sockets, test the required subscription, disconnect and resume path on a network that declares ws support. See WebSocket subscriptions.
Workflow check: list every method the whole flow calls, then check methods.allow, methods.deny and public.methods of the current catalog entry separately for the keyed and the keyless endpoint. A matching eth_chainId result shows the network only; confirm method support, the eth_getLogs block range and the history window one by one, and treat a missing method as a missing capability. A primary and a backup endpoint each need the full list. Return HTTP and JSON-RPC errors to the caller instead of turning them into an empty log or event list.
For example, a scanner that reads logs and waits for a transaction needs more than the first receipt call. With viem 2.47.10 (source), waitForTransactionReceipt defaults to checkReplacement: true. If the first receipt is already available it can return right away. While the transaction is pending, or when a same-sender, same-nonce replacement is detected, it can additionally call eth_getTransactionByHash and read blocks. The exact calls depend on the viem version and configuration. A catalog check does not prove that the data is complete or that history is available.
import type { Client } from "viem";
import { waitForTransactionReceipt } from "viem/actions";
// Methods this workflow needs, checked against the catalog entry.
export const required = [
"eth_chainId",
"eth_getLogs",
"eth_getTransactionReceipt",
"eth_getTransactionByHash",
"eth_blockNumber",
"eth_getBlockByNumber",
];
type Scope = { allow?: string[]; deny?: string[] };
// A rule is an exact name or a trailing "*" prefix; "*" matches every method.
const matches = (rule: string, method: string) =>
rule.endsWith("*") ? method.startsWith(rule.slice(0, -1)) : rule === method;
// Deny wins; a missing allow list means nothing is allowed.
export function missingMethods(required: string[], scope: Scope) {
return required.filter(
(m) =>
(scope.deny ?? []).some((r) => matches(r, m)) ||
!(scope.allow ?? []).some((r) => matches(r, m)),
);
}
type Entry = { methods?: Scope; public?: { methods?: string[] } };
// Keyed uses methods.allow/deny; keyless uses only public.methods.
export function checkEntry(required: string[], entry: Entry) {
return {
keyed: missingMethods(required, entry.methods ?? {}),
public: missingMethods(required, { allow: entry.public?.methods }),
};
}
// Synthetic entry for illustration, not a copy of the live catalog.
export const syntheticEntry: Entry = {
methods: { allow: ["eth_*"] },
public: { methods: ["eth_chainId", "eth_blockNumber"] },
};
export const missing = checkEntry(required, syntheticEntry);
// Missing methods per scope:
// keyed: []
// public: eth_getLogs, eth_getTransactionReceipt, eth_getTransactionByHash, eth_getBlockByNumber
export async function confirmTransaction(
client: Client,
hash: `0x${string}`,
timeout = 60_000,
) {
const receipt = await waitForTransactionReceipt(client, {
hash,
timeout,
});
return { hash: receipt.transactionHash, status: receipt.status };
}In a checkout of the docs source, apps/docs/tests/rpc-workflow-coverage-guide.test.ts runs this snippet against a mock transport for the pending-then-included and pending-then-replaced cases, using the installed viem version rather than 2.47.10. Run it with pnpm exec vitest run apps/docs/tests/rpc-workflow-coverage-guide.test.ts.
Push delivery and indexed data
For address notifications, inspect the chain's push declaration and its confirmation settings. BlockVectra can watch the same address set across supported chains in one subscription with one HTTPS receiver; check self-service and enterprise capacity against your address count. For Data API queries, inspect the datasets and indexed range in GET /v1/status. Indexed records do not imply arbitrary historical contract execution. RPC polling, WebSocket messages, delivered Push events and watched address-days use different billing meters; calculate each needed workflow from the applicable weights in plans.
Self-test: for Push, use an HTTPS receiver you control, verify signatures and test duplicate handling, retries and replay using an event from an address you control. For Data API, query a known indexed transaction or transfer, compare its block hash with RPC, exhaust pagination, and save the cursor before resuming. Record coverage gaps and the number of billed events or calls. Use Webhook Push, Webhook versus WebSocket and the Data API reference for the appropriate recovery path.
Authentication and Agent access
Check whether your client can securely supply a key, discover machine-readable documentation, create an account and recover from errors. BlockVectra RPC accepts a path key at POST /v1/{chain}/{api_key} or an x-api-key header at POST /v1/{chain}. Data API uses x-api-key. Keep keys in server environments and out of browser bundles, logs and chat messages.
Developers and AI Agents use the same pricing and limits. Programmatic sign-up documents wallet-based account creation, and the Agent guide provides documentation and MCP entry points. Agents can fund the account usage balance with stablecoins through the documented top-up flow, without a monthly RPC subscription. Top-up networks, tokens and minimums come from GET /v1/topup/status.
Self-test: have the intended client discover the chain and method, read the documentation, load a key from its environment and execute one bounded authenticated request. Inspect both HTTP status and JSON-RPC error. Check a missing-key response without logging credentials. Verify that the client saves progress on insufficient balance, reads the enabled top-up network and token, and follows the documented top-up flow; account creation and payment steps should use accounts you control. Do not treat a documentation MCP connection as proof that the Agent can execute an authenticated RPC call.
Record the decision
Keep a short result sheet: source and sampling date; chain and method; fixed block hash; result completeness; total calls and retries; available quota; paid task cost; latency and throttling; history and protocol gaps; recovery steps; migration effort. If the workload requires contractual support or an SLA, obtain the applicable terms separately from these API tests.
Once your workload is defined, compare with specific providers:
- Compare with specific providers: compute pricing and log ranges.
- Compare with specific providers: trial and subscription billing.
- Compare with specific providers: HTTPS request costs.
- Compare with specific providers: daily and cycle budgets.
- Compare with specific providers: included requests and overage.
Last updated:
Reading CU pricing
At current published rates, eth_call costs 15 CU per call, or $1.50 per million calls before available free credits; fetch the current plans API for your workload estimate.
Wallet assets page
List a wallet's non-zero ERC-20 token balances with one GET /addresses/{address}/balances request, then add transfer history and token metadata.