# Shager mit Claude Code verbinden: ein Befehl, dann Entwürfe für 50 Konten direkt aus dem Terminal

_2026-08-04 · Binde den MCP-Server von Shager per claude mcp add und Bearer-Header in Claude Code ein, wähle den passenden Scope, teste ihn und erstelle einen ersten Entwurf._

Um Shager mit Claude Code zu verbinden, führst du `claude mcp add --transport http shager https://app.shager.ai/api/mcp --header "Authorization: Bearer shgr_live_..."` aus und prüfst danach in einer Session `/mcp`. Damit ist der Remote-MCP-Server von Shager über Streamable HTTP registriert, und Claude Code kann sofort deine Workspaces, verbundenen Konten und Beiträge auflisten. Sobald du einen API-Schlüssel hast, dauert das Ganze etwa zwei Minuten.

Diese Anleitung zeigt, wie du an den Schlüssel kommst, den richtigen Config-Scope wählst, das Secret aus git heraushältst und welche erste echte Aufgabe sich lohnt.

## Was brauchst du, bevor es losgeht?

Zwei Dinge: ein installiertes Claude Code und einen Shager-API-Schlüssel, der mit `shgr_live_` beginnt.

An den Schlüssel kommst du auf zwei Wegen. Hast du schon ein Shager-Konto, legt ein Mensch aus deinem Team ihn unter https://app.shager.ai/dashboard/agents an und wählt die Scopes (`read`, `write` und optional `publish`). Hast du noch kein Konto, kann sich der Agent mit einem einzigen HTTP-Aufruf selbst registrieren und bekommt einen Sandbox-Schlüssel zurück. Dieser Ablauf ist in [Selbstregistrierung und Übernahme von Agenten](/en/blog/agent-self-signup-and-claim) beschrieben, die Kurzfassung steht unter [/auth.md](/auth.md).

Noch ein Wort zu den Scopes, bevor du irgendetwas einfügst: Gib Claude Code in der ersten Woche nur `read` und `write`. Damit kann es Workspaces anlegen, Medien hochladen und Entwürfe bauen, aber nichts planen oder veröffentlichen. `publish` kommt später dazu, wenn du den Entwürfen vertraust, die es liefert.

## Wie fügst du den Server mit claude mcp add hinzu?

