Free Alchemy Alternative for 2026 — NodeFlare RPC

If you're building seriously on Ethereum, Base, Arbitrum, or another EVM chain you've probably already tried the big names: Alchemy, Infura, QuickNode. They're solid products. But their free tiers come with limits that bite early — method restrictions and request caps that you hit fast once you move past hello-world.

This post covers what NodeFlare's free tier actually includes, how to swap your endpoint in 60 seconds, and the one capability that makes a real difference for non-trivial on-chain work.

What NodeFlare's free tier includes#

No credit card. No waitlist. You get:

• 2,000,000 compute units per month — enough for development, indexing scripts, and light production workloads
• eth_getLogs — available on the free tier, no upgrade required
• trace_* and debug_* — heavy methods work on free (many providers gate these behind paid plans)
• WebSocket (eth_subscribe) — real-time subscriptions on every supported chain, free
• 23 EVM chains — Ethereum, Base, Polygon, Arbitrum One & Nova, OP Mainnet, Linea, Sonic, Unichain, HyperEVM, Avalanche and more
• Multi-region nodes — US-East (NYC), US-West (LA), EU, and Asia with automatic failover

Your endpoint is live in under a minute.

Why eth_getLogs matters#

eth_getLogs is the workhorse of on-chain development. You need it for:

• Syncing events in an indexer
• Pulling token transfer history
• Listening to contract emissions in a DeFi bot
• Any historical query that goes beyond the current block

Many providers restrict eth_getLogs on free tiers because large log-range queries are compute-intensive. NodeFlare prices by compute unit and gives you 2M free instead of gating the method — so you can prototype and build without hitting a wall on the second day.

Switch your endpoint in 60 seconds#

ethers.js#

import { JsonRpcProvider } from "ethers";

// Before (Alchemy / Infura / QuickNode / other provider)
// const provider = new JsonRpcProvider("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY");

// After — NodeFlare (free tier, no credit card)
const provider = new JsonRpcProvider("https://rpc.nodeflare.app/eth/v1/YOUR_KEY");

const block = await provider.getBlockNumber();
console.log("Current block:", block);

viem#

import { createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";

const client = createPublicClient({
  chain: mainnet,
  transport: http("https://rpc.nodeflare.app/eth/v1/YOUR_KEY"),
});

const block = await client.getBlockNumber();

web3.py#

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://rpc.nodeflare.app/eth/v1/YOUR_KEY"))
print(w3.eth.block_number)

It's a one-line change. All standard eth_* and net_* JSON-RPC methods work the same way.

No key? Use the public endpoint#

Need a quick test without signing up:

curl https://rpc.nodeflare.app/eth/public \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

The public endpoint is rate-limited per IP (2 req/s). Fine for local scripts; get a free key for anything sustained.

WebSocket: real-time event subscriptions#

Every chain on NodeFlare has a WebSocket endpoint on the free tier:

const ws = new WebSocket("wss://rpc.nodeflare.app/eth/ws/v1/YOUR_KEY");

ws.onopen = () =>
  ws.send(
    JSON.stringify({
      jsonrpc: "2.0",
      id: 1,
      method: "eth_subscribe",
      params: ["newHeads"],
    })
  );

ws.onmessage = (e) => {
  const msg = JSON.parse(e.data);
  console.log("New block:", msg.params?.result?.number);
};

WebSocket is where the real-time piece lives — block subscriptions, pending transactions, log filters. It's included on every NodeFlare plan, including free.

All 23 chains, one key#

One API key works across every supported chain. Your 3M monthly compute units pool across all of them — no per-chain fees, no separate keys.

Per-chain landing pages with public endpoints, copy-paste URLs, and code snippets: nodeflare.app/chains.

How compute units work#

NodeFlare bills by compute unit (CU), not raw request count. Simple reads like eth_blockNumber cost 1 CU. Heavier calls like eth_getLogs cost more — proportional to the actual compute they consume.

This is the same model Alchemy popularized. The free tier starts at 2M CU/month. eth_getLogs, trace_*, and debug_* are not gated — you get the full method set from day one.

Full per-method CU weights: rate limits reference.

When to upgrade#

The free tier covers most development and lightweight production workloads. If you're running a high-frequency bot, a heavy indexer, or a production API with real user traffic, the paid plans scale without changing your endpoint format:

• Hacker — $10/mo
• Starter — $30/mo
• Pro — $100/mo

All plans include all chains, WebSocket, heavy methods, and multi-region failover. Full pricing →

Getting started#

1. Go to nodeflare.app — no credit card required
2. Your API key is provisioned immediately
3. Swap your endpoint string — done

If you hit a question: quick-start guide covers the basics; the Ethereum endpoint reference lists every supported method.