Como baixar todos os tweets de uma conta: 4 métodos (2026)

Por Sorsa Editorial

Atualizado em julho de 2026: adicionado o caminho inicial de 100 requisições grátis, custo reformulado em torno do preço por 1.000 tweets e reverificados os valores da API oficial do X e o teto de 3.200 tweets da timeline na documentação atual.

Em resumo: Você pode baixar todos os tweets de uma conta pública do Twitter (X) de quatro formas: o arquivo de dados do próprio Twitter (só a sua conta), ferramentas no-code de exportação, scrapers de código aberto ou uma API de dados. A API oficial do X limita a timeline de um usuário a 3.200 posts, então uma API de dados com paginação é a rota prática para um histórico completo.

Toda semana algum pesquisador, analista ou desenvolvedor bate na mesma parede: precisa do histórico completo de tweets de uma conta, e a plataforma dificulta. O arquivo gratuito só cobre os seus próprios posts, a maioria das ferramentas no-code para em 3.200 tweets, e os scrapers de código aberto quebram sempre que o X muda o frontend. A Sorsa API, um provedor alternativo de API do Twitter (X), remove esse teto. Seu endpoint /user-tweets pagina a timeline completa até o primeiro post do usuário, com uma única chave de API no cabeçalho e cobrança fixa por requisição, em vez das cobranças por recurso da API oficial. Uma conta completa de 50.000 tweets custa menos de US$ 5 no plano Pro e termina em cerca de dois minutos.

Nós construímos e operamos essa API e testamos cada um desses métodos nos endpoints ao vivo, então as comparações abaixo vêm de execução real, não de suposição.

Quer resolver agora, sem código? O playground da API no navegador roda o endpoint /user-tweets contra qualquer conta pública sem exigir chave, então você vê uma página real da timeline antes de escrever uma linha de código. Para uma exportação repetível ou grande, os métodos abaixo escalam mais.

Índice

• Método 1: baixe o arquivo da sua própria conta do Twitter (X)
• Método 2: ferramentas no-code de exportação no navegador
• Método 3: scrapers de código aberto
• Método 4: use uma API de dados do Twitter (X)
• Qual método usar?
• Como baixar todos os tweets via API, passo a passo
• Como obter mais de 3.200 tweets de um usuário?
• Quanto custa baixar uma timeline completa?
• Na prática: as contas que quebram os outros métodos
• Perguntas frequentes
• Primeiros passos

