Como encontrar seu público-alvo no Twitter via API

Por Sorsa Editorial

Atualizado em julho de 2026: adicionada a franquia inicial de 100 requisições grátis, preço reapresentado em torno das taxas de lote por 1.000, atualizada a comparação de custo com a API oficial do X para o preço por recurso de abril de 2026 e reverificados os seis métodos de endpoint contra a API ao vivo.

Em resumo: Encontrar seu público-alvo no X (Twitter) em escala significa puxar listas de usuários de forma programática em vez de rolar. Seis métodos de API cobrem isso: bios por palavra-chave, intenção ao vivo em tweets, os seguidores de um concorrente, os membros de uma Comunidade, seguidores verificados e amplificadores de posts. Cada um retorna perfis públicos completos que você então deduplica, filtra e exporta.

O gargalo raramente é a estratégia. É o acesso aos dados. O X mostra um punhado de seguidores na interface antes de a lista parar de carregar, e a API oficial do X agora cobra por recurso: cada perfil de seguidor que você lê custa US$ 0,010, então uma única extração de 10.000 seguidores sai por cerca de US$ 100 antes de você filtrar ninguém. A Sorsa API, um provedor alternativo de API do Twitter (X), remove as duas paredes. Seu endpoint /followers retorna até 200 perfis completos por requisição a um preço fixo por requisição, então os mesmos 10.000 seguidores custam cerca de dez centavos no plano Pro, e você autentica com um único cabeçalho ApiKey em vez de um handshake OAuth e uma fila de aprovação. Cada técnica abaixo usa um endpoint e roda em um fixo de 20 requisições por segundo em qualquer plano.

Este guia cobre os seis métodos que usamos para montar um público, o código para rodar cada um, como combinar e limpar os resultados, quanto custa e o que fazer com a lista depois de tê-la.

Índice

• O que descoberta de público no X significa de verdade?
• Seis formas de encontrar um público, mapeadas para a pergunta que cada uma responde
• Técnica 1: encontrar contas pelo que colocam na bio
• Técnica 2: extrair a lista de seguidores de um concorrente
• Técnica 3: puxar a lista de membros de uma Comunidade
• Técnica 4: minerar intenção em tempo real da busca de tweets
• Técnica 5: isolar os seguidores verificados
• Técnica 6: capturar as contas que amplificam conteúdo
• Combine as fontes e pontue por sobreposição
• Filtre bots e contas mortas
• Quanto custa puxar um público contra a API oficial do X?
• O que fazer com o público depois de tê-lo
• Na prática: a montagem de público de uma equipe B2B SaaS
• Como testar você mesmo
• Perguntas frequentes

