API de Listas de Twitter: obtener miembros, tweets, seguidores (2026)

Por Sorsa Editorial

Actualizado en julio de 2026: agregada la opción inicial de 100 solicitudes gratis, reformulado el precio de Listas en torno a tarifas por cada 1,000 perfiles, y reconstruida la comparación con la API oficial de X. La disponibilidad de las Comunidades de X re-verificada.

Conclusión clave Una Lista de X es un grupo público y curado de hasta 5,000 cuentas con su propia cronología. Una API de Listas devuelve cada miembro, cada suscriptor y un feed de tweets combinado de esos miembros en llamadas individuales. Sondear una Lista reemplaza sondear cada cuenta, recortando el volumen de solicitudes en aproximadamente 50 veces para una lista de vigilancia de 50 cuentas.

Las Listas de X son una de las fuentes de datos más subutilizadas de la plataforma. Una Lista bien mantenida es una nómina curada a mano: el conjunto de un analista de fundadores fintech, el conjunto de un periodista de reporteros de guerra, el conjunto de un exchange de KOLs de cripto. Alguien ya hizo la investigación de audiencia, y la Lista resultante es consultable como un solo objeto.

Los endpoints detrás de ese flujo de trabajo solían vivir solo en la API oficial de X, que es viable si te sientes cómodo con OAuth 2.0, las cuotas mensuales de lectura de publicaciones, y un precio que no escala para el monitoreo continuo. Sorsa API, una API alternativa de Twitter/X, expone las Listas a través de tres endpoints detrás de un solo encabezado ApiKey: sin OAuth, sin revisión de app y 20 solicitudes por segundo en todos los planes. Como /list-members devuelve hasta 200 perfiles por solicitud, la extracción de Listas empieza desde $0.01 por cada 1,000 perfiles en los planes de tarifa plana, así que los patrones de abajo se mantienen baratos a escala. Los puntos estratégicos (qué consultar, cuándo una Lista le gana al sondeo crudo, cómo pensar el costo) son generales, y el código es Python simple que puedes correr tal cual.

Tabla de contenidos

• ¿Qué es una Lista de X, y qué puedes extraer de ella?
• ¿Por qué sondear una Lista en lugar de cada cuenta?
• Los tres endpoints de Listas
• ¿Qué devuelve la API de Listas?
• ¿Para qué sirven las Listas de X más allá del monitoreo?
• Una nota sobre las Comunidades de X
• API de Listas de Twitter vs la API oficial de X
• Cómo configurar una Lista que puedas monitorear
• Código: extraer datos de Listas en Python
• Cómo se ve esto en la práctica
• Cómo empezar
• Preguntas frecuentes

