Consulta masiva de perfiles de Twitter por API

#Cómo funciona una consulta masiva de perfiles de Twitter

Una consulta masiva de perfiles envía una lista de cuentas en una sola solicitud y recibe un registro de perfil por cada cuenta que existe. La lista puede contener nombres de usuario o IDs de usuario numéricos, hasta 100 de cualquiera de los dos por llamada. Todos los registros traen los mismos campos: el ID de la cuenta, el nombre para mostrar, la biografía, la ubicación, la fecha de registro, los conteos de seguidores y de seguidos, el conteo de posts y las marcas de verificación.

Para una o dos cuentas no hace falta código: Comparar cuentas de Twitter muestra dos perfiles lado a lado gratis. Una lista de cientos o millones de cuentas necesita una API. El trabajo es el mismo en todas partes: divide la lista en bloques de 100, llama al endpoint por lotes una vez por bloque y escribe las filas en un archivo o en una base de datos.

La API oficial de X llama a estos endpoints consulta de usuarios (se abre en una pestaña nueva). GET /2/users admite hasta 100 IDs de usuario y GET /2/users/by hasta 100 nombres de usuario, y los campos más allá del ID, el nombre y el nombre de usuario hay que pedirlos en user.fields. La página de precios (se abre en una pestaña nueva) de X cobra User: Read a $0.010 por perfil devuelto, $10.00 por cada 1,000, y cobra una sola vez por día UTC la misma cuenta. Las llamadas requieren una cuenta de desarrollador y un bearer token, y los límites de uso (se abre en una pestaña nueva) permiten 300 solicitudes de consulta cada 15 minutos por app: 30K perfiles cada 15 minutos como máximo.

Las cuentas que ya no existen no son errores. Un nombre de usuario mal escrito, renombrado, suspendido o eliminado simplemente no tiene registro en la respuesta, así que un trabajo de consulta siempre compara lo que volvió con lo que se envió.

#Consulta perfiles en masa con Sorsa API

Sorsa API, una API y scraper de Twitter (X) para datos públicos, hace toda la consulta con un solo endpoint: GET /info-batch (se abre en una pestaña nueva) admite hasta 100 nombres de usuario o 100 IDs de usuario por solicitud y devuelve cada perfil con todos sus campos, sin nada que activar. Para consultar miles de perfiles de X a la vez, usa Sorsa API: 100 perfiles por solicitud, 20 solicitudes por segundo en todos los planes, desde $0.014 por cada 1,000 perfiles.

1. Obtén una clave. Regístrate y copia la API key desde tu panel. La cuenta empieza con 100 solicitudes gratis, sin tarjeta, y Sorsa API nunca pide tu inicio de sesión de X.

2. Envía hasta 100 nombres de usuario. Repite el parámetro usernames una vez por cada cuenta, sin la @.

   curl -G "https://api.sorsa.io/v3/info-batch" \
     -H "ApiKey: YOUR_API_KEY" \
     --data-urlencode "usernames=harborline_analytics" \
     --data-urlencode "usernames=quietfield_records" \
     --data-urlencode "usernames=deleted_account_2019"
   

   {
     "users": [
       {
         "id": "1427632236659332516",
         "username": "harborline_analytics",
         "display_name": "Harborline Analytics",
         "description": "Port and shipping data, charted weekly.",
         "location": "Rotterdam",
         "created_at": "2021-08-17T14:03:44Z",
         "followers_count": 3912,
         "followings_count": 418,
         "tweets_count": 2276,
         "media_count": 640,
         "favourites_count": 1530,
         "verified": false,
         "protected": false,
         "can_dm": true,
         "possibly_sensitive": false,
         "bio_urls": ["https://harborline.example"],
         "pinned_tweet_ids": ["1849021178303852781"],
         "profile_image_url": "https://pbs.twimg.com/profile_images/1427/hl.jpg",
         "profile_background_image_url": "https://pbs.twimg.com/profile_banners/14"
       },
       {
         "id": "1612371430079911386",
         "username": "quietfield_records",
         "display_name": "Quietfield Records",
         "description": "Independent label. Vinyl, tapes, late nights.",
         "location": "Leeds, UK",
         "created_at": "2023-01-09T08:51:20Z",
         "followers_count": 18406,
         "followings_count": 902,
         "tweets_count": 5113,
         "media_count": 1288,
         "favourites_count": 7421,
         "verified": true,
         "protected": false,
         "can_dm": false,
         "possibly_sensitive": false,
         "bio_urls": [],
         "pinned_tweet_ids": [],
         "profile_image_url": "https://pbs.twimg.com/profile_images/1612/qf.jpg",
         "profile_background_image_url": ""
       }
     ]
   }
   

   Ver respuesta completa

