Como montar um dataset do Twitter para machine learning

#De onde vêm os datasets do Twitter

Todo dataset do Twitter (X) nasce em um de dois lugares: uma coleção que alguém já publicou, ou tweets que você coleta por conta própria por meio de uma API. Um conjunto publicado é grátis e carrega em minutos. Uma coleção sua combina com o seu tópico, idioma, datas e rótulos, porque é você quem os escolhe; nosso guia sobre como fazer scraping do Twitter compara todas as formas de puxar tweets em 2026.

Os conjuntos públicos mais conhecidos foram reunidos entre 2009 e 2022, quando o Twitter ainda dava acesso gratuito à API para pesquisadores, e vários deles já não distribuem mais o texto dos tweets.

• Sentiment140

  Tamanho

  1,6 milhão de tweets, 498 para teste

  Coletado

  2009

  O que você recebe hoje

  Texto com rótulos positivo ou negativo tirados de emoticons

• TweetEval (Cardiff NLP)

  Tamanho

  7 tarefas de classificação

  Coletado

  Benchmark de 2020

  O que você recebe hoje

  Texto e rótulos de sentimento, emoção, ironia, ódio, linguagem ofensiva, emoji e posicionamento

• COVID-19-TweetIDs

  Tamanho

  Mais de 1 bilhão de tweets

  Coletado

  A partir de janeiro de 2020

  O que você recebe hoje

  Apenas IDs de tweets

• Arquivo do Twitter do ArchiveTeam

  Tamanho

  Cerca de 16 bilhões de registros

  Coletado

  2011 a 2022

  O que você recebe hoje

  JSON bruto, sem rótulos

• SNAP Twitter7 (Stanford)

  Tamanho

  476 milhões de tweets

  Coletado

  2009

  O que você recebe hoje

  Nada: retirado a pedido do Twitter

Para uma linha de base genérica de sentimento ou emoção, um dos conjuntos rotulados é o começo mais rápido. A lista awesome-twitter-data (abre em uma nova aba), mantida pela comunidade, acompanha centenas de outros e marca quais ainda compartilham o texto. Para qualquer coisa específica, como reações ao seu produto, um evento deste ano, um idioma que os arquivos ignoram ou um esquema de rótulos seu, você monta o dataset.

#O problema dos datasets públicos do Twitter

Os datasets públicos do Twitter compartilham quatro problemas: são antigos, a maioria guarda só IDs, esses IDs se degradam a cada ano e os rótulos foram feitos para a tarefa de outra pessoa.

• Texto antigo. Todo tweet do Sentiment140 tem 140 caracteres ou menos, porque o Twitter só elevou o limite para 280 em novembro de 2017. Um modelo treinado com a linguagem de 2009 encontra em 2026 gírias, assuntos e tamanhos de post que nunca viu.
• IDs em vez de texto. Um dataset compartilhado com terceiros costuma conter apenas IDs de posts e de usuários, então muitos conjuntos de pesquisa, entre eles as grandes coleções de COVID-19, são listas de números. Você recupera o texto reidratando os IDs: consultando cada um de novo por meio de uma API.
• Degradação. Um tweet que foi apagado, ou cujo autor ficou privado ou foi suspenso, não volta mais. As linhas perdidas não são aleatórias, então o conjunto reconstruído tende para as contas que continuam ativas.
• Rótulos emprestados. Os rótulos do Sentiment140 vieram de emoticons, não de pessoas lendo os tweets, e os rótulos de benchmark respondem à pergunta do benchmark, não à sua.

Para um modelo que precisa entender os posts deste ano, sobra um caminho: um conjunto novo, limpo e rotulado para uma única tarefa.

#Como montar um dataset novo do Twitter com a Sorsa API

Para um dataset novo, use a Sorsa API, uma API e scraper do Twitter (X): uma chave de API, os operadores de busca do X desde 2006, cerca de 20 tweets por requisição a partir de US$ 0,07 por 1.000 e 20 requisições por segundo em todos os planos, então um conjunto de 1 milhão de tweets sobre um tópico leva cerca de 42 minutos para coletar. Todo tweet chega com o perfil completo do autor sem custo extra, e nada toca em uma conta sua do X.

Escolha o endpoint pelo que define o seu dataset:

• Um tópico, palavras-chave ou um intervalo de datas: POST /search-tweets (abre em uma nova aba).
• Os posts de uma única conta: POST /user-tweets (abre em uma nova aba), tratado no nosso guia para baixar todos os tweets de um usuário.
• Um grupo de contas escolhidas a dedo, lido como uma Lista do X: GET /list-tweets (abre em uma nova aba).
• Threads de respostas, para dados de conversa: POST /comments (abre em uma nova aba).

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

