Automatisation des réseaux sociaux avec Claude Code

Chaque projet perso et blog d'entreprise se heurte au même mur. Tu as écrit quelque chose qui vaut la peine d'être partagé, mais le transformer en posts adaptés pour Twitter/X, LinkedIn et les autres prend plus de temps que d'écrire l'article original. Claude Code peut automatiser une grande partie de ce travail, de la génération de contenu jusqu'à la publication via API.

Il n'existe pas de "social media MCP" magique que tu installes et oublies. Ça n'existe pas. Ce qui fonctionne, c'est de combiner l'écriture de Claude Code avec des MCPs d'automatisation de navigateur, des appels API directs et des exports vers des outils de planification. Voici à quoi ressemble chaque approche en pratique, avec du code que tu peux copier aujourd'hui.

Ce qui fonctionne vraiment (et ce qui ne fonctionne pas)

Soyons honnêtes sur l'état actuel. L'écosystème MCP est solide pour les outils développeur, les bases de données et les systèmes de fichiers. Les réseaux sociaux ? Construis-le toi-même.

Ce que tu peux faire aujourd'hui :

• Générer du contenu optimisé par plateforme directement avec Claude Code
• Utiliser des MCPs d'automatisation de navigateur (Puppeteer/Playwright) pour piloter les plateformes sociales
• Construire des serveurs MCP personnalisés qui appellent les APIs des plateformes
• Exporter du contenu formaté vers des planificateurs comme Buffer, Typefully ou Hootsuite

Ce que tu ne peux pas faire :

• Installer un social-media-mcp pré-construit depuis le registre officiel
• Avoir des flux OAuth clé en main sans écrire l'intégration toi-même

Même ainsi, les approches ci-dessous couvrent environ 90 % de ce qu'on attendrait d'un MCP social dédié. Le compromis, c'est que tu le construis une fois et tu en es propriétaire de bout en bout.

Approche 1 : Workflows de génération de contenu

Le pattern le plus simple ne nécessite aucun setup MCP. Claude Code connaît déjà les conventions des plateformes, les limites de caractères et les patterns d'engagement.

Génération d'un post unique

claude "Write a Twitter thread (5 tweets) about why developers should use terminal-based AI tools instead of browser chat. Make the first tweet a hook, include one specific metric or example per tweet, and end with a call to action. Keep each tweet under 270 characters."

Claude gère les règles de la plateforme automatiquement. Le vrai gain vient des workflows en lot.

Pipeline blog vers réseaux sociaux

C'est le workflow que la plupart des équipes adoptent. Une fois qu'un article est publié, Claude génère toutes les variantes sociales :

claude "Read the blog post at apps/web/src/content/blog/guide/mechanics/claude-md-mastery.mdx and create:
1. A Twitter thread (5-7 tweets) highlighting the key insight about orchestration vs onboarding
2. A LinkedIn post (200-300 words) with a professional angle about team productivity
3. Three standalone tweets I can schedule throughout the week, each covering a different point from the post
Format each as a separate section with the platform name as header."

Pourquoi c'est mieux que l'écriture IA générique : Claude lit ton vrai fichier source, donc le texte social correspond mot pour mot à l'article publié. Pas de dérive par copier-coller, pas de résumé de mémoire.

Conventions spécifiques à chaque plateforme

Chaque plateforme a des règles non écrites. Claude les suit dès que tu les lui précises :

claude "Convert this release announcement into platform-specific posts:
 
Source: 'Claude Code v5.0 ships with Agent Teams - 18 specialized agents that coordinate on complex tasks, 5 lifecycle hooks, and team orchestration built in.'
 
For Twitter/X: Hook format, 1-2 hashtags max, conversational tone
For LinkedIn: Professional tone, tag the company, 3-4 paragraphs with line breaks
For Reddit r/programming: Technical focus, no marketing language, lead with what it does not what it is"

Approche 2 : Automatisation du navigateur pour publier

Quand tu as besoin de publier réellement (et pas seulement de rédiger), Puppeteer MCP donne à Claude le contrôle direct du navigateur. Ça contourne entièrement les restrictions API parce que tu utilises les plateformes comme le ferait une personne.

Setup

Ajoute le serveur Puppeteer MCP dans ta config :

{
  "mcpServers": {
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    }
  }
}

Publier via le navigateur

Une fois connecté, Claude peut ouvrir n'importe quelle plateforme sociale et l'utiliser :

claude "Using Puppeteer, navigate to twitter.com, log in with the session already saved in Chrome, compose a new tweet with this text: 'Just shipped Agent Teams in Claude Code v5.0 - 18 agents that coordinate in real time. The future of coding is parallel, not sequential.', and post it."

