Quick answer: “Block range is too large” means the RPC endpoint you’re calling caps how many blocks one eth_getLogs request can scan. It’s a provider rule, not a Core blockchain rule. On Core mainnet we measured the public caps on 16 November 2026: Ankr’s public endpoint stopped at 1,001 blocks, dRPC’s free tier at 101 blocks and 1RPC at 50, while Core’s own https://rpc.coredao.org accepted 50,000-block queries and only failed once a request ran past roughly 30 seconds. The fix is to split your query into smaller block windows, filter by contract address and topics, and send large backfills to Core’s official endpoints.
If you’re building a dashboard, indexer, tax script or bot on Core (chain ID 1116), sooner or later you’ll ask for “all events since block X” and get an error back instead of logs. Below we list the exact error messages we got from each Core RPC, explain what they mean, and give you a chunked loop you can copy.
What the error looks like on Core RPCs
Every provider words this error differently. These are the raw JSON-RPC responses we got on 16 November 2026 when we asked for logs from the WCORE contract over ranges that were too wide:
// rpc.ankr.com/core (public)
{"jsonrpc":"2.0","id":1,"error":{"code":-32062,"message":"Block range is too large"}}
// core.drpc.org (free tier)
{"jsonrpc":"2.0","id":1,"error":{"code":35,"message":"ranges over 10000 blocks are not supported on free plan"}}
// 1rpc.io/core
{"jsonrpc":"2.0","id":1,"error":{"code":-32602,"message":"eth_getLogs is limited to 0 - 50 blocks range"}}
// rpc.coredao.org (very large range)
{"jsonrpc":"2.0","id":1,"error":{"code":-32002,"message":"request timed out"}}
ethers.js, viem and web3.py usually wrap these in a generic “could not coalesce error” or “server response” exception. Check the inner error.message to find the provider’s actual wording.
Why it happens
The Ethereum JSON-RPC eth_getLogs specification doesn’t define any maximum range. A node can technically scan from genesis to the tip in one call. The catch is cost. The node has to check a bloom filter for every block in the range and then load the receipts of every matching block. A wide query with no address filter can tie up a node for seconds and return hundreds of thousands of entries. Public providers protect themselves by capping the span between fromBlock and toBlock, the number of results, or the run time.
Core makes this worse than you might expect because blocks are fast. We sampled 10,000 recent blocks and they averaged exactly 3 seconds apart. That’s about 28,800 blocks a day, so a 1,000-block cap covers only about 50 minutes of chain history and a 100-block cap only 5 minutes.
Core RPC eth_getLogs limits we measured
We sent the same filter (WCORE contract address, ranges ending at the chain tip) to each endpoint listed on Core’s official RPC endpoints page. Then we narrowed in on the largest range each one accepted. “Range” here means the inclusive number of blocks from fromBlock to toBlock.
| Endpoint | Largest range accepted | Error when exceeded |
|---|---|---|
| rpc.coredao.org (official) | 50,000+ blocks (with address filter); 50,000 blocks returned 119,412 logs even without one | -32002 “request timed out” once a query ran ~30 s (a 10M-block query) |
| rpcar.coredao.org (official archive) | 50,000+ blocks in our test | Not reached |
| rpc.ankr.com/core (public) | 1,001 blocks (to minus from = 1,000) | -32062 “Block range is too large” |
| core.drpc.org (free) | 101 blocks | code 35 “ranges over 10000 blocks…” (the number in the message is misleading) |
| 1rpc.io/core | 50 blocks (per its error text) | -32602 “limited to 0 – 50 blocks range”; later retries returned HTTP 525 |
| api.zan.top/core-mainnet | None without an account | -32012 eth_getLogs “not available for unregistered accounts” |
The Ankr result matches its published plan limits (1,000 blocks on Public, 3,000 on Freemium, 10,000 on Premium, and at most 200,000 logs per response). dRPC’s error says “10000 blocks” even though it rejected anything over 101 blocks for us. Independent testers have reported the same mismatch on other chains. These are free public tiers, so limits can change without notice. Treat the table as a snapshot.

