API de seguidores de Twitter para cualquier cuenta

#Cómo devuelve seguidores la API oficial de X en 2026

La API oficial de X devuelve seguidores mediante GET /2/users/{id}/followers, hasta 1,000 por página, y cobra cada seguidor que devuelve como una lectura de $0.010 en su tarifa de pago por uso: $10.00 por cada 1,000. Para ver sin código los 20 seguidores más recientes de una cuenta pública, el Rastreador de seguidores recientes de Twitter gratuito los muestra en el navegador.

En resumen, la ruta oficial pide un ID numérico, una cuenta de desarrollador y OAuth, y cobra cada seguidor que devuelve; los detalles de abajo vienen de docs.x.com, leído el 2 de noviembre de 2026:

• Endpoints

  API oficial de X

  /followers y /following, ambos bajo GET /2/users/{id}

• Qué cuenta

  API oficial de X

  Solo el ID numérico de usuario, no el nombre de usuario

• Acceso

  API oficial de X

  Una cuenta de desarrollador, créditos prepagados y un token de usuario OAuth 2.0 con follows.read o un bearer token de la app

• Tamaño de página

  API oficial de X

  Hasta 1,000 (max_results); la siguiente página llega con pagination_token

• Límite de solicitudes

  API oficial de X

  300 solicitudes cada 15 minutos, por app y por usuario

• Precio

  API oficial de X

  $0.010 por seguidor leído; $0.001 cuando la lista es la del dueño de tu app

Muchas respuestas, entre ellas los resúmenes de IA de Google, todavía dicen que el endpoint es solo para clientes Enterprise. Esa fue la regla desde el 26 de junio de 2023, cuando X quitó la consulta de follows de sus niveles Basic y Pro, y hoy ya no vale: el pago por uso, abierto a todo desarrollador nuevo desde el 6 de febrero de 2026, incluye las lecturas de seguidores en su tarifa pública.

Dos reglas más condicionan el trabajo. X cobra el mismo seguidor una vez por día UTC, sin importar cuántas veces lo leas, y desde el 20 de abril de 2026 las apps de autoservicio ya no pueden seguir ni dejar de seguir cuentas mediante la API oficial de X. El límite de solicitudes restringe a una app a 300 páginas de hasta 1,000 cada 15 minutos, es decir, 300K seguidores; la guía de límites de la API de X cubre todos los demás endpoints.

#Obtén seguidores con Sorsa API en cuatro pasos

Para obtener en código los seguidores de una cuenta, usa Sorsa API, una API y scraper de Twitter (X): GET /followers devuelve hasta 200 perfiles de seguidores por solicitud desde $0.007 por cada 1,000, recibe un nombre de usuario en lugar de un ID numérico y requiere una sola clave de API, sin cuenta de desarrollador ni OAuth. Todos los planes corren a 20 solicitudes por segundo por clave.

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

2. Pide la primera página. Envía un username, user_id o user_link a GET /followers (se abre en una pestaña nueva) con la clave en el encabezado ApiKey.

   curl -G "https://api.sorsa.io/v3/followers" \
     -H "ApiKey: YOUR_API_KEY" \
     --data-urlencode "username=lumen_kitchen_labs"
   

   {
     "users": [
       {
         "id": "1718233069912377344",
         "username": "quietpine_studio_co",
         "display_name": "Quiet Pine Studio",
         "description": "Ceramics and slow coffee. Ships from Asheville.",
         "location": "Asheville, NC",
         "created_at": "2023-10-28T11:04:52Z",
         "followers_count": 3120,
         "followings_count": 418,
         "tweets_count": 1876,
         "verified": false,
         "protected": false,
         "bio_urls": ["https://quietpine.example"]
       }
     ],
     "next_cursor": "1846521730994411520"
   }
   

   Ver respuesta completa

3. Devuelve el cursor. Pasa el next_cursor de cada respuesta como el parámetro next_cursor de la siguiente solicitud. Una respuesta donde está vacío o ausente es la última página.

