# Connecter Shager à Claude Code : une commande, puis des brouillons pour 50 comptes depuis votre terminal

_2026-08-04 · Ajoutez le serveur MCP de Shager à Claude Code avec claude mcp add et un en-tête bearer, choisissez le scope, vérifiez, puis créez un brouillon multicompte._

Pour connecter Shager à Claude Code, lancez `claude mcp add --transport http shager https://app.shager.ai/api/mcp --header "Authorization: Bearer shgr_live_..."`, puis vérifiez avec `/mcp` dans une session. Cette commande enregistre le serveur MCP distant de Shager en HTTP streamable, et Claude Code peut aussitôt lister vos espaces de travail, vos comptes connectés et vos publications. Comptez environ deux minutes une fois la clé API en main.

Ce guide couvre l'obtention de la clé, le choix du bon niveau de configuration, la manière de garder le secret hors de git, et la première vraie tâche à lancer.

## De quoi avez-vous besoin avant de commencer ?

De deux choses : Claude Code installé, et une clé API Shager qui commence par `shgr_live_`.

Il y a deux façons d'obtenir la clé. Si vous avez déjà un compte Shager, une personne de votre équipe la crée sur https://app.shager.ai/dashboard/agents et choisit les scopes (`read`, `write` et, éventuellement, `publish`). Si vous n'avez pas encore de compte, l'agent peut s'inscrire lui-même en un seul appel HTTP et récupérer une clé de sandbox. Ce parcours est détaillé dans [l'auto-inscription des agents et la revendication](/fr/blog/agent-self-signup-and-claim), et la version courte se trouve sur [/auth.md](/auth.md).

Un mot sur les scopes avant de coller quoi que ce soit. La première semaine, donnez à Claude Code uniquement `read` et `write`. Il pourra créer des espaces de travail, importer des médias et préparer des brouillons, mais ni programmer ni publier. Vous ajouterez `publish` plus tard, quand les brouillons qu'il produit vous inspireront confiance.

## Comment ajouter le serveur avec claude mcp add ?

La [documentation MCP](https://code.claude.com/docs/en/mcp) de Claude Code donne la syntaxe exacte pour un serveur HTTP distant avec un jeton bearer : `--transport http`, un nom, l'URL et `--header`. Pour Shager, cela donne :

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

La documentation précise que `claude mcp add` enregistre la configuration sans vérifier l'identifiant. Une faute de frappe dans la clé ne provoquera pas d'erreur à ce stade : l'échec viendra plus tard, au moment où le client se connecte.

### Quel scope choisir ?

L'option `--scope` détermine où la configuration est enregistrée. D'après la même page de documentation :

| Scope | Emplacement | À utiliser quand |
|---|---|---|
| `local` (par défaut) | Votre configuration utilisateur, pour ce projet uniquement | Vous testez Shager dans un seul dépôt |
| `project` | `.mcp.json` dans le dépôt, partagé avec l'équipe | Toute l'équipe lance ses tâches de contenu depuis ce dépôt |
| `user` | Votre configuration utilisateur, tous projets confondus | Vous voulez Shager partout où vous ouvrez Claude Code |

Pour une agence, `user` est généralement le bon choix : la diffusion n'est pas liée à une base de code en particulier.

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

## Comment partager la configuration sans committer la clé ?

Si vous voulez un scope `project` pour que vos collègues récupèrent le serveur automatiquement, n'écrivez pas la clé en dur dans `.mcp.json`. Claude Code prend en charge l'expansion des variables d'environnement dans `url` et `headers` pour les serveurs HTTP, avec `${VAR}` ou `${VAR:-default}`. Committez plutôt ceci :

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

Chacun exporte ensuite sa propre clé dans le profil de son shell :

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

Deux détails de la documentation comptent ici. Si la variable n'est pas définie, Claude Code charge quand même la configuration et envoie le texte littéral `${SHAGER_API_KEY}`, avec un avertissement dans `claude mcp list`. Et certains noms d'identifiants réservés, comme `ANTHROPIC_API_KEY`, sont volontairement remplacés par une valeur vide dans les en-têtes distants : utilisez donc toujours votre propre nom de variable. `SHAGER_API_KEY` convient très bien.

Une clé par personne rend aussi utile le journal d'audit sur https://app.shager.ai/dashboard/agents. Chaque appel d'agent y est enregistré avec la clé qui l'a émis : vous savez quelle session a créé quel brouillon.

## Comment vérifier que tout fonctionne ?

Depuis le shell :

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

Dans une session, tapez `/mcp`. Un serveur en bonne santé apparaît comme connecté. Selon la documentation, un serveur aux identifiants invalides apparaît en échec, et le détail indique le code HTTP. Pour Shager, un 401 signifie que l'en-tête est absent ou mal formé. Le serveur attend exactement `Authorization: Bearer shgr_...`, avec le mot Bearer et une seule espace.

Demandez ensuite à Claude quelque chose de léger, en lecture seule :

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

`whoami` renvoie l'organisation et les scopes de la clé. Si vous voyez `read` et `write` mais pas `publish`, la configuration fonctionne exactement comme prévu.

## Quelle doit être la première vraie tâche ?

Ne commencez pas par « publie quelque chose ». Commencez par un brouillon qui sollicite les fonctions de Shager qui comptent à grande échelle. Un bon premier 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.
```

En coulisses, Claude enchaîne `list_channels`, `list_groups`, `upload_media_from_url` et `create_post`. Trois champs de cet appel font l'essentiel du travail.

1. `per_channel` donne à chaque compte sa propre légende au lieu de cinquante publications identiques. Les réseaux comme les audiences repèrent les doublons, c'est pourquoi nous le recommandons dans [éviter les blocages pour spam à grande échelle](/fr/blog/avoid-spam-blocks-when-posting-at-scale).
2. `cta_url` génère un lien court et un tag UTM distincts par compte, avec `utm_content` qui identifie le compte. Les clics remontent compte par compte via `get_analytics`.
3. Indiquer la largeur, la hauteur et `duration_ms` à l'import permet à Shager de valider le Reel selon les règles de chaque réseau avant toute mise en file d'attente.

Comme aucun `schedule_at` n'a été passé, le résultat est un brouillon. Vous le relisez dans l'application Shager, ou vous demandez à Claude un `get_post`.

## Comment encadrer ce que Claude Code a le droit de faire ?

Claude Code demande l'autorisation avant d'appeler des outils MCP, sauf si vous les avez autorisés. Les outils MCP sont nommés `mcp__<server>__<tool>` : pour Shager, vous verrez donc `mcp__shager__create_post`, `mcp__shager__list_posts`, etc. Une liste d'autorisations raisonnable pour démarrer approuve les outils de lecture et laisse tout ce qui écrit soumis à confirmation. Associez cela à une clé sans `publish` et vous disposez de deux freins indépendants : le client vous demande votre accord, et le serveur refuse de programmer quoi qu'il arrive.

Quand vous serez prêt à programmer, créez une nouvelle clé avec `publish`, remplacez la variable d'environnement et gardez l'ancienne clé read/write pour les sessions exploratoires. L'API REST et le serveur MCP de Shager appliquent les mêmes scopes : la règle tient, quel que soit le chemin emprunté par un script.

## Check-list de dépannage

| Symptôme | Cause probable | Solution |
|---|---|---|
| `/mcp` affiche un échec, 401 | `Bearer ` manquant dans l'en-tête ou clé mal saisie | Ajoutez à nouveau le serveur, ou vérifiez que la variable d'environnement est exportée dans le shell qui a lancé Claude |
| Les outils apparaissent mais `create_post` avec `schedule_at` renvoie 403 | La clé n'a pas `publish`, ou la sandbox n'est pas revendiquée | Comportement attendu. Créez un brouillon, ou demandez à un humain d'ajouter le scope |
| 429 `rate_limited` | Plus de 120 requêtes par minute sur une même clé | Regroupez le travail : un seul `create_post` couvre de nombreux comptes |
| 422 `rejected` | Une règle du réseau n'est pas respectée, par exemple un Reel trop long | Lisez le message : il indique le compte et la règle |

## FAQ

### Faut-il installer autre chose que Claude Code ?

Non. Shager fonctionne comme un serveur MCP distant : pas de processus local, de conteneur Docker ni de paquet npm à installer. Claude Code communique directement avec https://app.shager.ai/api/mcp en HTTP streamable.

### Claude Code peut-il publier sans que je valide chaque publication ?

Seulement si la clé qu'il utilise possède le scope `publish` et que le compte a été revendiqué par un humain. Sans ce scope, les appels de programmation et de publication renvoient 403, quoi que tente l'agent. Beaucoup d'équipes activent aussi la validation client par espace de travail, ce qui ajoute une relecture humaine avant toute programmation.

### Shager prend-il en charge la connexion OAuth pour Claude Code ?

Oui. Le serveur MCP de Shager prend en charge la connexion OAuth pour tout client MCP compatible. Ajoutez le serveur sans l'option `--header`, lancez `/mcp` et choisissez de vous authentifier, puis connectez-vous à Shager et validez dans le navigateur. L'en-tête avec la clé API présenté plus haut fonctionne toujours, et c'est le meilleur choix pour les scripts et les machines où personne ne peut se connecter.

## Et ensuite ?

Une fois que Claude Code voit vos espaces de travail, l'étape logique consiste à rendre la routine reproductible plutôt que de retaper vos prompts. Le guide [créer un skill Claude pour Shager](/fr/blog/build-a-claude-skill-for-shager) transforme le flux de brouillon ci-dessus en une commande `/shager` que toute votre équipe peut lancer, et la [page agents](/fr/agents) recense chaque outil et chaque endpoint si vous voulez d'abord la carte complète.

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