Free Solana RPC endpoints in 2026: What you actually get

Every Solana developer starts the same way. You need an endpoint, you do not want to pay yet, and you type "free Solana RPC" into a search bar. What comes back is a wall of numbers: 210 million compute units here, 100 requests per second there, unlimited-this and generous-that. Almost none of it tells you the thing you actually need to know.

Which is this: a free tier is not a product. It is a preview of the product you will run in production. The question is not who gives you the most requests for nothing. The question is whether the thing you build against the free endpoint will still work when it matters — during a launch, during congestion, at the moment your transaction has to land.

This guide compares what free Solana RPC actually gets you in 2026, using live pricing scanned, and it is specific about where each option breaks.

TL;DR

Key takeaways

• The public endpoint is not a free tier. api.mainnet-beta.solana.com is capped at 100 requests per 10 seconds per IP and Solana's own docs say it is not for production.
• Compute-unit volume is a vanity metric. The most generous free tiers on the market — dRPC at 210M and Ankr at 200M — have no Yellowstone gRPC at any price. Volume you cannot use is not volume.
• Free tiers hide their blocks. getProgramAccounts and the token-account methods are the first things throttled or disabled, and they are exactly what indexers and bots call.
• Mainnet gRPC is the real paywall. Helius gives gRPC on devnet only below the $499 Business tier. QuickNode wants $748 for it at the $249 price point. It is bundled into RPC Fast from $249.
• Pick by upgrade path, not by headline. Whatever you prototype against, you will rebuild against something else if the free tier cannot stream.

‍

Two very different things called "Free"

The phrase "free Solana RPC" covers two completely unrelated products, and conflating them is the single most common mistake in this space.

The first is the public cluster endpoint operated by the Solana Foundation. It is genuinely free, requires no account, and is deliberately crippled. The second is a free tier on a commercial RPC provider: you sign up, get an API key, and receive a metered slice of real infrastructure. These fail in different ways, at different times, for different reasons.

The public endpoint: Exact numbers

Solana's official cluster documentation publishes the limits, and they are stricter than most developers realise. All limits are measured over a 10-second window, not per second:

The Solana Foundation is unusually blunt about this. Its RPC infrastructure page states that free services typically do not autoscale, are rate-limited, offer no SLA, and are "not afraid to ban abusers," and that when an application is ready to open to the public, it is time to invest in private RPC access. The cluster reference adds that public endpoints are not intended for production applications. You can read both directly: Solana RPC infrastructure guidance and the clusters and public endpoints reference.

What failure looks like

You will not get a clean error telling you that you have outgrown the public endpoint. You get HTTP 429 under load, HTTP 403 once you are flagged, and — worst of all — intermittent success that makes the problem look like a bug in your code. Teams routinely spend days debugging a "race condition" that is a rate limiter.

// The failure mode that wastes the most time:
// this works fine in dev and silently degrades under load.
const conn = new Connection("https://api.mainnet-beta.solana.com");
 
// 40 requests / 10s on a single method means this loop
// starts returning 429 at roughly the 4th iteration per second.
for (const addr of watchlist) {
  const info = await conn.getAccountInfo(addr);   // <-- throttled
  process(info);
}

If you are reading a tutorial or poking at devnet, none of this matters. If you are building anything that will face users, the public endpoint is a development convenience and nothing more.

Free tiers compared, 2026

Here is what the major providers actually hand out on their free plans.

Read that chart carefully, because it is the whole argument of this article in one image. dRPC and Ankr give away 100x more free volume than anyone else — and neither offers Yellowstone gRPC on any plan, at any price. You can burn 210 million compute units learning an architecture you will have to throw away.

We will be equally direct about our own position on that chart: RPC Fast's free tier is 1.5M CU and 15 RPS, which is in the bottom third by raw volume, and four heavy methods are blocked on it. If your selection criterion is "most free requests," we are not your answer and this article will not pretend otherwise. Keep reading anyway, because that criterion is the trap.

The four things that actually break

Free tiers do not fail because you run out of compute units. They fail in four specific, predictable ways — and the CU headline tells you about none of them.

1. Heavy methods are blocked or throttled

Almost every free tier restricts the same handful of methods: getProgramAccounts, getTokenAccountsByOwner, getTokenAccountsByDelegate, and getTokenLargestAccounts. These scan large slices of account state and are brutally expensive to serve — which is precisely why they are the first to go.

They are also exactly what a real workload calls. Any indexer, any portfolio tracker, any bot that needs to enumerate pools or holders leans on these. A free tier that blocks them lets you build a demo, not a product. RPC Fast blocks all four on the free plan; we would rather say so here than have you discover it on a Friday night.

2. No mainnet streaming means no realistic testing

Yellowstone gRPC — built by Triton One and known upstream as Dragon's Mouth — is the standard way to get data off Solana in real time. It is a Geyser plugin that loads into the validator's own memory space and pushes typed Protobuf messages the instant the node touches an account, bypassing the JSON-RPC layer entirely. Polling and WebSocket are not close substitutes.

