API de analytics do Twitter para qualquer conta

#O que uma API de analytics do Twitter retorna

Uma API de analytics do Twitter é um endpoint que retorna em JSON, em vez de um painel, os números por trás de posts e contas do X: as contagens de engajamento de cada post, os totais de seguidores e de posts de cada conta e os próprios posts sobre os quais contar. O que ela pode retornar depende de uma divisão: números públicos que qualquer pessoa pode ler e números privados que só o autor pode ler.

Para ver primeiro a taxa de engajamento de uma conta no navegador, a Calculadora de taxa de engajamento do Twitter gratuita lê os posts mais recentes dela. O resto deste guia faz o mesmo trabalho em código, para qualquer número de contas e posts.

A tabela associa cada número ao campo que o carrega. A Sorsa API retorna as seis contagens públicas em todo post que devolve; a API oficial do X as mantém em public_metrics e as privadas em non_public_metrics.

• Curtidas

  Campo da Sorsa API

  likes_count

  Campo da API oficial do X

  like_count

  Quem pode ler

  qualquer pessoa

• Reposts

  Campo da Sorsa API

  retweet_count

  Campo da API oficial do X

  retweet_count

  Quem pode ler

  qualquer pessoa

• Respostas

  Campo da Sorsa API

  reply_count

  Campo da API oficial do X

  reply_count

  Quem pode ler

  qualquer pessoa

• Citações

  Campo da Sorsa API

  quote_count

  Campo da API oficial do X

  quote_count

  Quem pode ler

  qualquer pessoa

• Visualizações

  Campo da Sorsa API

  view_count

  Campo da API oficial do X

  impression_count

  Quem pode ler

  qualquer pessoa

• Itens salvos

  Campo da Sorsa API

  bookmark_count

  Campo da API oficial do X

  bookmark_count

  Quem pode ler

  qualquer pessoa

• Cliques em links

  Campo da Sorsa API

  nenhum

  Campo da API oficial do X

  url_link_clicks

  Quem pode ler

  o autor

• Cliques no perfil

  Campo da Sorsa API

  nenhum

  Campo da API oficial do X

  user_profile_clicks

  Quem pode ler

  o autor

As visualizações também são públicas. A documentação de métricas (abre em uma nova aba) do próprio X lista impressões como uma métrica pública que um simples bearer token lê em qualquer post; uma pessoa que vê um post duas vezes conta como duas impressões.

Os números privados têm três portas, todas ligadas à conta que escreveu o post. A primeira é o painel de analytics em x.com. A segunda é o GET /2/tweets/analytics (abre em uma nova aba) da API oficial do X: até 100 IDs de posts seus, como totais ou séries por hora, dia e semana, assinado com o token OAuth da sua conta. A terceira é a Engagement API Enterprise (abre em uma nova aba) do X, mediante contrato com o time de vendas. As métricas não públicas cobrem apenas posts dos últimos 30 dias.

Para contagens públicas, a API oficial do X cobra cada post lido a US$ 0,005, ou US$ 5,00 por 1.000, depois de uma conta de desenvolvedor e um app (preços da API do X (abre em uma nova aba)). A partir de 22 de novembro de 2026, um post lido com o autor anexado custa US$ 0,015 (aviso do X (abre em uma nova aba)). Lá, a timeline de uma conta para nos 3.200 posts mais recentes (abre em uma nova aba), e o pay-per-use para em 3 milhões de leituras de posts por mês.

#Obtenha métricas de engajamento de qualquer conta com a Sorsa API

Para métricas de engajamento de contas que não são suas, use a Sorsa API, uma API e scraper do Twitter (X): todo post que ela retorna traz as seis contagens e o perfil completo do autor, a partir de US$ 0,014 por 1.000 posts, contra US$ 5,00 na API oficial do X. Um header ApiKey substitui a conta de desenvolvedor e o OAuth, todos os planos rodam a 20 requisições por segundo, e a sua própria conta do X nunca entra na história.

O começo mais rápido é a timeline de uma conta: uma requisição retorna os posts mais recentes com suas contagens, e um cursor leva aos mais antigos. Um cursor é um token que a API retorna a cada página; você o envia de volta para obter a próxima página.

1. Pegue uma chave. Cadastre-se e copie a chave de API do seu painel. As 100 requisições grátis já estão nela.

