Scraper de imágenes de Twitter: descarga todas las imágenes

#Cómo funciona un scraper de imágenes de Twitter

Todo scraper de imágenes de Twitter hace las mismas tres cosas, sin importar en qué corra. Para un solo post no necesitas ninguna: pega su enlace en el Descargador de multimedia gratuito y guarda cada foto en tamaño completo. Para cientos o miles de imágenes, el trabajo es así:

1. Encuentra los posts que llevan fotos. El operador de búsqueda filter:images de X conserva solo los posts con al menos una imagen, de una cuenta con from: o de cualquier tema.

2. Lee el enlace de cada foto. Cada imagen está en el servidor de multimedia de X, en un enlace como https://pbs.twimg.com/media/G4kQ2vXbIAAm7Rz.jpg.

3. Descarga el original. Pide ese enlace con ?format=jpg&name=orig; sin eso, X envía una copia que cabe en 1,200 píxeles.

Las herramientas difieren en el paso 1, en de dónde salen los posts. x.com le muestra a un visitante sin sesión posts sueltos y unos pocos de los más recientes de un perfil, y envía la búsqueda a su página de inicio de sesión. Por eso las extensiones de navegador, los descargadores de escritorio y las herramientas de línea de comandos leen X a través de una cuenta con sesión iniciada. Su propia documentación lo dice: un descargador por lotes muy usado pide tu cookie auth_token y advierte que la cuenta puede ser suspendida.

Solo una API llega a las imágenes de una cuenta completa: la API oficial de X con una cuenta de desarrollador y OAuth, o una API de datos de Twitter/X con una sola clave.

La guía sobre cómo scrapear Twitter cubre todas las rutas y qué las rompe, y la comparativa de los mejores scrapers de Twitter pone precio a las herramientas una por una.

#Descarga todas las imágenes de una cuenta de X

Sorsa API, una API y scraper de Twitter (X), devuelve los posts con imágenes de una cuenta como JSON con el enlace de cada foto dentro, unos 20 posts por solicitud y hasta 2006. Cuatro pasos te llevan de un nombre de usuario a una carpeta de archivos originales.

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

2. Busca los posts con imágenes de la cuenta. Envía from: más filter:images a POST /search-tweets (se abre en una pestaña nueva), con order en latest para recibir primero los más recientes.

   curl -X POST "https://api.sorsa.io/v3/search-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"query": "from:northfield_photo_lab filter:images",
          "order": "latest"}'
   

   {
     "tweets": [
       {
         "id": "1984213377309245441",
         "created_at": "2026-10-30T14:12:09Z",
         "full_text": "Fog over the north ridge this morning.",
         "likes_count": 412,
         "entities": [
           {
             "type": "photo",
             "link": "https://pbs.twimg.com/media/G4kQ2vXbIAAm7Rz.jpg",
             "preview": "https://pbs.twimg.com/media/G4kQ2vXbIAAm7Rz.jpg"
           },
           {
             "type": "photo",
             "link": "https://pbs.twimg.com/media/G4kQ2vZaQAEw9Lp.jpg",
             "preview": "https://pbs.twimg.com/media/G4kQ2vZaQAEw9Lp.jpg"
           }
         ],
         "user": {
           "username": "northfield_photo_lab",
           "display_name": "Northfield Photo Lab",
           "media_count": 1840
         }
       }
     ],
     "next_cursor": "DAADDAABCgABG8vZ0Qm__-oKAAIbuv3MBVvA0AgAAwAAAAIAAA"
   }
   

   Ver respuesta completa

3. Sigue el cursor. Un cursor es un token que marca dónde empieza la siguiente página: envía next_cursor en el cuerpo de la siguiente solicitud hasta que vuelva vacío.

