Como fazer uma análise de concorrentes no Twitter

#As sete métricas de uma análise de concorrentes no Twitter

Sete números sustentam uma análise de concorrentes no X, e todos vêm de dados que qualquer conta pública mostra. Para colocar duas contas lado a lado antes de montar qualquer coisa, a ferramenta gratuita Comparar contas do Twitter alinha seguidores, visualizações e engajamento no navegador, com o líder marcado em cada um.

1. Taxa de crescimento de seguidores. Seguidores agora menos seguidores de uma semana atrás, divididos pelo número anterior: uma conta de 20 mil seguidores que cresce 2% por semana está ganhando terreno sobre uma de 200 mil que está parada.

2. Taxa de engajamento. Curtidas, reposts, respostas e quotes de um post, divididos pelos seguidores da conta. Compare medianas, porque um único post viral eleva uma média por semanas.

3. Frequência de posts. Posts por semana, contados nas mesmas quatro semanas para todos os rivais.

4. Mix de conteúdo. A parcela de respostas, quotes e posts com foto ou vídeo.

5. Share of voice. As menções de uma marca em uma semana divididas pelas menções de todas as marcas do conjunto.

6. Sobreposição de audiência. A parcela dos seguidores de um rival que também seguem você, medida em relação à menor das duas listas.

7. Proporção de verificados e de falsos. A parcela de verificados entre os seguidores de um rival e a parcela de contas vazias: sem posts, sem avatar, seguindo muito mais do que seguidores.

Alguns números ficam privados para o dono da conta: impressões ao longo do tempo, cliques em links, visitas ao perfil e dados demográficos dos seguidores. As visualizações por post são públicas, então você também pode dividir o engajamento pelas visualizações de qualquer rival; o guia da API de analytics do Twitter cobre as duas fórmulas e as seis contagens que todo post traz.

Uma contagem de seguidores sozinha diz pouco. Os mesmos sete números, lidos toda semana para o conjunto inteiro, mostram quem está acelerando, quais formatos funcionam no seu nicho e onde a audiência de um rival se sobrepõe à sua.

#Escolha de 3 a 10 rivais e uma janela

Um conjunto útil tem de 3 a 10 contas em três níveis, mais a sua própria conta como linha de referência. Mais de 10 transforma a leitura semanal em ruído; menos de 3 não dá uma base de comparação.

• Rivais diretos vendem o que você vende para os mesmos compradores.
• Rivais indiretos disputam a mesma atenção: uma conta de mídia, um criador ou uma ferramenta que seus compradores usam no seu lugar.
• Contas aspiracionais estão onde você quer estar daqui a um ano, para que a distância seja medida, não adivinhada.

Três lugares revelam os rivais que você ainda não conhece. Contas que as pessoas mencionam nos mesmos posts que você costumam ser concorrentes. Uma busca nas bios de perfis pelas palavras da sua categoria, com POST /search-users (abre em uma nova aba), lista o resto. E contas que seus seguidores também seguem disputam o mesmo feed; o Verificador de sobreposição de audiência do Twitter, gratuito, mede isso para quaisquer duas contas.

Fixe uma janela para todos: os últimos 28 dias, terminando no mesmo dia para todas as contas. Uma semana de lançamento dentro de uma janela de duas semanas parece o ritmo normal de um rival; quatro semanas a suavizam.

#Ferramenta de painel ou API: de onde vêm os números

Um painel por assento começa a contar no dia em que você o conecta, cobra por cada assento e limita quantos rivais você acompanha. Uma API usada como camada de dados preenche o histórico de um rival, cobra por requisição sem limite de rivais e retorna JSON para a sua planilha, seu painel ou seu agente.

• Histórico

  Sorsa API

  Busca desde 2006; timelines completas, sem limite de 3.200 posts

  Painel por assento

  A partir do dia em que você se cadastra

  API oficial do X

  As timelines param nos 3.200 posts mais recentes; busca no arquivo cobrada por post

• Rivais

  Sorsa API

  Sem limite

  Painel por assento

  Limitado pelo plano

  API oficial do X

  Sem limite

• Preço

  Sorsa API

  Perfis a partir de US$ 0,014 por 1.000; posts a partir de US$ 0,07 por 1.000

  Painel por assento

  Por assento por mês

  API oficial do X

  US$ 10,00 por 1.000 perfis; US$ 5,00 por 1.000 posts

