Crea un dataset de Twitter para machine learning

#De dónde salen los datasets de Twitter

Todo dataset de Twitter (X) empieza en uno de dos lugares: una colección que alguien ya publicó, o tweets que recopilas tú mismo con una API. Un conjunto publicado es gratis y se carga en minutos. Una colección propia se ajusta a tu tema, idioma, fechas y etiquetas, porque tú las eliges; nuestra guía de cómo hacer scraping de Twitter compara todas las formas de descargar tweets en 2026.

Los conjuntos públicos más conocidos se reunieron entre 2009 y 2022, cuando Twitter aún daba a los investigadores acceso gratuito a su API, y varios ya no entregan el texto de los tweets.

• Sentiment140

  Tamaño

  1.6M de tweets, 498 para pruebas

  Recopilado

  2009

  Lo que obtienes hoy

  Texto con etiquetas positivas o negativas tomadas de emoticonos

• TweetEval (Cardiff NLP)

  Tamaño

  7 tareas de clasificación

  Recopilado

  Benchmark de 2020

  Lo que obtienes hoy

  Texto y etiquetas de sentimiento, emoción, ironía, odio, lenguaje ofensivo, emojis y postura

• COVID-19-TweetIDs

  Tamaño

  Más de 1B de tweets

  Recopilado

  Desde enero de 2020

  Lo que obtienes hoy

  Solo IDs de tweets

• Archivo de Twitter de ArchiveTeam

  Tamaño

  Unos 16B de registros

  Recopilado

  De 2011 a 2022

  Lo que obtienes hoy

  JSON sin procesar, sin etiquetas

• SNAP Twitter7 (Stanford)

  Tamaño

  476M de tweets

  Recopilado

  2009

  Lo que obtienes hoy

  Nada: retirado a petición de Twitter

Para una línea base genérica de sentimiento o emoción, uno de los conjuntos etiquetados es el comienzo más rápido. La lista awesome-twitter-data (se abre en una pestaña nueva), mantenida por la comunidad, registra cientos más y marca cuáles aún comparten texto. Para cualquier necesidad específica, como las reacciones a tu producto, un evento de este año, un idioma que los archivos omiten o un esquema de etiquetas propio, creas el dataset.

#El problema de los datasets públicos de Twitter

Los datasets públicos de Twitter comparten cuatro problemas: son viejos, la mayoría guarda solo IDs, esos IDs se degradan cada año y sus etiquetas se hicieron para la tarea de otra persona.

• Texto viejo. Cada tweet de Sentiment140 tiene 140 caracteres o menos, porque Twitter subió el límite a 280 apenas en noviembre de 2017. Un modelo entrenado con el lenguaje de 2009 se topa con la jerga, los temas y las longitudes de post de 2026, que nunca ha visto.
• IDs en lugar de texto. Un dataset compartido con otros suele incluir solo IDs de posts y de usuarios, así que muchos conjuntos de investigación, entre ellos las grandes colecciones de COVID-19, son listas de números. El texto se recupera rehidratando los IDs: consultando cada uno de nuevo con una API.
• Degradación. Un tweet que se borró, o cuyo autor se volvió privado o fue suspendido, ya no vuelve. Las filas que pierdes no son aleatorias, así que el conjunto reconstruido se inclina hacia las cuentas que siguen activas.
• Etiquetas ajenas. Las etiquetas de Sentiment140 salieron de emoticonos, no de personas que leyeran los tweets, y las etiquetas de un benchmark responden a la pregunta del benchmark, no a la tuya.

Para un modelo que debe entender los posts de este año, queda un solo camino: un conjunto nuevo, limpiado y etiquetado para una tarea.

#Cómo crear un dataset nuevo de Twitter con Sorsa API

Para un dataset nuevo, usa Sorsa API, una API y scraper de Twitter (X): una API key, los operadores de búsqueda de X hasta 2006, unos 20 tweets por solicitud desde $0.07 por cada 1,000 y 20 solicitudes por segundo en todos los planes, así que un conjunto temático de 1M de tweets toma unos 42 minutos en reunirse. Cada tweet llega con el perfil completo de su autor sin costo extra, y nada toca una cuenta tuya de X.

Elige el endpoint según lo que defina tu dataset:

• Un tema, palabras clave o un rango de fechas: POST /search-tweets (se abre en una pestaña nueva).
• Los posts de una sola cuenta: POST /user-tweets (se abre en una pestaña nueva), que cubrimos en nuestra guía para descargar todos los tweets de un usuario.
• Un grupo de cuentas elegidas a mano, leído como una Lista de X: GET /list-tweets (se abre en una pestaña nueva).
• Hilos de respuestas para datos de conversación: POST /comments (se abre en una pestaña nueva).

1. Obtén una clave. Regístrate y copia tu API key desde el panel. Las primeras 100 solicitudes son gratis, sin tarjeta.

2. Escribe la consulta. Los operadores de búsqueda le dan forma al dataset antes de que pagues: lang:en conserva un solo idioma, -filter:retweets descarta las copias, since: y until: fijan la ventana. Prueba primero una consulta a mano en la herramienta gratuita de Búsqueda avanzada de Twitter.