2. Puxe os posts da conta. Envie o handle para POST /user-tweets (abre em uma nova aba). Cada página tem até 20 posts, do mais novo para o mais antigo, com as contagens e o perfil do autor.

   curl -X POST "https://api.sorsa.io/v3/user-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"username": "harborline_roasters"}'
   

   {
     "tweets": [
       {
         "id": "2116184394037384839",
         "full_text": "Winter blend ships Monday. First 200 orders get a tin.",
         "created_at": "2026-10-30T15:04:11Z",
         "lang": "en",
         "likes_count": 212,
         "retweet_count": 31,
         "reply_count": 24,
         "quote_count": 6,
         "view_count": 9640,
         "bookmark_count": 41,
         "is_reply": false,
         "is_quote_status": false,
         "conversation_id_str": "2116184394037384839",
         "user": {
           "id": "1503315520518280839",
           "username": "harborline_roasters",
           "display_name": "Harborline Roasters",
           "followers_count": 8450,
           "followings_count": 312,
           "tweets_count": 3921,
           "verified": false
         }
       }
     ],
     "next_cursor": "DAABCgABG5xQ2bW8AAAKAAIbmN8T0ZbQ6QgAAwAAAAIAAA"
   }
   

   Ver resposta completa

3. Volte páginas até a data de que você precisa. Envie next_cursor no corpo seguinte e pare quando ele vier vazio ou quando os posts ficarem mais antigos que a sua data de início. O loop abaixo grava uma linha por post em um arquivo CSV.

   import csv
   import requests
   
   API = "https://api.sorsa.io/v3/user-tweets"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   FIELDS = ["id", "created_at", "likes_count", "retweet_count",
             "reply_count", "quote_count", "view_count", "bookmark_count"]
   
   
   def account_posts(username, since="2026-10-01"):
       body, rows = {"username": username}, []
       while True:
           r = requests.post(API, headers=HEADERS, json=body, timeout=30)
           r.raise_for_status()
           data = r.json()
           page = data.get("tweets", [])
           rows += [t for t in page if t["created_at"] >= since]
           old = all(t["created_at"] < since for t in page)
           if not data.get("next_cursor") or old:
               return rows
           body["next_cursor"] = data["next_cursor"]
   
   
   posts = account_posts("harborline_roasters")
   with open("metrics.csv", "w", newline="") as f:
       w = csv.DictWriter(f, fieldnames=FIELDS, extrasaction="ignore")
       w.writeheader()
       w.writerows(posts)
   print(len(posts), "posts written")
   

   import { writeFileSync } from "node:fs";
   
   const API = "https://api.sorsa.io/v3/user-tweets";
   const HEADERS = {
     ApiKey: "YOUR_API_KEY",
     "Content-Type": "application/json",
   };
   const FIELDS = ["id", "created_at", "likes_count", "retweet_count",
     "reply_count", "quote_count", "view_count", "bookmark_count"];
   
   async function accountPosts(username, since = "2026-10-01") {
     const body = { username };
     const rows = [];
     for (;;) {
       const res = await fetch(API, {
         method: "POST", headers: HEADERS, body: JSON.stringify(body),
       });
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const data = await res.json();
       const page = data.tweets ?? [];
       rows.push(...page.filter((t) => t.created_at >= since));
       const old = page.every((t) => t.created_at < since);
       if (!data.next_cursor || old) return rows;
       body.next_cursor = data.next_cursor;
     }
   }
   
   const posts = await accountPosts("harborline_roasters");
   const lines = posts.map((t) => FIELDS.map((k) => t[k]).join(","));
   writeFileSync("metrics.csv", [FIELDS.join(","), ...lines].join("\n"));
   console.log(posts.length, "posts written");
   

4. Guarde cada execução como um snapshot. As contagens continuam crescendo depois que um post sai, então armazene cada coleta com a data dela (ID do post, momento da captura, as seis contagens). Dois snapshots com um dia de diferença mostram quais posts ainda estão ganhando, e uma contagem plotada contra created_at ao longo de um mês mostra se os posts da conta estão tendo mais ou menos alcance.

Um status 429 significa mais de 20 requisições em um segundo: espere um segundo e envie de novo. Um 403 significa que a chave está ausente ou sem requisições, e um 401 que está errada; requisições com falha nunca são cobradas.

#Mantenha as métricas atualizadas: atualize os posts acompanhados de 100 em 100