Die [MCP-Dokumentation](https://code.claude.com/docs/en/mcp) von Claude Code zeigt die genaue Form für einen Remote-HTTP-Server mit Bearer-Token: `--transport http`, ein Name, die URL und `--header`. Für Shager sieht das so aus:

```bash
claude mcp add --transport http shager https://app.shager.ai/api/mcp \
  --header "Authorization: Bearer shgr_live_your_key_here"
```

Laut Dokumentation speichert `claude mcp add` die Konfiguration, ohne die Zugangsdaten zu prüfen. Ein Tippfehler im Schlüssel fällt an dieser Stelle also nicht auf, sondern erst später, wenn sich der Client verbindet.

### Welchen Scope solltest du nehmen?

Das Flag `--scope` legt fest, wo die Konfiguration gespeichert wird. Laut derselben Dokumentationsseite:

| Scope | Wo sie gespeichert wird | Sinnvoll, wenn |
|---|---|---|
| `local` (Standard) | In deiner Benutzerkonfiguration, nur für dieses Projekt | du Shager in einem Repo ausprobierst |
| `project` | `.mcp.json` im Repo, geteilt mit dem Team | das ganze Team Content-Aufgaben aus diesem Repo erledigt |
| `user` | In deiner Benutzerkonfiguration, für alle Projekte | Shager überall verfügbar sein soll, wo du Claude Code öffnest |

Für Agenturen ist `user` meist die richtige Wahl. Distribution hängt schließlich nicht an einer bestimmten Codebasis.

```bash
claude mcp add --transport http shager --scope user https://app.shager.ai/api/mcp \
  --header "Authorization: Bearer shgr_live_your_key_here"
```

## Wie teilst du die Konfiguration, ohne den Schlüssel zu committen?

Wenn du den Scope `project` nutzen willst, damit dein Team den Server automatisch bekommt, schreib den Schlüssel nicht fest in die `.mcp.json`. Claude Code unterstützt bei HTTP-Servern Umgebungsvariablen in `url` und `headers`, und zwar mit `${VAR}` oder `${VAR:-default}`. Committe also das hier:

```json
{
  "mcpServers": {
    "shager": {
      "type": "http",
      "url": "https://app.shager.ai/api/mcp",
      "headers": {
        "Authorization": "Bearer ${SHAGER_API_KEY}"
      }
    }
  }
}
```

Jede Person exportiert dann ihren eigenen Schlüssel im Shell-Profil:

```bash
export SHAGER_API_KEY="shgr_live_your_key_here"
```

Zwei Details aus der Dokumentation sind hier wichtig. Ist die Variable nicht gesetzt, lädt Claude Code die Konfiguration trotzdem und schickt den Text `${SHAGER_API_KEY}` wörtlich mit, begleitet von einer Warnung in `claude mcp list`. Und einige reservierte Namen für Zugangsdaten wie `ANTHROPIC_API_KEY` werden in Remote-Headern absichtlich zu einem leeren Wert aufgelöst. Nimm deshalb immer einen eigenen Variablennamen. `SHAGER_API_KEY` passt.

Getrennte Schlüssel pro Person machen außerdem das Audit-Log unter https://app.shager.ai/dashboard/agents aussagekräftig. Jeder Agentenaufruf wird dem Schlüssel zugeordnet, der ihn ausgelöst hat. So siehst du, in wessen Session welcher Entwurf entstanden ist.

## Wie prüfst du, ob alles funktioniert?

In der Shell:

```bash
claude mcp list
claude mcp get shager
```

In einer Session tippst du `/mcp`. Ein funktionierender Server wird als verbunden angezeigt. Ein Server mit falschen Zugangsdaten erscheint laut Dokumentation als fehlgeschlagen, und in den Details steht der HTTP-Status. Bei Shager bedeutet ein 401, dass der Header fehlt oder falsch aufgebaut ist. Der Server erwartet exakt `Authorization: Bearer shgr_...`, mit dem Wort Bearer und genau einem Leerzeichen.

Danach bittest du Claude um etwas Günstiges, das nur liest:

```text
Call whoami on shager, then list my workspaces with their channel counts.
```

`whoami` liefert die Organisation und die Scopes des Schlüssels zurück. Siehst du `read` und `write`, aber kein `publish`, funktioniert das Setup genau wie gedacht.

## Was sollte die erste echte Aufgabe sein?

Fang nicht mit „veröffentliche irgendwas“ an. Fang mit einem Entwurf an, der genau die Teile von Shager auf die Probe stellt, auf die es im großen Maßstab ankommt. Ein guter erster Prompt:

```text
In the workspace "Northside Dental", list the channels and the account groups.
Upload this video as media: https://example.com/clips/whitening-30s.mp4
(width 1080, height 1920, duration_ms 30000).
Then create a DRAFT post (no schedule_at) to the group "All locations" as a REEL,
with a caption per channel that mentions the city in that account's name,
first_comment "Book a slot: " plus the cta_url,
cta_url https://northsidedental.example/book, campaign "whitening-oct".
Show me the per-channel captions before you call create_post.
```

Im Hintergrund verkettet Claude `list_channels`, `list_groups`, `upload_media_from_url` und `create_post`. Drei Felder in diesem Aufruf leisten die eigentliche Arbeit.

1. `per_channel` gibt jedem Konto einen eigenen Text, statt fünfzig identische Beiträge zu erzeugen. Sowohl Netzwerke als auch Zielgruppen bemerken Duplikate. Deshalb empfehlen wir das auch in unserem Artikel über [Spam-Sperren beim Posten im großen Stil](/en/blog/avoid-spam-blocks-when-posting-at-scale).
2. `cta_url` bekommt pro Konto einen eigenen Kurzlink und ein eigenes UTM-Tag, wobei `utm_content` das Konto kennzeichnet. Die Klicks kommen über `get_analytics` pro Konto zurück.
3. Wenn du beim Upload Breite, Höhe und `duration_ms` mitgibst, kann Shager das Reel gegen die Regeln jedes Netzwerks prüfen, bevor irgendetwas in die Warteschlange kommt.

Da kein `schedule_at` übergeben wurde, entsteht ein Entwurf. Du prüfst ihn in der Shager-App oder lässt dir von Claude `get_post` geben.

## Wie steuerst du, was Claude Code darf?

Claude Code fragt um Erlaubnis, bevor es MCP-Tools aufruft, sofern du sie nicht freigegeben hast. MCP-Tools heißen `mcp__<server>__<tool>`, bei Shager siehst du also `mcp__shager__create_post`, `mcp__shager__list_posts` und so weiter. Eine vernünftige Allowlist für den Anfang gibt die lesenden Tools frei und lässt bei allem, was schreibt, die Nachfrage stehen. Kombiniert mit einem Schlüssel ohne `publish` hast du zwei voneinander unabhängige Bremsen: Der Client fragt dich, und der Server verweigert das Planen ohnehin.

Wenn du so weit bist, dass geplant werden soll, legst du einen neuen Schlüssel mit `publish` an, tauschst die Umgebungsvariable aus und behältst den alten read/write-Schlüssel für explorative Sessions. Die REST-API und der MCP-Server von Shager setzen dieselben Scopes durch. Die Regel gilt also, egal welchen Weg ein Skript nimmt.

## Checkliste zur Fehlersuche

| Symptom | Wahrscheinliche Ursache | Lösung |
|---|---|---|
| `/mcp` zeigt fehlgeschlagen, 401 | Im Header fehlt `Bearer ` oder der Schlüssel ist falsch geschrieben | Server neu hinzufügen oder prüfen, ob die Umgebungsvariable in der Shell exportiert ist, aus der Claude gestartet wurde |
| Tools sind da, aber `create_post` mit `schedule_at` liefert 403 | Dem Schlüssel fehlt `publish`, oder die Sandbox wurde noch nicht übernommen | So gewollt. Stattdessen einen Entwurf anlegen oder einen Menschen den Scope ergänzen lassen |
| 429 `rate_limited` | Mehr als 120 Anfragen pro Minute mit einem Schlüssel | Arbeit bündeln; ein `create_post` deckt viele Konten ab |
| 422 `rejected` | Eine Netzwerkregel wurde verletzt, etwa ein zu langes Reel | Meldung lesen; sie nennt das Konto und die Regel |

## FAQ

### Muss ich außer Claude Code noch etwas installieren?

Nein. Shager läuft als Remote-MCP-Server. Es gibt also keinen lokalen Prozess, keinen Docker-Container und kein npm-Paket. Claude Code spricht über Streamable HTTP direkt mit https://app.shager.ai/api/mcp.

### Kann Claude Code veröffentlichen, ohne dass ich jeden Beitrag freigebe?

Nur wenn der verwendete Schlüssel den Scope `publish` hat und das Konto von einem Menschen übernommen wurde. Ohne diesen Scope liefern Aufrufe zum Planen und Veröffentlichen ein 403, egal was der Agent versucht. Viele Teams schalten zusätzlich pro Workspace die Kundenfreigabe ein, die vor dem Planen eine menschliche Prüfung einbaut.

### Unterstützt Shager die Anmeldung per OAuth für Claude Code?

Ja. Der MCP-Server von Shager unterstützt die Anmeldung per OAuth für jeden MCP-Client, der sie beherrscht. Füge den Server ohne das Flag `--header` hinzu, führe `/mcp` aus und wähle die Authentifizierung, dann meldest du dich im Browser bei Shager an und bestätigst. Der oben gezeigte Header mit dem API-Schlüssel funktioniert weiterhin und passt besser zu Skripten und Maschinen, an denen sich niemand anmelden kann.

## Nächster Schritt

Sobald Claude Code deine Workspaces sieht, liegt es nahe, die Routine wiederholbar zu machen, statt Prompts immer wieder neu einzutippen. Die Anleitung zum [Bau eines Claude-Skills für Shager](/en/blog/build-a-claude-skill-for-shager) macht aus dem Entwurfs-Workflow oben einen `/shager`-Befehl, den dein ganzes Team nutzen kann. Wer erst den vollständigen Überblick will: Die [Seite für Agenten](/en/agents) listet jedes Tool und jeden Endpunkt auf.

---
Source: https://shager.ai/de/blog/connect-shager-to-claude-code