Best Solana RPC Providers: How to Evaluate and Choose

The right way to compare Solana RPC providers is to test them against your own workload: latency from your region, the rate limit and credit model, method support (archival history and custom indexed methods), streaming options, shared versus dedicated capacity, uptime terms and price. A provider that is fastest on getSlot can still fail you on getProgramAccounts, on 429s at peak, or on a method it does not implement.

This guide gives you a checklist, a script that probes which methods an endpoint supports, and the facts about Solana Tracker's shared plans and dedicated nodes so you can score them the same way as any other option.

A shortlist of Solana RPC providers

We sell Solana Tracker RPC services. This shortlist is based on documented product scope, not a benchmark claiming our service is universally faster. It isn't an exhaustive market survey: add another provider when it meets a concrete requirement such as an existing enterprise contract, a needed region or a particular historical method.

How to evaluate Solana RPC providers

Write down your requirements before you test anything: the methods on your hot path, your peak requests per second, the history depth you need, the commitment level you read at, and whether you need streams. Then score each provider on the criteria below.

Latency from your region

Network distance usually dominates RPC latency. Measure from the region your bot or backend runs in, at the commitment level you use, and record slot lag alongside response time: a fast endpoint that is two slots behind gives you old state quickly. The Solana RPC latency guide explains how to measure this properly, and its companion benchmark tool compares several endpoints side by side: 06-reduce-solana-rpc-latency.

Rate limits and the credit model

Two limits matter, and they are independent. Credits (or request quotas) measure consumption over a billing cycle. Rate limits cap how fast you can send. A plan with plenty of credits can still return HTTP 429 during a burst.

Check three things:

• Per-method weights. Many providers charge heavy methods more. On Solana Tracker's shared RPC, archival calls (getTransaction, getBlock, getSignaturesForAddress and others), getProgramAccounts, getTokenAccountsByOwner and DAS calls cost 10 credits, while standard calls cost 1.
• Per-method rate limits. Sends and program-account scans often have their own, lower ceilings than general reads.
• What happens at the limit. Find out whether you get 429s, overage charges or a forced upgrade, and whether unused allowance rolls over.

Method support: archival and custom indexed methods

Standard JSON-RPC is the floor. The differences between Solana RPC providers show up in what sits on top of it:

• Archival history. getTransaction, getBlock and getSignaturesForAddress for old slots need a ledger archive. getFirstAvailableBlock tells you the earliest block a node can serve.
• Indexed account queries. Stock getProgramAccounts walks validator account state. An indexed alternative such as getProgramAccountsV2 pages through results (up to 10,000 per page) with a cursor and can return only accounts changed after a given slot via changedSince.
• Batch reads. getTokenAccountsByOwners returns one mint's balances across up to 250 wallets in a single call.
• Lookup tables and names. getLookupTablesByAccounts finds address lookup tables that cover a transaction's accounts, and getPrimaryDomain resolves a wallet's .sol name. See the lookup table guide and SNS guide.
• Fee estimation. getPriorityFeeEstimate returns priority-fee levels for a transaction or a set of accounts.

Custom methods are provider-specific. If you build on one, your fallback provider must support it too, or your code needs a path that works without it.

Streaming: WebSocket, Shredstream and gRPC

Check WebSocket connection limits per plan, then what is available beyond standard subscriptions. Shredstream (shredSubscribe on Solana Tracker) delivers transactions reconstructed from shreds before execution metadata exists; events are provisional and must be confirmed through RPC. Yellowstone gRPC streams filtered accounts, transactions, slots and blocks with full metadata and server-side filters. For anything long-running, test reconnect behavior: subscriptions do not replay what you missed while disconnected.

Shared versus dedicated

Shared endpoints are multi-tenant and credit-metered: cheap to start, but your tail latency depends partly on other customers. Dedicated nodes are your hardware with no rate limits and a fixed monthly price. Move to dedicated when your benchmark shows tail latency or 429s that track your own load, or when you need IP allowlisting, a specific region or heavy getProgramAccounts throughput.

Uptime and SLA terms

An uptime percentage on a landing page is a statement, not a contract. If downtime costs you money, ask whether there is a written SLA, what it measures, how incidents are reported, and what remedy applies. Keep a second endpoint warm either way and test the failover path, not just the backup URL.

Pricing model

Normalize every quote to your traffic. Suppose a month has 30 million standard reads and 1 million program-account scans. With stock getProgramAccounts at 10 credits each, that is 30M + 10M = 40M credits. With getProgramAccountsV2 at 1 credit, it is 31M. Either way it exceeds a 15M-credit plan and fits a 100M-credit plan, so check peak RPS against that plan's limits as well.

