eth_getLogs Limits Across Chains, Measured

By John Sullivan · November 20, 2026 · 14 min read · #eth_getlogs #block range limits #json-rpc #indexer #evm chains #rpc benchmarks

There is no single eth_getLogs block range limit by chain, and a table of per-chain numbers is not a table of caps. It records the widest span that succeeded in our 2026-10-11 probe across the top 20 chains by 30-day traffic, which makes every figure in it a lower bound: a query that succeeded at 5,000 blocks proves that 5,000 works and proves nothing about 5,001 [1]. The ceiling you actually hit belongs to the node answering the request, not to the chain you named [2]. Two different caps produce that failure — a block-span cap and a result-count cap — and which chains cap your log queries sets out how they differ and what each one's error looks like [3][4].

Read that way, the numbers stop being a reference that ages badly and become a measurement with a date, a sample and a known direction of error. The direction is the useful part: a largest-observed-success can only be revised upward by a later measurement of the same node, so a figure from 11 October is a floor that a newer measurement may raise. We published a newer one five weeks later, and it disagrees with this probe on 9 of the 20 rows [5]. That disagreement is the evidence for the reading rather than an embarrassment to explain away.

What was measured, and what the column means

The column is largest_observed_logs_range_blocks, and our own gloss on it is that "Observed ceiling" means the largest span that succeeded in the 2026-10-11 probe, not a guarantee [1]. The sample is the top 20 chains by 30-day traffic, each row carrying an archive flag and the measurement date [1]. Twenty rows, twenty chains, one date.

That caveat is doing real work, and it is worth taking at face value rather than treating it as boilerplate. "Not a guarantee" is not modesty about the probe's accuracy; it is a statement about what a largest-observed-success can support. A guarantee would be a promise about the next request. The column is a record of past ones.

The probe's stopping rule is not documented anywhere we hold. Nothing in the material states whether 5,000 and 10,000 were caps the probe ran into or where it stopped trying, and nothing states the step size, the number of attempts, or whether a failed attempt was retried. We are not going to fill that gap with a plausible method. The gap is the reason the column is a lower bound rather than a ceiling: a probe that stops at a rung reports the rung, not the wall.

One observation is available, and it is checkable from two published sources. Every one of the 20 values is one of four numbers — 1,000, 5,000, 10,000 or 50,000 — and the newer page documents its own column as the largest of those same four rungs [5]. That is consistent with a shared ladder. It is not a documented stopping rule, and we do not have one.

A lower bound is the only honest thing to publish from a probe of this shape. A ceiling would require testing every width up to the point of failure, and the probe did not do that — or if it did, the record of it is not in what we hold. What the probe does establish is a floor: on 2026-10-11, a query of this width returned logs on this chain. That is a fact about a specific day and a specific node, and it is worth more than a number with no date attached to it.

A floor is also the safer thing to publish. A chunk size taken from a lower bound is conservative by construction: if the real cap is higher, the query succeeds and you have spent more requests than you needed to. The failure mode runs the other way. A table presented as a ceiling invites a reader to size at the number and then treat a failure above it as a bug in their own code. The cost of publishing a floor is a few extra requests. The cost of publishing a false ceiling is a chunk size that breaks on a node the author never tested.

The cap belongs to whichever node answers, so two upstreams behind one endpoint can return different caps for the same query [2]. That one fact explains most of what looks wrong in the table, and it is why the date matters as much as the number.

The eth_getLogs block range limit by chain: all 20 rows

Measured 2026-10-11. The column is the widest span that succeeded in that probe, not a guarantee [1].

rank chain largest observed span (blocks) archive notes
1 robinhood 50,000 yes
2 bsc 5,000 yes one upstream accepted >50,000; another rejected 10,001
3 arbitrum 50,000 yes
4 base 5,000 yes
5 polygon 10,000 yes
6 plasma 50,000 yes
7 sei 1,000 no probe observed 1,000; one upstream error says max 2,000
8 unichain 10,000 yes
9 soneium 50,000 yes
10 eth 50,000 yes
11 monad 1,000 yes
12 avalanche 50,000 yes
13 optimism 5,000 yes
14 cronos 10,000 yes
15 berachain 50,000 yes
16 celo 5,000 yes
17 sonic 50,000 yes
18 opbnb 10,000 yes
19 mantle 50,000 yes
20 gnosis 5,000 yes

Nine rows sit at 50,000, four at 10,000, five at 5,000 and two at 1,000, which sums to 20 [1]. The shape is more useful than any single row: the set is not a spread of 20 different numbers but four rungs, with most of the weight on the top one. A chunk size taken from the middle of that distribution — 5,000, say — is above the observed span on two chains, equal to it on five, and below it on thirteen.

Two rows carry a note and the other eighteen carry none; the notes are reproduced as supplied [1]. Each row also carries an archive flag, which is not this measurement's subject and is reproduced with the data rather than interpreted here [1].

Two measurements, five weeks apart

