Configuración de Slack con OpenClaw

Integrar bots en plataformas de chat suele ser un proceso tedioso. Pasas demasiado tiempo configurando permisos, lidiando con firewalls o intentando que los webhooks respondan correctamente. Es frustrante cuando solo quieres que tu bot procese mensajes y terminas peleando con la infraestructura. Para evitar estos problemas, te recomiendo usar Socket Mode, que es la opción más directa y estable para conectar OpenClaw sin exponer URLs públicas.

Requisitos previos

Para empezar con esta integración, necesitas cumplir con estos requisitos:

• Una Slack app creada en tu panel de desarrollador.
• App Token (xapp-...) y Bot Token (xoxb-...).
• Permisos de eventos configurados en Slack.
• Acceso a la CLI de OpenClaw.

Inicio rápido

Sigue estos pasos para tener tu integración lista en menos de 5 minutos.

Opción 1: Socket Mode (Recomendado)

Es el modo por defecto y el más sencillo de configurar.

1. Crea tu Slack app y genera tokens En los ajustes de tu aplicación en Slack:

   • Activa Socket Mode.
   • Crea un App Token (xapp-...) con el scope connections:write.
   • Instala la app en tu workspace y copia el Bot Token (xoxb-...).

2. Configura OpenClaw Añade la configuración en tu archivo JSON5:

   {
     channels: {
       slack: {
         enabled: true,
         mode: "socket",
         appToken: "xapp-...",
         botToken: "xoxb-...",
       },
     },
   }

   También puedes usar variables de entorno para la cuenta principal:

   SLACK_APP_TOKEN=xapp-...
   SLACK_BOT_TOKEN=xoxb-...

3. Suscríbete a los eventos de la app Configura los “Bot Events” para los siguientes eventos:

   • app_mention y message.channels.
   • message.groups y message.im.
   • message.mpim y reaction_added.
   • reaction_removed y member_joined_channel.
   • member_left_channel y channel_rename.
   • pin_added y pin_removed.

   No olvides activar la pestaña Messages Tab en “App Home” para habilitar los mensajes directos (DMs).

4. Inicia el Gateway Ejecuta el siguiente comando en tu terminal:

   openclaw gateway

Opción 2: HTTP Events API mode

Usa este modo si prefieres trabajar con webhooks tradicionales.

1. Prepara Slack para HTTP Cambia el modo a HTTP e identifica tu Signing Secret.

2. Configura las URLs de solicitud En Slack, establece la “Request URL” para Event Subscriptions, Interactivity y Slash commands usando tu ruta de webhook (por defecto es /slack/events).

3. Define la configuración técnica

   {
     channels: {
       slack: {
         enabled: true,
         mode: "http",
         botToken: "xoxb-...",
         signingSecret: "tu-signing-secret",
         webhookPath: "/slack/events",
       },
     },
   }

4. Gestiona múltiples cuentas Si usas varias cuentas en modo HTTP, asigna a cada una un webhookPath único para evitar que las peticiones choquen entre sí.

Solución de problemas

Si encuentras problemas durante la configuración, revisa estos puntos:

• Utiliza los playbooks de reparación en el panel de diagnósticos si los mensajes no se entregan en canales específicos.
• Verifica que los tokens tengan los scopes correctos si el Gateway falla al conectar.

Si necesitas ayuda específica con tu archivo de configuración, consulta al AI Setup Assistant.

Próximos pasos

• Pairing en Slack
• Slash commands
• Troubleshooting de canales

---
title: Configuración del modelo de tokens y control de acceso en Slack
description: Guía técnica para gestionar botTokens, appTokens y políticas de canales en tu integración de Slack.
---

¿Alguna vez has perdido horas intentando entender por qué tu bot de Slack no responde o por qué tiene acceso a canales que no debería? Configurar la autenticación y los permisos suele ser la parte más frustrante de cualquier integración, especialmente cuando las variables de entorno y los archivos de configuración no parecen ponerse de acuerdo.

Manejar correctamente los tokens y las políticas de acceso no es solo una cuestión de seguridad, sino de evitar que tu Gateway se comporte de forma inesperada en producción.

## Requisitos previos

Para configurar este modelo, necesitas tener a mano los siguientes elementos mencionados en la documentación oficial:

- `botToken` y `appToken` (obligatorios para Socket Mode).
- `signingSecret` (obligatorio para HTTP mode).
- Un `userToken` (opcional, formato `xoxp-...`).
- Acceso al archivo de configuración de `channels.slack`.

## Inicio rápido