Probe which methods a provider supports

This script sends one cheap request per capability and reports ok, not supported (JSON-RPC error -32601), rate limiting or other errors, with response time. Run it against each candidate. It needs no dependencies beyond Node 20+ and tsx.

npm init -y && npm pkg set type=module
npm install --save-dev tsx typescript @types/node
node --env-file=.env --import tsx index.ts

# .env: full URL including ?api_key= (https://www.solanatracker.io/account/shared-rpc)
SOLANA_RPC_URL=
TIMEOUT_MS=10000

// index.ts: check which methods a Solana RPC endpoint supports, and how fast it answers them
export {}; // ES module, so top-level await type-checks

const RPC_URL = process.env.SOLANA_RPC_URL?.trim() ?? "";
if (!RPC_URL) {
  console.error("Missing SOLANA_RPC_URL. Copy the full URL from https://www.solanatracker.io/account/shared-rpc");
  process.exit(1);
}
if (!URL.canParse(RPC_URL)) {
  console.error("SOLANA_RPC_URL is not a valid URL"); // never print it: it contains the key
  process.exit(1);
}
const TIMEOUT_MS = Number(process.env.TIMEOUT_MS ?? 10_000);
if (!Number.isInteger(TIMEOUT_MS) || TIMEOUT_MS < 100) {
  console.error("TIMEOUT_MS must be an integer of at least 100");
  process.exit(1);
}

const USDC = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
const WALLET = "9aoUCn5J4sxhvYERCVwVnakPQxyXTHQVXe86CUJYxY8p";
const TOKEN_PROGRAM = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";

// One cheap request per capability. Custom methods return JSON-RPC -32601 where unsupported.
const probes: { label: string; method: string; params: unknown[] }[] = [
  { label: "baseline", method: "getSlot", params: [{ commitment: "processed" }] },
  { label: "ledger depth", method: "getFirstAvailableBlock", params: [] },
  {
    label: "indexed GPA",
    method: "getProgramAccountsV2",
    params: [TOKEN_PROGRAM, { encoding: "base64", limit: 1, filters: [{ dataSize: 165 }, { memcmp: { offset: 0, bytes: USDC } }] }],
  },
  { label: "multi-owner balances", method: "getTokenAccountsByOwners", params: [[WALLET], USDC] },
  { label: "lookup tables", method: "getLookupTablesByMint", params: [{ mint: USDC, limit: 1 }] },
  { label: "SNS", method: "getPrimaryDomain", params: [WALLET] },
  { label: "priority fees", method: "getPriorityFeeEstimate", params: [{ accountKeys: [USDC], options: { recommended: true } }] },
];

type RpcBody = { result?: unknown; error?: { code: number; message: string } };

async function probe(method: string, params: unknown[]): Promise<{ status: string; ms: number; detail: string }> {
  const started = performance.now();
  try {
    const res = await fetch(RPC_URL, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
      signal: AbortSignal.timeout(TIMEOUT_MS),
    });
    const ms = performance.now() - started;
    if (res.status === 429) return { status: "rate limited", ms, detail: "HTTP 429" };
    if (!res.ok) return { status: "http error", ms, detail: `HTTP ${res.status}` };
    const body = (await res.json()) as RpcBody;
    if (body.error?.code === -32601) return { status: "not supported", ms, detail: body.error.message };
    if (body.error) return { status: "error", ms, detail: `${body.error.code}: ${body.error.message}` };
    const preview = JSON.stringify(body.result) ?? "";
    return { status: "ok", ms, detail: preview.length > 60 ? `${preview.slice(0, 57)}...` : preview };
  } catch (error) {
    const timedOut = error instanceof Error && error.name === "TimeoutError";
    return { status: timedOut ? "timeout" : "network error", ms: performance.now() - started, detail: String(error) };
  }
}

const rows = [];
for (const p of probes) {
  const r = await probe(p.method, p.params);
  rows.push({ capability: p.label, method: p.method, status: r.status, ms: r.ms.toFixed(0), detail: r.detail });
  await new Promise((resolve) => setTimeout(resolve, 250)); // stay well under low rate limits
}
console.table(rows);

An unsupported method comes back as a standard JSON-RPC error, usually with HTTP 200:

{ "jsonrpc": "2.0", "id": 1, "error": { "code": -32601, "message": "Method not found" } }