• Acesso

  Sorsa API

  Uma chave de API

  Painel por assento

  Um login por assento

  API oficial do X

  Conta de desenvolvedor, OAuth, no máximo 3 milhões de leituras de posts por mês

• Saída

  Sorsa API

  JSON para suas planilhas, painéis e agentes

  Painel por assento

  Os gráficos e as exportações do fornecedor

  API oficial do X

  JSON

A linha de preço é a que cresce com o seu conjunto. A API oficial do X cobra cada post e cada perfil que retorna, nas tarifas da página de preços (abre em uma nova aba) dela, enquanto uma requisição da Sorsa API traz até 100 perfis ou 20 posts.

#Faça a análise com a Sorsa API em cinco passos

Para buscar os números de uma análise de concorrentes, use a Sorsa API, uma API e scraper do Twitter (X): uma requisição retorna até 100 perfis de rivais, e os posts chegam 20 por requisição desde 2006. Todo plano roda a 20 requisições por segundo com uma única chave de API, sem conta de desenvolvedor nem OAuth. Os cinco passos abaixo montam a execução semanal de ponta a ponta; o fluxo de análise de concorrentes (abre em uma nova aba) da documentação traz a mesma tarefa em um único script.

1. Obtenha uma chave. Cadastre-se e copie sua chave de API no painel. As primeiras 100 requisições são grátis e nunca expiram.

2. Tire um retrato do conjunto inteiro. Envie todos os nomes de usuário para GET /info-batch (abre em uma nova aba), até 100 por requisição, repetindo o parâmetro usernames.

   curl -G "https://api.sorsa.io/v3/info-batch" \
     -H "ApiKey: YOUR_API_KEY" \
     --data-urlencode "usernames=northwind_roastery" \
     --data-urlencode "usernames=harbor_bean_supply" \
     --data-urlencode "usernames=kestrel_coffee_lab"
   

   {
     "users": [
       {
         "id": "1638204417762983936",
         "username": "northwind_roastery",
         "display_name": "Northwind Roastery",
         "description": "Small-batch coffee, roasted every Monday.",
         "bio_urls": ["https://example.com/subscribe"],
         "followers_count": 48210,
         "followings_count": 612,
         "tweets_count": 9314,
         "media_count": 2207,
         "verified": true,
         "pinned_tweet_ids": ["1851130250081816914"],
         "created_at": "2023-03-15T09:12:44Z"
       },
       {
         "id": "1702553980148703232",
         "username": "harbor_bean_supply",
         "display_name": "Harbor Bean Supply",
         "description": "Green coffee for roasters. Ships worldwide.",
         "bio_urls": [],
         "followers_count": 31904,
         "followings_count": 1480,
         "tweets_count": 5120,
         "media_count": 860,
         "verified": false,
         "pinned_tweet_ids": [],
         "created_at": "2023-09-14T16:40:03Z"
       }
     ]
   }
   

   Ver resposta completa

