ClawdBot Full Tutorial for Beginners: SECURE Setup Guide

High-level concept

OpenClaw / Claudebot is an open-source orchestration layer — a “message queue” / orchestration system — that calls external LLMs (OpenAI, Anthropic, etc.). It is not the LLM itself; it coordinates models, tools, channels, and agents. Because it routes data to LLM providers, you must secure infrastructure, inputs, outputs, and credentials.

---

Primary security principles

• Don’t run the bot on your primary personal device or home network. Use a cloud VPS for better physical security, availability, and isolation.
• Isolate and sandbox every external integration (email, Drive, browser, API keys) with separate accounts.
• Use a private network (Tailscale) so SSH and service ports aren’t exposed to the public internet.
• Disable root SSH login and password authentication; create a non-root sudo user and require sudo passwords for elevation.
• Use hoster-level firewall rules: block all incoming by default; allow only the Tailscale UDP port and any explicit public ports you need (e.g., 80/443).
• Limit LLM/API spending via subscriptions, quotas, or API key spending caps; monitor usage and enable notifications.
• Avoid prompt-injection risks: never give the bot access to a primary account that can receive arbitrary untrusted input (e.g., your main Gmail). Prefer forwarding trusted items to a bot-only account.
• Keep admin access to the bot via authenticated devices only; use VPN/Tailscale for all administrative access.

---

Recommended hosting and tools

• VPS: Hostinger VPS (KVM2, Debian 13) used in the tutorial (author partnered with Hostinger). One-click OpenClaw deploy exists, but the tutorial covers a manual, hardened install.
• Private network / VPN: Tailscale.
• OS: Debian (or Ubuntu) VPS with SSH access.
• Runtime: Node / npm for OpenClaw gateway and services.
• Chat channel: Telegram (recommended over WhatsApp for this setup).
• LLM providers: OpenAI (ChatGPT/Codex via subscription preferred) and Anthropic (Claude). Prefer using existing subscriptions rather than raw API keys to control cost.

---

Step-by-step (condensed)

1. Provision VPS

   • Choose a VPS (e.g., Hostinger KVM2, Debian 13). Do not run on your daily-use device.
   • Configure root password (generate a strong random password).

2. SSH into VPS

   • Connect: ssh root@<VPS_IP>, accept host key, paste password (typing is hidden).
   • Optionally use the VPS provider terminal for password reset, reboots, etc.

3. Install and configure Tailscale

   • Install: bash curl -fsSL https://tailscale.com/install.sh | sh

   • Enable SSH support: bash tailscale up --ssh

   • Authenticate via the Tailscale browser link and install the Tailscale client on your admin devices (Windows/Mac/phone).

   • Confirm server Tailscale IP (100.x.x.x range).

4. Harden SSH and create non-root admin

   • Edit /etc/ssh/sshd_config:
     • Set ListenAddress to the Tailscale IP so SSH only listens on the private network.
     • PermitRootLogin no
     • PasswordAuthentication no (if using keys) or otherwise ensure strong settings.

   • Restart SSH: bash systemctl restart ssh

   • Add a non-root user: bash adduser <username> usermod -aG sudo <username>

   • Test that root SSH from the public internet is refused and SSH via Tailscale with the new user works.

5. Host-level firewall (hoster dashboard)

   • Block public incoming traffic by default.
   • Allow UDP port 41641 (Tailscale).
   • Only open ports 80/443 if you intend to host public web services.

6. Install OpenClaw / Claudebot

   • Use the OpenClaw one-liner to install npm & OpenClaw (or follow manual instructions).
   • Choose manual config, local gateway, token authentication, and keep wide exposure off.
   • Example gateway default port: 18789.

7. Model configuration (two recommended approaches)

   • Prefer using your provider subscription (saves cost; avoids raw API charges):
     • OpenAI: use ChatGPT subscription (Codex via ChatGPT Pro recommended for cost/limits).
     • Anthropic: use your Claude subscription (use claude code -> claude setup token to produce a token).
   • If using API keys, create dedicated API keys and set spending limits / quotas.

8. Connect channels (example: Telegram)

   • Use BotFather in Telegram to create a bot (name must end with “bot”), copy the bot token.
   • In OpenClaw config, paste the Telegram bot token and configure pairing policy (pairing is recommended).
   • Pair your Telegram account to the bot using the provided pairing command and code.

9. Gateway UI access and gateway token

   • Use SSH local port forwarding to map the gateway port to your local machine: bash ssh -N -L 18789:127.0.0.1:18789 <user>@<TAILSCALE_IP>

   • Open http://localhost:18789 in your browser.

   • Retrieve the gateway token from the bot (via Telegram command) and add ?token=<gateway_token> to the UI URL or paste it into the UI login.
   • Use the web UI to view channels, instances, cron jobs, enable skills, etc.

10. Add skills and additional nodes - OpenClaw has built-in skills (coding, GitHub, monitoring, etc.). Enable only skills you trust; many require additional installs (brew, npm) and API tokens. - Sandbox skills: use separate accounts and credentials for each integration. - Skills that require administrative changes will need sudo on the server — requiring a password prevents the bot from self-elevating.

11. Port forwarding for additional local services - To access bot-run services (e.g., FastAPI on port 500), create additional SSH port forwards: bash ssh -N -L 5000:127.0.0.1:5000 <user>@<TAILSCALE_IP>

---

Operational and safety notes

• Use separate email / Drive / browser accounts for the bot; forward only trusted items from your main account to a bot-only account to avoid prompt injection.
• Never supply primary credentials or highly sensitive keys to the bot. If you must give API keys, enforce strict usage/spending caps and notifications.
• Running LLMs completely locally is the only way to remove provider access to content entirely — but that requires heavy hardware and is outside this guide.
• Prefer provider subscriptions (ChatGPT Pro, Claude Plus) over raw API keys to reduce risk of unexpectedly high billing.
• Monitor LLM usage and set spending limits where possible.
• Keep the bot user non-root and require sudo passwords for administrative changes.

---

Useful commands / templates

• Install Tailscale: bash curl -fsSL https://tailscale.com/install.sh | sh

• Start Tailscale SSH support: bash tailscale up --ssh

• Edit SSH config: bash nano /etc/ssh/sshd_config

• Restart SSH: bash systemctl restart ssh

• Add a user: bash adduser <name>

• Add to sudo: bash usermod -aG sudo <name>

• SSH forward gateway UI: bash ssh -N -L 18789:127.0.0.1:18789 <user>@<tailscale-ip>

• Check OpenClaw gateway port: bash openclaw gateway

• Add Anthropic token:

  • Use claude code and claude setup token on your local machine, then paste the token into OpenClaw configuration (Model -> Anthropic token).

---

Recommendations & cautions (summary)

• Use a cloud VPS for stability and backups, and Tailscale for private admin access.
• Disable public SSH & root login; use a non-root sudo user.
• Sandbox all connected accounts; forward trusted items to bot-only accounts.
• Prefer subscription-based integration (ChatGPT Pro / Claude Plus) to avoid high API-key bills.
• Set spending limits and notifications on provider accounts or API keys.
• Audit and limit enabled skills; each skill can introduce new data flows and risks.

---

Speaker and sources

• Speaker: Tim (referred to himself as Tim; runs “Tech with Tim” style commentary). He mentions partnering with Hostinger.
• Mentioned services/tools: OpenClaw / Claudebot (open-source), Hostinger (VPS provider), Tailscale (VPN), OpenAI (Codex / ChatGPT subscription), Anthropic (Claude / Opus models), Telegram (BotFather), claude code CLI, Debian, Node/npm.