Quando você já sabe quais posts acompanha, atualize as contagens deles por ID: POST /tweet-info-bulk (abre em uma nova aba) recebe até 100 links ou IDs de posts e retorna cada post com as contagens atuais em uma única requisição, a partir de US$ 0,014 por 1.000 posts. As métricas de 1 milhão de posts custam a partir de US$ 14 assim.

A primeira página da timeline da conta faz parte do trabalho de graça: ela já contém os 20 posts mais recentes com as contagens atuais. Uma conta que posta duas vezes por dia mantém os últimos 10 dias atualizados com essa única requisição; só os posts mais antigos precisam da chamada em lote.

curl -X POST "https://api.sorsa.io/v3/tweet-info-bulk" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"tweet_links": ["2116184394037384839", "2115861688481928839"]}'

Em Python, corte a sua lista de IDs em fatias de 100 e envie cada fatia como tweet_links; a resposta é um único array tweets, sem cursor.

HEADERS = {"ApiKey": "YOUR_API_KEY"}


def refresh(ids):
    out = []
    for i in range(0, len(ids), 100):
        r = requests.post(
            "https://api.sorsa.io/v3/tweet-info-bulk",
            headers=HEADERS, json={"tweet_links": ids[i:i + 100]},
            timeout=60)
        r.raise_for_status()
        out += r.json().get("tweets", [])
    return out

Os cards comparam uma passada sobre uma lista de posts: as seis contagens de cada post, lidas uma vez.

#Respostas, citações e quem deu repost por API

As contagens dizem quantas pessoas se engajaram; mais três endpoints dizem quem elas eram e o que escreveram. Cada um recebe um link ou ID de post, e cada resposta e citação volta como um post completo, com as próprias contagens e o autor.

• Respostas abaixo de um post

  Endpoint da Sorsa API

  /comments (abre em uma nova aba)

  O que volta

  até 20 respostas por página, por Relevance, Recency ou Likes

• Posts com citação de um post

  Endpoint da Sorsa API

  /quotes (abre em uma nova aba)

  O que volta

  até 20 citações por página, com o texto acrescentado

• Contas que deram repost

  Endpoint da Sorsa API

  /retweeters (abre em uma nova aba)

  O que volta

  perfis com contagem de seguidores, do mais novo para o mais antigo

• Totais de muitas contas

  Endpoint da Sorsa API

  /info-batch (abre em uma nova aba)

  O que volta

  até 100 perfis por requisição

Cada um responde a uma pergunta diferente. Respostas ordenadas por Likes colocam as respostas mais curtidas na primeira página, então uma única requisição mostra como o público recebeu um post. As citações trazem o comentário que as pessoas acrescentaram, a matéria-prima para tom ou sentimento. As contagens de seguidores de quem deu repost somam a audiência que um post alcançou de segunda mão.

BASE = "https://api.sorsa.io/v3"
HEADERS = {"ApiKey": "YOUR_API_KEY"}


def pages(path, body, key, limit=10):
    for _ in range(limit):
        r = requests.post(f"{BASE}/{path}", headers=HEADERS,
                          json=body, timeout=30)
        r.raise_for_status()
        data = r.json()
        yield from data.get(key, [])
        if not data.get("next_cursor"):
            return
        body = {**body, "next_cursor": data["next_cursor"]}


post = "https://x.com/harborline_roasters/status/2116184394037384839"
top = list(pages("comments", {"tweet_link": post, "order_by": "Likes"},
                 "tweets", limit=1))[:5]
quotes = list(pages("quotes", {"tweet_link": post}, "tweets"))
fans = list(pages("retweeters", {"tweet_link": post}, "users"))
reach = sum(u.get("followers_count", 0) for u in fans)
print(len(quotes), "quotes,", len(fans), "retweeters,", reach, "reach")

Na API oficial do X, os posts com citação vêm de GET /2/tweets/:id/quote_tweets a US$ 0,005 cada e quem deu repost vem de GET /2/tweets/:id/retweeted_by a US$ 0,010 cada, US$ 10,00 por 1.000 contas. Cada um desses dois endpoints permite 75 requisições a cada 15 minutos (rate limits da API do X (abre em uma nova aba)). As respostas não têm endpoint próprio lá: elas vêm de uma busca por conversation_id, que na busca recente alcança 7 dias.

