API do Twitter em Python: guia completo para obter dados do X em 2026

Por Sorsa Editorial

Atualizado em julho de 2026: reverificamos o preço de pagamento por uso do X, reapresentamos os números de custo da Sorsa nas taxas de lote por 1.000 itens e adicionamos a oferta inicial de 100 requisições grátis.

Em resumo: Há quatro formas práticas de obter dados do Twitter (X) com Python em 2026: o SDK oficial do X (pip install xdk), o Tweepy, o requests puro com um bearer token, ou uma API REST de terceiros. As rotas oficiais cobram por recurso e exigem OAuth; uma API de terceiros somente leitura precisa apenas de uma chave de API e serve para trabalho de leitura intensa.

Se você pesquisou "twitter api python" esperando um pip install rápido e um trecho funcional, o cenário atual é mais bagunçado do que os tutoriais antigos sugerem. A API do X (antigo Twitter) mudou o modelo de preços, mudou a autenticação e agora publica um SDK Python oficial que não existia um ano atrás.

Nós construímos e operamos a Sorsa API, uma API alternativa do Twitter (X), então o caminho somente leitura é o que conhecemos melhor: ela retorna perfis, tweets, busca e seguidores como JSON limpo a partir de requests puro, com uma chave de API no cabeçalho, sem fluxo OAuth e sem aprovação de conta de desenvolvedor para esperar. Em trabalho de leitura intensa, a Sorsa sai até 50x mais barata que a API oficial do X: os endpoints em lote trazem o custo para a partir de US$ 0,02 por 1.000 tweets e de US$ 0,01 por 1.000 perfis, todo plano mantém um fixo de 20 requisições por segundo, e toda conta nova começa com 100 requisições grátis, sem cartão. Nem todo projeto encaixa nesse formato: alguns precisam postar, alguns precisam da API oficial para conformidade, e alguns desenvolvedores só querem entender como tudo funciona. Este guia cobre os quatro métodos com código Python funcional, uma comparação lado a lado, preço atual e um coletor de dados completo que pagina e carrega os resultados direto no pandas. Você também pode testar chamadas sem escrever código no playground da Sorsa API.

Índice

• O que mudou: a API do X em 2026
• Melhor biblioteca de Python para a API do X v2 (resposta rápida)
• Qual abordagem usar?
• Método 1: SDK Python oficial do X (XDK)
• Método 2: Tweepy
• Método 3: requests puro em Python com um bearer token
• Método 4: API de terceiros com requests em Python
• Construindo um coletor de dados de produção: paginação, retentativas e pandas
• Comparação: os quatro métodos lado a lado
• Como obter suas credenciais de API
• Tarefas comuns: exemplos de código
• Na prática: movendo extrações somente leitura da API oficial
• Perguntas frequentes
• Primeiros passos

O que mudou: a API do X em 2026

Se a última vez que você tocou na API do Twitter foi em 2023 ou antes, veja o que está diferente.

O pagamento por uso é o padrão. No início de 2026, o X substituiu seus antigos níveis de assinatura por um modelo de consumo. Não há plano Basic de US$ 100 nem Pro de US$ 5.000 para novos cadastros, e não há plano gratuito. Você compra créditos adiantado e paga por recurso que lê: US$ 0,005 por post, US$ 0,010 por perfil de usuário e US$ 0,010 por registro de seguidor ou de seguindo (valores verificados em julho de 2026). Ler os dados da sua própria conta (a sua timeline, os seus itens salvos, os seus seguidores) é mais barato, a US$ 0,001 por recurso, mas essa taxa com desconto não vale quando você lê outras contas.

Escrever ficou mais caro após a atualização de abril de 2026. Um post padrão agora custa US$ 0,015 por requisição, e um post com uma URL salta para US$ 0,20. As ações de follow, curtida e quote-post foram totalmente retiradas dos níveis self-service e agora exigem um contrato Enterprise. Se você planejava um bot de seguir de volta ou um auto-curtidor, isso não é mais possível em uma conta padrão de pagamento por uso.

Há um teto rígido de leitura. Contas padrão são limitadas a 2 milhões de leituras de posts por mês. O X também devolve uma parte do seu gasto como créditos de API da xAI (Grok), até 20% em volumes maiores. Para um detalhamento completo do que isso significa para um orçamento real, veja nossa análise de preços da API do X e o texto sobre por que a API do Twitter é tão cara.

