Last updated: 2026-07-02T04:07:13.447Z
How to Install OpenClaw on Every Device: macOS, Linux, Windows, and Mobile
OpenClaw is the viral open-source personal AI agent that runs on your own machine and connects to WhatsApp, Telegram, Discord, and now native iOS/Android apps. Here's exactly how to install and pair it on every device you own.
How to Install OpenClaw on Every Device: macOS, Linux, Windows, and Mobile (2026 Guide)
OpenClaw is the open-source "personal AI assistant" that went viral in early 2026 for doing something most AI tools don't: living inside the apps you already use — WhatsApp, Telegram, Discord, Slack, iMessage — instead of forcing you into another browser tab. It runs on your own hardware, keeps your data local, and can genuinely take action: running shell commands, managing files, browsing the web, sending emails, and handling multi-step tasks in the background while you do something else.
This guide covers everything you need to get it running: what it actually is, how it works, and exact installation steps for macOS, Linux, Windows, Docker, and mobile.
What Is OpenClaw?
OpenClaw began as a weekend project by Austrian developer Peter Steinberger, originally released under the name Clawdbot in late 2025, and was later rebranded to OpenClaw. It's MIT-licensed and fully open-source, and it grew into one of the fastest-rising GitHub repositories in recent memory, crossing over a million weekly npm downloads.
What sets it apart from a typical chatbot:
- Local-first — your API keys, configuration, and conversation memory live on your own machine, not a third-party server
- Always-on — it runs as a background daemon and can wake itself on a schedule (a "heartbeat") to check on tasks without you prompting it
- Action-taking, not just answering — it can execute shell commands, edit files, browse the web, manage your calendar, and send messages
- Meets you where you already are — instead of a dedicated app, you talk to it through WhatsApp, Telegram, Discord, Slack, Signal, iMessage, Microsoft Teams, and many more
How OpenClaw Is Built
Understanding the architecture makes installation much easier to follow. There are three core pieces:
- The Gateway — a single long-running Node.js process that is the control plane for everything. It manages authentication, message routing, sessions, and tool orchestration. You install this on one machine — a laptop, an old desktop, a $5/month VPS.
- Channels — connectors for each messaging platform (WhatsApp, Telegram, Discord, Slack, iMessage, and dozens more). You can run several at once; the Gateway routes each conversation to the right one.
- Skills — modular capabilities the agent can call on, like web browsing, email, calendar management, or file operations. Skills are community-extensible, similar in spirit to plugins.
- Nodes — optional companion devices (phones, mostly) that pair with the Gateway over WebSocket and add hardware capabilities like camera, location, and voice.
The important thing to understand before installing: the Gateway is the actual assistant. Everything else — the phone app, the desktop menu-bar app, the messaging channels — is a way of talking to that one running process.
Before You Start: Requirements
| Requirement | Details |
|---|---|
| OS | macOS, Linux, or Windows (native or via WSL2) |
| Runtime | Node.js 24 recommended, Node 22.19+ supported (the installer sets this up for you) |
| Model API key | From Anthropic, OpenAI, Google, or a local provider like Ollama |
| Disk/RAM | Lightweight for the Gateway itself; allocate ~4GB swap on VPS instances under 2GB RAM |
| Optional | pnpm (only needed if building from source), Docker (for container deployments) |
Install on macOS, Linux, or WSL2
The fastest path is the official one-line installer. It detects your OS, installs Node.js if it's missing, installs OpenClaw, and launches onboarding automatically:
```bash
curl -fsSL https://openclaw.ai/install.sh | bash
```
If you'd rather install without running onboarding right away:
```bash
curl -fsSL https://openclaw.ai/install.sh | bash -s -- --no-onboard
```
Alternative: npm, pnpm, or bun
If you manage Node.js yourself already:
```bash
npm
npm install -g openclaw@latest
openclaw onboard --install-daemon
pnpm (requires one extra approval step)
pnpm add -g openclaw@latest
pnpm approve-builds -g
openclaw onboard --install-daemon
bun (CLI only — Node is still recommended for running the Gateway)
bun add -g openclaw@latest
openclaw onboard --install-daemon
```
The `--install-daemon` flag registers OpenClaw as a background service (systemd on Linux, launchd on macOS), so it survives reboots and keeps running after you close the terminal.
Building From Source (for contributors)
```bash
git clone https://github.com/openclaw/openclaw.git
cd openclaw
pnpm install && pnpm build && pnpm ui:build
pnpm link --global
openclaw onboard --install-daemon
```
Install on Windows
Windows users have three real options, in order of simplicity:
1. Native Windows Hub app — the easiest desktop path. It bundles setup, tray status, chat, and local MCP mode into one native app, no terminal required.
2. PowerShell installer — open PowerShell and run:
```powershell
iwr -useb https://openclaw.ai/install.ps1 | iex
```
This is a native installer, but some features like full systemd-style service management work better under Linux.
3. WSL2 Gateway — install Ubuntu via WSL2, then run the same macOS/Linux install script inside it. This is the recommended path if you want the most complete feature set and proper background service management on Windows.
Install with Docker (Great for a VPS)
For headless or server deployments, OpenClaw ships an official Docker image. A typical setup mounts two volumes:
- `~/.openclaw` — configuration and credentials
- `~/openclaw/workspace` — the agent's working sandbox
If you hit permission errors on Linux hosts, fix ownership with `chown` on those directories before starting the container. Running on a small VPS (2 vCPU / 8GB RAM is comfortable) with Docker is a popular way to keep OpenClaw online 24/7 without leaving your personal machine running.
Run the Setup Wizard
If you skipped onboarding earlier, run it manually:
```bash
openclaw onboard
```
The wizard walks you through:
1. Model provider — choose Anthropic, OpenAI, Google, a local model via Ollama, or others, and paste in your API key
2. Gateway binding — for security, bind it to the loopback (localhost) interface rather than exposing it publicly
3. Channels — optionally connect WhatsApp, Telegram, Discord, Slack, or others right away
4. Skills — optionally install skills from the community skill hub, or skip and add them later
Connecting Your First Messaging Channel
Once the Gateway is running, you'll want to actually talk to it somewhere. A few notes on picking your first channel:
- Telegram is usually the fastest to set up — create a bot via BotFather, paste the token into OpenClaw's config or Web UI, and you're chatting within a minute.
- WhatsApp is the most popular first choice since it's already where most people live, but it works via WhatsApp Web-style QR pairing and stores more state on disk than Telegram.
- Discord requires creating an application in the Discord Developer Portal, enabling the Message Content intent, and inviting the bot to your server.
- iMessage is macOS-only.
You can run multiple channels on the same Gateway simultaneously — it routes each conversation independently, and if you bind your identities across platforms, it can maintain one continuous memory of "you" no matter which app you're messaging from.
Verify the Installation
```bash
openclaw --version # confirm the CLI is installed
openclaw doctor # run a health check
openclaw gateway status # confirm the Gateway is running
```
If `openclaw` isn't found after installing, your global npm bin directory probably isn't on your PATH:
```bash
node -v
npm prefix -g
export PATH="$(npm prefix -g)/bin:$PATH"
```
Add that line to your `~/.zshrc` or `~/.bashrc`, then open a new terminal.
Install on Mobile (iOS and Android)
OpenClaw's phone apps launched as companion nodes — not standalone assistants. They connect to a Gateway that's already running on your computer or server, and add phone-specific capabilities: camera, location, voice, and screen sharing via a live Canvas.
1. Make sure your Gateway is up and running (from the steps above)
2. Install OpenClaw from the App Store (iOS) or Google Play (Android)
3. Open the app — on the same Wi-Fi network, it auto-discovers the Gateway via mDNS/Bonjour. For remote pairing, OpenClaw recommends a Tailscale `wss://` endpoint rather than exposing the Gateway directly
4. Pair by scanning the QR code from your Gateway dashboard, or generate one from the terminal:
```bash
openclaw mobile pair --qrcode
```
5. Approve the pairing request from the Gateway:
```bash
openclaw devices list
openclaw devices approve REQUEST_ID
openclaw nodes status # should read "paired · connected"
```
By default, privacy-sensitive commands like `camera.snap` or `screen.record` are disabled until you explicitly allowlist them in `~/.openclaw/openclaw.json`:
```json
{
"gateway": {
"nodes": {
"allowCommands": ["camera.snap", "screen.record"]
}
}
}
```
A deny list (`denyCommands`) always overrides the allowlist, and camera/screen commands only work while the app is in the foreground.
Quick Troubleshooting
| Problem | Fix |
|---|---|
| Gateway shows "0 tokens used" / not responding | Daemon likely stopped, or API auth failed. Run `openclaw gateway restart` and re-check your API key |
| "RPC probe: failed" | Port 18789 is blocked by another process. Find it with `sudo lsof -i :18789` |
| `openclaw` command not found | Global npm bin dir isn't on PATH — see the PATH fix above |
| Pairing prompt never appears on mobile | Run `openclaw devices list` and approve manually |
| "Access not configured" on Telegram/Discord | Your user ID isn't allowlisted yet in the channel config |
| Chromium crashes silently in Docker | Set `shm_size: '2gb'` and mount `/dev/shm` if browser automation is enabled |
Run `openclaw doctor` any time something feels off — it checks config issues automatically — and `openclaw logs --follow` for real-time debugging.
Security: Don't Skip This
You're installing a long-running, high-privilege process with real system access — shell commands, file access, sometimes camera and location. A few non-negotiables:
- Never expose the Gateway directly to the public internet. Bind it to localhost and use SSH tunneling, Tailscale, or a VPN for remote access.
- Allowlist who can message the bot, especially on WhatsApp and Telegram — an unrestricted bot accepting messages from anyone is a real liability.
- Rotate your Gateway auth token and store it in an environment file, never hardcoded in a config file you might commit to a repo.
- Start with consent mode on (`exec.ask: "on"`) so the agent asks for approval before running write or execute commands, then loosen permissions only as you build trust.
- Treat inbound messages as untrusted input — OpenClaw connects to real messaging surfaces, and prompt-injection-style attacks through DMs are a real category of risk the project's own security docs call out explicitly.
Frequently Asked Questions
Is OpenClaw free?
Yes — it's fully open-source under the MIT license. You only pay for whatever model API (Anthropic, OpenAI, Google, etc.) you connect it to, or nothing at all if you run a local model via Ollama.
Does it work on Windows without WSL?
Yes, via the native PowerShell installer or the Windows Hub app, though some service-management features are more complete under WSL2.
Can I use it without a phone app?
Yes — the Gateway alone is a complete experience. The mobile and desktop companion apps are optional extras that add device-specific features like camera and voice.
Does the phone app run OpenClaw locally on my phone?
No — it's a companion node that requires a Gateway running elsewhere (your computer, a VPS). Your phone connects to it, it doesn't run the agent itself.
Is my data private?
OpenClaw is built local-first: memory, config, and credentials stay on your own machine rather than a vendor's servers. That said, you're responsible for securing the machine it runs on — see the security section above.
Explore More AI Tools on Nexorzo
Looking to explore other AI agents and tools beyond OpenClaw? Check out the Nexorzo AI Tools Directory — a curated collection of AI tools across categories like productivity, coding, content creation, and automation, updated regularly so you can compare options and find the right tool for your workflow without digging through dozens of scattered review sites.
Wrapping Up
Install the Gateway on a machine that can stay on (a spare laptop, a Mac Mini, or a cheap VPS), verify it's healthy with `openclaw doctor`, connect one messaging channel to start, and pair your phone as a node once you're comfortable. Start narrow — one channel, one model provider, consent mode on — and expand from there as you get a feel for what it can do.