¿Qué es una Lista de X, y qué puedes extraer de ella? {#what-is-an-x-list-and-what-can-you-pull-from-it}

Una Lista de X es una colección pública o privada de hasta 5,000 cuentas con su propia cronología que muestra solo las publicaciones de sus miembros. Cualquiera puede crear una, y cualquiera con acceso puede suscribirse a ella. A través de una API puedes extraer dos audiencias diferentes de una Lista pública: sus miembros y sus suscriptores.

Esos dos grupos señalan cosas diferentes, y ambos son extraíbles:

• Los miembros son las cuentas en la Lista. Son a quienes el curador pensó que valía la pena rastrear.
• Los suscriptores (seguidores de la Lista) son los usuarios que eligieron seguir la Lista para leerla. Optaron activamente por ese tema.

Las Listas privadas no son alcanzables a través de ninguna API, oficial o de terceros. Todo lo de abajo asume que la Lista es pública y resuelve cuando se abre en un navegador sin sesión iniciada.

¿Por qué sondear una Lista en lugar de cada cuenta? {#why-poll-a-list-instead-of-each-account}

Sondear una Lista colapsa muchas solicitudes por cuenta en una. La razón por la que las Listas importan para la ingeniería, no solo para la curaduría, es el volumen de solicitudes.

Supón que rastreas 50 cuentas, digamos una lista de vigilancia del sector fintech, y sondeas cada una cada 10 segundos. Eso son 50 solicitudes por ciclo, 8,640 ciclos por día, y 432,000 solicitudes por día, aproximadamente 13 millones al mes. Ningún plan en ningún proveedor está construido para eso.

Construye una Lista de las mismas 50 cuentas y sondea un solo feed de tweets en su lugar. Una solicitud por ciclo al mismo intervalo de 10 segundos son 8,640 solicitudes por día, unas 259,000 al mes. Atrapas las mismas publicaciones, a menudo con menor latencia, porque las cronologías de Listas se cachean agresivamente del lado de X.

Una llamada de Lista reemplaza 50 llamadas por cuenta, una reducción de 50x que escala con la lista de vigilancia: una Lista de 200 cuentas es una reducción de 200x.

En la práctica rara vez necesitas una cadencia de 10 segundos. Sondear una Lista cada 30 segundos son unas 86,000 solicitudes al mes, que se sientan cómodamente dentro del plan Pro de Sorsa a $199 por 100,000 solicitudes. Este es el patrón dominante en los pipelines de monitoreo en tiempo real que configuramos con clientes que corren escucha social en Twitter y X.

Los tres endpoints de Listas {#the-three-list-endpoints}

Sorsa expone tres endpoints de Listas, todos paginados a través de next_cursor. Cuando el cursor regresa null o ausente, has llegado al final.

Para la investigación de audiencia, /list-followers a menudo es más útil que /list-members: los miembros son a quienes el curador eligió, mientras que los suscriptores se auto-identificaron como interesados en el tema. Si también necesitas el propio grafo de seguidores y de seguidos de cada cuenta, ese es un trabajo separado cubierto por los endpoints de listas de seguidores y de seguidos, no los endpoints de Listas de aquí.

¿Qué devuelve la API de Listas? {#what-does-the-list-api-return}

Los endpoints de Listas devuelven JSON limpio sin cobro separado por el perfil de autor anidado. /list-members y /list-followers devuelven un array users de objetos de perfil completos más un next_cursor. /list-tweets devuelve un array tweets más un next_cursor, y cada tweet carga su perfil de autor completo en línea sin costo extra.

Estos son los campos principales en cada objeto de perfil de miembro o de suscriptor:

Cada tweet en una respuesta /list-tweets carga texto, métricas y el autor. Los campos principales:

Una respuesta /list-tweets recortada se ve así:

{
  "tweets": [
    {
      "id": "1782368585664626774",
      "full_text": "Shipping the new pricing today.",
      "created_at": "2026-05-18T10:30:00Z",
      "lang": "en",
      "likes_count": 200,
      "retweet_count": 50,
      "reply_count": 10,
      "view_count": 10000,
      "is_reply": false,
      "is_quote_status": false,
      "user": {
        "id": "44196397",
        "username": "founder",
        "display_name": "A Founder",
        "followers_count": 100000,
        "verified": true,
        "created_at": "2009-06-02T20:12:29Z"
      },
      "entities": []
    }
  ],
  "next_cursor": "DAABCgAB..."
}

Como el perfil de autor está incrustado en cada tweet, una sola llamada de feed de Lista te da tanto el contenido como las personas detrás de él, sin una segunda consulta y sin cargo por perfil. Las definiciones completas de campos están en la documentación de Listas y Comunidades.

¿Para qué sirven las Listas de X más allá del monitoreo? {#what-are-x-lists-good-for-beyond-monitoring}

Más allá del monitoreo en tiempo real, las Listas admiten varios patrones de investigación que de otro modo tomarían mucho más trabajo:

Descubrimiento de expertos de nicho. Los periodistas y los analistas curan Listas con nombres como «AI Safety Researchers» o «DeFi Founders». La nómina de miembros es una lista corta verificada por expertos. Extráela una vez, ordena por conteo de seguidores o por engagement reciente, y tienes una lista de objetivos de outreach en minutos.

Análisis de solapamiento de audiencia. Extrae los miembros de dos Listas competidoras en el mismo nicho. La intersección muestra las elecciones de consenso; la diferencia muestra los puntos ciegos de cada curador. Es más rápido que correr análisis de competencia desde cero.

Sentimiento de sector. Extrae el feed de una Lista de la industria de 100 cuentas a diario, pasa el texto por cualquier modelo de sentimiento, y grafica el promedio deslizante. Obtienes una señal sin hacer ningún descubrimiento de cuentas primero.

Herencia de audiencia. Extrae los suscriptores de una Lista de la industria mantenida por un curador respetado. Estas son personas que optaron por el tema, un punto de partida mucho más limpio para encontrar leads calificados en Twitter que un scrape de seguidores genérico.

Una nota sobre las Comunidades de X {#a-note-on-x-communities}

Las Comunidades de X son grupos basados en tema y de opt-in: los miembros eligen unirse, lo que hace de la nómina una señal de interés fuerte en lugar de la elección de un curador. Sorsa las expone a través de /community-members, /community-tweets y /community-search-tweets, todos endpoints POST que siguen el mismo patrón de paginación que los endpoints de Listas.

Una nota de estado importa aquí. X anunció en abril de 2026 que planeaba retirar las Comunidades, citando un uso por debajo del 0.4% de las cuentas y una parte desproporcionada del spam de la plataforma, como reportó TechCrunch junto con una extensión de la fecha límite original. La cronología se ha movido desde entonces, y a partir de junio de 2026 las Comunidades y los endpoints de Comunidad todavía devuelven datos. Trata la función como en riesgo: si construyes algo duradero, constrúyelo sobre las Listas, que no están programadas para su eliminación. Si necesitas extraer una Comunidad ahora, el patrón es idéntico al código de Listas de abajo, usando POST con community_id o community_link.

API de Listas de Twitter vs la API oficial de X {#twitter-list-api-vs-the-official-x-api}

La API oficial de X sí expone endpoints de Listas. Cuál usar depende mayormente de cuánto volumen necesitas y de cuánto OAuth estás dispuesto a mantener. Sorsa API es nuestro producto, y la comparación de abajo usa cifras que puedes verificar en la documentación de desarrolladores de X y nuestro propio desglose de precios de la API de X. Prueba cualquier proveedor contra tu propia carga de trabajo antes de comprometerte.

La diferencia central es la unidad de cobro. Sorsa cobra una solicitud por llamada sin importar cuántos perfiles o tweets regresen, así que los hasta 200 perfiles en una página de Lista y los perfiles de autor incrustados en un feed de Lista no cuestan nada extra. La API oficial de X cobra cada uno de esos como una lectura de recurso separada, que es lo que hace que el monitoreo continuo de Listas sume. En las cargas de trabajo de Listas intensivas en lectura Sorsa corre hasta 50 veces más barato. El desglose de límites de tasa cubre por qué el sondeo continuo es donde los dos modelos divergen más.

El veredicto:

• Extracción y monitoreo de Listas intensivos en lectura: Sorsa. El precio de tarifa plana por solicitud más los hasta 200 perfiles por llamada mantienen el sondeo continuo barato, y una sola clave API es suficiente para empezar.
• Publicar, DMs, Ads API, o streaming filtrado: la API oficial de X, ya que esas son capacidades de escritura y de stream de primera parte que Sorsa no ofrece.

Cómo configurar una Lista que puedas monitorear {#how-to-set-up-a-list-you-can-monitor}

Solo puedes extraer datos de Listas que existen, y toda API en este punto es de solo lectura. Para configurar una Lista que puedas monitorear, hazlo una vez en la interfaz web de X:

1. Ve a x.com/lists y selecciona «Crear nueva lista».
2. Marca la Lista como pública. Las Listas privadas no son accesibles por API para nadie.
3. Agrega hasta 5,000 cuentas. Puedes pegar usuarios, buscar, o importar en masa.
4. Copia el ID numérico de la Lista de la URL: en https://x.com/i/lists/1234567890, el ID es 1234567890.
5. Sondea el feed de la Lista contra ese ID al intervalo que tu presupuesto de latencia permita.

La Lista no tiene que ser tuya para ser consultable. Si la Lista pública de alguien más ya cubre tu tema, toma el ID de su URL. Si estás construyendo un pipeline de monitoreo privado y no quieres que tus cuentas rastreadas sean visibles bajo tu identidad principal, crea la Lista bajo una cuenta separada con un nombre genérico; se mantiene pública para que la API pueda alcanzarla, pero no está atada a tu usuario real.

Código: extraer datos de Listas en Python {#code-pulling-list-data-in-python}

Los ejemplos usan Python simple con requests. Sin SDK, sin baile de autenticación. Asumen Python 3.9 o más nuevo y una clave API en una variable de entorno. Cada endpoint paginado devuelve next_cursor; cuando es null o falta, terminaste.

import os
import time
import requests

API_KEY = os.environ["SORSA_API_KEY"]
BASE = "https://api.sorsa.io/v3"
HEADERS = {"ApiKey": API_KEY}

Extraer miembros de la Lista

def get_list_members(list_id, max_pages=50):
    """Fetch member profiles from a public X List. Up to 200 per page."""
    members, cursor = [], None

    for _ in range(max_pages):
        params = {"list_id": list_id}
        if cursor:
            params["next_cursor"] = cursor

        r = requests.get(f"{BASE}/list-members", headers=HEADERS, params=params, timeout=30)
        r.raise_for_status()
        data = r.json()

        members.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)

    return members


members = get_list_members("1234567890")
print(f"Pulled {len(members)} members")

for m in members[:5]:
    bio = (m.get("description") or "")[:60]
    print(f"@{m['username']} ({m['followers_count']:,} followers): {bio}")

Una Lista completamente poblada de 5,000 miembros toma unas 25 solicitudes para extraer, ya que el endpoint devuelve hasta 200 perfiles por llamada.

Extraer suscriptores de la Lista

Los suscriptores (personas que siguen la Lista para leerla, no los miembros en ella) usan el parámetro list_link, que acepta o bien la URL completa o solo el ID numérico.

def get_list_followers(list_link, max_pages=50):
    """Users who subscribe to a public X List."""
    followers, cursor = [], None

    for _ in range(max_pages):
        params = {"list_link": list_link}
        if cursor:
            params["next_cursor"] = cursor

        r = requests.get(f"{BASE}/list-followers", headers=HEADERS, params=params, timeout=30)
        r.raise_for_status()
        data = r.json()

        followers.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)

    return followers


subs = get_list_followers("https://x.com/i/lists/1234567890")
print(f"{len(subs)} accounts subscribe to this List")

Extraer tweets de una Lista

Este es el endpoint de monitoreo: alrededor de 20 tweets por llamada, ordenados cronológicamente a lo largo de todos los miembros.

def get_list_tweets(list_id, max_pages=10):
    """Recent tweets from all members of a List, combined feed."""
    tweets, cursor = [], None

    for _ in range(max_pages):
        params = {"list_id": list_id}
        if cursor:
            params["next_cursor"] = cursor

        r = requests.get(f"{BASE}/list-tweets", headers=HEADERS, params=params, timeout=30)
        r.raise_for_status()
        data = r.json()

        tweets.extend(data.get("tweets", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)

    return tweets


feed = get_list_tweets("1234567890", max_pages=20)
print(f"Collected {len(feed)} tweets")

for t in feed[:5]:
    likes = t.get("likes_count", 0)
    print(f"@{t['user']['username']} ({likes} likes): {t['full_text'][:80]}")

Para el monitoreo continuo, corre esto en un cron o un bucle de asyncio al intervalo que le quede a tu presupuesto de latencia. Sondear cada 30 a 60 segundos es más que suficiente para todo salvo las señales de trading.

Exportar a CSV

import csv

def export_users_to_csv(users, path):
    fields = ["id", "username", "display_name", "description",
              "followers_count", "tweets_count", "verified", "location"]

    with open(path, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fields)
        writer.writeheader()
        for u in users:
            writer.writerow({
                "id": u.get("id", ""),
                "username": u.get("username", ""),
                "display_name": u.get("display_name", ""),
                "description": (u.get("description") or "").replace("\n", " "),
                "followers_count": u.get("followers_count", 0),
                "tweets_count": u.get("tweets_count", 0),
                "verified": u.get("verified", False),
                "location": u.get("location", ""),
            })

    print(f"Wrote {len(users)} rows to {path}")


export_users_to_csv(get_list_members("1234567890"), "members.csv")

El mismo patrón funciona para los suscriptores. Para los tweets, cambia la lista de campos por id, full_text, created_at, likes_count, retweet_count y el username del user.

Manejo de reintentos y de límite de tasa

Cualquier cosa que corras con una programación necesita un manejo de errores mínimo. El límite de tasa de Sorsa es de 20 solicitudes por segundo. Si lo superas, obtienes un 429; retírate y reintenta.

def request_with_retry(method, url, max_attempts=5, **kwargs):
    for attempt in range(max_attempts):
        r = requests.request(method, url, **kwargs)

        if r.status_code == 429:
            time.sleep(2 ** attempt)
            continue

        if r.status_code >= 500:
            time.sleep(1 + attempt)
            continue

        r.raise_for_status()
        return r

    raise RuntimeError(f"Failed after {max_attempts} attempts: {url}")

Pon esto en lugar de requests.get en cualquier función de arriba. Para trabajos de larga duración, registra el cursor entre páginas para que puedas reanudar ante una falla sin rehacer trabajo. Hay más patrones en optimizar el uso de la API.

Cómo se ve esto en la práctica {#what-this-looks-like-in-practice}

Un pequeño equipo de analítica con el que trabajamos, de unas diez personas construyendo señales para un escritorio de trading, estaba monitoreando aproximadamente 120 KOLs de cripto sondeando cada cuenta por su cuenta. El enfoque por cuenta era tanto caro en la API oficial como lento para reaccionar. Mover las mismas cuentas a una sola Lista pública y sondear un feed reemplazó 120 extracciones por cuenta por ciclo con una, un recorte de 120x en el volumen de solicitudes, y les dio una lectura más temprana del tono cambiante que esperar a los rastreadores de sentimiento de terceros agregados. Los costos de datos siguieron el patrón general que cualquier equipo intensivo en lectura ve al cambiar fuera de la API oficial: hasta 50 veces más barato para la misma cobertura. La victoria fue estructural, no un truco: un feed de Lista en lugar de 120 cronologías.

Cómo empezar {#getting-started}

Toma una clave API del dashboard de Sorsa, apúntala a una Lista que ya sigues en X, y estás recolectando datos estructurados en unos minutos. Cada clave nueva incluye 100 solicitudes gratis, por única vez y sin tarjeta requerida, suficiente para extraer hasta 20,000 perfiles de miembros de Lista o correr un bucle de monitoreo antes de comprometerte. El API Playground te deja probar cada endpoint sin escribir código primero, y la extracción de Listas en los planes de precio de tarifa plana empieza desde $0.01 por cada 1,000 perfiles, con las mismas 20 solicitudes por segundo en cada nivel. Si te estás moviendo fuera de la API oficial de X y quieres un mapa endpoint por endpoint, la guía de migración recorre las equivalencias.

Preguntas frecuentes {#faq}

¿Puedes extraer miembros de una Lista de X privada?

No. Las Listas de X privadas no son accesibles a través de ninguna API, oficial o de terceros. La Lista debe ser pública, y su URL debe resolver cuando se abre en un navegador sin sesión iniciada. Cualquiera que afirme extraer datos de Listas privadas o bien está equivocado o planea abusar de una cuenta con sesión iniciada. Todo lo descrito en esta guía asume una Lista pública.

¿Cuál es el tamaño máximo de Lista de X que puedes extraer?

X limita las Listas a 5,000 miembros. El endpoint list-members de Sorsa pagina a hasta 200 perfiles por solicitud, así que una Lista completa de 5,000 miembros toma unas 25 llamadas para extraer de extremo a extremo. No hay un techo oculto más allá del límite de la plataforma de 5,000 miembros en sí.

¿Cómo encuentras el ID de una Lista a partir de su URL?

Las URLs de Listas de X se ven como https://x.com/i/lists/1234567890, donde el valor numérico al final es el ID de la Lista. Algunas URLs más viejas usan la forma x.com/username/lists/slug; abrir ese enlace redirige a la versión numérica, y el número en la URL resultante es el ID que pasas a la API.

¿Las Comunidades de X todavía funcionan a través de la API?

A partir de junio de 2026, sí. X anunció en abril de 2026 que planeaba retirar las Comunidades, citando el bajo uso y el alto spam, y el corte anunciado inicialmente se ha movido desde entonces, pero la función y los endpoints de Comunidad todavía devuelven datos. Trata las Comunidades como en riesgo y construye el monitoreo duradero sobre las Listas, que no están programadas para su eliminación.

¿Sondear una Lista es más eficiente que llamar a la API una vez por cuenta?

Sí, y esta es la razón principal por la que las Listas importan para la ingeniería. Construir una Lista pública y sondear un solo feed de tweets reemplaza una solicitud por cuenta por ciclo. Para una lista de vigilancia de 50 cuentas en Sorsa, eso son aproximadamente 50 veces menos solicitudes que sondear cada cuenta por separado, y el ahorro escala con el número de cuentas en la Lista.

¿Puedes obtener tweets históricos de una Lista, no solo los recientes?

Un feed de tweets de una Lista devuelve la cronología combinada reciente de sus miembros, remontándose tan atrás como esa cronología esté disponible. Para historial profundo de una cuenta específica, extrae la cronología propia de esa cuenta en su lugar; en Sorsa el endpoint user-tweets pagina hacia atrás hasta las publicaciones más tempranas de una cuenta sin un tope de 3,200 tweets. Las Listas son para monitoreo, las extracciones por cuenta son para archivos.

¿Cuánto cuesta extraer datos de Listas comparado con la API oficial de X?

Sorsa cobra una tarifa plana por llamada a la API sin importar cuántos perfiles o tweets regresen, así que la extracción de Listas empieza desde $0.01 por cada 1,000 perfiles en los planes de tarifa plana, y cada clave nueva incluye 100 solicitudes gratis para probar primero. La API oficial de X cobra por recurso obtenido bajo pago por uso, así que una sola lectura de Lista que devuelve muchos usuarios y tweets se cobra por ítem. En las cargas de trabajo de Listas intensivas en lectura Sorsa corre hasta 50 veces más barato.

¿Los IDs de Listas de la vieja era de Twitter v1.1 todavía funcionan?

Sí, siempre que la Lista siga siendo pública y cargue en la web. Los IDs de Listas creados en los días de Twitter v1.1 siguen siendo válidos en la plataforma X actual y en las APIs de terceros como Sorsa. El rebrand de Twitter a X no invalidó los IDs de Listas existentes ni cambió su formato numérico.

Revisado por Keksich, fundador de Sorsa, marketer e investigador de la API de X.

Esta guía se apoya en el trabajo práctico de nuestro equipo operando los endpoints de Listas y de Comunidades de Sorsa, la documentación en vivo de Sorsa API v3, y la propia documentación de desarrolladores de X. La cronología del retiro de las Comunidades de X está referenciada a TechCrunch; la disponibilidad de las Comunidades se revisó directamente en X. Las comparaciones de precio y de límite de tasa se re-verificaron contra nuestra guía de precios de la API de X de 2026 y las páginas oficiales de precios de desarrolladores de X. Última verificación el 6 de julio de 2026.