Which Chains Cap Your Log Queries: a per-chain reference

By John Sullivan · November 18, 2026 · 9 min read · #eth_getlogs #json-rpc #block range limits #indexer #evm chains #error codes

There is no single eth_getLogs limit per chain. The same call that returns logs on one chain can fail with a range error on another, and the ceiling you hit belongs to the node answering the request rather than to the chain you named [1]. Two different caps produce that failure: a block-span cap, which is a client configuration value republished per plan, and a result-count cap, which is provider-side only and depends on how many logs matched [2][3]. Almost nothing here is fixed at the protocol level, so a chunk size hard-coded against one endpoint breaks the first time you point it at another — and the failure does not arrive as one error but as five [4].

Two caps, two layers

Block span is a client configuration value. In geth it is eth/filters Config.RangeLimit, a field whose documented default is 0, meaning no limit is applied [2]. When it is set, Filter.Logs compares end-begin against it and returns an invalid-params error naming the configured maximum [5]. A provider that fronts geth republishes that value per plan, so identical node software can present a different ceiling on a different endpoint.

Result count is provider-side only. geth has no cap on how many logs a query returns. LogQueryLimit is the field most often mistaken for one: its documented default is 1000, and it bounds how many addresses and topics a filter may carry, not how many logs come back [2]. A result cap exists independently of block range, and it is a function of log density rather than of width [3].

Neither cap is in the specification. execution-apis declares exactly one error for eth_getLogs, 4444 Pruned history unavailable [6]. It does fix -32602 for bounds past the head or inverted, and it forbids the server from quietly narrowing the range or returning a partial result [6].

Confuse the two layers and every query is mis-sized. A 500-block window on a chain with heavy log traffic can exceed a result cap; a 50,000-block window on a quiet chain can pass.

Where the table contradicts itself

We label the column "Observed ceiling", and the label carries weight: the figure records the widest span that worked in our 2026-10-11 probe, and it is not a guarantee [7]. The twenty rows run from 1,000 blocks to 50,000, and they cluster: nine sit at 50,000, four at 10,000, five at 5,000 and two at 1,000 [7]. We publish the current per-chain table, measured again on 2026-11-15, on the chain-facts page [8], and that page is the reference for individual chains.

Two rows look like errors and are not.

chain observed ceiling, 2026-10-11 note
bsc 5,000 one upstream accepted more than 50,000; another rejected 10,001
sei 1,000 probe observed 1,000; one upstream error reports a maximum of 2,000

bsc is genuine upstream variance. One upstream accepted a span above 50,000 blocks; another rejected 10,001. The probe's recorded 5,000 is a third figure, lower than both. Averaging those three numbers would produce a value no upstream enforces, so the note is the finding.

sei is not variance, and the 1,000-versus-2,000 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, and exposes it per node as max_blocks_for_log [9][10]. Its range check returns an error of the form block range too large (%d), maximum allowed is %d blocks [9], and our upstream returned a body of that shape reporting a 2,000 maximum [4]. 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 came from an error body after a 5,001-block attempt [7][4].

Arbitrum sits at the other end. Arbitrum's own docs put the same point from the other side: Nitro applies no block-range limit to eth_getLogs at all, so any ceiling you meet on Arbitrum belongs to the endpoint in front of the node rather than to the chain software [11].

The error is not one thing

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 arrives as a transport failure or as a 200 carrying an error object [4].

A 400 with code -32602 and the message "query exceeds block range limit" [4]. A 413 with code -32614 and the message "eth_getLogs is limited to a 10,000 range" [4]. A 200 OK whose body carries code -32000 and the message "block range too large (5001), maximum allowed is 2000 blocks" [4]. A second 200 OK carrying -32602 — the same code as the first body, at a different status, with a shorter message. And a 403 with code -33000, which is the plan gate rather than an upstream cap.

The codes are not a family. -32602 is defined by the JSON-RPC 2.0 specification as invalid params. -32614 sits inside the reserved block from -32768 to -32000 but is not defined there, so the specification reserves it for future use. -32000 sits in the -32000 to -32099 band the specification reserves for implementation-defined server errors. -33000 is outside the reserved block entirely, which puts it in application-defined space [12]. Three of the five codes are not standard, and that is the practical problem.

A client that branches on HTTP status alone misses two of the five: both 200s. One that branches on -32602 alone misses three: the 413, the 200 with -32000, and the 403. Only a predicate that reads the status and the body catches all five.

Upstreams error, they do not truncate