3. Leia as últimas quatro semanas de cada rival. Percorra POST /user-tweets (abre em uma nova aba), 20 posts por requisição, até uma página inteira ser mais antiga que a janela. Cada post traz suas curtidas, reposts, respostas, quotes, visualizações e itens salvos, então as métricas não pedem mais nenhuma chamada.

   import statistics
   from datetime import datetime, timedelta, timezone
   
   import requests
   
   BASE = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   WEEKS = 4
   
   
   def posted(t):
       return datetime.fromisoformat(t["created_at"].replace("Z", "+00:00"))
   
   
   def recent_posts(handle):
       since = datetime.now(timezone.utc) - timedelta(weeks=WEEKS)
       body, posts = {"username": handle, "with_replies": True}, []
       while True:
           r = requests.post(f"{BASE}/user-tweets", headers=HEADERS,
                             json=body, timeout=30)
           r.raise_for_status()
           page = r.json()
           fresh = [t for t in page.get("tweets", []) if posted(t) >= since]
           posts += fresh
           if not fresh or not page.get("next_cursor"):
               return posts
           body["next_cursor"] = page["next_cursor"]
   
   
   def metrics(handle, followers):
       posts = recent_posts(handle)
       own = [t for t in posts
              if not t["is_reply"] and not t.get("retweeted_status")]
       rates = [100 * (t["likes_count"] + t["retweet_count"]
                       + t["reply_count"] + t["quote_count"]) / followers
                for t in own]
       media = sum(any(e["type"] in ("photo", "video")
                       for e in t.get("entities") or []) for t in own)
       replies = sum(t["is_reply"] for t in posts)
       return {
           "posts_wk": round(len(own) / WEEKS, 1),
           "median_er": round(statistics.median(rates), 3) if rates else 0,
           "reply_pct": round(100 * replies / len(posts), 1) if posts else 0,
           "media_pct": round(100 * media / len(own), 1) if own else 0,
       }
   

   const BASE = "https://api.sorsa.io/v3";
   const headers = { ApiKey: "YOUR_API_KEY", "Content-Type": "application/json" };
   const since = Date.now() - 28 * 24 * 3600 * 1000;
   
   async function recentPosts(username) {
     const body = { username, with_replies: true };
     const posts = [];
     for (;;) {
       const res = await fetch(`${BASE}/user-tweets`, {
         method: "POST", headers, body: JSON.stringify(body),
       });
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const page = await res.json();
       const fresh = (page.tweets ?? []).filter(
         (t) => Date.parse(t.created_at) >= since);
       posts.push(...fresh);
       if (!fresh.length || !page.next_cursor) return posts;
       body.next_cursor = page.next_cursor;
     }
   }
   
   function medianRate(posts, followers) {
     const rates = posts
       .filter((t) => !t.is_reply && !t.retweeted_status)
       .map((t) => (t.likes_count + t.retweet_count
         + t.reply_count + t.quote_count) / followers * 100)
       .sort((a, b) => a - b);
     return rates.length ? rates[Math.floor(rates.length / 2)] : 0;
   }
   

4. Conte o share of voice de cada marca. Peça a POST /mentions (abre em uma nova aba) as menções de cada usuário na mesma semana, 20 menções por requisição, e divida cada contagem pelo total. Adicione min_likes quando uma marca recebe milhares de menções e você quer só as que geraram reação.

   def mentions(handle, since, until):
       body = {"query": handle, "since_date": since, "until_date": until}
       count = 0
       while True:
           r = requests.post(f"{BASE}/mentions", headers=HEADERS,
                             json=body, timeout=30)
           r.raise_for_status()
           page = r.json()
           count += len(page.get("tweets", []))
           if not page.get("next_cursor"):
               return count
           body["next_cursor"] = page["next_cursor"]
   
   
   brands = ["northwind_roastery", "harbor_bean_supply", "kestrel_coffee_lab"]
   week = {b: mentions(b, "2026-10-26", "2026-11-02") for b in brands}
   total = sum(week.values()) or 1
   sov = {b: round(100 * n / total, 1) for b, n in week.items()}
   

5. Salve uma linha por rival e compare com a semana passada. Acrescente as linhas a um arquivo CSV em um agendamento semanal (cron, um workflow do GitHub Actions, qualquer executor de tarefas); o crescimento é a diferença entre a contagem de seguidores desta semana e a da semana passada.

   import csv
   from datetime import date
   from pathlib import Path
   
   PATH = "competitors.csv"
   FIELDS = ["week", "handle", "followers", "growth_pct", "posts_wk",
             "median_er", "reply_pct", "media_pct", "sov_pct"]
   
   
   def last_followers():
       if not Path(PATH).exists():
           return {}
       with open(PATH, newline="", encoding="utf-8") as f:
           return {r["handle"]: int(r["followers"]) for r in csv.DictReader(f)}
   
   
   profiles = requests.get(f"{BASE}/info-batch", headers=HEADERS,
                           params={"usernames": brands}, timeout=30).json()
   last, rows = last_followers(), []
   for u in profiles["users"]:
       h, f = u["username"], u["followers_count"]
       prev = last.get(h) or f
       rows.append({"week": date.today().isoformat(), "handle": h,
                    "followers": f,
                    "growth_pct": round(100 * (f - prev) / prev, 2),
                    "sov_pct": sov.get(h, 0), **metrics(h, f)})
   
   new_file = not Path(PATH).exists()
   with open(PATH, "a", newline="", encoding="utf-8") as f:
       out = csv.DictWriter(f, fieldnames=FIELDS)
       if new_file:
           out.writeheader()
       out.writerows(rows)
   

