Skip to content
PenyuOnCore
Menu
  • Home
  • Core Ecosystem Analysis
  • Personal Finance & Investing
  • Make Money Online
  • Bitcoin
  • About Us
Menu
eth_getLogs block range is too large error on Core RPC endpoints, with measured limits for Ankr, dRPC, 1RPC and rpc.coredao.org

eth_getLogs “Block Range Is Too Large” on Core: Limits and Fix

Posted on November 16, 2026

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.

EndpointLargest range acceptedError 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 testNot 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 blockscode 35 “ranges over 10000 blocks…” (the number in the message is misleading)
1rpc.io/core50 blocks (per its error text)-32602 “limited to 0 – 50 blocks range”; later retries returned HTTP 525
api.zan.top/core-mainnetNone 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.

Diagram showing a large eth_getLogs block range split into smaller chunks that fit each Core RPC provider's limit

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 params when fromBlock is higher than toBlock.
  • exceed max topics when you pass more than four topic positions.
  • cannot specify both BlockHash and FromBlock/ToBlock when you mix blockHash with 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.

Recent Posts

  • “tx fee exceeds the configured cap” on Core: Fix the 1 CORE RPC Limit
  • Zazzle Payout Schedule: When Do Zazzle Creators Get Paid? (2026)
  • “Transaction Underpriced” on Core: Fix the 60 Gwei Minimum
  • What Happens to EE Bonds After 30 Years? Payout, Paper Bonds and Taxes
  • USDT and USDC on Core: Contract Addresses and How to Add Them to MetaMask
Subscription form is not available at the moment
  • Altcoin News
  • Bitcoin
  • Core Ecosystem Analysis
  • DeFi
  • Free Crypto Signals
  • Make Money Online
  • Personal Finance & Investing
  • Token Analysis
  • About Us
  • Contact
  • Privacy Policy
  • Disclaimer
©2026 PenyuOnCore | Design: Newspaperly WordPress Theme