4. Guarda cada foto en su tamaño original. El script conserva solo las entidades photo, reescribe cada enlace a name=orig y nombra los archivos <post id>_<n>.jpg. Registra cada archivo en images.csv y guarda el cursor después de cada página, de modo que una ejecución detenida retoma donde se quedó.

   import csv
   import os
   import sys
   import time
   from urllib.parse import parse_qs, urlparse
   
   import requests
   
   API = "https://api.sorsa.io/v3/search-tweets"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   
   def orig(url):
       """Rewrite a pbs.twimg.com image link to its original size."""
       u = urlparse(url)
       path = u.path
       fmt = parse_qs(u.query).get("format", ["jpg"])[0]
       if "." in path.rsplit("/", 1)[-1]:
           path, fmt = path.rsplit(".", 1)
       fmt = fmt.split(":")[0]
       return f"https://pbs.twimg.com{path}?format={fmt}&name=orig", fmt
   
   
   def photo_urls(tweet):
       """Original-size links of every photo in a post."""
       for e in tweet.get("entities") or []:
           if e.get("type") != "photo":
               continue
           for link in (e.get("link"), e.get("preview")):
               if link and "pbs.twimg.com/media/" in link:
                   yield orig(link)
                   break
   
   
   def post(body):
       while True:
           r = requests.post(API, headers=HEADERS, json=body, timeout=60)
           if r.status_code == 429:  # over 20 requests a second: wait
               time.sleep(1)
               continue
           r.raise_for_status()  # 403: no key, or no requests left
           return r.json()
   
   
   def download(query, folder):
       os.makedirs(folder, exist_ok=True)
       state = os.path.join(folder, "cursor.txt")
       body = {"query": query, "order": "latest"}
       if os.path.exists(state):  # resume a stopped run
           body["next_cursor"] = open(state).read().strip()
       log_path = os.path.join(folder, "images.csv")
       with open(log_path, "a", newline="", encoding="utf-8") as f:
           log = csv.writer(f)
           while True:
               page = post(body)
               for t in page.get("tweets", []):
                   for n, (url, fmt) in enumerate(photo_urls(t), 1):
                       path = os.path.join(folder, f"{t['id']}_{n}.{fmt}")
                       if os.path.exists(path):
                           continue
                       img = requests.get(url, timeout=60)
                       img.raise_for_status()
                       with open(path, "wb") as out:
                           out.write(img.content)
                       log.writerow([t["id"], t["created_at"], url, path])
               cursor = page.get("next_cursor")
               if not cursor:
                   break
               body["next_cursor"] = cursor
               with open(state, "w") as s:
                   s.write(cursor)
       if os.path.exists(state):
           os.remove(state)
   
   
   if __name__ == "__main__":
       download(sys.argv[1], sys.argv[2])
   

   import fs from "node:fs";
   import path from "node:path";
   
   const API = "https://api.sorsa.io/v3/search-tweets";
   const HEADERS = {
     ApiKey: "YOUR_API_KEY",
     "Content-Type": "application/json",
   };
   
   // Rewrite a pbs.twimg.com image link to its original size.
   function orig(link) {
     const u = new URL(link);
     let p = u.pathname;
     let fmt = u.searchParams.get("format") || "jpg";
     if (p.split("/").pop().includes(".")) {
       fmt = p.slice(p.lastIndexOf(".") + 1);
       p = p.slice(0, p.lastIndexOf("."));
     }
     fmt = fmt.split(":")[0];
     return [`https://pbs.twimg.com${p}?format=${fmt}&name=orig`, fmt];
   }
   
   function* photoUrls(tweet) {
     for (const e of tweet.entities ?? []) {
       if (e.type !== "photo") continue;
       const link = [e.link, e.preview]
         .find((l) => l?.includes("pbs.twimg.com/media/"));
       if (link) yield orig(link);
     }
   }
   
   async function post(body) {
     for (;;) {
       const r = await fetch(API, {
         method: "POST", headers: HEADERS, body: JSON.stringify(body),
       });
       if (r.status === 429) {          // over 20 requests a second: wait
         await new Promise((ok) => setTimeout(ok, 1000));
         continue;
       }
       if (!r.ok) throw new Error(`HTTP ${r.status}`); // 403: key or quota
       return r.json();
     }
   }
   
   async function download(query, folder) {
     fs.mkdirSync(folder, { recursive: true });
     const body = { query, order: "latest" };
     const log = path.join(folder, "images.csv");
     for (;;) {
       const page = await post(body);
       for (const t of page.tweets ?? []) {
         let n = 0;
         for (const [url, fmt] of photoUrls(t)) {
           const file = path.join(folder, `${t.id}_${++n}.${fmt}`);
           if (fs.existsSync(file)) continue;
           const img = await fetch(url);
           if (!img.ok) throw new Error(`HTTP ${img.status} for ${url}`);
           fs.writeFileSync(file, Buffer.from(await img.arrayBuffer()));
           fs.appendFileSync(log, `${t.id},${t.created_at},${url},${file}\n`);
         }
       }
       if (!page.next_cursor) break;
       body.next_cursor = page.next_cursor;
     }
   }
   
   await download(process.argv[2], process.argv[3]);
   