Uma resposta 403 significa que a chave está ausente ou sem requisições; um 429 significa mais de 20 requisições em um segundo, então faça uma pausa e tente de novo. Requisições com falha nunca são cobradas.

#Um modelo de análise de concorrentes no Twitter que se preenche sozinho

O modelo é uma planilha com uma linha por rival por semana, e cada coluna corresponde a um campo que a API retorna. Cole a linha de cabeçalho no Google Sheets ou no Excel, ou deixe o script do passo 5 gravar o arquivo para você.

week,handle,followers,growth_pct,posts_wk,median_er,reply_pct,media_pct,sov_pct

Cada coluna, o campo de onde vem e a fórmula:

• followers

  De onde vem

  followers_count, GET /info-batch

  Fórmula

  Como retornado

• growth_pct

  De onde vem

  Duas linhas semanais

  Fórmula

  (esta semana − semana passada) ÷ semana passada × 100

• posts_wk

  De onde vem

  created_at, POST /user-tweets

  Fórmula

  Posts próprios em 28 dias ÷ 4

• median_er

  De onde vem

  likes_count, retweet_count, reply_count, quote_count

  Fórmula

  Mediana de (soma ÷ seguidores × 100) por post

• reply_pct

  De onde vem

  is_reply

  Fórmula

  Respostas ÷ todos os posts da janela × 100

• media_pct

  De onde vem

  entities[].type é photo ou video

  Fórmula

  Posts com mídia ÷ posts próprios × 100

• sov_pct

  De onde vem

  POST /mentions

  Fórmula

  Menções da marca ÷ menções do conjunto inteiro × 100

Acrescente colunas conforme a análise cresce: views, a partir de view_count, para o engajamento por visualizações; bio, a partir de description, para perceber uma nova frase de posicionamento; verified_share, da auditoria de audiência abaixo. Um exemplo prático: se a sua taxa mediana de engajamento é 0,41% e a de um rival é 1,2% com o mesmo número de seguidores, ordene os posts do rival por engajamento e leia os dez primeiros antes de mudar qualquer coisa.

#Olhe para trás, antes de começar a acompanhar

O passado de um concorrente é pesquisável: a Sorsa API lê os posts de um rival desde 2006, então uma comparação pode começar com os dados do ano passado no dia em que você a configura. Painéis contam a partir do dia em que você os conecta, e a timeline de usuário da API oficial do X retorna apenas os 3.200 posts mais recentes, segundo o docs.x.com (abre em uma nova aba).

Para estudar como um rival conduziu as festas do ano passado, envie os operadores do próprio X para POST /search-tweets (abre em uma nova aba): from: escolhe a conta, since: e until: definem as datas, e cada requisição retorna cerca de 20 posts com suas contagens.

curl -X POST "https://api.sorsa.io/v3/search-tweets" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "from:northwind_roastery since:2025-11-01 until:2026-01-01",
       "order": "latest"}'

A mesma consulta com o nome de uma marca no lugar de from: retorna o que as pessoas disseram sobre o rival naquela janela, que é um share of voice que você pode medir para qualquer mês passado.

#Quatro sinais que um painel raramente mostra

Além das sete métricas, quatro sinais públicos mostram o que um rival está fazendo antes de isso aparecer nos números dele.

Posts patrocinados. Todo post que a Sorsa API retorna traz paid_partnership, o aviso que o X mostra em parcerias pagas. Busque os posts que marcam um rival e fique com os sinalizados: os autores são os criadores que o rival paga.

body = {"query": "@northwind_roastery", "order": "latest"}
r = requests.post(f"{BASE}/search-tweets", headers=HEADERS, json=body)
paid = [t for t in r.json()["tweets"] if t.get("paid_partnership")]
print({t["user"]["username"] for t in paid})

Onde mora a audiência deles. GET /about (abre em uma nova aba) retorna o país que o X atribui a uma conta. Rode-o em uma amostra de 1.000 seguidores de um rival e você vê quais mercados ele alcança; o guia da API de localização do Twitter mostra o quanto uma amostra se aproxima da lista completa.

