---
title: "Connecteur Slack"
description: "Guide complet d'intégration Slack pour envoyer des notifications, synchroniser les données de canaux et déclencher des automatisations Brevo depuis les événements Slack via Tajo."
url: https://tajo.io/fr/docs/connectors/custom/slack/
markdown: https://tajo.io/fr/docs/connectors/custom/slack.md
lang: fr-FR
robots: noindex
---

Demandez un accès anticipé

Indiquez votre prénom et votre adresse e-mail professionnelle. Nous vous enverrons un lien pour confirmer votre demande d’accès à Tajo.

# Connecteur Slack

Statut du connecteur: Prévu Pas encore construit. Tajo n'exécute pas ce connecteur aujourd'hui.

| Champ source | Champ de destination | Valeur d’exemple |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Connectez votre workspace Slack à Brevo via Tajo pour des notifications marketing en temps réel, des alertes d’équipe sur les événements clients et l’automatisation de workflows déclenchés par les interactions Slack.

## Vue d’ensemble

| Propriété | Valeur |
| --- | --- |
| **Plateforme** | Slack |
| **Catégorie** | Intégration personnalisée |
| **Complexité d’installation** | Facile |
| **Intégration officielle** | Non |
| **Données synchronisées** | Utilisateurs, canaux, messages, événements |
| **URL de base de l’API** | `https://slack.com/api` |

## Fonctionnalités

- **Alertes marketing**, Envoyez des notifications en temps réel pour les événements de campagne, nouveaux abonnés et jalons de revenus
- **Notifications d’événements clients**, Alertez les équipes lors d’actions clients à forte valeur depuis Brevo
- **Déclencheurs de workflows**, Utilisez les interactions Slack (clics de boutons, soumissions de formulaires) pour déclencher des automatisations Brevo
- **Routage basé sur les canaux**, Routez les notifications vers des canaux spécifiques selon le type d’événement ou le segment client
- **Synchronisation d’utilisateurs**, Mappez les utilisateurs du workspace Slack aux contacts Brevo pour les communications internes
- **Messages interactifs**, Envoyez des messages riches avec boutons et actions pour les workflows d’équipe
- **Messages planifiés**, Planifiez les notifications pour les résumés marketing quotidiens/hebdomadaires
- **Prise en charge des threads**, Regroupez les notifications liées dans des threads pour une communication organisée

## Prérequis

Avant de commencer, assurez-vous de disposer de :

1. Un workspace Slack avec accès admin
2. Une application Slack créée sur [api.slack.com/apps](https://api.slack.com/apps)
3. Un bot token avec les scopes requis
4. Un compte Brevo avec accès API
5. Un compte Tajo

## Authentification

### Bot Token (recommandé)

Installez une application Slack dans votre workspace et utilisez le bot token pour l’accès API.

1. Créez l’application sur [api.slack.com/apps](https://api.slack.com/apps)
2. Ajoutez les scopes OAuth requis dans « OAuth & Permissions »
3. Installez l’application dans le workspace
4. Copiez le 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

Pour distribuer votre intégration Slack à plusieurs workspaces :

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

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

#### Scopes bot requis

```
chat:write           # Envoyer des messages
channels:read        # Lister les canaux
channels:history     # Lire les messages de canaux
users:read           # Lister les utilisateurs du workspace
users:read.email     # Lire les adresses e-mail utilisateur
reactions:write      # Ajouter des réactions aux messages
files:write          # Uploader des fichiers
```

Accès aux e-mails utilisateur

Le scope `users:read.email` est requis pour faire correspondre les utilisateurs Slack aux contacts Brevo. Sans lui, le mappage utilisateur sera limité aux noms affichés.

## Configuration

### Configuration de base

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

    # Canaux de notification
    channels:
      marketing: "C01234567"
      sales: "C01234568"
      support: "C01234569"
      alerts: "C01234570"

    # Routage d'événements
    notifications:
      new_subscriber:
        channel: marketing
        template: subscriber_alert
      high_value_order:
        channel: sales
        template: order_alert
      support_ticket:
        channel: support
        template: ticket_alert
```

### Mappage des champs

Mappez les données utilisateur Slack vers les attributs de contact Brevo :

#### Default Mappings

| Parameter | Type | Description |
| --- | --- | --- |
| `profile.email` required | string | E-mail utilisateur (identifiant unique pour la correspondance Brevo) |
| `real_name` optional | string | Nom complet, réparti en FIRSTNAME/LASTNAME |
| `profile.phone` optional | string | Mappé vers l'attribut SMS |
| `profile.title` optional | string | Intitulé de poste |
| `tz` optional | string | Fuseau horaire de l'utilisateur |
| `is_admin` optional | boolean | Statut admin du workspace |
| `team_id` optional | string | ID d'équipe du workspace |
| `status_text` optional | string | Statut personnalisé de l'utilisateur |

## Méthodes API

### Messagerie

| Méthode | Endpoint | Description |
| --- | --- | --- |
| `POST` | `chat.postMessage` | Envoyer un message vers un canal |
| `POST` | `chat.update` | Mettre à jour un message existant |
| `POST` | `chat.delete` | Supprimer un message |
| `POST` | `chat.scheduleMessage` | Planifier un message |
| `POST` | `chat.postEphemeral` | Envoyer un message éphémère à un utilisateur |

### Canaux

| Méthode | Endpoint | Description |
| --- | --- | --- |
| `GET` | `conversations.list` | Lister les canaux |
| `GET` | `conversations.info` | Obtenir les infos d’un canal |
| `GET` | `conversations.members` | Lister les membres d’un canal |
| `GET` | `conversations.history` | Obtenir les messages d’un canal |

### Utilisateurs

| Méthode | Endpoint | Description |
| --- | --- | --- |
| `GET` | `users.list` | Lister les utilisateurs du workspace |
| `GET` | `users.info` | Obtenir les infos d’un utilisateur |
| `GET` | `users.lookupByEmail` | Trouver un utilisateur par e-mail |
| `GET` | `users.conversations` | Lister les canaux d’un utilisateur |

### Interactions

| Méthode | Endpoint | Description |
| --- | --- | --- |
| `POST` | `views.open` | Ouvrir une vue modale |
| `POST` | `views.update` | Mettre à jour une vue modale |
| `POST` | `reactions.add` | Ajouter une réaction emoji |

## Événements

### Notifications Brevo-vers-Slack

| Événement | Déclencheur | Action Slack |
| --- | --- | --- |
| `new_subscriber` | Contact créé dans Brevo | Publier dans #marketing |
| `campaign_sent` | Campagne e-mail envoyée | Publier un résumé dans #marketing |
| `order_placed` | Commande à forte valeur détectée | Publier dans #sales avec les détails |
| `cart_abandoned` | Panier abandonné depuis 30 min | Publier dans #sales pour suivi |
| `ticket_created` | Ticket de support ouvert | Publier dans #support |
| `unsubscribed` | Contact désabonné | Publier une alerte dans #marketing |

### Déclencheurs Slack-vers-Brevo

| Événement Slack | Déclencheur | Action Brevo |
| --- | --- | --- |
| `message_action` | Raccourci de message personnalisé | Ajouter un contact à une liste ou déclencher une automatisation |
| `block_actions` | Clic sur bouton dans un message | Mettre à jour un attribut de contact ou envoyer un e-mail |
| `view_submission` | Formulaire modal soumis | Créer un contact ou déclencher un workflow |

## Exemples de code

### Initialiser le connecteur

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

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

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

### Envoyer des notifications marketing

```javascript
// Envoyer une notification lors d'une commande à forte valeur
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'
          }
        ]
      }
    ]
  }
});
```

### Gérer les interactions Slack

```javascript
import crypto from 'crypto';

