Cómo rehidratar IDs de tweets de X en bloque

#Qué significa rehidratar IDs de tweets

Rehidratar IDs de tweets es consultar cada ID de nuevo para obtener el tweet completo que hay detrás: el texto, la hora de publicación, los me gusta y las vistas, y el perfil del autor. Un ID de tweet es el número de 19 dígitos al final del enlace de cada post, y una lista de ellos se llama dataset deshidratado. Para ver cuándo se publicó un ID cualquiera antes de gastar una solicitud en él, pégalo en el Conversor de ID de tweet a fecha, gratuito.

Los datasets viajan como IDs sueltos por las reglas de X. La Política para desarrolladores de X (se abre en una pestaña nueva) permite compartir con otros IDs de posts y de usuarios, pero no los tweets en sí, y limita lo que entregas a un mismo destinatario a 1.5M de IDs de posts cada 30 días sin permiso escrito de X. Por eso casi toda lista que encuentres es solo de números:

• Archivos de investigación. Las colecciones sobre elecciones, crisis y COVID-19 en Harvard Dataverse, Zenodo o GitHub se publican como archivos de texto con IDs, a menudo con decenas de millones de líneas.
• Exportaciones de social listening. La API de Meltwater, por ejemplo, exporta los posts de X solo como un ID y un ID de autor y indica a sus clientes que los rehidraten (se abre en una pestaña nueva).
• Tus propios registros. Bases de datos, logs y hojas de cálculo antiguos que guardaron el ID y descartaron el texto.

La rehidratación devuelve el tweet tal como es hoy. Un post borrado desde que se recopiló, o de una cuenta que pasó a ser protegida o fue suspendida, regresa vacío, y las métricas y el perfil del autor que obtienes son valores actuales, no los del día en que se publicó. Por eso todo conjunto rehidratado es un poco más pequeño que la lista de la que partió.

#Cuánto cuesta y cuánto tarda

Rehidratar un millón de IDs de tweets cuesta $5,000 en la API oficial de X y desde $14 en Sorsa API, y ambas consultan 100 IDs por llamada. La diferencia está en la unidad: la tarifa de X (se abre en una pestaña nueva) cobra cada post que devuelve, $0.005 por cada uno, mientras que Sorsa API cobra una solicitud por lote de 100, sin importar lo que contenga.

Dos reglas más moldean el precio de la API oficial de X para listas grandes. El pago por uso se detiene en 3M de lecturas de posts por ciclo de facturación mensual; una lista mayor espera al mes siguiente o requiere un contrato Enterprise, desde unos $42,000 al mes. Y desde el 22 de noviembre de 2026, X cobra cada objeto que viaja junto mediante las expansiones (se abre en una pestaña nueva), así que cada perfil de autor que pides suma $0.010 a los $0.005 del post.

• 10K

  Sorsa API

  gratis (las 100 solicitudes del registro)

  Tiempo en Sorsa API a 20 solicitudes por segundo

  unos 5 segundos

  API oficial de X

  $50

• 100K

  Sorsa API

  desde $1.40

  Tiempo en Sorsa API a 20 solicitudes por segundo

  menos de un minuto

  API oficial de X

  $500

• 1M

  Sorsa API

  desde $14

  Tiempo en Sorsa API a 20 solicitudes por segundo

  unos 8 minutos

  API oficial de X

  $5,000

• 3M

  Sorsa API

  desde $42

  Tiempo en Sorsa API a 20 solicitudes por segundo

  unos 25 minutos

  API oficial de X

  $15,000, todo el tope mensual

• 10M

  Sorsa API

  desde $140

  Tiempo en Sorsa API a 20 solicitudes por segundo

  cerca de 1 hora 23 minutos

  API oficial de X

  Solo Enterprise, más de $42K al mes

Los precios "desde" de Sorsa API usan su tarifa más baja por solicitud; a la tarifa del plan Pro, un millón de IDs cuesta $19.90. Las solicitudes fallidas nunca se cobran, y el perfil completo del autor viene dentro de cada tweet sin costo adicional. Para la misma comparación en recopilación nueva por búsqueda, consulta cuánto cuesta 1 millón de tweets.

#Rehidrata IDs de tweets con Sorsa API

Para rehidratar IDs de tweets a escala, usa Sorsa API, una API y scraper de Twitter (X): POST /tweet-info-bulk (se abre en una pestaña nueva) acepta hasta 100 IDs o enlaces de posts por solicitud y devuelve cada tweet con el perfil completo de su autor, desde $0.014 por 1,000 IDs a 20 solicitudes por segundo en todos los planes. Necesita una sola clave de API, ninguna cuenta de desarrollador de X, ningún OAuth y jamás tu usuario de X.

1. Consigue una clave. Regístrate y copia la clave de API desde el panel. Las 100 solicitudes gratis rehidratan hasta 10K IDs.

2. Envía un lote. Pon hasta 100 IDs, como cadenas de texto, en el arreglo tweet_links. Los enlaces completos de posts también funcionan.

   curl -X POST "https://api.sorsa.io/v3/tweet-info-bulk" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"tweet_links": ["1856270992012337728",
          "1399991672632369728", "1496699442164785728"]}'
   

