> ## Documentation Index
> Fetch the complete documentation index at: https://docs.chainstack.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Throughput guidelines

> View Chainstack platform limits for node deployments, API requests, concurrent connections, and resource quotas across different subscription plan tiers.

## Rate limits

### Solana-specific

* Solana Mainnet:
  * Developer plan: 5 requests per second (RPS)
  * Growth plan: 50 requests per second (RPS)
* Solana Devnet:
  * Developer plan: 25 requests per second (RPS)
  * Growth plan: 250 requests per second (RPS)

### Arbitrum-specific

* Arbitrum Mainnet: `debug_traceBlockByNumber` 20 RPS on all plans

### Cronos-specific

* Cronos Mainnet archive: `debug_traceBlockByNumber` 10 RPS on all plans

### All other protocols

For global plan RPS limits across all other protocols, see [Requests per second (RPS) plan limits](/docs/rps-plan-limits).

## EVM Range limits

For `eth_newFilter` requests, Developer subscription plan users get capped at 10,000 blocks per request.

For the `eth_getLogs`, the caps are:

* Developer plan — 100 blocks
* Growth plan — 10,000 blocks
* Pro plan — 10,000 blocks
* Business plan — 10,000 blocks
* Enterprise — 10,000 blocks. Customization available on request.

<Info>
  Learn more about `eth_getLogs` limits by reading [Understanding eth\_getLogs limitations](/docs/understanding-eth-getlogs-limitations).
</Info>

Need a larger range? [Dedicated Nodes](/docs/dedicated-node) support custom block-range limits on request.

## EVM `eth_getProof` history limits

`eth_getProof` returns a proof only for blocks inside the node's proof history. On Global Nodes that history is fixed per network, and a request for an older block returns an error instead of a proof. A proof for a block 127 or more blocks behind the tip is also an archive request and costs 2 RUs — see [Full vs archive by protocol](/docs/request-units#full-vs-archive-by-protocol).

| Global Node network | Blocks with proofs | Error for an older block |
| - | - | - |
| Avalanche C-Chain, Linea, Mantle, Scroll, Sonic, Robinhood Chain Testnet | Every block from genesis | — |
| Stable | Every block, with an explicit block number; the proof is a Cosmos IAVL proof — see [Stable methods](/docs/stable-methods) | — |
| Ethereum Mainnet, Ethereum Sepolia | The latest 10,000 blocks | `-32602` `distance to target block exceeds maximum proof window` |
| BNB Smart Chain | Blocks less than 127 behind the tip | `-32602` `distance to target block exceeds maximum proof window` |
| Polygon | Blocks less than 127 behind the tip | `-32000` `missing trie node` |
| Elysium | Blocks less than 127 behind the tip | `-32000` `historical state <state root> is not available` |
| Kaia, opBNB | Blocks less than 127 behind the tip — these Global Nodes run in full mode only | `-32002` |
| Arbitrum, Robinhood Chain Mainnet | About the latest 128 blocks | `-32000` `missing trie node` |
| Cronos | Recent blocks only — older state is pruned | `-32000` `target version is pruned` |
| Arc, Base, Berachain, Celo, Ethereum Hoodi, Ink, Optimism, Plasma, Ronin, Tempo, Unichain, World Chain, Zora | The latest block only (`latest`) | `-32602` `distance to target block exceeds maximum proof window` |
| Hyperliquid (HyperEVM), Monad, ZKsync Era | Not served — the network's node client does not implement `eth_getProof`. On ZKsync Era, use `zks_getProof`, which proves storage against an L1 batch | `-32601` `Method not found` |
| Fantom | Not served — the Sonic node client no longer supports `eth_getProof` on the Fantom chain | `-32000` `method handler crashed` |
| MegaETH | Not served — MegaETH does not support `eth_getProof` | `-32603` `internal eth error` |

Proof generation time grows with block depth. On Ethereum Mainnet, a proof about 9,000 blocks behind the tip takes over a minute, so raise your client's request timeout for deep proofs.

Need proofs further back? A [Dedicated Node](/docs/dedicated-node) running Reth supports a longer proof window on request, up to 1,209,600 blocks (about 168 days on Ethereum Mainnet). Generation time still grows with depth, so a proof hundreds of thousands of blocks back takes tens of minutes.

## EVM disabled debug methods

The following debug methods are disabled on EVM chains:

* `debug_executionWitness`
* `debug_executionWitnessByBlockHash`
* `debug_executePayload`

## Custom tracers on EVMs

EVM debug and trace methods accept two kinds of tracers:

* Native (built-in) tracers — selected by name, such as `callTracer`. Available on [Global Nodes](/docs/global-elastic-node); the exact set depends on the protocol (see below).
* [Custom JavaScript](/docs/mastering-custom-javascript-tracing-for-ethereum-virtual-machine) tracers — where you pass raw JavaScript as the `tracer` argument. These are disabled on Global Nodes and are available as customized solutions on the [Enterprise plan](https://chainstack.com/pricing/) on [Dedicated Nodes](/docs/dedicated-node).

### Available native tracers

The following native tracers are enabled by default on EVM Global Nodes:

* `4byteTracer`
* `callTracer`
* `prestateTracer`
* `noopTracer`

On Global Nodes, the extended set — `flatCallTracer`, `muxTracer`, and `erc7562Tracer` — is enabled per protocol rather than everywhere. Requesting one where it is not enabled returns the [disabled tracer error](#disabled-tracer-error).

| Protocol | `flatCallTracer` | `muxTracer` | `erc7562Tracer` |
| - | - | - | - |
| Ethereum | Available | Available | Available |
| Polygon | Available | Not available | Available |
| Elysium | Available | Available | Available |
| All other EVM networks | Not available | Not available | Not available |

On Polygon, `flatCallTracer` is what replaces the retired Erigon `trace_*` namespace, because it returns traces in the Parity-style flat format — see [Polygon methods](/docs/polygon-methods).

Elysium also accepts `stylusTracer`, the Nitro tracer that records the host I/O calls of Stylus (WebAssembly) contracts for `cargo stylus replay`. It returns an empty array for a transaction that makes no Stylus calls.

Three networks accept a narrower default set. The limit comes from the network's node client, so these tracers return a client error rather than the disabled tracer error:

* Monad — `callTracer` and `prestateTracer` only. `4byteTracer` and `noopTracer` return `-32602`.
* ZKsync Era — `callTracer` only. `prestateTracer`, `4byteTracer`, and `noopTracer` return `-32602`.
* Kaia — `noopTracer` returns `-32000`. The other three default tracers work.

See [Debug and Trace | Ethereum](/reference/ethereum-debug-trace-rpc-methods#pre-built-native-tracers) for a description of each tracer.

### Disabled tracer error

Requesting a tracer that isn't enabled on the node—a custom JavaScript tracer, or a native tracer not available on that protocol—returns:

```json theme={"system"}
{
  "error": {
    "code": -32612,
    "message": "Custom tracers are disabled by default. See https://docs.chainstack.com/docs/limits for details."
  }
}
```

## Ethereum `eth_simulateV1` supports only full node

Running [eth\_simulateV1 | Ethereum](/reference/ethereum-simulatev1) will yield only a full node response—i.e. the data from the latest 128 blocks. Archive data is not supported for this call and the node will respond with `missing trie node`.

## Fantom method limits

The following limits are applied on all subscription plans:

* `debug_traceBlockByNumber`: 5 RPS
* `debug_traceBlockByHash`: 5 RPS

## Solana method limits

The following per-method RPS limits apply to Solana Mainnet [Global Nodes](/docs/global-elastic-node). On [Dedicated Nodes](/docs/dedicated-node), per-method limits are configured per node.

| Method | RPS |
| - | - |
| `getBlockTime` | 500 |
| `getBlock` | 400 |
| `getTokenSupply` | 500 |
| `getMultipleAccounts` | 300 |
| `getSupply` | 300 |
| `getTokenAccountsByOwner` | 150 |
| `getProgramAccounts` | Depends on the program size and on filters — see [getProgramAccounts limits](#getprogramaccounts-limits) |
| `getLargestAccounts` | 0 — available on [Dedicated Nodes](/docs/dedicated-node) only |
| `getTokenLargestAccounts` | 0 — available on [Dedicated Nodes](/docs/dedicated-node) only |

<Note>
  The `getConfirmedBlock` method was removed in Agave 2.0 and returns `Method not found` on current validators. Use [`getBlock`](/reference/solana-getblock) instead.
</Note>

Architectural limits (set by Solana, not Chainstack):

* `getBlocks`: 500,000 blocks range — [Solana architecture limit](https://solana.com/docs/rpc/http/getblocks).
* `getBlocksWithLimit`: 500,000 blocks range — [Solana architecture limit](https://solana.com/docs/rpc/http/getblockswithlimit).

### getProgramAccounts limits

On Solana Mainnet Global Nodes, the [`getProgramAccounts`](/reference/solana-getprogramaccounts) rate limit depends on the size of the program you query. Each program is assigned a size tier by its approximate number of accounts, and each tier has one limit for requests that include `filters` and a lower limit for requests without them. Filters raise the limit only within the program's tier — a filtered request to a program with 1M or more accounts is limited to 3 requests per 20 seconds.

| Program size (accounts) | With filters | Without filters |
| - | - | - |
| Under 10K | 20 RPS | 10 RPS |
| 10K–30K | 15 RPS | 5 RPS |
| 30K–60K | 15 RPS | 3 RPS |
| 60K–200K | 15 RPS | 2 RPS |
| 200K–500K | 10 RPS | 2 RPS |
| 500K–1M | 5 RPS | 2 RPS |
| 1M and more | 3 requests per 20 seconds | 2 requests per 20 seconds |

The following rules also apply:

* A program without an assigned size tier, such as a recently deployed program, is limited to 2 RPS with or without filters.
* Requests to some high-traffic programs at `finalized` or `confirmed` commitment are served from a cache under separate per-program limits instead of the size tiers.
* Unfiltered requests to the SPL Token Program (`TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`), Token-2022 (`TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb`), and Kin (`kinXdEcpDQeHPEuQnqmUgtYykqKGVFq6CeVX5iAHJq6`) are rejected with error `-32602` — see [getProgramAccounts filters](/reference/solana-getprogramaccounts#filters). The SPL Token Program and Kin are also [excluded from indexing](#solana-accounts-excluded-from-indexing).
* A request over the limit returns HTTP `429` with JSON-RPC error `-32005`.

## Solana scan method limits

The account-scan methods — [`getProgramAccounts`](/reference/solana-getprogramaccounts), [`getTokenAccountsByOwner`](/reference/solana-gettokenaccountsbyowner), [`getTokenAccountsByDelegate`](/reference/solana-gettokenaccountsbydelegate), and [`getSupply`](/reference/solana-getsupply) — read across a program's accounts, which on a large program can be hundreds of millions of accounts. To keep one heavy scan from tying up a node, Solana Mainnet Global Nodes run each scan under a 60-second execution-time limit and a per-request memory limit, and run a limited number of scans at once. A scan that waits more than 15 seconds for a free scan slot is dropped without running.

A scan that exceeds the execution-time or memory limit is aborted and returns error [`-32012`](/docs/error-reference#json-rpc-error-codes) rather than hanging:

```json theme={"system"}
{
  "error": {
    "code": -32012,
    "message": "scan aborted: the scan was aborted (result size limit exceeded or externally cancelled)"
  }
}
```

To keep the scan within the limits, narrow the query — for example with `dataSize` or `memcmp` filters on `getProgramAccounts`.

A scan dropped from the queue also returns error `-32012`, with the message `scan aborted: scan abandoned after waiting Nms for a scan slot`, where `N` is the time the request spent queued in milliseconds. The scan never ran, so the same request can succeed later. Retry it with exponential backoff.

## Solana accounts excluded from indexing

The following Solana accounts are excluded from the `program-id` secondary index and cannot be queried with [`getProgramAccounts`](/reference/solana-getprogramaccounts). Use [`getTokenAccountsByOwner`](/reference/solana-gettokenaccountsbyowner) instead:

* `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA` — SPL Token Program
* `kinXdEcpDQeHPEuQnqmUgtYykqKGVFq6CeVX5iAHJq6` — Kin

## Solana method availability

The following methods are available only on the paid plans:

* `getProgramAccounts`
* `getLargestAccounts` — this method is available only on [Dedicated Nodes](/docs/dedicated-node).
* `getSupply`
* `getTokenAccountsByOwner`

## Solana archive methods availability

While most methods are supported on Solana [Global Nodes](/docs/global-elastic-node), only the following methods can fetch archive data:

* `getSignaturesForAddress`
* `getTransaction`
* `getBlock`
* `getBlocks`
* `getBlockHeight`
* `getBlockTime`
* `getBlocksWithLimit`

Note that this is only true for mainnet as there are no Solana archive nodes for Devnet.