The right free Ethereum RPC depends on your workload. An occasional chain-ID check needs very little capacity; a wallet, event indexer or historical analysis needs predictable quotas and the right methods. Start by separating public URLs without a key from free accounts with an API key.
This guide is published by NodeFlare, one of the providers compared below. The comparison uses linked provider documentation reviewed on 4 November 2026 and the limited endpoint checks described below. It is not an uptime, latency or throughput ranking.
Quick comparison: public endpoints and free accounts
CU and credits are provider-specific units. A larger allowance does not necessarily buy more calls, and a per-second limit does not replace a daily or monthly quota.
| Provider and option | Published allowance | Throughput or access constraint | Getting access |
|---|---|---|---|
| NodeFlare public endpoint | Basic-method access; separate from the free account quota | 50 requests per 10 seconds per IP | No key |
| NodeFlare Free | 3M CU/month | Up to 10 requests/second, plus method and concurrency limits | Free account and API key |
| Alchemy Free | 30M CU/month | Plan documentation lists 300 CU/second; method costs determine call capacity | Account and application key |
| Infura Free | 3M credits/day | 500 credits/second; each method has a credit cost | Account and API key |
| Ankr Freemium | 200M API credits/month | Documentation lists approximately 1,800 Node API requests/minute across endpoints | Account and personal endpoint token |
| PublicNode | Public Ethereum endpoint | No numeric per-client allowance established by our source review; do not interpret this as unlimited | No key in the basic check below |
Alchemy's older support material also gives a 500 CU/second figure. Its linked plan and throughput documentation list 300. Confirm the limit shown for your account before sizing an application; this guide does not convert either figure into a universal requests-per-second claim.
A public endpoint you can check now
For a single Ethereum mainnet identity check:
curl --max-time 15 https://rpc.nodeflare.app/eth/public \
-H 'Content-Type: application/json' \
-H 'User-Agent: ethereum-rpc-check/1.0' \
--data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}'Ethereum mainnet returns "result":"0x1" (chain ID 1). NodeFlare's public endpoint allows 50 requests per 10 seconds per IP. For scripts that poll regularly or make several requests during startup, use an API-key plan rather than repeatedly hitting the public limiter.
We made a basic unauthenticated eth_chainId request from one server on 4 November 2026:
| URL checked | Observed JSON-RPC result |
|---|---|
https://rpc.nodeflare.app/eth/public | 0x1 |
https://ethereum-rpc.publicnode.com | 0x1 |
https://rpc.ankr.com/eth | Authentication error asking for an API key |
These observations verify only those requests at that time. They do not establish sustained availability, archive access, geographical performance or a rate limit. Ankr documents a public service, but the bare Ethereum URL rejected our unauthenticated request. Use the endpoint supplied by your Ankr account rather than assuming that URL will work without a token.
Choose by the job you need to finish
Occasional reads without an account: PublicNode is an option to evaluate; the checked Ethereum URL answered without a key. NodeFlare's public URL suits low-frequency checks under its explicit ten-second interval. Neither single test proves that your wallet's startup burst or your application's methods will work.
An application with usage tracking: Use a keyed plan. NodeFlare Free provides a shared monthly CU budget across its supported chains. Alchemy or Infura may fit better when an existing application depends on their SDKs, indexed APIs or product integrations. Compare those requirements separately from standard JSON-RPC access.
Ankr projects: Review its Freemium account option and copy the actual token-bearing endpoint from its dashboard. Check the published batch and block-range limits for your query pattern.
Historical data and indexing: Test the exact historical block, method and log range you need. An endpoint answering eth_chainId tells you nothing about archive depth, tracing permissions or a large eth_getLogs scan. See the Ethereum endpoint documentation and log-query limits before committing to NodeFlare for that workload.
Estimate requests from your own method mix
For NodeFlare, the current weights include 1 CU for eth_blockNumber, 5 CU for eth_call and 25 CU for eth_getLogs. A workload of 1,000 block-number checks, 10,000 contract reads and 500 log queries uses:
1,000 × 1 + 10,000 × 5 + 500 × 25 = 63,500 CUThat is a quota calculation, not a throughput test. Add retries, background polling, batches and other chains before comparing the total with the 3M CU monthly allowance. Rate, concurrency and query-range limits still apply. For another provider, redo the calculation using that provider's own method weights; do not reuse NodeFlare's CU numbers.
Connect with a free NodeFlare key
Create an account through Get started, then copy the key from your dashboard. The Ethereum endpoint format is:
https://rpc.nodeflare.app/eth/v1/YOUR_KEYKeep a backend key in an environment variable. Do not commit real keys or publish a token-bearing URL in logs, screenshots or support messages.
For a Node.js application using ethers v6:
import { JsonRpcProvider } from "ethers";
const rpcUrl = process.env.ETHEREUM_RPC_URL;
if (!rpcUrl) throw new Error("Set ETHEREUM_RPC_URL");
const provider = new JsonRpcProvider(rpcUrl);
const network = await provider.getNetwork();
if (network.chainId !== 1n) throw new Error("Expected Ethereum mainnet");For viem:
import { createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";
const rpcUrl = process.env.ETHEREUM_RPC_URL;
if (!rpcUrl) throw new Error("Set ETHEREUM_RPC_URL");
const client = createPublicClient({
chain: mainnet,
transport: http(rpcUrl),
});
if (await client.getChainId() !== 1) throw new Error("Expected Ethereum mainnet");Validate before switching a production application
- Check the expected chain ID and the methods your application actually calls.
- Test a representative contract read and, if needed, an old block and a bounded log query. Do not infer full historical coverage from a latest-block response.
- Confirm authentication, WebSocket support and any provider-specific APIs. Standard JSON-RPC compatibility does not make indexed APIs, subscriptions, sticky filters or SDK extensions interchangeable.
- Handle HTTP errors and JSON-RPC errors separately. Back off on rate limiting; do not blindly retry transaction submissions or other stateful operations.
- Monitor quota use and successful application operations. A successful healthcheck is not evidence that every customer workload works.
See the production integration guide for the next steps, pricing for NodeFlare's current plans, and the chain directory for supported networks. The public endpoint is a starting point for a small check; select your production plan from measured usage and method requirements.