Slack

Slack verbinden. App-Token und Workspace-Einrichtung.

Socket-Modus (Standard)

Schnelleinrichtung (Anfänger)

Slack-App erstellen und Socket Mode aktivieren.
App Token (xapp-...) und Bot Token (xoxb-...) erstellen.
Tokens für OpenClaw setzen und Gateway starten.

Minimale Konfiguration:


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

Einrichtung

Slack-App (From scratch) unter https://api.slack.com/apps erstellen.
Socket Mode → aktivieren. Dann Basic Information → App-Level Tokens → Generate Token and Scopes mit Scope connections:write. App Token (xapp-...) kopieren.
OAuth & Permissions → Bot-Token-Scopes hinzufügen (Manifest unten nutzen). Install to Workspace klicken. Bot User OAuth Token (xoxb-...) kopieren.
Optional: OAuth & Permissions → User Token Scopes hinzufügen (siehe schreibgeschützte Liste unten). App neu installieren und User OAuth Token (xoxp-...) kopieren.
Event Subscriptions → Events aktivieren und abonnieren:
- message.* (inkl. Bearbeitungen/Löschungen/Thread-Broadcasts)
- app_mention
- reaction_added, reaction_removed
- member_joined_channel, member_left_channel
- channel_rename
- pin_added, pin_removed
Bot in die Kanäle einladen, die er lesen soll.
Slash Commands → /clawd erstellen, falls Sie channels.slack.slashCommand nutzen. Bei nativen Befehlen einen Slash-Befehl pro eingebautem Befehl hinzufügen (gleiche Namen wie /help). Native ist für Slack standardmäßig aus, außer Sie setzen channels.slack.commands.native: true (globales commands.native ist "auto", Slack bleibt aus).
App Home → Messages Tab aktivieren, damit Benutzer dem Bot DMs schicken können.

Manifest unten nutzen, damit Scopes und Events synchron bleiben. Mehrkonten-Unterstützung: nutzen Sie channels.slack.accounts mit Token pro Konto und optionalem name. Siehe gateway/configuration für das gemeinsame Muster.

OpenClaw-Konfiguration (minimal)

Tokens über Umgebungsvariablen setzen (empfohlen):

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

Oder über Konfiguration:


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

User Token (optional)

OpenClaw kann einen Slack-User-Token (xoxp-...) für Leseoperationen (Historie, Pins, Reaktionen, Emoji, Mitglieder-Info) nutzen. Standardmäßig bleibt dies schreibgeschützt: Leseoperationen bevorzugen den User-Token, wenn vorhanden; Schreiboperationen nutzen weiterhin den Bot-Token, außer Sie aktivieren es explizit. Auch bei userTokenReadOnly: false bleibt der Bot-Token für Schreiboperationen bevorzugt, wenn verfügbar. User-Tokens werden in der Konfigurationsdatei gesetzt (keine Umgebungsvariablen). Für Mehrkonten: channels.slack.accounts.<id>.userToken setzen. Beispiel mit Bot- + App- + User-Token:


{
  channels: {
    slack: {
      enabled: true,
      appToken: "xapp-...",
      botToken: "xoxb-...",
      userToken: "xoxp-..."
    }
  }
}

Beispiel mit explizit gesetztem userTokenReadOnly (User-Token-Schreibzugriff erlauben):


{
  channels: {
    slack: {
      enabled: true,
      appToken: "xapp-...",
      botToken: "xoxb-...",
      userToken: "xoxp-...",
      userTokenReadOnly: false
    }
  }
}

Token-Nutzung

Leseoperationen (Historie, Reaktionen-Liste, Pins-Liste, Emoji-Liste, Mitglieder-Info, Suche) bevorzugen den User-Token, wenn konfiguriert, sonst den Bot-Token.
Schreiboperationen (Nachrichten senden/bearbeiten/löschen, Reaktionen hinzufügen/entfernen, Pin/unpin, Datei-Uploads) nutzen standardmäßig den Bot-Token. Wenn userTokenReadOnly: false und kein Bot-Token verfügbar ist, fällt OpenClaw auf den User-Token zurück.

Historie-Kontext