Ejecútalo con una búsqueda y un nombre de carpeta: python twitter_images.py "from:northfield_photo_lab filter:images" northfield_photo_lab. Una respuesta 403 significa que falta la clave o que se quedó sin solicitudes; un 429 significa más de 20 solicitudes en un segundo, y el script espera un segundo y lo intenta de nuevo. Los archivos que ya están en disco se omiten, así que volver a ejecutar el mismo comando solo agrega las imágenes nuevas.

Para tener en cuenta

Una cita o un retweet lleva fotos de otra persona: están en quoted_status.entities y retweeted_status.entities, y el script las deja fuera. Agrega esas dos listas a photo_urls para conservarlas. Para dimensionar primero el trabajo, GET /info (se abre en una pestaña nueva) devuelve el media_count de la cuenta, las fotos y videos que ha publicado.

Para recorrer el timeline de la cuenta post por post en lugar de buscarlo, envía el nombre de usuario a POST /user-tweets (se abre en una pestaña nueva). Devuelve los mismos objetos de tweet, 20 por solicitud, así que photo_urls lee sus imágenes sin cambios; también llegan los posts de solo texto, así que el trabajo toma más solicitudes.

#Scrapea las imágenes de un hashtag o una búsqueda

El mismo script reúne las imágenes de cualquier tema: solo cambia la consulta. filter:images se combina con todos los operadores de búsqueda de X, y la búsqueda llega hasta 2006.

• Un hashtag

  Consulta

  #nightphotography filter:images

• Una palabra clave en un mes

  Consulta

  aurora filter:images since:2026-10-01 until:2026-11-01

• Solo imágenes populares

  Consulta

  #interiordesign filter:images min_faves:500

• Una cuenta sin sus respuestas

  Consulta

  from:northfield_photo_lab filter:images -filter:replies

• Varias cuentas a la vez

  Consulta

  (from:northfield_photo_lab OR from:harborline_studio_co) filter:images

Para un tema grande, ejecuta una ventana de fechas por mes en su propia carpeta. Cada ejecución sigue siendo corta, una que falle es fácil de repetir y las ventanas corren en paralelo con una sola clave, hasta 20 solicitudes por segundo en todos los planes. Fija order en popular para recibir primero los posts destacados de X o en latest para los más recientes. Todos los operadores, con ejemplos, están en la guía de operadores de búsqueda de Twitter.

Las imágenes de un hashtag cambian a medida que la gente publica, así que un trabajo de monitoreo vuelve a ejecutar la ventana más reciente con un calendario. Como el script omite los archivos que ya tiene y registra solo los nuevos, cada nueva ejecución agrega solo las imágenes publicadas desde la anterior.

#Obtén cada imagen en su tamaño original

X conserva cada archivo subido completo pero sirve copias más pequeñas, y la copia que recibes depende solo del valor de name en el enlace. El 2 de noviembre de 2026 pedimos cuatro imágenes públicas en todos los tamaños que sirve X y medimos lo que volvió; la escalera de abajo es una foto publicada a finales de octubre de 2026.

• El enlace simple es la copia medium. Un enlace de pbs.twimg.com sin name devuelve una imagen que cabe en 1,200 píxeles.
• large se detiene en 2,048 píxeles y 4096x4096 en 4,096. Un archivo subido más pequeño que eso vuelve en su propio tamaño.
• name=orig devuelve el archivo subido tal cual. Para la foto de arriba eso fue 8,000 × 4,501 píxeles, 44 veces los píxeles del enlace simple.
• format=png no agrega detalle. Recodifica un archivo JPG como un PNG varias veces más grande, y format=png&name=orig devuelve 404 para un JPG, así que conserva el formato que ya tiene el enlace.

Descargar desde pbs.twimg.com es una solicitud HTTP simple sin clave, así que los archivos en sí no cuestan solicitudes de la API: solo cuesta encontrar los posts.

#Descarga imágenes de forma masiva sin código

Sin código, el trabajo se divide en dos: exportar los enlaces de las imágenes y luego descargar los archivos.

1. Exporta los enlaces de los posts recientes. La herramienta gratuita Exportar tweets guarda los últimos posts de una cuenta como CSV, Excel o JSON con una columna media_urls; activa Solo posts con multimedia.

2. Exporta una cuenta o búsqueda completa. En el playground de la API, ejecuta POST /search-tweets con tu clave y una consulta como from:northfield_photo_lab filter:images; sigue el cursor por ti y exporta cada página a CSV o JSON.

3. Convierte los enlaces en originales. Pega los enlaces de las imágenes en el convertidor de abajo y copia los enlaces de tamaño original que devuelve.