O X lançou um SDK Python oficial. O XDK (X Developer Kit) é um SDK autogerado com type hints, paginação automática e suporte a streaming. Instale-o com pip install xdk. É a primeira biblioteca Python oficial que o X já publicou.

O Tweepy ainda funciona. Ele suporta a X API v2 e continua a biblioteca de comunidade mais madura. Código Tweepy existente roda bem com as credenciais atuais.

As bibliotecas antigas estão mortas. O pacote original python-twitter, do bear, está arquivado, e o pacote twitter no PyPI não recebe atualização há anos. Se um tutorial mandar você fazer pip install python-twitter, esse tutorial está desatualizado. (Um wrapper v2 separado e ativamente mantido, publicado pela sns-sdks, está coberto na próxima seção.)

Melhor biblioteca de Python para a API do X v2 (resposta rápida)

Se você só quer a versão curta: o Tweepy é a melhor biblioteca de Python de uso geral para a X API v2, porque é madura, bem documentada e suporta leitura e escrita por fluxos de bearer token e OAuth. Se você quer uma ferramenta de primeira parte que segue a especificação da API exatamente, use o XDK oficial. Para coleta de dados somente leitura, muitos desenvolvedores pulam bibliotecas por completo e chamam uma API REST de terceiros com requests puro (veja o Método 4).

Veja como as principais opções se comparam.

Toda biblioteca de API oficial acima cobra pelo preço de pagamento por uso do X. O custo é idêntico chame você o X com o XDK, o Tweepy ou requests cru, porque a cobrança por recurso vem do X, não da biblioteca. A variável que você de fato controla é quantos recursos puxa, que é onde uma API de terceiros e os endpoints em lote mudam a conta (coberto abaixo).

Qual abordagem usar?

Escolha o caminho antes de escrever código. Isso economiza horas.

Se o seu projeto só lê dados públicos (perfis, tweets, resultados de busca, seguidores), uma API de terceiros remove a dança do OAuth: uma chave de API em um cabeçalho e você começa a puxar dados, sem candidatura de conta de desenvolvedor e sem compra de crédito. Se você precisa postar ou executar ações de escrita, use a API oficial do X pelo XDK, pelo Tweepy ou por requests cru. A Sorsa é somente leitura e não posta em seu nome.

Método 1: SDK Python oficial do X (XDK)

O XDK é o primeiro SDK Python oficial do X. Ele embrulha toda a API v2 com modelos tipados, trata a paginação automaticamente e suporta os três métodos de autenticação (bearer token, OAuth 2.0 PKCE, OAuth 1.0a).

Instale-o:

pip install xdk

Buscar tweets recentes

import os
from xdk import Client

client = Client(bearer_token=os.environ["BEARER_TOKEN"])

response = client.posts.recent_search(query="python lang:en")

for post in response.data:
    print(f"@{post.author_id}: {post.text[:120]}")

Isso retorna posts que batem com a sua consulta dos últimos 7 dias. O objeto response inclui tokens de paginação, então você pode percorrer páginas sem rastrear cursores à mão.

Consultar um perfil de usuário

user = client.users.find_by_username(username="elonmusk")
print(f"@{user.data.username} - {user.data.public_metrics}")

Postar um tweet (exige OAuth 2.0)

Operações de escrita precisam de autenticação em contexto de usuário. Defina o seu Client ID e Client Secret como variáveis de ambiente, e então:

client = Client(
    client_id=os.environ["CLIENT_ID"],
    client_secret=os.environ["CLIENT_SECRET"],
)

client.posts.create(post_data={"text": "Hello from the XDK!"})

O XDK trata o fluxo OAuth 2.0 PKCE internamente, incluindo o refresh de token.

Quando usar o XDK

O XDK é a escolha certa se você quer suporte oficial, precisa de acesso de escrita e está começando um projeto novo. Os modelos tipados fazem o autocomplete da IDE funcionar bem, e a paginação automática economiza boilerplate. As desvantagens: o SDK é novo (lançado no início de 2026, com um seguimento pequeno mas crescente no GitHub), a documentação ainda é rala, e você paga o preço de pagamento por uso do X em cada requisição, então uma leitura de post custa US$ 0,005 e uma consulta de usuário custa US$ 0,010, e essas cobranças se acumulam em escala. A documentação completa do SDK está em docs.x.com/xdks/python/overview.