channels.slack.historyLimit (oder channels.slack.accounts.*.historyLimit) steuert, wie viele aktuelle Kanal-/Gruppennachrichten in den Prompt eingebunden werden.
Fallback auf messages.groupChat.historyLimit. Setzen Sie 0 zum Deaktivieren (Standard 50).

HTTP-Modus (Events API)

HTTP-Webhook-Modus nutzen, wenn Ihr Gateway von Slack über HTTPS erreichbar ist (typisch für Server-Deployments). HTTP-Modus nutzt Events API + Interaktivität + Slash Commands mit einer gemeinsamen Request-URL.

Einrichtung

Slack-App erstellen und Socket Mode deaktivieren (optional, wenn Sie nur HTTP nutzen).
Basic Information → Signing Secret kopieren.
OAuth & Permissions → App installieren und Bot User OAuth Token (xoxb-...) kopieren.
Event Subscriptions → Events aktivieren und Request URL auf Ihren Gateway-Webhook-Pfad setzen (Standard /slack/events).
Interactivity & Shortcuts → aktivieren und dieselbe Request URL setzen.
Slash Commands → dieselbe Request URL für Ihre Befehle setzen.

Beispiel-Request-URL: https://gateway-host/slack/events

OpenClaw-Konfiguration (minimal)


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

Mehrkonten-HTTP-Modus: channels.slack.accounts.<id>.mode = "http" setzen und pro Konto einen eindeutigen webhookPath angeben, damit jede Slack-App auf ihre eigene URL zeigen kann.

Manifest (optional)

Dieses Slack-App-Manifest nutzen, um die App schnell zu erstellen (Name/Befehl bei Bedarf anpassen). User-Scopes einbeziehen, wenn Sie einen User-Token konfigurieren wollen.


{
  "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": "/clawd",\
        "description": "Send a message to OpenClaw",\
        "should_escape": false\
      }\
    ]
  },
  "oauth_config": {
    "scopes": {
      "bot": [\
        "chat:write",\
        "channels:history",\
        "channels:read",\
        "groups:history",\
        "groups:read",\
        "groups:write",\
        "im:history",\
        "im:read",\
        "im:write",\
        "mpim:history",\
        "mpim:read",\
        "mpim:write",\
        "users:read",\
        "app_mentions:read",\
        "reactions:read",\
        "reactions:write",\
        "pins:read",\
        "pins:write",\
        "emoji:read",\
        "commands",\
        "files:read",\
        "files:write"\
      ],
      "user": [\
        "channels:history",\
        "channels:read",\
        "groups:history",\
        "groups:read",\
        "im:history",\
        "im:read",\
        "mpim:history",\
        "mpim:read",\
        "users:read",\
        "reactions:read",\
        "pins:read",\
        "emoji:read",\
        "search:read"\
      ]
    }
  },
  "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"\
      ]
    }
  }
}

Bei nativen Befehlen einen slash_commands-Eintrag pro gewünschtem Befehl hinzufügen (entsprechend der /help-Liste). Überschreiben mit channels.slack.commands.native.

Scopes (aktuell vs. optional)

Slacks Conversations API ist typ-gescoped: Sie brauchen nur die Scopes für die Konversationstypen, die Sie tatsächlich nutzen (channels, groups, im, mpim). Siehe https://docs.slack.dev/apis/web-api/using-the-conversations-api/ für den Überblick.

Bot-Token-Scopes (erforderlich)

chat:write (Nachrichten senden/aktualisieren/löschen über chat.postMessage) https://docs.slack.dev/reference/methods/chat.postMessage
im:write (DMs über conversations.open öffnen für User-DMs) https://docs.slack.dev/reference/methods/conversations.open
channels:history, groups:history, im:history, mpim:history https://docs.slack.dev/reference/methods/conversations.history
channels:read, groups:read, im:read, mpim:read https://docs.slack.dev/reference/methods/conversations.info
users:read (Benutzer-Lookup) https://docs.slack.dev/reference/methods/users.info
reactions:read, reactions:write (reactions.get / reactions.add) https://docs.slack.dev/reference/methods/reactions.get https://docs.slack.dev/reference/methods/reactions.add
pins:read, pins:write (pins.list / pins.add / pins.remove) https://docs.slack.dev/reference/scopes/pins.read https://docs.slack.dev/reference/scopes/pins.write
emoji:read (emoji.list) https://docs.slack.dev/reference/scopes/emoji.read
files:write (Uploads über files.uploadV2) https://docs.slack.dev/messaging/working-with-files/#upload

