---
title: "Cómo Instalar OpenClaw 2026: Script, npm, Docker y Raspberry Pi"
seo_title: "Cómo Instalar OpenClaw 2026: Script (5 min), Docker y Raspberry Pi"
seo_description: "Instala OpenClaw con script automático en 5 minutos (macOS, Linux, Windows WSL2), npm, Docker o Raspberry Pi. Requisito: Node.js 22+. Guía completa con comandos verificados."
excerpt: "Guía completa para instalar OpenClaw (antes Clawdbot) en 2026: script automático en 5 minutos, npm manual, Docker con docker-compose y Raspberry Pi 4/5. Requisito mínimo: Node.js 22+."
date: "2026-02-16"
lastModified: "2026-03-29T00:00:00.000Z"
category: "OpenClaw"
author:
  name: "Angel Cruz"
  avatar: "https://angelcruzdevcdn.nyc3.cdn.digitaloceanspaces.com/images/avatar.jpg"
  url: "https://www.angelcruz.dev"
ogImage:
  url: "https://angelcruzdevcdn.nyc3.cdn.digitaloceanspaces.com/content/5/01KFVJFYG53S1S5DCMGREM3CC2.png"
---

> **Actualización (febrero 2026):** Este artículo cubre la instalación de **OpenClaw**, que antes se llamó Clawdbot y brevemente Moltbot. Si buscas "Clawdbot instalación", estás en el lugar correcto: es el mismo proyecto. Lee la [historia completa del rebrand](/post/openclaw-de-clawdbot-a-plataforma-agentes-ia) si quieres contexto.

Hace unas semanas escribí sobre [Clawdbot (ahora OpenClaw)](/post/clawdbot-asistente-ia-personal-open-source), el asistente de IA open source que promete automatizar tu vida digital desde tu propia máquina. Ese artículo cubrió *qué es* y *por qué es interesante*. Este va directo al grano: **cómo instalarlo paso a paso**, desde el script más simple hasta configuraciones avanzadas con Docker y Raspberry Pi.

La historia del nombre es curiosa: el proyecto nació como **Clawdbot** en noviembre de 2025, se renombró a **Moltbot** el 27 de enero de 2026 (por una queja de marca registrada de Anthropic), y tres días después se convirtió en **OpenClaw** porque "Moltbot nunca terminó de sonar bien". El "fastest triple rebrand in open source history", como lo llaman en la comunidad. Si encuentras tutoriales viejos que dicen "Clawdbot" o "Moltbot", tranquilo: es el mismo software, solo cambiaron los nombres de los comandos y dominios.

Lo importante: OpenClaw sigue siendo el mismo asistente de IA que puede revisar tus emails, negociar la compra de un auto, generar resúmenes diarios por voz o ejecutar comandos en tu sistema. Y sigue siendo open source, gratuito y completamente privado (corre en tu máquina, no en la nube).

## ¿Qué es OpenClaw?

OpenClaw es un asistente de IA personal **open-source** que se ejecuta localmente en tu máquina. A diferencia de asistentes como ChatGPT o Claude que funcionan solo en el navegador, OpenClaw:

- Se ejecuta como **proceso en segundo plano** (daemon) en tu sistema
- Puede **controlar tu computadora** (abrir apps, ejecutar comandos, navegar)
- Se integra con **múltiples canales** (Slack, Discord, Telegram, WhatsApp, Microsoft Teams)
- Admite **múltiples modelos de IA** (Claude, GPT-4, modelos locales)
- Es totalmente **personalizable** mediante skills y configuración

Creado originalmente por **Peter Steinberger** en noviembre de 2025, OpenClaw derivó de Molty (anteriormente Clawd), un asistente virtual de IA que él había desarrollado.

**Actualización febrero 2026**: Peter Steinberger anunció el 14 de febrero de 2026 que se unirá a OpenAI, y el proyecto será trasladado a una fundación open-source para garantizar su continuidad.

## Requisitos de OpenClaw

Los **requisitos mínimos de OpenClaw** son:

- **Node.js 22 o superior** (OpenClaw requiere Node ≥22)
- Sistema operativo: **macOS**, **Linux**, o **Windows con WSL2**
- Al menos **4 GB de RAM** (recomendado 8 GB para uso intensivo)
- Cuenta API de un proveedor de IA (Claude, OpenAI o modelo local)

## Script OpenClaw: Instalación en 5 Minutos (Recomendado)

La forma más rápida de instalar OpenClaw es usando el script de instalación automático:

```bash
curl -fsSL https://openclaw.ai/install.sh | bash
```

**¿Qué hace este script?**

1. Detecta tu sistema operativo
2. Instala Node.js 22+ si no está presente
3. Instala OpenClaw globalmente
4. Ejecuta el wizard de configuración (`openclaw onboard`)
5. Instala el daemon/servicio en segundo plano

**Ventajas**:
- Instalación en menos de 5 minutos
- Configura todo automáticamente
- Instala el daemon para que OpenClaw esté siempre activo

**Después de la instalación**, el wizard te preguntará:

1. **API Key**: Configura Claude, OpenAI, o modelo local
2. **Gateway**: Puerto local para la interfaz web (default: 18789)
3. **Channels**: Slack, Discord, Telegram, etc.
4. **Skills**: Habilidades adicionales (navegación web, ejecución de código, etc.)

## npm install OpenClaw: Instalación Manual en macOS y Linux

Si prefieres instalar manualmente con npm:

```bash
npm install -g openclaw@latest
```

Luego ejecuta el wizard de configuración:

```bash
openclaw onboard --install-daemon
```

**El flag `--install-daemon`**:
- En **Linux**: Registra OpenClaw como servicio systemd
- En **macOS**: Registra OpenClaw con launchd
- Garantiza que el agente sobreviva reinicios del sistema

**Verificar instalación**:

```bash
openclaw --version
// Debería mostrar: v2026.2.14 (o versión más reciente)

openclaw status
// Muestra si el daemon está activo
```

## Docker OpenClaw: Instalación Aislada con docker-compose

OpenClaw incluye soporte oficial para Docker mediante `docker-compose`:

```bash
// Clonar el repositorio
git clone https://github.com/openclaw/openclaw.git
cd openclaw

// Ejecutar el script de configuración Docker
./docker-setup.sh
```

**Ventajas de Docker**:
- **Aislamiento de procesos**: OpenClaw corre en su propio contenedor
- **Entornos reproducibles**: Misma configuración en cualquier máquina
- **Actualizaciones sin dolor**: `docker-compose pull && docker-compose up -d`
- **Bundled runtime**: Incluye Node.js dentro del contenedor

**Configuración manual con Docker**:

```bash
docker pull openclaw/openclaw:latest

docker run -d \
  --name openclaw \
  -p 18789:18789 \
  -v ~/.openclaw:/root/.openclaw \
  openclaw/openclaw:latest
```

**Mapeo de puertos**:
- El gateway se mapea a `127.0.0.1:18789`
- La configuración se persiste en `~/.openclaw` mediante volúmenes Docker

**Acceder al wizard en Docker**:

```bash
docker exec -it openclaw openclaw onboard
```

**Docker en servidores VPS**:

Docker es especialmente útil si quieres ejecutar OpenClaw en un servidor dedicado (Digital Ocean, AWS, etc.) y acceder a él remotamente. Consulta la [guía oficial de Docker](https://docs.openclaw.ai/install/docker) para configuraciones avanzadas de red y seguridad.

## OpenClaw en Raspberry Pi 4/5: Servidor Dedicado 24/7

OpenClaw puede ejecutarse en una **Raspberry Pi 4 o 5** como servidor dedicado 24/7. Solo necesita **~300MB de RAM** incluso bajo carga sostenida de mensajería.

**Requisitos**:
- Raspberry Pi 4 (4GB+ RAM recomendado) o Raspberry Pi 5 (8GB ideal)
- Raspberry Pi OS (64-bit recomendado)
- Node.js 22+ instalado

**Paso 1: Instalar Node.js 22 en Raspberry Pi**

```bash
// Usar nvm (Node Version Manager)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

// Cerrar y reabrir terminal, luego:
nvm install 22
nvm use 22

// Verificar versión
node --version
// Debería mostrar: v22.x.x
```

**Paso 2: Instalar OpenClaw**

```bash
npm install -g openclaw@latest
openclaw onboard --install-daemon
```

**Paso 3: Configurar API Key**

Durante el wizard, configura tu API key de Claude o OpenAI. Para modelos **locales** (Llama, Mistral), necesitarás hardware más potente (Pi 5 con 8GB mínimo + USB SSD recomendado).

**Paso 4: Acceso remoto**

Si quieres acceder a OpenClaw desde otros dispositivos en tu red:

```bash
// Editar ~/.openclaw/openclaw.json
// Cambiar "host": "127.0.0.1" por "host": "0.0.0.0"

// Reiniciar el servicio
openclaw restart
```

Ahora puedes acceder desde cualquier dispositivo en tu red local en `http://[IP_DE_TU_PI]:18789`

**Raspberry Pi como servidor siempre activo**:
- Bajo consumo de energía (~5W)
- Ideal para automatizaciones programadas (cron jobs)
- Puede ejecutar múltiples agentes simultáneamente con modelos cloud

## Configuración de OpenClaw

La configuración de OpenClaw vive en `~/.openclaw/openclaw.json`. Aquí un ejemplo comentado:

```json
{
  "agent": {
    "model": "claude-sonnet-4.5",
    "provider": "anthropic",
    "apiKey": "sk-ant-..."
  },
  "gateway": {
    "port": 18789,
    "host": "127.0.0.1"
  },
  "channels": [
    {
      "type": "slack",
      "token": "xoxb-...",
      "enabled": true
    },
    {
      "type": "telegram",
      "token": "123456:ABC-DEF...",
      "enabled": true
    }
  ],
  "skills": {
    "web-browser": true,
    "code-execution": true,
    "file-operations": true
  },
  "security": {
    "allowedCommands": ["git", "npm", "docker"],
    "blockedCommands": ["rm -rf /", "dd"]
  }
}
```

**Campos importantes**:

- **agent.model**: Modelo de IA a usar (claude-sonnet-4.5, gpt-4o, llama-3-70b, etc.)
- **gateway.port**: Puerto local para la interfaz web (default: 18789)
- **channels**: Canales de mensajería habilitados
- **skills**: Habilidades del agente (navegación, código, archivos)
- **security**: Comandos permitidos/bloqueados por seguridad

## Integraciones Principales

### Slack

```bash
openclaw channel add slack
// Sigue las instrucciones para crear una Slack App
// Necesitarás un Bot User OAuth Token (xoxb-...)
```

### Discord

```bash
openclaw channel add discord
// Proporciona el Discord Bot Token
```

### Microsoft Teams

OpenClaw soporta integración con Microsoft Teams mediante webhooks:

```bash
openclaw channel add teams --webhook-url "https://outlook.office.com/webhook/..."
```

**Configuración en Teams**:
1. En tu canal de Teams, ve a "Connectors"
2. Agrega "Incoming Webhook"
3. Copia la URL del webhook
4. Pégala en la configuración de OpenClaw

### Telegram

```bash
openclaw channel add telegram
// Crea un bot con @BotFather en Telegram
// Proporciona el Bot Token
```

### WhatsApp (Vía Twilio)

```bash
openclaw channel add whatsapp --twilio-account-sid "AC..." --twilio-auth-token "..."
```

### Cron Jobs y Automatizaciones Programadas

OpenClaw puede ejecutar tareas automáticamente usando cron jobs:

```bash
openclaw skill add cron

// Ejemplo: Resumen diario de emails a las 9 AM
openclaw cron add "0 9 * * *" "Resume mis emails del día"

// Ejemplo: Backup semanal los domingos a las 2 AM
openclaw cron add "0 2 * * 0" "Ejecuta backup de la carpeta ~/proyectos"
```

**Formatos de cron**:
- `0 9 * * *` = Todos los días a las 9:00 AM
- `*/30 * * * *` = Cada 30 minutos
- `0 */6 * * *` = Cada 6 horas
- `0 2 * * 0` = Domingos a las 2:00 AM

### Voz y ElevenLabs

OpenClaw soporta interacción por voz mediante integración con ElevenLabs:

```bash
openclaw skill add voice
openclaw skill add elevenlabs --api-key "..."
```

**Características de voz**:
- **Wake word**: Activa OpenClaw con "Hey OpenClaw"
- **Modo always-on**: OpenClaw escucha continuamente
- **Text-to-speech**: Respuestas habladas naturales con ElevenLabs
- **Modelos de voz**: Elige entre múltiples voces profesionales

**Configuración del wake word**:

```bash
openclaw config set voice.wakeWord "hey openclaw"
openclaw config set voice.alwaysListening true
```

**Requisitos**:
- Micrófono funcional
- API key de ElevenLabs (plan gratuito disponible)
- Conexión a internet estable

### Canvas Interactivo

OpenClaw incluye un canvas interactivo para colaboración visual:

```bash
openclaw skill add canvas
```

Permite al agente:
- Dibujar diagramas y flujos
- Editar imágenes
- Colaborar en pizarras virtuales
- Exportar resultados como PNG/SVG

## Casos de Uso Reales

### 1. Automatización de Desarrollo

```bash
// Crear rama, implementar feature, tests, commit, push
"Crea una rama llamada 'feature/auth-2fa', implementa autenticación de dos factores, ejecuta los tests, haz commit y push"
```

### 2. Gestión de Emails

```bash
// Revisar emails importantes, responder, archivar
"Resume mis emails no leídos de hoy, responde los urgentes y archiva los newsletters"
```

### 3. Investigación y Síntesis

```bash
// Investigar un tema, generar informe
"Investiga las últimas tendencias en IA agentic 2026, genera un informe con fuentes"
```

### 4. Monitoreo de Servers

```bash
// Revisar logs, alertar problemas
"Revisa los logs del server nginx, alerta si hay errores 5xx en la última hora"
```

### 5. Scraping y Análisis de Datos

```bash
// Extraer datos de sitios web
"Extrae las 20 mejores ofertas de trabajo de remote.co para Python developers, guárdalas en CSV"
```

## Seguridad y Permisos

OpenClaw ejecuta comandos en tu sistema, por lo que es importante configurar permisos adecuadamente.

**Lista blanca de comandos**:

```json
{
  "security": {
    "allowedCommands": [
      "git",
      "npm",
      "docker",
      "python",
      "node"
    ]
  }
}
```

**Lista negra de comandos**:

```json
{
  "security": {
    "blockedCommands": [
      "rm -rf /",
      "dd",
      "mkfs",
      ":(){ :|:& };:"
    ]
  }
}
```

**Modo sandbox**:

```bash
openclaw config set security.sandboxMode true
```

En modo sandbox, OpenClaw solo puede ejecutar comandos en directorios específicos.

## Actualizar OpenClaw

### Con npm:

```bash
npm update -g openclaw
openclaw restart
```

### Con Docker:

```bash
cd ~/openclaw
docker-compose pull
docker-compose up -d
```

### Verificar versión:

```bash
openclaw --version
```

## Solución de Problemas Comunes

### OpenClaw no inicia

```bash
// Ver logs
openclaw logs

// Reiniciar daemon
openclaw restart

// Verificar que el puerto 18789 no esté ocupado
lsof -i :18789
```

### Errores de API Key

```bash
// Reconfigurar API key
openclaw config set agent.apiKey "sk-ant-..."

// Verificar provider correcto
openclaw config set agent.provider "anthropic"  # o "openai"
```

### Consumo alto de memoria

```bash
// Limitar memoria del agente
openclaw config set agent.maxMemory "512MB"

// Deshabilitar skills no usados
openclaw skill disable web-browser
```

### No responde en canales

```bash
// Verificar tokens de channels
openclaw channel list

// Reconfigurar channel
openclaw channel remove slack
openclaw channel add slack
```

## Comparación: OpenClaw vs Zapier vs Make

| Característica | OpenClaw | Zapier | Make |
|---|---|---|---|
| **Ejecución** | Local (tu máquina) | Cloud | Cloud |
| **Open-source** | Sí | No | No |
| **Costo** | Gratis + API costs | $19.99+/mes | $9+/mes |
| **Control total** | Sí | Limitado | Limitado |
| **Comandos del sistema** | Sí | No | No |
| **Código personalizado** | JavaScript/Python | Limitado | JavaScript |
| **Privacidad** | Total (datos locales) | Datos en cloud | Datos en cloud |

**Cuándo usar OpenClaw**:
- Necesitas control total del sistema
- Privacidad de datos es crítica
- Quieres automatizaciones complejas sin límites
- Prefieres pagar por uso (API calls) vs suscripción mensual

**Cuándo usar Zapier/Make**:
- Prefieres solución no-code lista para usar
- No te importa que tus datos pasen por servidores externos
- Necesitas integraciones pre-construidas con cientos de apps

## Recursos Oficiales

- **Documentación oficial**: [docs.openclaw.ai](https://docs.openclaw.ai)
- **Repositorio GitHub**: [github.com/openclaw/openclaw](https://github.com/openclaw/openclaw)
- **Paquete npm**: [npmjs.com/package/openclaw](https://www.npmjs.com/package/openclaw)
- **Comunidad Discord**: [discord.gg/openclaw](https://discord.gg/openclaw)

## Preguntas Frecuentes

### ¿OpenClaw es gratis?

Sí, OpenClaw es completamente **open-source y gratis**. Solo pagas por los costos de API de tu proveedor de IA (Claude, OpenAI, etc.). Si usas modelos locales (Llama, Mistral), no hay costos de API.

### ¿Puedo usar OpenClaw sin conexión a internet?

Sí, si usas modelos de IA **locales** (Llama, Mistral via Ollama). Pero necesitas hardware potente (GPU recomendada) para ejecutar modelos locales.

### ¿OpenClaw funciona en Windows?

Sí, mediante **WSL2** (Windows Subsystem for Linux). Instala WSL2 primero, luego sigue las instrucciones de instalación para Linux.

### ¿Cuánta RAM necesita OpenClaw?

**Mínimo 4GB**, recomendado **8GB**. Con modelos cloud (Claude, GPT-4), OpenClaw usa ~300MB de RAM. Con modelos locales, necesitas 8-16GB+ dependiendo del modelo.

### ¿Puedo ejecutar múltiples agentes simultáneamente?

Sí, OpenClaw soporta múltiples agentes. Cada agente puede tener su propia configuración, modelo de IA y conjunto de skills.

```bash
openclaw agent create "agente-email" --model gpt-4o
openclaw agent create "agente-dev" --model claude-sonnet-4.5
```

### ¿OpenClaw soporta modelos locales?

Sí, OpenClaw soporta modelos locales mediante **Ollama** o **llama.cpp**:

```bash
// Instalar Ollama
curl -fsSL https://ollama.ai/install.sh | sh

// Descargar modelo
ollama pull llama3:70b

// Configurar OpenClaw
openclaw config set agent.provider "ollama"
openclaw config set agent.model "llama3:70b"
```

### ¿Es seguro darle acceso a mi sistema?

OpenClaw ejecuta comandos con tus permisos de usuario. **Usa listas blancas/negras** de comandos y habilita **modo sandbox** si tienes dudas. Nunca ejecutes OpenClaw como root.

### ¿Puedo contribuir al proyecto?

Sí, OpenClaw es open-source. Contribuye en [github.com/openclaw/openclaw](https://github.com/openclaw/openclaw). El proyecto será trasladado a una fundación open-source tras la incorporación de Peter Steinberger a OpenAI.

## Conclusión

OpenClaw (anteriormente Clawdbot/Moltbot) es una herramienta poderosa para automatizar tareas, integrar IA en tu flujo de trabajo diario y mantener control total sobre tus datos. Con soporte para múltiples modelos, canales de mensajería, Docker, Raspberry Pi y una comunidad activa, es una alternativa robusta y open-source a servicios cloud como Zapier o Make.

**Próximos pasos**:
1. Instala OpenClaw con el método que prefieras
2. Configura tu API key y canales
3. Experimenta con comandos simples
4. Habilita skills avanzados según necesites
5. Únete a la comunidad en Discord

**Última actualización**: 16 de febrero de 2026.

---

## Fuentes

- [No Mac Mini, no worries: running OpenClaw on a Raspberry Pi | ajfisher](https://ajfisher.me/2026/02/03/openclaw-raspberrypi-howto/)
- [OpenClaw Installation and Deployment: Complete Guide | LaoZhang AI Blog](https://blog.laozhang.ai/en/posts/openclaw-installation-deployment-guide)
- [Docker - OpenClaw Official Docs](https://docs.openclaw.ai/install/docker)
- [Running OpenClaw in Docker | Simon Willison's TILs](https://til.simonwillison.net/llms/openclaw-docker)
- [OpenClaw - Wikipedia](https://en.wikipedia.org/wiki/OpenClaw)
- [Clawdbot's Final Rename: OpenClaw Officially Released | WenHaoFree](https://blog.wenhaofree.com/en/posts/articles/clawdbots-final-rename-openclaw-officially-released-ending-the-fastest-triple-rebrand-in-open-source-history/)
- [The Rise, Fall, and Rebirth of Clawdbot in 72 Hours | EveryDev.ai](https://www.everydev.ai/p/the-rise-fall-and-rebirth-of-clawdbot-in-72-hours)
- [openclaw - npm](https://www.npmjs.com/package/openclaw)
- [Installer Internals - OpenClaw Official Docs](https://docs.openclaw.ai/install/installer)
- [OpenClaw GitHub Repository](https://github.com/openclaw/openclaw)

---

## Sitemap

Índice completo del sitio: [/sitemap.md](https://angelcruz.dev/sitemap.md)

Canónico HTML: [https://angelcruz.dev/post/como-instalar-openclaw-guia-completa](https://angelcruz.dev/post/como-instalar-openclaw-guia-completa)