---
title: "Slack Connector"
description: "Vollständiger Leitfaden zur Slack-Integration für den Versand von Benachrichtigungen, das Synchronisieren von Channel-Daten und das Auslösen von Brevo-Automationen aus Slack-Events über Tajo."
url: https://tajo.io/de/docs/connectors/custom/slack/
markdown: https://tajo.io/de/docs/connectors/custom/slack.md
lang: de-DE
robots: noindex
---

Beantrage frühzeitigen Zugang

Gib deinen Vornamen und deine geschäftliche E-Mail-Adresse ein. Wir senden dir einen Link, mit dem du deine Anfrage für den Tajo-Zugang bestätigst.

# Slack Connector

Connector-Status: Geplant Noch nicht gebaut. Tajo betreibt diesen Connector heute nicht.

| Quellfeld | Zielfeld | Beispielwert |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Verbinde deinen Slack-Workspace über Tajo mit Brevo für Echtzeit-Marketing-Benachrichtigungen, Team-Alerts bei Kund:innen-Events und Workflow-Automation, ausgelöst durch Slack-Interaktionen.

## Überblick

| Eigenschaft | Wert |
| --- | --- |
| **Plattform** | Slack |
| **Kategorie** | Custom Integration |
| **Einrichtungsaufwand** | Einfach |
| **Offizielle Integration** | Nein |
| **Synchronisierte Daten** | Nutzer:innen, Channels, Nachrichten, Events |
| **API-Basis-URL** | `https://slack.com/api` |

## Funktionen

- **Marketing-Alerts** - Sende Echtzeit-Benachrichtigungen zu Kampagnen-Events, neuen Abonnent:innen und Umsatzmeilensteinen
- **Kund:innen-Event-Benachrichtigungen** - Informiere Teams über wertvolle Kund:innen-Aktionen aus Brevo
- **Workflow-Trigger** - Nutze Slack-Interaktionen (Button-Klicks, Formular-Einreichungen), um Brevo-Automationen auszulösen
- **Channel-basiertes Routing** - Leite Benachrichtigungen je nach Event-Typ oder Kund:innen-Segment an passende Channels
- **Nutzer:innen-Synchronisation** - Mappe Slack-Workspace-Nutzer:innen auf Brevo-Kontakte für interne Kommunikation
- **Interaktive Nachrichten** - Sende Rich-Nachrichten mit Buttons und Aktionen für Team-Workflows
- **Geplante Nachrichten** - Plane Benachrichtigungen für tägliche/wöchentliche Marketing-Summaries
- **Thread-Support** - Gruppiere verwandte Benachrichtigungen in Threads für organisierte Kommunikation

## Voraussetzungen

Bevor du beginnst, stelle sicher, dass du Folgendes hast:

1. Einen Slack-Workspace mit Admin-Zugriff
2. Eine Slack-App, erstellt unter [api.slack.com/apps](https://api.slack.com/apps)
3. Einen Bot-Token mit den erforderlichen Scopes
4. Ein Brevo-Konto mit API-Zugriff
5. Ein Tajo-Konto

## Authentifizierung

### Bot-Token (empfohlen)

Installiere eine Slack-App in deinem Workspace und nutze den Bot-Token für API-Zugriff.

1. App unter [api.slack.com/apps](https://api.slack.com/apps) erstellen
2. Erforderliche OAuth-Scopes unter “OAuth & Permissions” hinzufügen
3. App im Workspace installieren
4. Den Bot User OAuth Token (`xoxb-...`) kopieren

```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

Zur Verteilung deiner Slack-Integration über mehrere 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}"
```

#### Erforderliche Bot-Scopes

```
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
```

Zugriff auf Nutzer:innen-E-Mails

Der Scope `users:read.email` wird benötigt, um Slack-Nutzer:innen mit Brevo-Kontakten abzugleichen. Ohne ihn ist das Nutzer:innen-Mapping auf Anzeigenamen beschränkt.

## Konfiguration

### Grundeinrichtung

```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
```

### Feld-Mapping

Mappe Slack-Nutzer:innen-Daten auf Brevo-Kontaktattribute:

#### Standard-Mappings

| Parameter | Type | Description |
| --- | --- | --- |
| `profile.email` required | string | Nutzer:innen-E-Mail (eindeutiger Identifier fürs Brevo-Matching) |
| `real_name` optional | string | Vollständiger Name, aufgeteilt in FIRSTNAME/LASTNAME |
| `profile.phone` optional | string | Mapping auf SMS-Attribut |
| `profile.title` optional | string | Berufsbezeichnung |
| `tz` optional | string | Zeitzone der Nutzer:in |
| `is_admin` optional | boolean | Workspace-Admin-Status |
| `team_id` optional | string | Workspace-Team-ID |
| `status_text` optional | string | Custom-Status der Nutzer:in |

## API-Methoden

### Messaging

| Methode | Endpoint | Beschreibung |
| --- | --- | --- |
| `POST` | `chat.postMessage` | Nachricht an einen Channel senden |
| `POST` | `chat.update` | Bestehende Nachricht aktualisieren |
| `POST` | `chat.delete` | Nachricht löschen |
| `POST` | `chat.scheduleMessage` | Nachricht planen |
| `POST` | `chat.postEphemeral` | Ephemere Nachricht an Nutzer:in senden |

### Channels

| Methode | Endpoint | Beschreibung |
| --- | --- | --- |
| `GET` | `conversations.list` | Channels auflisten |
| `GET` | `conversations.info` | Channel-Infos abrufen |
| `GET` | `conversations.members` | Channel-Mitglieder auflisten |
| `GET` | `conversations.history` | Channel-Nachrichten abrufen |

### Nutzer:innen

| Methode | Endpoint | Beschreibung |
| --- | --- | --- |
| `GET` | `users.list` | Workspace-Nutzer:innen auflisten |
| `GET` | `users.info` | Nutzer:innen-Info abrufen |
| `GET` | `users.lookupByEmail` | Nutzer:in per E-Mail suchen |
| `GET` | `users.conversations` | Channels der Nutzer:in auflisten |

### Interaktionen

| Methode | Endpoint | Beschreibung |
| --- | --- | --- |
| `POST` | `views.open` | Modales View öffnen |
| `POST` | `views.update` | Modales View aktualisieren |
| `POST` | `reactions.add` | Emoji-Reaktion hinzufügen |

## Events

### Brevo-zu-Slack-Benachrichtigungen

| Event | Trigger | Slack-Aktion |
| --- | --- | --- |
| `new_subscriber` | Kontakt in Brevo erstellt | Post in #marketing |
| `campaign_sent` | E-Mail-Kampagne versendet | Zusammenfassung in #marketing posten |
| `order_placed` | Hochwertige Bestellung erkannt | Post in #sales mit Details |
| `cart_abandoned` | Warenkorb 30 Min. abgebrochen | Post in #sales zur Nachverfolgung |
| `ticket_created` | Support-Ticket geöffnet | Post in #support |
| `unsubscribed` | Kontakt hat abgemeldet | Alert in #marketing |

### Slack-zu-Brevo-Trigger

| Slack-Event | Trigger | Brevo-Aktion |
| --- | --- | --- |
| `message_action` | Custom Message Shortcut | Kontakt zur Liste hinzufügen oder Automation auslösen |
| `block_actions` | Button-Klick in Nachricht | Kontaktattribut aktualisieren oder E-Mail senden |
| `view_submission` | Modales Formular abgeschickt | Kontakt erstellen oder Workflow auslösen |

## Code-Beispiele

### Connector initialisieren

```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
});
```

### Marketing-Benachrichtigungen senden

```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'
          }
        ]
      }
    ]
  }
});
```

### Slack-Interaktionen verarbeiten

```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();
});
```

## Rate Limits

Die Rate Limits der Slack-API nutzen ein Stufen-System:

| Tier | Limit | Gängige Methoden |
| --- | --- | --- |
| Tier 1 | 1 Anfrage/Minute | `chat.delete`, `conversations.kick` |
| Tier 2 | 20 Anfragen/Minute | `conversations.history`, `users.info` |
| Tier 3 | 50 Anfragen/Minute | `conversations.list`, `users.list` |
| Tier 4 | 100 Anfragen/Minute | `chat.postMessage` |
| Special | Variabel | `chat.postMessage` zum gleichen Channel: 1/Sek |

Zusätzliche Limits:

- **Web API**: Burst-Limit mit kurzfristigem Throttle
- **Events API**: Delivery-Retries bei 3 Versuchen
- **Incoming Webhooks**: 1 Nachricht/Sekunde pro Webhook-URL
- **Block Kit**: Maximal 50 Blöcke pro Nachricht

Rate für Channel-Postings

Das Posten in denselben Channel ist auf etwa 1 Nachricht pro Sekunde beschränkt. Bündle Benachrichtigungen oder nutze Threads, um Rate Limiting zu vermeiden.

## Fehlerbehebung

### Häufige Probleme

| Problem | Ursache | Lösung |
| --- | --- | --- |
| `not_authed` | Ungültiger Bot-Token | App neu installieren und neuen Bot-Token kopieren |
| `channel_not_found` | Bot nicht im Channel | Bot in den Ziel-Channel einladen |
| `missing_scope` | Erforderlicher Scope nicht vergeben | Scope hinzufügen und App neu installieren |
| Event nicht empfangen | Event-Subscription nicht gesetzt | Event-Subscriptions-URL konfigurieren |
| Interaktion-Timeout | Antwort >3 Sekunden | Sofort mit 200 antworten, asynchron verarbeiten |

### Debug-Modus

Aktiviere ausführliches Logging:

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

### Verbindung testen

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

## Best Practices

1. **Block Kit nutzen** - Baue mit dem Block-Kit-Framework von Slack reichhaltige, interaktive Nachrichten
2. **Schnell antworten** - Bestätige Interaktionen innerhalb von 3 Sekunden, verarbeite asynchron
3. **Zusammengehörige Nachrichten in Threads** - Gruppiere verwandte Benachrichtigungen in Threads, um Rauschen zu reduzieren
4. **Nach Channel routen** - Sende unterschiedliche Event-Typen an passende Team-Channels
5. **Action-Buttons einbauen** - Füge “View in Brevo”-Buttons für schnellen Zugriff auf Kund:innen-Daten hinzu
6. **Unfurling implementieren** - Zeige Rich-Previews für in Slack geteilte Brevo-Links

## Sicherheit

- **Bot-Token** - OAuth-gescopter Access Token mit granularen Berechtigungen
- **Request-Signing** - HMAC-SHA-256-Signaturverifizierung für eingehende Anfragen
- **OAuth 2.0** - Industriestandard-Autorisierung für Multi-Workspace-Verteilung
- **TLS-Verschlüsselung** - Gesamte API-Kommunikation verschlüsselt über HTTPS
- **Token-Rotation** - Automatische Token-Rotation für erhöhte Sicherheit

## Verwandte Ressourcen

- [Slack-API-Dokumentation](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)
- [Brevo Connector](https://tajo.io/de/docs/connectors/marketing/brevo)
- [Customer-Sync-Skill](https://tajo.io/de/docs/skills/data-sync/customer-sync)