Método 1: baixe o arquivo da sua própria conta do Twitter (X) {#method-1-download-your-own-twitterx-archive}

O X permite baixar de graça um arquivo completo da sua própria conta. A exportação inclui cada tweet que você postou, suas mídias, mensagens diretas e metadados da conta, sem limite de quantidade de tweets. Funciona apenas para uma conta em que você está logado; não dá para solicitar o arquivo de outro usuário.

Para solicitar, abra Configurações e privacidade, depois Sua conta e então Baixe um arquivo dos seus dados. Confirme sua identidade, solicite o arquivo e aguarde. O X costuma deixá-lo pronto em 24 a 48 horas e envia por e-mail um link para um arquivo .zip. Dentro há um visualizador HTML e uma pasta data/ com arquivos JSON contendo todo o seu histórico de posts e mídias.

O problema, além do limite à própria conta, é o formato. O JSON é aninhado e específico do Twitter, não uma planilha limpa, então transformá-lo em algo analisável significa escrever um parser ou rodar uma etapa de conversão.

Melhor para: backup pessoal, arquivar a própria conta antes de desativá-la e manutenção de registros de conformidade.

Método 2: ferramentas no-code de exportação no navegador {#method-2-no-code-browser-export-tools}

Ferramentas de exportação no navegador permitem baixar os tweets de uma conta pública em CSV ou Excel sem escrever código. Você digita um @, espera e baixa um arquivo com texto dos tweets, timestamps e métricas de engajamento. A maioria dessas ferramentas usa a API oficial do X por baixo dos panos, então herda o teto de 3.200 tweets e às vezes retorna menos.

A categoria inclui Circleboom, Tweet Binder e uma série de extensões do Chrome. Elas diferem principalmente no formato de saída e no preço, não no limite subjacente.

Essas ferramentas são uma escolha razoável quando você precisa de uma exportação rápida de tweets recentes de uma única conta e não quer tocar em código, e várias delas exportam direto para Excel ou PDF, o que é conveniente para públicos não técnicos. O limite aparece nas contas prolíficas: peça a uma dessas ferramentas o histórico completo de uma conta com 50.000 posts e a maioria devolve, no máximo, os 3.200 mais recentes. Os planos pagos também pesam se você puxa de muitas contas com frequência, e algumas ferramentas pedem que você conecte os cookies da sua própria sessão, o que carrega seu próprio risco de segurança.

Melhor para: exportações pontuais de tweets recentes, usuários não técnicos, panoramas rápidos da concorrência.

Método 3: scrapers de código aberto {#method-3-open-source-scrapers}

Scrapers de código aberto puxam tweets por engenharia reversa dos endpoints web do X, contornando a API oficial e seus preços. São gratuitos, e são frágeis: quando o X gira os tokens do frontend, todo scraper que depende daquele mecanismo quebra de uma vez, sem SLA, sem aviso de descontinuação e sem caminho de migração.

O cenário também encolheu. Ferramentas que eram padrão anos atrás, snscrape e twint, estão na prática mortas: o snscrape sem manutenção há anos e o twint arquivado. Um punhado de bibliotecas ainda é mantido, mas carrega o mesmo risco estrutural: um scraper que funciona hoje pode parar da noite para o dia depois de uma única mudança na plataforma. Para uma visão atual do que ainda roda, veja a análise dos scrapers de Twitter em 2026.

Se você precisa de acesso repetível para um fluxo de produção ou uma pesquisa com prazo, um scraper é uma dependência que você não controla.

Melhor para: exploração pontual, projetos com orçamento apertado e prazos flexíveis, desenvolvedores confortáveis em consertar quebras.

Método 4: use uma API de dados do Twitter (X) {#method-4-use-a-twitterx-data-api}

Uma API de dados é a maneira mais confiável de baixar uma timeline completa de forma programática: você envia requisições HTTP, recebe JSON estruturado e pagina até chegar ao primeiro tweet da conta. A API oficial do X funciona, mas limita a timeline do usuário a 3.200 posts e cobra por recurso no modelo de pagamento por uso de 2026, enquanto uma API de dados de terceiros pode retornar o histórico completo a uma taxa fixa por requisição.

A API oficial do X

Duas coisas tornam o caminho oficial doloroso para esse trabalho específico. Primeiro, o endpoint de timeline do usuário é limitado aos 3.200 posts mais recentes, um limite documentado que se mantém há mais de uma década e ainda vale na X API v2. Segundo, o modelo atual de pagamento por uso cobra por recurso lido (cerca de US$ 0,005 por post e US$ 0,010 por perfil de usuário, verificado em julho de 2026), com teto mensal de 2 milhões de posts, então coletas grandes ficam caras rápido, antes mesmo de você bater no teto da timeline. A autenticação é OAuth 2.0 com bearer token, em vez de uma chave única.

APIs de dados de terceiros

APIs de terceiros alcançam os mesmos dados públicos com autenticação mais simples, preços mais previsíveis e menos restrições. A Sorsa é uma dessas alternativas à API do Twitter (X): um serviço REST gerenciado que retorna dados completos de tweets com um único cabeçalho ApiKey, cobra uma taxa fixa por requisição em vez de por recurso e, o ponto crucial, não tem teto de 3.200 tweets no endpoint /user-tweets. Você pagina o histórico inteiro do usuário até chegar ao primeiro post. Para comparar os dois modelos de preço em detalhe, veja a análise de preços da API do Twitter em 2026.

Melhor para: desenvolvedores, engenheiros de dados, pipelines de produção, projetos de pesquisa, qualquer pessoa que precise de dados estruturados em escala.

Qual método usar? {#which-method-should-you-use}

O método certo depende de quais tweets você precisa, de quantos e com que frequência. Cada opção domina um nicho específico; uma API de dados domina o caso de leitura intensa, em escala ou agendado.

• Backup da sua própria conta: o arquivo nativo do X, que exporta todo o seu histórico de posts de graça e sem limite.
• Uma exportação rápida e pontual de tweets recentes: uma ferramenta no-code no navegador, que atende enquanto você fica dentro do teto dos 3.200 mais recentes da plataforma.
• Scraping pontual sem prazo: um scraper de código aberto, aceitando que ele pode quebrar na próxima mudança de frontend do X.
• Histórico completo, muitas contas ou coleta recorrente: uma API de dados como a Sorsa, cujo endpoint /user-tweets pagina além do teto de 3.200 a uma taxa fixa por requisição.

Como baixar todos os tweets via API, passo a passo {#how-to-download-all-tweets-via-api-step-by-step}

Este é o processo completo com a Sorsa API, da primeira requisição ao arquivo final.

Pré-requisitos

• Uma chave de API do painel da API; as 100 requisições grátis de uma conta nova bastam para testar o loop de paginação de ponta a ponta
• Python 3.7+ com a biblioteca requests, ou Node.js 18+
• O nome de usuário da conta alvo, por exemplo stripe

Novo na API? O guia de início rápido cobre a autenticação e a primeira requisição em poucos minutos, e o guia da API do Twitter com Python aprofunda a configuração de cliente usada abaixo.

Buscar a timeline completa

O endpoint /user-tweets retorna cerca de 20 tweets por página com paginação por cursor. Percorra as páginas até next_cursor sumir ou vir nulo, o que significa que você chegou ao fim da timeline.

Python:

import requests
import time

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

def download_all_tweets(username, max_pages=None):
    """Download every tweet from a public account."""
    all_tweets = []
    cursor = None
    page = 0

    while True:
        body = {"username": username}
        if cursor:
            body["next_cursor"] = cursor

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

        tweets = data.get("tweets", [])
        all_tweets.extend(tweets)
        page += 1
        print(f"Page {page}: {len(tweets)} tweets (total: {len(all_tweets)})")

        cursor = data.get("next_cursor")
        if not cursor:
            print("Done. Reached end of timeline.")
            break
        if max_pages and page >= max_pages:
            print(f"Stopped at {max_pages} pages.")
            break

        time.sleep(0.05)  # stay well within 20 requests per second

    return all_tweets


tweets = download_all_tweets("stripe")
print(f"\nCollected {len(tweets)} tweets from @stripe")

JavaScript:

const API_KEY = "YOUR_API_KEY";
const BASE_URL = "https://api.sorsa.io/v3";

async function downloadAllTweets(username, maxPages = Infinity) {
  const allTweets = [];
  let cursor = null;
  let page = 0;

  while (page < maxPages) {
    const body = { username };
    if (cursor) body.next_cursor = cursor;

    const resp = await fetch(`${BASE_URL}/user-tweets`, {
      method: "POST",
      headers: {
        "ApiKey": API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(body),
    });
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);

    const data = await resp.json();
    allTweets.push(...(data.tweets || []));
    page++;

    console.log(`Page ${page}: ${data.tweets?.length || 0} tweets (total: ${allTweets.length})`);

    cursor = data.next_cursor;
    if (!cursor) break;
    await new Promise((r) => setTimeout(r, 50));
  }

  return allTweets;
}

const tweets = await downloadAllTweets("stripe");
console.log(`Collected ${tweets.length} tweets from @stripe`);

Cada objeto de tweet carrega o texto completo, a data de publicação, os contadores de engajamento (curtidas, retweets, respostas, quotes, visualizações, itens salvos), o idioma, as entidades de mídia e o perfil completo do autor. Esse perfil do autor vem embutido em cada resposta sem custo extra de requisição, então você não precisa de uma chamada separada para buscar a conta, a menos que queira antes os links da bio ou os IDs dos tweets fixados.

Exportar para CSV

Com os tweets em mãos, grave-os em CSV para análise no Pandas, no R, no Google Sheets ou para importar em um banco de dados:

import csv

def export_tweets_csv(tweets, filename="tweets.csv"):
    fields = [
        "id", "created_at", "full_text", "lang",
        "likes_count", "retweet_count", "reply_count",
        "quote_count", "view_count", "bookmark_count",
        "is_reply", "is_quote_status", "username",
    ]

    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fields)
        writer.writeheader()
        for t in tweets:
            writer.writerow({
                "id": t["id"],
                "created_at": t["created_at"],
                "full_text": t["full_text"].replace("\n", " "),
                "lang": t.get("lang", ""),
                "likes_count": t.get("likes_count", 0),
                "retweet_count": t.get("retweet_count", 0),
                "reply_count": t.get("reply_count", 0),
                "quote_count": t.get("quote_count", 0),
                "view_count": t.get("view_count", 0),
                "bookmark_count": t.get("bookmark_count", 0),
                "is_reply": t.get("is_reply", False),
                "is_quote_status": t.get("is_quote_status", False),
                "username": t.get("user", {}).get("username", ""),
            })

    print(f"Exported {len(tweets)} tweets to {filename}")


export_tweets_csv(tweets, "stripe_tweets.csv")

Exportar para Excel

Se o público é não técnico e quer uma planilha, grave as mesmas linhas em .xlsx com o Pandas em duas linhas:

import pandas as pd

df = pd.DataFrame(tweets)
df.to_excel("stripe_tweets.xlsx", index=False)

Se o destino é uma planilha compartilhada em vez de um arquivo local, o guia de exportação de dados do Twitter para o Google Sheets cobre a rota no-code. Para um relatório compartilhável em vez de um dataset de trabalho, dá para renderizar a tabela em PDF com uma biblioteca como o ReportLab, mas CSV e JSON continuam sendo as melhores escolhas quando os dados vão para análise ou para um modelo.

Além da timeline: o método de busca

O endpoint /user-tweets entrega a timeline cronológica bruta. Quando você quer um recorte específico, só tweets com imagens, só tweets acima de um patamar de curtidas ou um intervalo de datas, use /search-tweets com o operador from::

# High-engagement tweets from one account
resp = requests.post(
    f"{BASE_URL}/search-tweets",
    headers={"ApiKey": API_KEY, "Content-Type": "application/json"},
    json={"query": "from:stripe min_faves:50 -filter:replies", "order": "latest"},
)

Dá para combinar from: com filtros de engajamento (min_faves:, min_retweets:), filtros de mídia (filter:images), códigos de idioma (lang:en) e intervalos de datas (since: / until:). O construtor visual de buscas de tweets monta essas consultas visualmente, e a referência completa de operadores de busca lista cada opção.

Como obter mais de 3.200 tweets de um usuário? {#how-do-you-get-more-than-3200-tweets-from-a-user}

Para obter mais de 3.200 tweets de um usuário, você não pode depender do endpoint de timeline da API oficial do X, que trava nos 3.200 posts mais recentes (e em 800 quando as respostas são excluídas). As duas rotas que funcionam são uma API de dados de terceiros com paginação, que percorre a timeline completa, ou coleta baseada em busca por intervalos de datas. Raspar a página de busca da web dia a dia também funciona, mas quebra com frequência e é lento.

Esse teto de 3.200 derruba muito mais gente do que o preço. Guias antigos e respostas de fórum ainda afirmam que passar dele é impossível, ou apontam para scripts de Selenium que raspam a página de busca do Twitter um dia por vez. Esses scripts foram feitos para uma interface de busca que mudou e, em geral, não rodam mais. Veja como cada método realmente se compara hoje:

A conclusão: só dois métodos rompem a barreira dos 3.200 de forma limpa, e ambos são baseados em API. Para a maioria dos usos casuais, puxar as últimas centenas de tweets para uma auditoria de conteúdo, o limite nem aparece. Ele vira um bloqueio para pesquisadores arquivando comentário político, analistas montando datasets históricos de engajamento e qualquer um lidando com contas prolíficas: jornalistas, políticos e marcas de mídia passam com folga dos 50.000 posts. Se você precisa coletar em muitas contas por palavra-chave e data, em vez de uma timeline, o fluxo de dados históricos do Twitter cobre a busca por janelas de data em detalhe.

Quanto custa baixar uma timeline completa? {#how-much-does-it-cost-to-download-a-full-timeline}

Baixar uma timeline completa por uma API de dados de taxa fixa é barato. A cerca de 20 tweets por requisição, uma conta de 50.000 tweets dá cerca de 2.500 requisições; no plano Pro, a US$ 0,00199 por requisição, isso fica abaixo de US$ 5 e termina em cerca de dois minutos a 20 requisições por segundo. O custo escala com o tamanho da conta, não com uma cobrança por recurso.

Duas taxas importam aqui. Paginar uma timeline completa passa pelo /user-tweets a cerca de 20 tweets por requisição, o que dá aproximadamente US$ 0,10 por 1.000 tweets no plano Pro. Quando você já tem os IDs dos tweets, o endpoint em lote /tweet-info-bulk retorna até 100 tweets por requisição, a partir de US$ 0,02 por 1.000 tweets. Um arquivo completo usa a primeira taxa, já que você está percorrendo a timeline em vez de consultar IDs conhecidos.

Veja como fica a extração completa em diferentes escalas, no plano Pro a US$ 0,00199 por requisição (taxas verificadas em julho de 2026):

A timeline completa de uma conta de 50.000 tweets custa menos de US$ 5 e leva cerca de dois minutos. Nesse tipo de trabalho de leitura intensa, a Sorsa sai até 50x mais barata por post do que a API oficial do X, que cobra US$ 0,005 por cada post lido mais US$ 0,010 por cada perfil de autor buscado (taxas do X verificadas em julho de 2026). Uma ferramenta no-code com assinatura mensal ainda entregaria só os últimos 3.200 daquela mesma conta. Se você puxa de muitas contas em agenda, os planos de preço fixo por requisição chegam a 500.000 requisições, cerca de 200 arquivos completos de 50.000 tweets por mês.

Na prática: as contas que quebram os outros métodos {#in-practice-the-accounts-that-break-the-other-methods}

As contas que as pessoas mais precisam por inteiro são as prolíficas, exatamente onde os outros métodos falham. Uma equipe de monitoramento de mídia com quem trabalhamos precisava do histórico completo de posts de uma figura pública com cerca de 60.000 tweets para um estudo de discurso. A ferramenta no-code que usavam retornou os 3.200 mais recentes e parou, deixando uma lacuna de vários anos impossível de preencher. Eles passaram a paginar o endpoint /user-tweets, puxaram a timeline inteira em uma única tarde por menos de US$ 6 no plano Pro e gravaram tudo direto em CSV para o modelo. O teto de 3.200, não o custo, era o verdadeiro bloqueio o tempo todo, e, uma vez removido, o trabalho virou rotina. O mesmo padrão de coletar e exportar sustenta o passo a passo de montagem de um dataset do Twitter para machine learning.

Perguntas frequentes {#faq}

Dá para baixar tweets de uma conta privada (protegida)?

Não. Contas protegidas restringem seus tweets a seguidores aprovados, então nenhuma API, scraper ou ferramenta de exportação consegue lê-los, a menos que você seja um seguidor autenticado com sessão ativa. Isso vale igualmente para a API oficial do X, para a Sorsa API e para todos os outros métodos daqui. Só contas públicas podem ser baixadas por terceiros.

Até onde no passado dá para chegar?

O endpoint de timeline da API oficial do X retorna apenas os 3.200 tweets mais recentes, independentemente da idade. O seu próprio arquivo do Twitter contém tudo o que você postou. Uma API de dados com paginação, como a Sorsa API, percorre a timeline do /user-tweets até o primeiro post do usuário sem limite rígido, e a busca por from:username com os operadores since: e until: dá controle preciso sobre uma janela específica.

Os tweets baixados incluem imagens e vídeos?

Sim. Cada objeto de tweet contém um array entities com URLs diretas das fotos, vídeos e GIFs anexados ao tweet, além de miniaturas de prévia. Você pode usar essas URLs para baixar os arquivos de mídia de forma programática. Para salvar mídia de tweets individuais sem código, o baixador de mídia gratuito da Sorsa cuida de fotos, vídeo e áudio, e o guia de download de mídia do Twitter via API cobre a versão programática.

É legal baixar os tweets de alguém?

Baixar tweets disponíveis publicamente para análise pessoal, pesquisa ou inteligência de negócios é, em geral, permitido, já que tweets públicos são visíveis para qualquer pessoa online. O risco está no uso que se faz dos dados: redistribuição, republicação em escala ou uso para assediar podem violar os termos da plataforma ou normas como o GDPR na União Europeia. Para coleta comercial ou em grande escala, consulte assessoria jurídica que conheça a sua jurisdição.

Qual formato é melhor para análise, CSV, JSON ou Excel?

CSV é a escolha mais universal e abre no Excel, no Google Sheets, no Pandas e no R. JSON preserva a estrutura aninhada completa, como entidades de mídia, tweets citados e objetos de autor, e serve para processamento programático ou importação em banco de dados. Excel é conveniente para públicos não técnicos, mas adiciona uma etapa de conversão. Comece com CSV; vá de JSON quando precisar de dados aninhados de respostas ou mídia.

Existe uma API do Twitter sem o limite de 3.200 tweets?

Sim. A Sorsa API é uma API de dados do Twitter (X) cujo endpoint /user-tweets não tem teto de 3.200 tweets: você pagina a timeline completa até o primeiro post da conta. Ela autentica com um único cabeçalho ApiKey em vez de OAuth, cobra uma taxa fixa por requisição em vez de por recurso e aplica um limite de 20 requisições por segundo em todos os planos, então o arquivo completo de uma conta grande custa só alguns dólares.

Como baixar tweets com palavras-chave ou hashtags específicas?

Use a busca em vez do endpoint de timeline. Passe ao /search-tweets uma consulta combinando a palavra-chave ou hashtag com um filtro from:username. Por exemplo, from:stripe #payments since:2025-01-01 retorna apenas tweets de @stripe com a hashtag #payments postados desde janeiro de 2025. A lista completa de operadores está na referência de operadores de busca.

Primeiros passos {#getting-started}

Você pode avaliar tudo isso antes de assinar um plano. Primeiro, teste qualquer conta pública no playground, sem cadastro e sem chave. Depois, uma conta nova inclui 100 requisições grátis: concedidas uma única vez, sem cartão de crédito, sem prazo de validade e válidas em todos os 40 endpoints, o que dá até 10.000 tweets ou 20.000 perfis pela API. É o bastante para rodar um trabalho real de arquivo, não um crédito simbólico de teste, antes de decidir.

O preço parte da taxa por 1.000: a partir de US$ 0,02 por 1.000 tweets nos endpoints em lote, com planos fixos de US$ 49 por 10.000 requisições, US$ 199 por 100.000 e US$ 899 por 500.000. Não há processo de aprovação, não há fluxo OAuth, é uma única chave de API e um limite fixo de 20 requisições por segundo em todos os planos.

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

Este guia se apoia no nosso próprio trabalho operando uma API alternativa do Twitter (X) desde 2022, hoje com mais de 5 bilhões de requisições servidas, e no teste dos quatro métodos contra os endpoints ao vivo. Reverificamos o teto de 3.200 tweets da timeline em julho de 2026 na documentação atual da X API v2 e na referência do cliente tweepy, e as taxas de pagamento por uso da API oficial do X nos preços de desenvolvedor publicados pelo X. Comportamento de endpoints, paginação e custos por requisição vêm da documentação da Sorsa API; mais sobre a equipe está na página sobre a Sorsa. Encontrou algo desatualizado? Fale conosco em contacts@sorsa.io. Última verificação: 3 de julho de 2026.