Run a Validator Node

This guide walks you through running your own RP1 validator node on the testnet. You do not need to build anything from source — everything runs through a single Docker image.

Before you start

You need:

A machine with at least 4 CPU cores, 8 GB RAM, and 100 GB of free disk space
A public IP address that other nodes on the internet can reach (a VPS or cloud server works well; a home connection may require port forwarding)
Docker and Docker Compose installed
Port 26656 open and reachable from the internet on your machine (this is required for validator consensus)

To check your public IP at any time, run:

curl ifconfig.me

Step 1 — Create your workspace

Create a folder for your validator data and a docker-compose.yml file inside it.

mkdir my-validator
cd my-validator

Create docker-compose.yml with the following content. This is the setup configuration — it keeps the container running without starting the node yet, so you can initialize it first.

services:
  rp1d:
    image: northroomza/rp1-chain-distrub:latest
    container_name: rp1d
    ports:
      - "26657:26657"
      - "26656:26656"
    volumes:
      - ./rp1d-data:/root/
    entrypoint: ["sh", "-c", "sleep 10000"]

Start the setup container:

docker compose up -d

Step 2 — Create your validator key

Your validator key is how you sign transactions and identify yourself on the network. Run this command to create one:

docker exec -it rp1d rp1d keys add my-validator --keyring-backend test

The output will show you a mnemonic phrase (24 words) and your rp1 address.

Write down the 24-word mnemonic and store it somewhere safe. If you lose it, you cannot recover your key. Your address will look like rp1abc123....

If you already have a key from a previous setup, recover it instead:

docker exec -it rp1d rp1d keys add my-validator --recover --keyring-backend test

To see your address at any time:

docker exec rp1d rp1d keys show my-validator --keyring-backend test -a

Step 3 — Fund your account

Your validator needs testnet tokens to pay for the transaction fees when joining, and to stake as self-delegation.

Copy your rp1... address from the previous step
Go to https://docs.rp.one/wallet/faucet and claim testnet tokens

After claiming, you can verify your balance:

docker exec rp1d rp1d query bank balances $(docker exec rp1d rp1d keys show my-validator --keyring-backend test -a) --node https://testnet.rpc.rp.one

Step 4 — Join the testnet

This command does two things at once: it configures your node with the testnet genesis and settings, and it submits the on-chain transactions to register you as a validator candidate.

Replace YOUR_PUBLIC_IP with your machine’s actual public IP address (from curl ifconfig.me), and replace My Validator Name with whatever you want to call your validator.

docker exec -it rp1d rp1d testnet join \
  --bootstrap-url https://testnet.chain.rp.one/bootstrap.json \
  --consensus.listen-addr 0.0.0.0:26656 \
  --consensus.advertise-addr YOUR_PUBLIC_IP:26656 \
  --from my-validator \
  --keyring-backend test \
  --moniker "My Validator Name" \
  --self-delegation 100urp1 \
  --node https://testnet.rpc.rp.one

If successful, you will see two transaction hashes — one for create-validator and one for register-consensus-endpoint.

Common reasons this fails:

Account not funded — go back to Step 3
YOUR_PUBLIC_IP was not replaced — double-check the command
Port 26656 is blocked by a firewall — open it in your server’s firewall settings

Step 5 — Switch to the running configuration

Stop the setup container:

docker compose down

Edit your docker-compose.yml and remove the entrypoint line. Your final configuration should look like this:

services:
  rp1d:
    image: northroomza/rp1-chain-distrub:latest
    container_name: rp1d
    ports:
      - "26657:26657"
      - "26656:26656"
    volumes:
      - ./rp1d-data:/root/
    restart: unless-stopped

Start your node:

docker compose up -d

Your node will begin syncing from the chain. This may take a few minutes. See State Sync if you want to sync faster.

Step 6 — Check your node

Check that your node is running and syncing:

docker exec rp1d rp1d status

Look for "catching_up": false in the output — this means your node has fully synced and is up to date with the chain.

To watch your node’s logs in real time:

docker compose logs -f

How validator admission works

After joining, your node goes through an automatic admission process before it can participate in consensus:

Your node syncs and runs as an observer — it follows the chain but does not produce blocks yet
Active validators check that your consensus endpoint (YOUR_PUBLIC_IP:26656) is reachable over the network
After one full epoch (100 blocks), if your endpoint was consistently reachable, you are promoted to the active validator set
Your node will then begin participating in block production

Default admission parameters:

Parameter	Value
Epoch length	100 blocks
Required reachability	more than 2/3 of validators must reach you
Max active validators	32
Ejection after	2 consecutive bad epochs

Keeping your node running

Your docker-compose.yml includes restart: unless-stopped, which means Docker will automatically restart your node if it crashes or if your server reboots.

To stop your node manually:

docker compose down

To update to a new version of the node software:

docker compose down
docker compose pull
docker compose up -d

Troubleshooting

Join command ran but no transactions were submitted

Check that you included --from my-validator and --keyring-backend test. Without --from, the command only sets up the config files and does not send any transactions.

Transactions fail with “account not found” or insufficient funds

Your account is not funded. Complete Step 3 before running the join command.

Candidate never becomes active

Check:

The join command completed without errors and both transactions were confirmed
YOUR_PUBLIC_IP:26656 is publicly reachable — test from another machine or use a port-check website
Your node has been running continuously since joining; downtime during the admission epoch resets the counter

Node is stuck and not syncing

Check your logs:

docker compose logs --tail 50

If you see connection errors, your node may not have peers. Restarting often helps:

docker compose restart

Lost your key mnemonic

Your key data is stored in ./rp1d-data/.rp1/keyring-test/. As long as this folder exists on your machine, your key is safe. If you need to move to a new server, copy the entire ./rp1d-data/ folder.