Summary of "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)

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).
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.
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).
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.
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.
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.
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.
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.
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.
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.
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.