Are you an LLM? Read llms.txt for a summary of the docs, or llms-full.txt for the full context.
Skip to content

networks

Networks YAML config describes the networks you wish to enable.

Fields

name

The name of the network it should be unique to the YAML so you can not have 2 networks with the same name in the same YAML file.

rindexer.yaml
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: ethereum // [!code focus]

chain_id

The chainId of the network.

rindexer.yaml
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: ethereum
  chain_id: 1 // [!code focus]

rpc

The rpc url for the network.

rindexer.yaml
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: ethereum
  chain_id: 1
  rpc: https://mainnet.gateway.tenderly.co // [!code focus]

You can use erpc for load-balancing between multiple rpc endpoints (with failover, re-org aware caching, auto-batching, rate-limiters, auto-discovery of node providers, etc.)

rindexer.yaml
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: ethereum
  chain_id: 1
  rpc: http://erpc:4000/main/evm/1 // [!code focus]

We advise using environment variables for the rpc url to avoid checking in sensitive information.

rindexer.yaml
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: ethereum
  chain_id: 1
  rpc: ${ETHEREUM_RPC} // [!code focus]

You can read more about environment variables in the Environment Variables section.

max_block_range

Set the max block range for the network, this means when rindexer is fetching logs it will not fetch more than the max block range per request.

rindexer.yaml
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: ethereum
  chain_id: 1
  rpc: https://mainnet.gateway.tenderly.co
  max_block_range: 10000 // [!code focus]

hypersync

Use an Envio HyperSync endpoint as the data source for historical log fetching, which is significantly faster than eth_getLogs over RPC for backfills.

The rpc field is still required: HyperSync only serves log data, so rindexer continues to use your RPC node for everything else — eth_call, transaction receipts, traces, latest block polling and live indexing at the chain head. If HyperSync is briefly behind the chain head or unavailable, rindexer automatically falls back to the RPC endpoint, so indexing always remains correct.

A HyperSync API token is required — you can create one for free at envio.dev/app/api-tokens. rindexer reads it from hypersync.api_token or the HYPERSYNC_API_TOKEN / ENVIO_API_TOKEN environment variables.

The simplest way to enable it (uses https://{chain_id}.hypersync.xyz and the token from your environment):

rindexer.yaml
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: ethereum
  chain_id: 1
  rpc: https://mainnet.gateway.tenderly.co
  hypersync: true // [!code focus]

All the options:

rindexer.yaml
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: ethereum
  chain_id: 1
  rpc: https://mainnet.gateway.tenderly.co
  hypersync: 
    url: https://eth.hypersync.xyz // [!code focus] # optional, defaults to https://{chain_id}.hypersync.xyz
    api_token: ${HYPERSYNC_API_TOKEN} // [!code focus] # optional, defaults to HYPERSYNC_API_TOKEN / ENVIO_API_TOKEN env vars
    max_block_range: 50000 // [!code focus] # optional, block range per HyperSync request during backfill
    stream_concurrency: 20 // [!code focus] # optional, concurrent internal requests per logs request; lower to reduce burst load
    batch_size: 1000 // [!code focus] # optional, initial block span per internal request before density is measured
    max_batch_size: 100000 // [!code focus] # optional, cap per internal request; helps wide sparse ranges with data, hurts empty-heavy scans
    response_bytes_target: 400000 // [!code focus] # optional, bytes each internal response is sized towards

Timestamp indexing (timestamps: true) gets an extra speed boost with HyperSync enabled: block timestamps are joined into the log queries directly, so rindexer does not need to fetch blocks over RPC to stamp events.

block_poll_frequency

Set the block poll frequency for the network, this allows making a trade-off between RPC use and live indexing speed. The default setting will aggressively poll new blocks to ensure that we index as quickly as possible.

This is not always wanted, and you can choose configure to use an rpc "optimized" version, or manually define the millisecond polling rate per network, or alternatively, manually define a factor of the polling rate.

rapid (default)
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: ethereum
  chain_id: 1
  rpc: https://mainnet.gateway.tenderly.co
  block_poll_frequency: rapid // [!code focus] # This will rapid-poll, roughly every ~50ms.

compute_units_per_second

The compute units per second for the network.

rindexer.yaml
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: ethereum
  chain_id: 1
  rpc: https://mainnet.gateway.tenderly.co
  compute_units_per_second: 660 // [!code focus]

get_logs_settings

Advanced configuration options that allow fine-grained control of event fetching logic.

address_filtering

Specifies how events that require address filtering (one that use either address filter or factory filter) are fetched from the network.

Can be one of:

  • with max_address_per_get_logs_request configuration (default behaviour) - events are fetched with addresses filter, log fetching happens in batches that consist of addresses chunks up to the specified value. Useful when events are often happening, but there is no huge number of addresses that are being watched for. The default value is 1000 addresses, which fits most of the RPC provider limits.
  • in-memory - all matching events are fetched and then filtered in memory by addresses. Useful when events are not happening often, but there are a huge number of addresses that are being watched for.
with max_address_per_get_logs_request
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: ethereum
  chain_id: 1
  rpc: https://mainnet.gateway.tenderly.co
  get_logs_settings:
    address_filtering:
      max_address_per_get_logs_request: 100000

disable_logs_bloom_checks

rindexer.yaml
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: ethereum
  chain_id: 1
  rpc: https://mainnet.gateway.tenderly.co
  disable_logs_bloom_checks: true // [!code focus]

multicall3_address

When using $call() in custom tables, rindexer automatically batches view calls using Multicall3 for significantly improved performance. This can reduce indexing time by 5-10x when your tables use on-chain view calls.

The standard Multicall3 contract (0xcA11bde05977b3631167028862bE2a173976CA11) is deployed on most EVM chains. See the full deployment list.

If your chain uses a different Multicall3 address, you can specify it:

rindexer.yaml
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: my_custom_chain
  chain_id: 12345
  rpc: https://rpc.mycustomchain.com
  multicall3_address: "0xYourCustomMulticall3Address"

If Multicall3 is not available on a network, rindexer will automatically detect this and fall back to individual RPC calls.

reth

Configure rindexer to use a local reth node for indexing. This provides direct connection to Reth with minimal latency and native reorg handling.

rindexer.yaml
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks:
- name: ethereum
  chain_id: 1
  rpc: https://mainnet.gateway.tenderly.co  # Fallback RPC
  reth: 
    enabled: true // [!code focus]
    logging: true // [!code focus]  # Show Reth logs in stdout
    cli_args: 
      - "--datadir /data/reth"
      - "--http"
      - "--full false" // [!code focus]  # Archive mode
      - "--authrpc.jwtsecret /path/to/jwt.hex"

enabled

Enable or disable the reth integration for this network.

logging

Show Reth logs in stdout (useful for debugging).

cli_args

Array of Reth CLI arguments in "flag value" format. Common arguments include:

  • --datadir: Path to the reth data directory
  • --authrpc.jwtsecret: Path to the JWT secret file for authenticated RPC
  • --authrpc.port: The port for the auth RPC server (default: 8551)
  • --full: Whether to run as a full node (use false for archive node)
  • --http: Enable HTTP RPC server

Multiple Networks

You can have as many networks as you want in the YAML file.

rindexer.yaml
name: rETHIndexer
description: My first rindexer project
repository: https://github.com/joshstevens19/rindexer
project_type: no-code
networks: 
- name: ethereum // [!code focus]
  chain_id: 1 // [!code focus]
  rpc: https://mainnet.gateway.tenderly.co // [!code focus]
- name: base // [!code focus]
  chain_id: 8453 // [!code focus]
  rpc: https://mainnet.base.org // [!code focus]