Slack-Integration für OpenClaw einrichten

Ständiges Hin- und Herwechseln zwischen verschiedenen Tools unterbricht deinen Workflow und kostet Zeit. Wenn du Bots in Slack einbindest, möchtest du, dass sie ohne komplizierte Konfiguration sofort funktionieren.

Die Slack-Integration von OpenClaw ist bereit für den Produktiveinsatz und unterstützt sowohl DMs als auch Channels. Ich empfehle dir den Socket Mode, da dies der einfachste Weg für die Kommunikation ist.

Voraussetzungen

• Eine Slack App
• App Token (xapp-...)
• Bot Token (xoxb-...)
• Signing Secret (nur für den HTTP Mode erforderlich)

Schnellstart

In dieser Anleitung zeige ich dir den Weg über den Socket Mode, da dieser als Standard voreingestellt ist.

Option 1: Socket Mode (Standard)

1. Slack App und Tokens erstellen: Gehe in die Slack App Einstellungen und aktiviere den Socket Mode. Erstelle einen App Token (xapp-...) mit dem Scope connections:write. Installiere die App in deinem Workspace und kopiere den Bot Token (xoxb-...).

2. OpenClaw konfigurieren: Trage die Tokens in deine Konfigurationsdatei ein:

{
  channels: {
    slack: {
      enabled: true,
      mode: "socket",
      appToken: "xapp-...",
      botToken: "xoxb-...",
    },
  },
}

Alternativ kannst du Umgebungsvariablen für den Standard-Account verwenden:

SLACK_APP_TOKEN=xapp-...
SLACK_BOT_TOKEN=xoxb-...

3. App Events abonnieren: Abonniere folgende Bot Events in den Slack-Einstellungen:

   • app_mention, message.channels, message.groups, message.im
   • message.mpim, reaction_added, reaction_removed, member_joined_channel
   • member_left_channel, channel_rename, pin_added, pin_removed

   Aktiviere unter “App Home” zusätzlich den Messages Tab, damit DMs funktionieren.

4. Gateway starten: Führe den folgenden Befehl in deinem Terminal aus:

openclaw gateway

Option 2: HTTP Events API Mode

Falls du die Events über HTTP empfangen möchtest, folge diesen Schritten:

• Setze den Mode in der Konfiguration auf HTTP (channels.slack.mode="http").
• Kopiere das Slack Signing Secret aus deinen App-Einstellungen.
• Hinterlege die Request URL für Event Subscriptions, Interactivity und Slash commands. Verwende dafür denselben Webhook-Pfad (Standard ist /slack/events).

Hier ist das passende Konfigurationsbeispiel:

{
  channels: {
    slack: {
      enabled: true,
      mode: "http",
      botToken: "xoxb-...",
      signingSecret: "your-signing-secret",
      webhookPath: "/slack/events",
    },
  },
}

Wenn du mehrere Accounts im HTTP Mode betreibst, musst du für jeden Account einen eindeutigen webhookPath festlegen. So verhinderst du, dass die Registrierungen kollidieren.

Fehlerbehebung

Falls Probleme mit deinen Channels auftreten, kannst du die integrierten Diagnose-Tools nutzen. OpenClaw bietet channelübergreifende Diagnosen und Playbooks für die Reparatur an, um Fehler in der Kommunikation schnell zu beheben.

AI Setup Assistant

Nächste Schritte

• Pairing
• Slash commands

Es ist immer das Gleiche: Du willst eine Slack-Integration starten und verbringst die erste Stunde damit, Scopes zu sortieren und zu rätseln, warum der Bot in DMs schweigt. Die Verwaltung von Tokens und Zugriffsberechtigungen fühlt sich oft komplizierter an, als sie sein müsste.

Wenn du verstehen willst, wie du Bot- und User-Tokens richtig trennst und das Routing sauber aufsetzt, bist du hier richtig. Ich empfehle dir, von Anfang an klar zwischen Socket Mode und HTTP Mode zu unterscheiden, um unnötige Debugging-Sessions zu vermeiden.

Voraussetzungen

• botToken (xoxb-…)
• appToken (für Socket Mode)
• signingSecret (für HTTP Mode)
• userToken (optional, xoxp-…)

Schnellstart

In 5 Minuten steht dein Setup, wenn du dich an diese Token-Logik hältst:

1. Modus wählen:
   • Für den Socket Mode brauchst du zwingend botToken + appToken.
   • Für den HTTP Mode benötigst du botToken + signingSecret.
2. Tokens konfigurieren:
   • Nutze die Config-Datei, um Tokens zu definieren. Diese überschreiben immer die Environment Variables.
   • Wenn du nur einen Standard-Account nutzt, kannst du auf SLACK_BOT_TOKEN und SLACK_APP_TOKEN als Fallback zurückgreifen.
3. User Tokens:
   • Diese werden nur über die Config gesetzt (kein Env Fallback).
   • Standardmäßig sind sie schreibgeschützt (userTokenReadOnly: true).

Tipp

Für das Lesen von Verzeichnissen oder einfache Aktionen ist das User-Token ideal. Wenn du Nachrichten schreiben willst, nimm das Bot-Token. User-Token-Writes funktionieren nur, wenn userTokenReadOnly: false gesetzt ist und kein Bot-Token zur Verfügung steht.

Access Control und Routing

Du kannst genau steuern, wer wo mit deinem Bot interagieren darf.

DM Policy

Die Einstellung channels.slack.dm.policy regelt den Zugriff auf Direktnachrichten:

• pairing (Standardeinstellung)
• allowlist
• open (setzt voraus, dass dm.allowFrom den Wert "*" enthält)
• disabled

Zusätzlich gibt es Flags für die Feinsteuerung:

• dm.enabled: Standardmäßig auf true.
• dm.allowFrom: Liste der erlaubten Absender.
• dm.groupEnabled: Für Gruppen-DMs (standardmäßig false).
• dm.groupChannels: Optionale Allowlist für MPIMs.

Wenn du pairing nutzt, erfolgt die Freigabe über das CLI: openclaw pairing approve slack <code>

Channel Policy

Mit channels.slack.groupPolicy verwaltest du reguläre Channels. Hier hast du folgende Optionen:

• open
• allowlist
• disabled
• Fallback-Verhalten: Falls channels.slack komplett fehlt und kein channels.defaults.groupPolicy gesetzt ist, nutzt das System automatisch open und gibt eine Warnung im Log aus.

Die Allowlist für Channels definierst du unter channels.slack.channels. Namen und IDs werden beim Startup aufgelöst, sofern der Token-Zugriff das zulässt. Nicht auflösbare Einträge bleiben so bestehen, wie du sie konfiguriert hast.

Mentions und Channel-User

Standardmäßig reagiert die App in Channels nur, wenn sie erwähnt wird (Mention-Gating).

Erkennungsquellen für Mentions:

• Explizite Mentions (<@botId>)
• Regex-Muster (über agents.list[].groupChat.mentionPatterns oder messages.groupChat.mentionPatterns)
• Implizites Verhalten bei Antworten in Bot-Threads

Pro Channel kannst du unter channels.slack.channels.<id|name> spezifische Regeln festlegen, wie etwa requireMention, users (Allowlist), allowBots oder sogar eigene tools und systemPrompt Einstellungen.

Fehlerbehebung

• Token wird ignoriert: Prüfe, ob du Tokens in der Config definiert hast. Diese überschreiben deine SLACK_BOT_TOKEN Environment Variable immer.
• Bot antwortet nicht in Channels: Prüfe das Mention-Gating. Ohne explizite Erwähnung oder passendes Regex-Muster bleibt der Bot inaktiv.
• User-Token schreibt nicht: Stelle sicher, dass userTokenReadOnly: false gesetzt ist. Denke aber daran: Bot-Tokens werden für Schreibvorgänge bevorzugt.
• Namen werden nicht aufgelöst: Das passiert beim Startup. Wenn dein Token nicht die nötigen Berechtigungen hat, um Channel-Listen zu lesen, bleiben die IDs ungelöst.

AI Setup Assistant

Nächste Schritte

• Slack App Setup Guide
• Advanced Channel Configuration
• Handling Multi-Account Environments

Slack-Apps zu bauen, die sich für Endnutzer natürlich anfühlen, ist oft eine Herausforderung. Meistens scheitert es an Kleinigkeiten: Slash-Commands reagieren nicht wie erwartet, Threads verlieren den Kontext oder Media-Uploads sprengen das Limit. Wenn du eine Integration suchst, die diese Details sauber verarbeitet, bist du hier richtig.

In diesem Guide erfährst du, wie du die Slack-Integration präzise steuerst, damit deine Commands und Sessions stabil laufen.