User-Token-Scopes (optional, standardmäßig schreibgeschützt)

Unter User Token Scopes hinzufügen, wenn Sie channels.slack.userToken konfigurieren.

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

Heute nicht nötig (aber wahrscheinlich künftig)

mpim:write (nur wenn wir Group-DM-Öffnung/DM-Start über conversations.open hinzufügen)
groups:write (nur wenn wir Private-Channel-Verwaltung hinzufügen: erstellen/umbenennen/einladen/archivieren)
chat:write.public (nur wenn wir in Kanäle posten wollen, in denen der Bot nicht ist) https://docs.slack.dev/reference/scopes/chat.write.public
users:read.email (nur wenn wir E-Mail-Felder aus users.info brauchen) https://docs.slack.dev/changelog/2017-04-narrowing-email-access
files:read (nur wenn wir Datei-Metadaten auflisten/lesen)

Konfiguration

Slack nutzt nur Socket Mode (kein HTTP-Webhook-Server). Beide Tokens angeben:


{
  "slack": {
    "enabled": true,
    "botToken": "xoxb-...",
    "appToken": "xapp-...",
    "groupPolicy": "allowlist",
    "dm": {
      "enabled": true,
      "policy": "pairing",
      "allowFrom": ["U123", "U456", "*"],
      "groupEnabled": false,
      "groupChannels": ["G123"],
      "replyToMode": "all"
    },
    "channels": {
      "C123": { "allow": true, "requireMention": true },
      "#general": {
        "allow": true,
        "requireMention": true,
        "users": ["U123"],
        "skills": ["search", "docs"],
        "systemPrompt": "Keep answers short."
      }
    },
    "reactionNotifications": "own",
    "reactionAllowlist": ["U123"],
    "replyToMode": "off",
    "actions": {
      "reactions": true,
      "messages": true,
      "pins": true,
      "memberInfo": true,
      "emojiList": true
    },
    "slashCommand": {
      "enabled": true,
      "name": "clawd",
      "sessionPrefix": "slack:slash",
      "ephemeral": true
    },
    "textChunkLimit": 4000,
    "mediaMaxMb": 20
  }
}

Tokens können auch über Umgebungsvariablen gesetzt werden:

SLACK_BOT_TOKEN
SLACK_APP_TOKEN

Ack-Reaktionen werden global über messages.ackReaction + messages.ackReactionScope gesteuert. messages.removeAckAfterReply nutzen, um die Ack-Reaktion nach der Bot-Antwort zu entfernen.

Limits

Ausgehender Text wird auf channels.slack.textChunkLimit (Standard 4000) gechunkt.
Optionale Zeilenumbruch-Chunking: channels.slack.chunkMode="newline" setzen, um vor Längen-Chunking an Leerzeilen (Absatzgrenzen) zu teilen.
Medien-Uploads sind durch channels.slack.mediaMaxMb (Standard 20) begrenzt.

Antwort-Threading

Standardmäßig antwortet OpenClaw im Hauptkanal. channels.slack.replyToMode nutzen, um automatisches Threading zu steuern:

Modus	Verhalten
`off`	Standard. Antwort im Hauptkanal. Nur im Thread antworten, wenn die auslösende Nachricht bereits in einem Thread war.
`first`	Erste Antwort geht in den Thread (unter der auslösenden Nachricht), weitere Antworten in den Hauptkanal. Nützlich, um Kontext sichtbar zu halten und Thread-Unordnung zu vermeiden.
`all`	Alle Antworten gehen in den Thread. Hält Konversationen gebündelt, kann Sichtbarkeit reduzieren.

Der Modus gilt für Auto-Antworten und Agent-Tool-Aufrufe (slack sendMessage).

Pro-Chat-Typ-Threading