Duas tarefas ficam em páginas próprias. Para verificar se uma conta seguiu, deu repost, citou ou respondeu, o guia da API de verificação do Twitter responde em uma única checagem. Para ler as respostas de um post sem código, veja como ver comentários no X.

#Como calcular a taxa de engajamento com dados da API

A taxa de engajamento é a parcela de pessoas que interagiram com um post, e os campos da API dão as duas versões comuns. Por visualizações, some curtidas, reposts, respostas e citações, divida pelas visualizações e multiplique por 100. Por seguidores, divida a mesma soma pelo followers_count do autor, que todo post traz no objeto user.

Tome o post da resposta acima: 212 curtidas, 31 reposts, 24 respostas e 6 citações somam 273 interações. Contra 9.640 visualizações, isso dá 2,83%; contra 8.450 seguidores, 3,23%. A Calculadora de taxa de engajamento do Twitter usa as mesmas duas fórmulas, então seu código e a ferramenta gratuita concordam em qualquer conta.

from statistics import median


def engagement(posts):
    followers = posts[0]["user"]["followers_count"]
    for t in posts:
        acts = (t["likes_count"] + t["retweet_count"]
                + t["reply_count"] + t["quote_count"])
        views = t["view_count"] or 1
        t["er_views"] = round(100 * acts / views, 2)
        t["er_followers"] = round(100 * acts / followers, 2)
    return median(t["view_count"] for t in posts)

Informe a mediana de visualizações ao lado da taxa. Um post viral levanta uma média por meses, enquanto a mediana mostra o que um post típico recebe. Deixe de fora da mediana os posts com menos de dois dias, já que as visualizações deles ainda estão subindo.

Bom saber

As visualizações contam telas, não pessoas. O X conta uma impressão cada vez que um post aparece em uma tela, então um leitor que passa por ele duas vezes soma duas visualizações. Compare taxas por visualizações entre contas de tamanho parecido e use a taxa por seguidores para comparar audiências.

#Quanto custa por mês um pipeline de analytics do X

O custo de um pipeline de analytics depende de três números: quantas contas você acompanha, quantos posts cada uma publica por dia e por quantos dias você relê cada post. Mova os controles deslizantes para ver um mês nas duas APIs.

A diferença vem da unidade. A API oficial do X cobra cada post que retorna, a cada dia em que você o lê de novo, e para em 3 milhões de leituras de posts por mês; acima disso, resta apenas um contrato Enterprise a partir de cerca de US$ 42.000 por mês. A Sorsa API cobra a requisição, e uma requisição carrega até 100 posts por ID ou 20 de uma timeline.

Para um dashboard sobre concorrentes, clientes ou criadores, escolha a Sorsa API: as métricas de tweets custam a partir de US$ 0,014 por 1.000 posts, em vez de US$ 5,00. Todos os planos rodam a 20 requisições por segundo, uma chave de API substitui a conta de desenvolvedor, e a mesma chave lê respostas, citações, quem deu repost e a busca desde 2006. Ela é somente leitura, então nunca toca na sua conta do X.

#Analise um assunto, não só uma conta

A análise de engajamento também funciona sobre uma conversa: busque os posts sobre um assunto e depois ordene-os pelas contagens. POST /search-tweets (abre em uma nova aba) aceita os próprios operadores de busca do X, retorna cerca de 20 posts por página com as seis contagens e o autor, e alcança 2006.

curl -X POST "https://api.sorsa.io/v3/search-tweets" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "\"cold brew\" min_faves:50 lang:en", "order": "popular"}'

Acrescente since: e until: à consulta para uma janela de datas. Some as interações por autor para ver quem move o assunto, ou execute uma consulta por marca sobre as mesmas datas para obter a participação na conversa. O guia da API de busca do Twitter cobre os operadores, e a análise de concorrentes no Twitter transforma os mesmos dados em um benchmark.

#Comece hoje com uma conta

As curtidas, os reposts, as respostas, as citações, as visualizações e os itens salvos de todo post público podem ser lidos por API, de qualquer conta; só cliques e follows ficam com o autor. A Sorsa API retorna as seis contagens com o perfil do autor, 100 posts por requisição por ID, a partir de US$ 0,014 por 1.000, contra US$ 5,00 na API oficial do X. Puxe o último mês de uma conta com o loop acima, atualize-o diariamente, e as 100 requisições grátis cobrem seus primeiros 10 mil posts.

#FAQ