Skip to main content
This page covers the go-livepeer flags needed to run as an Orchestrator. By the end, a working startup command is ready and each flag is understood. Prerequisites:
  • go-livepeer installed and GPU detected. See .
  • Arbitrum wallet with ETH for gas. See .
  • The hardware session limit number from the livepeer_bench test in .

Essential Flags

These flags must be set every time go-livepeer starts as an Orchestrator.
1

Set the network

-network arbitrum-one-mainnet
Tells go-livepeer which network to connect to. The default is offchain - without this flag the node does not participate in the Livepeer protocol at all.Options:
  • arbitrum-one-mainnet - production network
  • offchain - local or dev only, no on-chain participation
2

Connect to Arbitrum RPC

-ethUrl <YOUR_ARBITRUM_RPC_URL>
Points go-livepeer at an Arbitrum One RPC endpoint to read and write on-chain state - Orchestrator registration, reward calls, ticket redemption.
-ethUrl https://arb-mainnet.g.alchemy.com/v2/YOUR_API_KEY
This must be an Arbitrum One endpoint, not an Ethereum L1 endpoint. See for how to set up a reliable RPC.
3

Set the Ethereum account (optional)

-ethAcctAddr <YOUR_ETH_ADDRESS>
Specifies which ETH account acts as the Orchestrator identity on the network. This account holds staked LPT, receives ETH fee payments, and signs on-chain transactions.If omitted, go-livepeer creates a new account and prompts for a passphrase to encrypt the keystore. The key is stored at ~/.lpData/arbitrum-one-mainnet/keystore by default.
The private key controls the wallet and all funds on it. Back it up securely before proceeding. A lost keystore cannot be recovered.
4

Enable Orchestrator and Transcoder mode

-orchestrator -transcoder
-orchestrator enables the on-chain protocol role - the node participates in job routing, makes reward calls, and is visible to Gateways.-transcoder enables local GPU transcoding - the node processes jobs using its GPU.Use both together for the standard combined setup where one machine handles all roles. For alternate configurations:See for the O-T split and Siphon configurations.
5

Select the GPU

-nvidia <GPU_IDs>
Specifies which NVIDIA GPUs go-livepeer uses for transcoding. Omitting this flag falls back to CPU transcoding, which is significantly slower and not competitive on the network.
-nvidia 0        # Single GPU - device ID 0
-nvidia 0,1      # Two GPUs
-nvidia all      # All available GPUs
Check GPU IDs before starting:
nvidia-smi -L
For AI-only operation (no video transcoding), -transcoder is not required but -nvidia is still needed to expose the GPU to AI runner containers. See Adding AI inference below.
6

Set the session limit

-maxSessions <VALUE>
Sets the maximum concurrent transcoding sessions the node accepts. The default is 10. Set it to the minimum of the hardware limit and the bandwidth limit.Hardware limit: the last session count from the livepeer_bench test in where Real-Time Duration Ratio was ≤ 0.8.Bandwidth limit: available symmetric bandwidth (Mbps) ÷ 6 Mbps per stream × 0.8 margin.
session limit = min(hardware limit, bandwidth limit)
Example: hardware limit 12, bandwidth 100 Mbps → bandwidth limit ~13 → use -maxSessions 12.
-maxSessions applies to video transcoding only. AI inference capacity is controlled per pipeline by the capacity field in aiModels.json. See Adding AI inference below.
7

Set the price

-pricePerUnit <VALUE_IN_WEI>
Sets the price charged per unit of transcoding work. The unit is wei per pixel, not ETH.
  • 1 ETH = 1,000,000,000,000,000,000 wei
  • A typical starting price is 500-2,000 wei per pixel
  • Check current market rates at tools.livepeer.cloud
Setting this in ETH rather than wei results in a price orders of magnitude below market rate. Setting it too high means Gateways route jobs to lower-priced Orchestrators instead.
-pricePerUnit 1000
-pricePerUnit sets the startup price. The on-chain registered price used for discovery is set separately during activation via livepeer_cli. Both can be adjusted independently later.
8

Set the service address

-serviceAddr <YOUR_PUBLIC_IP_OR_HOSTNAME>:<PORT>
Declares the public address at which Gateways reach the Orchestrator. This is stored on-chain during activation and is how the network discovers the node.
-serviceAddr 203.0.113.42:8935
# or with a domain name (preferred):
-serviceAddr orch.yourdomain.com:8935
Common mistakes:
  • Using an internal IP (192.168.x.x, 10.x.x.x) - not routable from the internet
  • Using 0.0.0.0 - binds locally but is not a network address
  • Changing the IP without updating on-chain registration - Gateways lose contact