Configura tus tokens en 5 minutos siguiendo estas reglas de prioridad:

1. **Prioridad de configuración**: Los tokens definidos en tu archivo de configuración siempre mandan sobre las variables de entorno.
2. **Fallback de entorno**: `SLACK_BOT_TOKEN` y `SLACK_APP_TOKEN` solo funcionan como respaldo para la cuenta por defecto.
3. **User Tokens**: El `userToken` solo se puede definir en el config (no hay fallback de entorno) y por defecto es de solo lectura (`userTokenReadOnly: true`).

Si necesitas que el `userToken` realice escrituras, debes configurarlo así:
- Establece `userTokenReadOnly: false`.
- Asegúrate de que el `botToken` no esté disponible (el sistema prefiere el `botToken` para escrituras).

### Control de acceso en DMs y Canales

Para gestionar quién puede interactuar con el bot, utiliza las políticas de `channels.slack`.

**Para DMs (Mensajes Directos):**
La política por defecto es `pairing`. Si quieres que el bot esté abierto a cualquier usuario, cambia la política a `open` y asegúrate de que `dm.allowFrom` incluya `"*"`.

Si usas la política `pairing`, utiliza este comando para aprobar el acceso:
```bash
openclaw pairing approve slack <code>

Para Canales: Si omites la sección channels.slack y no defines channels.defaults.groupPolicy, el sistema usará por defecto groupPolicy="open" y mostrará un aviso en los logs. Lo ideal es definir una allowlist bajo channels.slack.channels para tener un control granular.

Solución de problemas

Si encuentras problemas durante la ejecución, revisa estos puntos basados en el comportamiento del runtime:

• Tokens no reconocidos: Si estás usando una cuenta que no es la predeterminada, las variables de entorno SLACK_BOT_TOKEN no funcionarán. Debes definirlos explícitamente en el config.
• El bot no responde en grupos: Por defecto, los mensajes en canales requieren mención. Verifica si estás usando la mención explícita (<@botId>) o si el patrón de regex en mentionPatterns es correcto.
• Entradas no resueltas: Si los IDs de canales en tu allowlist no se resuelven al inicio, el sistema mantendrá la configuración tal cual. Revisa si el token tiene permisos de lectura para esos canales.
• Escrituras fallidas con User Token: Recuerda que las escrituras con userToken solo se permiten si userTokenReadOnly es false y el botToken no está configurado.

¿Necesitas ayuda para generar tu archivo de configuración? Prueba nuestro AI Setup Assistant.

Próximos pasos

• Configuración avanzada de channels.slack.channels
• Definición de skills y tools por canal
• Gestión de mentionPatterns en agents.list

Integrar un bot en Slack suele ser frustrante cuando los comandos no responden como esperas o los hilos de conversación se vuelven un caos. Configurar correctamente los slash commands y la persistencia de las sesiones es vital para que la experiencia de los usuarios sea clara y funcional desde el primer mensaje.

Aquí tienes los detalles técnicos para dominar el comportamiento de Slack en tu Gateway.

## Requisitos previos

- Una instancia de Node.js configurada con el agente.
- Acceso a la configuración del canal de Slack.
- Permisos de administrador en tu espacio de trabajo de Slack para registrar slash commands.

## Inicio rápido

Sigue estos pasos para activar la respuesta a comandos en menos de 5 minutos:

1. **Activa los comandos nativos**: Por defecto, el modo automático está desactivado para Slack. Cambia `channels.slack.commands.native: true` (o usa el global `commands.native: true`).
2. **Registra los comandos en Slack**: Una vez activados, debes registrar manualmente los nombres de los comandos (`/<command>`) en el panel de configuración de tu App en Slack.
3. **Configura el comando por defecto**: Si decides no usar comandos nativos, puedes ejecutar un único comando configurado mediante `channels.slack.slashCommand`.
4. **Define el comportamiento de las respuestas**: Ajusta `channels.slack.replyToMode` a `first` o `all` según necesites que el bot responda en hilos.

## Detalles de Configuración y Sesiones

### Slash Commands
Cuando usas slash commands, las sesiones utilizan llaves aisladas para evitar colisiones de datos:
`agent:<agentId>:slack:slash:<userId>`

Aun así, la ejecución del comando se enruta contra la sesión de la conversación objetivo mediante `CommandTargetSessionKey`. Los ajustes por defecto son:
- `enabled: false`
- `name: "openclaw"`
- `sessionPrefix: "slack:slash"`
- `ephemeral: true`

### Sesiones e Hilos
El enrutamiento depende del tipo de chat:
- **DMs**: Se enrutan como `direct`.
- **Canales**: Se enrutan como `channel`.
- **MPIMs**: Se enrutan como `group`.

Con `session.dmScope=main`, los DMs de Slack se colapsan en la sesión principal del agente. Para canales, la estructura es `agent:<agentId>:slack:channel:<channelId>`. Si respondes en hilos, se crean sufijos específicos: `:thread:<threadTs>`.

Controles de hilos disponibles:
- `channels.slack.thread.historyScope`: Por defecto es `thread`.
- `thread.inheritParent`: Por defecto es `false`.
- `channels.slack.replyToMode`: Opciones `off`, `first`, `all`.

También puedes usar etiquetas manuales para forzar respuestas:
- `[[reply_to_current]]`
- `[[reply_to:<id>]]`

## Media y Entrega de Archivos

Slack gestiona los archivos mediante URLs privadas protegidas por token. El sistema descarga estos archivos y los escribe en el media store si el tamaño lo permite.

- **Límite de entrada**: 20MB por defecto, ajustable con `channels.slack.mediaMaxMb`.
- **Límite de texto**: Los fragmentos de texto usan `channels.slack.textChunkLimit` (4000 caracteres).
- **Modo de fragmentación**: `channels.slack.chunkMode="newline"` para dividir por párrafos.

Para envíos explícitos, usa estos targets:
- `user:<id>` para DMs.
- `channel:<id>` para canales.

## Actions y Eventos

Las acciones de Slack se controlan mediante `channels.slack.actions.*`. Estos son los grupos disponibles:

| Group      | Default |
| ---------- | ------- |
| messages   | enabled |
| reactions  | enabled |
| pins       | enabled |
| memberInfo | enabled |
| emojiList  | enabled |

El sistema mapea automáticamente eventos como ediciones, eliminaciones, reacciones (añadir/quitar), y cambios en miembros o canales. Si activas `configWrites`, el evento `channel_id_changed` puede migrar las llaves de configuración del canal automáticamente.

## Solución de problemas

- **Los comandos nativos no funcionan**: Asegúrate de no estar usando `commands.native: "auto"`. En Slack, esto no activa los comandos; debes usar `true` explícitamente.
- **Los archivos no se descargan**: Revisa si el archivo excede los 20MB. Si es así, aumenta el valor en `channels.slack.mediaMaxMb`.
- **El bot no responde en hilos**: Verifica que `channels.slack.replyToMode` no esté en `off`.
- **Las sesiones de DM están dispersas**: Comprueba que `session.dmScope` esté configurado como `main`.

¿Necesitas ayuda con una configuración específica? Prueba nuestro [AI Setup Assistant](/docs/).

## Próximos pasos
- [Configuración Global de API](/docs/)
- [Gestión de Media Store](/docs/)
- [Seguridad y Gates](/docs/)
- [Webhooks de Slack](/docs/)

Configurar los permisos de una API suele ser la parte más tediosa del desarrollo. Es común perder tiempo intentando adivinar por qué un bot no recibe eventos o por qué un comando falla debido a un scope faltante.

Para evitar errores de configuración, lo mejor es usar una referencia clara desde el primer minuto. Esto te permite avanzar sin tener que revisar la documentación de permisos cada vez que algo falla.

## Requisitos previos

- Un archivo de configuración para el manifest de la Slack app.
- Configuración de `channels.slack.userToken` (opcional).

## Inicio rápido

Para que OpenClaw funcione correctamente, copia y pega este ejemplo de manifest en la configuración de tu aplicación. Este archivo define el bot, activa el Socket Mode y establece los eventos necesarios para interactuar con los canales.

```json
{
  "display_information": {
    "name": "OpenClaw",
    "description": "Slack connector for OpenClaw"
  },
  "features": {
    "bot_user": {
      "display_name": "OpenClaw",
      "always_online": false
    },
    "app_home": {
      "messages_tab_enabled": true,
      "messages_tab_read_only_enabled": false
    },
    "slash_commands": [
      {
        "command": "/openclaw",
        "description": "Send a message to OpenClaw",
        "should_escape": false
      }
    ]
  },
  "oauth_config": {
    "scopes": {
      "bot": [
        "chat:write",
        "channels:history",
        "channels:read",
        "groups:history",
        "im:history",
        "mpim:history",
        "users:read",
        "app_mentions:read",
        "reactions:read",
        "reactions:write",
        "pins:read",
        "pins:write",
        "emoji:read",
        "commands",
        "files:read",
        "files:write"
      ]
    }
  },
  "settings": {
    "socket_mode_enabled": true,
    "event_subscriptions": {
      "bot_events": [
        "app_mention",
        "message.channels",
        "message.groups",
        "message.im",
        "message.mpim",
        "reaction_added",
        "reaction_removed",
        "member_joined_channel",
        "member_left_channel",
        "channel_rename",
        "pin_added",
        "pin_removed"
      ]
    }
  }
}

