---
title: "Conector Slack"
description: "Guia completo de integração do Slack para enviar notificações, sincronizar dados de canais e disparar automações do Brevo a partir de eventos do Slack via Tajo."
url: https://tajo.io/pt/docs/connectors/custom/slack/
markdown: https://tajo.io/pt/docs/connectors/custom/slack.md
lang: pt-BR
robots: noindex
---

Solicite acesso antecipado

Indique o seu nome e endereço de e-mail profissional. Enviaremos um link para confirmar o seu pedido de acesso ao Tajo.

# Conector Slack

Status do conector: Planejado Ainda não construído. O Tajo não executa este conector hoje.

| Campo de origem | Campo de destino | Valor de exemplo |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Conecte seu workspace Slack ao Brevo via Tajo para notificações de marketing em tempo real, alertas para a equipe sobre eventos de clientes e automação de workflow disparada por interações no Slack.

## Visão geral

| Propriedade | Valor |
| --- | --- |
| **Plataforma** | Slack |
| **Categoria** | Integração Personalizada |
| **Complexidade de configuração** | Fácil |
| **Integração oficial** | Não |
| **Dados sincronizados** | Usuários, Canais, Mensagens, Eventos |
| **URL base da API** | `https://slack.com/api` |

## Recursos

- **Alertas de marketing** - Envie notificações em tempo real para eventos de campanha, novos inscritos e marcos de receita
- **Notificações de eventos de clientes** - Alerte as equipes sobre ações de clientes de alto valor a partir do Brevo
- **Gatilhos de workflow** - Use interações do Slack (cliques em botões, envios de formulário) para disparar automações do Brevo
- **Roteamento baseado em canal** - Roteie notificações para canais específicos com base no tipo de evento ou segmento de cliente
- **Sincronização de usuários** - Mapeie usuários do workspace Slack para contatos do Brevo em comunicações internas
- **Mensagens interativas** - Envie mensagens ricas com botões e ações para workflows de equipe
- **Mensagens agendadas** - Agende notificações para resumos diários/semanais de marketing
- **Suporte a threads** - Agrupe notificações relacionadas em threads para comunicação organizada

## Pré-requisitos

Antes de começar, certifique-se de ter:

1. Um workspace Slack com acesso de admin
2. Um app Slack criado em [api.slack.com/apps](https://api.slack.com/apps)
3. Bot token com os escopos necessários
4. Uma conta Brevo com acesso à API
5. Uma conta Tajo

## Autenticação

### Bot Token (Recomendado)

Instale um app Slack no seu workspace e use o bot token para acesso à API.

1. Crie o app em [api.slack.com/apps](https://api.slack.com/apps)
2. Adicione os escopos OAuth necessários em “OAuth & Permissions”
3. Instale o app no workspace
4. Copie o Bot User OAuth Token (`xoxb-...`)

```bash
curl -X POST "https://slack.com/api/chat.postMessage" \
  -H "Authorization: Bearer xoxb-YOUR-BOT-TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"channel": "C01234567", "text": "Hello from Tajo!"}'
```

### OAuth 2.0

Para distribuir sua integração Slack para múltiplos workspaces:

```bash
# Authorization URL
https://slack.com/oauth/v2/authorize?
  client_id={client_id}&
  scope=chat:write,channels:read,users:read&
  redirect_uri={redirect_uri}

# Token exchange
curl -X POST "https://slack.com/api/oauth.v2.access" \
  -d "client_id={client_id}" \
  -d "client_secret={client_secret}" \
  -d "code={auth_code}"
```

#### Escopos de bot necessários

```
chat:write           # Send messages
channels:read        # List channels
channels:history     # Read channel messages
users:read           # List workspace users
users:read.email     # Read user email addresses
reactions:write      # Add reactions to messages
files:write          # Upload files
```

Acesso a e-mail do usuário

O escopo `users:read.email` é necessário para associar usuários do Slack a contatos do Brevo. Sem ele, o mapeamento de usuários ficará limitado a nomes de exibição.

## Configuração

### Configuração básica

```yaml
connectors:
  slack:
    enabled: true
    bot_token: "${SLACK_BOT_TOKEN}"
    signing_secret: "${SLACK_SIGNING_SECRET}"

    # Notification channels
    channels:
      marketing: "C01234567"
      sales: "C01234568"
      support: "C01234569"
      alerts: "C01234570"

    # Event routing
    notifications:
      new_subscriber:
        channel: marketing
        template: subscriber_alert
      high_value_order:
        channel: sales
        template: order_alert
      support_ticket:
        channel: support
        template: ticket_alert
```

### Mapeamento de campos

Mapeie dados de usuário do Slack para atributos de contato do Brevo:

#### Mapeamentos padrão

| Parameter | Type | Description |
| --- | --- | --- |
| `profile.email` required | string | E-mail do usuário (identificador único para correspondência no Brevo) |
| `real_name` optional | string | Nome completo, dividido em FIRSTNAME/LASTNAME |
| `profile.phone` optional | string | Mapeia para o atributo SMS |
| `profile.title` optional | string | Cargo profissional |
| `tz` optional | string | Fuso horário do usuário |
| `is_admin` optional | boolean | Status de admin do workspace |
| `team_id` optional | string | ID da equipe do workspace |
| `status_text` optional | string | Status personalizado do usuário |

## Métodos da API

### Mensagens

| Método | Endpoint | Descrição |
| --- | --- | --- |
| `POST` | `chat.postMessage` | Enviar uma mensagem para um canal |
| `POST` | `chat.update` | Atualizar uma mensagem existente |
| `POST` | `chat.delete` | Excluir uma mensagem |
| `POST` | `chat.scheduleMessage` | Agendar uma mensagem |
| `POST` | `chat.postEphemeral` | Enviar mensagem efêmera ao usuário |

### Canais

| Método | Endpoint | Descrição |
| --- | --- | --- |
| `GET` | `conversations.list` | Listar canais |
| `GET` | `conversations.info` | Obter informações do canal |
| `GET` | `conversations.members` | Listar membros do canal |
| `GET` | `conversations.history` | Obter mensagens do canal |

### Usuários

| Método | Endpoint | Descrição |
| --- | --- | --- |
| `GET` | `users.list` | Listar usuários do workspace |
| `GET` | `users.info` | Obter informações do usuário |
| `GET` | `users.lookupByEmail` | Buscar usuário por e-mail |
| `GET` | `users.conversations` | Listar canais do usuário |

### Interações

| Método | Endpoint | Descrição |
| --- | --- | --- |
| `POST` | `views.open` | Abrir uma view modal |
| `POST` | `views.update` | Atualizar uma view modal |
| `POST` | `reactions.add` | Adicionar reação emoji |

## Eventos

### Notificações Brevo-para-Slack

| Evento | Gatilho | Ação no Slack |
| --- | --- | --- |
| `new_subscriber` | Contato criado no Brevo | Publicar em #marketing |
| `campaign_sent` | Campanha de e-mail enviada | Publicar resumo em #marketing |
| `order_placed` | Pedido de alto valor detectado | Publicar em #sales com detalhes |
| `cart_abandoned` | Carrinho abandonado por 30min | Publicar em #sales para follow-up |
| `ticket_created` | Ticket de suporte aberto | Publicar em #support |
| `unsubscribed` | Contato cancelou inscrição | Publicar alerta em #marketing |

### Gatilhos Slack-para-Brevo

| Evento do Slack | Gatilho | Ação no Brevo |
| --- | --- | --- |
| `message_action` | Atalho de mensagem personalizado | Adicionar contato à lista ou disparar automação |
| `block_actions` | Clique em botão na mensagem | Atualizar atributo do contato ou enviar e-mail |
| `view_submission` | Formulário modal enviado | Criar contato ou disparar workflow |

## Exemplos de código

### Inicializar o conector

```javascript
import { TajoClient } from '@tajo/sdk';

const tajo = new TajoClient({
  apiKey: process.env.TAJO_API_KEY,
  brevoApiKey: process.env.BREVO_API_KEY
});

// Connect Slack
await tajo.connectors.connect('slack', {
  botToken: process.env.SLACK_BOT_TOKEN,
  signingSecret: process.env.SLACK_SIGNING_SECRET
});
```

### Enviar notificações de marketing

```javascript
// Send a notification when a high-value order is placed
await tajo.slack.notify({
  channel: 'sales',
  event: 'order_placed',
  data: {
    customerEmail: 'customer@example.com',
    orderValue: '$1,250.00',
    products: ['Premium Widget', 'Pro Service'],
    isFirstOrder: true
  },
  template: {
    blocks: [
      {
        type: 'header',
        text: { type: 'plain_text', text: 'New High-Value Order' }
      },
      {
        type: 'section',
        fields: [
          { type: 'mrkdwn', text: '*Customer:*\ncustomer@example.com' },
          { type: 'mrkdwn', text: '*Amount:*\n$1,250.00' }
        ]
      },
      {
        type: 'actions',
        elements: [
          {
            type: 'button',
            text: { type: 'plain_text', text: 'View in Brevo' },
            url: 'https://app.brevo.com/contacts'
          }
        ]
      }
    ]
  }
});
```

### Tratar interações do Slack

```javascript
import crypto from 'crypto';

app.post('/slack/interactions', async (req, res) => {
  // Verify Slack request signature
  const timestamp = req.headers['x-slack-request-timestamp'];
  const signature = req.headers['x-slack-signature'];
  const sigBasestring = `v0:${timestamp}:${req.rawBody}`;
  const mySignature = 'v0=' + crypto
    .createHmac('sha256', process.env.SLACK_SIGNING_SECRET)
    .update(sigBasestring)
    .digest('hex');

  if (signature !== mySignature) {
    return res.status(401).send('Unauthorized');
  }

  const payload = JSON.parse(req.body.payload);

  // Handle button actions
  if (payload.type === 'block_actions') {
    await tajo.connectors.handleWebhook('slack', {
      type: 'interaction',
      action: payload.actions[0].action_id,
      userId: payload.user.id,
      payload
    });
  }

  res.status(200).send();
});
```

## Limites de taxa

Os limites de taxa da API Slack usam um sistema em camadas:

| Camada | Limite | Métodos comuns |
| --- | --- | --- |
| Tier 1 | 1 requisição/minuto | `chat.delete`, `conversations.kick` |
| Tier 2 | 20 requisições/minuto | `conversations.history`, `users.info` |
| Tier 3 | 50 requisições/minuto | `conversations.list`, `users.list` |
| Tier 4 | 100 requisições/minuto | `chat.postMessage` |
| Especial | Varia | `chat.postMessage` para o mesmo canal: 1/seg |

Limites adicionais:

- **Web API**: Limite de burst com throttle de curto prazo
- **Events API**: Tentativas de entrega por 3 tentativas
- **Incoming Webhooks**: 1 mensagem/segundo por URL de webhook
- **Block Kit**: Máximo 50 blocos por mensagem

Taxa de publicação em canal

A publicação no mesmo canal é limitada a aproximadamente 1 mensagem por segundo. Agrupe notificações em lote ou use threads para evitar limitação de taxa.

## Solução de problemas

### Problemas comuns

| Problema | Causa | Solução |
| --- | --- | --- |
| `not_authed` | Bot token inválido | Reinstale o app e copie o novo bot token |
| `channel_not_found` | Bot não está no canal | Convide o bot para o canal alvo |
| `missing_scope` | Escopo necessário não concedido | Adicione o escopo e reinstale o app |
| Evento não recebido | Event subscription não configurada | Configure a URL de Event Subscriptions |
| Timeout de interação | Resposta >3 segundos | Responda com 200 imediatamente, processe de forma assíncrona |

### Modo de depuração

Habilite logging detalhado:

```yaml
connectors:
  slack:
    debug: true
    log_level: verbose
    log_events: true
```

### Testar conexão

```bash
tajo connectors test slack
# ✓ Bot token valid
# ✓ Workspace accessible
# ✓ Channels readable
# ✓ Message posting enabled
# ✓ Event subscriptions active
```

## Melhores práticas

1. **Use Block Kit** - Construa mensagens ricas e interativas com o framework Block Kit do Slack
2. **Responda rapidamente** - Confirme as interações em 3 segundos, processe de forma assíncrona
3. **Agrupe mensagens relacionadas em thread** - Agrupe notificações relacionadas em threads para reduzir ruído
4. **Roteie por canal** - Envie diferentes tipos de eventos para canais apropriados da equipe
5. **Inclua botões de ação** - Adicione botões “Ver no Brevo” para acesso rápido aos dados do cliente
6. **Implemente unfurling** - Exiba previews ricos para links do Brevo compartilhados no Slack

## Segurança

- **Bot Token** - Token de acesso com escopo OAuth e permissões granulares
- **Assinatura de requisições** - Verificação de assinatura HMAC SHA-256 para requisições recebidas
- **OAuth 2.0** - Autorização padrão da indústria para distribuição em múltiplos workspaces
- **Criptografia TLS** - Toda a comunicação com a API é criptografada via HTTPS
- **Rotação de tokens** - Rotação automática de tokens para segurança aprimorada

## Recursos relacionados

- [Documentação da API Slack](https://api.slack.com/methods)
- [Slack Block Kit Builder](https://app.slack.com/block-kit-builder)
- [Slack Events API](https://api.slack.com/events-api)
- [Conector Brevo](https://tajo.io/pt/docs/connectors/marketing/brevo)
- [Skill de sincronização de clientes](https://tajo.io/pt/docs/skills/data-sync/customer-sync)