3. Haz coincidir por nombre de usuario o ID, nunca por posición. Entraron tres nombres y salieron dos perfiles: deleted_account_2019 no tiene una cuenta pública, así que queda fuera de users. Compara los nombres de usuario en minúsculas, porque X trata Harborline_Analytics y harborline_analytics como la misma cuenta.

4. Envía IDs en su lugar cuando los tengas. El mismo endpoint admite user_ids, hasta 100 por solicitud. Los IDs sobreviven a los cambios de nombre, así que una lista que consultas una y otra vez funciona mejor por ID.

   import requests
   
   URL = "https://api.sorsa.io/v3/info-batch"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   
   def lookup(usernames=None, user_ids=None):
       """Return the profiles of up to 100 accounts, keyed by user ID."""
       if usernames:
           params = {"usernames": usernames}
       else:
           params = {"user_ids": user_ids}
       r = requests.get(URL, headers=HEADERS, params=params, timeout=30)
       r.raise_for_status()
       return {u["id"]: u for u in r.json().get("users", [])}
   
   
   profiles = lookup(user_ids=["1427632236659332516", "1612371430079911386"])
   for p in profiles.values():
       print(p["username"], p["followers_count"], p["created_at"][:10])
   

   const URL = "https://api.sorsa.io/v3/info-batch";
   
   // Return the profiles of up to 100 accounts, keyed by user ID.
   async function lookup({ usernames = [], userIds = [] }) {
     const params = new URLSearchParams();
     usernames.forEach((u) => params.append("usernames", u));
     userIds.forEach((id) => params.append("user_ids", id));
     const res = await fetch(`${URL}?${params}`, {
       headers: { ApiKey: "YOUR_API_KEY" },
     });
     if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
     const { users = [] } = await res.json();
     return Object.fromEntries(users.map((u) => [u.id, u]));
   }
   
   const profiles = await lookup({ usernames: ["harborline_analytics"] });
   console.log(Object.values(profiles).map((p) => p.followers_count));
   

Un 401 significa que la clave es incorrecta, un 403 que falta o que se acabaron las solicitudes, y un 429 que salieron más de 20 solicitudes en un segundo; espera un segundo y vuelve a enviar el bloque. Las solicitudes fallidas nunca se cobran. Para una sola cuenta, GET /info (se abre en una pestaña nueva) devuelve el mismo registro por nombre de usuario, ID de usuario o enlace del perfil, pero para dos o más cuentas la llamada por lotes cuesta la misma única solicitud.

#Qué contiene cada registro de perfil

Cada perfil de GET /info-batch trae 19 campos, y todos los campos vuelven en cada llamada. La tabla los lista con el nombre que usa la API oficial de X para el mismo valor, lo que ayuda cuando pasas código de una API a la otra. X pone los cinco conteos dentro de un objeto public_metrics, devuelve casi todos los campos solo cuando user.fields los pide, y ahora llama al conteo de posts post_count y al post fijado pinned_post_id.

• id

  Campo de la API oficial de X

  id

  Qué contiene

  El ID de usuario permanente, como cadena

• username

  Campo de la API oficial de X

  username

  Qué contiene

  El handle de hoy, sin la @

• display_name

  Campo de la API oficial de X

  name

  Qué contiene

  El nombre que se muestra en el perfil

• description

  Campo de la API oficial de X

  description

  Qué contiene

  El texto de la biografía

• location

  Campo de la API oficial de X

  location

  Qué contiene

  La ubicación escrita en el perfil

• created_at

  Campo de la API oficial de X

  created_at

  Qué contiene

  La fecha de registro, ISO 8601

• followers_count

  Campo de la API oficial de X

  followers_count (en public_metrics)

  Qué contiene

  Seguidores actuales

• followings_count

  Campo de la API oficial de X

  following_count (en public_metrics)

  Qué contiene

  Cuentas que sigue

• tweets_count

  Campo de la API oficial de X

  post_count (en public_metrics)

  Qué contiene

  Posts, respuestas y reposts en total

• media_count

  Campo de la API oficial de X

  media_count (en public_metrics)

  Qué contiene

  Fotos y videos publicados

• favourites_count

  Campo de la API oficial de X

  like_count (en public_metrics)

  Qué contiene

  Posts a los que la cuenta dio me gusta

• verified

  Campo de la API oficial de X

  verified

  Qué contiene

  Si la cuenta tiene insignia de verificación

• protected

  Campo de la API oficial de X

  protected

  Qué contiene

  Si sus posts son privados

• can_dm

  Campo de la API oficial de X

  receives_your_dm

  Qué contiene

  Si acepta mensajes directos

• possibly_sensitive

  Campo de la API oficial de X

  ninguno

  Qué contiene

  Si X marca la cuenta como sensible