4. Descarga la lista. Carga los enlaces en cualquier gestor de descargas que acepte una lista de URL, y guarda los archivos en una sola ejecución.

   Enlaces de imágenes de X https://pbs.twimg.com/media/G4kQ2vXbIAAm7Rz.jpg https://pbs.twimg.com/media/G4kQ2vZaQAEw9Lp?format=jpg&name=small https://pbs.twimg.com/media/G4jx81-WgAA0nHc.png:large

   Uno por línea, o pega una columna completa de un CSV.

   Enlaces a tamaño original 3 enlaces

   https://pbs.twimg.com/media/G4kQ2vXbIAAm7Rz?format=jpg&name=orig https://pbs.twimg.com/media/G4kQ2vZaQAEw9Lp?format=jpg&name=orig https://pbs.twimg.com/media/G4jx81-WgAA0nHc?format=png&name=orig

   Copiar enlaces

   Pega cualquier cantidad de enlaces de pbs.twimg.com, uno por línea o directo de una columna de CSV; nada sale de tu navegador.

#Cuánto cuesta una descarga masiva de imágenes

En Sorsa API, los posts con imágenes cuestan desde $0.07 por cada 1,000, porque una página de búsqueda de unos 20 posts es una solicitud sin importar cuántas fotos contenga. En la API oficial de X, los enlaces de imágenes llegan solo mediante su expansion de multimedia. Desde el 22 de noviembre de 2026, X cobra cada imagen expandida (se abre en una pestaña nueva) a $0.005 además de los $0.005 de la lectura del post: $10.00 por cada 1,000 posts con una imagen, $25.00 cuando cada uno lleva cuatro.

Puestas lado a lado, las formas de obtener los posts difieren tanto en lo que te exigen como en el precio.

• Sorsa API

  Qué necesita

  Una clave de API

  Costo por cada 1,000 posts con imágenes

  desde $0.07

• API oficial de X

  Qué necesita

  Cuenta de desarrollador y OAuth

  Costo por cada 1,000 posts con imágenes

  $10.00 desde el 22 de nov. de 2026 (post y una imagen)

• Extensiones y descargadores

  Qué necesita

  Tu inicio de sesión de X o tu cookie de sesión

  Costo por cada 1,000 posts con imágenes

  Gratis o una suscripción, con la cuenta en riesgo

El precio de pago por uso (se abre en una pestaña nueva) de la API oficial de X también se detiene en 3M de lecturas de posts por ciclo de facturación; por encima de eso, X vende solo contratos Enterprise. En Sorsa API las 100 solicitudes gratis cubren unos 2,000 posts con imágenes, las solicitudes fallidas nunca se cobran y la tarifa del plan por cada 1,000 solicitudes se aplica a todos los endpoints.

El tiempo se deduce del límite de solicitudes, 20 por segundo por clave en todos los planes. 1M de posts con imágenes toman 50K solicitudes, unos 42 minutos cuando las ventanas de fechas corren en paralelo; los archivos de imagen se descargan luego directo de los servidores de X a la velocidad de tu conexión.

#Obtén las imágenes de posts específicos

Para obtener las imágenes de posts que ya tienes, envía sus enlaces o IDs a POST /tweet-info-bulk (se abre en una pestaña nueva): hasta 100 posts por solicitud, desde $0.014 por cada 1,000, con la misma lista entities que devuelve la búsqueda.

curl -X POST "https://api.sorsa.io/v3/tweet-info-bulk" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"tweet_links": [
        "https://x.com/northfield_photo_lab/status/1984213377309245441",
        "1983850021164118016"]}'

Un solo post va a POST /tweet-info (se abre en una pestaña nueva) con tweet_link. Pasa el enlace de cada foto por la misma función orig y tendrás los archivos en tamaño completo. En la API oficial de X la misma consulta necesita un bearer token más expansions=attachments.media_keys y media.fields=url, y desde el 22 de noviembre cada imagen de la respuesta suma $0.005.

Los videos y GIF llegan en la misma lista entities bajo su propio type. Sus archivos MP4 y variantes de calidad requieren un paso más, que cubre la guía para descargar multimedia de Twitter por API; para exportaciones de texto completo con una columna de multimedia, consulta cómo descargar todos los tweets de un usuario.

#Empieza tu primera descarga de imágenes

Para descargar todas las imágenes de una cuenta o búsqueda de X en tamaño completo, usa Sorsa API: unos 20 posts con imágenes por solicitud desde $0.07 por cada 1,000, sin riesgo para tu cuenta de X. Copia el script, agrega tu clave y tus 100 solicitudes gratis descargan los primeros 2,000 posts con imágenes.

#Preguntas frecuentes