Neither cap degrades gracefully. When a query exceeds a result-count limit or a block span, the upstream returns an error rather than a truncated set. We confirm that some upstreams enforce a result-count limit independent of block range, that they error rather than truncate, and that nothing is silently dropped from the response [3]. A measured Arbitrum example reports that the logs matched by the query exceeded a limit of 10,000 [3]. The proxy in front of the upstreams also carries a defensive 128 MB response-body cap, which returns -32005 and asks for a narrower range or an address filter [3]; -32005 is not defined in the specification either, and sits in the implementation-defined band [12].

The specification agrees. A server is not permitted to trim the range to the head block, and it is not permitted to answer with part of the result [6].

That is what makes a large query safe to get wrong. A client that handles the error cannot silently miss logs, because there is no partial success for them to hide in. A query that exceeds a cap returns an error and nothing else.

What to do with the table

Size the window from the observed ceiling for the chain you are on, then treat that number as a starting point rather than a contract. Three habits do the rest.

Branch on both layers. A predicate that checks the HTTP status and the JSON-RPC code together catches all five shapes above; either one alone does not.

Keep the span and the result count separate in your retry logic. A range error means narrow the window. A result-count error means narrow the window or add an address filter, and the second is usually cheaper on a dense chain, because the cap is a function of how many logs matched rather than of how many blocks you asked for [3].

Expect the cap to move. The figure in the error belongs to the node that answered, and two nodes behind a single endpoint can return different caps for the same request [1]. A chunk size that is correct against one endpoint is a guess against the next. If you are looking at one of these bodies now, the block-range error page covers that specific failure and its fixes.

The one range cap we impose ourselves is a plan gate: the Free plan allows 100 blocks per eth_getLogs request, fixed and not load-adaptive, and paid plans carry no range cap of ours [13]. It is a plan property rather than a chain property, and it is the only cap here that we set rather than inherit.

For the budgeting side — how many requests a backfill needs at a given span, and where to spend them — planning an indexer backfill works through the arithmetic.

What the table does not tell you

The 20 chains in the probe are the top 20 by 30-day traffic, not the full set we serve [7]. A chain outside that list has no observed ceiling here, and its absence is not evidence of a high cap.

The numbers are observed, not guaranteed [7]. "Largest observed" is a lower bound by construction: it records the widest span that succeeded, so the true ceiling is at least that and may be higher. Our own chain-facts page, measured on 2026-11-15, reports different figures for several of the same chains [8] — the same point from another direction. Either the caps moved in five weeks or the probe stopped before it found them, and the sources do not separate the two. A longer companion piece, which walks the same set chain by chain, is in progress.

The cap can differ between two upstreams of the same chain. bsc is the proof [7].

And the measurement is dated 2026-10-11, which makes it more than five weeks old [7]. Treat any number here as something to verify against the endpoint you are actually calling.

Read the rate-limit guide

Sources

  1. SwiftNodes /errors — eth_getLogs block range too large: "a property of the node, not of the chain" — SwiftNodes, 2026-09-24
  2. go-ethereum eth/filters/filter_system.go — Config.RangeLimit default 0; LogQueryLimit caps addresses, not results — ethereum/go-ethereum (GitHub), 2026-11-17
  3. SwiftNodes — result-count cap is independent of block range; upstreams error rather than truncate — SwiftNodes (customer-supplied, expert answer 15b679e3), 2026-11-03
  4. 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
  5. go-ethereum eth/filters/filter.go — range-limit check compares end-begin, returns invalidParamsErr — ethereum/go-ethereum (GitHub), 2026-11-17
  6. execution-apis src/eth/filter.yaml — eth_getLogs declares exactly one error: 4444 Pruned history unavailable — ethereum/execution-apis (GitHub), 2026-11-17
  7. 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
  8. SwiftNodes /docs/chain-facts — measured per-chain eth_getLogs range table, last measured 2026-11-15 — SwiftNodes, 2026-11-15
  9. sei-chain evmrpc/filter.go — DefaultMaxBlockRange = 2000 and checkBlockRange enforcement — sei-protocol/sei-chain (GitHub), 2026-11-17
  10. sei-chain evmrpc/config/config.go — MaxBlocksForLog is a node config field (mapstructure max_blocks_for_log) — sei-protocol/sei-chain (GitHub), 2026-11-17
  11. Arbitrum docs — RPC methods: "Nitro imposes no block-range limit on eth_getLogs" (retrieved 2026-11-17) — Arbitrum docs (Offchain Labs), 2026-01-01
  12. JSON-RPC 2.0 Specification — error code ranges: -32000..-32099 reserved for implementation-defined server errors — jsonrpc.org, 2010-01-01
  13. SwiftNodes — Free-plan cap is 100 blocks and fixed; paid plans have no SwiftNodes range cap — SwiftNodes (customer-supplied, expert answer 28676230), 2026-11-03

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 →