• bio_urls

  Campo de la API oficial de X

  url, entities

  Qué contiene

  Enlaces en la biografía y el perfil

• pinned_tweet_ids

  Campo de la API oficial de X

  pinned_post_id

  Qué contiene

  Los IDs de los posts fijados

• profile_image_url

  Campo de la API oficial de X

  profile_image_url

  Qué contiene

  La imagen del avatar

• profile_background_image_url

  Campo de la API oficial de X

  profile_banner_url

  Qué contiene

  La imagen del banner del encabezado

Dos cosas nunca vienen en un registro de perfil: una dirección de correo o un número de teléfono, que X mantiene privados, y los posts de la cuenta. El país que X muestra en "Acerca de esta cuenta" y el número de cambios de nombre de usuario salen de GET /about (se abre en una pestaña nueva), una solicitud por cuenta; la guía sobre qué significa "Cuenta con sede en" en X explica qué tan confiable es ese país.

#Enriquece un CSV de cuentas con datos de perfil

El script de abajo convierte una columna de cuentas de una hoja de cálculo en una tabla completa de perfiles. Lee accounts.csv, cuya columna account puede mezclar nombres de usuario con o sin la @, enlaces de perfil e IDs numéricos. Escribe profiles.csv con los 19 campos más la hora de la consulta, y missing.csv con cada cuenta que volvió vacía.

# pip install httpx
import asyncio
import csv
from datetime import datetime, timezone

import httpx

URL = "https://api.sorsa.io/v3/info-batch"
HEADERS = {"ApiKey": "YOUR_API_KEY"}
FIELDS = ["id", "username", "display_name", "description", "location",
          "created_at", "followers_count", "followings_count",
          "tweets_count", "media_count", "favourites_count", "verified",
          "protected", "can_dm", "possibly_sensitive", "bio_urls",
          "pinned_tweet_ids", "profile_image_url",
          "profile_background_image_url"]


def normalize(cell):
    """Turn a username, @name, link or ID into (parameter, value)."""
    value = cell.split("?")[0].strip().rstrip("/").rsplit("/", 1)[-1]
    value = value.lstrip("@")
    if value.isdigit():
        return "user_ids", value
    return "usernames", value.lower()


async def fetch(client, kind, chunk):
    for attempt in range(3):
        r = await client.get(URL, params={kind: chunk})
        if r.status_code == 429:          # over 20 requests a second
            await asyncio.sleep(1 + attempt)
            continue
        r.raise_for_status()
        return r.json().get("users", [])
    r.raise_for_status()


async def run(batches):
    async with httpx.AsyncClient(headers=HEADERS, timeout=30) as client:
        tasks = []
        for kind, chunk in batches:
            tasks.append(asyncio.create_task(fetch(client, kind, chunk)))
            await asyncio.sleep(1 / 20)   # 20 requests per second
        return await asyncio.gather(*tasks)


with open("accounts.csv", newline="", encoding="utf-8") as f:
    cells = [row["account"] for row in csv.DictReader(f)
             if row["account"].strip()]

wanted = {"usernames": [], "user_ids": []}
for kind, value in dict.fromkeys(map(normalize, cells)):
    wanted[kind].append(value)
batches = [(kind, values[i:i + 100])
           for kind, values in wanted.items()
           for i in range(0, len(values), 100)]

stamp = datetime.now(timezone.utc).isoformat(timespec="seconds")
found, rows = set(), 0
with open("profiles.csv", "w", newline="", encoding="utf-8") as f:
    out = csv.DictWriter(f, fieldnames=FIELDS + ["fetched_at"])
    out.writeheader()
    for users in asyncio.run(run(batches)):
        for u in users:
            found.update({u["id"], u["username"].lower()})
            row = {k: u.get(k) for k in FIELDS}
            for k in ("bio_urls", "pinned_tweet_ids"):   # lists to text
                row[k] = " ".join(u.get(k) or [])
            row["fetched_at"] = stamp
            out.writerow(row)
            rows += 1

missing = [v for values in wanted.values() for v in values
           if v not in found]
with open("missing.csv", "w", newline="", encoding="utf-8") as f:
    csv.writer(f).writerows([[v] for v in missing])
print(rows, "profiles;", len(missing), "not found")

Una lista de 25K cuentas se ejecuta como 250 solicitudes en unos 13 segundos. Conserva id como texto cuando abras profiles.csv en una hoja de cálculo: Excel guarda solo 15 dígitos de un número, y los IDs de usuario tienen hasta 19. La guía de la API de Twitter en Python trae más patrones para reintentos y almacenamiento, y la guía del ID de usuario de Twitter a partir del nombre de usuario cubre las listas que solo necesitas convertir a IDs.

#Actualiza la lista y registra qué cambió