3. Lee los tweets. La respuesta es un solo arreglo tweets, sin paginar. Cada tweet trae su propio id, que es como lo asocias con el ID que enviaste.

   {
     "tweets": [
       {
         "id": "1856270992012337728",
         "full_text": "Day 3 of the field survey: river levels are normal.",
         "created_at": "2024-11-12T09:41:07Z",
         "lang": "en",
         "likes_count": 42,
         "retweet_count": 7,
         "reply_count": 3,
         "quote_count": 1,
         "view_count": 5210,
         "bookmark_count": 2,
         "conversation_id_str": "1856270992012337728",
         "is_reply": false,
         "is_quote_status": false,
         "user": {
           "id": "1497281610093821952",
           "username": "field_notes_demo01",
           "display_name": "Field Notes Demo",
           "followers_count": 1288,
           "protected": false,
           "verified": false
         }
       }
     ]
   }
   

   Ver respuesta completa

Un 403 significa que falta la clave o que se agotaron sus solicitudes; un 429 significa más de 20 solicitudes en un segundo, así que espera un segundo y envía el lote de nuevo. Las citas y los reposts llevan el tweet original anidado dentro (quoted_status, retweeted_status), una respuesta nombra el tweet al que contesta en in_reply_to_tweet_id y los enlaces de contenido multimedia están en entities.

Para tener en cuenta

Las métricas rehidratadas son las cifras de hoy. Un tweet de 2016 regresa con los me gusta y las vistas que tiene ahora y con el nombre, la bio y el número de seguidores actuales de su autor. Si tu estudio necesita los valores del día de la publicación, usa los contadores guardados en el dataset original, cuando los tenga.

#Limpia la lista de IDs antes de gastar una solicitud

La mayoría de las rehidrataciones fallidas empiezan en el archivo de IDs, no en la API. Un ID de tweet tiene 19 dígitos, más de lo que conserva una hoja de cálculo o un número flotante de 64 bits, así que una lista que pasó por Excel, por pandas con una columna flotante o por JSON.parse de JavaScript apunta a tweets que no existen. Una conocida pregunta de Stack Overflow sobre recuperar 18 tweets de 24K se debía a una lista de IDs dañada, no a la API.

Tres reglas mantienen la lista íntegra:

• Lee los IDs como texto. En pandas, pd.read_csv(path, dtype=str); en un archivo JSON, conserva el id_str o la forma de cadena; nunca abras el archivo sin procesar en Excel.
• Elimina primero los duplicados. Los datasets compartidos suelen repetir IDs entre archivos diarios, y cada duplicado desperdicia un espacio en un lote de 100.
• Detecta las líneas redondeadas. Un ID en notación científica (1.85627E+18) o que termina en una serie de ceros fue cortado por una hoja de cálculo. Vuelve a obtener esas líneas de la fuente original; ninguna API puede repararlas.

El planificador de abajo ejecuta esas comprobaciones sobre una muestra de tu lista en el navegador y calcula el precio del trabajo completo.

#Un trabajo reanudable para millones de IDs de tweets

Una lista de millones de IDs necesita un trabajo que corra a la velocidad máxima y sobreviva a una caída sin pagar dos veces. El script de abajo lee los IDs como texto, elimina duplicados, envía 20 lotes de 100 cada segundo, escribe los tweets a medida que llegan y registra cada lote terminado en progress.txt, de modo que una nueva ejecución parte donde se detuvo la anterior.

import json
import os
import time
from concurrent.futures import ThreadPoolExecutor

import requests

URL = "https://api.sorsa.io/v3/tweet-info-bulk"
HEADERS = {"ApiKey": os.environ.get("SORSA_API_KEY", "YOUR_API_KEY")}
BATCH, PER_SECOND = 100, 20


def load_ids(path):
    seen, ids = set(), []
    with open(path, encoding="utf-8") as f:
        for line in f:
            tid = line.strip().split("/status/")[-1].split("?")[0]
            if tid.isdigit() and tid not in seen:
                seen.add(tid)
                ids.append(tid)
    return ids


def lookup(batch):
    for attempt in range(5):
        r = requests.post(URL, headers=HEADERS, timeout=60,
                          json={"tweet_links": batch})
        if r.status_code == 429 or r.status_code >= 500:
            time.sleep(2 ** attempt)
            continue
        if r.status_code == 404:
            return []
        r.raise_for_status()
        return r.json().get("tweets", [])
    raise RuntimeError(f"batch starting {batch[0]} failed 5 times")