Does Core’s node software have a range limit?
Core runs a Geth fork (core-chain). The official RPC reported Geth/v1.0.27, which matches the latest release, published 31 October 2026. Its source includes a --rangelimit flag described as “Enable 5000 blocks limit for range query”. Our 50,000-block queries worked, so that limit clearly wasn’t active on rpc.coredao.org. What did stop us was time. Core-chain’s default HTTP server write timeout is 30 seconds, and our 10-million-block query failed after almost exactly 30 seconds with Geth’s standard -32002 request timed out. A 2-million-block query for a single contract finished in about 16 seconds and returned 58,890 logs.
The node also rejects a few malformed queries regardless of range. We hit each of these:
invalid block range paramswhenfromBlockis higher thantoBlock.exceed max topicswhen you pass more than four topic positions.cannot specify both BlockHash and FromBlock/ToBlockwhen you mixblockHashwith a range.
Upstream Geth recently added its own --rpc.rangelimit (default 0, unlimited) and --rpc.logquerylimit options, defined in Geth’s flag definitions. So if you run your own Core node, check how your operator has configured it.
How to fix “block range is too large”
1. Split the range into chunks
Pick a chunk size below the smallest cap you might hit. Walk forward through the range, and if a chunk still fails, halve it and retry. Here’s a minimal version for ethers v6:
import { JsonRpcProvider } from "ethers";
const provider = new JsonRpcProvider("https://rpc.coredao.org");
async function getLogsChunked(filter, from, to, step = 1000) {
const out = [];
let start = from;
while (start <= to) {
const end = Math.min(start + step - 1, to);
try {
out.push(...await provider.getLogs({ ...filter, fromBlock: start, toBlock: end }));
start = end + 1; // move on only after success
} catch (e) {
const msg = String(e?.error?.message ?? e?.message ?? e);
if (step > 1 && /range|too large|limited|timed out|results/i.test(msg)) {
step = Math.floor(step / 2); // shrink and retry the same chunk
continue;
}
throw e;
}
}
return out;
}
Save the last block you finished, so a crash or rate limit doesn’t make you rescan from the start. If you use Ankr’s public endpoint, start at step = 1000. On dRPC’s free tier, use 100.
2. Always filter by address and topics
An address filter plus a topics[0] event signature (for example the ERC-20 Transfer hash 0xddf252ad…) cuts both the node’s work and the size of the response. In our tests, the last 5,000 blocks on Core produced 9,193 logs with no filter but only 86 for the WCORE contract.
3. Use Core’s official endpoints for backfills
For one-off historical scans, https://rpc.coredao.org handled much wider ranges than the third-party free tiers. Still, chunk at something like 10,000 to 50,000 blocks so each call finishes well under the 30-second timeout. Log history is part of normal full-node data, so you don’t need the archive endpoint just for logs. If you also need old balances or eth_call results at past blocks, see our missing trie node guide for when to use rpcar.coredao.org.
4. Test a range with curl first
curl -s -X POST https://rpc.coredao.org \
-H "content-type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"eth_getLogs","params":[{
"fromBlock":"0x269b000","toBlock":"0x269b3e7",
"address":"0x191e94fa59739e188dce837f7f6978d84727ad01"}]}'
Block numbers must be hex. 0x269b000 to 0x269b3e7 is exactly 1,000 blocks. The address is WCORE, the wrapped version of Core’s gas token (see what WCORE is). An empty "result":[] is a valid answer. It just means no matching events in that window.
5. Don’t need code? Use the explorer
If you only want the history for one wallet or token, Core Scan already indexes it. Our guides on using Core Scan and exporting Core transaction history to CSV cover that route without touching eth_getLogs.
FAQ
Is the limit set by the Core blockchain?
No. Neither the JSON-RPC spec nor Core’s consensus rules limit the range. Each RPC provider or node operator sets its own cap, which is why the same query works on one endpoint and fails on another.
Why does dRPC say 10,000 blocks when it fails at 101?
We can’t say why. We can only report that its free tier rejected 102-block ranges with that message in repeated tests. Use 100-block chunks there, or a paid key.
Can I use “earliest” to “latest” in one call?
Only on endpoints with no range cap, and even then a busy contract will hit the timeout. Chunking is more reliable.
Will I miss logs between chunks?
Not if each chunk starts at the previous toBlock + 1. Both bounds are inclusive. For data near the tip, re-read the last few blocks. Core has fast finality, but blocks that aren’t final yet can still change.
Disclaimer: This article is for general educational purposes only and is not financial or investment advice. RPC limits were tested on 16 November 2026 against public endpoints and may change at any time; always check your provider’s current documentation.