Solución de problemas

Si configuras channels.slack.userToken y tienes problemas con las operaciones de lectura, verifica que tengas asignados estos scopes típicos:

• channels:history, groups:history, im:history, mpim:history
• channels:read, groups:read, im:read, mpim:read
• users:read
• reactions:read
• pins:read
• emoji:read
• search:read (en caso de que dependas de lecturas de búsqueda en Slack)

¿Tienes dudas sobre algún parámetro específico? Consulta al AI Setup Assistant.

Próximos pasos

• Configuración de Webhooks
• Guía de Socket Mode

¿Alguna vez has configurado un bot y te has quedado esperando una respuesta que nunca llega? Es frustrante revisar logs sin saber exactamente qué falla mientras los mensajes se pierden en el vacío. Configurar la comunicación entre tu Gateway y Slack suele presentar retos con los tokens o los permisos de los canales.

Aquí tienes los pasos directos para que todo funcione sin complicaciones.

What You’ll Need

• CLI de openclaw instalada y configurada.
• Acceso al panel de administración de tu Slack app.
• Tokens de autenticación (Bot Token y App Token).
• Permisos para leer logs en tu entorno de ejecución.

Quick Start (5 minutos)

Si algo no funciona, sigue esta ruta mínima para identificar el fallo:

1. Ejecuta openclaw doctor para validar la salud general de tu configuración.
2. Usa openclaw logs --follow para observar el flujo de eventos en tiempo real.
3. Lanza openclaw channels status --probe para verificar si el bot ve los canales.
4. Confirma que tus tokens en el archivo de configuración coinciden con los de Slack.