A supported custom method returns its own shape. For example, getPrimaryDomain returns { "context": { "slot": 423867852, "apiVersion": "3.0.0" }, "value": { "wallet": "9aoU...", "domain": "solanatracker.sol" } }, with domain set to null when the wallet has no primary name. Treat a successful probe as "the method exists"; you still need a load test with your real parameters.

Solana Tracker shared RPC plans

Solana RPC is a shared, credit-based service. One credit is one standard call. The same endpoint serves standard JSON-RPC, WebSocket subscriptions, Shredstream and the custom methods above (getProgramAccountsV2, getTokenAccountsByOwnerV2, getTokenAccountsByOwners, lookup table and SNS methods).

Yearly billing takes 15% off paid plans. Credits reset each billing cycle and do not roll over; requests over a limit return HTTP 429. Archival and DAS calls cost 10 credits, V2 indexed methods cost 1. You can start from the Shared RPC dashboard. Yellowstone gRPC is also sold standalone at €200/mo with 25 concurrent connections across EU and US endpoints.

Solana Tracker dedicated nodes

Dedicated nodes are private bare-metal machines with unlimited requests and no rate limits, priced per month rather than per credit. The Ridge DB tier runs RidgeDB v2, our purpose-built Solana account store.

Nodes deploy in 11 regions (New York, Los Angeles, Utah, St. Louis, Chicago, Frankfurt, Strasbourg, Amsterdam, Šiauliai, Tokyo and Singapore), and most are live within 24 hours. Yearly billing takes 20% off. The load balancer supports round-robin, weighted and method-level routing with automatic failover. Fleets of 5+ nodes get volume pricing, SLAs and custom regions through Enterprise. Deploy from the dedicated nodes dashboard.

Shared or dedicated: which fits

RPC for low-latency trading bots

Start with what your bot actually waits on. Run the benchmark from the region the bot runs in, and treat reads, streams and sends as three separate tests:

• Reads. Record slot lag next to response time. A fast answer from a node two slots behind is still old state.
• Streams. Shredstream and Yellowstone gRPC replace polling, and they fail differently from HTTP. Force a disconnect and prove your state recovers.
• Sends. Measure acknowledgement separately from confirmation. Check the send RPS on your plan, because it is lower than the general limit.

Move to a dedicated node when your own measurements show shared capacity is the constraint. Dedicated hardware doesn't remove network distance, account contention or the need to confirm transactions.

Migrate with a rollback path

Inventory provider-specific methods, authentication, WebSocket formats and gRPC client versions. Shadow reads before switching production, compare values and slots, then move a small portion of traffic.

Keep send behavior separate from read failover. A slow confirmation is not permission to create a new business action: track the original signature and the transaction's validity before deciding how to retry.

Common mistakes when choosing an RPC provider

• Benchmarking only cheap methods. getSlot tells you about the network path, not about scans or archival reads.
• Ignoring per-method limits. A plan's headline RPS rarely applies to sendTransaction or getProgramAccounts.
• Building on a custom method without a fallback. Keep a code path for providers that return -32601.
• Testing once. Rerun after traffic, region or plan changes, and at busy times.
• Leaking keys. Provider URLs often carry the API key in the query string. Keep them server-side and out of logs.

FAQ

What makes one Solana RPC provider faster than another?

Mostly distance between your code and the node, then node load and how current the node's view of the chain is. Measure p99 and slot lag from your own region; headline numbers from someone else's location do not transfer.

Can I switch providers by changing one URL?

Often for standard JSON-RPC calls, but indexed methods, subscriptions, authentication and limits can require code changes.

Do I need archival access?

Only if you read old transactions or blocks. If you call getTransaction or getSignaturesForAddress for historical data, confirm archival depth and the credit cost of those calls before you commit.

Are custom methods like getProgramAccountsV2 standard?

No. They are provider extensions. Their request and response formats differ from the stock methods, so check the docs and keep a fallback if you may switch providers.

When is a dedicated node worth it?

When your benchmark shows 429s or tail latency that follow your own traffic, when you need IP allowlisting or a specific region, or when heavy getProgramAccounts workloads make credit pricing expensive.

Is Yellowstone gRPC included with RPC plans?

On Solana Tracker it is included with Business and Professional shared plans and with every dedicated node, and sold standalone at €200/mo.

References

• Solana RPC API reference
• Credits and rate limits
• Pricing and limits
• getProgramAccountsV2
• getTokenAccountsByOwners
• getPriorityFeeEstimate
• Shred subscribe
• Yellowstone gRPC
• Latency benchmark tool (example 06)