Node Operations on Sei

Deploy and maintain Sei Network infrastructure with comprehensive guides for validators, RPC nodes, and archive nodes, including hardware requirements, installation steps, and operational best practices.

Power the Sei network infrastructure

These guides show how to run, maintain, and optimize Sei network nodes. Whether you set up a validator, an RPC node, or an archive node, they give detailed instructions and best practices for performance and security.

RPC/API nodes

Validator nodes

State sync nodes

Archive nodes

Network versions

For live binary versions, genesis, and seed peers, see the technical reference.

Hardware requirements

Component	Required
CPU	16 cores (Intel Xeon/Core i7/i9 or AMD Epyc/Ryzen)
RAM	256 GB DDR5 or better
Storage	2 TB NVMe SSD (high IOPS required)
Network	2 Gbps with low latency

Installation & setup steps

1. Environment setup

   System preparation

   1. Update and upgrade system

   sudo apt update && sudo apt upgrade -y
   

   2. Install essential packages

   sudo apt install make gcc git jq chrony curl lz4 wget tar build-essential -y
   

   3. Synchronize system time

   sudo timedatectl set-timezone UTC
   sudo systemctl enable --now chronyd
   timedatectl
   

   Install Go

   You need Go only if you build seid from source. The prebuilt binary and Docker install paths in the next step do not require it.

   Current seid releases require Go 1.25.6 or later. For the exact requirement, check the go.mod at the release tag that you check out (for example, v6.6.1).

   Installation steps

   # Check for existing Go installations — more than one entry means another copy
   # may still win on your PATH after this install
   which -a go
   go version
   
   # Bumping Go? Change these two lines only
   GO_TARBALL=go1.25.6.linux-amd64.tar.gz
   GO_SHA256=f022b6aad78e362bcba9b0b94d09ad58c5a70c6ba3b7582905fababf5fe0181a
   
   curl -fLO https://go.dev/dl/${GO_TARBALL}
   
   # Verify integrity before trusting the archive (go.dev/dl publishes a SHA256 per file
   # at ${GO_TARBALL}.sha256), then replace any previous installation — extracting over
   # one leaves stale files behind
   echo "${GO_SHA256}  ${GO_TARBALL}" | sha256sum -c - \
     && sudo rm -rf /usr/local/go \
     && sudo tar -C /usr/local -xzf ${GO_TARBALL}
   
   # Add Go to your environment variables
   echo 'export PATH=$PATH:/usr/local/go/bin' >> $HOME/.bashrc
   source $HOME/.bashrc
   
   # Verify installation
   go version
   

   sudo rm -rf /usr/local/go is the replacement step that Go’s install docs prescribe. It clears only a tarball install. A package-manager Go (/usr/lib/go-*, Homebrew) survives it and can still shadow /usr/local/go/bin/go. If the final go version reports the old release, which -a go lists every copy on your PATH. If the extraction itself fails, the verified tarball is still in your working directory. Re-run the sudo tar command instead of starting over.

