Social-Media-Automatisierung mit Claude Code

Jedes Nebenprojekt und jeder Unternehmensblog stößt an dieselbe Wand. Du hast etwas Teilenswertes geschrieben, aber daraus plattformspezifische Posts für Twitter/X, LinkedIn und den Rest zu machen, dauert länger als den Originalartikel zu schreiben. Claude Code kann den Großteil dieser Arbeit automatisieren, von der Content-Generierung bis zum API-basierten Posting.

Es gibt kein magisches "Social-Media-MCP", das du installierst und vergisst. Das existiert nicht. Was funktioniert, ist die Kombination von Claude Codes Schreiben mit Browser-Automatisierungs-MCPs, direkten API-Aufrufen und Scheduling-Tool-Exporten. Hier ist, wie jeder Ansatz in der Praxis aussieht, mit Code, den du heute kopieren kannst.

Was wirklich funktioniert (und was nicht)

Seien wir ehrlich über den aktuellen Stand. Das MCP-Ökosystem ist stark für Entwicklerwerkzeuge, Datenbanken und Dateisysteme. Social Media? Bau es selbst.

Was du heute tun kannst:

• Plattformoptimierte Inhalte direkt mit Claude Code generieren
• Browser-Automatisierungs-MCPs (Puppeteer/Playwright) nutzen, um Social-Plattformen zu steuern
• Benutzerdefinierte MCP-Server bauen, die Plattform-APIs aufrufen
• Formatierten Inhalt in Scheduler wie Buffer, Typefully oder Hootsuite exportieren

Was du nicht tun kannst:

• Ein fertig gebautes social-media-mcp aus der offiziellen Registry installieren
• Schlüsselfertige OAuth-Flows ohne eigene Integration-Implementierung bekommen

Trotzdem decken die folgenden Ansätze etwa 90 % dessen ab, was du von einem dedizierten Social-MCP wollen würdest. Der Kompromiss: Du baust es einmal und besitzt es von Anfang bis Ende.

Ansatz 1: Content-Generierungs-Workflows

Das einfachste Muster braucht null MCP-Setup. Claude Code kennt Plattformkonventionen, Zeichenlimits und Engagement-Muster bereits.

Einzelpost-Generierung

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 kümmert sich automatisch um die Plattformregeln. Der echte Mehrwert kommt durch Batch-Workflows.

Blog-zu-Social-Pipeline

Das ist der Workflow, den die meisten Teams nutzen. Sobald ein Blog-Post erscheint, erstellt Claude alle Social-Varianten:

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."

Warum das generisches KI-Schreiben schlägt: Claude liest deine echte Quelldatei, also passt der Social-Copy Wort für Wort zum veröffentlichten Artikel. Kein Copy-Paste-Drift, kein Zusammenfassen aus dem Gedächtnis.

Plattformspezifische Konventionen

Jede Plattform hat ungeschriebene Regeln. Claude folgt ihnen, sobald du sie klar formulierst:

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"

Ansatz 2: Browser-Automatisierung zum Posten

Wenn du wirklich posten möchtest (nicht nur Entwürfe erstellen), gibt Puppeteer MCP Claude direkte Browser-Kontrolle. Das umgeht API-Einschränkungen vollständig, weil du die Plattformen genauso nutzt wie ein Mensch.

Setup

Füge den Puppeteer MCP-Server in deine Konfiguration ein:

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

Über den Browser posten

Sobald es verdrahtet ist, kann Claude jede Social-Plattform öffnen und bedienen:

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."

Einschränkungen bei der Browser-Automatisierung:

• Du musst bereits eingeloggt sein (oder die Authentifizierung in der Automatisierung behandeln)
• Plattformen ändern ihr DOM ohne Vorwarnung und brechen Selektoren
• Rate-Limits gelten weiterhin, und schnelles automatisiertes Posten kann dein Konto markieren
• Zwei-Faktor-Auth-Flows fügen Komplexität hinzu
• Gut für gelegentliches Posten, nicht für hochvolumiges Scheduling

Browser-Automatisierung glänzt bei einmaligen Posts oder kleinen Batches, bei denen Claude den gesamten Ablauf übernehmen soll. Für großes Volumen funktioniert die API-Route oder der Scheduler-Export (unten) besser.

Ansatz 3: Benutzerdefinierter MCP-Server für die Twitter/X-API

Für zuverlässiges, wiederholbares Posten bau einen benutzerdefinierten MCP-Server, der die Twitter/X-API direkt aufruft. Mehr Einrichtungsaufwand vorab, aber die solideste langfristige Option.

