Why put OpenClaw on a VPS

OpenClaw is an open-source, self-hosted gateway that connects chat apps (Telegram, WhatsApp, Signal, Discord, Slack, Matrix and more) to an AI agent. One Gateway process holds the sessions, memory, channel logins and API keys, and every chat app talks to it. It only answers while that process is running, so on a laptop the assistant goes quiet whenever the lid closes. A VPS keeps the Gateway up, keeps the channel sessions connected, and gives cron jobs and webhooks somewhere to run at 4 am.

The server holds everything sensitive the assistant has: model provider keys, the Telegram bot token, the WhatsApp session, memory files and every transcript. Running it on a server bought without an account and paid in Bitcoin or Monero keeps that box off a customer record with your name on it. It does not hide your prompts from the model provider: they still go to whoever serves the model, under that provider’s account and terms.

Sizing: CPU barely matters, RAM and the browser do

With a hosted model (an API key from Anthropic, OpenAI, OpenRouter or similar) the heavy work happens at the provider. The Gateway itself is a Node process that idles at a few hundred MB. OpenClaw’s own docs give an absolute minimum of 1 vCPU, 1 GB of RAM and about 500 MB of disk, with 2 GB of swap on a 1 GB machine, and recommend 2 GB or more for logs, media and several channels. What moves the number is browser control: the agent drives a real headless Chrome, and a few tabs on heavy sites take 1 to 2 GB on their own.

Chat only, one person: BVX12 (1 vCPU, 2 GB RAM, 40 GB NVMe, $20 a month in Helsinki, $24 in Germany, $31 in Singapore) matches the 2 GB the docs recommend.
Cheaper for chat only: BVA11 (2 Arm vCPU, 4 GB, 40 GB, $13 a month in Helsinki) when the configure page lists it. OpenClaw supports 64-bit Arm Linux; only 32-bit ARMv7 is unsupported.
Browser control: pick an x86 plan. The docs recommend Google’s Chrome .deb, which is built for amd64, and the snap Chromium that Ubuntu installs on Arm fails to start under OpenClaw. BVX22 (2 vCPU, 4 GB, 80 GB, $35 in Helsinki, $40 in Germany, $55 in Singapore) is the comfortable start.
Heavy browser use, several agents or a small team: BVX32 (4 vCPU, 8 GB, 160 GB, $60 in Helsinki, $75 in Germany).
US locations (Ashburn, Hillsboro): BVX11 (2 vCPU, 2 GB, 40 GB) at $35 for chat only, BVX21 (3 vCPU, 4 GB, 80 GB) at $65 with the browser.
BVX02 (1 vCPU, 1 GB, 20 GB, $11 in Helsinki) runs a single chat channel with swap, but leaves no headroom for skills or the browser.

Prepare the server

Everything below assumes a fresh Ubuntu 24.04 image and a root shell (prefix sudo if you created a user). Patch first, then lock down SSH and the firewall before anything else is listening.

apt update && apt full-upgrade -y
apt install -y ufw unattended-upgrades curl gnupg

# SSH: keys only. Put your public key in /root/.ssh/authorized_keys first and
# confirm you can log in with it before disabling passwords.
cat > /etc/ssh/sshd_config.d/00-keys-only.conf <<'EOF'
PasswordAuthentication no
KbdInteractiveAuthentication no
PermitRootLogin prohibit-password
EOF
sshd -t && systemctl restart ssh

# Firewall: deny everything inbound except SSH for now.
ufw default deny incoming
ufw default allow outgoing
ufw allow OpenSSH
ufw --force enable

Install OpenClaw as a non-root user

Use root only to install Node and the CLI. OpenClaw itself runs as an ordinary user, so its state lives under that user’s home and the Gateway installs as a systemd user service. Lingering keeps that user’s services running when nobody is logged in.

# Node 24 LTS from NodeSource (Node 22, 23 and 25 are not supported).
curl -fsSL https://deb.nodesource.com/setup_24.x | bash -
apt install -y nodejs
node --version

# OpenClaw CLI, without starting onboarding as root.
curl -fsSL https://openclaw.ai/install.sh | bash -s -- --no-onboard

# The user that owns OpenClaw state and its Gateway service.
adduser --disabled-password --gecos "" openclaw
loginctl enable-linger openclaw
su - openclaw
openclaw --version

On a 1 GB plan, add swap before onboarding. Run this as root (exit the openclaw shell first, then su - openclaw again).

fallocate -l 2G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile
echo '/swapfile none swap sw 0 0' >> /etc/fstab
free -h

Onboarding and the Gateway service

As the openclaw user, run onboarding with the daemon flag. The wizard asks for model access (paste the API key), generates the Gateway token, offers channel setup and installs the systemd user unit. Pick the strongest current model you are willing to pay for: OpenClaw’s docs are blunt that weaker models are easier to steer with prompt injection.

openclaw onboard --install-daemon

# Check it is up and stays up.
openclaw status
openclaw doctor
systemctl --user status openclaw-gateway.service
journalctl --user -u openclaw-gateway.service -f   # Ctrl-C to leave

