Skip to content

Helius

Helius is a Solana-native RPC provider billed in credits. There is a free tier — 1M credits a month at 10 requests/second — and paid plans from $49/month. Most RPC calls cost 1 credit; getProgramAccounts and archival calls cost 10.

What is the Helius RPC URL?

https://mainnet.helius-rpc.com/?api-key=<YOUR_API_KEY>

Devnet uses the same shape with a different host:

https://devnet.helius-rpc.com/?api-key=<YOUR_API_KEY>

The key is a query parameter, not a path segment or a header.

How do I get a Helius API key?

  1. Sign up at helius.dev — the free tier needs no card.
  2. Open the dashboard — a key is created for you on signup.
  3. Copy the key, or the full endpoint URL shown alongside it.

The key goes in the URL, so treat the whole endpoint URL as a secret — put it in an environment variable rather than committing it.

Is there a free Helius tier, and what are its limits?

Yes. The Free plan is $0/month and includes:

Limit Free plan
Monthly credits 1,000,000
RPC requests 10/sec
sendTransaction 1/sec
DAS requests 2/sec
getProgramAccounts 5/sec

These are separate buckets, not a shared 10/s — see the general limit is not the one you will hit.

1M credits is roughly 1M standard calls, or 100k archival calls, since archival is 10 credits each. The 1/sec sendTransaction limit is the binding constraint for anything that writes — it is a development tier, not a production one.

Plans and rate limits

Plan Price Credits/mo RPC req/s sendTransaction/s
Free $0 1M 10 1
Developer $49/mo 10M 50 5
Business $499/mo 100M 200 50
Professional $999/mo 200M 500 100
Enterprise Custom 1B+ Custom Custom

Verified 2026-09-05 against helius.dev/pricing. Check the source before budgeting — provider pricing moves.

What each method costs

Helius charges 1 credit per call with two exceptions: getProgramAccounts and archival reads (getBlock, getTransaction, getSignaturesForAddress) cost 10 credits each. DAS methods are also 10.

sendTransaction costs 1 credit — it is a standard call, not free. If you sized a write-heavy budget on the assumption that writes were free, re-check it.

The provider pricing reference has the full per-method table and the effective dollar rates.

Configure Helius in RPC Plane

[[providers]]
name = "helius"
url  = "https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}"

export HELIUS_API_KEY=your_api_key_here
rpc-plane run

Staying inside your plan's rate limit

Set max_rps to your plan's documented per-second limit. RPC Plane then sheds load to providers with headroom instead of letting Helius return 429s:

[[providers]]
name    = "helius"
url     = "https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}"
max_rps = 10   # Free plan; 50 on Developer, 200 on Business

This is a load-shedding hint, not a hard throttle — if every provider is at its cap the request is still forwarded. It only helps when there is a peer to shed to, so pair a free Helius key with at least one other provider.

The general limit is not the one you will hit

Helius publishes a separate, much tighter limit per method category. On the free plan the headline is 10 RPC req/s, but sendTransaction is 1/s, DAS is 2/s and getProgramAccounts is 5/s. A single max_rps = 10 does nothing to stop you spending the whole budget on writes and collecting 429s at one tenth of the cap.

Because max_rps is per provider entry and only name has to be unique, register the key twice and give the tight method its own bucket:

# Writes: 1 rps, matching the plan's sendTransaction limit.
[[providers]]
name    = "helius-writes"
url     = "https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}"
methods = ["sendTransaction"]
max_rps = 1

# Everything else: the general limit.
[[providers]]
name    = "helius-reads"
url     = "https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}"
max_rps = 10

The two entries hold independent buckets, so writes cannot eat the read budget. rpc_plane_rate_limited_total{provider="helius-writes"} then tells you specifically that the write limit is binding. See working around a per-method limit.

When to use Helius

  • Standard reads. At 1 credit a call it is among the cheaper options for account and state reads.
  • Watch archival. getBlock and getTransaction at 10× are the usual reason a Helius bill is larger than expected. If your workload is history-heavy, put a provider that charges no history premium in front of Helius for those calls — QuickNode does not charge one.
  • Free tier as a backup, not a primary. 10 req/s and 1 write/s is enough for a failover leg or a CI environment. Give it a max_rps so it never becomes the hot path.