Método 2: Tweepy

O Tweepy existe desde 2009 e continua a biblioteca Python mais popular para a API do Twitter. Ele suporta a X API v2, trata o rate limit e tem documentação de comunidade extensa.

Instale-o:

pip install tweepy

Buscar tweets recentes

import os
import tweepy

client = tweepy.Client(bearer_token=os.environ["BEARER_TOKEN"])

response = client.search_recent_tweets(
    query="python lang:en",
    max_results=10,
    tweet_fields=["created_at", "public_metrics"],
)

for tweet in response.data:
    metrics = tweet.public_metrics
    print(tweet.text[:120])
    print(f"  Likes: {metrics['like_count']}  Retweets: {metrics['retweet_count']}")

Obter os seguidores de um usuário

user = client.get_user(username="elonmusk")
followers = client.get_users_followers(
    id=user.data.id,
    max_results=100,
    user_fields=["description", "public_metrics"],
)

for follower in followers.data:
    print(f"@{follower.username} - {follower.public_metrics['followers_count']} followers")

Postar um tweet

client = tweepy.Client(
    consumer_key=os.environ["API_KEY"],
    consumer_secret=os.environ["API_SECRET"],
    access_token=os.environ["ACCESS_TOKEN"],
    access_token_secret=os.environ["ACCESS_TOKEN_SECRET"],
)

client.create_tweet(text="Hello from Tweepy!")

Quando usar o Tweepy

O Tweepy é o padrão seguro para a maioria dos desenvolvedores de Python. É testado em batalha, a comunidade é grande, e há uma resposta no Stack Overflow para quase qualquer problema. Ele embrulha o tratamento de rate limit, as retentativas e a paginação em uma interface limpa. As trocas batem com as do XDK: você ainda precisa de uma conta de desenvolvedor do X, ainda paga por recurso, e os rate limits são herdados da API oficial (tipicamente 300 requisições por janela de 15 minutos para busca, embora isso varie por endpoint). Se você já tem código Tweepy rodando, não há razão para migrar para o XDK a menos que precise de um recurso que falte no Tweepy. Documentação completa: docs.tweepy.org.

Método 3: requests puro em Python com um bearer token

Sem bibliotecas, sem wrappers, só requisições HTTP. Essa abordagem serve para desenvolvedores que querem controle total sobre o que é enviado e recebido, ou que trabalham em ambientes onde instalar pacotes de terceiros é restrito.

Buscar tweets recentes

import os
import requests

search_url = "https://api.x.com/2/tweets/search/recent"
headers = {"Authorization": f"Bearer {os.environ['BEARER_TOKEN']}"}
params = {
    "query": "python lang:en",
    "max_results": 10,
    "tweet.fields": "created_at,public_metrics,author_id",
}

response = requests.get(search_url, headers=headers, params=params)
data = response.json()

for tweet in data["data"]:
    print(tweet["text"][:120])
    print(f"  Likes: {tweet['public_metrics']['like_count']}")

Obter um perfil de usuário

user_url = "https://api.x.com/2/users/by/username/elonmusk"
headers = {"Authorization": f"Bearer {os.environ['BEARER_TOKEN']}"}
params = {"user.fields": "description,public_metrics,created_at"}

response = requests.get(user_url, headers=headers, params=params)
user = response.json()["data"]

print(f"@{user['username']} - {user['public_metrics']['followers_count']} followers")

Tratando a paginação manualmente

search_url = "https://api.x.com/2/tweets/search/recent"
next_token = None
all_tweets = []

while True:
    params = {
        "query": "python lang:en",
        "max_results": 100,
        "tweet.fields": "created_at,public_metrics",
    }
    if next_token:
        params["next_token"] = next_token

    response = requests.get(search_url, headers=headers, params=params)
    data = response.json()
    all_tweets.extend(data.get("data", []))

    next_token = data.get("meta", {}).get("next_token")
    if not next_token:
        break

print(f"Collected {len(all_tweets)} tweets")