A domain name is preferable to a bare IP. If the server’s IP changes, a DNS record can be updated without a new on-chain registration transaction.

Full Startup Command

Replace every placeholder with actual values:
livepeer \
  -network arbitrum-one-mainnet \
  -ethUrl https://arb-mainnet.g.alchemy.com/v2/YOUR_API_KEY \
  -ethAcctAddr YOUR_ETH_ADDRESS \
  -orchestrator \
  -transcoder \
  -nvidia 0 \
  -maxSessions 10 \
  -pricePerUnit 1000 \
  -serviceAddr YOUR_PUBLIC_IP:8935
On first run with a new account (omitting -ethAcctAddr), go-livepeer prompts for a passphrase to create and encrypt a new keystore. This passphrase is required on every subsequent start. For verbose logging while getting started:
livepeer ... -v 6
This outputs detailed logs including transcoding activity, RPC calls, and session events.

Adding AI Inference

To serve AI inference jobs alongside or instead of transcoding, three additional flags are needed.
-aiWorker \
-aiModels /path/to/aiModels.json \
-aiModelsDir /path/to/models/
When running in Docker, the AI Orchestrator needs access to the Docker socket to manage AI runner containers:
docker run \
  --name livepeer_ai_orchestrator \
  -v ~/.lpData/:/root/.lpData/ \
  -v /var/run/docker.sock:/var/run/docker.sock \
  --network host \
  --gpus all \
  livepeer/go-livepeer:master \
  -orchestrator \
  -serviceAddr 0.0.0.0:8936 \
  -nvidia 0 \
  -aiWorker \
  -aiModels /root/.lpData/aiModels.json \
  -aiModelsDir ~/.lpData/models
The AI Orchestrator uses port 8936 by default to avoid conflict with a transcoding Orchestrator on the same machine (which uses 8935). Set -serviceAddr accordingly.
With Docker-out-of-Docker, the -aiModelsDir path must be a path on the host machine, not inside the container. Docker uses this path to mount model files into AI runner containers it spawns.
For the full guide to configuring aiModels.json and receiving the first AI job, see .

Variants

docker run \
  --name livepeer_orchestrator \
  -v ~/.lpData/:/root/.lpData/ \
  --network host \
  --gpus all \
  livepeer/go-livepeer:latest \
  -network arbitrum-one-mainnet \
  -ethUrl https://arb-mainnet.g.alchemy.com/v2/YOUR_API_KEY \
  -orchestrator \
  -transcoder \
  -nvidia 0 \
  -maxSessions 10 \
  -pricePerUnit 1000 \
  -serviceAddr YOUR_PUBLIC_IP:8935
Mount ~/.lpData/ so the keystore and data persist between container restarts. Without this mount, a new ETH account is created on every run.
Create /etc/systemd/system/livepeer.service:
/etc/systemd/system/livepeer.service
[Unit]
Description=Livepeer Orchestrator
After=network.target

[Service]
Type=simple
User=ubuntu
ExecStart=/usr/local/bin/livepeer \
  -network arbitrum-one-mainnet \
  -ethUrl https://arb-mainnet.g.alchemy.com/v2/YOUR_API_KEY \
  -orchestrator \
  -transcoder \
  -nvidia 0 \
  -maxSessions 10 \
  -pricePerUnit 1000 \
  -serviceAddr YOUR_PUBLIC_IP:8935
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target
Enable and start:
sudo systemctl daemon-reload
sudo systemctl enable livepeer
sudo systemctl start livepeer
journalctl -u livepeer -f
go-livepeer does not have a native config file flag. The standard pattern stores flags in a plain text file and expands them at startup:
/etc/livepeer/livepeer.conf
-network arbitrum-one-mainnet
-ethUrl https://arb-mainnet.g.alchemy.com/v2/YOUR_API_KEY
-orchestrator
-transcoder
-nvidia 0
-maxSessions 10
-pricePerUnit 1000
-serviceAddr YOUR_PUBLIC_IP:8935
livepeer $(< /etc/livepeer/livepeer.conf)
In a systemd unit file, this requires an ExecStart wrapper shell script rather than calling the binary directly - systemd does not perform shell expansion in ExecStart.

Next Steps

Connect to Arbitrum

Set up the Arbitrum RPC endpoint and fund the wallet with ETH for gas.

Activate on the network

Register the Orchestrator on-chain and enter the active set via livepeer_cli.

CLI reference

Every flag, its type, default, and description.
Last modified on April 7, 2026