Sie können unterschiedliches Threading-Verhalten pro Chat-Typ über channels.slack.replyToModeByChatType setzen:


{
  channels: {
    slack: {
      replyToMode: "off",        // default for channels
      replyToModeByChatType: {
        direct: "all",           // DMs always thread
        group: "first"           // group DMs/MPIM thread first reply
      },
    }
  }
}

Unterstützte Chat-Typen:

direct: 1:1-DMs (Slack im)
group: Gruppen-DMs / MPIMs (Slack mpim)
channel: Standardkanäle (öffentlich/privat)

Reihenfolge:

replyToModeByChatType.<chatType>
replyToMode
Provider-Standard (off)

Legacy channels.slack.dm.replyToMode wird weiterhin als Fallback für direct akzeptiert, wenn kein Chat-Typ-Override gesetzt ist. Beispiele: Nur DMs threaden:


{
  channels: {
    slack: {
      replyToMode: "off",
      replyToModeByChatType: { direct: "all" }
    }
  }
}

Gruppen-DMs threaden, Kanäle im Root lassen:


{
  channels: {
    slack: {
      replyToMode: "off",
      replyToModeByChatType: { group: "first" }
    }
  }
}

Kanäle threaden, DMs im Root lassen:


{
  channels: {
    slack: {
      replyToMode: "first",
      replyToModeByChatType: { direct: "off", group: "off" }
    }
  }
}

Manuelle Threading-Tags

Für feinere Steuerung diese Tags in Agent-Antworten nutzen:

[[reply_to_current]] — auf die auslösende Nachricht antworten (Thread starten/fortsetzen).
[[reply_to:<id>]] — auf eine bestimmte Nachrichten-ID antworten.

Sitzungen + Routing

DMs teilen die main-Sitzung (wie WhatsApp/Telegram).
Kanäle werden agent:<agentId>:slack:channel:<channelId>-Sitzungen zugeordnet.
Slash-Befehle nutzen agent:<agentId>:slack:slash:<userId>-Sitzungen (Präfix über channels.slack.slashCommand.sessionPrefix konfigurierbar).
Wenn Slack channel_type nicht liefert, leitet OpenClaw es aus dem Kanal-ID-Präfix (D, C, G) ab und verwendet standardmäßig channel, damit Sitzungsschlüssel stabil bleiben.
Native Befehl-Registrierung nutzt commands.native (globaler Standard "auto" → Slack aus) und kann pro Workspace mit channels.slack.commands.native überschrieben werden. Text-Befehle erfordern eigenständige /...-Nachrichten und können mit commands.text: false deaktiviert werden. Slack-Slash-Befehle werden in der Slack-App verwaltet und nicht automatisch entfernt. commands.useAccessGroups: false nutzen, um Zugriffsgruppenprüfungen für Befehle zu umgehen.
Vollständige Befehlsliste + Konfiguration: Slash-Befehle

DM-Sicherheit (Pairing)

Standard: channels.slack.dm.policy="pairing" — unbekannte DM-Absender erhalten einen Kopplungscode (läuft nach 1 Stunde ab).
Freigabe über: openclaw pairing approve slack <code>.
Alle zulassen: channels.slack.dm.policy="open" und channels.slack.dm.allowFrom=["*"] setzen.
channels.slack.dm.allowFrom akzeptiert Benutzer-IDs, @handles oder E-Mails (werden beim Start aufgelöst, wenn Tokens es erlauben). Der Assistent akzeptiert Benutzernamen und löst sie beim Setup in IDs auf, wenn Tokens es erlauben.

Gruppenrichtlinie

channels.slack.groupPolicy steuert die Kanalbehandlung (open|disabled|allowlist).
allowlist erfordert, dass Kanäle in channels.slack.channels gelistet sind.
Wenn Sie nur SLACK_BOT_TOKEN/SLACK_APP_TOKEN setzen und nie einen channels.slack-Abschnitt anlegen, setzt die Laufzeit groupPolicy standardmäßig auf open. channels.slack.groupPolicy, channels.defaults.groupPolicy oder eine Kanal-Zulassen-Liste hinzufügen, um es einzuschränken.
Der Konfigurations-Assistent akzeptiert #channel-Namen und löst sie in IDs auf, wenn möglich (öffentlich + privat); bei mehreren Treffern wird der aktive Kanal bevorzugt.
Beim Start löst OpenClaw Kanal-/Benutzernamen in Zulassen-Listen in IDs auf (wenn Tokens es erlauben) und protokolliert die Zuordnung; nicht auflösbare Einträge bleiben wie eingegeben.
Keine Kanäle zulassen: channels.slack.groupPolicy: "disabled" setzen (oder Zulassen-Liste leer lassen).