Quando usar requests cru

Isso funciona quando você quer zero dependências além do requests, quando está depurando o comportamento da API, ou quando chama só um ou dois endpoints e um SDK completo é exagero. A desvantagem é óbvia: você trata paginação, códigos de erro, rate limit e lógica de retentativa por conta própria. Para um script pontual, tudo bem. Para um pipeline de produção, você acaba escrevendo o seu próprio wrapper, ponto em que você reinventou o Tweepy. Esse método ainda exige uma conta de desenvolvedor do X e créditos de pagamento por uso, e o cabeçalho usa um bearer token para acesso somente leitura.

Método 4: API de terceiros com requests em Python

Se o seu projeto só precisa ler dados públicos do Twitter, pule a API oficial por completo e chame um provedor de dados de terceiros. Essa é a rota prática para dados do Twitter sem uma conta de desenvolvedor: sem OAuth, sem etapa de candidatura, sem fluxo de compra de crédito, só uma chave de API em um cabeçalho, chamadas REST padrão, respostas JSON e 100 requisições grátis para testar antes de pagar qualquer coisa. Veja como fica com a API da Sorsa.

Obter um perfil de usuário

import requests

headers = {"ApiKey": "YOUR_SORSA_API_KEY"}

response = requests.get(
    "https://api.sorsa.io/v3/info",
    headers=headers,
    params={"username": "elonmusk"},
)

user = response.json()
print(f"@{user['username']}: {user['display_name']}")
print(f"Followers: {user['followers_count']}")
print(f"Tweets: {user['tweets_count']}")

A resposta inclui o perfil completo em uma requisição: ID, nome de usuário, nome de exibição, bio, localização, contadores de seguidores e de seguindo, contadores de tweets e de mídia, status de verificação, imagens de perfil, data de criação da conta, tweets fixados e URLs da bio.

Buscar tweets

response = requests.post(
    "https://api.sorsa.io/v3/search-tweets",
    headers=headers,
    json={"query": "python programming", "order": "popular"},
)

for tweet in response.json()["tweets"]:
    print(f"@{tweet['user']['username']}: {tweet['full_text'][:120]}")
    print(f"  Likes: {tweet['likes_count']}  Views: {tweet['view_count']}")

Cada requisição de busca retorna até 20 tweets, e todo tweet inclui o perfil completo do autor no campo user. Não há requisição extra (nem cobrança extra) para obter o contador de seguidores ou o status de verificação de quem postou, diferente da API oficial, em que expandir os dados de usuário adiciona US$ 0,010 por usuário. O endpoint de busca suporta os mesmos operadores avançados que você digitaria na busca do X (from:, to:, since:, until:, frases entre aspas, hashtags). A lista completa está na nossa referência de operadores de busca do Twitter.

Obter seguidores

response = requests.get(
    "https://api.sorsa.io/v3/followers",
    headers=headers,
    params={"username": "elonmusk"},
)

for follower in response.json()["users"][:5]:
    print(f"@{follower['username']} - {follower['followers_count']} followers")

O endpoint /followers retorna até 200 perfis completos por requisição, com paginação por um parâmetro next_cursor.

Buscar múltiplos tweets em lote

response = requests.post(
    "https://api.sorsa.io/v3/tweet-info-bulk",
    headers=headers,
    json={
        "tweet_links": [
            "https://x.com/elonmusk/status/1234567890",
            "https://x.com/OpenAI/status/9876543210",
            "1122334455667788",
        ]
    },
)

for tweet in response.json()["tweets"]:
    print(f"@{tweet['user']['username']}: {tweet['full_text'][:100]}")

O endpoint /tweet-info-bulk aceita até 100 URLs ou IDs de tweets em uma única requisição e retorna objetos completos de tweet com dados de autor. Uma chamada, 100 tweets.

Por que essa abordagem funciona para projetos somente leitura