2. Install Sei

   Install the seid binary

   For the current recommended version, see the Network Versions table above.

   Prebuilt binary (recommended)

   Each release attaches a statically linked seid build for linux/amd64 with no runtime dependencies. You do not need to install a Go toolchain or shared libraries.

   VERSION=<version-tag>  # e.g. v6.6.1 — see the Network Versions table above
   FILE=sei-chain_${VERSION#v}_linux_x86_64.tar.gz  # asset filenames omit the leading v
   
   curl -fLO https://github.com/sei-protocol/sei-chain/releases/download/${VERSION}/${FILE}
   curl -fLO https://github.com/sei-protocol/sei-chain/releases/download/${VERSION}/checksums.txt
   
   # Verify integrity before trusting the binary; extract and install only if it passes
   sha256sum -c checksums.txt --ignore-missing \
     && tar -xzf ${FILE} seid \
     && sudo install -m 0755 seid /usr/local/bin/seid
   
   # Verify installation
   seid version
   

   Prebuilt binaries are attached from v6.6.1 onward. For earlier versions, build from source or use Docker. Prebuilt binaries are linux/amd64 only and do not include hardware Ledger support. On other architectures, or if you sign with a Ledger device, build from source or use Docker.

   If you are switching from a previous make install build, remove the old copy (rm -f "$(go env GOPATH)/bin/seid"). Alternatively, make sure that your service unit points at /usr/local/bin/seid. The which -a seid command lists every copy on your PATH.

   Build from source

   This method requires Go and a C toolchain (see the Environment Setup step above).

   # Clone repository and install
   git clone https://github.com/sei-protocol/sei-chain.git
   cd sei-chain
   git checkout <version-tag>  # Replace with specific version
   make install
   
   # Verify installation
   seid version
   

   If you get an error like command not found: seid, you may need to set your GOPATH environment variable.

   Add these lines to your ~/.bashrc or ~/.zshrc:

   export GOPATH=$(go env GOPATH)
   export PATH=$PATH:$GOPATH/bin
   

   Then reload your shell with source ~/.bashrc or source ~/.zshrc.

   For more information, see the Go documentation for GOPATH.

   Docker

   Official Docker images are available in the GitHub Container Registry.

   # Pull the latest version
   docker pull ghcr.io/sei-protocol/sei:latest
   
   # Or pull a specific version (recommended)
   docker pull ghcr.io/sei-protocol/sei:v6.3.1
   

   Available architectures: linux/amd64 and linux/arm64.

   Never use the testing-only image variants in production. Sei’s continuous integration (CI) pipelines publish these variants to an internal registry. They are not available on ghcr.io. The variants are compiled with special Go build tags:

   • mock-*: built with the mock_balances build tag. It mocks account balances.
   • mock_block_validation-*: bypasses AppHash and DataHash block validation.
   • mock_chain_validation-*: swallows most halting consensus validation failures (every swallow-eligible check except ErrLastCommitVerify). It computes each check authentically but continues instead of halting. It is built with both the mock_balances and mock_chain_validation Go build tags. Nodes that run these non-default consensus policies emit a sei_unsafe_validation_skipped_total counter (attribute validation_error) each time a failure is swallowed. On production policies, the counter never increments.

   Production images are built with full validation enabled. The mock_block_validation and mock_chain_validation variants are intended only for testing environments that require relaxed validation checks. Running either variant on a production network is unsafe.

   Initialize chain files

   The default init mode is full, in which RPC and P2P bind to all interfaces. For validator or seed nodes, use --mode validator or --mode seed. In these modes, RPC and P2P bind to localhost only. For the full validator init example, see the Validator Operations Guide.

   You can find peers here:

   • Sei Mainnet (pacific-1):

   • Sei Testnet (atlantic-2):

   # Initialize node (default mode is full: RPC/P2P bind to all interfaces)
   # --chain-id is required, e.g. pacific-1 or atlantic-2
   # For validator nodes, use: seid init <your-moniker> --chain-id <chain-id> --mode validator
   seid init <your-moniker> --chain-id <chain-id>
   
   # Genesis is written automatically for known networks (mainnet and testnets); no download needed.
   
   # For known public networks (pacific-1, atlantic-2), seid init also pre-populates
   # bootstrap-peers in config.toml with the built-in Sei Labs seed nodes, so peer
   # discovery works with no manual configuration. Devnets (arctic-1) and
   # unknown/private chains get none, and any bootstrap-peers value you already set
   # is never overwritten.
   
   # Optionally configure additional persistent peers in config.toml.
   PEERS="<comma-separated-peer-list>"
   
   #Set persistent peers in config.toml
   sed -i 's/persistent-peers = .*/persistent-peers = "'$PEERS'"/' ~/.sei/config/config.toml
   

   Configure app settings

   # Set minimum gas price (recommended; helps prevent spam transactions)
   # Mainnet enforces a chain-wide minimum of 0.02usei, so set at least that value
   # Use "0usei" only for local development or private networks
   sed -i -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"0.02usei\"/" $HOME/.sei/config/app.toml
   
   # Tune mempool settings
   sed -i \
     -e 's/^keep-invalid-txs-in-cache = .*/keep-invalid-txs-in-cache = true/' \
     -e 's/^ttl-duration = .*/ttl-duration = "5s"/' \
     -e 's/^ttl-num-blocks = .*/ttl-num-blocks = 5/' \
     $HOME/.sei/config/config.toml
   
   # Set Concurrent Workers to 500 and enable occ
   sed -i -e "s/^#concurrency-workers *=.*/concurrency-workers = 500/" $HOME/.sei/config/app.toml
   sed -i -e "s/^occ-enabled *=.*/occ-enabled = true/" $HOME/.sei/config/app.toml
   

   If you run an archive node, use this command to set ss-keep-recent = 0 in your state-store settings:

   sed -i 's/^ss-keep-recent = [0-9]*/ss-keep-recent = 0/' ~/.sei/config/app.toml
   

   Advanced configuration

   Archive node setup

   An archive node keeps the complete historical record of the chain. To run one, you must disable state sync and start from a pre-existing database (a snapshot).

   1. Disable state sync: In $HOME/.sei/config/config.toml, modify the [statesync] section:

   # State sync configuration
   [statesync]
   enable = false
   

   2. Configure archive node peers: To sync from the height at which your snapshot was created, you need peers that keep many historical blocks. During the initial sync, the node needs these specific peers. You can change them later.

   Mempool configuration

   For optimal transaction handling and resource management, update the mempool settings in your config.toml file.

   If you have performance or resource issues on your hardware, adjust these parameters.

   # Mempool configuration settings
   [mempool]
   
   # Broadcast transactions to other nodes
   broadcast = true
   
   # Maximum number of transactions in the mempool
   size = 5000
   
   # Limit the total size of all txs in the mempool.
   max-txs-bytes = 1073741824
   
   # Size of the cache (used to filter duplicate transactions)
   cache-size = 10000
   
   # Do not remove invalid transactions from the cache
   keep-invalid-txs-in-cache = true
   
   # Maximum size of a single transaction
   max-tx-bytes = 2048576
   
   # Maximum size of a batch of transactions to send to a peer
   max-batch-bytes = 0
   
   # Maximum length of time a transaction can remain in the mempool.
   # Zero (or unset) disables TTL purging entirely — see the mempool TTL
   # note in Node Operators before changing these.
   ttl-duration = "5s"
   
   # Maximum number of blocks a transaction can remain in the mempool
   ttl-num-blocks = 10
   
   tx-notify-threshold = 0
   
   check-tx-error-blacklist-enabled = true
   
   check-tx-error-threshold = 50
   
   pending-size = 5000
   
   max-pending-txs-bytes = 1073741824
   
   # Deprecated: these fields no longer have any effect and are ignored.
   pending-ttl-duration = "0s"
   pending-ttl-num-blocks = 0
   

   pending-ttl-duration and pending-ttl-num-blocks are deprecated and have no effect. They are ignored, whatever value you set.

3. Run node

   Setting up a systemd service

   If you see an error such as panic: recovered: runtime error: integer divide by zero, it means that you cannot start nodes directly from the genesis file. Instead, sync to the block tip with state sync or a snapshot.

   For production deployments, configure a systemd service so that your node restarts automatically:

   # Create the systemd service file
   sudo tee /etc/systemd/system/seid.service > /dev/null << EOF
   [Unit]
   Description=Sei Node
   After=network-online.target
   
   [Service]
   User=$USER
   ExecStart=$(which seid) start
   Restart=always
   RestartSec=3
   LimitNOFILE=65535
   
   [Install]
   WantedBy=multi-user.target
   EOF
   
   # Reload systemd, enable and start the service
   sudo systemctl daemon-reload
   sudo systemctl enable seid
   sudo systemctl start seid
   

   Monitoring & troubleshooting

   Check your node’s status with these commands:

   # Check sync status
   seid status
   
   # Monitor logs in real-time
   journalctl -u seid -f -o cat
   
   # Check validator status (if running a validator)
   seid query staking validator $(seid keys show <your_key> --bech val -a)
   

   Common issues & solutions

   Sync issues

   • Verify that you have enough disk space
   • Make sure that the network connection is stable
   • Confirm that the system time is synchronized
   • Consider using state sync for the initial setup

   Performance problems

   • Monitor system resources (CPU, RAM, I/O)
   • Evaluate disk performance and network bandwidth
   • Adjust mempool and peer settings if needed

View the complete node setup guide

Node resources

Node setup

Node operations guide

Complete guide to setting up and running a Sei node, with hardware requirements and configuration steps.

Validator operations guide

Specialized instructions for validators, including staking, commission settings, and security best practices.

Default configurations

Full reference for the app.toml, config.toml, and client.toml files from the latest seid release.

Advanced operations

Configuration & monitoring

Optimize your node’s performance with advanced settings and monitoring tools.

Giga SS store migration

Move EVM historical state into dedicated state-store databases on supported RPC nodes.

Technical reference

Detailed technical specifications, API endpoints, and commands for node operators.