6 minIteradian Engineeringinfrastructuregetting-started
Public RPC endpoints are free. Here is what they cost you.
Every chain publishes a free public RPC endpoint, and they are genuinely useful for local development. In production they introduce aggressive shared rate limits, no archive depth, no analytics and no accountability when they go down. This post covers when the free endpoint is fine and when it stops being fine.
Almost every chain publishes a free public RPC URL, and for a local test script it is exactly the right tool. The mistake is carrying that URL into production because it worked in development. Public endpoints are a shared community resource with no capacity commitment to you specifically, and the failure mode is not a clean error — it is intermittent slowness that looks like a bug in your own code.
What you are actually giving up
| Concern | Public endpoint | Managed endpoint |
|---|---|---|
| Rate limit | Shared across every anonymous caller, usually undocumented | Per account or per key, documented, enforced predictably |
| Archive depth | Usually pruned — historical state calls fail | Archive access depends on plan, but stated up front |
| Analytics | None | Per-request logs, method breakdown, error rates |
| Failover | None — one host, one fate | Routed across a node pool with health checks |
| Accountability | None. Nobody owes you an explanation | A support channel and, on some plans, a contractual SLA |
| Access control | None — the URL is the credential and it is public | Hashed API keys, per-key IP allowlists enforced at the gateway, rotation and revocation |
The failure mode is silence, not errors
A well-behaved managed endpoint tells you it is throttling you: HTTP 429, a hint saying how long to wait, a number in a dashboard. Public endpoints frequently just get slow, drop connections, or return stale data from a lagging node. Your application does not see an error to handle — it sees a request that took eleven seconds, and your users see a spinner.
It is also worth noting that some paid providers route their free tiers to public nodes rather than their own infrastructure. dRPC, for instance, states plainly that its free plan uses public nodes. That is honest disclosure, and it means a free tier is not automatically the same product as the paid one.
A reasonable rule of thumb
- Local development, one-off scripts, throwaway prototypes: use the public endpoint. It is free and it is fine.
- CI pipelines: move off public endpoints early. Flaky tests caused by a throttled public node will waste more engineering time than the subscription costs.
- Anything with users: use a managed endpoint. The moment a person is waiting on a response, you need a rate limit you control.
- Indexers and backfills: definitely managed, and on a separate API key from your user traffic.
- Transaction broadcasting: always managed. A dropped broadcast on a public node is invisible until a user complains.
Do not hardcode the URL either way
Whatever you choose, put the endpoint in configuration, not in source. Providers change hostnames, you will want to move traffic during an incident, and a hardcoded URL turns a five-minute failover into a deploy. Read it from an environment variable from day one.
// Config, not a constant. Failover should be an env change, not a release.
const RPC_URL = process.env.RPC_URL ?? "https://api.iteradian.com/rpc/v1/eth-mainnet";
const RPC_KEY = process.env.RPC_API_KEY;
if (!RPC_KEY) throw new Error("RPC_API_KEY is not set");Iteradian puts every network it routes behind one endpoint pattern and one API key, with a 7-day trial if you want to measure the difference against your current setup before committing.
Frequently asked questions
01Are public RPC endpoints safe to use in production?
Generally no. Public endpoints have undocumented shared rate limits, are often pruned rather than archive, provide no analytics or failover, and offer no accountability when they degrade. They are well suited to local development and throwaway scripts.
02What is the difference between an archive node and a full node?
A full node keeps recent state and prunes older state. An archive node retains historical state for every block, which is required for queries such as a balance at a specific past block. Most public endpoints are pruned, so historical state calls fail against them.
03Do free tiers from paid RPC providers use dedicated infrastructure?
Not always. Some providers route free-tier traffic to public nodes rather than their own node pool. dRPC states this explicitly for its free plan. Check the provider's own wording before assuming the free tier behaves like the paid product.