4. Repite hasta que termine la lista. La función de abajo lee hasta el final cualquier endpoint de listas y espera un segundo cada vez que la clave supera las 20 solicitudes por segundo.

   import time
   import requests
   
   API = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   
   def get_page(path, params):
       """One GET request; on 429 it waits a second and tries again."""
       while True:
           r = requests.get(API + path, headers=HEADERS, params=params,
                            timeout=30)
           if r.status_code == 429:  # more than 20 requests in one second
               time.sleep(1)
               continue
           r.raise_for_status()
           return r.json()
   
   
   def all_users(path, username):
       """Every account in a list endpoint, one page of 200 at a time."""
       params = {"username": username}
       while True:
           page = get_page(path, params)
           yield from page.get("users", [])
           cursor = page.get("next_cursor")
           if not cursor:
               return
           params["next_cursor"] = cursor
   
   
   followers = list(all_users("/followers", "lumen_kitchen_labs"))
   print(len(followers), "followers")
   

   // followers.mjs, Node.js 18 or later
   const API = "https://api.sorsa.io/v3";
   const headers = { ApiKey: "YOUR_API_KEY" };
   const pause = (ms) => new Promise((done) => setTimeout(done, ms));
   
   async function* allUsers(path, username) {
     const query = new URLSearchParams({ username });
     for (;;) {
       const res = await fetch(`${API}${path}?${query}`, { headers });
       if (res.status === 429) {
         await pause(1000); // more than 20 requests in one second
         continue;
       }
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const page = await res.json();
       yield* page.users ?? [];
       if (!page.next_cursor) return;
       query.set("next_cursor", page.next_cursor);
     }
   }
   
   const followers = [];
   for await (const user of allUsers("/followers", "lumen_kitchen_labs")) {
     followers.push(user);
   }
   console.log(followers.length, "followers");
   

Un 403 significa que falta la clave o que se agotaron sus solicitudes; una cuenta protegida también devuelve un error, y las solicitudes fallidas nunca se cobran. Las páginas llegan de la más reciente a la más antigua, así que la primera página siempre trae a los seguidores más recientes, algo que la sección de seguimiento de abajo aprovecha.

#Obtén la lista de cuentas que sigue un usuario

Para obtener la lista de cuentas que un usuario sigue en X, llama a GET /follows (se abre en una pestaña nueva) con el mismo nombre de usuario, ID o enlace de perfil: Sorsa API devuelve hasta 200 cuentas seguidas por solicitud, de la más reciente a la más antigua, con el mismo cursor, así que el ciclo del paso 4 cambia en una sola palabra.

following = list(all_users("/follows", "lumen_kitchen_labs"))
following.sort(key=lambda u: u["followers_count"], reverse=True)
for user in following[:10]:  # the biggest accounts it follows
    print(user["username"], user["followers_count"])

Una lista de seguidos suele ser mucho más corta que una de seguidores, así que leerla completa sale barato: una cuenta que sigue a 1,500 otras toma 8 solicitudes. Muestra a quién lee la cuenta, desde proveedores y rivales hasta los creadores y fuentes de noticias que vigila. Leída junto a la lista de seguidores, también muestra quién sigue de vuelta: los IDs que aparecen en ambas. Para un vistazo rápido sin código, el Rastreador de seguidores recientes de arriba también lista las 20 cuentas que siguió más recientemente.

Para guardar cualquiera de las dos listas como archivo CSV o Excel, la guía para exportar seguidores de Twitter explica cómo obtener archivos que se abren sin problemas.

#Qué endpoint responde cada pregunta sobre seguidores

Sorsa API responde cada pregunta común sobre seguidores con su propio endpoint, y cobra cada uno por solicitud, nunca por perfil devuelto.

• ¿Quién sigue a esta cuenta?

  Endpoint

  GET /followers

  Por solicitud

  Hasta 200 seguidores

• ¿A quién sigue?

  Endpoint

  GET /follows

  Por solicitud

  Hasta 200 cuentas

• ¿Cuáles de sus seguidores están verificados?

  Endpoint

  GET /verified-followers (se abre en una pestaña nueva)

  Por solicitud

  Una página, el mismo cursor

• ¿La cuenta B sigue a la cuenta A?

  Endpoint

  POST /check-follow (se abre en una pestaña nueva)

  Por solicitud

  Una respuesta: follow true o false