Voraussetzungen

• Zugriff auf die Konfiguration deiner Slack-Integration
• Administrator-Rechte im Slack Workspace (zum Registrieren von Slash-Commands)
• Zugriff auf die channels.slack Konfigurationsparameter

Schnellstart

In 5 Minuten zu nativen Slack-Commands:

1. Aktiviere native Commands in deiner Konfiguration:

   channels.slack.commands.native: true

2. Registriere den passenden Slash-Command (z.B. /openclaw) direkt in deinem Slack App Dashboard.
3. Stelle sicher, dass der Command-Name mit dem in der Konfiguration hinterlegten Namen übereinstimmt.
4. Teste den Command in einem Channel; die Antwort erfolgt standardmäßig als ephemeral Nachricht.

Commands und Slash-Verhalten

Wichtig zu wissen: Der native Command-Auto-Mode ist für Slack standardmäßig deaktiviert. Das bedeutet, dass commands.native: "auto" keine Slack-Native-Commands aktiviert.

Um native Slack-Command-Handler zu nutzen, musst du channels.slack.commands.native: true (oder global commands.native: true) setzen. Sobald dies aktiv ist, musst du die entsprechenden Slash-Commands (/<command> Namen) in Slack registrieren.

Falls du native Commands nicht aktivierst, kannst du dennoch einen einzelnen konfigurierten Slash-Command über channels.slack.slashCommand ausführen.

Hier sind die Standardeinstellungen für Slash-Commands:

• enabled: false
• name: "openclaw"
• sessionPrefix: "slack:slash"
• ephemeral: true

Slash-Sessions nutzen isolierte Keys: agent:<agentId>:slack:slash:<userId>. Die Ausführung wird trotzdem gegen die Ziel-Konversations-Session (CommandTargetSessionKey) geroutet.

Threading, Sessions und Reply-Tags

Die Integration erkennt automatisch den Kontext: DMs werden als direct geroutet, Channels als channel und MPIMs als group.

• DM-Handling: Mit dem Standard session.dmScope=main werden Slack DMs in der Haupt-Session des Agents zusammengefasst.
• Channel-Sessions: Diese folgen dem Muster agent:<agentId>:slack:channel:<channelId>.
• Threads: Antworten in Threads können Thread-Session-Suffixe (:thread:<threadTs>) erzeugen. Der Standardwert für channels.slack.thread.historyScope ist thread, und thread.inheritParent ist standardmäßig false.

Reply-Steuerung

Du kannst steuern, wie die Integration auf Nachrichten antwortet:

• channels.slack.replyToMode: Mögliche Werte sind off, first oder all (Default ist off).
• channels.slack.replyToModeByChatType: Erlaubt spezifische Einstellungen für direct, group oder channel.

Manuelle Reply-Tags werden ebenfalls unterstützt:

• [[reply_to_current]]
• [[reply_to:<id>]]

Media, Chunking und Delivery

Die Verarbeitung von Dateien und langen Texten folgt festen Regeln:

Inbound Attachments

Slack-Dateianhänge werden von privaten Slack-URLs heruntergeladen. Dies geschieht über einen Token-authentifizierten Flow. Die Dateien werden in den Media Store geschrieben, sofern der Download erfolgreich ist und die Größenlimits eingehalten werden. Das Standard-Limit liegt bei 20MB, außer du überschreibst es mit channels.slack.mediaMaxMb.

Outbound Text und Files

• Text Chunks: Hier greift channels.slack.textChunkLimit (Standard 4000 Zeichen).
• Chunk Mode: Mit channels.slack.chunkMode="newline" aktivierst du ein Splitting, das Absätze bevorzugt.
• Dateiversand: Nutzt die Slack Upload APIs und unterstützt Thread-Replies (thread_ts).

Delivery Targets

Bevorzugte explizite Ziele für den Versand:

• user:<id> für DMs
• channel:<id> für Channels

Actions und Gates

Slack Actions werden über channels.slack.actions.* gesteuert. Folgende Gruppen sind standardmäßig aktiviert:

Gruppe	Status
messages	enabled
reactions	enabled
pins	enabled
memberInfo	enabled
emojiList	enabled

Events und operatives Verhalten

Das System bildet diverse Slack-Ereignisse auf interne System-Events ab:

• Bearbeiten/Löschen von Nachrichten und Thread-Broadcasts.
• Hinzufügen oder Entfernen von Reaktionen.
• Beitreten/Verlassen von Mitgliedern, Erstellen/Umbenennen von Channels sowie Pins.
• Channel-Migration: channel_id_changed kann Channel-Konfigurationskeys migrieren, wenn configWrites aktiviert ist.

Metadaten wie Channel-Themen oder Beschreibungen werden als nicht vertrauenswürdiger Kontext behandelt und können in den Routing-Kontext injiziert werden.

Fehlerbehebung

• Slash-Command zeigt keine Reaktion: Prüfe, ob channels.slack.commands.native auf true steht. Ohne diesen Flag ignoriert die Integration native Slack-Payloads.
• Dateien werden nicht empfangen: Kontrolliere das 20MB Limit. Wenn deine Dateien größer sind, musst du channels.slack.mediaMaxMb entsprechend anpassen.
• Threads verlieren Kontext: Überprüfe, ob thread.inheritParent auf false steht (Standard). Falls du Kontext aus dem Haupt-Channel im Thread benötigst, musst du deine Session-Logik anpassen.
• DMs landen in der falschen Session: Das liegt oft am session.dmScope. Wenn du separate Sessions pro DM willst, ändere den Standardwert main.

Brauchst du Hilfe bei der Einrichtung? Nutze den AI Setup Assistant.

Nächste Schritte

• Slack API Setup Guide
• Session Management Deep Dive
• Media Pipeline Configuration
• Event Webhooks Overview

Es ist immer das Gleiche: Du baust eine Integration und am Ende scheitert es an einer fehlenden Berechtigung. Du klickst dich durch endlose Menüs im Slack Dashboard und suchst verzweifelt nach dem einen Scope, der noch fehlt.

Dieses Hin und Her nervt und hält dich vom eigentlichen Coding ab. Damit deine OpenClaw Integration sofort läuft, findest du hier die exakte Konfiguration für dein App Manifest.

Was du brauchst

• Slack App Manifest Zugriff
• channels.slack.userToken (optional für erweiterte Lesezugriffe)

Schnellstart

In weniger als 5 Minuten ist deine App startklar. Kopiere dieses JSON-Beispiel direkt in dein Slack App Manifest. Es enthält alle notwendigen Bot-Berechtigungen, slash_commands und event_subscriptions, damit der Connector sauber funktioniert.

{
  "display_information": {
    "name": "OpenClaw",
    "description": "Slack connector for OpenClaw"
  },
  "features": {
    "bot_user": {
      "display_name": "OpenClaw",
      "always_online": false
    },
    "app_home": {
      "messages_tab_enabled": true,
      "messages_tab_read_only_enabled": false
    },
    "slash_commands": [
      {
        "command": "/openclaw",
        "description": "Send a message to OpenClaw",
        "should_escape": false
      }
    ]
  },
  "oauth_config": {
    "scopes": {
      "bot": [
        "chat:write",
        "channels:history",
        "channels:read",
        "groups:history",
        "im:history",
        "mpim:history",
        "users:read",
        "app_mentions:read",
        "reactions:read",
        "reactions:write",
        "pins:read",
        "pins:write",
        "emoji:read",
        "commands",
        "files:read",
        "files:write"
      ]
    }
  },
  "settings": {
    "socket_mode_enabled": true,
    "event_subscriptions": {
      "bot_events": [
        "app_mention",
        "message.channels",
        "message.groups",
        "message.im",
        "message.mpim",
        "reaction_added",
        "reaction_removed",
        "member_joined_channel",
        "member_left_channel",
        "channel_rename",
        "pin_added",
        "pin_removed"
      ]
    }
  }
}

Optionale User-Token Scopes

Wenn du channels.slack.userToken konfigurierst, solltest du diese Scopes für Lesezugriffe setzen:

• channels:history, groups:history, im:history, mpim:history
• channels:read, groups:read, im:read, mpim:read
• users:read, reactions:read
• pins:read, emoji:read
• search:read (falls du Slack-Suchanfragen nutzt)

Fehlerbehebung

Falls die App nicht wie erwartet reagiert, prüfe die Scope-Liste im Manifest. Die meisten Fehler entstehen durch fehlende Event-Subscriptions oder nicht gesetzte Berechtigungen für app_mention und message Events.

Bei weiteren Fragen hilft dir der AI Setup Assistant.

