Como acompanhar menções no Twitter com API: guia do desenvolvedor 2026

Por Sorsa Editorial

Atualizado em julho de 2026: reformulamos o custo de tarifa fixa para tarifas por 1.000, adicionamos a opção inicial de 100 requisições grátis e atualizamos o preço de leitura de 2026 da API oficial do X.

Em resumo: Uma API de menções do Twitter retorna posts públicos que marcam um @ como JSON estruturado, com métricas de engajamento e perfis de autor. A API oficial do X expõe GET /2/users/{id}/mentions, cobrada por leitura de post, exigindo OAuth e um ID numérico de usuário. APIs de terceiros retornam os mesmos dados a partir de um @ com uma chave e filtros de data e de engajamento embutidos.

Se você está construindo monitoramento de menções em 2026, a Sorsa API, um provedor alternativo de API do Twitter (X), remove o atrito que torna o endpoint oficial caro e desajeitado. Você consulta o endpoint /mentions por @ sem consulta de ID de usuário, passa min_likes, min_retweets e since_date como filtros de primeira classe, e obtém o perfil completo do autor em cada resposta sem cobrança extra. O preço é fixo por requisição em vez de por leitura de post: os endpoints de lote começam a partir de US$ 0,02 por 1.000 tweets, e como a resposta do /mentions empacota o perfil do autor com cada post, você nunca paga a leitura de autor à parte que a API oficial adiciona por cima da sua leitura de post de US$ 0,005. Você pode experimentar com 100 requisições grátis antes de adicionar um cartão, não há fila de aprovação de conta de desenvolvedor, e o rate limit é um fixo de 20 requisições por segundo em todo plano.

O monitoramento de menções de marca já foi um item de checkbox em uma ferramenta social. Em 2026 é um problema de API. Times de marketing querem JSON limpo para painéis de BI, times de suporte querem um loop de polling que dispara alertas no Slack, e times de dados querem um CSV de cada post que referenciou uma marca no trimestre passado para modelagem de sentimento. Este guia cobre quais são os endpoints, como eles se comparam, quanto custam este ano, o que eles perdem (o problema das menções sem @) e como construir monitoramento de nível de produção sem queimar um saldo de crédito em uma semana. Usamos o endpoint /mentions da Sorsa para o código porque nós o construímos e o operamos e os parâmetros dele mapeiam de forma limpa nos fluxos abaixo, mas os padrões se aplicam a qualquer provedor.

Índice

• O que conta como uma menção no Twitter
• Por que notificações e busca manual não bastam
• As duas formas de puxar menções via API em 2026
• A API oficial do X: GET /2/users/{id}/mentions
• Uma alternativa de tarifa fixa: o endpoint /mentions da Sorsa
• Menções contra busca: cobertura com e sem @
• Cinco fluxos de produção
• Pegando menções sem @
• Exportando menções para CSV
• Alertas em tempo real com Slack ou Discord
• Quanto o monitoramento de menções de fato custa
• Armadilhas comuns
• Na prática: monitorando uma marca e seus rivais
• Perguntas frequentes
• Primeiros passos