• ¿Cuántos seguidores tiene?

  Endpoint

  GET /info (se abre en una pestaña nueva)

  Por solicitud

  Un perfil con followers_count

• Conteo de seguidores de muchas cuentas

  Endpoint

  GET /info-batch (se abre en una pestaña nueva)

  Por solicitud

  Hasta 100 perfiles

• ¿Quién está en una Lista de X, o la sigue?

  Endpoint

  GET /list-members (se abre en una pestaña nueva), GET /list-followers (se abre en una pestaña nueva)

  Por solicitud

  Una página, el mismo cursor

Solo los seguidores verificados

GET /verified-followers recibe la misma entrada y el mismo cursor que GET /followers y devuelve solo las cuentas con insignia de verificación. En una cuenta grande se salta la mayoría de las páginas, porque las cuentas verificadas son una pequeña minoría en casi todas las audiencias: nunca lees las filas que de todos modos filtrarías.

Verifica una relación de follow

POST /check-follow responde si una cuenta sigue a otra en una sola solicitud, desde $0.0014 por verificación, sin importar lo larga que sea cualquiera de las listas. username_1 es la cuenta que debería ser seguida y username_2 la cuenta que verificas; un user_id_* o user_link_* sirve en cualquiera de los dos lados.

curl -X POST "https://api.sorsa.io/v3/check-follow" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username_1": "lumen_kitchen_labs",
       "username_2": "quietpine_studio_co"}'

La respuesta cubre un solo sentido, así que un follow mutuo requiere dos llamadas con los lados invertidos. Las verificaciones para sorteos y campañas, con retweets, citas y respuestas junto a los follows, están en la guía de la API de verificación de Twitter. Los miembros y seguidores de las Listas de X tienen su propia guía: la API de Listas de Twitter.

#Qué contiene cada registro de seguidor

Cada seguidor llega como un perfil público completo con 19 campos, el mismo objeto que devuelve todo endpoint de perfil de Sorsa API, así que filtrar y puntuar no requiere una segunda solicitud.

Los campos se agrupan en seis grupos, y la mayor parte del trabajo con audiencias usa los primeros cuatro:

• Identidad

  Campos

  id, username, display_name, created_at

• Alcance

  Campos

  followers_count, followings_count

• Actividad

  Campos

  tweets_count, media_count, favourites_count, pinned_tweet_ids

• Tema y lugar

  Campos

  description, bio_urls, location

• Indicadores

  Campos

  verified, protected, can_dm, possibly_sensitive

• Imágenes

  Campos

  profile_image_url, profile_background_image_url

Tres reglas mantienen los datos fiables:

• Usa siempre el ID como clave. Los IDs de cuenta en id nunca cambian y llegan como cadenas; los nombres de usuario cambian cuando su dueño quiere. Si solo necesitas los IDs de los seguidores, conserva el id de cada registro: llegan con los perfiles completos sin costo adicional. Guarda los IDs como cadenas también en JavaScript: los IDs de X llegan a 19 dígitos, y los números de JavaScript son exactos solo hasta 16.
• Espera que la lista difiera del conteo en unos pocos puntos porcentuales. followers_count es el total en vivo de X, mientras que la lista deja fuera las cuentas suspendidas o desactivadas.
• Lee los perfiles tal como están hoy. Cada registro muestra la biografía y los conteos actuales del seguidor, no el estado del día en que empezó a seguir.

Para tener en cuenta

GET /followers no trae fecha del follow, porque la lista pública de seguidores de X no muestra cuándo ocurrió un follow. Para fechar a los seguidores nuevos, revisa según un calendario y registra el día en que aparece por primera vez cada ID; la siguiente sección muestra cómo.

#Rastrea nuevos seguidores y dejados de seguir

Para rastrear nuevos seguidores por API, conserva los IDs de seguidores que viste la última vez y compara: como las páginas llegan de la más reciente a la más antigua, una revisión lee solo hasta encontrar un ID que ya conoce, así que cuesta una solicitud siempre que hayan llegado menos de 200 seguidores desde la anterior.

