API de seguidores do Twitter para qualquer conta

#Como a API oficial do X devolve seguidores em 2026

A API oficial do X devolve seguidores por GET /2/users/{id}/followers, até 1.000 por página, e cobra cada seguidor devolvido como uma leitura de US$ 0,010 na sua tabela de pagamento por uso: US$ 10,00 por 1.000. Para dar uma olhada nos 20 seguidores mais novos de uma conta pública sem código, o Monitor de seguidores recentes do Twitter, gratuito, mostra-os no navegador.

Em resumo, a rota oficial exige um ID numérico, uma conta de desenvolvedor e OAuth, e cobra por cada seguidor devolvido; os detalhes abaixo vêm de docs.x.com, lido em 2 de novembro de 2026:

• Endpoints

  API oficial do X

  /followers e /following, ambos sob GET /2/users/{id}

• Qual conta

  API oficial do X

  Só o ID numérico do usuário, não o handle

• Acesso

  API oficial do X

  Uma conta de desenvolvedor, créditos pré-pagos e um token de usuário OAuth 2.0 com follows.read ou um bearer token de app

• Tamanho da página

  API oficial do X

  Até 1.000 (max_results); a página seguinte vem por pagination_token

• Limite de requisições

  API oficial do X

  300 requisições a cada 15 minutos, por app e por usuário

• Preço

  API oficial do X

  US$ 0,010 por seguidor lido; US$ 0,001 quando a lista é a do dono do app

Muitas respostas, entre elas os resumos de IA do Google, ainda dizem que o endpoint é só para clientes Enterprise. Essa era a regra desde 26 de junho de 2023, quando o X tirou a consulta de follows dos níveis Basic e Pro, e hoje está desatualizada: o pagamento por uso, aberto a todo novo desenvolvedor desde 6 de fevereiro de 2026, lista as leituras de seguidores na sua tabela pública de preços.

Mais duas regras moldam o trabalho. O X cobra o mesmo seguidor uma vez por dia UTC, não importa quantas vezes você o leia, e desde 20 de abril de 2026 os apps self-service não podem mais seguir nem deixar de seguir contas pela API oficial do X. O limite de requisições restringe um app a 300 páginas de até 1.000 a cada 15 minutos, o que dá 300 mil seguidores; o guia de limites de taxa da API do X cobre todos os outros endpoints.

#Obtenha seguidores com a Sorsa API em quatro passos

Para obter em código os seguidores de uma conta, use a Sorsa API, uma API e scraper do Twitter (X): GET /followers devolve até 200 perfis de seguidores por requisição a partir de US$ 0,007 por 1.000, recebe um handle em vez de um ID numérico e precisa de uma única chave de API, sem conta de desenvolvedor nem OAuth. Todos os planos rodam a 20 requisições por segundo por chave.

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

2. Peça a primeira página. Envie um username, user_id ou user_link para GET /followers (abre em uma nova aba) com a chave no header ApiKey.

   curl -G "https://api.sorsa.io/v3/followers" \
     -H "ApiKey: YOUR_API_KEY" \
     --data-urlencode "username=lumen_kitchen_labs"
   

   {
     "users": [
       {
         "id": "1718233069912377344",
         "username": "quietpine_studio_co",
         "display_name": "Quiet Pine Studio",
         "description": "Ceramics and slow coffee. Ships from Asheville.",
         "location": "Asheville, NC",
         "created_at": "2023-10-28T11:04:52Z",
         "followers_count": 3120,
         "followings_count": 418,
         "tweets_count": 1876,
         "verified": false,
         "protected": false,
         "bio_urls": ["https://quietpine.example"]
       }
     ],
     "next_cursor": "1846521730994411520"
   }
   

   Ver resposta completa

3. Envie o cursor de volta. Passe o next_cursor de cada resposta como o parâmetro next_cursor da requisição seguinte. Uma resposta em que ele vem vazio ou ausente é a última página.