2. Escreva a consulta. Os operadores de busca moldam o dataset antes de você pagar por ele: lang:en mantém um único idioma, -filter:retweets descarta cópias, since: e until: fixam a janela. Teste uma consulta à mão primeiro na ferramenta gratuita Busca Avançada do Twitter.

3. Envie uma requisição de teste. Uma requisição devolve cerca de 20 tweets e um cursor para a próxima página.

   curl -X POST "https://api.sorsa.io/v3/search-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"order": "latest",
          "query": "crashing lang:en -filter:retweets since:2026-10-01"}'
   

   {
     "tweets": [
       {
         "id": "2115807747265175863",
         "full_text": "The new beta keeps crashing on launch for me",
         "created_at": "2026-10-29T14:07:31Z",
         "lang": "en",
         "likes_count": 12,
         "reply_count": 3,
         "retweet_count": 0,
         "conversation_id_str": "2115807747265175863",
         "in_reply_to_tweet_id": null,
         "is_reply": false,
         "made_with_ai": false,
         "user": {
           "id": "1710221540156513285",
           "username": "maya_trains_models",
           "followers_count": 412,
           "created_at": "2023-10-06T09:12:44Z",
           "verified": false
         }
       }
     ],
     "next_cursor": "DAADDAABCgABHV5mIq0VsAoKAAIdXmUz8Kqg"
   }
   

   Ver resposta completa

4. Percorra as páginas e salve JSONL bruto. Envie o next_cursor de volta até que ele venha vazio e grave cada tweet intocado, um objeto JSON por linha. A limpeza roda depois, sobre uma cópia, então você nunca paga para coletar os mesmos tweets duas vezes.

   import json
   import time
   
   import requests
   
   URL = "https://api.sorsa.io/v3/search-tweets"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   QUERY = "crashing lang:en -filter:retweets since:2026-10-01"
   
   
   def collect(query, path, limit=50_000):
       body = {"query": query, "order": "latest"}
       saved = 0
       with open(path, "a", encoding="utf-8") as out:
           while saved < limit:
               r = requests.post(URL, headers=HEADERS, json=body, timeout=30)
               if r.status_code == 429:  # over 20 requests per second
                   time.sleep(1)
                   continue
               r.raise_for_status()  # 403: no key, or no requests left
               page = r.json()
               for tweet in page.get("tweets", []):
                   tweet["_query"] = query
                   out.write(json.dumps(tweet, ensure_ascii=False) + "\n")
                   saved += 1
               if not page.get("next_cursor"):
                   break
               body["next_cursor"] = page["next_cursor"]
       return saved
   
   
   print(collect(QUERY, "raw_tweets.jsonl"), "tweets saved")
   

Rode uma consulta por classe ou tópico, cada uma em seu próprio arquivo, e a contagem por arquivo mostra na hora se uma classe está muito rala. Para ir além deste ano, o mesmo endpoint alcança todo tweet público desde 2006; nosso guia sobre dados históricos do Twitter trata do fatiamento por data em grandes coletas retroativas.

#Reidrate um dataset de IDs de tweets

Para reconstruir um dataset publicado só com IDs, envie os IDs dos tweets para POST /tweet-info-bulk (abre em uma nova aba) na Sorsa API, até 100 por requisição, e guarde o que voltar. Uma lista de 1 milhão de IDs custa a partir de US$ 14 e leva cerca de 8 minutos a 20 requisições por segundo; o mesmo 1 milhão de posts custa US$ 5.000 em leituras de posts na API oficial do X.

import json

import requests

URL = "https://api.sorsa.io/v3/tweet-info-bulk"
HEADERS = {"ApiKey": "YOUR_API_KEY"}

with open("tweet_ids.txt", encoding="utf-8") as f:
    ids = list(dict.fromkeys(x.strip() for x in f if x.strip()))

found = set()
with open("rehydrated.jsonl", "w", encoding="utf-8") as out:
    for i in range(0, len(ids), 100):
        body = {"tweet_links": ids[i:i + 100]}
        r = requests.post(URL, headers=HEADERS, json=body, timeout=30)
        r.raise_for_status()
        for tweet in r.json().get("tweets", []):
            found.add(tweet["id"])
            out.write(json.dumps(tweet, ensure_ascii=False) + "\n")

missing = [x for x in ids if x not in found]
print(f"recovered {len(found)} of {len(ids)}; {len(missing)} gone")

Informe a taxa de recuperação junto com o dataset: quantos IDs voltaram, de quantos, em que data. Dois datasets reconstruídos a partir dos mesmos IDs com um ano de diferença são datasets diferentes, e quem lê seus resultados precisa saber com qual você treinou.

Bom saber

Mantenha os IDs de tweets como texto do início ao fim. Um ID tem 19 dígitos, enquanto uma planilha guarda 15 dígitos significativos e um número do JavaScript cerca de 16, então um ID que passa pelo Excel ou por JSON.parse volta arredondado e não corresponde a nenhum tweet. Leia os arquivos de IDs como strings e salve-os entre aspas.

