---
title: "Como Configurar OpenClaw no Slack - Guia Completo"
url: "https://openclaw.ia.br/tutoriais/slack/"
markdown_url: "https://openclaw.ia.br/tutoriais/slack.MD"
description: "Integre seu agente OpenClaw ao Slack para automatizar tarefas, responder perguntas e participar de canais. Tutorial completo com configuração de app e permissões."
date: "2026-02-01"
author: ""
---

# Como Configurar OpenClaw no Slack - Guia Completo

Integre seu agente OpenClaw ao Slack para automatizar tarefas, responder perguntas e participar de canais. Tutorial completo com configuração de app e permissões.


# Como Configurar OpenClaw no Slack

Transforme seu agente OpenClaw em um membro ativo do seu workspace Slack. Responda perguntas, automatize tarefas e integre com seus workflows existentes.

## Pré-requisitos

- OpenClaw instalado e funcionando ([guia de instalação](/instalacao/))
- Conta no Slack com permissão de admin no workspace
- Acesso à criação de apps no workspace

## Visão Geral da Arquitetura

O OpenClaw se conecta ao Slack de duas formas:

1. **Socket Mode** (recomendado): Conexão WebSocket, sem servidor público
2. **HTTP Mode**: Requer URL pública para webhooks

Este tutorial foca no Socket Mode, mais simples de configurar.

## Passo 1: Criar App no Slack

### 1.1 Acessar Portal de Apps