3. Envía una solicitud de prueba. Una solicitud devuelve unos 20 tweets y un cursor a la página siguiente.

   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 respuesta completa

4. Recorre las páginas y guarda JSONL sin procesar. Envía next_cursor de vuelta hasta que llegue vacío, y escribe cada tweet intacto, un objeto JSON por línea. La limpieza se hace después sobre una copia, así nunca pagas por reunir los mismos tweets dos veces.

   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")
   

Ejecuta una consulta por clase o tema, cada una en su propio archivo, y el conteo por archivo te dice al instante si una clase está muy flaca. Para ir más atrás que este año, el mismo endpoint llega a todos los tweets públicos desde 2006; nuestra guía de datos históricos de Twitter explica cómo dividir por fechas para las cargas históricas grandes.

#Rehidrata un dataset de IDs de tweets

Para reconstruir un dataset de IDs publicado, envía sus IDs de tweets a POST /tweet-info-bulk (se abre en una pestaña nueva) en Sorsa API, hasta 100 por solicitud, y conserva lo que vuelva. Una lista de 1M de IDs cuesta desde $14 y toma unos 8 minutos a 20 solicitudes por segundo; esos mismos 1M de posts cuestan $5,000 en lecturas de posts en la API oficial de 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")

Informa la tasa de recuperación junto con el dataset: cuántos IDs volvieron, de cuántos, en qué fecha. Dos datasets reconstruidos con los mismos IDs con un año de diferencia son datasets distintos, y quien lea tus resultados necesita saber con cuál entrenaste.

Para tener en cuenta

Conserva los IDs de tweets como texto de principio a fin. Un ID tiene 19 dígitos, mientras que una hoja de cálculo guarda 15 dígitos significativos y un número de JavaScript unos 16, así que un ID que pasa por Excel o por JSON.parse vuelve redondeado y no coincide con ningún tweet. Lee los archivos de IDs como cadenas y guárdalos entre comillas.

#Limpia y deduplica los tweets

Limpia un dataset de tweets en cuatro pasadas: descarta retweets y duplicados exactos por ID, colapsa el texto casi duplicado, filtra por idioma y autor, y cambia handles y enlaces por marcadores. Cada pasada usa campos que vienen en todos los tweets.

• id

  Qué hace en un dataset

  La clave primaria; guárdalo como cadena

• full_text

  Qué hace en un dataset

  El texto que limpias, etiquetas y con el que entrenas

• lang

  Qué hace en un dataset

  Mantiene cada división en un solo idioma

• conversation_id_str

  Qué hace en un dataset

  Agrupa un hilo, para que la división lo mantenga unido

• in_reply_to_tweet_id

  Qué hace en un dataset

  Enlaza una respuesta con su post padre para formar pares de conversación

• made_with_ai

  Qué hace en un dataset

  Marca los posts que X etiqueta como hechos con IA; déjalos fuera de los conjuntos de texto humano

• user.followers_count, user.created_at

  Qué hace en un dataset

  Señales del autor para filtros de spam y bots

• likes_count, reply_count

  Qué hace en un dataset

  Un piso de calidad: los posts con los que nadie interactuó suelen ser spam

Los casi duplicados son la pasada que la mayoría de los pipelines se salta. Los retweets con comentario, los posts copiados, las campañas de bots y la misma queja pegada por diez cuentas sobreviven a una revisión por ID e inflan lo que dicen. Normaliza primero el texto (minúsculas, sin enlaces, sin handles, sin puntuación) y luego compara shingles de palabras: dos posts que comparten la mayoría de sus tramos de tres palabras dicen lo mismo. El verificador de abajo hace esa prueba con lo que pegues.

Para el texto que leerá el modelo, reemplaza cada handle con @user y cada enlace con http, la convención que usan los modelos de tweets de Cardiff NLP. Así el modelo aprende cómo escribe la gente, no qué cuentas y enlaces aparecen más. Conserva el full_text original junto al limpio, para poder cambiar la limpieza después sin volver a reunir los datos.

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)

El hash atrapa las copias exactas tras la normalización; para coincidencias difusas a escala de millones, MinHash con hashing sensible a la localidad hace la comparación de shingles sin comparar cada par.

#Etiqueta el dataset

Etiqueta un dataset de tweets en dos capas: un conjunto de referencia de unos cientos de tweets que personas etiquetan a mano, y el grueso preetiquetado por un modelo y revisado por una persona donde el modelo duda. El conjunto de referencia nunca entra al entrenamiento; es la prueba que te dice si las etiquetas del grueso son lo bastante buenas.

Escribe las reglas de etiquetado antes de que alguien empiece, con un ejemplo de cada clase y de los casos difíciles: sarcasmo, preguntas, citas de la opinión de otro. Dos personas que etiquetan los mismos 100 tweets y comparan resultados muestran dónde son vagas las reglas. Guarda con cada etiqueta quién o qué la produjo (human, model, query), para poder descartar o reponderar las débiles más adelante.