4. Repita até a lista acabar. A função abaixo lê qualquer endpoint de lista até o fim e espera um segundo sempre que a chave passa de 20 requisições por segundo.

   import time
   import requests
   
   API = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   
   def get_page(path, params):
       """One GET request; on 429 it waits a second and tries again."""
       while True:
           r = requests.get(API + path, headers=HEADERS, params=params,
                            timeout=30)
           if r.status_code == 429:  # more than 20 requests in one second
               time.sleep(1)
               continue
           r.raise_for_status()
           return r.json()
   
   
   def all_users(path, username):
       """Every account in a list endpoint, one page of 200 at a time."""
       params = {"username": username}
       while True:
           page = get_page(path, params)
           yield from page.get("users", [])
           cursor = page.get("next_cursor")
           if not cursor:
               return
           params["next_cursor"] = cursor
   
   
   followers = list(all_users("/followers", "lumen_kitchen_labs"))
   print(len(followers), "followers")
   

   // followers.mjs, Node.js 18 or later
   const API = "https://api.sorsa.io/v3";
   const headers = { ApiKey: "YOUR_API_KEY" };
   const pause = (ms) => new Promise((done) => setTimeout(done, ms));
   
   async function* allUsers(path, username) {
     const query = new URLSearchParams({ username });
     for (;;) {
       const res = await fetch(`${API}${path}?${query}`, { headers });
       if (res.status === 429) {
         await pause(1000); // more than 20 requests in one second
         continue;
       }
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const page = await res.json();
       yield* page.users ?? [];
       if (!page.next_cursor) return;
       query.set("next_cursor", page.next_cursor);
     }
   }
   
   const followers = [];
   for await (const user of allUsers("/followers", "lumen_kitchen_labs")) {
     followers.push(user);
   }
   console.log(followers.length, "followers");
   

Um 403 significa que a chave está ausente ou que as requisições acabaram; uma conta protegida também devolve erro, e requisições com falha nunca são cobradas. As páginas vêm dos mais novos para os mais antigos, então a primeira página sempre traz os seguidores mais recentes, algo que a seção de acompanhamento abaixo põe para trabalhar.

#Obtenha a lista de contas que um usuário segue

Para obter a lista de contas que um usuário segue no X, chame GET /follows (abre em uma nova aba) com o mesmo handle, ID ou link de perfil: a Sorsa API devolve até 200 contas seguidas por requisição, das mais novas para as mais antigas, com o mesmo cursor, então o loop do passo 4 muda em uma palavra.

following = list(all_users("/follows", "lumen_kitchen_labs"))
following.sort(key=lambda u: u["followers_count"], reverse=True)
for user in following[:10]:  # the biggest accounts it follows
    print(user["username"], user["followers_count"])

Uma lista de seguindo costuma ser bem mais curta que uma de seguidores, então é barato lê-la inteira: uma conta que segue 1.500 outras leva 8 requisições. Ela mostra quem a conta acompanha, de fornecedores e concorrentes a criadores e fontes de notícias que ela observa. Lida ao lado da lista de seguidores, também mostra quem segue de volta: os IDs que estão nas duas. Para uma olhada rápida sem código, o Monitor de seguidores recentes acima também lista as 20 contas que ela seguiu mais recentemente.

Para salvar qualquer das listas como arquivo CSV ou Excel, o guia para exportar seguidores do Twitter cobre arquivos que abrem sem problemas.

#Qual endpoint responde a qual pergunta sobre seguidores

A Sorsa API responde a cada pergunta comum sobre seguidores com um endpoint próprio, e cobra cada um por requisição, nunca por perfil devolvido.

• Quem segue esta conta?

  Endpoint

  GET /followers

  Por requisição

  Até 200 seguidores

• Quem ela segue?

  Endpoint

  GET /follows

  Por requisição

  Até 200 contas

• Quais dos seus seguidores são verificados?

  Endpoint

  GET /verified-followers (abre em uma nova aba)

  Por requisição

  Uma página, mesmo cursor

• A conta B segue a conta A?

  Endpoint

  POST /check-follow (abre em uma nova aba)

  Por requisição

  Uma resposta: follow true ou false