Here is the part the pricing pages bury: on most providers, the free and entry tiers give you gRPC on devnet only. Helius documents this plainly — LaserStream mainnet requires a Business or Professional plan, with devnet available from Developer and above (Helius gRPC docs). OrbitFlare is the same shape. So you can build and test a streaming client for free, and discover the economics of running it on mainnet only after the architecture is set.

3. No stake-weighted QoS means transactions do not land

Sending a transaction is not the same as landing one. Solana's stake-weighted quality of service gives a validator the right to transmit packets to the leader in proportion to its stake — a validator with 1% of stake can push up to 1% of packets. RPC nodes that peer with staked validators inherit that lane. Nodes that do not, queue with everyone else.

During calm periods you will never notice. During a launch, when it counts, the difference between a staked path and an unstaked one is the difference between a filled order and a timeout. Most free tiers put you on the unstaked path by default, and the pricing page will not mention it.

4. Rate limits are windows, not rates

"15 RPS" and "150 requests per 10 seconds" are not the same product. A per-second limit smooths your traffic; a windowed limit lets you burst and then locks you out for the remainder of the window. Providers publish whichever framing looks better. Read the docs, not the pricing table — and test your actual burst pattern, not a steady loop.

The upgrade cliff

Every free tier is a funnel. The honest question is what waits at the bottom of it. Since mainnet streaming is the capability that separates a toy from a system, the meaningful comparison is: what does it cost to get roughly ten mainnet Yellowstone gRPC streams?

The sharpest single comparison on that table is QuickNode. At the $249 price point, QuickNode's Accelerate plan does not include gRPC — you add it for $499, so the real cost of that configuration is $748. RPC Fast Stream includes ten mainnet streams at $249. That is the same capability for a third of the money, and it is checkable against both public pricing pages in about ninety seconds.

We will not overclaim the rest of the field. Shyft bundles gRPC honestly and cheaply and is a legitimate alternative — its gap against us is Shredstream, which it does not put in a tier. Chainstack can beat us on narrow gRPC configurations ($198 for seven streams) and includes Shredstream by default; where we answer them is measured latency, not price. If someone tells you one provider wins every row, they are selling.

Where RPC Fast sits

Our tiers, scanned the same day as everyone else's:

The design idea is one line: gRPC and Shredstream are wired into the tier, not sold as add-ons. Most of the market prices streaming separately — QuickNode at $499–699, OrbitFlare at $500, eRPC as a €198 module, Alchemy by the terabyte. That is why our $249 buys what costs $748 elsewhere, and why Aperture at $499 carries 25 gRPC streams plus 10 Shredstream streams where the same money buys ten streams and a $1000/IP Shreds bill at Helius.

Focus at $45 also drops the bandwidth cap entirely, which matters more than it sounds if you have ever been metered by the gigabyte on a streaming workload.

The honest counterweight, stated once more: our free tier is small, four heavy methods are blocked on it, we have no annual discount, and overage runs $5 per million CU with no hard cap. If you want the most generous free tier in Solana, that is dRPC, and you should go use it. If you want the cheapest honest route from prototype to a bot that streams and lands, that is the argument we are making.

How to choose

If you are learning

Use the public endpoint or a local validator. Do not sign up for anything. solana-test-validator and Surfpool give you a full node on localhost with no limits at all, and you will iterate faster than against any remote endpoint.

If you are building an app you intend to ship

Take a free tier on infrastructure you would actually pay for, and check three things before you write a line: which methods are blocked, whether the rate limit is a rate or a window, and what the next tier costs. The free tier's job is to de-risk the paid tier.

If you are building a bot, or anything timed to the slot

Use a free tier to wire up the client and read the docs, then move. Free tiers cannot teach you anything about latency, because latency is the product you are not paying for. If your strategy depends on seeing state inside the slot, the free tier is a login screen, not a test environment.

A checklist worth running before you commit

• Are getProgramAccounts and the token-account methods available, or blocked?
• Is mainnet gRPC available on any plan — or is it devnet-only until $499?
• Is the rate limit per second, or per 10-second window?
• Are staked connections included, and on which tier?
• Is there an overage cap, or can a bad loop invoice you unbounded?
• What does the first tier with streaming cost — and is streaming bundled or an add-on?

The short version

Free Solana RPC is real and useful, and it is measured wrong by nearly everyone. The public endpoint is a development convenience with published, strict caps and an explicit warning from the Foundation not to ship on it. Provider free tiers range from 1M to 210M compute units, and that range tells you almost nothing, because the largest numbers on the board belong to providers that cannot stream at all.

The line that matters is mainnet Yellowstone gRPC. It is where the free tier ends on every provider in this comparison, and the cost of crossing it varies by 3.6x for the same capability. Choose the free tier whose paid tier you would actually want.

Start on the infrastructure you will ship on

• RPC Fast Start is free, no card, and runs on the same bare-metal Solana nodes as every paid tier — co-located with validators, Yellowstone gRPC and Jito Shredstream available the moment you need them, with no re-architecture in between.
• 1.5M CU/month, 15 RPS, mainnet and devnet, live in under a minute.
• When you outgrow it, Stream at $249 gives you ten mainnet gRPC streams — the configuration that costs $748 at QuickNode and $499 at Helius.

Create a free account and get your endpoint: rpcfast.com