LiveRobinhood Chain now served from Frankfurt, Chicago and Singapore — a node on three continents.
All posts
·7 min read·NodeFlare Team

Best Free Ethereum RPC Endpoints in 2026

Compare free Ethereum RPC endpoints and API-key plans, with dated provider sources, a chain-ID check, workload budgeting and practical integration limits.

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 optionPublished allowanceThroughput or access constraintGetting access
NodeFlare public endpointBasic-method access; separate from the free account quota50 requests per 10 seconds per IPNo key
NodeFlare Free3M CU/monthUp to 10 requests/second, plus method and concurrency limitsFree account and API key
Alchemy Free30M CU/monthPlan documentation lists 300 CU/second; method costs determine call capacityAccount and application key
Infura Free3M credits/day500 credits/second; each method has a credit costAccount and API key
Ankr Freemium200M API credits/monthDocumentation lists approximately 1,800 Node API requests/minute across endpointsAccount and personal endpoint token
PublicNodePublic Ethereum endpointNo numeric per-client allowance established by our source review; do not interpret this as unlimitedNo 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:

Terminal
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 checkedObserved JSON-RPC result
https://rpc.nodeflare.app/eth/public0x1
https://ethereum-rpc.publicnode.com0x1
https://rpc.ankr.com/ethAuthentication 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:

Text
1,000 × 1 + 10,000 × 5 + 500 × 25 = 63,500 CU

That 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:

Text
https://rpc.nodeflare.app/eth/v1/YOUR_KEY

Keep 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:

JavaScript
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:

TypeScript
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

  1. Check the expected chain ID and the methods your application actually calls.
  2. 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.
  3. 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.
  4. Handle HTTP errors and JSON-RPC errors separately. Back off on rate limiting; do not blindly retry transaction submissions or other stateful operations.
  5. 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.