HostNexFlow › Library › Solana RPC endpoints, explained
Solana RPC endpoints — free vs paid, explained
On Solana the RPC endpoint is not plumbing — it is the surface every wallet, bot and trading app stands on. Here is what the public endpoint really gives you, which calls a serious read lane answers, and the honest line where free stops being enough.
Every Solana RPC endpoint is the same shape: an HTTPS URL that accepts JSON-RPC POSTs — getBalance, getAccountInfo, getLatestBlockhash, sendTransaction — answered by a node holding a synced copy of the ledger. Solana's validator clients expose this surface directly, so "an RPC endpoint" is literally a validator (or a full node) with its HTTP port open. That is why endpoint choice matters more on Solana than on slower chains: the network produces a block roughly every 400 ms, and whatever you are shown — balances, quotes, the blockhash your transaction is built on — is only as fresh as the node answering you.
The public endpoint, honestly
There is a canonical free endpoint: api.mainnet-beta.solana.com, the keyless public lane listed in Solana's cluster documentation beside api.devnet.solana.com and api.testnet.solana.com. It is real infrastructure run for the community, and it comes with real, published rate limits — the docs list per-IP caps on calls per 10 seconds, with a lower ceiling on expensive methods. The deal is simple: it exists so wallets and first deploys work out of the box, and it makes zero promises about throughput, freshness, or archive depth.
What that means in practice: the public endpoint is correct for a person in a wallet, and wrong for almost anything automated. Under load it sheds you — HTTP 429s, dropped websocket subscriptions, reads answered seconds late. Nobody is misbehaving; "free and unlimited" was never the offer. The same docs that hand you the URL tell you it is rate-limited.
The three clusters are separate ledgers, not modes: mainnet-beta is the real chain, devnet is the development sandbox where faucet SOL costs nothing, and testnet is where validator operators rehearse — our own SFDP-registered validator lives on testnet, which you can see on our Solana network page. An endpoint URL alone does not tell you which cluster you are on; getGenesisHash does.
Free vs keyed vs relayed
| Public keyless | Keyed provider tier | Relayed read lane | |
|---|---|---|---|
| Price | $0 | Monthly plan, billed by request volume | Free for reads; metered per call on paid lanes |
| Throughput | Published per-IP caps, shed under load | Allocated quota you paid for | Rotation across many upstreams — one lane's limit isn't yours |
| Freshness | Whatever the crowd leaves | Consistent — that's the product | Health-aware: a slow upstream cools out of rotation |
| Heavy calls | Truncated or refused | Archive + scan methods on upper tiers | Reads by allowlist; world-scans denied on principle |
| Sends | Best-effort broadcast | Depends on provider | Protected path first — Jito block engine on Solana |
| Suits | Wallet clicks, first deploys | Backends, dashboards | Bots, agents, anything that can't stall silently |
The middle column is the traditional answer — Helius, Triton, QuickNode, Alchemy and others sell keyed Solana lanes with per-tier quotas. The third column is what we run: /rpc/solana/ is a public read relay — one URL, no key for reads, fanned out over a ladder of keyless upstreams plus any keyed nodes configured ahead of them. It exists because most Solana traffic is reads, and reads should not require an account.
What a serious read lane answers — and refuses
Solana's RPC surface has a clean split between cheap reads and calls that are secretly whole-chain scans. A sane lane serves the first kind fast and refuses the second kind always. Ours publishes the distinction as an explicit allowlist — this is the actual shape of the relay's method table, not a marketing description of it:
Answered: the read set every wallet and bot actually needs — getBalance, getAccountInfo, getMultipleAccounts, getTokenAccountsByOwner, getTokenAccountBalance, getTokenSupply, getSignaturesForAddress, getTransaction, getLatestBlockhash, isBlockhashValid, getSignatureStatuses, getEpochInfo, getSlot, getHealth, getRecentPrioritizationFees, simulateTransaction, and friends. Identical requests inside short method-scoped windows share one upstream call — a micro-cache plus in-flight dedupe, with each caller's JSON-RPC id re-stamped so client-side correlation never sees a sibling's id.
Refused: the enumeration class — getProgramAccounts (walk every account a program owns), getLargestAccounts, getSupply, getVoteAccounts, getClusterNodes, getBlock/getBlocks (full block bodies), getBlockProduction, requestAirdrop on mainnet lanes. These are the calls that turn a public endpoint into an abuse report; every operator who has run one learns the list the same week.
Sends are a different lane entirely. sendTransaction doesn't go to the read pool — a signed transaction races a protected path first (the Jito block engine on Solana: bundle-grade, no public-mempool exposure, no sandwich surface) with the read pool as fanout backup so a hiccup on the protected path can't lose your transaction. Signing methods like signTransaction are refused outright: no endpoint should ever touch an unsigned payload, and a relay that asks for one is telling you something about itself.
Where Solana endpoints actually fail
Rate limits are the visible failure. 429 responses, websocket subscriptions that stop delivering, and timeouts at the top of the hour when every bot wakes up at once. Boring, survivable, and the reason retries exist.
Staleness is the quiet failure. Solana exposes commitment levels — processed, confirmed, finalized — and a lagging node answers processed reads against an old slot. A trading bot reading a price off a node 30 slots back is reading last minute's market. The check is cheap: getSlot on two independent endpoints must agree within a small window, and getHealth should return ok rather than a behind-by-N-slots error.
Blockhash expiry is the failure that looks like a bug. A recent blockhash is valid for about 150 slots — roughly a minute at Solana's cadence. A transaction built on a stale hash fails with BlockhashNotFound no matter how good the endpoint is. Slow reads push you closer to the window's edge; this is also why isBlockhashValid exists on the allowlist. Durable nonces are the designed escape for anything that must sit in a queue.
Archive depth is the failure nobody warns about. Standard nodes serve recent history; a getTransaction on an old signature can return null on one endpoint and the full transaction on an archival node. Public free tiers typically don't carry deep history — when a read returns "not found" for data that exists, the endpoint's depth is the first thing to suspect, not the chain.
The trust model in one line: on Solana the endpoint sees every account you query and decides what the chain looks like to you. Signing is safe — your key never crosses the wire — but every decision you make rides on answers you didn't verify. Cross-check anything that decides a trade: same call, second endpoint, same answer or don't act on it.
Picking a lane for real work
The decision rule hasn't changed since the first public endpoint existed: if a silent stall or a 429 costs you money, the endpoint is infrastructure and you should treat it that way — a keyed tier, your own node (docs.anza.xyz's RPC-node setup guide is the real checklist — plan on real CPU, RAM and NVMe, not a VPS coupon), or a relay where the contract is a request and a price rather than a signup.
For Solana specifically, test the lane you pick against the three things that actually bite: freshness (getSlot parity), the methods you need (simulateTransaction and getTransaction for trade-path verification), and send path (does your signed transaction take a protected route, or is it broadcast into the open where ordering games live?). Our /rpc/solana/ page shows the live upstream ladder the lane falls back across, and /validators/ shows the on-chain infra we run — an operator that runs validators is holding itself to a standard you can check on-chain.
Ask the lane yourself
One POST, no key — the same getSlot every wallet polls:
curl -X POST https://nexflowscan.com/api/rpc/solana \
-H 'content-type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"getSlot"}'
Frequently asked
What is the official Solana RPC endpoint?
There is no single official endpoint, but there is a canonical public one: https://api.mainnet-beta.solana.com, the keyless JSON-RPC surface listed in Solana's own cluster documentation alongside api.devnet.solana.com and api.testnet.solana.com. It is real Solana infrastructure and it is deliberately rate-limited — it exists for onboarding and light wallet traffic, not for production load. Anything that needs guaranteed throughput uses a keyed provider tier or a relay.
Is the free Solana RPC endpoint rate-limited?
Yes — the public endpoints publish rate limits in Solana's cluster documentation, and in practice they shed load aggressively: HTTP 429s, dropped websocket subscriptions, and slow answers at busy times. For a person checking a balance that is fine. For a bot, a backend, or anything watching the chain continuously, a free public endpoint is the first thing that fails.
Can a Solana RPC endpoint see or steal my private key?
No — signing happens in your wallet and the endpoint only ever sees a signed transaction or a read request. What it can do is lie about chain state, censor or delay your transaction, and log every address you query. Our own relay refuses signing-shaped methods outright for this reason: an endpoint that asks for more than a signed payload is not an endpoint you want.
Why does getProgramAccounts fail on public Solana endpoints?
Because it is a whole-chain scan — it asks the node to walk every account a program owns, which can be millions of entries. It is the single most expensive call in the Solana RPC surface, so publics refuse it, truncate it, or rate-limit you into the ground. The workable alternatives are targeted calls like getTokenAccountsByOwner for a known wallet, or an indexer when you genuinely need program-wide state. Our relay denies it on every lane, keyed or not — a free upstream should never be asked to enumerate the world.
What is the difference between Solana mainnet, devnet, and testnet RPC endpoints?
Three separate clusters with separate ledgers. Mainnet-beta is the real-money chain. Devnet is the development sandbox where faucet airdrops make SOL free. Testnet is the validator rehearsal network — our own SFDP validator runs there. Each cluster has a different genesis hash, so getGenesisHash is the cheap way to prove which network an endpoint actually answers before you send anything.