Mises en garde avec l'automatisation du navigateur :

• Tu dois déjà être connecté (ou gérer l'auth dans l'automatisation)
• Les plateformes changent leur DOM sans prévenir, cassant les sélecteurs
• Les limites de débit s'appliquent quand même, et les publications automatisées rapides peuvent signaler ton compte
• Les flux d'authentification à deux facteurs ajoutent de la complexité
• Bon pour les publications occasionnelles, pas pour la planification à grand volume

L'automatisation du navigateur brille sur les posts ponctuels ou les petits lots où tu veux que Claude gère le flux complet. Pour le volume, la route API ou l'export vers un planificateur (ci-dessous) fonctionne mieux.

Approche 3 : Serveur MCP personnalisé pour l'API Twitter/X

Pour une publication fiable et reproductible, construis un serveur MCP personnalisé qui appelle directement l'API Twitter/X. Plus de setup au départ, mais l'option la plus solide sur le long terme.

Prérequis

Tu as besoin d'un compte Twitter Developer avec accès API. Le niveau gratuit couvre 1 500 tweets/mois pour la publication, ce qui convient à la plupart des besoins individuels et des petites équipes. Tu as aussi besoin du package Node.js twitter-api-v2.

Construire le serveur MCP

// src/twitter-mcp.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { TwitterApi } from "twitter-api-v2";
 
const client = new TwitterApi({
  appKey: process.env.TWITTER_API_KEY!,
  appSecret: process.env.TWITTER_API_SECRET!,
  accessToken: process.env.TWITTER_ACCESS_TOKEN!,
  accessSecret: process.env.TWITTER_ACCESS_SECRET!,
});
 
const server = new Server(
  { name: "twitter-poster", version: "1.0.0" },
  { capabilities: { tools: {} } },
);
 
server.setRequestHandler("tools/list", async () => ({
  tools: [
    {
      name: "post_tweet",
      description: "Post a tweet to Twitter/X",
      inputSchema: {
        type: "object",
        properties: {
          text: {
            type: "string",
            description: "Tweet text (max 280 characters)",
          },
        },
        required: ["text"],
      },
    },
    {
      name: "post_thread",
      description: "Post a thread of connected tweets",
      inputSchema: {
        type: "object",
        properties: {
          tweets: {
            type: "array",
            items: { type: "string" },
            description: "Array of tweet texts in thread order",
          },
        },
        required: ["tweets"],
      },
    },
    {
      name: "get_my_tweets",
      description: "Get your recent tweets for context",
      inputSchema: {
        type: "object",
        properties: {
          count: {
            type: "number",
            description: "Number of tweets to fetch (max 100)",
          },
        },
      },
    },
  ],
}));
 