app.post('/slack/interactions', async (req, res) => {
  // Vérifier la signature de la requête Slack
  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);

  // Gérer les actions sur boutons
  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 débit

Les limites de débit de l’API Slack utilisent un système par tiers :

| Tier | Limite | Méthodes courantes |
| --- | --- | --- |
| Tier 1 | 1 requête/minute | `chat.delete`, `conversations.kick` |
| Tier 2 | 20 requêtes/minute | `conversations.history`, `users.info` |
| Tier 3 | 50 requêtes/minute | `conversations.list`, `users.list` |
| Tier 4 | 100 requêtes/minute | `chat.postMessage` |
| Spécial | Variable | `chat.postMessage` vers le même canal : 1/s |

Limites supplémentaires :

- **Web API** : limite de burst avec throttling à court terme
- **Events API** : livraison avec retry sur 3 tentatives
- **Incoming Webhooks** : 1 message/seconde par URL de webhook
- **Block Kit** : maximum 50 blocs par message

Fréquence de publication dans un canal

La publication dans le même canal est limitée à environ 1 message par seconde. Groupez les notifications ou utilisez des threads pour éviter le rate limiting.

## Dépannage

### Problèmes courants

| Problème | Cause | Solution |
| --- | --- | --- |
| `not_authed` | Bot token invalide | Réinstallez l’application et copiez le nouveau bot token |
| `channel_not_found` | Bot absent du canal | Invitez le bot dans le canal cible |
| `missing_scope` | Scope requis non accordé | Ajoutez le scope et réinstallez l’application |
| Événement non reçu | Abonnement d’événement non configuré | Configurez l’URL Event Subscriptions |
| Timeout d’interaction | Réponse > 3 secondes | Répondez immédiatement 200, traitez en asynchrone |

### Mode debug

Activez la journalisation verbeuse :

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

### Tester la connexion

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

## Bonnes pratiques

1. **Utilisez Block Kit**, Construisez des messages riches et interactifs avec le framework Block Kit de Slack
2. **Répondez rapidement**, Acquittez les interactions en moins de 3 secondes, traitez-les en asynchrone
3. **Mettez les messages associés en thread**, Regroupez les notifications liées en threads pour réduire le bruit
4. **Routez par canal**, Envoyez différents types d’événements vers les canaux d’équipe appropriés
5. **Incluez des boutons d’action**, Ajoutez des boutons « View in Brevo » pour un accès rapide aux données clients
6. **Implémentez l’unfurling**, Affichez des previews riches pour les liens Brevo partagés dans Slack

## Sécurité

- **Bot Token**, Token d’accès OAuth à portée limitée avec permissions granulaires
- **Signature de requête**, Vérification de signature HMAC SHA-256 pour les requêtes entrantes
- **OAuth 2.0**, Autorisation standard de l’industrie pour la distribution multi-workspaces
- **Chiffrement TLS**, Toutes les communications API chiffrées via HTTPS
- **Rotation des tokens**, Rotation automatique des tokens pour une sécurité renforcée

## Ressources associées

- [Documentation de l’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)
- [Connecteur Brevo](https://tajo.io/fr/docs/connectors/marketing/brevo)
- [Skill de synchronisation client](https://tajo.io/fr/docs/skills/data-sync/customer-sync)