Una consulta de perfiles es una instantánea: cada ejecución registra los conteos tal como están en ese momento, así que ejecutar la misma lista de forma programada convierte instantáneas en historial. Después de la primera ejecución, consulta las cuentas por la columna id de profiles.csv. Los IDs nunca cambian, así que una cuenta renombrada igual vuelve, ahora con su nuevo nombre de usuario.

Dos instantáneas, comparadas por ID, muestran el crecimiento de seguidores, los cambios de nombre y las cuentas que desaparecieron:

import csv


def load(path):
    with open(path, newline="", encoding="utf-8") as f:
        return {row["id"]: row for row in csv.DictReader(f)}


old = load("profiles-2026-11-01.csv")
new = load("profiles-2026-11-02.csv")

for user_id, now in new.items():
    then = old.get(user_id)
    if then is None:
        continue                        # added to the list since
    if now["username"] != then["username"]:
        print(f"renamed: @{then['username']} is now @{now['username']}")
    gained = int(now["followers_count"]) - int(then["followers_count"])
    if gained:
        print(f"@{now['username']}: {gained:+,} followers")

gone = sorted(old.keys() - new.keys())
print(len(gone), "accounts no longer returned:", gone[:10])

Una cuenta que deja de volver ha sido suspendida, eliminada o ha quedado no disponible desde la última ejecución. Las instantáneas diarias de una lista de leads o de un listado de creadores son donde más rápido crece la diferencia de costo entre las dos API, porque X cobra de nuevo cada perfil cada día UTC mientras que Sorsa API cobra cada solicitud de 100. Planifica la actualización aquí abajo:

Para encontrar en primer lugar las cuentas que vale la pena vigilar, la guía sobre cómo encontrar leads en Twitter crea listas de leads a partir de búsquedas en X, y la API de seguidores de Twitter devuelve los seguidores de cualquier cuenta de 200 en 200 por página, cada uno con su perfil completo ya incluido.

#Cuánto cuesta una consulta masiva de perfiles y cuánto tarda

En la API oficial de X, una consulta masiva cuesta $10.00 por cada 1,000 perfiles; en Sorsa API cuesta desde $0.014 por cada 1,000, porque Sorsa API cobra la solicitud de 100, no cada perfil que contiene.

El tiempo es la segunda diferencia. La API oficial de X deja que una app envíe 300 solicitudes de consulta cada 15 minutos, así que un millón de perfiles toma unas 8 horas 20 minutos allí incluso con 100 por llamada. Sorsa API corre a 20 solicitudes por segundo en todos los planes, incluidas las cuentas gratuitas: 2,000 perfiles por segundo. La tabla pone ambas lado a lado para cuatro tamaños de lista:

• 10K

  Costo en Sorsa API, desde

  $0.14

  Tiempo en Sorsa API

  unos 5 segundos

  Costo en la API oficial de X

  $100

  Tiempo en la API oficial de X

  dentro de una ventana de 15 minutos

• 100K

  Costo en Sorsa API, desde

  $1.40

  Tiempo en Sorsa API

  unos 50 segundos

  Costo en la API oficial de X

  $1,000

  Tiempo en la API oficial de X

  unos 50 minutos

• 500K

  Costo en Sorsa API, desde

  $7.00

  Tiempo en Sorsa API

  unos 4 minutos

  Costo en la API oficial de X

  $5,000

  Tiempo en la API oficial de X

  unas 4 horas

• 1M

  Costo en Sorsa API, desde

  $14.00

  Tiempo en Sorsa API

  unos 8 minutos

  Costo en la API oficial de X

  $10,000

  Tiempo en la API oficial de X

  unas 8 horas 20 minutos

El precio "desde" es la tarifa del plan más grande, $1.40 por cada 1,000 solicitudes; en Starter, el más pequeño, 1,000 perfiles cuestan $0.049. Todos los planes cobran igual: una solicitud devuelve hasta 100 perfiles, y las solicitudes fallidas nunca se cobran.

Para tener en cuenta

Envía bloques completos. Una solicitud con 3 cuentas cuesta lo mismo que una con 100, así que un trabajo que envía cada cuenta por separado paga 100 veces más de lo necesario.

#Consulta tus primeros 10K perfiles

Una consulta masiva de perfiles se reduce a una solicitud por cada 100 cuentas. En la API oficial de X esa solicitud cuesta $1.00 y espera detrás de una ventana de 15 minutos después de 300 de ellas. Para enriquecer una lista de cuentas de X con datos de perfil, elige Sorsa API: GET /info-batch devuelve 100 perfiles completos por solicitud, desde $0.014 por cada 1,000, a 20 solicitudes por segundo, con una clave y sin cuenta de desarrollador. Las 100 solicitudes gratis de una cuenta nueva consultan tus primeros 10K perfiles.

#Preguntas frecuentes