We publish our own per-chain measurement at the current per-chain measurements, last measured 2026-11-15 [5]. Set against the 2026-10-11 probe, 9 of the 20 rows differ and 11 agree. No row is excluded as incomparable: Ethereum appears on the newer page at 50,000+, which is consistent with the probe's observed 50,000, so it counts as agreement [5].

chain 2026-10-11 probe 2026-11-15 measurement direction
base 5,000 50,000+ up
polygon 10,000 50,000+ up
celo 5,000 50,000+ up
opbnb 10,000 50,000+ up
gnosis 5,000 50,000+ up
bsc 5,000 1,000 down
unichain 10,000 1,000 down
soneium 50,000 1,000 down
monad 1,000 under 1,000 down

Five of the nine moved up, and that is what the lower-bound reading predicts. The probe stopped at a rung, the later measurement reached a higher one, and the earlier figure was a floor rather than a wrong answer. A query that succeeded at 5,000 does not prove 5,001 fails, so a later measurement that succeeds at 50,000 has not contradicted the earlier one — it has raised it [1][5].

Four of the nine moved down, and the lower-bound reading does not explain those. A floor can be revised upward by a later measurement; it cannot fall. bsc went from 5,000 to 1,000, unichain from 10,000 to 1,000, soneium from 50,000 to 1,000, and monad from 1,000 to under 1,000 [5]. For those four the honest reading is that the cap itself moved, or that the newer measurement reached a different upstream node than the probe did. The sources do not separate the two, and we are not going to pick one.

The four downward rows are not a problem for the reading. The newer page makes the same point from its own side: a limit belongs to the nodes that serve a chain, and the upstreams behind one endpoint need not agree [5]. A cap that belongs to a node can move when the node changes, in either direction. A cap that belonged to the chain could not.

The eleven rows that agree matter too, because agreement is the less interesting half and it is the half that makes the disagreement mean something. robinhood, arbitrum, plasma, eth, avalanche, berachain, sonic and mantle sit at 50,000 against 50,000+; optimism at 5,000 against 5,000; cronos at 10,000 against 10,000; sei at 1,000 against 1,000 [5]. Where two measurements five weeks apart land on the same rung, that rung is likely real for that node on both days. Where they do not, the disagreement is the information.

The newer page's own column has the same shape, and that is worth noticing because it applies this reading to itself. It documents its column as the largest of 1,000, 5,000, 10,000 or 50,000 blocks that an address-filtered query was accepted for [5]. So a figure of 50,000+ on that page is not a ceiling either. It is the top rung of the same ladder, and it means at least 50,000. The newer measurement is the better number where the two disagree, and it is still a lower bound.

Where the two disagree, the newer number is the better one — not because the newer source is more authoritative, but because a lower bound from 11 October is superseded by a measurement from 15 November on the same question [1][5]. Measurements age. That is this reading applied to itself, and it is why the date belongs with the number.

For a reader choosing a chunk size today, the practical consequence is short. Take the newer figure where the two disagree, because it is the later measurement of the same question [5]. Where they agree, the rung is likely stable and worth trusting a little further. Where the newer figure is lower than the probe's, do not read that as the probe having been wrong — read it as the node having changed, and size to the lower number, because a floor that has since fallen is not a floor you can rely on.

The two rows that are findings, not errors

Two rows in the table carry a note, and both are the lower-bound reading failing to be a ceiling in our own data rather than in an argument.

bsc records 5,000. Its note says one upstream accepted more than 50,000 and another rejected 10,001 [1]. Three numbers, one chain, one day: the probe's largest success, a success above 50,000 on one upstream, and a rejection at 10,001 on another. Averaging them would produce a value no upstream enforces, so the note is the finding. It survives the two-measurement conflict because it rests on the note — a claim about two upstreams disagreeing — rather than on the observed column, which is a dated measurement [1]. The newer page reports 1,000 for bsc [5]. Four numbers now exist for one chain, from three surfaces, and the only reading that holds all of them is that the cap belongs to the node [2].

sei records 1,000, and its note says one upstream error reports a maximum of 2,000 [1]. This is not variance, and the gap is not evidence of it. Sei's own EVM RPC implementation ships a default maximum block range of 2,000, applied when a node's configuration leaves it unset [6], and exposes it per node as max_blocks_for_log [7]. Its range check returns an error of the form block range too large (%d), maximum allowed is %d blocks [6]. So 2,000 is a chain-software default an operator can change — not a consensus rule, and not one provider's plan setting. The probe's largest success was 1,000, and the 2,000 arrived in an error body after a 5,001-block attempt [1][8]. The probe never tested 1,001 to 2,000, so the table's 1,000 is a floor with a default sitting above it that the probe did not reach.

Both rows are the same lesson at two scales. A largest-observed-success records what worked. It cannot record what would have failed, and it cannot record what a different node would have allowed.

What this measurement cannot tell you