#Limpe e remova duplicatas dos tweets

Limpe um dataset de tweets em quatro passadas: descarte retweets e duplicatas exatas por ID, reduza o texto quase duplicado, filtre por idioma e autor, e troque handles e links por marcadores. Cada passada usa campos que voltam em todo tweet.

• id

  O que faz em um dataset

  A chave primária; guarde-a como string

• full_text

  O que faz em um dataset

  O texto que você limpa, rotula e usa para treinar

• lang

  O que faz em um dataset

  Mantém cada divisão em um único idioma

• conversation_id_str

  O que faz em um dataset

  Agrupa uma thread, para que a divisão possa mantê-la inteira

• in_reply_to_tweet_id

  O que faz em um dataset

  Liga uma resposta ao seu tweet-pai, para pares de conversa

• made_with_ai

  O que faz em um dataset

  Marca posts que o X rotula como feitos com IA; deixe-os fora de conjuntos de texto humano

• user.followers_count, user.created_at

  O que faz em um dataset

  Sinais do autor para filtros de spam e de bots

• likes_count, reply_count

  O que faz em um dataset

  Um piso de qualidade: posts com os quais ninguém interagiu costumam ser spam

As quase duplicatas são a passada que a maioria dos pipelines pula. Retweets com comentário, posts copiados, campanhas de bots e a mesma reclamação colada por dez contas passam todos por uma checagem de ID e inflam tudo o que dizem. Normalize o texto primeiro (minúsculas, sem links, sem handles, sem pontuação) e depois compare shingles de palavras: dois posts que compartilham a maior parte de suas sequências de três palavras dizem a mesma coisa. O verificador abaixo executa esse teste sobre o que você colar.

Para o texto que o modelo vai ler, troque cada handle por @user e cada link por http, a convenção que os modelos de tweets do Cardiff NLP usam. O modelo então aprende como as pessoas escrevem, não quais contas e links mais aparecem. Guarde o full_text original ao lado do limpo, para poder mudar a limpeza depois sem coletar de novo.

import hashlib
import json
import re


def norm(text):
    text = re.sub(r"https?://\S+", " ", text.lower())
    text = re.sub(r"^rt @\w+:?|@\w+", " ", text)
    text = re.sub(r"[^\w\s#]", " ", text)
    return " ".join(text.split())


seen, rows = set(), []
for line in open("raw_tweets.jsonl", encoding="utf-8"):
    t = json.loads(line)
    if t.get("retweeted_status") or t.get("made_with_ai"):
        continue
    clean = norm(t["full_text"])
    key = hashlib.sha1(clean.encode()).hexdigest()
    if key in seen or len(clean.split()) < 4:
        continue
    seen.add(key)
    rows.append(t)

O hash pega as cópias exatas depois da normalização; para correspondências aproximadas na escala de milhões, o MinHash com hashing sensível à localidade faz a comparação de shingles sem comparar todos os pares.

#Rotule o dataset

Rotule um dataset de tweets em duas camadas: um conjunto de referência de algumas centenas de tweets que pessoas rotulam à mão, e o grosso pré-rotulado por um modelo e conferido por uma pessoa onde o modelo tem dúvida. O conjunto de referência nunca entra no treino; ele é o teste que diz se os rótulos do grosso são bons o bastante.

Escreva as regras de rotulagem antes de qualquer um começar, com um exemplo de cada classe e dos casos difíceis: sarcasmo, perguntas, citações da opinião de outra pessoa. Duas pessoas rotulando os mesmos 100 tweets e comparando os resultados mostram onde as regras são vagas. Guarde com cada rótulo quem ou o que o produziu (human, model, query), para poder descartar ou reponderar os mais fracos depois.

Uma consulta de busca pode servir de rótulo fraco: tweets coletados para "keeps crashing" tendem ao negativo. Use isso só para dar a partida, porque um rótulo de consulta ensina ao modelo as palavras da consulta, não o sentimento.

#Divida treino e teste sem vazamento

Divida um dataset de tweets por conversa e por tempo, nunca linha a linha: reserve as semanas mais recentes como conjunto de teste e mantenha cada thread de um mesmo lado da linha. Uma divisão aleatória coloca um post e suas respostas, ou duas cópias do mesmo texto, tanto no treino quanto no teste, e a nota do teste passa a medir memória em vez de habilidade.

import hashlib

rows.sort(key=lambda t: t["created_at"])
cut = rows[int(len(rows) * 0.9)]["created_at"]  # newest 10% = test
test = [t for t in rows if t["created_at"] >= cut]

threads = {t.get("conversation_id_str") for t in test}
rest = [t for t in rows if t["created_at"] < cut
        and t.get("conversation_id_str") not in threads]