Detectar a quienes dejaron de seguir requiere la lista completa: un ID presente en la lectura completa de la semana pasada y ausente en la de hoy se fue. Ejecuta la revisión barata a diario o cada hora, y la lectura completa cada semana o cada mes. Ambas funciones reutilizan get_page y all_users del paso 4.

def new_followers(username, known):
    """Followers added since the last check. Pages come newest first,
    so the loop stops at the first page that holds a known ID."""
    params, found = {"username": username}, []
    while True:
        page = get_page("/followers", params)
        users = page.get("users", [])
        fresh = [u for u in users if u["id"] not in known]
        found += fresh
        cursor = page.get("next_cursor")
        if len(fresh) < len(users) or not cursor:
            return found
        params["next_cursor"] = cursor


def unfollowed(username, last_full_read):
    """IDs from the last full read that no longer follow."""
    now = {u["id"] for u in all_users("/followers", username)}
    return last_full_read - now, now

Antes de contar un ID como alguien que dejó de seguir, consúltalo con GET /info-batch: una cuenta suspendida o eliminada también desaparece de todas las listas de seguidores. Las revisiones corren con tu calendario y el costo sigue siendo bajo: 25 cuentas de 50K seguidores cada una, revisadas a diario y leídas completas una vez al mes, toman unas 7,000 solicitudes al mes.

#Filtra seguidores y encuentra audiencias en común

Cada registro de seguidor ya trae sus conteos, biografía e indicadores, así que filtrar una lista son unas pocas líneas de código y ninguna solicitud adicional. Su location es lo que escribió el usuario; para el país que asigna la propia X, la guía de la API de ubicación de Twitter mapea una audiencia por país con GET /about.

followers = list(all_users("/followers", "lumen_kitchen_labs"))
shortlist = [
    u for u in followers
    if u["followers_count"] >= 1000          # some reach
    and u["tweets_count"] >= 100             # posts regularly
    and not u["protected"]
    and "coffee" in (u.get("description") or "").lower()
]

Las cuentas que siguen a dos o más de tus rivales son las personas más comprometidas de tu mercado. Lee la lista de cada rival una vez y cuenta cuántas veces aparece cada ID:

from collections import Counter

rivals = ["lumen_kitchen_labs", "copperleaf_cookware", "saltmarsh_pantry"]
lists = {h: {u["id"] for u in all_users("/followers", h)} for h in rivals}
seen = Counter(i for ids in lists.values() for i in ids)
core = {i for i, n in seen.items() if n >= 2}
smallest = min(len(ids) for ids in lists.values())
print(f"{len(core)} accounts follow 2+ rivals, "
      f"{len(core) / smallest:.1%} of the smallest audience")

Mide la coincidencia contra la audiencia más pequeña, no contra el total: una porción compartida de 2,000 significa mucho para una cuenta de 5K y poco para una de 2M. Para comparar dos cuentas sin código, el Verificador de audiencia en común de Twitter gratuito lo hace en el navegador, y convertir esas cuentas centrales en prospectos es el tema de cómo encontrar leads en Twitter.

#Encuentra y evalúa influencers de Twitter con la API

Para encontrar y evaluar influencers de Twitter por API, busca creadores por palabras clave de la biografía y temas, enriquece sus perfiles por lotes y luego puntúa a cada uno según su interacción reciente y la calidad de su audiencia. Sorsa API cubre cada paso en modo de solo lectura, a partir de métricas públicas: me gusta, respuestas, reposts, citas y vistas.

Descubre creadores por nicho

• Por biografía y nombre: POST /search-users (se abre en una pestaña nueva) encuentra cuentas por palabra clave, biografías incluidas, unas 20 por página; filtra por nivel de seguidores, estado de verificación, ubicación y cantidad de posts.
• Por los temas que impulsan: POST /search-tweets (se abre en una pestaña nueva) ejecuta los operadores de búsqueda de X, y los autores de los posts más destacados sobre un tema son sus voces activas.
• Desde listas curadas: GET /list-members lee las Listas de X que alguien ya armó para un nicho, y GET /info-batch enriquece cualquier lista de candidatos de 100 perfiles a la vez.

Evalúalos con interacción real