O que descoberta de público no X significa de verdade? {#what-does-audience-discovery-on-x-actually-mean}

Descoberta de público no X (Twitter) é o processo de identificar as contas específicas que vale a pena alcançar e então coletá-las como uma lista estruturada e filtrável. Ela abrange três grupos que se sobrepõem: pessoas que publicamente se descrevem como o seu público, pessoas que já seguem contas do seu segmento e pessoas postando ativamente sobre o seu tema agora.

A rota manual é familiar. Você abre a Busca Avançada, monta algumas Listas do Twitter à mão, navega por uma Comunidade e faz anotações. Isso funciona para um olhar pontual. Desmorona no momento em que você precisa de alguns milhares de contas, dos dados para qualificá-las e de um processo que dá para rodar de novo no mês seguinte. Não há botão de exportação, a interface para de carregar depois de algumas centenas de perfis, e nada disso é reproduzível.

A rota programática corrige os três problemas. Cada pergunta de descoberta mapeia para uma única chamada de API que retorna perfis públicos completos como JSON limpo: bio, contador de seguidores, idade da conta, localização, status verificado. Você coleta em escala, filtra no código e exporta para CSV ou um banco de dados. O restante deste guia é a versão prática disso.

Uma distinção que vale manter clara: o seu público-alvo é quem você quer alcançar, que nem sempre é quem já segue você. Os métodos abaixo encontram o primeiro, não só o segundo.

Seis formas de encontrar um público, mapeadas para a pergunta que cada uma responde {#six-ways}

Cada técnica responde uma pergunta de segmentação diferente e usa um endpoint diferente. Rode uma isolada, ou combine várias e pontue por sobreposição (coberto mais adiante).

Todos os exemplos usam https://api.sorsa.io/v3 como URL base e o cabeçalho ApiKey. A configuração compartilhada:

import requests, time

API_KEY = "YOUR_API_KEY"
BASE = "https://api.sorsa.io/v3"
AUTH = {"ApiKey": API_KEY}                                  # GET endpoints
POST_HEADERS = {**AUTH, "Content-Type": "application/json"} # POST endpoints

Técnica 1: encontrar contas pelo que colocam na bio {#technique-1}

A forma mais rápida de encontrar pessoas que se autodeclaram como o seu público é buscar o que elas escreveram sobre si mesmas. Uma palavra-chave como Solidity developer, growth marketer ou oncology nurse casa com bios, nomes de exibição e @s, então as pessoas que se identificam com um papel aparecem diretamente. Essa é a escolha certa quando o seu público se rotula com um título ou nicho.

O endpoint /search-users recebe uma consulta e pagina pelos resultados. Cada resultado é um perfil completo, então você qualifica candidatos no código sem uma segunda consulta.

def find_users_by_bio(query, max_pages=10):
    users, cursor = [], None
    for _ in range(max_pages):
        body = {"query": query}
        if cursor:
            body["next_cursor"] = cursor
        resp = requests.post(f"{BASE}/search-users", headers=POST_HEADERS,
                             json=body, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        users.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return users

users = find_users_by_bio("machine learning engineer")

O padrão é idêntico em qualquer linguagem. A mesma chamada em JavaScript:

async function findUsersByBio(query, maxPages = 10) {
  const all = [];
  let cursor = null;
  for (let i = 0; i < maxPages; i++) {
    const body = { query };
    if (cursor) body.next_cursor = cursor;
    const resp = await fetch("https://api.sorsa.io/v3/search-users", {
      method: "POST",
      headers: { ApiKey: "YOUR_API_KEY", "Content-Type": "application/json" },
      body: JSON.stringify(body),
    });
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
    const data = await resp.json();
    all.push(...(data.users || []));
    cursor = data.next_cursor;
    if (!cursor) break;
    await new Promise((r) => setTimeout(r, 100));
  }
  return all;
}

Como cada registro carrega o perfil completo, filtrar é uma list comprehension, não outra rodada de chamadas de API:

qualified = [
    u for u in users
    if u.get("followers_count", 0) >= 1000
    and u.get("tweets_count", 0) >= 100
    and not u.get("protected", False)
]

Para precisão com múltiplas palavras e operadores, a mesma sintaxe de consulta usada para tweets se aplica. Nosso guia da API de busca do Twitter percorre o conjunto de operadores em profundidade.

Técnica 2: extrair a lista de seguidores de um concorrente {#technique-2}

O sinal de público de maior rendimento é quem já segue uma conta do seu segmento. Se uma pessoa segue o seu concorrente direto, ela se pré-qualificou: ela se importa com a categoria. O endpoint /followers retorna essa lista, até 200 perfis completos por requisição, o que faz dele a chamada de descoberta mais econômica disponível.

def get_followers(username, max_pages=20):
    followers, cursor = [], None
    for _ in range(max_pages):
        params = {"username": username}
        if cursor:
            params["next_cursor"] = cursor
        resp = requests.get(f"{BASE}/followers", headers=AUTH,
                            params=params, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        followers.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return followers

followers = get_followers("competitor_handle", max_pages=20)

Um único concorrente é um ponto de partida. As contas que seguem vários players do seu segmento são um segmento mais afiado, porque a sobreposição sinaliza interesse genuíno na categoria em vez de um follow pontual. Puxe algumas sementes e guarde a interseção:

from collections import Counter

competitors = ["competitor_a", "competitor_b", "competitor_c"]
follower_sets = {h: {f["id"] for f in get_followers(h, max_pages=10)}
                 for h in competitors}

all_ids = [uid for ids in follower_sets.values() for uid in ids]
overlap = {uid for uid, c in Counter(all_ids).items() if c >= 2}

Percorrer uma conta de 50 milhões de seguidores de ponta a ponta raramente vale a pena. Para contas acima de cerca de 500.000 seguidores, puxar as primeiras 50 a 100 páginas (10.000 a 20.000 perfis) costuma ser uma amostra representativa do público recente e ativo. Para um tratamento mais profundo da extração de seguidores e de seguindo, incluindo os casos de borda de conta protegida e de amostragem, veja nosso guia de como extrair seguidores do Twitter.

Técnica 3: puxar a lista de membros de uma Comunidade {#technique-3}

As Comunidades do X são grupos com escopo de tema, o que significa que os membros já vêm filtrados por interesse auto-selecionado. Puxar a lista de uma Comunidade do seu nicho te entrega um público que optou pelo assunto exato. O endpoint /community-members aceita o ID numérico da Comunidade ou a URL completa.

def get_community_members(community_id, max_pages=20):
    members, cursor = [], None
    for _ in range(max_pages):
        body = {"community_link": community_id}
        if cursor:
            body["next_cursor"] = cursor
        resp = requests.post(f"{BASE}/community-members", headers=POST_HEADERS,
                             json=body, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        members.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return members

Os resultados de Comunidade são perfis compactos (id, username, nome de exibição, imagem, verificado, protegido). Para enriquecê-los com contadores de seguidores, bios e idade da conta para filtrar, passe os IDs coletados pelo endpoint de perfis em lote, que aceita até 100 IDs e conta como uma única requisição. Os endpoints relacionados de Listas e Comunidades estão cobertos no nosso guia da API de Listas e Comunidades do X.

Técnica 4: minerar intenção em tempo real da busca de tweets {#technique-4}

As outras técnicas encontram pessoas por quem elas são ou por quem elas seguem. A busca de tweets as encontra pelo que estão dizendo agora. Alguém postando "procurando uma recomendação de CRM" hoje é um público diferente e muitas vezes mais valioso do que alguém que apenas encaixa em um perfil estático, porque a intenção é fresca. Busque os tweets e depois extraia os autores únicos.

def find_active_voices(query, min_followers=100, max_pages=10):
    seen, voices, cursor = set(), [], None
    for _ in range(max_pages):
        body = {"query": query, "order": "latest"}
        if cursor:
            body["next_cursor"] = cursor
        resp = requests.post(f"{BASE}/search-tweets", headers=POST_HEADERS,
                             json=body, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        for tw in data.get("tweets", []):
            u = tw.get("user", {})
            uid = u.get("id")
            if uid and uid not in seen and u.get("followers_count", 0) >= min_followers:
                seen.add(uid)
                voices.append({
                    "username": u.get("username"),
                    "followers": u.get("followers_count", 0),
                    "bio": u.get("description", ""),
                    "sample_tweet": (tw.get("full_text") or "")[:160],
                })
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return voices

voices = find_active_voices(
    '("need a CRM" OR "looking for a CRM") lang:en -filter:retweets')

A string de consulta é onde essa técnica se paga. Alguns padrões que revelam intenção:

O conjunto completo de operadores, incluindo os filtros de engajamento que a API oficial silenciosamente descarta, está na nossa referência de operadores de busca do Twitter.

Técnica 5: isolar os seguidores verificados {#technique-5}

Para listas de PR, abordagem a jornalistas, pesquisa de investidores ou checagem de influenciadores, a fatia de alto perfil de um público importa mais que o número bruto. O /verified-followers retorna só as contas verificadas que seguem um alvo, com o mesmo formato e a mesma paginação do /followers.

def get_verified_followers(username, max_pages=10):
    verified, cursor = [], None
    for _ in range(max_pages):
        params = {"username": username}
        if cursor:
            params["next_cursor"] = cursor
        resp = requests.get(f"{BASE}/verified-followers", headers=AUTH,
                            params=params, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        verified.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return verified

verified = get_verified_followers("openai")
verified.sort(key=lambda u: u.get("followers_count", 0), reverse=True)

Ordenada por alcance, essa é uma lista curta pronta das contas mais influentes na órbita de um alvo. Para encontrar e qualificar contas influentes além de uma única lista de seguidores, nossa API de influenciadores para qualquer nicho cobre o fluxo mais amplo.

Técnica 6: capturar as contas que amplificam conteúdo {#technique-6}

As pessoas que dão retweet e quote-tweet em conteúdo do seu segmento são um público que já age, não só espia. Dois endpoints cobrem a amplificação. O /retweeters retorna os usuários que repostaram um tweet. O /quotes retorna os quote tweets completos, que incluem o usuário que citou mais o comentário dele, útil para abordagem marcada por sentimento.

def get_retweeters(tweet_link, max_pages=10):
    users, cursor = [], None
    for _ in range(max_pages):
        body = {"tweet_link": tweet_link}
        if cursor:
            body["next_cursor"] = cursor
        resp = requests.post(f"{BASE}/retweeters", headers=POST_HEADERS,
                             json=body, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        users.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return users

def get_quoters(tweet_link, max_pages=10):
    quotes, cursor = [], None
    for _ in range(max_pages):
        body = {"tweet_link": tweet_link}
        if cursor:
            body["next_cursor"] = cursor
        resp = requests.post(f"{BASE}/quotes", headers=POST_HEADERS,
                             json=body, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        quotes.extend(data.get("tweets", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return quotes

Os quote tweets são objetos de tweet, não objetos de usuário: alcance a conta que citou por tweet["user"] e o comentário dela por tweet["full_text"]. O conjunto completo de engajamento (respostas, quotes, quem deu retweet) está coberto no nosso guia da API de engajamento do Twitter.

Combine as fontes e pontue por sobreposição {#combine}

Cada técnica cobre um ponto cego diferente, então o segmento mais forte são as contas que aparecem em mais de uma. Rode vários métodos, deduplique por ID de usuário e ranqueie por quantas fontes cada conta apareceu:

def score_by_source(by_source):
    """by_source: {source_name: [user objects]} -> deduped users with source_count."""
    index = {}
    for source, users in by_source.items():
        for u in users:
            uid = u["id"]
            index.setdefault(uid, {"user": u, "sources": set()})["sources"].add(source)

    result = []
    for entry in index.values():
        u = entry["user"].copy()
        u["source_count"] = len(entry["sources"])
        u["sources"] = sorted(entry["sources"])
        result.append(u)

    result.sort(key=lambda r: (-r["source_count"], -r.get("followers_count", 0)))
    return result

combined = score_by_source({
    "followers_competitor_a": followers,
    "bio_ml_engineer": users,
    "intent_crm": voices,
    "community_indie_hackers": get_community_members("1966045657589813686"),
})

Contas que aparecem em duas ou mais fontes costumam ser a parte de maior valor da lista. Uma pessoa que segue o seu concorrente, se descreve com o seu papel-alvo e postou intenção esta semana é um lead mais forte que qualquer sinal isolado.

Filtre bots e contas mortas {#filter}

A saída bruta de descoberta sempre carrega ruído: bots, contas abandonadas e perfis de fazenda de follow. Como cada endpoint retorna o perfil completo, um único filtro reutilizável limpa a lista inteira sem chamadas extras:

from datetime import datetime, timezone, timedelta

def is_quality_account(user, min_followers=500, min_tweets=100, max_following_ratio=10):
    if user.get("protected", False):
        return False
    if user.get("followers_count", 0) < min_followers:
        return False
    if user.get("tweets_count", 0) < min_tweets:
        return False
    followers = user.get("followers_count", 1)
    if user.get("followings_count", 0) > followers * max_following_ratio:
        return False
    created = user.get("created_at")
    if created:
        try:
            dt = datetime.fromisoformat(created.replace("Z", "+00:00"))
            if dt > datetime.now(timezone.utc) - timedelta(days=30):
                return False
        except ValueError:
            pass
    if not (user.get("description") or "").strip():
        return False
    return True

qualified = [u for u in combined if is_quality_account(u)]

Uma razão desproporcional de seguindo para seguidores, uma bio vazia, uma conta recém-criada e quase zero tweets são os sinais de bot mais baratos. Ajuste os limiares ao seu nicho. Para uma passada mais profunda na pontuação de contas falsas e inativas, veja nosso guia de auditoria de seguidores falsos.

Quanto custa puxar um público contra a API oficial do X? {#cost}

A descoberta de público é de leitura intensa por natureza: milhares de perfis por projeto, muitas vezes atualizados em uma agenda. Essa é exatamente a carga em que o modelo de cobrança decide a conta. A API oficial do X cobra por recurso buscado, então cada perfil é uma unidade cobrável separada. Uma API do Twitter (X) de taxa fixa cobra por requisição, e uma requisição de seguidores retorna até 200 perfis pelo preço de uma chamada.

A diferença se acumula em escala. Puxar 10.000 seguidores de concorrentes mais 10.000 perfis de busca por bio na API oficial são cerca de 20.000 leituras de usuário, uns US$ 200, antes de qualquer filtragem. As mesmas duas extrações no plano Pro de um provedor com preço fixo por requisição cabem dentro de um único orçamento mensal de requisições. Para o detalhamento completo de custo provedor por provedor, veja nossa comparação de alternativas à API do Twitter. (Os números da API oficial do X refletem o preço por recurso vigente após a atualização de abril de 2026; as nossas próprias taxas são fixas por requisição em todos os planos.)

O que fazer com o público depois de tê-lo {#what-next}

Uma lista de contas é matéria-prima, não o resultado. Onde o valor de fato aparece:

• Abordagem e geração de leads. Perfis filtrados e deduplicados viram uma lista de contatos priorizada. Os scores de intenção e de sobreposição dizem quem alcançar primeiro. Nosso fluxo de geração de leads no X se apoia exatamente nessa saída, e o guia prático de como encontrar leads no X percorre os filtros de qualificação.
• Estratégia de conteúdo. As bios, frases recorrentes e tweets de amostra que você coletou mapeiam a linguagem que o seu público de fato usa. Espelhe a redação deles em ganchos e threads em vez de adivinhar.
• Benchmark de concorrentes e de público. Compare a sobreposição entre os seus seguidores e os de um rival, ou acompanhe como o público de um concorrente cresce ao longo do tempo, com acompanhamento de concorrentes no X. O método do lado de desenvolvedor está no nosso guia de análise de concorrentes no Twitter.
• Dimensionamento de mercado por geografia. Agregue o público por país para ver quais mercados são reais antes de comprometer um orçamento. O método está no nosso guia de geografia de audiência do Twitter.

Seja qual for o destino, a exportação é o mesmo passo. Se você preferir pular o código, os mesmos perfis podem ir direto para uma planilha pelo nosso passo a passo de exportar dados do X para o Google Sheets. O trecho abaixo grava a saída de qualquer técnica em CSV:

import csv

def export_users_to_csv(users, output_file="audience.csv"):
    fields = ["user_id", "username", "display_name", "description",
              "followers_count", "followings_count", "tweets_count",
              "location", "verified", "created_at"]
    with open(output_file, "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(f, fieldnames=fields)
        w.writeheader()
        for u in users:
            w.writerow({
                "user_id": u.get("id", ""),
                "username": u.get("username", ""),
                "display_name": u.get("display_name", ""),
                "description": (u.get("description") or "").replace("\n", " "),
                "followers_count": u.get("followers_count", 0),
                "followings_count": u.get("followings_count", 0),
                "tweets_count": u.get("tweets_count", 0),
                "location": u.get("location", ""),
                "verified": u.get("verified", False),
                "created_at": u.get("created_at", ""),
            })

Na prática: a montagem de público de uma equipe B2B SaaS {#in-practice}

Uma equipe de marketing B2B SaaS com cerca de 12 pessoas chegou a essa abordagem depois de fazer abordagem à mão por dois trimestres. O processo deles era um pesquisador copiando @s da Busca Avançada para uma planilha, o que travava em torno de algumas centenas de contas por semana e não produzia dados de qualificação. Eles o reconstruíram como um pipeline: extrair os seguidores dos três concorrentes mais próximos, rodar uma busca por bio para os dois cargos que os compradores deles ocupam, buscar tweets com intenção de migração contra uma ferramenta já estabelecida, depois combinar e pontuar por sobreposição. As contas que batiam em duas ou mais fontes viraram uma lista de abordagem ranqueada de alguns milhares de perfis qualificados, atualizada semanalmente.

A parte que os surpreendeu foi a linha de custo. O plano original de rodar esse volume na API oficial do X precificava a carga de leitura em centenas de dólares por mês antes de filtrar. Mover a camada de dados para um scraper de Twitter de taxa fixa colocou as mesmas extrações dentro de um plano mensal abaixo de US$ 200. Para trabalho de leitura intensa como esse, um modelo fixo por requisição sai até 50x mais barato que a cobrança por recurso, porque uma requisição de seguidores retorna até 200 perfis pelo preço de uma única unidade.

Como testar você mesmo {#getting-started}

Você pode testar cada técnica aqui sem escrever código primeiro. O Sorsa Playground no-code roda os mesmos endpoints por uma interface: escolha um método, defina o número de páginas, veja o custo da requisição de saída e baixe os resultados. Quando estiver pronto para colocar em script, o início rápido te dá uma requisição funcional em poucos minutos.

A configuração é um único cabeçalho ApiKey, sem análise de conta de desenvolvedor e sem fluxo OAuth, e as primeiras 100 requisições são grátis: uma franquia única que dispensa cartão, nunca expira e cobre todos os 40 endpoints (o bastante para até 10.000 tweets ou 20.000 perfis). As extrações de perfil saem a partir de US$ 0,01 por 1.000 e os tweets a partir de US$ 0,02 por 1.000, e todo plano mantém um fixo de 20 requisições por segundo, que em uma chamada de seguidores de 200 perfis chega a até 4.000 perfis por segundo. Para levantamentos de público maiores ou agendados, a página de preços tem o cálculo por requisição e uma calculadora.

Perguntas frequentes {#faq}

Como você encontra o seu público-alvo no Twitter (X)? Encontrar o seu público-alvo no X significa coletar as contas específicas que vale a pena alcançar como uma lista estruturada em vez de rolar o app. Os métodos práticos são busca por palavra-chave em bio e em tweets, extrair os seguidores de um concorrente, raspar os membros de uma Comunidade e reunir as contas que dão retweet em posts relevantes. Uma API os retorna como perfis completos que você pode filtrar e exportar.

Dá para encontrar usuários do Twitter por uma palavra-chave na bio? Sim. Buscar bios, nomes de exibição e @s por uma palavra-chave revela contas que se autoidentificam com um papel ou nicho, como "Solidity developer" ou "growth marketer". Um endpoint de busca de usuários faz isso e retorna cada correspondência como um perfil completo, incluindo contador de seguidores e idade da conta, para você qualificar candidatos no código sem uma segunda consulta.

Como obter uma lista dos seguidores de um concorrente? Os seguidores de um concorrente são acessíveis por um endpoint de seguidores que retorna a lista pública de seguidores como perfis completos, até 200 por requisição, então uma lista de 10.000 seguidores leva cerca de 50 chamadas. Puxar vários concorrentes e guardar as contas que seguem dois ou mais produz um segmento mais afiado e interessado na categoria do que qualquer conta isolada.

Existe uma alternativa à API do X com melhores rate limits para extrações de público? Sim. A Sorsa API é uma alternativa à API do Twitter (X) feita para trabalho de leitura intensa, com um fixo de 20 requisições por segundo em todos os planos e sem janelas por endpoint. Ela cobra por requisição em vez de por recurso, então uma única chamada de seguidores retorna até 200 perfis por uma unidade de cota, e a configuração é uma única chave de API sem fila de aprovação.

Quanto custa puxar 10.000 perfis de seguidores? Na API oficial do X, 10.000 perfis de seguidores são cobrados como 10.000 leituras de recurso a US$ 0,010 cada, cerca de US$ 100. Em um modelo fixo por requisição, os mesmos 10.000 perfis levam cerca de 50 requisições a US$ 0,002 cada, uns dez centavos, porque um endpoint de seguidores retorna até 200 perfis por requisição.

Dá para encontrar um público no X sem programar? Sim. O Sorsa Playground roda os endpoints de descoberta por uma interface web: escolha um método como busca de usuários ou extração de seguidores, defina quantas páginas puxar, veja o custo da requisição antes de rodar e exporte os resultados. Ele usa os mesmos dados da API, e as primeiras 100 requisições são grátis sem cartão, então uma extração inicial de público não custa nada antes de você assinar um plano.

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

Como este guia foi preparado: os seis métodos são os que rodamos contra a camada de dados do X ao vivo enquanto construímos e operamos a API alternativa do Twitter (X) da Sorsa, e cada endpoint, parâmetro e comportamento por requisição aqui foi reconferido contra a documentação da Sorsa API durante esta revisão. A comparação de custo usa o preço por recurso da API oficial do X como publicado após a atualização de abril de 2026, cruzado com as nossas próprias taxas publicadas. Verificado em 11 de junho de 2026.