• Quantos seguidores ela tem?

  Endpoint

  GET /info (abre em uma nova aba)

  Por requisição

  Um perfil com followers_count

• Número de seguidores de várias contas

  Endpoint

  GET /info-batch (abre em uma nova aba)

  Por requisição

  Até 100 perfis

• Quem está em uma Lista do X, ou a segue?

  Endpoint

  GET /list-members (abre em uma nova aba), GET /list-followers (abre em uma nova aba)

  Por requisição

  Uma página, mesmo cursor

Só os seguidores verificados

GET /verified-followers recebe a mesma entrada e o mesmo cursor que GET /followers e devolve só as contas com selo de verificado. Em uma conta grande isso pula a maior parte das páginas, porque as contas verificadas são uma pequena minoria na maioria dos públicos: você nunca lê as linhas que acabaria filtrando de qualquer jeito.

Verifique uma relação de follow

POST /check-follow responde se uma conta segue outra em uma única requisição, a partir de US$ 0,0014 por verificação, não importa o tamanho de qualquer das listas. username_1 é a conta que deveria ser seguida e username_2 a conta que você verifica; um user_id_* ou user_link_* funciona em qualquer dos lados.

curl -X POST "https://api.sorsa.io/v3/check-follow" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username_1": "lumen_kitchen_labs",
       "username_2": "quietpine_studio_co"}'

A resposta cobre um sentido só, então um follow mútuo exige duas chamadas com os lados trocados. As verificações para sorteios e campanhas, com retweets, quotes e respostas ao lado de follows, estão no guia da API de verificação do Twitter. Membros e seguidores de Listas do X têm guia próprio: a API de Listas do Twitter.

#O que cada registro de seguidor contém

Cada seguidor chega como um perfil público completo com 19 campos, o mesmo objeto que todo endpoint de perfil da Sorsa API devolve, então filtrar e pontuar não exige uma segunda requisição.

Os campos se dividem em seis grupos, e a maior parte do trabalho com público usa os quatro primeiros:

• Identidade

  Campos

  id, username, display_name, created_at

• Alcance

  Campos

  followers_count, followings_count

• Atividade

  Campos

  tweets_count, media_count, favourites_count, pinned_tweet_ids

• Tema e lugar

  Campos

  description, bio_urls, location

• Flags

  Campos

  verified, protected, can_dm, possibly_sensitive

• Imagens

  Campos

  profile_image_url, profile_background_image_url

Três regras mantêm os dados confiáveis:

• Use o ID como chave de tudo. Os IDs de conta em id nunca mudam e chegam como strings; os handles mudam sempre que o dono quiser. Se você só precisa dos IDs dos seguidores, guarde o id de cada registro: eles vêm com os perfis completos sem custo extra. Mantenha os IDs como strings também em JavaScript: os IDs do X chegam a 19 dígitos, e os números do JavaScript só são exatos até 16.
• Espere que a lista difira da contagem em alguns por cento. followers_count é o total ao vivo do X, enquanto a lista deixa de fora contas suspensas ou desativadas.
• Leia os perfis como estão hoje. Cada registro mostra a bio e as contagens atuais do seguidor, não o estado no dia em que ele seguiu.

Bom saber

GET /followers não traz a data do follow, porque a lista pública de seguidores do X não mostra quando um follow aconteceu. Para datar novos seguidores, verifique em intervalos e registre o dia em que cada ID aparece pela primeira vez; a próxima seção mostra como.

#Acompanhe novos seguidores e quem deixou de seguir

Para acompanhar novos seguidores por API, guarde os IDs de seguidores que você viu da última vez e compare: como as páginas vêm dos mais novos para os mais antigos, uma verificação lê só até encontrar um ID que já conhece, então custa uma requisição sempre que chegaram menos de 200 seguidores desde a anterior.

Descobrir quem deixou de seguir exige a lista inteira: um ID presente na leitura completa da semana passada e ausente na de hoje saiu. Rode a verificação barata diariamente ou a cada hora, e a leitura completa semanalmente ou mensalmente. As duas funções reutilizam get_page e all_users do passo 4.