The table records successes. It says nothing about how a failure arrives, and the failure does not arrive one way. Five real responses to an over-wide eth_getLogs call, all recorded against one service, differ in HTTP status, in JSON-RPC code, and in whether the error comes back as a transport failure or as a 200 carrying an error object: 400 with -32602, 413 with -32614, 200 with -32000, 200 with -32602, and 403 with -33000 [8]. None of those five is a partial result: upstreams return an error rather than truncating, so there is no silent truncation [4], and the execution-apis spec forbids returning a partial result, or clamping a range to the head block [9]. A client that branches on HTTP status alone misses two of the five, both 200s. One that branches on -32602 alone misses three. Only a predicate that reads the status and the body catches all five [8]. Three of those codes are not standard: -32614 sits inside the reserved block but is not defined there, -32000 is implementation-defined, and -33000 is outside the reserved block entirely [10]. The 403 is a plan gate rather than an upstream cap [8]. which chains cap your log queries works through the full taxonomy and what to do with each shape. The specific failure has its own reference at the block-range error page.

Twenty chains by 30-day traffic is the sample, and it is not the full set we serve [1]. A chain outside the list has no observed span here, and its absence is not evidence of a high cap.

Every figure is a lower bound on the cap of the node that answered on 2026-10-11 [1]. The true ceiling on that node is at least the number in the table and may be higher, and the probe's stopping rule is undocumented, so nobody — including us — can say how much higher.

The direction of that error is the one thing the table does tell you reliably, for the node it measured. Every figure sat at or below that node's cap on the day, so a chunk size taken from this table will not over-request on a node that has not changed since. It may under-request, which costs requests and time rather than correctness. That asymmetry is worth more than precision: a number you know is too low is usable, and a number you cannot bound is not. The four rows where the newer measurement is lower — bsc, unichain, soneium and monad — are the exception, and there the newer number is the one to size to.

The measurement is dated 2026-10-11 [1]. Our own newer measurement, from 2026-11-15, is the better number where the two disagree [5].

Two upstreams of the same chain can disagree, and bsc is the proof [1]. A single number per chain summarises a distribution rather than stating a property of the chain.

What would change the answer is a documented stopping rule. If the probe's step size and attempt policy were recorded, the column could be read as a bounded interval rather than a floor, and the gap between the two measurements could be attributed rather than described. We do not have that record, and inventing one would make the table look more precise than the evidence supports.

Sizing a backfill against these numbers is a separate arithmetic, worked through in planning an indexer backfill.

If you need the real limit of the endpoint you are actually calling, this table cannot give it to you. That takes a method rather than a table — a probe against your own endpoint, with a stopping rule you write down — and finding your own endpoint's real limits is a different piece of work from this one.

Read the API reference

Sources

  1. SwiftNodes 20-row per-chain CSV — largest observed eth_getLogs range, measured_on 2026-10-11 — SwiftNodes (customer-supplied, expert answer be3ce5d4), 2026-11-03
  2. SwiftNodes /errors — eth_getLogs block range too large: "a property of the node, not of the chain" — SwiftNodes, 2026-09-24
  3. go-ethereum eth/filters/filter_system.go — Config.RangeLimit default 0; LogQueryLimit caps addresses, not results — ethereum/go-ethereum (GitHub), 2026-11-17
  4. SwiftNodes — result-count cap is independent of block range; upstreams error rather than truncate — SwiftNodes (customer-supplied, expert answer 15b679e3), 2026-11-03
  5. SwiftNodes /docs/chain-facts — measured per-chain eth_getLogs range table, last measured 2026-11-15 — SwiftNodes, 2026-11-15
  6. sei-chain evmrpc/filter.go — DefaultMaxBlockRange = 2000, applied when node config is unset — sei-protocol/sei-chain (GitHub), 2026-11-17
  7. sei-chain evmrpc/config/config.go — MaxBlocksForLog is a per-node config field (mapstructure max_blocks_for_log) — sei-protocol/sei-chain (GitHub), 2026-11-17
  8. SwiftNodes five real eth_getLogs error bodies — HTTP status, JSON-RPC code, transport vs 200-with-error-object — SwiftNodes (customer-supplied, expert answer a10d5ab1), 2026-11-03
  9. execution-apis src/eth/filter.yaml — eth_getLogs: -32602 for out-of-range bounds, no partial results — ethereum/execution-apis (GitHub), 2026-11-17
  10. JSON-RPC 2.0 Specification — error code ranges: -32000..-32099 reserved for implementation-defined server errors — jsonrpc.org, 2010-01-01

This article was researched, written and edited by AI under human supervision, and checked against Rankwrite's public editorial rubric.

J
John Sullivan
Infrastructure Writer, SwiftNodes

John Sullivan covers RPC infrastructure, node operations, and multi-chain development at SwiftNodes — what it actually takes to keep endpoints fast, fresh, and reliable across EVM and non-EVM networks.

Related posts

Try SwiftNodes free — multi-chain RPC across 139 networks, flat-rate pricing, pay by card or crypto, no KYC. Get an API key in 30 seconds →