Automatização de Redes Sociais com Claude Code

Todo projeto paralelo e blog de empresa bate na mesma parede. Escreveste algo que vale a pena partilhar, mas transformar isso em posts específicos para Twitter/X, LinkedIn e o resto demora mais do que escrever o artigo original. O Claude Code consegue automatizar grande parte desse trabalho, desde a geração de conteúdo até à publicação via API.

Não existe um "social media MCP" mágico que instalas e esqueces. Isso não existe. O que funciona é combinar a escrita do Claude Code com MCPs de automação de browser, chamadas diretas à API e exportações para ferramentas de agendamento. Aqui está como cada abordagem funciona na prática, com código que podes copiar hoje.

O Que Funciona Mesmo (e o Que Não Funciona)

Vamos ser honestos sobre o estado atual. O ecossistema MCP é forte para ferramentas de desenvolvimento, bases de dados e sistemas de ficheiros. Redes sociais? Constrói tu mesmo.

O que podes fazer hoje:

• Gerar conteúdo otimizado para cada plataforma diretamente com o Claude Code
• Usar MCPs de automação de browser (Puppeteer/Playwright) para controlar plataformas sociais
• Construir servidores MCP personalizados que chamam as APIs das plataformas
• Exportar conteúdo formatado para agendadores como Buffer, Typefully ou Hootsuite

O que não consegues fazer:

• Instalar um social-media-mcp pré-construído do registo oficial
• Ter fluxos OAuth prontos sem escrever a integração tu mesmo

Mesmo assim, as abordagens abaixo cobrem cerca de 90% do que querias de um MCP social dedicado. A contrapartida é que constróis uma vez e és o dono de ponta a ponta.

Abordagem 1: Workflows de Geração de Conteúdo

O padrão mais simples não precisa de nenhuma configuração MCP. O Claude Code já conhece as convenções de cada plataforma, limites de caracteres e padrões de engagement.

Geração de Post Individual

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

O Claude trata automaticamente das regras da plataforma. O verdadeiro valor vem dos workflows em lote.

Pipeline Blog para Redes Sociais

É o workflow que a maioria das equipas adota. Assim que um post de blog é publicado, o Claude gera todas as variantes para redes sociais:

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

Porque isto bate a escrita genérica com IA: o Claude lê o teu ficheiro fonte real, por isso o copy para redes sociais corresponde ao artigo publicado palavra por palavra. Sem desvios de copiar-colar, sem resumos de memória.

Convenções Específicas de Cada Plataforma

Cada plataforma tem regras não escritas. O Claude segue-as assim que as defines:

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"

Abordagem 2: Automação de Browser para Publicar

Quando precisas de publicar mesmo (não apenas rascunhar), o Puppeteer MCP dá ao Claude controlo direto do browser. Isso contorna as restrições de API porque estás a usar as plataformas da mesma forma que uma pessoa usaria.

Configuração

Adiciona o servidor Puppeteer MCP à tua configuração:

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

Publicar Pelo Browser

Uma vez ligado, o Claude consegue abrir qualquer plataforma social e trabalhar nela:

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

Ressalvas com automação de browser:

• Tens de estar já com sessão iniciada (ou tratar da autenticação na automação)
• As plataformas mudam o seu DOM sem aviso, quebrando os seletores
• Os limites de taxa ainda se aplicam, e publicações automáticas rápidas podem sinalizar a tua conta
• Fluxos de autenticação de dois fatores adicionam complexidade
• Bom para publicações ocasionais, não para agendamento de alto volume

A automação de browser brilha em publicações únicas ou pequenos lotes onde queres que o Claude trate de todo o fluxo. Para volume, a rota da API ou a exportação para agendador (abaixo) funciona melhor.

Abordagem 3: Servidor MCP Personalizado para a API do Twitter/X

Para publicações fiáveis e repetíveis, constrói um servidor MCP personalizado que chama a API do Twitter/X diretamente. Mais configuração no início, mas a opção mais sólida a longo prazo.

Pré-requisitos

Precisas de uma conta de Programador do Twitter com acesso à API. O nível gratuito cobre 1.500 tweets/mês para publicação, o que se encaixa na maioria das necessidades individuais e de pequenas equipas. Também precisas do pacote Node.js twitter-api-v2.

Construindo o Servidor 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);

Registar o Servidor MCP

Liga-o à tua configuração do 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"
      }
    }
  }
}

Usando o Servidor MCP

Agora podes escrever e publicar tweets diretamente do 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 publica uma 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."

O Claude chama get_my_tweets primeiro para corresponder à voz, redige o conteúdo, e depois chama post_tweet ou post_thread para publicar.

Abordagem 4: Exportar para Ferramentas de Agendamento

Para equipas que usam Buffer, Typefully, Hootsuite ou similares, o Claude Code consegue gerar exportações formatadas corretamente:

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

O output é um CSV que podes importar diretamente para a maioria dos agendadores. Sem chaves de API, sem configuração MCP. A opção de menor fricção para equipas já numa ferramenta de agendamento.

Para o Typefully especificamente (popular para threads no 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."

Verificação de Realidade Sobre o Acesso à API

Construir MCPs sociais personalizados depende do acesso à API das plataformas, e o panorama é desigual:

Bluesky e Mastodon são os alvos mais fáceis porque as suas APIs são abertas e bem documentadas. O Twitter/X funciona assim que estás num nível pago de programador. O LinkedIn é o mais difícil devido à aprovação restritiva de apps.

O Que Não Funciona Bem

Alguns pontos honestos para te poupar tempo:

• Automação de browser para publicação de alto volume. Quebra quando as plataformas lançam atualizações de interface. Está bem para uso ocasional, não para agendamento diário.
• Agentes sociais totalmente autónomos que publicam sem verificação humana. Os erros nas redes sociais são públicos e permanentes. Mantém um passo de revisão.
• MCPs multi-plataforma que tentam lidar com todas as plataformas num único servidor. Constrói um por plataforma; os padrões de autenticação e API diferem demasiado.
• Publicação de imagens por automação de browser é frágil. As caixas de diálogo de upload de ficheiros comportam-se de forma diferente em plataformas e ambientes de sistema operativo.

Juntando Tudo: Um Workflow Real

Aqui está o workflow que se mantém na prática, combinando as abordagens acima:

Passo 1: Gerar conteúdo a partir do teu material fonte

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

Passo 2: Rever e editar (o passo humano que nunca deves saltar)

Passo 3: Publicar ou agendar usando o método escolhido

• Publicação direta via API por MCP personalizado para Twitter/X
• Exportar para uma ferramenta de agendamento para distribuição multi-plataforma
• Automação de browser para publicações únicas em plataformas sem acesso à API

Passo 4: Acompanhar o engagement e iterar

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

Próximos Passos

A automatização de redes sociais com Claude Code é uma aventura de construção própria. Começa com a geração de conteúdo (zero configuração), passa para exportações de agendamento (configuração mínima), e avança para integrações de API personalizadas quando o volume justificar.

Guias relacionados:

• Automação de browser com Playwright e Puppeteer MCPs para a configuração completa de controlo de browser
• Construir servidores MCP personalizados para o guia completo de desenvolvimento MCP
• Básicos e configuração do MCP se és novo nos servidores MCP
• Servidores MCP populares para outras integrações que valem a pena explorar
• Criação de conteúdo com Claude Code para mais templates de prompts

O ecossistema MCP cresce semanalmente. Consulta o registo oficial do MCP de vez em quando. Quando um MCP social dedicado for lançado, os padrões de servidor personalizado acima dão-te uma vantagem na integração.