1. Acesse [api.slack.com/apps](https://api.slack.com/apps)
2. Clique em **"Create New App"**
3. Escolha **"From scratch"**

### 1.2 Configurar App

1. **App Name:** "OpenClaw Assistant" (ou nome de sua preferência)
2. **Workspace:** Selecione seu workspace
3. Clique em **"Create App"**

## Passo 2: Configurar Permissões

### 2.1 OAuth & Permissions

No menu lateral, acesse **"OAuth & Permissions"**

#### Bot Token Scopes (adicione todos):

**Mensagens:**
- `chat:write` - Enviar mensagens
- `chat:write.public` - Enviar em canais públicos
- `im:write` - Enviar DMs
- `im:history` - Ler histórico de DMs

**Canais:**
- `channels:history` - Ler histórico de canais públicos
- `channels:read` - Ver lista de canais
- `groups:history` - Ler canais privados (se necessário)
- `groups:read` - Ver canais privados

**Usuários:**
- `users:read` - Ver informações de usuários
- `users:read.email` - Ver emails (opcional)

**Reações:**
- `reactions:read` - Ver reações
- `reactions:write` - Adicionar reações

**Arquivos (opcional):**
- `files:read` - Ler arquivos compartilhados
- `files:write` - Enviar arquivos

### 2.2 Instalar App no Workspace

1. Role até **"OAuth Tokens for Your Workspace"**
2. Clique em **"Install to Workspace"**
3. Revise permissões e clique em **"Allow"**
4. Copie o **"Bot User OAuth Token"** (começa com `xoxb-`)

## Passo 3: Habilitar Socket Mode

### 3.1 Ativar Socket Mode

1. No menu lateral, acesse **"Socket Mode"**
2. Ative **"Enable Socket Mode"**

### 3.2 Gerar App-Level Token

1. Clique em **"Generate"** em "App-Level Tokens"
2. Nome: "openclaw-socket"
3. Scope: `connections:write`
4. Clique em **"Generate"**
5. Copie o token (começa com `xapp-`)

## Passo 4: Configurar Eventos

### 4.1 Event Subscriptions

1. Acesse **"Event Subscriptions"** no menu lateral
2. Ative **"Enable Events"**

### 4.2 Subscribe to Bot Events

Adicione os seguintes eventos:

**Mensagens:**
- `message.channels` - Mensagens em canais públicos
- `message.groups` - Mensagens em canais privados
- `message.im` - Mensagens diretas
- `message.mpim` - Grupos de DM

**Menções:**
- `app_mention` - Quando o bot é mencionado

**Reações (opcional):**
- `reaction_added` - Quando alguém reage
- `reaction_removed` - Quando remove reação

3. Clique em **"Save Changes"**

## Passo 5: Configurar OpenClaw

### 5.1 Adicionar Credenciais

Edite seu arquivo de configuração (`config.yaml`):

```yaml
channels:
  slack:
    enabled: true
    
    # Tokens (obrigatórios)
    botToken: "xoxb-seu-bot-token"
    appToken: "xapp-seu-app-token"
    
    # Configurações básicas
    appId: "A0123456789"       # ID do app (Basic Information)
    signingSecret: "abc123"    # Signing Secret (Basic Information)
```

### 5.2 Obter App ID e Signing Secret

1. No portal do Slack, acesse **"Basic Information"**
2. Copie o **"App ID"**
3. Copie o **"Signing Secret"**

### 5.3 Reiniciar OpenClaw

```bash
openclaw gateway restart
```

## Passo 6: Testar Integração

### 6.1 Adicionar Bot ao Canal

1. Abra o canal desejado no Slack
2. Digite: `/invite @OpenClaw Assistant`
3. Ou clique no nome do canal > Integrações > Adicionar apps

### 6.2 Testar Mensagem

Mencione o bot:
```
@OpenClaw Olá, você está funcionando?
```

### 6.3 Testar DM

Envie uma mensagem direta para o bot.

## Configurações Avançadas

### Controle de Acesso

```yaml
channels:
  slack:
    # Limitar a canais específicos
    allowedChannels:
      - "C0123456789"  # ID do canal
      - "bot-commands"  # Nome do canal
    
    # Bloquear canais específicos
    blockedChannels:
      - "off-topic"
      - "random"
    
    # Limitar a usuários específicos
    allowedUsers:
      - "U0123456789"  # Admin
    
    # Responder apenas quando mencionado
    mentionOnly: true
```

### Formatação de Mensagens

```yaml
channels:
  slack:
    formatting:
      useBlocks: true        # Usar Block Kit para mensagens ricas
      useThreads: true       # Responder em threads
      unfurlLinks: false     # Não expandir previews de links
```

### Reações Automáticas

```yaml
channels:
  slack:
    reactions:
      onReceive: "eyes"      #  ao receber mensagem
      onProcess: "hourglass" # ⏳ processando
      onComplete: "white_check_mark"  # ✅ completou
      onError: "x"           # ❌ erro
```

### Threads

```yaml
channels:
  slack:
    threads:
      enabled: true
      alwaysReplyInThread: false  # Responder no thread se existir
      createThreadFor:
        - "long_response"    # Respostas longas
        - "code"             # Blocos de código
```

## Slack Blocks (Mensagens Ricas)

### Formato Básico

O OpenClaw pode enviar mensagens formatadas com Blocks:

```yaml
channels:
  slack:
    formatting:
      useBlocks: true
      defaultBlocks:
        - type: "section"
          text:
            type: "mrkdwn"
            text: "*Resposta do OpenClaw*"
```

### Exemplos de Blocks

**Mensagem com Botões:**
```json
{
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "Deseja continuar?"
      }
    },
    {
      "type": "actions",
      "elements": [
        {
          "type": "button",
          "text": {"type": "plain_text", "text": "Sim"},
          "action_id": "confirm_yes"
        },
        {
          "type": "button",
          "text": {"type": "plain_text", "text": "Não"},
          "action_id": "confirm_no"
        }
      ]
    }
  ]
}
```

## Slash Commands

### Configurar no Slack

1. Acesse **"Slash Commands"** no menu
2. Clique em **"Create New Command"**
3. Configure:
   - Command: `/openclaw`
   - Request URL: (não necessário com Socket Mode)
   - Description: "Interagir com OpenClaw"

### Configurar no OpenClaw

```yaml
channels:
  slack:
    slashCommands:
      enabled: true
      commands:
        - name: "/openclaw"
          description: "Comando principal"
        - name: "/lembrete"
          description: "Criar lembrete"
        - name: "/status"
          description: "Status do sistema"
```

### Usar Comandos

No Slack:
```
/openclaw ajuda
/lembrete "Reunião às 15h" em 30 minutos
/status
```

## Workflows e Automações

### Integrar com Workflow Builder

O OpenClaw pode ser acionado por Workflows do Slack:

1. No Slack, acesse **"Automations" > "Workflow Builder"**
2. Crie novo workflow
3. Adicione step "Send a webhook"
4. Configure para enviar para OpenClaw

### Agendamento de Mensagens

```yaml
channels:
  slack:
    scheduling:
      enabled: true
      allowScheduledMessages: true
```

Exemplo de uso:
```
@OpenClaw agende mensagem "Bom dia, equipe!" para #geral amanhã às 9h
```

## Boas Práticas

### 1. SOUL.md para Slack

Adicione instruções específicas:

```markdown
## Comportamento no Slack

### Em Canais Públicos:
- Responda apenas quando mencionado
- Use threads para conversas longas
- Mantenha respostas concisas
- Use reações para reconhecer sem poluir

### Em DMs:
- Responda a todas as mensagens
- Pode ser mais detalhado
- Mantenha contexto da conversa

### Formatação:
- Use *negrito* para ênfase
- Use `código` para comandos
- Use blocos de código para scripts
- Evite mensagens muito longas (use threads)
```

### 2. Limites de Taxa

Slack tem rate limits rigorosos:

```yaml
channels:
  slack:
    rateLimit:
      messagesPerSecond: 1
      messagesPerMinute: 30
      burstLimit: 5
```

### 3. Tratamento de Erros

```yaml
channels:
  slack:
    errorHandling:
      retryOnError: true
      maxRetries: 3
      notifyOnError: true
      errorChannel: "bot-errors"
```

## Casos de Uso

### Bot de Suporte IT

```yaml
channels:
  slack:
    allowedChannels:
      - "ti-suporte"
    mentionOnly: false  # Responder a todas mensagens no canal
```

SOUL.md:
```markdown
Você é o assistente de TI no Slack.
- Responda dúvidas técnicas
- Crie tickets para problemas complexos
- Mantenha base de conhecimento atualizada
```

### Assistente de Equipe

```yaml
channels:
  slack:
    mentionOnly: true
    threads:
      enabled: true
```

SOUL.md:
```markdown
Você auxilia a equipe de desenvolvimento.
- Resuma discussões quando pedido
- Ajude com documentação
- Lembre de reuniões e deadlines
```

### Bot de Onboarding

```yaml
channels:
  slack:
    allowedChannels:
      - "novos-membros"
    reactions:
      onJoin: "wave"
```

SOUL.md:
```markdown
Você dá boas-vindas a novos membros.
- Explique os canais principais
- Compartilhe recursos úteis
- Responda perguntas frequentes
```

## Solução de Problemas

### Bot Não Conecta

1. Verifique se Socket Mode está ativo
2. Confirme que `appToken` (xapp-) está correto
3. Verifique logs: `openclaw status`

### Bot Não Responde

1. Confirme que eventos estão configurados
2. Verifique se bot está no canal
3. Teste em DM para isolar problema

### Erro de Permissão

```
missing_scope: chat:write
```

Solução:
1. Adicione scope em OAuth & Permissions
2. Reinstale o app no workspace
3. Reinicie OpenClaw

### Rate Limited

```
ratelimited: too many requests
```

Solução:
```yaml
channels:
  slack:
    rateLimit:
      messagesPerSecond: 0.5
      cooldownMs: 2000
```

### Socket Desconecta

Verifique se `appToken` tem scope `connections:write`:
1. Basic Information > App-Level Tokens
2. Delete e regenere se necessário

## Segurança

### Verificar Assinaturas

```yaml
channels:
  slack:
    security:
      verifySignature: true
      signingSecret: "seu-signing-secret"
```

### Tokens Seguros

Nunca commite tokens no código:

```bash
# Use variáveis de ambiente
export SLACK_BOT_TOKEN="xoxb-..."
export SLACK_APP_TOKEN="xapp-..."
```

```yaml
channels:
  slack:
    botToken: "${SLACK_BOT_TOKEN}"
    appToken: "${SLACK_APP_TOKEN}"
```

## Métricas e Logs

### Habilitar Logging

```yaml
channels:
  slack:
    logging:
      enabled: true
      level: "info"
      logChannel: "bot-logs"
```

### Métricas

Acompanhe uso do bot:
- Mensagens processadas
- Tempo de resposta
- Erros por tipo
- Canais mais ativos

## Próximos Passos

- [Configurar Discord](/tutoriais/discord/) - Integração com Discord
- [Criar Skills](/tutoriais/criar-skills/) - Expanda funcionalidades
- [Configurar Memória](/tutoriais/configurar-memoria/) - Contexto persistente
- [Guia de Segurança](/guias/seguranca/) - Proteja suas integrações

---

**Dica:** O Slack tem um ambiente de desenvolvimento em [api.slack.com/sandbox](https://api.slack.com/sandbox) onde você pode testar sem afetar seu workspace real.