def bucket(t):
    key = t.get("conversation_id_str") or t["id"]
    return int(hashlib.md5(key.encode()).hexdigest(), 16) % 10


train = [t for t in rest if bucket(t) != 0]
valid = [t for t in rest if bucket(t) == 0]

Para tarefas sobre contas em vez de posts, como a detecção de bots no Twitter, agrupe por user.id, de modo que nenhuma conta apareça nos dois lados.

#Salve no formato que o seu modelo lê

Salve um dataset de tweets como JSONL, um registro por linha, com o ID do tweet em todo registro. O JSONL faz streaming, aceita acréscimos e carrega direto no pandas, na biblioteca datasets do Hugging Face e na maioria dos scripts de treino. Quais campos entram em cada linha depende do trabalho.

• Classificador ou modelo de tópicos

  O que cada linha JSONL guarda

  id, text limpo, label, label_source, lang, created_at

• Conjunto de avaliação de um modelo ou de um prompt

  O que cada linha JSONL guarda

  id, text, a resposta esperada e a regra que ele testa

• Índice RAG para recuperação

  O que cada linha JSONL guarda

  id, text, a URL do post, created_at e o ID do autor, para que as respostas possam citar o post

{
  "id": "2115807747265175863",
  "text": "the new beta keeps crashing on launch for me",
  "label": "negative",
  "label_source": "human",
  "lang": "en",
  "created_at": "2026-10-29T14:07:31Z",
  "split": "test"
}

Entregue um cartão do dataset junto com os arquivos: as consultas e as datas, o dia em que você coletou ou reidratou, a taxa de recuperação, como os rótulos foram feitos, o que foi filtrado e para o que o conjunto não deve ser usado. Os cartões de dataset do Hugging Face seguem o mesmo roteiro, e a próxima pessoa a treinar com os seus dados, muitas vezes você mesmo daqui a seis meses, precisa de cada linha dele.

#Quanto custa um dataset do Twitter

Um dataset de 1 milhão de tweets custa US$ 5.000 em leituras de posts na API oficial do X, contra a partir de US$ 70 na Sorsa API por busca, ou a partir de US$ 14 quando você reidrata IDs conhecidos. Troque o tamanho para ver os totais de uma coleta nova por busca.

Dois limites da API oficial do X mudam a conta para datasets. O plano de pagamento por uso para em 3 milhões de leituras de posts por mês, então um conjunto de 10 milhões de tweets exige um contrato Enterprise, para o qual a lista de preços do X (abre em uma nova aba) aponta acima desse teto. E, a partir de 22 de novembro de 2026, o X também cobra como leitura de usuário o perfil do autor que volta com cada post, US$ 0,010 a mais por post (aviso do X (abre em uma nova aba)). Na Sorsa API o perfil completo do autor faz parte de todo tweet, e requisições com falha nunca são cobradas.

O tempo é a outra metade do orçamento. A 20 requisições por segundo, a Sorsa API coleta cerca de 400 tweets por segundo por busca e até 2.000 por segundo por ID, então 1 milhão de tweets novos leva cerca de 42 minutos e um conjunto de 10 milhões cerca de 7 horas em uma única chave.

#Como compartilhar um dataset de tweets e treinar com ele

Datasets públicos de pesquisa são distribuídos como IDs de tweets e de usuários, e quem tem os IDs recupera o texto completo por meio de uma API: a Sorsa API reidrata 1 milhão de IDs em cerca de 8 minutos.

• Compartilhamento. Publique os IDs de tweets e de usuários com um script de reidratação, como fazem os datasets públicos de pesquisa; o POST /tweet-info-bulk transforma 100 IDs de volta em posts completos por requisição.
• Treinamento. Guarde o texto completo que você coleta para os seus próprios modelos: classificadores, modelos de tópicos, conjuntos de avaliação, índices de recuperação e fine-tuning de modelos de linguagem são os trabalhos comuns dos datasets de tweets.
• Pessoas. Troque os handles antes de treinar, não monte perfis de indivíduos e remova os tweets que os autores apagaram quando atualizar o conjunto.

A Sorsa API devolve apenas dados públicos e nunca publica, curte nem segue. Universidades com um projeto de pesquisa também podem perguntar sobre o acesso acadêmico à Sorsa API.

#Comece o seu dataset com uma coleta de teste

Os datasets públicos do Twitter dão uma linha de base; um dataset novo dá o seu próprio tópico, as suas próprias datas e rótulos que combinam com a sua tarefa. Monte-o com a Sorsa API: a partir de US$ 0,07 por 1.000 tweets por busca e a partir de US$ 0,014 por 1.000 por ID, a 20 requisições por segundo, com o perfil do autor em todo tweet. Suas 100 requisições grátis coletam os primeiros 2.000 tweets, o bastante para testar a consulta, a limpeza e a divisão antes de pagar por qualquer coisa.

#FAQ