Voraussetzungen

Du brauchst ein Twitter Developer-Konto mit API-Zugang. Der kostenlose Tier deckt 1.500 Tweets/Monat für das Posten ab, was für die meisten Einzel- und Kleinteam-Anforderungen passt. Du brauchst auch das twitter-api-v2 Node.js-Paket.

Den MCP-Server bauen

// 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);

Den MCP-Server registrieren

Binde ihn in deine Claude Code-Konfiguration ein:

{
  "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"
      }
    }
  }
}

Den MCP-Server nutzen

Jetzt kannst du Tweets direkt aus Claude Code schreiben und veröffentlichen:

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."

Oder einen Thread posten:

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 ruft zuerst get_my_tweets zur Stimmungsanpassung auf, entwirft den Inhalt und ruft dann post_tweet oder post_thread zum Veröffentlichen auf.

Ansatz 4: In Scheduling-Tools exportieren

Für Teams auf Buffer, Typefully, Hootsuite oder ähnlichem kann Claude Code ordentlich formatierte Exporte ausgeben:

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."

Die Ausgabe ist eine CSV-Datei, die du direkt in die meisten Scheduler importieren kannst. Keine API-Keys, kein MCP-Setup. Die reibungsloseste Option für Teams, die bereits ein Scheduling-Tool nutzen.

Für Typefully speziell (beliebt für Twitter-Threads):

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."

API-Zugang: Realitätscheck

Der Aufbau benutzerdefinierter Social-MCPs hängt vom Plattform-API-Zugang ab, und die Landschaft ist ungleichmäßig:

Bluesky und Mastodon sind die einfachsten Ziele, weil ihre APIs offen und gut dokumentiert sind. Twitter/X funktioniert, sobald du auf einem bezahlten Developer-Tier bist. LinkedIn ist das Schwierigste aufgrund der restriktiven App-Genehmigung.

Was nicht gut funktioniert

Ein paar ehrliche Misserfolge, um dir Zeit zu sparen:

• Browser-Automatisierung für hochvolumiges Posten. Bricht, wenn Plattformen UI-Updates ausliefern. Für gelegentliche Nutzung okay, nicht für tägliches Scheduling.
• Vollständig autonome Social-Agenten, die ohne menschliche Prüfung posten. Social-Fehler sind öffentlich und dauerhaft. Behalte einen Review-Schritt.
• Plattformübergreifende MCPs, die versuchen, jede Plattform in einem Server zu verwalten. Bau einen pro Plattform; die Auth- und API-Muster unterscheiden sich zu sehr.
• Bild-Posting über Browser-Automatisierung ist fragil. Datei-Upload-Dialoge verhalten sich auf verschiedenen Plattformen und OS-Umgebungen unterschiedlich.

Alles zusammensetzen: Ein echter Workflow

Hier ist der Workflow, der in der Praxis standhält, kombiniert aus den obigen Ansätzen:

Schritt 1: Inhalte aus deinem Quellmaterial generieren

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

Schritt 2: Überprüfen und bearbeiten (der menschliche Schritt, den du niemals überspringen solltest)

Schritt 3: Mit deiner gewählten Methode posten oder planen

• Direktes API-Posting über benutzerdefinierten MCP für Twitter/X
• Export in ein Scheduling-Tool für plattformübergreifende Verteilung
• Browser-Automatisierung für einmalige Posts auf Plattformen ohne API-Zugang

Schritt 4: Engagement beobachten und iterieren

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

Nächste Schritte

Social-Media-Automatisierung mit Claude Code ist ein Bau-dein-eigenes-Abenteuer. Fang mit Content-Generierung an (null Setup), gehe zu Scheduling-Exporten über (minimales Setup) und steige auf benutzerdefinierte API-Integrationen um, sobald das Volumen es rechtfertigt.

Verwandte Leitfäden:

• Browser-Automatisierung mit Playwright und Puppeteer MCPs für das vollständige Browser-Control-Setup
• Benutzerdefinierte MCP-Server bauen für den vollständigen MCP-Entwicklungsleitfaden
• MCP-Grundlagen und Konfiguration, wenn du neu bei MCP-Servern bist
• Beliebte MCP-Server für andere lohnende Integrationen
• Content-Erstellung mit Claude Code für mehr Prompt-Vorlagen

Das MCP-Ökosystem wächst wöchentlich. Schau von Zeit zu Zeit in die offizielle MCP-Registry. Wenn ein dediziertes Social-MCP erscheint, geben dir die benutzerdefinierten Server-Muster oben einen Vorsprung bei der Integration.