Troubleshooting

No hay respuestas en los canales

Si el bot está online pero no responde, revisa estos puntos en orden:

• groupPolicy
• Channel allowlist (channels.slack.channels)
• requireMention
• Allowlist de users por canal

Comandos útiles para depurar:

openclaw channels status --probe
openclaw logs --follow
openclaw doctor

Mensajes directos (DM) ignorados

Cuando los DMs no procesan nada, el problema suele estar en la política de acceso. Revisa:

• channels.slack.dm.enabled
• channels.slack.dm.policy
• Entradas en la allowlist o aprobaciones de pairing

openclaw pairing list slack

Socket Mode no conecta

Si no logras establecer la conexión inicial, valida que los tokens de bot y app sean correctos. Asegúrate también de que el Socket Mode esté activado en los ajustes de tu Slack app.

HTTP Mode no recibe eventos

Para integraciones vía HTTP, verifica los siguientes puntos de enlace:

• Signing secret correcto.
• Webhook path configurado.
• Slack Request URLs (Events + Interactivity + Slash Commands).
• Un webhookPath único para cada cuenta HTTP.

Comandos nativos o Slash Commands no funcionan

Verifica qué modo intentas usar:

• Modo de comando nativo (channels.slack.commands.native: true) con los slash commands correspondientes registrados en Slack.
• Modo de slash command único (channels.slack.slashCommand.enabled: true).

No olvides revisar commands.useAccessGroups y las allowlists de canales o usuarios.

Configuration reference pointers

Si necesitas ajustar parámetros específicos, usa estas referencias:

Referencia principal:

• Configuration reference - Slack

Campos de Slack con alta relevancia:

• mode/auth: mode, botToken, appToken, signingSecret, webhookPath, accounts.*
• DM access: dm.enabled, dm.policy, dm.allowFrom, dm.groupEnabled, dm.groupChannels
• channel access: groupPolicy, channels.*, channels.*.users, channels.*.requireMention
• threading/history: replyToMode, replyToModeByChatType, thread.*, historyLimit, dmHistoryLimit, dms.*.historyLimit
• delivery: textChunkLimit, chunkMode, mediaMaxMb
• ops/features: configWrites, commands.native, slashCommand.*, actions.*, userToken, userTokenReadOnly

¿Necesitas ayuda personalizada para tu configuración? Prueba nuestro AI Setup Assistant.

What’s Next

• Pairing
• Channel routing
• Troubleshooting
• Configuration
• Slash commands