def run(ids):
    batches = [ids[i:i + BATCH] for i in range(0, len(ids), BATCH)]
    start = 0
    if os.path.exists("progress.txt"):
        start = int(open("progress.txt").read() or 0)
    with open("tweets.jsonl", "a", encoding="utf-8") as out, \
         open("missing_ids.txt", "a", encoding="utf-8") as miss, \
         ThreadPoolExecutor(max_workers=PER_SECOND) as pool:
        for k in range(start, len(batches), PER_SECOND):
            t0 = time.monotonic()
            group = batches[k:k + PER_SECOND]
            for batch, tweets in zip(group, pool.map(lookup, group)):
                got = {t["id"] for t in tweets}
                for t in tweets:
                    out.write(json.dumps(t, ensure_ascii=False) + "\n")
                for tid in batch:
                    if tid not in got:
                        miss.write(tid + "\n")
            out.flush()
            miss.flush()
            with open("progress.txt", "w") as p:
                p.write(str(k + len(group)))
            time.sleep(max(0, 1 - (time.monotonic() - t0)))


if __name__ == "__main__":
    ids = load_ids("tweet_ids.txt")
    run(ids)
    with open("tweets.jsonl", encoding="utf-8") as f:
        got = {json.loads(line)["id"] for line in f}
    print(f"recovered {len(got):,} of {len(ids):,} IDs "
          f"({len(got) / len(ids):.1%})")

Define la clave con export SORSA_API_KEY=..., pon un ID o un enlace de post por línea en tweet_ids.txt y ejecuta python rehydrate.py. A 20 solicitudes por segundo, un millón de IDs termina en unos 8 minutos y diez millones en menos de hora y media. Antes de una ejecución larga, GET /key-usage-info (se abre en una pestaña nueva) muestra cuántas solicitudes le quedan a la clave, y esa consulta es gratis.

#Por qué algunos tweets no regresan

Un ID de tweet no devuelve nada cuando el tweet ya no existe para el público: su autor lo borró, la cuenta pasó a ser protegida o fue suspendida o desactivada. Ninguna API los recupera; un ID que no devuelve nada es una respuesta, no un error, así que el script lo escribe en missing_ids.txt y sigue.

Cuánto se pierde depende de la antigüedad y el tema de la lista. Un conjunto recopilado el mes pasado puede regresar casi completo, mientras que los conjuntos de hace años sobre elecciones, conflictos o hashtags llenos de spam pierden mucho más, porque esas cuentas se suspenden o borran con más frecuencia. Mídelo en lugar de adivinar:

• Tasa de recuperación. Tweets devueltos dividido entre IDs únicos enviados, la última línea que imprime el script. Repórtala con la fecha en que rehidrataste, ya que la misma lista devuelve menos tweets cada año.
• Faltantes por período. Decodifica las fechas de los IDs faltantes (el planificador de arriba y la herramienta de ID a fecha las leen) para ver si las pérdidas se concentran en una semana o en un suceso.
• Dañados frente a desaparecidos. Los IDs redondeados también aparecen como faltantes. Revisa el archivo de faltantes en busca de series de ceros antes de contarlos como borrados.

Para un estudio publicado, conserva juntos la lista de IDs de la que partiste, la tasa de recuperación y la fecha de rehidratación: el próximo equipo que rehidrate la misma lista obtendrá un conjunto distinto, y esos tres datos explican la diferencia.

#Hydrator, twarc y otras herramientas en 2026

Las herramientas que antes rehidrataban datasets funcionaban todas con el acceso propio a la API de X, y la mayor parte de ese acceso ya no existe. Hydrator de DocNow, la app de escritorio a la que aún apuntan muchas guías de investigación, ahora abre su página de GitHub con un aviso de que las claves de aplicación en las que se apoyaba fueron revocadas y que la app ya no sirve.

El comando hydrate de twarc todavía funciona, pero solo con tu propio bearer token de la API oficial de X, así que se cobra a la tarifa de pago por uso de X: $5,000 por millón de posts, dentro del tope mensual de 3M. Los paquetes de R como rehydratoR y academictwitteR se escribieron para niveles de acceso gratuitos y para una vía de Investigación Académica que X cerró en 2023. Para probar primero unos pocos lotes a mano, el playground de la API ejecuta el mismo endpoint con tu clave y exporta a CSV. Si ya tienes un pipeline de twarc, el JSON que necesitas más adelante se parece mucho al que devuelve POST /tweet-info-bulk, así que lo que cambia es la función de solicitud, no todo el pipeline.

Para los equipos de investigación, Sorsa API también ofrece acceso académico, adaptado a cada proyecto y solicitado desde un correo institucional. La rehidratación es un paso de una construcción mayor: la recopilación por rango de fechas se trata en datos históricos de Twitter, y convertir un conjunto rehidratado en datos de entrenamiento etiquetados, en cómo crear un dataset de Twitter para machine learning.

#Rehidrata tus primeros 10K IDs de tweets

Rehidratar una lista de IDs de tweets es un trabajo por lotes de 100 IDs por llamada, y las únicas decisiones reales son el precio y la velocidad. En Sorsa API un millón de IDs cuesta desde $14 y tarda unos 8 minutos, frente a $5,000 y un tope mensual de 3M en la API oficial de X. Limpia una muestra de tu lista en el planificador, ejecuta los primeros 10K IDs con las 100 solicitudes gratis y revisa la tasa de recuperación antes de enviar el resto.

#Preguntas frecuentes