Config lives in ~/.openclaw/openclaw.json and the agent workspace in ~/.openclaw/workspace. On a small or Arm machine the CLI feels faster with Node’s compile cache turned on, which the docs suggest for exactly this case:

cat >> ~/.bashrc <<'EOF'
export NODE_COMPILE_CACHE=/var/tmp/openclaw-compile-cache
mkdir -p /var/tmp/openclaw-compile-cache
export OPENCLAW_NO_RESPAWN=1
EOF
source ~/.bashrc

Reach the dashboard without opening a port

On a normal install the Gateway listens on 127.0.0.1:18789 only, and it should stay that way. The firewall from the prep section allows SSH and nothing else, so the dashboard is reachable only through a tunnel. From your own computer:

# Leave this running, then open http://127.0.0.1:18789/ in your browser
# and sign in with the Gateway token from onboarding.
ssh -N -L 18789:127.0.0.1:18789 root@SERVER_IP

If you use Tailscale, Tailscale Serve is the other supported route: install Tailscale on the server, join it to your tailnet, then run openclaw config set gateway.tailscale.mode serve. Do not bind the Gateway to the public interface or put it behind a public reverse proxy unless you have worked through OpenClaw’s exposure runbook first. The dashboard can run commands on the server.

Connect Telegram

Telegram is the fastest channel to set up because it needs only a bot token, not a phone session. In Telegram, message @BotFather (check the handle exactly), run /newbot and copy the token. Then, as the openclaw user:

openclaw channels add --channel telegram --token 'PASTE_BOT_TOKEN'
openclaw channels status --probe

# Send your bot any message in Telegram, then approve that pairing request.
# Codes expire after an hour.
openclaw pairing list telegram
openclaw pairing approve telegram CODE

The default DM policy is pairing: a stranger who finds the bot gets a pairing code, not an answer, until you approve them. Keep it that way. In groups the bot answers only when mentioned unless you change it. WhatsApp and Signal work the same way but link a real phone number; use a separate number for the assistant rather than your own.

Browser control on a headless server

On Ubuntu, apt install chromium installs a snap wrapper, and snap confinement stops OpenClaw from launching and monitoring it. Install Google Chrome from the .deb instead (x86 plans), as root:

wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
apt install -y ./google-chrome-stable_current_amd64.deb
google-chrome-stable --version

Then, as the openclaw user, add a browser block to ~/.openclaw/openclaw.json (merge it with what onboarding wrote, do not replace the file) and restart the Gateway:

{
  "browser": {
    "enabled": true,
    "executablePath": "/usr/bin/google-chrome-stable",
    "headless": true,
    "noSandbox": true
  }
}

openclaw gateway restart
openclaw browser status

Backups and updates

Everything that makes the assistant yours sits under ~/.openclaw: config, the SQLite databases that hold model auth and sessions, channel credentials and the workspace with its memory files. Copying only openclaw.json is not enough. Stop the Gateway so the databases are consistent, take a verified archive, start it again:

openclaw gateway stop
mkdir -p ~/Backups/openclaw
openclaw backup create --output ~/Backups/openclaw --verify
openclaw gateway start
ls -lh ~/Backups/openclaw

The archive contains API keys and channel sessions in the clear, so encrypt it before it leaves the server (restic does this by default; age or gpg work for a single file) and keep it somewhere you control. A prepaid server that is not extended is deleted at the end of its term, and this archive is what you restore onto the next one with openclaw backup restore and openclaw doctor.

Update with openclaw update, which checks the new version while the old Gateway keeps serving, then switches over. Run openclaw doctor afterwards. Ubuntu security updates keep arriving through unattended-upgrades from the prep section.

Security checklist

Run openclaw security audit after setup and after every config change. It flags drift from the safe defaults.
Gateway on loopback only; ufw status should list OpenSSH and nothing else.
Keep DM pairing and group mention gating on. Allowlist the people who may talk to the agent.
Give the assistant its own accounts: a separate bot, a separate phone number, a separate email. Do not sign the server into your personal Google or Apple account or password manager.
Treat anything the agent reads (web pages, emails, documents) as untrusted input. Restrict tools for agents that read the outside world.
If a backup or the server may have leaked, rotate the model key and the bot token first; they are the credentials that cost money or speak as you.

Which plan to pick

For a personal assistant on Telegram with a hosted model, choose BVX12 (1 vCPU, 2 GB, $20 a month in Helsinki), or BVA11 (2 Arm vCPU, 4 GB, $13 in Helsinki) when it is listed. If the agent will browse the web, choose BVX22 (2 vCPU, 4 GB, 80 GB, $35 in Helsinki, $40 in Germany) and go to BVX32 when several agents share the box. Configure a server with Ubuntu 24.04, pay in Bitcoin, Monero or card, and follow the sections above in order: prep, install as the openclaw user, onboarding, the SSH tunnel, then channels.

VPS for OpenClaw: run the Gateway around the clock on a server paid in Bitcoin or Monero