Os Métodos 1 a 3 exigem uma conta de desenvolvedor do X (com uma etapa de candidatura), créditos comprados, tokens OAuth e cobrança por recurso. O Método 4 precisa de uma chave de API em um cabeçalho. A Sorsa usa preço fixo por requisição: uma chamada é uma requisição da sua cota, não importa quantos tweets ou perfis ela retorne, então uma busca que retorna 20 tweets custa o mesmo que uma consulta de um ID. No plano Pro da Sorsa (US$ 199 por mês por 100.000 requisições) isso dá US$ 0,00199 por requisição. Roteado pelos endpoints em lote, isso é a partir de US$ 0,02 por 1.000 tweets pelo /tweet-info-bulk e de US$ 0,01 por 1.000 perfis pelo /followers, e o rate limit é 20 requisições por segundo em todos os planos, sem janelas de 15 minutos.

A troca é que não há acesso de escrita: você não pode postar, curtir ou seguir por uma API de terceiros somente leitura. Se você precisa disso, use os Métodos 1 ou 2 para as escritas e uma API de terceiros para o trabalho de leitura intensa. Esse híbrido é exatamente o que configuramos para um cliente de fintech rodando um pipeline de sentimento: eles vinham pagando US$ 5.000 por mês em um plano Pro legado, movemos todas as leituras (rastreamento de menções, monitoramento de concorrentes, análise de seguidores) para um provedor de terceiros e mantivemos uma configuração oficial mínima para postar alertas, e o gasto total deles caiu para menos de US$ 250 por mês. Se você está vindo da API oficial, nosso guia de migração da API do X mapeia endpoints e nomes de campo.

Construindo um coletor de dados de produção: paginação, retentativas e pandas

Os exemplos de chamada única acima bastam para testar a sua chave, mas o trabalho real com dados precisa de três coisas a mais: paginação para passar dos primeiros 20 resultados, tratamento de erros para uma resposta ruim não matar uma execução longa, e uma forma de transformar o JSON em algo que você possa analisar. Aqui vai um coletor completo e executável que faz as três coisas contra a Sorsa, depois carrega os resultados em um DataFrame do pandas e os salva em CSV.

import os
import time
import requests
import pandas as pd

API_KEY = os.environ["SORSA_API_KEY"]   # read the key from the environment, never hard-code it
BASE = "https://api.sorsa.io/v3"
HEADERS = {"ApiKey": API_KEY}


def post_with_retry(path, payload, retries=3):
    """POST to Sorsa with exponential backoff on transient errors and 429 responses."""
    for attempt in range(retries):
        try:
            response = requests.post(f"{BASE}{path}", headers=HEADERS, json=payload, timeout=30)
            response.raise_for_status()
            return response.json()
        except requests.HTTPError as error:
            status = error.response.status_code
            if status == 429 and attempt < retries - 1:   # rate limited: wait and retry
                time.sleep(2 ** attempt)
                continue
            raise   # 401 (bad key), 400 (bad params), and the final 429 surface here
        except requests.RequestException:
            if attempt == retries - 1:
                raise
            time.sleep(2 ** attempt)


def collect_tweets(query, order="latest", max_pages=5):
    """Collect tweets for a query, following next_cursor pagination up to max_pages."""
    cursor, rows = None, []
    for page in range(max_pages):
        payload = {"query": query, "order": order}
        if cursor:
            payload["next_cursor"] = cursor
        data = post_with_retry("/search-tweets", payload)
        batch = data.get("tweets", [])
        rows.extend(batch)
        print(f"page {page + 1}: +{len(batch)} tweets (total {len(rows)})")
        cursor = data.get("next_cursor")
        if not cursor:        # no cursor means there are no more pages
            break
    return rows


if __name__ == "__main__":
    tweets = collect_tweets('"machine learning" lang:en', max_pages=3)
    df = pd.json_normalize(tweets)
    df.to_csv("tweets.csv", index=False)
    print(f"Saved {len(df)} rows to tweets.csv")

Algumas coisas que valem destacar:

• A paginação usa o next_cursor. Cada resposta de /search-tweets retorna até 20 tweets mais um next_cursor. Passe esse cursor de volta no corpo da requisição seguinte e repita até ele ficar vazio. A trava max_pages impede que uma consulta ampla desgoverne e queime a sua cota. A documentação da Sorsa cobre o fluxo de cursor em detalhe.
• Retentativas e backoff. O raise_for_status() transforma respostas falhas em exceções. Um 429 (você excedeu o limite de 20 requisições por segundo) dispara um backoff exponencial curto e uma retentativa. Um 401 significa chave ruim e aparece na hora, para você notar em vez de coletar nada em silêncio.
• A chave vive em uma variável de ambiente. Defina-a uma vez com export SORSA_API_KEY='your_key' e leia-a com os.environ. Nunca faça commit da chave no controle de versão.