server.setRequestHandler("tools/call", async (request) => {
  const { name, arguments: args } = request.params;
 
  try {
    if (name === "post_tweet") {
      const result = await client.v2.tweet(args.text);
      return {
        content: [
          {
            type: "text",
            text: `Tweet posted successfully. ID: ${result.data.id}\nURL: https://twitter.com/i/status/${result.data.id}`,
          },
        ],
      };
    }
 
    if (name === "post_thread") {
      const tweets = args.tweets as string[];
      let lastTweetId: string | undefined;
      const postedIds: string[] = [];
 
      for (const tweetText of tweets) {
        const result = lastTweetId
          ? await client.v2.tweet(tweetText, {
              reply: { in_reply_to_tweet_id: lastTweetId },
            })
          : await client.v2.tweet(tweetText);
        lastTweetId = result.data.id;
        postedIds.push(result.data.id);
      }
 
      return {
        content: [
          {
            type: "text",
            text: `Thread posted (${postedIds.length} tweets).\nFirst tweet: https://twitter.com/i/status/${postedIds[0]}`,
          },
        ],
      };
    }
 
    if (name === "get_my_tweets") {
      const count = Math.min(args.count || 10, 100);
      const me = await client.v2.me();
      const timeline = await client.v2.userTimeline(me.data.id, {
        max_results: count,
        "tweet.fields": ["created_at", "public_metrics"],
      });
 
      const tweetSummary = timeline.data.data
        .map(
          (t) =>
            `[${t.created_at}] ${t.text.substring(0, 100)}... (${t.public_metrics?.like_count || 0} likes)`,
        )
        .join("\n");
 
      return {
        content: [{ type: "text", text: tweetSummary }],
      };
    }
  } catch (error) {
    return {
      content: [
        {
          type: "text",
          text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`,
        },
      ],
      isError: true,
    };
  }
});
 
const transport = new StdioServerTransport();
server.connect(transport);

Enregistrer le serveur MCP

Connecte-le dans ta config Claude Code :

{
  "mcpServers": {
    "twitter": {
      "command": "node",
      "args": ["./dist/twitter-mcp.js"],
      "env": {
        "TWITTER_API_KEY": "your-api-key",
        "TWITTER_API_SECRET": "your-api-secret",
        "TWITTER_ACCESS_TOKEN": "your-access-token",
        "TWITTER_ACCESS_SECRET": "your-access-secret"
      }
    }
  }
}

Utiliser le serveur MCP

Tu peux maintenant écrire et envoyer des tweets directement depuis Claude Code :

claude "Read my last 10 tweets to understand my voice and topics. Then write and post a tweet about the new context engineering techniques I covered in today's blog post. Match my usual tone."

Ou publier un thread :

claude "Write a 5-tweet thread breaking down the key differences between CLAUDE.md as documentation vs as an operating system. Post it as a thread."

Claude appelle d'abord get_my_tweets pour matcher le style, rédige le contenu, puis appelle post_tweet ou post_thread pour publier.

Approche 4 : Export vers des outils de planification

Pour les équipes sur Buffer, Typefully, Hootsuite ou similaires, Claude Code peut générer des exports correctement formatés :

claude "Generate a week of social media content about Claude Code development tips. Format as CSV with columns: date, platform, content, hashtags. Use dates starting next Monday. Include 2 tweets and 1 LinkedIn post per day."

Le résultat est un CSV que tu peux importer directement dans la plupart des planificateurs. Pas de clés API, pas de setup MCP. L'option avec le moins de friction pour les équipes déjà sur un outil de planification.

Pour Typefully spécifiquement (populaire pour les threads Twitter) :

claude "Write 3 Twitter threads about agentic coding. Format each as a Typefully draft with tweets separated by blank lines, and add a scheduling note at the top of each."

Vérification de la réalité sur l'accès API

Construire des MCPs sociaux personnalisés dépend de l'accès à l'API des plateformes, et le paysage est inégal :

Bluesky et Mastodon sont les cibles les plus faciles parce que leurs APIs sont ouvertes et bien documentées. Twitter/X fonctionne une fois que tu es sur un niveau développeur payant. LinkedIn est le plus difficile à cause de l'approbation d'application restrictive.

Ce qui ne fonctionne pas bien

Quelques points honnêtes pour te faire gagner du temps :

• L'automatisation du navigateur pour la publication à grand volume. Se casse quand les plateformes mettent à jour leur interface. Bien pour un usage occasionnel, pas pour la planification quotidienne.
• Les agents sociaux entièrement autonomes qui publient sans vérification humaine. Les erreurs sociales sont publiques et permanentes. Garde une étape de révision.
• Les MCPs cross-platform qui essaient de gérer toutes les plateformes dans un seul serveur. Construis-en un par plateforme, les patterns d'auth et d'API diffèrent trop.
• La publication d'images via l'automatisation du navigateur est fragile. Les dialogues de téléchargement de fichiers se comportent différemment selon les plateformes et les environnements OS.

Tout mettre ensemble : un workflow concret

Voici le workflow qui tient en pratique, combinant les approches ci-dessus :

Étape 1 : Générer du contenu à partir de ta source

claude "Read my latest blog post and generate social content for all platforms"

Étape 2 : Réviser et modifier (l'étape humaine que tu ne dois jamais sauter)

Étape 3 : Publier ou planifier selon ta méthode choisie

• Publication API directe via MCP personnalisé pour Twitter/X
• Export vers un outil de planification pour la distribution multi-plateforme
• Automatisation du navigateur pour les posts ponctuels sur des plateformes sans accès API

Étape 4 : Surveiller l'engagement et itérer

claude "Check my last 10 tweets. Which topics got the most engagement? Suggest 3 follow-up tweets based on what performed well."

Prochaines étapes

L'automatisation des réseaux sociaux avec Claude Code est une aventure à construire soi-même. Commence par la génération de contenu (zéro setup), passe aux exports de planification (setup minimal), et passe aux intégrations API personnalisées quand le volume le justifie.

Guides associés :

• Automatisation du navigateur avec les MCPs Playwright et Puppeteer pour le setup complet du contrôle navigateur
• Construction de serveurs MCP personnalisés pour le guide de développement MCP complet
• Bases MCP et configuration si tu es nouveau sur les serveurs MCP
• Serveurs MCP populaires pour d'autres intégrations intéressantes à explorer
• Création de contenu avec Claude Code pour plus de templates de prompts

L'écosystème MCP grandit chaque semaine. Consulte le registre MCP officiel de temps en temps. Quand un MCP social dédié sort, les patterns de serveur personnalisé ci-dessus te donnent une longueur d'avance pour l'intégrer.