def new_followers(username, known):
    """Followers added since the last check. Pages come newest first,
    so the loop stops at the first page that holds a known ID."""
    params, found = {"username": username}, []
    while True:
        page = get_page("/followers", params)
        users = page.get("users", [])
        fresh = [u for u in users if u["id"] not in known]
        found += fresh
        cursor = page.get("next_cursor")
        if len(fresh) < len(users) or not cursor:
            return found
        params["next_cursor"] = cursor


def unfollowed(username, last_full_read):
    """IDs from the last full read that no longer follow."""
    now = {u["id"] for u in all_users("/followers", username)}
    return last_full_read - now, now

Antes de contar um ID como alguém que deixou de seguir, consulte-o com GET /info-batch: uma conta suspensa ou excluída também sai de todas as listas de seguidores. As verificações rodam na sua agenda, e o custo continua pequeno: 25 contas de 50 mil seguidores cada, verificadas diariamente e lidas por inteiro uma vez por mês, levam cerca de 7.000 requisições por mês.

#Filtre seguidores e encontre a sobreposição de público

Cada registro de seguidor já traz suas contagens, bio e flags, então filtrar uma lista são algumas linhas de código e nenhuma requisição extra. O location dele é o que o usuário digitou; para o país que o próprio X atribui, o guia da API de localização do Twitter mapeia um público por país com GET /about.

followers = list(all_users("/followers", "lumen_kitchen_labs"))
shortlist = [
    u for u in followers
    if u["followers_count"] >= 1000          # some reach
    and u["tweets_count"] >= 100             # posts regularly
    and not u["protected"]
    and "coffee" in (u.get("description") or "").lower()
]

As contas que seguem dois ou mais dos seus concorrentes são as pessoas mais engajadas do seu mercado. Leia a lista de cada concorrente uma vez e conte quantas vezes cada ID aparece:

from collections import Counter

rivals = ["lumen_kitchen_labs", "copperleaf_cookware", "saltmarsh_pantry"]
lists = {h: {u["id"] for u in all_users("/followers", h)} for h in rivals}
seen = Counter(i for ids in lists.values() for i in ids)
core = {i for i, n in seen.items() if n >= 2}
smallest = min(len(ids) for ids in lists.values())
print(f"{len(core)} accounts follow 2+ rivals, "
      f"{len(core) / smallest:.1%} of the smallest audience")

Meça a sobreposição contra o menor público, não contra o total: uma fatia compartilhada de 2.000 significa muito para uma conta de 5 mil e pouco para uma de 2 milhões. Para comparar duas contas sem código, o Verificador de sobreposição de público do Twitter, gratuito, faz isso no navegador, e transformar essas contas centrais em prospects é o assunto de como encontrar leads no Twitter.

#Encontre e avalie influenciadores do Twitter pela API

Para encontrar e avaliar influenciadores do Twitter por API, procure criadores por palavras-chave da bio e por temas, enriqueça os perfis em lotes e depois pontue cada um pelo engajamento recente e pela qualidade do público. A Sorsa API cobre todas as etapas somente em leitura, a partir de métricas públicas: curtidas, respostas, reposts, quotes e visualizações.

Descubra criadores por nicho

• Por bio e nome: POST /search-users (abre em uma nova aba) encontra contas por palavra-chave, bios incluídas, cerca de 20 por página; filtre por faixa de seguidores, status de verificação, localização e número de posts.
• Pelos temas que movimentam: POST /search-tweets (abre em uma nova aba) roda os operadores de busca do X, e os autores dos posts mais fortes sobre um tema são as vozes ativas dele.
• De listas curadas: GET /list-members lê Listas do X que alguém já montou para um nicho, e GET /info-batch enriquece qualquer lista de candidatos de 100 em 100 perfis.

Avalie pelo engajamento real

A taxa de engajamento são as interações dos posts recentes (curtidas, respostas, reposts e quotes) por post, divididas pelos seguidores ou pelas visualizações. POST /user-tweets (abre em uma nova aba) devolve cerca de 20 posts recentes por requisição com todas as contagens, e POST /tweet-info-bulk (abre em uma nova aba) lê até 100 posts escolhidos de uma vez. Não há nota de caixa-preta: as entradas são as contagens públicas do X, e a fórmula é sua para ajustar.

