> ## Documentation Index
> Fetch the complete documentation index at: https://docs.so-me.studio/llms.txt
> Use this file to discover all available pages before exploring further.

# OpenClaw

> Steuere deinen Social-media-studio-Workspace über den persönlichen KI-Agenten OpenClaw

Social media studio wird als **OpenClaw-Skill im npm-Paket [`@social-media-scheduler/cli`](https://www.npmjs.com/package/@social-media-scheduler/cli)** mitgeliefert — installiere die CLI einmal, und OpenClaw findet den Skill automatisch.

## Installation

**1. OpenClaw auf deinem Rechner installieren**

Folge der [OpenClaw-Installationsanleitung](https://github.com/openclaw/openclaw). Erfordert Node.js 22+.

```bash theme={null}
npm install -g openclaw@latest
openclaw onboard --install-daemon
```

**2. Die Social-media-studio-CLI installieren (sie liefert den Skill mit)**

```bash theme={null}
npm install -g @social-media-scheduler/cli
```

Das Paket `@social-media-scheduler/cli` enthält:

* Die `so-me`-CLI-Binärdatei
* `SKILL.md` — den Inhalt des OpenClaw-Skills
* `tools.md` — automatisch generierter Katalog aller 205 Tools
* `examples/` — drei durchgespielte Transkripte (`schedule-post.md`, `reply-dm.md`, `weekly-report.md`)

**3. Authentifizieren**

Erstelle einen API-Schlüssel unter [so-me.studio/settings?tab=api](https://so-me.studio/settings?tab=api) und exportiere ihn:

```bash theme={null}
export SOME_API_KEY=sk_live_...
```

OpenClaw prüft die Eignung automatisch. Überprüfe es mit:

```bash theme={null}
openclaw skills list --eligible | grep so-me-studio
```

Nach dem Koppeln kannst du mit dem Agenten über Discord, Slack, WhatsApp, Telegram oder einen der [22 unterstützten Messenger](#aus-jedem-messenger-chatten) chatten.

## Oder über ClawHub

Der Skill ist auf ClawHub veröffentlicht. Installiere ihn mit einem der offiziellen Befehle:

```bash theme={null}
# OpenClaw-native (recommended)
openclaw skills install yasin047/so-me-studio

# ClawHub package-manager path
npx clawhub@latest install so-me-studio
```

Beide laden dasselbe Skill-Bundle. Der zugrunde liegende Mechanismus ist `@social-media-scheduler/cli` auf npm — ClawHub indexiert das veröffentlichte npm-Paket.

Skill-Seite: [clawhub.ai/yasin047/so-me-studio](https://clawhub.ai/yasin047/so-me-studio)

## Was du fragen kannst

Nach der Installation sprichst du den Agenten in normaler Sprache an:

| Prompt | Was passiert |
| - | - |
| *„Welche Social-Konten habe ich verbunden?“* | Ruft `accounts:list` auf und fasst nach Plattform zusammen. |
| *„Plane einen Tweet mit ‚Hallo‘ für morgen um 17 Uhr.“* | Berechnet den ISO-Zeitstempel und ruft `posts:create` auf. |
| *„Antworte auf diese DM mit meiner gespeicherten Vorlage ‚pricing‘.“* | Sucht die gespeicherte Antwort heraus und ruft `inbox:reply` auf. |
| *„Wie haben meine Twitter-Beiträge letzte Woche abgeschnitten?“* | Ruft `analytics:platform` mit `--days 7` auf. |
| *„Generiere eine Produktstart-Bildunterschrift für LinkedIn am Freitag und plane sie.“* | Ruft `ai:generate-and-schedule` durchgängig auf. |

Der Agent hat Zugriff auf **alle 205 MCP-Tools von Social media studio** — jede Aktion, die im Dashboard möglich ist, ist auch hier möglich.

## Aus jedem Messenger chatten

OpenClaw unterstützt **22 Messaging-Kanäle** — schreib dem Agenten per DM über den, den du ohnehin nutzt. Nach dem Koppeln verwenden alle Kanäle denselben Agenten und denselben Skill `so-me-studio`, du bekommst also von Discord, WhatsApp oder Slack dieselben Antworten.

### Einmalige Voraussetzung

Bevor ein Kanal hinzugefügt werden kann, braucht OpenClaw eine Erstkonfiguration unter `~/.openclaw/openclaw.json`:

```bash theme={null}
openclaw onboard          # interactive — recommended
# or:  openclaw setup --non-interactive --accept-risk
```

Überspringst du diesen Schritt, schlägt `openclaw gateway` mit `Missing config. Run openclaw setup or set gateway.mode=local` fehl.

### Das Schema (gilt für jeden Kanal)

```bash theme={null}
# 1. Get a credential from the platform you want to use
# 2. Wire it into OpenClaw
openclaw config set channels.<slug>.<field> <value>
openclaw config set channels.<slug>.enabled true --strict-json

# 3. Register the channel + run the gateway
openclaw channels add --channel <slug>
openclaw gateway
```

Der Befehl `gateway` startet einen lokalen Daemon, der auf jedem aktivierten Kanal lauscht und Nachrichten an deine installierten Skills weiterleitet.

### Die 7 wichtigsten — vollständige Einrichtung

**Discord**

**1. Eine Discord-Anwendung erstellen**

1. Gehe zu [discord.com/developers/applications](https://discord.com/developers/applications) → **New Application**
2. Tab **Bot** → **Add Bot** → klicke unter TOKEN auf „Copy“ (halte ihn geheim)
3. Tab **Bot** → **INTENT SETTINGS** → aktiviere **Message Content Intent** ⚠️ erforderlich
4. *(Optional, für die Nutzung auf Servern)* **OAuth2 → URL Generator** → Scope `bot`, Berechtigungen `Send Messages`, `Read Message History`, `Embed Links`, `Attach Files` → öffne die URL, um den Bot auf einen Server einzuladen. Für die reine DM-Nutzung überspringst du diesen Schritt.

**2. Das Token in OpenClaw eintragen**

```bash theme={null}
export DISCORD_BOT_TOKEN="your_bot_token_here"

openclaw config set channels.discord.token \
  --ref-provider default --ref-source env --ref-id DISCORD_BOT_TOKEN
openclaw config set channels.discord.enabled true --strict-json
```

**3. Den Kanal registrieren**

```bash theme={null}
openclaw channels add --channel discord
```

Der Assistent fragt nach einer Konto-Kennung — verwende deine Discord-Benutzer-ID oder deinen Benutzernamen.

**4. Gateway starten + Smoke-Test**

```bash theme={null}
openclaw gateway
```

Schreibe deinem Bot dann in Discord per DM:

> „List my connected social accounts“

Die erste Nachricht löst einen Kopplungscode aus, der im OpenClaw-Terminal ausgegeben wird. Bestätige ihn mit `openclaw admin pair-code <code>`.

**Slack**

**1. Eine Slack-App erstellen**

1. Gehe zu [api.slack.com/apps](https://api.slack.com/apps) → **Create New App** → **From scratch** → wähle deinen Workspace
2. **OAuth & Permissions** → füge diese **Bot Token Scopes** hinzu:
   * `app_mentions:read`, `chat:write`, `channels:read`, `groups:read`, `im:read`
   * `channels:history`, `groups:history`, `im:history`, `mpim:history`
   * `files:read`, `files:write`
3. Tab **Socket Mode** → aktiviere ihn (empfohlen — keine öffentliche Webhook-URL nötig)
4. **Basic Information** → erzeuge ein **App-Level Token** mit dem Scope `connections:write` (`xapp-…`)
5. **Install to Workspace** → kopiere das **Bot User OAuth Token** (`xoxb-…`)

**2. Die Tokens in OpenClaw eintragen**

```bash theme={null}
export SLACK_BOT_TOKEN="xoxb-..."
export SLACK_APP_TOKEN="xapp-..."

openclaw config set channels.slack.botToken "$SLACK_BOT_TOKEN"
openclaw config set channels.slack.appToken "$SLACK_APP_TOKEN"
openclaw config set channels.slack.mode "socket"
openclaw config set channels.slack.enabled true --strict-json
```

**3. Den Kanal registrieren**

```bash theme={null}
openclaw channels add --channel slack
```

**4. Gateway starten + Smoke-Test**

```bash theme={null}
openclaw gateway
```

Schreibe deinem Slack-Bot per DM:

> „List my connected social accounts“

Bestätige den Kopplungscode (gleicher Ablauf wie bei Discord).

**WhatsApp**

WhatsApp nutzt [Baileys](https://github.com/WhiskeySockets/Baileys) für die Kopplung per QR-Code — du brauchst kein Meta-Business-API-Konto, nur ein Smartphone mit installiertem WhatsApp.

**1. Den Kanal aktivieren**

```bash theme={null}
openclaw config set channels.whatsapp.enabled true --strict-json
```

**2. Registrieren + QR-Code scannen**

```bash theme={null}
openclaw channels add --channel whatsapp
```

OpenClaw zeigt einen QR-Code im Terminal an. Auf deinem Smartphone:

1. Öffne WhatsApp → **Settings** → **Linked Devices** → **Link a Device**
2. Scanne den im Terminal angezeigten QR-Code

Nach der Kopplung ist dein Konto die OpenClaw-Brücke — DMs an dich selbst oder an Kontakte, denen du schreibst, werden an den Agenten weitergeleitet.

**3. Gateway starten + Smoke-Test**

```bash theme={null}
openclaw gateway
```

Schreibe dir selbst oder lass dir von einem Freund schreiben:

> „List my connected social accounts“

Die erste Nachricht löst im Terminal eine Aufforderung zur Eingabe des Kopplungscodes aus. Bestätige ihn mit `openclaw admin pair-code <code>`.

> [!TIP]
>
> Die Baileys-Integration von WhatsApp läuft gegen ein echtes Konto — behandle sie wie eine persönliche Smartphone-Sitzung. Gib deine Terminal-Sitzung nicht weiter und betreibe nicht mehrere OpenClaw-Instanzen mit demselben WhatsApp-Konto.

**Telegram**

Telegram ist der **schnellste** Kanal in der Einrichtung — nur ein Bot-Token, keine Scopes, keine Intents.

**1. Einen Bot mit @BotFather erstellen**

1. Öffne Telegram und schreibe [@BotFather](https://t.me/BotFather)
2. Sende `/newbot` und folge den Anweisungen (Name + Benutzername)
3. Kopiere das Bot-Token, das BotFather dir schickt (sieht aus wie `1234567890:ABC...`)

**2. Das Token eintragen**

```bash theme={null}
export TELEGRAM_BOT_TOKEN="1234567890:ABC..."

openclaw config set channels.telegram.token \
  --ref-provider default --ref-source env --ref-id TELEGRAM_BOT_TOKEN
openclaw config set channels.telegram.enabled true --strict-json
```

**3. Den Kanal registrieren**

```bash theme={null}
openclaw channels add --channel telegram
```

**4. Gateway starten + Smoke-Test**

```bash theme={null}
openclaw gateway
```

Suche deinen Bot in Telegram (über den festgelegten Benutzernamen), tippe auf **Start** und sende dann:

> „List my connected social accounts“

Bestätige den Kopplungscode im Terminal.

**iMessage**

iMessage-Unterstützung setzt einen Mac mit [BlueBubbles Server](https://bluebubbles.app) voraus — Apple stellt iMessage auf anderen Plattformen nicht bereit, der einzige Weg ist daher eine Brücke über einen Mac, den du kontrollierst.

**1. BlueBubbles Server auf deinem Mac installieren**

1. Lade ihn von [bluebubbles.app](https://bluebubbles.app) herunter und folge dem Installer
2. Melde dich mit der Apple-ID an, die auf diesem Mac mit iMessage verknüpft ist
3. Kopiere in den Einstellungen von BlueBubbles Server die **Server-URL** (z. B. `http://192.168.1.20:1234`) und das **Passwort**

**2. BlueBubbles in OpenClaw eintragen**

```bash theme={null}
export BLUEBUBBLES_SERVER_URL="http://192.168.1.20:1234"
export BLUEBUBBLES_PASSWORD="your-bluebubbles-password"

openclaw config set channels.bluebubbles.serverUrl "$BLUEBUBBLES_SERVER_URL"
openclaw config set channels.bluebubbles.password "$BLUEBUBBLES_PASSWORD"
openclaw config set channels.bluebubbles.enabled true --strict-json
```

**3. Den Kanal registrieren**

```bash theme={null}
openclaw channels add --channel bluebubbles
```

**4. Gateway starten + Smoke-Test**

```bash theme={null}
openclaw gateway
```

Schreibe dir selbst oder einem anderen Kontakt per iMessage:

> „List my connected social accounts“

Bestätige den Kopplungscode im Terminal.

> [!NOTE]
>
> Der Mac mit BlueBubbles muss wach und angemeldet bleiben, damit das iMessage-Routing funktioniert. Der alte Kanal-Slug `imessage` ist **veraltet** — verwende `bluebubbles`.

**MS Teams**

Microsoft Teams nutzt das [Bot Framework](https://dev.botframework.com/) — registriere deinen Bot einmal und verbinde dann Teams als Kanal.

**1. Eine Azure-Bot-Ressource registrieren**

1. Erstelle im [Azure Portal](https://portal.azure.com/) eine neue **Azure Bot**-Ressource
2. Notiere die **Microsoft App ID** und erstelle unter **Certificates & secrets** ein neues **Client Secret**
3. Füge unter **Channels** **Microsoft Teams** als aktivierten Kanal hinzu
4. Lege unter **Configuration** den Messaging-Endpunkt fest — für das Gateway von OpenClaw verwendest du die öffentliche URL deiner getunnelten lokalen Instanz (z. B. über [ngrok](https://ngrok.com): `https://abc.ngrok.io/teams/messages`)

**2. Zugangsdaten in OpenClaw eintragen**

```bash theme={null}
export MSTEAMS_APP_ID="<your-app-id>"
export MSTEAMS_APP_PASSWORD="<your-client-secret>"

openclaw config set channels.msteams.appId "$MSTEAMS_APP_ID"
openclaw config set channels.msteams.appPassword "$MSTEAMS_APP_PASSWORD"
openclaw config set channels.msteams.enabled true --strict-json
```

**3. Registrieren + starten**

```bash theme={null}
openclaw channels add --channel msteams
openclaw gateway
```

**4. Den Bot zu einem Teams-Chat hinzufügen**

Suche in deinem Teams-Client nach dem Namen deines Bots und starte einen 1:1-Chat. Sende:

> „List my connected social accounts“

Bestätige den Kopplungscode im Terminal.

> [!TIP]
>
> Microsoft Teams benötigt einen öffentlich erreichbaren HTTPS-Endpunkt. Verwende in der Entwicklung ngrok oder Cloudflare Tunnel; in der Produktion betreibst du das Gateway hinter einer stabilen URL.

**Google Chat**

Google Chat nutzt einen HTTP-Webhook — kein OAuth, nur eine Webhook-URL.

**1. Eine Google-Chat-App erstellen**

1. Aktiviere in der [Google Cloud Console](https://console.cloud.google.com) die **Google Chat API**
2. Gehe zu **Google Chat API → Configuration** und lege fest:
   * App-Name + Avatar
   * **Connection settings** → HTTP endpoint → füge die öffentliche URL deines OpenClaw-Gateways ein (z. B. `https://abc.ngrok.io/googlechat/messages`)
   * **Visibility** → für deine Organisation oder bestimmte Benutzer verfügbar machen

**2. Das Webhook-Secret in OpenClaw eintragen**

```bash theme={null}
export GOOGLECHAT_WEBHOOK_SECRET="<your-shared-secret>"

openclaw config set channels.googlechat.webhookSecret "$GOOGLECHAT_WEBHOOK_SECRET"
openclaw config set channels.googlechat.enabled true --strict-json
```

**3. Registrieren + starten**

```bash theme={null}
openclaw channels add --channel googlechat
openclaw gateway
```

**4. Dem Bot in Google Chat per DM schreiben**

Suche in Google Chat deine App unter **Apps** und starte eine Direktnachricht:

> „List my connected social accounts“

Bestätige den Kopplungscode im Terminal.

> [!NOTE]
>
> **Warum kein WebChat?** Ältere OpenClaw-Tutorials erwähnten einen Kanal `webchat` — in der aktuellen CLI ist er kein echter, für Benutzer sichtbarer Kanal (er ist eine interne Routing-Konstante). `openclaw channels add --channel webchat` liefert `unknown channel id: webchat`. Für einen schnellen Test ohne Konto nutzt du **Telegram** von oben (\~1 Minute über [@BotFather](https://t.me/BotFather)).

### 15 weitere Kanäle (+ 1 demnächst)

> **Weitere Kanäle (Einrichtungshinweise in einer Zeile)**
>
> | Kanal | Slug | Einrichtung |
> | - | - | - |
> | Feishu / Lark | `feishu` | WebSocket-Bot — [Doku](https://docs.openclaw.ai/channels/feishu) |
> | LINE | `line` | Zugangsdaten für den Messaging-API-Bot — [Doku](https://docs.openclaw.ai/channels/line) |
> | Matrix | `matrix` | Homeserver-URL + Access Token — [Doku](https://docs.openclaw.ai/channels/matrix) |
> | Mattermost | `mattermost` | Bot-API + WebSocket — [Doku](https://docs.openclaw.ai/channels/mattermost) |
> | Nextcloud Talk | `nextcloud-talk` | Selbst gehostetes Nextcloud — [Doku](https://docs.openclaw.ai/channels/nextcloud-talk) |
> | Signal | `signal` | Kopplung über `signal-cli` — [Doku](https://docs.openclaw.ai/channels/signal) |
> | Twitch | `twitch` | IRC-Brücke — [Doku](https://docs.openclaw.ai/channels/twitch) |
> | Zalo | `zalo` | Bot-API — [Doku](https://docs.openclaw.ai/channels/zalo) |
> | Zalo Personal | `zalouser` | QR-Login — [Doku](https://docs.openclaw.ai/channels/zalouser) |
> | Tlon | `tlon` | Urbit-basiertes Konto — [Doku](https://docs.openclaw.ai/channels/tlon) |
> | QQ | `qqbot` | Tencent QQ Bot API — [Doku](https://docs.openclaw.ai/channels/qqbot) |
> | Nostr | `nostr` | NIP-04-DMs — [Doku](https://docs.openclaw.ai/channels/nostr) |
> | IRC | `irc` | Serveradresse + Kopplung — [Doku](https://docs.openclaw.ai/channels/irc) |
> | Synology Chat | `synology-chat` | NAS-Webhook — [Doku](https://docs.openclaw.ai/channels/synology-chat) |
> | iMessage (legacy) | `imessage` | **Veraltet** — verwende stattdessen `bluebubbles` |
> | WeChat | `wechat` | 🚧 **Nicht in der aktuellen CLI** — im README von OpenClaw aufgeführt, aber `openclaw channels add --channel wechat` liefert `Unknown channel`. Verfolge die Unterstützung im [OpenClaw-Repo](https://github.com/openclaw/openclaw). |

### Was du nach der Kopplung fragen kannst

Dieselben Prompts funktionieren auf jedem Kanal:

* *„Welche Social-Konten habe ich verbunden?“*
* *„Plane einen Tweet ‚launching today‘ für morgen um 9 Uhr UTC.“*
* *„Generiere eine Produktstart-Bildunterschrift für LinkedIn am Freitag und plane sie für 17 Uhr.“*
* *„Wie haben meine Twitter-Beiträge letzte Woche abgeschnitten?“*
* *„Antworte auf diese DM mit meiner gespeicherten Vorlage ‚pricing‘.“*

Die vollständige Prompt-Liste findest du unter [Was du fragen kannst](#was-du-fragen-kannst).

### Allgemeine Fehlerbehebung

* **`Missing config` bei `openclaw gateway`:** Du hast die Voraussetzung übersprungen — führe `openclaw onboard` (oder `openclaw setup --non-interactive --accept-risk`) aus, bevor du einen Kanal hinzufügst.
* **Bot antwortet gar nicht:** Stelle sicher, dass `openclaw gateway` läuft. Es ist der Daemon, der auf jedem Kanal lauscht — läuft er nicht, kommen keine Nachrichten durch.
* **Erste Nachricht hängt:** OpenClaw verlangt bei der ersten Nutzung eine Kopplung. Die erste DM löst einen Code aus, der im Terminal ausgegeben wird; bestätige ihn mit `openclaw admin pair-code <code>`.
* **Discord-spezifisch:** *Message Content Intent* muss im Developer Portal aktiviert sein, sonst kann der Bot keine DMs lesen.
* **Slack-spezifisch:** Fehlende OAuth-Scopes (`im:history`, `im:read`, `chat:write`); installiere die App nach dem Hinzufügen von Scopes erneut in deinem Workspace.
* **Skill nicht geeignet:** `openclaw skills list --eligible` sollte `so-me-studio` enthalten. Falls nicht, ist `SOME_API_KEY` in der Gateway-Shell nicht sichtbar — exportiere ihn in demselben Terminal, in dem du `openclaw gateway` ausführst.
* **Mehrere Kanäle funktionieren nicht alle:** Jeder Kanal hat ein eigenes `enabled`-Flag; prüfe den Status mit `openclaw channels status`.
* **MS Teams oder Google Chat nicht erreichbar:** Beide benötigen einen öffentlichen HTTPS-Endpunkt für das Gateway von OpenClaw. Nutze während der Entwicklung [ngrok](https://ngrok.com) oder Cloudflare Tunnel.

## So funktioniert es

```
┌──────────────────┐
│  OpenClaw agent  │
└────────┬─────────┘
         │ reads SKILL.md from @social-media-scheduler/cli's npm install
         ▼
┌──────────────────┐
│  SKILL.md +      │
│  tools.md +      │
│  examples/       │
└────────┬─────────┘
         │ invokes
         ▼
┌──────────────────┐         ┌────────────────────────┐
│  CLI (so-me)     │ ──────► │  api.so-me.studio/v1   │
└──────────────────┘         └────────────────────────┘
```

Der Skill-Inhalt (`SKILL.md`) ist eine System-Prompt-Erweiterung, die dem Agenten beibringt, die `so-me`-CLI zu verwenden. Die CLI liefert für jede Operation strukturiertes JSON, sodass der Agent Aufrufe parsen, auswerten und verketten kann.

## Feste Regeln im Skill

* Erfinde niemals Konto-/Beitrags-/Unterhaltungs-IDs — schlage sie immer zuerst nach.
* `scheduledAt` ist ISO 8601 in UTC und liegt strikt in der Zukunft.
* Mehrstufige Aufgaben (z. B. KI-Bild → Beitrag) werden nacheinander verkettet.
* Gib niemals API-Schlüssel oder Webhook-Secrets preis, auch nicht auf Nachfrage.

## Updates

Wenn neue Tools in Social media studio erscheinen, werden `SKILL.md` und `tools.md` neu generiert und `@social-media-scheduler/cli` neu veröffentlicht. Führe `npm install -g @social-media-scheduler/cli` erneut aus, um die neueste Version zu erhalten.

## Quelle

Der Skill-Quellcode liegt im Social-media-studio-Monorepo unter [`apps/cli/SKILL.md`](https://github.com/7t1-studio/schedular-app/blob/main/apps/cli/SKILL.md). Pull Requests sind willkommen.

## Andere Agenten?

Wenn du eine andere Agenten-Laufzeit verwendest:

* **Hermes 4** — siehe die [Hermes-Integration](/de/integrations/hermes.md), die dasselbe MCP-Backend über `npm install -g @so-me/hermes-agent` nutzt.
* **Claude Desktop / Cursor / OpenCode** — richte sie direkt auf unseren [MCP-Server](/de/mcp/overview.md). Weder Skill noch Laufzeit nötig.
* **Alles andere (LangGraph, CrewAI, OpenAI Assistants, Anthropic API)** — erzeuge eine Tool-Definitionsdatei im bevorzugten Format:
  ```bash theme={null}
  so-me agent export-tools --format openai --out tools.openai.json
  so-me agent export-tools --format anthropic --out tools.anthropic.json
  so-me agent export-tools --format mcp --out tools.mcp.json
  ```


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.