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

# op-node configuration options

> Complete reference for all op-node command-line flags and environment variables.

This page catalogues every configuration option for the op-node, the consensus-layer
(rollup node) client of an OP Stack chain.

The flag tables below are generated directly from the op-node's flag
definitions in the monorepo (`op-node/flags`) at the release tag named in the
provenance line, and are regenerated when a new finalized release is
published, so they cannot silently fall behind. Every flag can also be set
through the environment variable listed next to it.

For guidance on running a node — hardware, sync strategies, and monitoring —
see the [node operator guides](/node-operators/tutorials/run-node-from-source).

## Flags

Generated from [`op-node/v1.19.3`](https://github.com/ethereum-optimism/optimism/releases/tag/op-node%2Fv1.19.3)
flag definitions. 109 flags: 3 required, 106 optional.

### Required flags

| Flag              | Description                                                                                                         | Environment variable     |
| ----------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------ |
| `--l1`            | Address of L1 User JSON-RPC endpoint to use (eth namespace required)                                                | `OP_NODE_L1_ETH_RPC`     |
| `--l2`            | Address of L2 Engine JSON-RPC endpoints to use (engine and eth namespace required)                                  | `OP_NODE_L2_ENGINE_RPC`  |
| `--l2.jwt-secret` | Path to JWT secret key. Keys are 32 bytes, hex encoded in a file. A new key will be generated if the file is empty. | `OP_NODE_L2_ENGINE_AUTH` |

### Optional flags

| Flag                                  | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Default                   | Environment variable                        |
| ------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------- | ------------------------------------------- |
| `--altda.da-server`                   | HTTP address of a DA Server                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | —                         | `OP_NODE_ALTDA_DA_SERVER`                   |
| `--altda.da-service`                  | Use DA service type where commitments are generated by Alt-DA server                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `false`                   | `OP_NODE_ALTDA_DA_SERVICE`                  |
| `--altda.enabled`                     | Enable Alt-DA mode Alt-DA Mode is a Beta feature of the MIT licensed OP Stack. While it has received initial review from core contributors, it is still undergoing testing, and may have bugs or other issues.                                                                                                                                                                                                                                                                                                                     | `false`                   | `OP_NODE_ALTDA_ENABLED`                     |
| `--altda.get-timeout`                 | Timeout for get requests. 0 means no timeout.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `0s`                      | `OP_NODE_ALTDA_GET_TIMEOUT`                 |
| `--altda.max-concurrent-da-requests`  | Maximum number of concurrent requests to the DA server                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `1`                       | `OP_NODE_ALTDA_MAX_CONCURRENT_DA_REQUESTS`  |
| `--altda.put-timeout`                 | Timeout for put requests. 0 means no timeout.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `0s`                      | `OP_NODE_ALTDA_PUT_TIMEOUT`                 |
| `--altda.verify-on-read`              | Verify input data matches the commitments from the DA storage service                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `true`                    | `OP_NODE_ALTDA_VERIFY_ON_READ`              |
| `--conductor.enabled`                 | Enable the conductor service                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `false`                   | `OP_NODE_CONDUCTOR_ENABLED`                 |
| `--conductor.rpc`                     | Conductor service rpc endpoint                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `"http://127.0.0.1:8547"` | `OP_NODE_CONDUCTOR_RPC`                     |
| `--conductor.rpc-timeout`             | Conductor service rpc timeout                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `1s`                      | `OP_NODE_CONDUCTOR_RPC_TIMEOUT`             |
| `--experimental.sequencer-api`        | Enables experimental test sequencer RPC functionality                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `false`                   | `OP_NODE_EXPERIMENTAL_SEQUENCER_API`        |
| `--fetch-withdrawal-root-from-state`  | Read withdrawal\_storage\_root (aka message passer storage root) from state trie (via execution layer) instead of the block header. Restores pre-Isthmus behavior, requires an archive EL client.                                                                                                                                                                                                                                                                                                                                  | `false`                   | `OP_NODE_FETCH_WITHDRAWAL_ROOT_FROM_STATE`  |
| `--finality.delay`                    | Number of L1 blocks to traverse before trying to finalize L2 blocks again. Uses default (64) if 0.                                                                                                                                                                                                                                                                                                                                                                                                                                 | `0`                       | `OP_NODE_FINALITY_DELAY`                    |
| `--finality.lookback`                 | Number of L1 blocks to look back for finality verification. Uses default calculation if 0 (considers alt-DA challenge/resolve windows if applicable).                                                                                                                                                                                                                                                                                                                                                                              | `0`                       | `OP_NODE_FINALITY_LOOKBACK`                 |
| `--interop.dependency-set`            | Dependency-set configuration, point at JSON file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | —                         | `OP_NODE_INTEROP_DEPENDENCY_SET`            |
| `--l1.beacon`                         | Address of L1 Beacon-node HTTP endpoint to use.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | —                         | `OP_NODE_L1_BEACON`                         |
| `--l1.beacon-fallbacks`               | Addresses of L1 Beacon-API compatible HTTP fallback endpoints. Used to fetch blob sidecars not available at the l1.beacon (e.g. expired blobs).                                                                                                                                                                                                                                                                                                                                                                                    | —                         | `OP_NODE_L1_BEACON_FALLBACKS`               |
| `--l1.beacon-header`                  | Optional HTTP header to add to all requests to the L1 Beacon endpoint. Format: 'X-Key: Value'                                                                                                                                                                                                                                                                                                                                                                                                                                      | —                         | `OP_NODE_L1_BEACON_HEADER`                  |
| `--l1.beacon.fetch-all-sidecars`      | If true, all sidecars are fetched and filtered locally. Workaround for buggy Beacon nodes.                                                                                                                                                                                                                                                                                                                                                                                                                                         | `false`                   | `OP_NODE_L1_BEACON_FETCH_ALL_SIDECARS`      |
| `--l1.beacon.ignore`                  | When false, halts op-node startup if the healthcheck to the Beacon-node endpoint fails.                                                                                                                                                                                                                                                                                                                                                                                                                                            | `false`                   | `OP_NODE_L1_BEACON_IGNORE`                  |
| `--l1.beacon.slot-duration-override`  | Duration in seconds of an L1 slot. When set (non-zero), bypasses the beacon /eth/v1/config/spec fetch and uses this value as SECONDS\_PER\_SLOT. Useful for devnets where the beacon spec endpoint is unavailable (e.g. anvil).                                                                                                                                                                                                                                                                                                    | `0`                       | `OP_NODE_L1_BEACON_SLOT_DURATION_OVERRIDE`  |
| `--l1.cache-size`                     | Cache size for blocks, receipts and transactions. If this flag is set to 0, 3/2 of the sequencing window size is used (usually 2400). The default value of 900 (\~3h of L1 blocks) is good for (high-throughput) networks that see frequent safe head increments. On (low-throughput) networks with infrequent safe head increments, it is recommended to set this value to 0, or a value that well covers the typical span between safe head increments. Note that higher values will cause significantly increased memory usage. | `900`                     | `OP_NODE_L1_CACHE_SIZE`                     |
| `--l1.epoch-poll-interval`            | Poll interval for retrieving new L1 epoch updates such as safe and finalized block changes. Disabled if 0 or negative.                                                                                                                                                                                                                                                                                                                                                                                                             | `6m24s`                   | `OP_NODE_L1_EPOCH_POLL_INTERVAL`            |
| `--l1.http-poll-interval`             | Polling interval for latest-block subscription when using an HTTP RPC provider. Ignored for other types of RPC endpoints.                                                                                                                                                                                                                                                                                                                                                                                                          | `12s`                     | `OP_NODE_L1_HTTP_POLL_INTERVAL`             |
| `--l1.max-concurrency`                | Maximum number of concurrent RPC requests to make to the L1 RPC provider.                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `10`                      | `OP_NODE_L1_MAX_CONCURRENCY`                |
| `--l1.rpc-max-batch-size`             | Maximum number of RPC requests to bundle, e.g. during L1 blocks receipt fetching. The L1 RPC rate limit counts this as N items, but allows it to burst at once.                                                                                                                                                                                                                                                                                                                                                                    | `20`                      | `OP_NODE_L1_RPC_MAX_BATCH_SIZE`             |
| `--l1.rpc-rate-limit`                 | Optional self-imposed global rate-limit on L1 RPC requests, specified in requests / second. Disabled if set to 0.                                                                                                                                                                                                                                                                                                                                                                                                                  | `0`                       | `OP_NODE_L1_RPC_RATE_LIMIT`                 |
| `--l1.rpckind`                        | The kind of RPC provider, used to inform optimal transactions receipts fetching, and thus reduce costs. Valid options: alchemy, quicknode, infura, parity, nethermind, debug\_geth, erigon, basic, any, standard                                                                                                                                                                                                                                                                                                                   | `standard`                | `OP_NODE_L1_RPC_KIND`                       |
| `--l1.runtime-config-reload-interval` | Poll interval for reloading the runtime config, useful when config events are not being picked up. Disabled if 0 or negative.                                                                                                                                                                                                                                                                                                                                                                                                      | `10m0s`                   | `OP_NODE_L1_RUNTIME_CONFIG_RELOAD_INTERVAL` |
| `--l1.trustrpc`                       | Trust the L1 RPC, sync faster at risk of malicious/buggy RPC providing bad or inconsistent L1 data                                                                                                                                                                                                                                                                                                                                                                                                                                 | `false`                   | `OP_NODE_L1_TRUST_RPC`                      |
| `--l2.engine-rpc-timeout`             | L2 engine client rpc timeout                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `10s`                     | `OP_NODE_L2_ENGINE_RPC_TIMEOUT`             |
| `--l2.enginekind`                     | The kind of engine client, used to control the behavior of optimism in respect to different types of engine clients. Valid options: geth, reth, erigon                                                                                                                                                                                                                                                                                                                                                                             | `reth`                    | `OP_NODE_L2_ENGINE_KIND`                    |
| `--l2.follow.source`                  | Address of L2 CL RPC HTTP endpoint to follow source                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | —                         | `OP_NODE_L2_FOLLOW_SOURCE`                  |
| `--log.color`                         | Color the log output if in terminal mode                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `false`                   | `OP_NODE_LOG_COLOR`                         |
| `--log.format`                        | Format the log output. Supported formats: text, terminal, logfmt, logfmtms, json, jsonms                                                                                                                                                                                                                                                                                                                                                                                                                                           | `text`                    | `OP_NODE_LOG_FORMAT`                        |
| `--log.level`                         | The lowest log level that will be output                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `INFO`                    | `OP_NODE_LOG_LEVEL`                         |
| `--log.pid`                           | Show pid in the log                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `false`                   | `OP_NODE_LOG_PID`                           |
| `--metrics.addr`                      | Metrics listening address                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `"0.0.0.0"`               | `OP_NODE_METRICS_ADDR`                      |
| `--metrics.enabled`                   | Enable the metrics server                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `false`                   | `OP_NODE_METRICS_ENABLED`                   |
| `--metrics.port`                      | Metrics listening port                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `7300`                    | `OP_NODE_METRICS_PORT`                      |
| `--network`                           | Predefined network selection. Available networks: every chain bundled from the [superchain-registry](https://github.com/ethereum-optimism/superchain-registry) at the release; run `op-node --help` for the exact list                                                                                                                                                                                                                                                                                                             | —                         | `OP_NODE_NETWORK`                           |
| `--override.canyon`                   | Manually specify the canyon fork timestamp, overriding the bundled setting                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `0`                       | `OP_NODE_OVERRIDE_CANYON`                   |
| `--override.delta`                    | Manually specify the delta fork timestamp, overriding the bundled setting                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `0`                       | `OP_NODE_OVERRIDE_DELTA`                    |
| `--override.ecotone`                  | Manually specify the ecotone fork timestamp, overriding the bundled setting                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `0`                       | `OP_NODE_OVERRIDE_ECOTONE`                  |
| `--override.fjord`                    | Manually specify the fjord fork timestamp, overriding the bundled setting                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `0`                       | `OP_NODE_OVERRIDE_FJORD`                    |
| `--override.granite`                  | Manually specify the granite fork timestamp, overriding the bundled setting                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `0`                       | `OP_NODE_OVERRIDE_GRANITE`                  |
| `--override.holocene`                 | Manually specify the holocene fork timestamp, overriding the bundled setting                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `0`                       | `OP_NODE_OVERRIDE_HOLOCENE`                 |
| `--override.isthmus`                  | Manually specify the isthmus fork timestamp, overriding the bundled setting                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `0`                       | `OP_NODE_OVERRIDE_ISTHMUS`                  |
| `--override.jovian`                   | Manually specify the jovian fork timestamp, overriding the bundled setting                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `0`                       | `OP_NODE_OVERRIDE_JOVIAN`                   |
| `--override.karst`                    | Manually specify the karst fork timestamp, overriding the bundled setting                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `0`                       | `OP_NODE_OVERRIDE_KARST`                    |
| `--override.keep-karst-upgrade-gas`   | Manually set keep\_karst\_upgrade\_gas, overriding the bundled setting. When true, the Karst activation block's one-time upgrade gas is kept on every later block (for chains that activated Karst with the leak baked into their history).                                                                                                                                                                                                                                                                                        | `false`                   | `OP_NODE_OVERRIDE_KEEP_KARST_UPGRADE_GAS`   |
| `--override.lagoon`                   | Manually specify the lagoon fork timestamp, overriding the bundled setting                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `0`                       | `OP_NODE_OVERRIDE_LAGOON`                   |
| `--override.pectrablobschedule`       | Manually specify the pectrablobschedule fork timestamp, overriding the bundled setting                                                                                                                                                                                                                                                                                                                                                                                                                                             | `0`                       | `OP_NODE_OVERRIDE_PECTRABLOBSCHEDULE`       |
| `--p2p.advertise.ip`                  | The IP address to advertise in Discv5, put into the ENR of the node. This may also be a hostname / domain name to resolve to an IP.                                                                                                                                                                                                                                                                                                                                                                                                | —                         | `OP_NODE_P2P_ADVERTISE_IP`                  |
| `--p2p.advertise.tcp`                 | The TCP port to advertise in Discv5, put into the ENR of the node. Set to p2p.listen.tcp value if 0.                                                                                                                                                                                                                                                                                                                                                                                                                               | `0`                       | `OP_NODE_P2P_ADVERTISE_TCP`                 |
| `--p2p.advertise.udp`                 | The UDP port to advertise in Discv5 as fallback if not determined by Discv5, put into the ENR of the node. Set to p2p.listen.udp value if 0.                                                                                                                                                                                                                                                                                                                                                                                       | `0`                       | `OP_NODE_P2P_ADVERTISE_UDP`                 |
| `--p2p.ban.duration`                  | The duration that peers are banned for.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `1h0m0s`                  | `OP_NODE_P2P_PEER_BANNING_DURATION`         |
| `--p2p.ban.peers`                     | Enables peer banning.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `true`                    | `OP_NODE_P2P_PEER_BANNING`                  |
| `--p2p.ban.threshold`                 | The minimum score below which peers are disconnected and banned.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `-100`                    | `OP_NODE_P2P_PEER_BANNING_THRESHOLD`        |
| `--p2p.bootnodes`                     | Comma-separated base64-format ENR list. Bootnodes to start discovering other node records from.                                                                                                                                                                                                                                                                                                                                                                                                                                    | —                         | `OP_NODE_P2P_BOOTNODES`                     |
| `--p2p.disable`                       | Completely disable the P2P stack                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `false`                   | `OP_NODE_P2P_DISABLE`                       |
| `--p2p.discovery.path`                | Discovered ENRs are persisted in a database to recover from a restart without having to bootstrap the discovery process again. Set to 'memory' to never persist the peerstore.                                                                                                                                                                                                                                                                                                                                                     | `"opnode_discovery_db"`   | `OP_NODE_P2P_DISCOVERY_PATH`                |
| `--p2p.gossip.timestamp.threshold`    | Threshold for rejecting gossip messages with payload timestamps older than this duration. Default is 60 seconds.                                                                                                                                                                                                                                                                                                                                                                                                                   | `1m0s`                    | `OP_NODE_P2P_GOSSIP_TIMESTAMP_THRESHOLD`    |
| `--p2p.listen.ip`                     | IP to bind LibP2P and Discv5 to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `"0.0.0.0"`               | `OP_NODE_P2P_LISTEN_IP`                     |
| `--p2p.listen.tcp`                    | TCP port to bind LibP2P to. Any available system port if set to 0.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `9222`                    | `OP_NODE_P2P_LISTEN_TCP_PORT`               |
| `--p2p.listen.udp`                    | UDP port to bind Discv5 to. Same as TCP port if left 0.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `0`                       | `OP_NODE_P2P_LISTEN_UDP_PORT`               |
| `--p2p.nat`                           | Enable NAT traversal with PMP/UPNP devices to learn external IP.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `false`                   | `OP_NODE_P2P_NAT`                           |
| `--p2p.netrestrict`                   | Comma-separated list of CIDR masks. P2P will only try to connect on these networks                                                                                                                                                                                                                                                                                                                                                                                                                                                 | —                         | `OP_NODE_P2P_NETRESTRICT`                   |
| `--p2p.no-discovery`                  | Disable Discv5 (node discovery)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `false`                   | `OP_NODE_P2P_NO_DISCOVERY`                  |
| `--p2p.peers.grace`                   | Grace period to keep a newly connected peer around, if it is not misbehaving.                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `30s`                     | `OP_NODE_P2P_PEERS_GRACE`                   |
| `--p2p.peers.hi`                      | High-tide peer count. The node starts pruning peer connections slowly after reaching this number.                                                                                                                                                                                                                                                                                                                                                                                                                                  | `30`                      | `OP_NODE_P2P_PEERS_HI`                      |
| `--p2p.peers.lo`                      | Low-tide peer count. The node actively searches for new peer connections if below this amount.                                                                                                                                                                                                                                                                                                                                                                                                                                     | `20`                      | `OP_NODE_P2P_PEERS_LO`                      |
| `--p2p.peerstore.path`                | Peerstore database location. Persisted peerstores help recover peers after restarts. Set to 'memory' to never persist the peerstore. Peerstore records will be pruned / expire as necessary. Warning: a copy of the priv network key of the local peer will be persisted here.                                                                                                                                                                                                                                                     | `"opnode_peerstore_db"`   | `OP_NODE_P2P_PEERSTORE_PATH`                |
| `--p2p.priv.path`                     | Read the hex-encoded 32-byte private key for the peer ID from this txt file. Created if not already exists.Important to persist to keep the same network identity after restarting, maintaining the previous advertised identity.                                                                                                                                                                                                                                                                                                  | `"opnode_p2p_priv.txt"`   | `OP_NODE_P2P_PRIV_PATH`                     |
| `--p2p.scoring`                       | Sets the peer scoring strategy for the P2P stack. Can be one of: none or light.                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `"light"`                 | `OP_NODE_P2P_PEER_SCORING`                  |
| `--p2p.sequencer.key`                 | Hex-encoded private key for signing off on p2p application messages as sequencer.                                                                                                                                                                                                                                                                                                                                                                                                                                                  | —                         | `OP_NODE_P2P_SEQUENCER_KEY`                 |
| `--p2p.static`                        | Comma-separated multiaddr-format peer list. Static connections to make and maintain, these peers will be regarded as trusted. Addresses of the local peer are ignored. Duplicate/Alternative addresses for the same peer all apply, but only a single connection per peer is maintained.                                                                                                                                                                                                                                           | —                         | `OP_NODE_P2P_STATIC`                        |
| `--p2p.sync.req-resp`                 | Enables the P2P req-resp sync server, which serves payloads-by-number to peers that request them. The client side has been removed; the server will be deprecated in a future release in favor of EL P2P sync.                                                                                                                                                                                                                                                                                                                     | `true`                    | `OP_NODE_P2P_SYNC_REQ_RESP`                 |
| `--pprof.addr`                        | pprof listening address                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `"0.0.0.0"`               | `OP_NODE_PPROF_ADDR`                        |
| `--pprof.enabled`                     | Enable the pprof server                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `false`                   | `OP_NODE_PPROF_ENABLED`                     |
| `--pprof.path`                        | pprof file path. If it is a directory, the path is \{dir}/\{profileType}.prof                                                                                                                                                                                                                                                                                                                                                                                                                                                      | —                         | `OP_NODE_PPROF_PATH`                        |
| `--pprof.port`                        | pprof listening port                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `6060`                    | `OP_NODE_PPROF_PORT`                        |
| `--pprof.type`                        | pprof profile type. One of cpu, heap, goroutine, threadcreate, block, mutex, allocs                                                                                                                                                                                                                                                                                                                                                                                                                                                | —                         | `OP_NODE_PPROF_TYPE`                        |
| `--rollup.config`                     | Rollup chain parameters                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | —                         | `OP_NODE_ROLLUP_CONFIG`                     |
| `--rollup.l1-chain-config`            | Path to .json file with the chain configuration for the L1, either in the direct format or genesis.json format (i.e. embedded under the .config property). Not necessary / will be ignored if using Ethereum mainnet or Sepolia as an L1.                                                                                                                                                                                                                                                                                          | —                         | `OP_NODE_ROLLUP_L1_CHAIN_CONFIG`            |
| `--rpc.addr`                          | rpc listening address                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `"0.0.0.0"`               | `OP_NODE_RPC_ADDR`                          |
| `--rpc.admin-state`                   | File path used to persist state changes made via the admin API so they persist across restarts. Disabled if not set.                                                                                                                                                                                                                                                                                                                                                                                                               | —                         | `OP_NODE_RPC_ADMIN_STATE`                   |
| `--rpc.enable-admin`                  | Enable the admin API                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `false`                   | `OP_NODE_RPC_ENABLE_ADMIN`                  |
| `--rpc.port`                          | rpc listening port                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `9545`                    | `OP_NODE_RPC_PORT`                          |
| `--safedb.path`                       | File path used to persist safe head update data. Disabled if not set.                                                                                                                                                                                                                                                                                                                                                                                                                                                              | —                         | `OP_NODE_SAFEDB_PATH`                       |
| `--sequencer.enabled`                 | Enable sequencing of new L2 blocks. A separate batch submitter has to be deployed to publish the data for verifiers.                                                                                                                                                                                                                                                                                                                                                                                                               | `false`                   | `OP_NODE_SEQUENCER_ENABLED`                 |
| `--sequencer.l1-confs`                | Number of L1 blocks to keep distance from the L1 head as a sequencer for picking an L1 origin.                                                                                                                                                                                                                                                                                                                                                                                                                                     | `4`                       | `OP_NODE_SEQUENCER_L1_CONFS`                |
| `--sequencer.max-safe-lag`            | Maximum number of L2 blocks for restricting the distance between L2 safe and unsafe. Disabled if 0.                                                                                                                                                                                                                                                                                                                                                                                                                                | `0`                       | `OP_NODE_SEQUENCER_MAX_SAFE_LAG`            |
| `--sequencer.recover`                 | Forces the sequencer to strictly prepare the next L1 origin and create empty L2 blocks                                                                                                                                                                                                                                                                                                                                                                                                                                             | `false`                   | `OP_NODE_SEQUENCER_RECOVER`                 |
| `--sequencer.sealing-duration`        | This is the amount of the time the sequencer allocates to sealing the block (i.e. it will fetch the payload from the execution engine this much prior to the block's timestamp). If this is \<= 0 it is automatically adjusted to 50ms.                                                                                                                                                                                                                                                                                            | `50ms`                    | `OP_NODE_SEQUENCER_SEALING_DURATION`        |
| `--sequencer.stopped`                 | Initialize the sequencer in a stopped state. The sequencer can be started using the admin\_startSequencer RPC                                                                                                                                                                                                                                                                                                                                                                                                                      | `false`                   | `OP_NODE_SEQUENCER_STOPPED`                 |
| `--signer.address`                    | Address the signer is signing requests for                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | —                         | `OP_NODE_SIGNER_ADDRESS`                    |
| `--signer.endpoint`                   | Signer endpoint the client will connect to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | —                         | `OP_NODE_SIGNER_ENDPOINT`                   |
| `--signer.header`                     | Headers to pass to the remote signer. Format `key=value`. Value can contain any character allowed in a HTTP header. When using env vars, split with commas. When using flags one key value pair per flag.                                                                                                                                                                                                                                                                                                                          | —                         | `OP_NODE_SIGNER_HEADER`                     |
| `--signer.tls.ca`                     | tls ca cert path                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `"tls/ca.crt"`            | `OP_NODE_SIGNER_TLS_CA`                     |
| `--signer.tls.cert`                   | tls cert path                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `"tls/tls.crt"`           | `OP_NODE_SIGNER_TLS_CERT`                   |
| `--signer.tls.enabled`                | Enable or disable TLS client authentication for the signer                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `true`                    | `OP_NODE_SIGNER_TLS_ENABLED`                |
| `--signer.tls.key`                    | tls key                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `"tls/tls.key"`           | `OP_NODE_SIGNER_TLS_KEY`                    |
| `--syncmode`                          | Blockchain sync mode (options: consensus-layer, execution-layer)                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `consensus-layer`         | `OP_NODE_SYNCMODE`                          |
| `--syncmode.offset-el-safe`           | After execution-layer sync completes, set safe and finalized heads to this duration behind the synced tip (converted to L2 blocks via rollup block time using ceiling division). Default 12h, matching the OP Mainnet sequencing window.                                                                                                                                                                                                                                                                                           | `12h0m0s`                 | `OP_NODE_SYNCMODE_OFFSET_EL_SAFE`           |
| `--verifier.l1-confs`                 | Number of L1 blocks to keep distance from the L1 head before deriving L2 data from. Reorgs are supported, but may be slow to perform.                                                                                                                                                                                                                                                                                                                                                                                              | `0`                       | `OP_NODE_VERIFIER_L1_CONFS`                 |

## Notes on selected flags

### network and rollup.config

In addition to the required flags above, the op-node must be told which chain
it serves: set exactly one of `--network` (a chain bundled from the
superchain-registry, e.g. `op-mainnet`) or `--rollup.config` (a rollup
configuration file, for custom chains). Setting both, or neither, is a startup
error.

### l1.trustrpc

<Info>
  If you're running an Erigon Ethereum execution client for your L1 provider
  you will need to include `--l1.trustrpc`. At the time of writing, Erigon
  doesn't support the `eth_getProof` method that op-node prefers to use to
  load L1 data for some processing. The trustrpc flag makes it use something
  else that Erigon supports, but the op-node can't verify for correctness.
</Info>

### syncmode.offset-el-safe

Only effective with `--syncmode=execution-layer`. After execution-layer sync
completes, the safe and finalized heads are set to this duration behind the
synced tip (converted to L2 blocks using the rollup block time). The default
`12h` matches the OP Mainnet sequencing window.

Setting this to `0` leaves safe and finalized at the synced tip. This is
**not recommended and is dangerous**: the offset ensures the node does not
label the EL-sync tip as safe/finalized until L1 has had time to confirm it.
With `0`, an EL-sync tip that later turns out to be on a reorged
(non-canonical) branch can be marked safe/finalized, and safe/finalized are
not supposed to reorg. Fix a body-pruning mismatch by enlarging the EL's
retained body window instead — see the warning below.

<Warning>
  op-node reads the L1-info deposit transaction from the block body at the
  head placed this far behind the tip, so the execution client must retain
  block bodies at least this far back. Body pruning (op-reth's `--minimal`
  mode or `--prune.bodies.distance`) is unsupported; if you enable it anyway,
  keep the retained body window comfortably larger than this offset (in
  blocks), or EL sync fails with `l2 block is missing L1 info deposit tx`.
  See [Pruning op-reth](/node-operators/guides/management/archive-node#pruning-op-reth).
</Warning>

### sequencer.l1-confs

<Warning>
  The maximum value for `sequencer.l1-confs` cannot exceed the sequencer
  drift, currently set to 30 minutes (1800 seconds or 150 blocks). Setting a
  value higher than this limit will prevent the sequencer from producing
  blocks within the sequence window.
</Warning>

### verifier.l1-confs

<Info>
  While `verifier.l1-confs` has no strict limit, it's recommended to keep this
  value within 12-13 minutes (typically 10-20 blocks) for optimal performance.
  Exceeding this range may impact the verifier's data processing efficiency.
</Info>

### altda.\*

The `altda.*` flags configure Alt-DA mode, a Beta feature of the OP Stack.
While it has received initial review from core contributors, it is still
undergoing testing, and may have bugs or other issues. See the
[Alt-DA mode guide](/chain-operators/guides/features/alt-da-mode-guide) for
setup instructions.

### interop.\*

The `interop.*` flags configure OP Stack interop networks. Interop is a highly
experimental feature; the flags apply only to interop-enabled networks. Do not
enable the interop RPC (`--interop.rpc.addr`) if you do not run a supervisor
service.

### version

<Info>
  Nodes built from source do not output the correct version numbers that are
  reported on the GitHub release page.
</Info>

## Node log levels

Node log levels determine the verbosity of log messages, allowing operators to filter messages based on importance and detail. The log levels for the `op-node` (used in Optimism)
are as follows:

1. Silent (0): No log messages are displayed. This level is rarely used as it provides
   no feedback on the node's status.

2. Error (1): Only error messages are displayed. Use this level to focus on critical
   issues that need immediate attention.

3. Warn (2): Displays error messages and warnings. This level helps to identify
   potential problems that might not be immediately critical but require attention.

4. Info (3): Displays error messages, warnings, and normal activity logs. This is the
   default level and provides a balanced view of the node's operations without being too
   verbose.

5. Debug (4): All info-level messages plus additional debugging information. Use this
   level when troubleshooting issues or developing the node software.

6. Detail (5): The most verbose level, including detailed debugging information and
   low-level system operations. This level generates a large amount of log data and is
   typically used only for in-depth troubleshooting.

To set the log level, use the `--log.level` flag when running the `op-node` command. For
example, to set the log level to debug:

```bash theme={null}
op-node --log.level=debug
```

By adjusting the log level, operators can control the amount and type of information that
gets logged, helping to manage log data volume and focus on relevant details during
different operational scenarios.
