# Free EVM RPC pool: rotate keyless endpoints for Polygon, Base, Ethereum, Arbitrum, Optimism, BSC

A tested pool of free endpoints and a small rotating client: standard JSON-RPC (`eth_getLogs`, receipts, blocks,
`eth_call`, ...), no keys needed to start. Tested live on 2026-11-13: 270 keyless endpoints per chain were checked for
block number, USDC `Transfer` logs over 2k / 10k / 50k / 100k-block ranges with 10-1,000-address OR filters, old logs
and receipts (Polygon 2020), and bursts of 8 parallel calls.

- Pool config: https://fetchapi.co/docs/rpc/free-pool.json (endpoints, measured limits, priority; `{KEY}` placeholders
  for the optional free-tier keys)
- Client: https://fetchapi.co/docs/rpc/rotating-rpc.js (Node 18+, no dependencies)

## What the keyless pool covers

| Chain | Endpoints that took 50k-block `eth_getLogs` | Old logs |
|---|---|---|
| Polygon | 2 Tenderly gateways, Pocket (10k: QuickNode public, PublicNode) | Tenderly, Pocket, QuickNode public returned 2020 logs; old receipts: Tenderly, QuickNode |
| Base | PublicNode, bloXroute, degenprotocol, Pocket | degenprotocol, Pocket |
| Ethereum | none; 10k: Tenderly, mevblocker | Tenderly, mevblocker |
| Arbitrum | arb1.arbitrum.io and Tenderly (100k), Pocket, fastnode | yes |
| Optimism | Tenderly, Pocket (10k: mainnet.optimism.io) | yes |
| BSC | none; 10k: PublicNode (recent only) | Pocket, fastnode at 2k |

- **Address lists:** 1,000-address OR filters worked on nearly every capable endpoint.
- **Rate:** all of them passed 8 parallel calls and 30 calls at 5 per second without a 429.
- **Tenderly:** returns at most 20,000 results per call.
- **Dead or useless (excluded):** polygon-rpc.com (401), llamarpc (gone), Blast (shut down), keyless Ankr (needs a key),
  Nodies, 1rpc and keyless dRPC (50-2,000-block caps), mainnet.base.org (429 on logs).

## The client

```js
const { RotatingRpc } = require("./rotating-rpc.js");
const pool = new RotatingRpc(require("./free-pool.json"), { keys: { ALCHEMY: process.env.ALCHEMY_KEY } });
const logs = await pool.getLogs("polygon", { fromBlock, toBlock, address: [USDC, USDC_E], topics: [TRANSFER] });
const rcpt = await pool.call("polygon", "eth_getTransactionReceipt", [hash]);
```

- **Routing:** big `eth_getLogs` goes to endpoints that took 50k ranges; everything else goes to any healthy endpoint.
- **On a 429:** the endpoint is cooled down and the next one is tried.
- **On a range error:** that endpoint's limit is lowered, and the range is split in half if every endpoint refuses it.
- **Rate caps and lag:** each endpoint has its own rate cap. Endpoints more than 20 blocks behind the head are benched.
- **Cache:** finalized receipts, blocks and logs are cached.
- **Measured:** 4,153 Polygon logs from a 200k-block 2020 range in 1.2-2.8 s, and a burst of 8 calls in 0.5 s.

## Make the load fit the free pool (two changes)

Today's design is about **9.1M calls a month (3.5/s)**. Two changes take it to about **0.56M (0.22/s)**, which the keyless
pool covers on every chain:

1. **Whale scan:** don't send 80 address-filtered `eth_getLogs` a minute. Send one unfiltered `eth_getLogs` on the
   USDC / USDC.e / pUSD contracts over the last ~30 blocks, and match the 2,000 watched wallets locally.
   - Measured: 2-5k logs, ~1.2 MB, ~100 ms.
   - Keep `toBlock` a few blocks behind the head: a lagging node returns fewer logs without an error.
2. **Wallet-history sweeps:** don't page `eth_getLogs` over a year of blocks (~3,160 calls a wallet per chain). Use a
   history API, about 8 calls a wallet:

| Source | Cost | Chains |
|---|---|---|
| Etherscan V2 `tokentx` / `txlist` | free: 3 calls/s, 100k/day, 1,000 records a call | Ethereum, Polygon, Arbitrum (Base, OP and BSC are paid, Lite $49) |
| Alchemy `alchemy_getAssetTransfers` | 120 CU a call; free 30M CU/month ≈ 250k calls | all 6 |
| Blockscout | free (keyless 300/min/IP, or a free key) | backup |
| dRPC address history (what burned the credit) | ~$0.09 a wallet | 5-100x the options above |

## Free accounts worth creating (one per provider: stacking accounts on one provider breaks their terms)

1. **Etherscan:** wallet history on Ethereum, Polygon and Arbitrum.
2. **Alchemy:** 30M CU/month, all 6 chains, plus `getAssetTransfers` history. Its free plan limits `eth_getLogs` to 10
   blocks, so use it for reads, not logs.
3. **Allnodes / PublicNode token:** archive access. The quota was not verified.
4. **Envio HyperSync token:** fast backfills. $4 per 1M past the free tier.
5. **Blockscout key**, **Infura Core** (3M credits/day), **Ankr Freemium** (~1M calls/month), **dRPC free**: extra headroom.

Not worth it:
- **QuickNode, GoldRush:** trials only.
- **Moralis:** no free plan.
- **Tenderly Node RPC:** not on its free plan.
- **NOWNodes:** free for the first month only.

## If you need an SLA later

At ~0.56M calls a month after the two changes:
- **dRPC pay-as-you-go:** ~$3.40 a month.
- **Alchemy pay-as-you-go:** ~$9 a month, assuming ~30 CU a call.
- **Flat plans:** dRPC Pro, Chainstack Growth and Nodies are ~$49-50 for ~6M calls.

Self-hosting doesn't pay at this load. A Polygon full node is ~4.5 TB growing ~105 GB a day: about €150-500 a month on
Hetzner, plus 4-8 hours a month of ops. Reconsider only if RPC spend passes ~$500 a month.

Keyless endpoints have no SLA. polygon-rpc.com and llamarpc both died this year, so keep a paid fallback key in the pool.