Connecteur Slack

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

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
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
2. Ajoutez les scopes OAuth requis dans « OAuth & Permissions »
3. Installez l’application dans le workspace
4. Copiez le Bot User OAuth Token (xoxb-...)

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 :

# 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

Configuration

Configuration de base

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 :

Méthodes API

Messagerie

Canaux

Utilisateurs

Interactions

Événements

Notifications Brevo-vers-Slack

Déclencheurs Slack-vers-Brevo

Exemples de code

Initialiser le connecteur

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

// Envoyer une notification lors d'une commande à forte valeur
await tajo.slack.notify({
  channel: 'sales',
  event: 'order_placed',
  data: {
    customerEmail: '[email protected]',
    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:*\n[email protected]' },
          { 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

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 :

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

Dépannage

Problèmes courants

Mode debug

Activez la journalisation verbeuse :

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

Tester la connexion

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
• Slack Block Kit Builder
• Slack Events API
• Connecteur Brevo
• Skill de synchronisation client