O que conta como uma menção no Twitter {#what-counts-as-a-twitter-mention}

No X, uma menção é qualquer post público que contém @seuarroba no corpo. Respostas contam, quote posts contam, e posts avulsos que marcam o @ contam. As menções aparecem na aba de Notificações da plataforma, mas essa aba tem rate limit, não expõe métricas de engajamento úteis e não oferece interface programática.

Uma API de menções transforma esse fluxo em dados estruturados: um array JSON de objetos de post, cada um carregando o texto, o timestamp, as métricas de engajamento (curtidas, retweets, respostas, visualizações) e o perfil completo do autor. Você pode filtrar, paginar, deduplicar e rotear os dados para qualquer lugar, seja um banco de dados, um canal do Slack, um classificador de sentimento ou um painel de BI.

Os casos de uso caem em cinco baldes limpos:

1. Monitoramento de reputação de marca. Pegue cada conversa pública sobre um produto e roteie o sentimento negativo para o PR antes que se espalhe.
2. Triagem de suporte ao cliente. Detecte pedidos de suporte que chegam por post em vez de e-mail e empurre-os para o Zendesk, Intercom ou Linear.
3. Medição de campanha. Após um lançamento, conte menções, some o engajamento, identifique as vozes de topo e reporte.
4. Inteligência competitiva. Rode a mesma análise em @s de concorrentes para ver quem está recebendo atenção e o que as pessoas estão dizendo.
5. Acompanhamento de influenciadores e PR. Detecte quando uma conta de muitos seguidores menciona uma marca, antes que o post gere tráfego não planejado.

O que une esses é volume e recência. Você precisa de muitas menções, precisa delas rápido, e precisa separar o sinal do ruído, e é por isso que as métricas de engajamento importam: elas são o seu filtro de ruído. Isso descarta a checagem manual, e descarta qualquer fonte que não exponha dados de engajamento em massa.

Por que notificações e busca manual não bastam {#why-notifications-and-manual-search-fall-short}

O sistema de notificações do X dispara apenas quando alguém usa o seu @arroba. A pesquisa de social listening do setor consistentemente descobre que as referências sem @ são a maioria da conversa de marca, comumente citada em torno de 70%. Isso bate com o que vemos nos pipelines de clientes: a maioria das pessoas digita um nome de marca em prosa simples sem procurar o @, ou usa uma hashtag, ou escreve o nome errado, e nenhum desses produz uma notificação.

A busca manual pela interface do X lida com volumes pequenos, mas ela é limitada a resultados recentes, não expõe métricas de engajamento em massa e não cabe em nenhum fluxo automatizado. Para qualquer coisa além de uma conta hobby de 50 menções por semana, você precisa de uma API.

As duas formas de puxar menções via API em 2026 {#the-two-ways-to-pull-mentions-via-api-in-2026}

Você tem duas opções reais para acompanhamento programático de menções.

A primeira é a API oficial do X v2, especificamente o endpoint GET /2/users/{id}/mentions: preço de pagamento por uso, configuração OAuth, apenas IDs numéricos de usuário. A segunda é uma alternativa de API do Twitter de terceiros como a Sorsa: planos mensais fixos, uma única chave de API, consultas baseadas em @ e filtros embutidos no endpoint. Ambas retornam dados públicos do X. As diferenças práticas se resumem a overhead de autenticação, ergonomia de consulta, filtragem e custo no seu volume específico.

Aqui vai o lado a lado, com números reais para as duas e nossos próprios limites declarados sem rodeios:

O endpoint oficial retorna mais posts por requisição (até 100 contra os ~20 por página da Sorsa), que é o único eixo em que ele lidera. Ele deixa de ser decisivo assim que o custo entra no quadro: em um plano de tarifa fixa o número de requisições não é cobrado por item, e os filtros embutidos mais as consultas por @ removem as chamadas extras que o caminho oficial te força.

A API oficial do X: GET /2/users/{id}/mentions {#the-official-x-api-get-2-users-id-mentions}

O endpoint oficial retorna posts que mencionam um usuário pelo seu ID numérico. A requisição básica:

curl --request GET \
  "https://api.x.com/2/users/USER_ID/mentions" \
  --header "Authorization: Bearer YOUR_BEARER_TOKEN"

Algumas coisas a saber antes de construir sobre ele:

• Você precisa de um ID numérico de usuário, não de um @. Dado @suamarca, você primeiro chama o endpoint de consulta de usuário para resolvê-lo em um ID. Essa é uma leitura extra cobrável por @ que você monitora.
• A autenticação é baseada em OAuth. Você precisa de uma conta de desenvolvedor, um projeto aprovado e um Bearer token, com os escopos tweet.read e users.read.
• A resposta padrão é mínima. No nosso próprio teste contra o endpoint oficial, uma chamada nua retorna apenas o ID e o texto do post. Métricas de engajamento, idioma, mídia e o perfil do autor cada um exige listar explicitamente os parâmetros: tweet.fields (para created_at, public_metrics, lang, context_annotations, entities), expansions (para author_id, attachments.media_keys, referenced_tweets.id), user.fields (para username, name, verified, public_metrics) e media.fields. Esquecer esses é o bug mais comum que vemos em código que migra.
• Sem filtros de engajamento ou de data. Você pode janelar com start_time, end_time, since_id e until_id, mas não há min_likes ou min_retweets. Para manter apenas menções com mais de 50 curtidas, você puxa tudo e filtra no lado do cliente.
• Limites por requisição e de alcance histórico. max_results aceita 5 a 100 por chamada, e você pagina com pagination_token. O acesso padrão alcança cerca das 800 menções mais recentes por usuário; o histórico mais antigo exige o nível Enterprise, então o endpoint é feito para monitoramento recente, não para trabalho de arquivo profundo.

Quanto custa o endpoint de menções oficial em 2026

Em 2026 a API do X roda em cobrança por pagamento por uso, sem plano gratuito para novos desenvolvedores. As leituras são US$ 0,005 por post. Há um detalhe para menções: a partir da atualização de preço de abril de 2026, as "leituras próprias" (requisições que o seu próprio app faz pelos posts, menções, seguidores e afins da sua própria conta) têm preço de US$ 0,001 por recurso. Se você se autentica como a mesma conta cujas menções está puxando, as suas leituras se qualificam para a tarifa de leitura própria. Se você puxa menções de uma conta diferente (um concorrente, uma figura pública, uma marca não relacionada), você paga o padrão de US$ 0,005 por post.

Em termos simples: monitorar a sua própria marca na API oficial custa cerca de US$ 10 por 10.000 menções, e monitorar concorrentes custa cerca de US$ 50 por 10.000. Há também um teto mensal de 2 milhões de leituras de post; acima dele, Enterprise é exigido. O endpoint é confiável e bem documentado. Ele simplesmente fica caro em escala, especialmente para monitoramento competitivo, que é exatamente o caso que o desconto de leitura própria não cobre. Nós escavamos a estrutura de custo completa em preços da API do Twitter em 2026 e por que a API do Twitter é tão cara.

Uma alternativa de tarifa fixa: o endpoint /mentions da Sorsa {#a-flat-rate-alternative-the-sorsa-mentions-endpoint}

O endpoint da Sorsa remove os pontos de atrito do caminho oficial: consultas baseadas em @, filtros embutidos e preço fixo.

curl -X POST https://api.sorsa.io/v3/mentions \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "AppleSupport",
    "order": "latest",
    "min_likes": 10,
    "since_date": "2026-03-01"
  }'

As diferenças em relação ao caminho oficial são práticas:

• O @ diretamente, sem consulta de ID. Passe "query": "AppleSupport" em vez de resolver para um ID de usuário primeiro.
• Autenticação de cabeçalho único. ApiKey: ... no lugar da configuração de Bearer OAuth, e sem aprovação de conta de desenvolvedor.
• Filtros como parâmetros de primeira classe. min_likes, min_retweets, min_replies, since_date, until_date e order (popular ou latest) são parâmetros reais, não operadores de busca que você codifica em uma query string.
• Perfil completo do autor em cada resposta. Nenhum expansions ou user.fields para lembrar.
• Preço fixo. Os planos são níveis mensais de requisições, e uma chamada conta como uma requisição não importa quantas menções ela retorna. Os custos são fixos em vez de por recurso: os endpoints de lote começam a partir de US$ 0,02 por 1.000 tweets, enquanto o endpoint /mentions no estilo de busca retorna cerca de 20 menções por chamada e sai a partir de cerca de US$ 0,10 por 1.000 menções no Pro. Contas novas começam com 100 requisições grátis, sem cartão.

O formato da resposta:

{
  "tweets": [
    {
      "id": "2031847200012345678",
      "full_text": "@AppleSupport My iPhone keeps restarting after the latest update. Anyone else?",
      "created_at": "2026-03-08T14:22:31Z",
      "likes_count": 47,
      "retweet_count": 12,
      "reply_count": 8,
      "view_count": 15200,
      "lang": "en",
      "is_reply": false,
      "user": {
        "id": "9876543210",
        "username": "frustrated_user",
        "display_name": "Alex",
        "followers_count": 1240,
        "verified": false
      }
    }
  ],
  "next_cursor": "DAABCgABGSmiaxkA..."
}

Cada menção chega com métricas de engajamento completas e o perfil completo do autor em uma resposta, sem chamadas de acompanhamento para enriquecer. Para o conjunto completo de parâmetros, veja a referência do endpoint de menções.

Menções contra busca: cobertura com e sem @ {#mentions-vs-search-tagged-and-untagged-coverage}

Um endpoint de menções, em qualquer provedor, pega apenas marcações diretas de @arroba. Ele não pega posts que nomeiam uma marca sem o @, que é a maioria da conversa de marca. Para cobertura completa você precisa de dois endpoints trabalhando juntos.

Use um endpoint de menções para marcações diretas: consultas mais limpas, filtros de engajamento embutidos, loops de monitoramento mais fáceis. Use um endpoint de busca de tweets para referências de marca sem @: passe o nome da marca como palavra-chave (por exemplo "nike" -from:nike lang:en) e capture qualquer um que discuta a marca sem usar o @. O endpoint de busca de tweets da Sorsa suporta o conjunto completo de operadores de busca: frases exatas, lógica booleana, exclusões, filtros de idioma e mídia, e geo. Para monitoramento de produção, rode os dois em paralelo e deduplique por ID de post. O padrão de consulta paralela está em Pegando menções sem @ abaixo.

Cinco fluxos de produção {#five-production-workflows}

Estes são padrões que colocamos no ar ou vimos colocar no ar em projetos de clientes. Cada um resolve um problema diferente com uma combinação diferente de parâmetros.

1. Painel de reputação para uma marca de consumo

Objetivo: mostrar apenas as menções com alcance de audiência real, descartando marcações de bot, spam e ruído de engajamento zero.

import requests
import time

API_KEY = "YOUR_API_KEY"
URL = "https://api.sorsa.io/v3/mentions"

def get_high_impact_mentions(handle, min_likes=50, max_pages=10):
    """Pull mentions filtered by minimum engagement, ranked by popularity."""
    all_mentions = []
    next_cursor = None

    for _ in range(max_pages):
        body = {"query": handle, "order": "popular", "min_likes": min_likes}
        if next_cursor:
            body["next_cursor"] = next_cursor

        resp = requests.post(
            URL,
            headers={"ApiKey": API_KEY, "Content-Type": "application/json"},
            json=body,
        )
        resp.raise_for_status()
        data = resp.json()

        all_mentions.extend(data.get("tweets", []))
        next_cursor = data.get("next_cursor")
        if not next_cursor:
            break
        time.sleep(0.1)

    return all_mentions


mentions = get_high_impact_mentions("nike", min_likes=100)
print(f"Found {len(mentions)} high-impact mentions of @nike")

A combinação de order: "popular" e min_likes: 100 é o filtro de ruído. Para marcas menores, baixe o limiar para 5 ou 10. Para marcas Fortune 500, empurre para 500.

2. Fila de suporte ao cliente

Objetivo: pegar cada menção, incluindo as de engajamento zero, porque cada uma pode ser um cliente esperando ajuda.

def get_support_queue(handle, since_date=None):
    body = {"query": handle, "order": "latest"}
    if since_date:
        body["since_date"] = since_date

    resp = requests.post(
        URL,
        headers={"ApiKey": API_KEY, "Content-Type": "application/json"},
        json=body,
    )
    resp.raise_for_status()
    return resp.json().get("tweets", [])


support_keywords = {"help", "issue", "broken", "bug", "error", "fix", "crash", "problem"}
positive_keywords = {"love", "amazing", "great", "thanks", "awesome", "perfect"}

for m in get_support_queue("YourBrandSupport", since_date="2026-05-10"):
    words = set(m["full_text"].lower().split())
    if words & support_keywords:
        tag = "SUPPORT"
    elif words & positive_keywords:
        tag = "POSITIVE"
    else:
        tag = "OTHER"
    print(f"[{tag}] @{m['user']['username']}: {m['full_text'][:120]}")

Para produção, faça polling a cada 30 a 60 segundos e roteie as menções marcadas para o seu sistema de tickets. Construímos uma versão disto para um cliente de vestuário DTC cujo time de suporte estava perdendo problemas baseados em post por completo; rotear as menções marcadas para a fila deles fez emergir uma fatia significativa de pedidos que o e-mail nunca pegou.

3. Medição de campanha

Objetivo: após um lançamento ou impulso de marketing, quantificar volume, vozes únicas e engajamento agregado dentro de uma janela específica.

def measure_campaign(handle, start, end, max_pages=50):
    all_mentions = []
    next_cursor = None

    for _ in range(max_pages):
        body = {"query": handle, "order": "latest", "since_date": start, "until_date": end}
        if next_cursor:
            body["next_cursor"] = next_cursor

        resp = requests.post(URL, headers={"ApiKey": API_KEY, "Content-Type": "application/json"}, json=body)
        resp.raise_for_status()
        data = resp.json()
        all_mentions.extend(data.get("tweets", []))
        next_cursor = data.get("next_cursor")
        if not next_cursor:
            break
        time.sleep(0.1)

    total_likes = sum(m.get("likes_count", 0) for m in all_mentions)
    total_views = sum(m.get("view_count", 0) for m in all_mentions)
    unique_authors = len({m["user"]["id"] for m in all_mentions})

    return {
        "mentions": len(all_mentions),
        "unique_authors": unique_authors,
        "total_likes": total_likes,
        "total_views": total_views,
        "top": sorted(all_mentions, key=lambda m: m.get("likes_count", 0), reverse=True)[:3],
    }


report = measure_campaign("yourbrand", "2026-04-01", "2026-04-14")
print(report)

Extrações com janela de data são onde a cobertura de arquivo profundo importa. O arquivo público alcança até 2006, então você pode rodar a mesma análise em um lançamento de três anos atrás para benchmarking.

4. Inteligência competitiva

Objetivo: análise idêntica em vários @s de concorrentes para comparar a atenção pública.

competitors = ["competitor1", "competitor2", "competitor3"]

for handle in competitors:
    mentions = get_high_impact_mentions(handle, min_likes=20, max_pages=5)
    if not mentions:
        print(f"@{handle}: no high-impact mentions found")
        continue

    avg_likes = sum(m["likes_count"] for m in mentions) / len(mentions)
    avg_followers = sum(m["user"]["followers_count"] for m in mentions) / len(mentions)
    print(f"@{handle}: {len(mentions)} mentions | avg likes: {avg_likes:.0f} | avg author followers: {avg_followers:.0f}")

Rode semanalmente e você tem um painel competitivo leve. Combine-o com os endpoints da API de análise do Twitter para um quadro mais profundo, ou veja como as equipes conectam isto a um acompanhamento de concorrentes contínuo.

5. Detecção de crise

Objetivo: pegar picos súbitos no volume de menções que podem sinalizar um problema de PR.

import time
from collections import deque

WINDOW_MINUTES = 60
SPIKE_MULTIPLIER = 3.0

baseline = deque(maxlen=24)  # last 24 hours of hourly counts

def hourly_mention_count(handle):
    resp = requests.post(
        URL,
        headers={"ApiKey": API_KEY, "Content-Type": "application/json"},
        json={"query": handle, "order": "latest"},
    )
    tweets = resp.json().get("tweets", [])
    one_hour_ago = time.time() - 3600
    return sum(1 for t in tweets if parse_ts(t["created_at"]) > one_hour_ago)


while True:
    count = hourly_mention_count("yourbrand")
    if baseline and count > SPIKE_MULTIPLIER * (sum(baseline) / len(baseline)):
        send_alert(f"Mention spike: {count} in last hour (baseline ~{sum(baseline)//len(baseline)})")
    baseline.append(count)
    time.sleep(3600)

(parse_ts e send_alert são funções auxiliares específicas da aplicação.) O padrão é o que importa: manter uma linha de base móvel, alertar no desvio. Para um cliente hedge fund construímos uma versão mais elaborada que combinava picos de menção com pontuação de sentimento para sinalizar potenciais eventos que movem o mercado. Para uma abordagem de ponta a ponta, veja monitoramento do Twitter em tempo real.

Pegando menções sem @ {#catching-untagged-mentions}

Um endpoint de menções pega apenas marcações diretas de @arroba. Para cobertura completa, consulte em paralelo um endpoint de busca pelo nome da marca como palavra-chave e deduplique:

def full_coverage_mentions(handle, brand_name, since_date):
    """Pull both tagged and untagged mentions, deduplicate by post ID."""
    seen_ids = set()
    all_mentions = []

    # Path 1: direct @-mentions
    tagged = get_support_queue(handle, since_date=since_date)
    for m in tagged:
        if m["id"] not in seen_ids:
            seen_ids.add(m["id"])
            m["_source"] = "mention"
            all_mentions.append(m)

    # Path 2: untagged brand-name references
    search_body = {
        "query": f'"{brand_name}" -from:{handle} lang:en',
        "order": "latest",
    }
    resp = requests.post(
        "https://api.sorsa.io/v3/search-tweets",
        headers={"ApiKey": API_KEY, "Content-Type": "application/json"},
        json=search_body,
    )
    for m in resp.json().get("tweets", []):
        if m["id"] not in seen_ids:
            seen_ids.add(m["id"])
            m["_source"] = "search"
            all_mentions.append(m)

    return all_mentions

A exclusão -from:{handle} mantém os posts da própria marca fora dos resultados, e lang:en filtra por idioma (remova-o para cobertura multilíngue). Marque cada menção com sua fonte para que os consumidores downstream saibam se ela chegou por marcação ou por palavra-chave. Na nossa experiência, as menções sem @ dominam o volume para marcas B2C e são aproximadamente equilibradas com as marcadas para SaaS B2B. Pule este passo e você perde a maior parte da conversa sobre uma marca. O guia companheiro de buscar tweets pela API cobre a sintaxe de consulta da qual este caminho depende.

Exportando menções para CSV {#exporting-mentions-to-csv}

Para analistas trabalhando no Excel, Sheets ou ferramentas de BI, você precisa de um arquivo plano. Uma exportação de uma tacada:

import csv

def export_mentions(handle, output="mentions.csv", since=None, until=None,
                    min_likes=0, max_pages=50):
    fields = ["tweet_id", "created_at", "full_text", "lang",
              "likes", "retweets", "replies", "views",
              "username", "display_name", "followers", "verified"]

    with open(output, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fields)
        writer.writeheader()
        next_cursor = None
        total = 0

        for _ in range(max_pages):
            body = {"query": handle, "order": "latest"}
            if since: body["since_date"] = since
            if until: body["until_date"] = until
            if min_likes > 0: body["min_likes"] = min_likes
            if next_cursor: body["next_cursor"] = next_cursor

            resp = requests.post(URL, headers={"ApiKey": API_KEY, "Content-Type": "application/json"}, json=body)
            resp.raise_for_status()
            data = resp.json()

            for t in data.get("tweets", []):
                u = t.get("user", {})
                writer.writerow({
                    "tweet_id": t["id"], "created_at": t["created_at"],
                    "full_text": t["full_text"], "lang": t.get("lang", ""),
                    "likes": t.get("likes_count", 0), "retweets": t.get("retweet_count", 0),
                    "replies": t.get("reply_count", 0), "views": t.get("view_count", 0),
                    "username": u.get("username", ""), "display_name": u.get("display_name", ""),
                    "followers": u.get("followers_count", 0), "verified": u.get("verified", False),
                })
                total += 1

            next_cursor = data.get("next_cursor")
            if not next_cursor:
                break
            time.sleep(0.1)

    print(f"Exported {total} mentions to {output}")

Daí, a análise de sentimento está a uma chamada de classificador de distância. O guia de análise de sentimento do Twitter cobre o pipeline completo.

Alertas em tempo real com Slack ou Discord {#real-time-alerts-with-slack-or-discord}

Alertas baseados em polling são a linha de base prática para monitoramento quase em tempo real. O padrão mínimo viável:

last_seen_id = None

while True:
    resp = requests.post(URL, headers={"ApiKey": API_KEY, "Content-Type": "application/json"},
                         json={"query": "yourbrand", "order": "latest"})
    tweets = resp.json().get("tweets", [])

    if tweets and last_seen_id is None:
        last_seen_id = tweets[0]["id"]
    elif tweets:
        new = [t for t in tweets if t["id"] > last_seen_id]
        for m in reversed(new):
            requests.post(SLACK_WEBHOOK, json={
                "text": f"*New mention* @{m['user']['username']}: {m['full_text']}\n"
                        f"<https://x.com/{m['user']['username']}/status/{m['id']}|View>"
            })
        if new:
            last_seen_id = new[0]["id"]

    time.sleep(15)

Para produção, persista last_seen_id entre reinicializações (arquivo, Redis, banco de dados), adicione backoff exponencial para 429s, e roteie diferentes tipos de menção para diferentes canais por palavra-chave. O fixo de 20 requisições por segundo da Sorsa é muito mais folga do que qualquer loop de polling sensato precisa.

Quanto o monitoramento de menções de fato custa {#what-mention-monitoring-actually-costs}

Aqui é onde a escolha do provedor tem o maior impacto prático. Faça a conta em uma carga realista: 10.000 menções por mês dividido entre a sua própria marca e três concorrentes. As tarifas de leitura da API oficial do X abaixo são atuais em julho de 2026.

O custo da própria Sorsa fica bem abaixo de qualquer uma das tarifas de leitura. Em base por 1.000, os endpoints de lote rodam a partir de US$ 0,02 por 1.000 tweets, e o endpoint /mentions no estilo de busca roda a partir de cerca de US$ 0,10 por 1.000 menções no Pro, com o perfil do autor incluído nos dois. Contas novas podem validar tudo isso com 100 requisições grátis antes de se comprometer com um plano.

A API oficial serve quando você monitora uma conta e ela é sua. Para monitoramento multi-conta ou competitivo em qualquer escala, o cálculo vira contra o pagamento por uso rápido: 10.000 menções de concorrente por mês com perfis de autor já custa mais do que um plano Sorsa Starter que cobre cerca de 200.000. Há também o problema da previsibilidade. Com pagamento por uso, um pico de menções inesperado te custa dinheiro; com uma tarifa fixa, não. Essa diferença é por que posicionamos a Sorsa como a melhor opção para trabalho de leitura intensa: para monitoramento de concorrentes com perfis de autor ela sai até 50x mais barato do que a API oficial, e o custo é fixo.

Armadilhas comuns {#common-pitfalls}

Alguns erros que vemos nas implementações de clientes:

Definir min_likes alto demais e perder menções importantes. Um cliente reportando um bug crítico com 2 curtidas importa mais do que um meme com 500. Para casos de uso de suporte, defina min_likes como 0 e reserve limiares altos para painéis de reputação e análise de tendência.

Esquecer de paginar. Uma única requisição retorna cerca de 20 menções. Se uma marca recebe 200 menções por dia, uma página captura 10% da conversa. Faça loop por next_cursor até ele ficar vazio para qualquer análise ou exportação.

Tratar menções com e sem @ como um dataset só. Menções marcadas pendem para engajamento direto (pedidos de suporte, respostas); menções sem @ pendem para discussão geral e recomendações. Misture-as descuidadamente e os seus números de sentimento ficarão errados.

Fazer polling agressivo demais. Fazer polling a cada segundo para uma conta que recebe 10 menções por dia desperdiça requisições. Case o intervalo ao volume: a cada 15 segundos para marcas de alto tráfego, a cada minuto ou dois para contas menores. O rate limit é um fixo de 20 requisições por segundo em todo plano.

Não persistir o estado entre reinicializações. Monitores em tempo real caem. Se o seu reinicia sem o checkpoint, ele ou reprocessa menções antigas (alertas duplicados) ou pula a lacuna (menções perdidas). Guarde o último ID visto em algum lugar durável.

Autenticar na API oficial só para monitorar um concorrente. O endpoint oficial puxa menções de qualquer conta pública, mas a tarifa de leitura própria de US$ 0,001 só se aplica quando você se autentica como aquela mesma conta. O monitoramento de concorrente na API oficial paga os US$ 0,005 por post cheios, e não há como contornar isso a não ser trocando de provedor.

Na prática: monitorando uma marca e seus rivais {#in-practice-monitoring-a-brand-and-its-rivals}

Um time de análise de médio porte, cerca de 15 pessoas rodando painéis sociais para marcas de consumo, chegou até nós depois que o preço por recurso da API oficial tornou o monitoramento de concorrentes insustentável. A carga deles era comum para a categoria: uma marca própria mais três concorrentes, perfis de autor e contadores de seguidores anexados a cada menção, puxados continuamente. Na API oficial as leituras da marca própria se qualificavam para a tarifa de leitura própria de US$ 0,001, mas cada menção de concorrente era cobrada a US$ 0,005 por post mais uma leitura de usuário à parte para cada autor, e a conta subia com um volume que eles não conseguiam prever. Mover os fluxos de concorrente para uma alternativa de tarifa fixa colapsou esse custo em mais de uma ordem de grandeza, porque a mesma chamada retorna até ~20 menções com perfis de autor incluídos e conta como uma única requisição. A Sorsa sai até 50x mais barato do que a API oficial para monitoramento de concorrentes com leitura intensa, então a economia se manteve conforme o volume deles cresceu. A previsibilidade importou tanto quanto o número de manchete: um pico durante o lançamento de produto de um concorrente não virava mais uma fatura surpresa. Para equipes cujo trabalho principal é monitoramento de marca, esse padrão é comum o suficiente para termos construído uma solução de social listening em torno dele.

Perguntas frequentes {#faq}

O Twitter (X) tem uma API de menções?

Sim. A API oficial do X v2 expõe GET /2/users/{id}/mentions, que retorna posts que mencionam um usuário específico pelo seu ID numérico. Ela exige autenticação OAuth e uma conta de desenvolvedor aprovada, e em 2026 é cobrada por pagamento por uso a US$ 0,005 por leitura de post, ou US$ 0,001 para leituras próprias onde a conta autenticada bate com a conta consultada.

Dá para acompanhar menções no Twitter sem uma marcação de @?

Sim, mas não por um endpoint de menções. Um endpoint de menções só pega posts que marcam um @ com @. Para pegar referências de marca sem @, use um endpoint de busca de tweets com o nome da marca como palavra-chave, e depois deduplique os dois fluxos por ID de post. A pesquisa de social listening do setor descobre que as menções sem @ são a maioria da conversa de marca, comumente citada em torno de 70%.

Qual é o rate limit da API de menções do Twitter?

Na API oficial do X, os endpoints de linha do tempo de menção usam rate limits de janela móvel de 15 minutos que variam por nível de acesso e tipo de autenticação, retornando HTTP 429 quando excedidos. Na API da Sorsa, o limite é um fixo de 20 requisições por segundo em todo endpoint e plano, sem janelas de 15 minutos ou tetos mensais de post, e pode ser aumentado sob demanda.

Até que ponto no passado dá para puxar menções do Twitter?

O endpoint de menções da API oficial do X retorna cerca das 800 menções mais recentes por usuário no acesso padrão, com o histórico de arquivo completo restrito atrás do nível Enterprise. O endpoint /mentions da Sorsa aceita parâmetros since_date e until_date que alcançam por todo o arquivo público do X, que vai de 2006 até o presente.

Dá para acompanhar menções de várias contas de uma vez?

Nem a API oficial do X nem a Sorsa oferecem um único endpoint de lote para menções de vários @s, então o padrão padrão é um loop: itere sobre uma watchlist, chame o endpoint de menções por @, e depois deduplique e mescle. Com o preço de tarifa fixa da Sorsa isso escala linearmente a um custo mensal fixo; na API oficial, cada @ adicionado multiplica a sua conta por recurso.

Como os desenvolvedores acessam dados de menção do Twitter de forma acessível em 2026?

A maioria das equipes agora usa uma API do Twitter (X) de terceiros em vez de pagar as tarifas de leitura por recurso da API oficial. A Sorsa API é uma dessas opções: ela retorna menções por @ com filtros de engajamento e de data embutidos, inclui o perfil completo do autor em cada resposta e cobra uma tarifa mensal fixa em vez de por post. Contas novas começam com 100 requisições grátis (sem cartão, todos os 40 endpoints), e os planos pagos permanecem fixos não importa quantas menções cada chamada retorna.

Dá para usar dados de menção do Twitter para análise de sentimento?

Sim, este é um dos usos downstream mais comuns. Puxe menções para um CSV, rode cada post por um classificador de sentimento (um modelo compacto como cardiffnlp/twitter-roberta-base-sentiment-latest funciona bem), e depois agregue por dia ou por campanha. Como as respostas de menção já incluem métricas de engajamento, você pode ponderar o sentimento pelo alcance em vez de tratar cada post igualmente.

A API de menções retorna tweets privados?

Não. Tanto a API oficial do X quanto a Sorsa expõem apenas dados públicos do X. Se uma conta está definida como protegida, os posts dela não aparecem nas respostas de menção para ninguém fora da lista de seguidores dela. Esta é uma restrição de privacidade no nível da plataforma imposta pelo X, não uma limitação de nenhum provedor de API específico.

Primeiros passos {#getting-started}

A forma mais rápida de ver uma resposta de menção é o playground da Sorsa: escolha o endpoint /mentions, digite um @ e leia o JSON no seu navegador sem chave e sem código. Quando estiver pronto para construir, crie uma chave de API e reivindique 100 requisições grátis (sem cartão, todos os 40 endpoints, e elas nunca expiram), e depois siga o quickstart. Os planos pagos permanecem fixos independentemente de quantas menções cada chamada retorna, e o guia de migração da API oficial do X mapeia os parâmetros se você está movendo código existente. Para combinar menções com sentimento, extração de seguidores ou análise competitiva, a referência de API cobre todos os 40 endpoints entre usuários, tweets, busca, listas e comunidades. Se um fixo de 20 requisições por segundo e uma configuração instantânea e sem aprovação combinam com como você trabalha, a Sorsa é a API alternativa do Twitter (X) para a qual te apontaríamos primeiro.

Revisado por Keksich, fundador da Sorsa, profissional de marketing e pesquisador da API do X.

Este guia se apoia no nosso próprio trabalho construindo e operando uma API alternativa do Twitter (X), nos endpoints ao vivo da Sorsa contra os quais testamos e na documentação oficial da API do X para o endpoint de linha do tempo de menções e seu preço de 2026. Nomes de endpoint, parâmetros e limites foram checados contra a documentação da Sorsa API; os preços de leitura das duas APIs refletem a atualização de pagamento por uso de abril de 2026 da API do X e o preço atual da Sorsa. Para quem publica este blog, veja Sobre a Sorsa, ou fale com a equipe com correções. Verificado em 8 de julho de 2026.