def engagement_rate(username):
    """Interactions per post, per follower and per view."""
    # the latest page of posts; API and HEADERS come from step 4
    r = requests.post(API + "/user-tweets", headers=HEADERS,
                      json={"username": username}, timeout=30)
    r.raise_for_status()
    posts = r.json().get("tweets", [])
    if not posts:
        return None
    acts = sum(p["likes_count"] + p["reply_count"] + p["retweet_count"]
               + p["quote_count"] for p in posts)
    views = sum(p.get("view_count") or 0 for p in posts)
    followers = max(posts[0]["user"]["followers_count"], 1)
    return {"by_followers": acts / len(posts) / followers,
            "by_views": acts / views if views else None}

Para uma verificação rápida de uma conta sem código, a Calculadora de taxa de engajamento do Twitter, gratuita, faz a mesma conta.

Flagre seguidores falsos e engajamento comprado

Leia uma ou duas páginas dos seguidores mais novos de um criador e procure os sinais que raramente aparecem juntos por acaso:

• engajamento muito abaixo do que o número de seguidores sugere;
• uma amostra de seguidores cheia de contas criadas no mês passado, com bios vazias, o avatar padrão ou nenhum post;
• contas desequilibradas, que seguem milhares e são seguidas por poucos;
• posts recentes com muitas visualizações, mas quase nenhuma curtida ou resposta.

O método completo, com dez sinais e um script que pontua uma lista inteira de seguidores, está no guia de detecção de bots no Twitter.

Confira a campanha depois do acordo

POST /user-tweets acompanha os posts do criador, POST /mentions (abre em uma nova aba) encontra posts que mencionam sua marca com min_likes e um intervalo de since_date a until_date, e POST /check-quoted (abre em uma nova aba) e GET /check-comment (abre em uma nova aba) confirmam que um quote ou uma resposta exigidos foram ao ar, a partir de US$ 0,0014 por verificação.

A execução inteira sobre 500 criadores leva cerca de 540 requisições: 25 páginas de busca, 5 chamadas em lote, 500 leituras de timeline e 10 páginas de seguidores. Isso dá cerca de US$ 0,76 na tarifa mais baixa da Sorsa API e uma fatia pequena das 10 mil requisições do menor plano; as mesmas leituras nas tarifas da API oficial do X custam cerca de US$ 75.

#Quanto custam os dados de seguidores por 1.000 seguidores

A Sorsa API lê seguidores a partir de US$ 0,007 por 1.000, contra US$ 10,00 por 1.000 na API oficial do X: 1.000x menos pela mesma lista pública.

Com essas tarifas, 100 mil seguidores custam a partir de US$ 0,70 contra US$ 1.000, e 1 milhão custa a partir de US$ 7 contra US$ 10.000. Até a tarifa de US$ 0,001 do X para os seguidores do seu próprio app dá US$ 1,00 por 1.000. A Sorsa API cobra por requisição, não por perfil: uma página de 200 seguidores é uma requisição, requisições com falha não custam nada, e consultar o seu saldo com GET /key-usage-info (abre em uma nova aba) é grátis. Todos os preços oficiais estão detalhados no guia de preços da API do X.

Trabalhos recorrentes custam o que suas leituras somam em um mês. O planejador abaixo transforma as contas que você acompanha e a frequência das verificações em requisições e dinheiro nas duas APIs.

#Obtenha seus primeiros 20 mil seguidores hoje

Para seguidores, listas de seguindo e verificações de follow em código, use a Sorsa API: 200 seguidores por requisição, a partir de US$ 0,007 por 1.000, uma chave de API e nenhuma conta de desenvolvedor. Suas 100 requisições grátis leem os primeiros 20 mil seguidores; rode o loop do passo 4 contra qualquer conta pública e veja a lista inteira voltar.

#Perguntas frequentes