Carregando os dados no pandas

O pandas.json_normalize achata os objetos de tweet aninhados (incluindo o autor embutido em user.*) em uma tabela plana em uma linha:

df = pd.json_normalize(tweets)

# Keep the columns most analyses need
columns = [
    "id", "full_text", "created_at", "lang",
    "likes_count", "retweet_count", "reply_count", "view_count",
    "user.username", "user.followers_count", "user.verified",
]
df = df[columns]

# Example: engagement rate per tweet
df["engagement_rate"] = (
    df["likes_count"] + df["retweet_count"] + df["reply_count"]
) / df["view_count"].clip(lower=1)

df.to_csv("tweets.csv", index=False)      # portable, opens in Excel or Sheets
df.to_parquet("tweets.parquet")           # compact, fast to reload for repeated analysis

A partir daqui você pode agrupar por autor, calcular taxas de engajamento, rodar classificação de sentimento (veja nosso guia de análise de sentimento no Twitter) ou montar um dataset de treinamento para um modelo. Como cada tweet já inclui o perfil completo do autor, você não precisa de uma segunda chamada por autor para obter contadores de seguidores ou status de verificação, que é a principal razão de esse padrão continuar barato em escala.

Comparação: os quatro métodos lado a lado

Como obter suas credenciais de API

Conta de desenvolvedor do X (Métodos 1 a 3)

1. Acesse developer.x.com, entre com a sua conta do X e crie um Project e um App dentro dele.
2. Para acesso somente leitura, copie o seu Bearer Token. Esse único token basta para busca, consultas de usuário e timelines.
3. Para postagem e outras ações de escrita, abra User Authentication Settings e defina as permissões como Read and Write, depois gere as quatro credenciais OAuth 1.0a: API Key (Consumer Key), API Key Secret (Consumer Secret), Access Token e Access Token Secret. As quatro são obrigatórias para postar.
4. Compre créditos no Developer Console. O pagamento por uso não tem gasto mínimo, mas o seu saldo precisa estar acima de zero antes de qualquer chamada autenticada dar certo.

Guarde as credenciais em variáveis de ambiente, nunca no código:

export BEARER_TOKEN='AAAAAAAAAAAAAAAAAAAAAxxxxxxx'
export API_KEY='your_api_key'
export API_SECRET='your_api_secret'
export ACCESS_TOKEN='your_access_token'
export ACCESS_TOKEN_SECRET='your_access_token_secret'

Para um passo a passo do portal captura por captura, incluindo onde achar o bearer token e como trocar as permissões para Read and Write, veja nosso guia de como obter uma chave de API do Twitter (X). Para o que cada credencial custa por requisição, veja a seção O que mudou acima.

Chave de API da Sorsa (Método 4)

1. Crie uma conta em api.sorsa.io/overview.
2. A sua chave de API é gerada na hora na página de chaves do painel.
3. Comece a fazer requisições. Toda conta nova inclui 100 requisições grátis: uma única vez, sem cartão, elas nunca expiram e cobrem todos os 40 endpoints. Sem processo de candidatura, sem compra de crédito para começar.

O início rápido na documentação da Sorsa percorre a sua primeira chamada em menos de um minuto, incluindo o formato do cabeçalho ApiKey.

Tarefas comuns: exemplos de código

Como buscar tweets por palavra-chave

Os quatro métodos suportam busca por palavra-chave. Os Métodos 1 a 3 usam o endpoint de busca recente da X API v2 (últimos 7 dias, ou o arquivo completo no Pro legado). O Método 4 busca no arquivo público completo. Para montar consultas complexas, combine operadores: "machine learning" from:OpenAI since:2026-01-01 -is:retweet retorna posts originais de @OpenAI mencionando a frase desde janeiro de 2026. Para um construtor visual, use o construtor de buscas dentro do playground da Sorsa; a referência completa de operadores está no guia de operadores de busca linkado acima.

Como obter tweets históricos