Wie es weitergeht

• Slack Connector Konfiguration
• API Referenz

Du kennst das: Die Konfiguration sieht auf den ersten Blick perfekt aus, aber der Bot reagiert einfach nicht. Du schickst eine Nachricht im Channel, wartest auf einen Reply, und nichts passiert. Debugging von Slack-Integrationen kann nervig sein, besonders wenn Events lautlos im Hintergrund verschwinden oder Berechtigungen nicht greifen.

Meistens liegt es an einer Kleinigkeit in der Config oder einem fehlenden Flag in den Slack-App-Settings. Statt blind zu raten, solltest du systematisch vorgehen. Dieser Guide hilft dir dabei, die häufigsten Fehlerquellen schnell zu identifizieren und zu beheben.

Voraussetzungen

Bevor du startest, stelle sicher, dass du Zugriff auf diese Ressourcen hast:

• Configuration reference - Slack
• Deine aktuelle openclaw Konfigurationsdatei
• Zugriff auf das Slack Developer Dashboard deiner App

Quick Start: Schnelle Diagnose

Wenn es brennt, helfen dir diese drei Schritte, das Problem in unter 5 Minuten einzugrenzen:

1. Status prüfen: Nutze openclaw channels status --probe, um die Verbindung zu testen.
2. Logs checken: Starte openclaw logs --follow, um Live-Fehlermeldungen zu sehen.
3. System-Check: Führe openclaw doctor aus, um die grundlegende Umgebung zu validieren.

Fehlerbehebung

Hier sind die häufigsten Szenarien und wie du sie löst.

Keine Antworten in Channels

Wenn der Bot in Channels schweigt, solltest du diese Punkte nacheinander prüfen:

• groupPolicy
• Channel Allowlist (channels.slack.channels)
• requireMention
• Per-Channel users Allowlist

Nutze diese Commands zur Analyse:

openclaw channels status --probe
openclaw logs --follow
openclaw doctor

DM-Nachrichten werden ignoriert

Falls Direktnachrichten (DMs) nicht funktionieren, liegt es meist an den Policy-Einstellungen. Prüfe folgende Felder:

• channels.slack.dm.enabled
• channels.slack.dm.policy
• Pairing-Approvals oder Einträge in der Allowlist

Mit diesem Befehl siehst du den aktuellen Status:

openclaw pairing list slack

Socket Mode verbindet nicht

Wenn der Socket Mode keine Verbindung aufbaut, liegt der Fehler meist bei den Tokens. Validiere dein Bot Token und App Token. Prüfe auch im Slack Dashboard, ob der Socket Mode in den App-Settings wirklich aktiviert ist.

HTTP Mode empfängt keine Events

Falls du den HTTP Mode nutzt und keine Events ankommen, checke diese Details:

• Signing Secret
• Webhook Path
• Slack Request URLs (Events, Interactivity und Slash Commands)
• Eindeutigkeit des webhookPath pro HTTP-Account

Native oder Slash Commands funktionieren nicht

Hier musst du entscheiden, welchen Modus du nutzen möchtest. Prüfe, ob deine Konfiguration dazu passt:

• Native Command Mode (channels.slack.commands.native: true) erfordert registrierte Slash Commands in Slack.
• Single Slash Command Mode (channels.slack.slashCommand.enabled: true).

Checke zusätzlich commands.useAccessGroups sowie die Allowlists für Channels und User.

Configuration Reference Pointers

Für tiefergehende Details solltest du die Configuration reference - Slack nutzen. Hier sind die wichtigsten Felder für das Troubleshooting:

• Mode/Auth: mode, botToken, appToken, signingSecret, webhookPath, accounts.*
• DM Access: dm.enabled, dm.policy, dm.allowFrom, dm.groupEnabled, dm.groupChannels
• Channel Access: groupPolicy, channels.*, channels.*.users, channels.*.requireMention
• Threading/History: replyToMode, replyToModeByChatType, thread.*, historyLimit, dmHistoryLimit
• Delivery: textChunkLimit, chunkMode, mediaMaxMb
• Ops/Features: configWrites, commands.native, slashCommand.*, actions.*, userToken

Du brauchst Hilfe bei einem spezifischen Setup? Frag den AI Setup Assistant.

Nächste Schritte

• Pairing
• Channel routing
• Troubleshooting
• Configuration
• Slash commands