La tasa de interacción son las interacciones en posts recientes (me gusta, respuestas, reposts y citas) por post, divididas entre los seguidores o entre las vistas. POST /user-tweets (se abre en una pestaña nueva) devuelve unos 20 posts recientes por solicitud con todos los conteos, y POST /tweet-info-bulk (se abre en una pestaña nueva) lee hasta 100 posts elegidos a la vez. No hay una puntuación de caja negra: los datos de entrada son los conteos públicos de X, y la fórmula la ajustas tú.

def engagement_rate(username):
    """Interactions per post, per follower and per view."""
    # the latest page of posts; API and HEADERS come from step 4
    r = requests.post(API + "/user-tweets", headers=HEADERS,
                      json={"username": username}, timeout=30)
    r.raise_for_status()
    posts = r.json().get("tweets", [])
    if not posts:
        return None
    acts = sum(p["likes_count"] + p["reply_count"] + p["retweet_count"]
               + p["quote_count"] for p in posts)
    views = sum(p.get("view_count") or 0 for p in posts)
    followers = max(posts[0]["user"]["followers_count"], 1)
    return {"by_followers": acts / len(posts) / followers,
            "by_views": acts / views if views else None}

Para una revisión rápida de una cuenta sin código, la Calculadora de tasa de interacción de Twitter gratuita hace la misma aritmética.

Detecta seguidores falsos e interacción comprada

Lee una o dos páginas de los seguidores más recientes de un creador y busca las señales que rara vez coinciden por casualidad:

• una interacción muy inferior a la que sugiere su cantidad de seguidores;
• una muestra de seguidores llena de cuentas creadas el mes pasado, con biografías vacías, el avatar por defecto o sin posts;
• cuentas desproporcionadas que siguen a miles y son seguidas por pocos;
• posts recientes con muchas vistas pero casi sin me gusta ni respuestas.

El método completo, con diez señales y un script que puntúa una lista entera de seguidores, está en la guía de detección de bots en Twitter.

Revisa la campaña después del acuerdo

POST /user-tweets sigue los posts del creador, POST /mentions (se abre en una pestaña nueva) encuentra posts que mencionan tu marca con min_likes y un rango de since_date a until_date, y POST /check-quoted (se abre en una pestaña nueva) y GET /check-comment (se abre en una pestaña nueva) confirman que una cita o respuesta requerida se publicó, desde $0.0014 por verificación.

La ejecución completa sobre 500 creadores toma unas 540 solicitudes: 25 páginas de búsqueda, 5 llamadas por lotes, 500 extracciones de timeline y 10 páginas de seguidores. Son unos $0.76 a la tarifa más baja de Sorsa API y una porción pequeña de las 10K solicitudes de su plan más chico; las mismas lecturas a tarifas de la API oficial de X cuestan unos $75.

#Cuánto cuestan los datos de seguidores por cada 1,000 seguidores

Sorsa API lee seguidores desde $0.007 por cada 1,000, frente a $10.00 por cada 1,000 en la API oficial de X: 1,000 veces menos por la misma lista pública.

Con esas tarifas, 100K seguidores cuestan desde $0.70 frente a $1,000, y 1M cuesta desde $7 frente a $10,000. Incluso la tarifa de $0.001 de X para los seguidores de tu propia app equivale a $1.00 por cada 1,000. Sorsa API cobra por solicitud, no por perfil: una página de 200 seguidores es una solicitud, las solicitudes fallidas no cuestan nada y consultar tu saldo con GET /key-usage-info (se abre en una pestaña nueva) es gratis. Todos los precios oficiales están desglosados en la guía de precios de la API de X.

Las tareas recurrentes cuestan lo que suman sus lecturas en un mes. El planificador de abajo convierte las cuentas que vigilas y la frecuencia con que las revisas en solicitudes y dinero en ambas APIs.

#Obtén tus primeros 20K seguidores hoy

Para seguidores, listas de seguidos y verificaciones de follow en código, usa Sorsa API: 200 seguidores por solicitud, desde $0.007 por cada 1,000, una sola clave de API y ninguna cuenta de desarrollador. Tus 100 solicitudes gratis leen los primeros 20K seguidores; ejecuta el ciclo del paso 4 con cualquier cuenta pública y mira cómo llega la lista completa.

#Preguntas frecuentes