O endpoint de busca recente na API oficial só cobre os últimos 7 dias, a menos que você tenha acesso legado ao arquivo completo. Uma API de terceiros busca no arquivo completo diretamente, e os operadores de data (since:, until:) permitem paginar para trás por posts mais antigos. Para grandes extrações históricas e as trocas envolvidas, veja nosso guia de dados históricos do Twitter.

Como obter os seguidores de um usuário

Na API oficial, as listas de seguidores são paginadas a 100 usuários por página e cada perfil é um recurso cobrável de US$ 0,010, então 1.000 seguidores custam cerca de US$ 10 em leituras de usuário. Pela Sorsa, o /followers retorna até 200 perfis por requisição, então 1.000 seguidores são 5 requisições, cerca de US$ 0,01 no plano Pro. Mais detalhe está no nosso guia da API de seguidores do Twitter.

Como buscar dados de tweet por ID

Quando você tem uma lista de IDs de tweets, as consultas em lote são o caminho eficiente. Na API oficial, o GET /2/tweets?ids=... aceita até 100 IDs e cobra US$ 0,005 por tweet retornado. Com a Sorsa, o POST /tweet-info-bulk aceita até 100 URLs ou IDs e conta como uma requisição, retornando objetos completos de tweet com dados de autor.

Na prática: movendo extrações somente leitura da API oficial

Um padrão que vemos com frequência: uma equipe começa na API oficial do X com o Tweepy porque é o que os tutoriais antigos mostram, e depois esbarra em atrito em um projeto que só lê dados. Uma equipe de análise chegou até nós depois de montar um coletor diário que puxava perfis e tweets recentes de alguns milhares de contas acompanhadas. O código funcionava, mas cada execução queimava leituras cobráveis de posts e de usuário, a aprovação de conta de desenvolvedor e a lógica de refresh de OAuth adicionavam tempo de configuração, e o teto mensal de 2 milhões de leituras fazia com que vigiassem o volume de perto conforme a lista de contas crescia.

A correção não foi uma reescrita, só uma troca na camada de transporte. A lógica de coleta, a normalização com pandas e o agendamento ficaram todos iguais. Eles substituíram o cliente Tweepy pelo padrão de requests puro do Método 4, apontaram-no para os endpoints de busca e /followers, e abandonaram o fluxo OAuth por completo (um cabeçalho ApiKey em vez de gestão de token). Como cada requisição retorna até 20 tweets ou 200 perfis de seguidores em vez de cobrar por recurso, a mesma extração diária custou uma fração do que custava, e um limite por segundo substituiu o teto mensal como a única coisa a acompanhar. Para uma carga somente leitura, a API oficial tinha sido a forma cara de fazer um trabalho simples.

Perguntas frequentes

Existe uma API do Twitter gratuita para Python em 2026?

Não pelo X. A API oficial do X não tem acesso gratuito no pagamento por uso: você precisa comprar créditos antes de qualquer requisição, e contas novas não ganham créditos grátis. A Sorsa dá a toda conta nova 100 requisições grátis: uma única vez, sem cartão, elas nunca expiram e cobrem todos os 40 endpoints, o bastante para até 10.000 tweets ou 20.000 perfis pelos endpoints em lote. Para um detalhamento completo, veja nossa análise de se a API do Twitter é gratuita em 2026.

Qual é a forma mais fácil de obter dados do Twitter em Python?

Chame uma API REST de terceiros com a biblioteca requests: pegue uma chave de API, passe-a em um cabeçalho e faça um POST da sua consulta em um endpoint de busca. O JSON mapeia direto para dicts de Python e para o pandas. É mais simples que a API oficial mais o Tweepy porque não há fluxo OAuth nem aprovação de conta de desenvolvedor para esperar.

Como carregar tweets em um DataFrame do pandas em Python?

Colete os objetos de tweet em uma lista e então chame pandas.json_normalize(tweets) para achatar os campos aninhados (incluindo o autor embutido) em um DataFrame em uma linha. Salve com df.to_csv("tweets.csv", index=False) para um arquivo portátil, ou df.to_parquet(...) para um arquivo colunar compacto que você recarrega rápido. A partir daí você pode filtrar, agrupar e calcular métricas de engajamento com pandas normal.

Como paginar por tweets em Python?