Una consulta de búsqueda puede servir como etiqueta débil: los tweets reunidos con "keeps crashing" tienden a ser negativos. Úsala solo para arrancar, porque una etiqueta de consulta le enseña al modelo las palabras de la consulta, no el sentimiento.

#Divide entrenamiento y prueba sin fugas

Divide un dataset de tweets por conversación y por tiempo, nunca fila por fila: reserva las semanas más recientes como conjunto de prueba y mantén cada hilo en un solo lado de la línea. Una división aleatoria pone un post y sus respuestas, o dos copias del mismo texto, tanto en entrenamiento como en prueba, y entonces la puntuación de prueba mide memoria en lugar de habilidad.

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 tareas sobre cuentas en lugar de posts, como la detección de bots en Twitter, agrupa por user.id, para que ninguna cuenta aparezca en ambos lados.

#Guárdalo en el formato que lee tu modelo

Guarda un dataset de tweets como JSONL, un registro por línea, con el ID del tweet en cada registro. JSONL se lee en flujo, admite añadir al final y se carga directo en pandas, en la biblioteca datasets de Hugging Face y en la mayoría de los scripts de entrenamiento. Qué campos van en cada línea depende de la tarea.

• Clasificador o modelo de temas

  Qué contiene cada línea JSONL

  id, text limpio, label, label_source, lang, created_at

• Conjunto de evaluación para un modelo o un prompt

  Qué contiene cada línea JSONL

  id, text, la respuesta esperada y la regla que se prueba

• Índice RAG para recuperación

  Qué contiene cada línea JSONL

  id, text, la URL del post, created_at y el ID del autor, para que las respuestas puedan citar el 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"
}

Entrega una ficha del dataset junto con los archivos: las consultas y fechas, el día en que reuniste o rehidrataste los datos, la tasa de recuperación, cómo se hicieron las etiquetas, qué se filtró y para qué no debe usarse el conjunto. Las fichas de dataset de Hugging Face siguen el mismo esquema, y la próxima persona que entrene con tus datos, muchas veces tú mismo dentro de seis meses, necesita cada línea.

#Cuánto cuesta un dataset de Twitter

Un dataset de 1M de tweets cuesta $5,000 en lecturas de posts en la API oficial de X, frente a desde $70 en Sorsa API por búsqueda o desde $14 cuando rehidratas IDs conocidos. Cambia el tamaño para ver los totales de una colección nueva por búsqueda.

Dos límites de la API oficial de X cambian las cuentas para los datasets. Su plan de pago por uso se detiene en 3M de lecturas de posts al mes, así que un conjunto de 10M de tweets exige un contrato Enterprise, al que remite la lista de precios de X (se abre en una pestaña nueva) por encima de ese tope. Y desde el 22 de noviembre de 2026, X también cobra como lectura de usuario el perfil del autor que vuelve con cada post, $0.010 más por post (el aviso de X (se abre en una pestaña nueva)). En Sorsa API el perfil completo del autor forma parte de cada tweet, y las solicitudes fallidas nunca se cobran.

El tiempo es la otra mitad del presupuesto. A 20 solicitudes por segundo, Sorsa API reúne unos 400 tweets por segundo por búsqueda y hasta 2,000 por segundo por ID, así que 1M de tweets nuevos toman unos 42 minutos y un conjunto de 10M de tweets unas 7 horas con una sola clave.

#Cómo compartir un dataset de tweets y entrenar con él

Los datasets públicos de investigación se distribuyen como IDs de tweets y de usuarios, y cualquiera que tenga los IDs recupera el texto completo con una API: Sorsa API rehidrata 1M de IDs en unos 8 minutos.

• Compartir. Publica los IDs de tweets y de usuarios con un script de rehidratación, como hacen los datasets públicos de investigación; POST /tweet-info-bulk convierte 100 IDs de nuevo en posts completos por solicitud.
• Entrenar. Conserva el texto completo que recopiles para tus propios modelos: los clasificadores, los modelos de temas, los conjuntos de evaluación, los índices de recuperación y el ajuste fino de modelos de lenguaje son los usos habituales de los datasets de tweets.
• Personas. Reemplaza los handles antes de entrenar, no guardes perfiles de personas concretas y elimina los tweets que sus autores borraron cuando actualices el conjunto.

Sorsa API devuelve solo datos públicos y nunca publica, da me gusta ni sigue. Las universidades con un proyecto de investigación también pueden consultar sobre el acceso académico a Sorsa API.

#Empieza tu dataset con una descarga de prueba

Los datasets públicos de Twitter te dan una línea base; uno nuevo te da tu propio tema, tus propias fechas y etiquetas que se ajustan a tu tarea. Créalo con Sorsa API: desde $0.07 por cada 1,000 tweets por búsqueda y desde $0.014 por cada 1,000 por ID, a 20 solicitudes por segundo, con el perfil del autor en cada tweet. Tus 100 solicitudes gratis reúnen los primeros 2,000 tweets, suficientes para probar la consulta, la limpieza y la división antes de pagar nada.

#Preguntas frecuentes