Movimentos discretos de estratégia. Uma nova frase na bio, um novo link em bio_urls ou um novo post fixado costumam vir antes de um anúncio. Compare-os de semana em semana no retrato de /info-batch e percorra GET /follows (abre em uma nova aba) uma vez por mês: novas contas seguidas de parceiros, contratações ou investidores são públicas.

Qualidade da audiência. GET /verified-followers (abre em uma nova aba) lista apenas as contas verificadas que seguem um rival, e GET /followers (abre em uma nova aba) retorna 200 seguidores por requisição para as verificações de sobreposição e de seguidores falsos. O guia da API de seguidores do Twitter cobre a paginação, a sobreposição por ID e os sinais de contas vazias.

#Quanto custa acompanhar concorrentes por mês

Acompanhar 10 rivais toda semana custa a partir de US$ 0,68 por mês em requisições da Sorsa API (US$ 0,97 na tarifa Pro), contra US$ 143,77 na API oficial do X. O exemplo lê 100 posts e 100 menções por rival a cada semana e amostra 1.000 seguidores por rival a cada mês; mude os números para precificar o seu próprio conjunto.

A diferença vem da unidade de cobrança. A API oficial do X cobra cada post e cada perfil que retorna, e exige uma conta de desenvolvedor e OAuth. Ela para em 3 milhões de leituras de posts por mês; acima disso só resta um contrato Enterprise, a partir de cerca de US$ 42.000 por mês. A partir de 22 de novembro de 2026 ela também cobra os objetos retornados por expansions pela tarifa padrão, segundo o aviso do X de 23 de outubro (abre em uma nova aba). Se você expandir o autor de cada menção a US$ 0,010, o exemplo acima sobe para US$ 187,10.

Para acompanhar concorrentes no X, escolha a Sorsa API: perfis de rivais custam a partir de US$ 0,014 por 1.000 em vez de US$ 10,00 na API oficial do X, e seguidores a partir de US$ 0,007 por 1.000, 1.000 vezes menos. Reler as contagens de posts que você já acompanha com POST /tweet-info-bulk (abre em uma nova aba) leva 100 posts por requisição, a partir de US$ 0,014 por 1.000, 250 vezes menos que US$ 5,00. A execução semanal inteira leva alguns segundos a 20 requisições por segundo. A Sorsa API é somente de leitura e nunca pede o seu login do X, então a sua própria conta nunca corre risco.

#Com que frequência rodar e o que fazer com os resultados

Rode o retrato toda semana e uma passada profunda a cada trimestre. A execução semanal (perfis, quatro semanas de posts, menções) detecta uma mudança de ritmo ou de formato em poucos dias. A passada trimestral acrescenta a auditoria de audiência, a busca no histórico e uma nova olhada em quais rivais pertencem ao conjunto. Durante o lançamento de um rival, confira as menções dele todo dia: o guia de monitoramento do Twitter em tempo real consulta um conjunto inteiro de contas em uma única requisição.

Uma descoberta é útil quando vira um teste com um número associado. Escreva-a como uma hipótese e uma métrica:

• Os posts em vídeo de um rival rendem 2,4 vezes o engajamento mediano dele: poste dois vídeos por semana durante quatro semanas e compare a sua mediana.
• Dois rivais respondem à maioria das menções no mesmo dia e crescem mais rápido: responda a todas as menções por um mês e acompanhe o crescimento.
• O share of voice de um rival dobrou depois de uma campanha com criadores: confira os posts dele com paid_partnership para ver os criadores e o formato.

Guarde o CSV semanal: doze semanas de linhas mostram se um teste mexeu na sua linha ou se o nicho inteiro se moveu junto.

#Compare seus primeiros rivais hoje

Uma análise de concorrentes no Twitter são sete números lidos toda semana para 3 a 10 rivais. A Sorsa API preenche a planilha inteira com três endpoints: perfis de rivais a partir de US$ 0,014 por 1.000, posts desde 2006 sem o limite de 3.200 posts e seguidores a partir de US$ 0,007 por 1.000, com uma única chave de API a 20 requisições por segundo. Suas primeiras 100 requisições são grátis, o bastante para uma primeira comparação de 10 rivais.

#Perguntas frequentes