Kanaloptionen (channels.slack.channels.<id> oder channels.slack.channels.<name>):

allow: Kanal erlauben/verweigern bei groupPolicy="allowlist".
requireMention: Erwähnungs-Steuerung für den Kanal.
tools: optionale Pro-Kanal-Tool-Richtlinien-Overrides (allow/deny/alsoAllow).
toolsBySender: optionale Pro-Absender-Tool-Richtlinien-Overrides im Kanal (Keys sind Absender-IDs/@handles/E-Mails; "*"-Wildcard unterstützt).
allowBots: Bot-verfasste Nachrichten in diesem Kanal erlauben (Standard: false).
users: optionale Pro-Kanal-Benutzer-Zulassen-Liste.
skills: Skill-Filter (weglassen = alle Skills, leer = keine).
systemPrompt: zusätzlicher System-Prompt für den Kanal (kombiniert mit Topic/Purpose).
enabled: auf false setzen, um den Kanal zu deaktivieren.

Zustellziele

Mit Cron/CLI-Sendungen nutzen:

user:<id> für DMs
channel:<id> für Kanäle

Tool-Aktionen

Slack-Tool-Aktionen können mit channels.slack.actions.* gesteuert werden:

Aktionsgruppe	Standard	Hinweise
reactions	aktiviert	Reagieren + Reaktionen auflisten
messages	aktiviert	Lesen/Senden/Bearbeiten/Löschen
pins	aktiviert	Pin/unpin/auflisten
memberInfo	aktiviert	Mitglieder-Info
emojiList	aktiviert	Benutzerdefinierte Emoji-Liste

Sicherheitshinweise

Schreiboperationen nutzen standardmäßig den Bot-Token, damit zustandsändernde Aktionen im Rahmen der App-Bot-Berechtigungen und -Identität bleiben.
userTokenReadOnly: false erlaubt die Nutzung des User-Tokens für Schreiboperationen, wenn kein Bot-Token verfügbar ist – Aktionen laufen dann mit dem Zugriff des installierenden Benutzers. User-Token als hochprivilegiert behandeln und Aktions-Steuerung sowie Zulassen-Listen eng halten.
Bei User-Token-Schreibzugriff sicherstellen, dass der User-Token die erwarteten Schreib-Scopes enthält (chat:write, reactions:write, pins:write, files:write), sonst schlagen diese Operationen fehl.

Hinweise

Erwähnungs-Steuerung über channels.slack.channels (requireMention auf true setzen); agents.list[].groupChat.mentionPatterns (oder messages.groupChat.mentionPatterns) zählen ebenfalls als Erwähnungen.
Multi-Agent-Override: Pro-Agent-Muster auf agents.list[].groupChat.mentionPatterns setzen.
Reaktions-Benachrichtigungen folgen channels.slack.reactionNotifications (mit reactionAllowlist im Modus allowlist).
Bot-verfasste Nachrichten werden standardmäßig ignoriert; aktivieren über channels.slack.allowBots oder channels.slack.channels.<id>.allowBots.
Warnung: Wenn Sie Antworten auf andere Bots erlauben (channels.slack.allowBots=true oder channels.slack.channels.<id>.allowBots=true), Bot-zu-Bot-Antwortschleifen mit requireMention, channels.slack.channels.<id>.users-Zulassen-Listen und/oder klaren Guardrails in AGENTS.md und SOUL.md verhindern.
Für das Slack-Tool: Reaktions-Entfernung siehe /tools/reactions.
Anhänge werden in den Medien-Speicher heruntergeladen, wenn erlaubt und unter der Größenbegrenzung.