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.

MethodCU per callPrice per 1M calls (USD)
eth_blockNumber1$0.10
eth_call15$1.50
eth_getLogs30$3.00
debug_traceTransaction100$10.00
data.block5$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.

MethodExample callsCU per callTask cost (USD)Requests/s from key CU budget
eth_call1,000,00015$1.506
eth_getLogs100,00030$0.303

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.

Current weights, prices and key limits: GET /v1/plans.

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_usd

List 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:

ChainChain slugmax_logs_block_range (blocks)
Arbitrum Onearb_mainnet1,000
Arcarc_mainnet1,000
Avalanche C-Chainavax_mainnet1,000
Basebase_mainnet1,000
Berachainberachain_mainnet1,000
Bobaboba_mainnet1,000
BNB Smart Chainbsc_mainnet1,000
Celocelo_mainnet1,000
Ethereumeth_mainnet1,000
Ethereum Sepoliaeth_sepolia1,000
Fraxtalfraxtal_mainnet1,000
Gnosisgnosis_mainnet1,000
HyperEVMhyperevm_mainnet1,000
Inkink_mainnet1,000
Katanakatana_mainnet1,000
Linealinea_mainnet1,000
Metal L2metall2_mainnet1,000
Modemode_mainnet1,000
OP Mainnetop_mainnet1,000
Polygonpolygon_mainnet1,000
Robinhood Chainrobinhood_mainnet1,000
Robinhood Chain Testnetrobinhood_testnet1,000
Rootstockrootstock_mainnet1,000
Soneiumsoneium_mainnet1,000
Sonicsonic_mainnet1,000
Unichainunichain_mainnet1,000
World Chainworld_mainnet1,000
X Layerxlayer_mainnet1,000
Zorazora_mainnet1,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.

MethodCU WeightApprox Calls / CycleApprox / DayList Price / 1M Calls
eth_blockNumber130,000,0001,000,000$0.10
eth_getBlockByNumber56,000,000200,000$0.50
eth_getBalance103,000,000100,000$1.00
eth_call152,000,00066,666$1.50
eth_getLogs301,000,00033,333$3.00
debug_traceTransaction100300,00010,000$10.00
data.block56,000,000200,000$0.50
data.address_balances251,200,00040,000$2.50
data.dex_prices152,000,00066,666$1.50
data.transaction_trace200150,0005,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.json

Use 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:

Last updated:

On this page