Cada resposta inclui um next_cursor (ou next_token na API oficial). Passe-o de volta na requisição seguinte e repita até ficar vazio. Sempre limite o loop com uma trava max_pages para uma consulta ampla não desgovernar e consumir a sua cota. O script do coletor acima mostra o padrão.

Dá para obter dados do Twitter com Python sem uma chave de API?

Tecnicamente sim, por web scraping com bibliotecas como Twikit ou Playwright, mas os scrapers quebram a cada 2 a 4 semanas quando o X gira tokens internos e identificadores GraphQL, e você arrisca banimentos de conta. Para acesso confiável, uma chave de API (do X ou de um provedor de terceiros) é o caminho prático. Veja nosso guia de scraping do X para a abordagem técnica ou nossa comparação de scrapers de Twitter para as opções gerenciadas.

Quanto o acesso à API do Twitter custa para desenvolvedores de Python?

Na API oficial do X: US$ 0,005 por post lido, US$ 0,010 por perfil de usuário lido, US$ 0,015 por post padrão criado e US$ 0,20 por um post com uma URL. Uma busca que retorna 20 tweets custa US$ 0,10, e buscar 1.000 perfis de seguidores custa cerca de US$ 10. Há um teto de 2 milhões de leituras de posts por mês. Na Sorsa, a cobrança fixa por requisição dá a partir de US$ 0,02 por 1.000 tweets nos endpoints em lote e de US$ 0,01 por 1.000 perfis, com planos a partir de US$ 49 por mês e 100 requisições grátis para começar.

O Tweepy ainda funciona em 2026?

Sim. O Tweepy suporta a X API v2 e funciona com a autenticação atual (bearer tokens e OAuth). Ele exige créditos pagos da API do X: não há como usar o Tweepy sem uma conta de desenvolvedor do X ativa com créditos comprados no pagamento por uso.

Como lidar com rate limits da API do Twitter em Python?

A API oficial impõe limites por janela de 15 minutos (tipicamente de 300 a 900 requisições, conforme o endpoint) e retorna um 429 com um cabeçalho Retry-After quando você bate em um. O Tweepy e o XDK recuam automaticamente; com requests cru você checa os cabeçalhos e dorme antes de repetir. Para uma tabela completa de limites por endpoint, veja nosso guia de rate limits da API do X. Uma API de terceiros como a Sorsa usa um limite por segundo (20 requisições por segundo) em vez de janelas, então, em um 429, você espera um segundo e repete.

Primeiros passos

Escolha um método e rode um dos exemplos acima.

• Dados somente leitura: pegue uma chave no painel da Sorsa, cole-a no dict headers de qualquer exemplo do Método 4 e rode o script. As suas primeiras 100 requisições são grátis, sem cartão, e você vai ter dados estruturados do Twitter no seu terminal em menos de um minuto. A documentação da Sorsa API cobre todos os 40 endpoints.
• Leitura e escrita: crie uma conta de desenvolvedor do X em developer.x.com, compre créditos e rode os exemplos do XDK ou do Tweepy com o seu bearer token.
• Ainda sem código: o playground no navegador linkado acima deixa você testar qualquer endpoint por uma interface web antes de escrever uma linha de Python.

Para um olhar mais amplo sobre provedores somente leitura, veja nossa comparação de alternativas à API do Twitter.

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

Como verificamos este guia

Checamos cada afirmação externa contra fontes primárias em julho de 2026. Os detalhes do XDK oficial (o pacote pip install xdk, o cliente autogerado, a paginação automática, o streaming e os três métodos de autenticação) vêm do anúncio de desenvolvedor do X sobre os XDKs de Python e TypeScript e da documentação do XDK no docs.x.com. O suporte continuado do Tweepy à v2 foi confirmado na documentação do Tweepy. Os números de preço da API do X refletem o modelo atual de pagamento por uso, incluindo as mudanças de custo de escrita de abril de 2026, e o comportamento dos endpoints da Sorsa, o agrupamento em lote por requisição e o preço dos planos vêm da documentação da Sorsa API. Não citamos contagens de tweets nem estrelas de biblioteca, já que esses números mudam; onde um valor poderia envelhecer, descrevemos o mecanismo. Se você notar um número que mudou desde a publicação, a documentação no produto é sempre a fonte atual da verdade.