Cómo encontrar tu público objetivo en Twitter por API

Por Sorsa Editorial

Actualizado en julio de 2026: agregada la asignación inicial de 100 solicitudes gratis, replanteado el precio alrededor de las tarifas por lotes por cada 1,000, refrescada la comparación de costos con la API oficial de X para el precio por recurso de abril de 2026, y re-verificados los seis métodos de endpoints contra la API en vivo.

Conclusión clave: Encontrar tu público objetivo en X (Twitter) a escala significa extraer listas de usuarios por código en lugar de recorrer. Seis métodos de API lo cubren: bios por palabra clave, intención en vivo en tweets, los seguidores de un competidor, los miembros de una Comunidad, los seguidores verificados y quienes amplifican posts. Cada uno devuelve perfiles públicos completos que luego deduplicas, filtras y exportas.

El cuello de botella rara vez es la estrategia. Es el acceso a los datos. X muestra un puñado de seguidores en la interfaz antes de que la lista deje de cargar, y la API oficial de X ahora cobra por recurso: cada perfil de seguidor que lees cuesta $0.010, así que una sola extracción de 10,000 seguidores cuesta unos $100 antes de que hayas filtrado a nadie. Sorsa API, un proveedor alternativo de API de Twitter/X, elimina ambos muros. Su endpoint /followers devuelve hasta 200 perfiles completos por solicitud a un precio de tarifa plana por solicitud, así que los mismos 10,000 seguidores cuestan unos diez centavos en el plan Pro, y te autenticas con un único encabezado ApiKey en lugar de un apretón de manos OAuth y una cola de aprobación. Cada técnica de abajo usa un endpoint y corre a 20 solicitudes por segundo en cualquier plan.

Esta guía cubre los seis métodos que usamos para armar una audiencia, el código para correr cada uno, cómo combinar y limpiar los resultados, qué cuesta y qué hacer con la lista una vez que la tienes.

Contenido

• ¿Qué significa de verdad el descubrimiento de audiencia en X?
• Seis formas de encontrar una audiencia, mapeadas a la pregunta que cada una responde
• Técnica 1: encuentra cuentas por lo que ponen en su bio
• Técnica 2: extrae la lista de seguidores de un competidor
• Técnica 3: extrae el listado de miembros de una Comunidad
• Técnica 4: mina la intención en tiempo real de la búsqueda de tweets
• Técnica 5: aísla los seguidores verificados
• Técnica 6: captura las cuentas que amplifican contenido
• Combina las fuentes y puntúa por traslape
• Filtra los bots y las cuentas muertas
• ¿Qué cuesta extraer una audiencia contra la API oficial de X?
• Qué hacer con la audiencia una vez que la tienes
• En la práctica: la construcción de audiencia de un equipo B2B SaaS
• Cómo probar esto tú mismo
• Preguntas frecuentes

¿Qué significa de verdad el descubrimiento de audiencia en X? {#what-does-audience-discovery-on-x-actually-mean}

El descubrimiento de audiencia en X (Twitter) es el proceso de identificar las cuentas específicas que vale la pena alcanzar, y luego recolectarlas como una lista estructurada y filtrable. Abarca tres grupos que se traslapan: personas que se describen públicamente como tu audiencia, personas que ya siguen a cuentas de tu espacio y personas que publican activamente sobre tu tema ahora mismo.

La ruta manual es familiar. Abres la Búsqueda avanzada, armas unas cuantas Listas de Twitter a mano, exploras una Comunidad y tomas notas. Eso funciona para una mirada puntual. Se cae en el momento en que necesitas unos miles de cuentas, los puntos de datos para calificarlas y un proceso que puedas volver a correr el mes que viene. No hay botón de exportar, la interfaz deja de cargar después de unos cientos de perfiles, y nada de eso es reproducible.

La ruta programática arregla los tres problemas. Cada pregunta de descubrimiento mapea a una sola llamada a la API que devuelve perfiles públicos completos como JSON limpio: bio, número de seguidores, antigüedad de la cuenta, ubicación, estado de verificación. Recolectas a escala, filtras en código y exportas a CSV o a una base de datos. El resto de esta guía es la versión práctica de eso.

Una distinción que vale mantener clara: tu público objetivo es a quién quieres alcanzar, que no siempre es quien ya te sigue. Los métodos de abajo encuentran a los primeros, no solo a los segundos.

Seis formas de encontrar una audiencia, mapeadas a la pregunta que cada una responde {#six-ways}

Cada técnica responde una pregunta de segmentación distinta y usa un endpoint distinto. Corre una en aislamiento, o combina varias y puntúa por traslape (cubierto más abajo).

Todos los ejemplos usan https://api.sorsa.io/v3 como la URL base y el encabezado ApiKey. El montaje compartido:

import requests, time

API_KEY = "YOUR_API_KEY"
BASE = "https://api.sorsa.io/v3"
AUTH = {"ApiKey": API_KEY}                                  # GET endpoints
POST_HEADERS = {**AUTH, "Content-Type": "application/json"} # POST endpoints

Técnica 1: encuentra cuentas por lo que ponen en su bio {#technique-1}

La forma más rápida de encontrar personas que se auto-declaran como tu audiencia es buscar lo que escribieron sobre sí mismas. Una palabra clave como Solidity developer, growth marketer u oncology nurse coincide contra bios, nombres visibles y nombres de usuario, así que las personas que se identifican con un rol salen directamente. Esta es la elección correcta cuando tu audiencia se etiqueta a sí misma con un título o nicho.

El endpoint /search-users toma una consulta y pagina por las coincidencias. Cada resultado es un perfil completo, así que calificas candidatos en código sin una segunda consulta.

def find_users_by_bio(query, max_pages=10):
    users, cursor = [], None
    for _ in range(max_pages):
        body = {"query": query}
        if cursor:
            body["next_cursor"] = cursor
        resp = requests.post(f"{BASE}/search-users", headers=POST_HEADERS,
                             json=body, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        users.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return users

users = find_users_by_bio("machine learning engineer")

El patrón es idéntico en cualquier lenguaje. La misma llamada en JavaScript:

async function findUsersByBio(query, maxPages = 10) {
  const all = [];
  let cursor = null;
  for (let i = 0; i < maxPages; i++) {
    const body = { query };
    if (cursor) body.next_cursor = cursor;
    const resp = await fetch("https://api.sorsa.io/v3/search-users", {
      method: "POST",
      headers: { ApiKey: "YOUR_API_KEY", "Content-Type": "application/json" },
      body: JSON.stringify(body),
    });
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
    const data = await resp.json();
    all.push(...(data.users || []));
    cursor = data.next_cursor;
    if (!cursor) break;
    await new Promise((r) => setTimeout(r, 100));
  }
  return all;
}

Como cada registro carga el perfil completo, filtrar es una list comprehension, no otra ronda de llamadas a la API:

qualified = [
    u for u in users
    if u.get("followers_count", 0) >= 1000
    and u.get("tweets_count", 0) >= 100
    and not u.get("protected", False)
]

Para precisión de varias palabras y guiada por operadores, aplica la misma sintaxis de consulta usada para los tweets. Nuestra guía de la API de búsqueda de Twitter recorre el conjunto de operadores a fondo.

Técnica 2: extrae la lista de seguidores de un competidor {#technique-2}

La única señal de audiencia de mayor rendimiento es quién ya sigue a una cuenta de tu espacio. Si una persona sigue a tu competidor directo, se ha precalificado sola: le importa la categoría. El endpoint /followers devuelve esa lista, hasta 200 perfiles completos por solicitud, lo que la hace la llamada de descubrimiento más costo-eficiente disponible.

def get_followers(username, max_pages=20):
    followers, cursor = [], None
    for _ in range(max_pages):
        params = {"username": username}
        if cursor:
            params["next_cursor"] = cursor
        resp = requests.get(f"{BASE}/followers", headers=AUTH,
                            params=params, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        followers.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return followers

followers = get_followers("competitor_handle", max_pages=20)

Un solo competidor es un punto de partida. Las cuentas que siguen a varios jugadores de tu espacio son un segmento más filoso, porque el traslape señala interés genuino en la categoría en lugar de un follow aislado. Extrae unas cuantas semillas y quédate con la intersección:

from collections import Counter

competitors = ["competitor_a", "competitor_b", "competitor_c"]
follower_sets = {h: {f["id"] for f in get_followers(h, max_pages=10)}
                 for h in competitors}

all_ids = [uid for ids in follower_sets.values() for uid in ids]
overlap = {uid for uid, c in Counter(all_ids).items() if c >= 2}

Recorrer una cuenta de 50 millones de seguidores de principio a fin rara vez vale la pena. Para cuentas por encima de unos 500,000 seguidores, extraer las primeras 50 a 100 páginas (10,000 a 20,000 perfiles) suele ser una muestra representativa de la audiencia reciente y activa. Para un tratamiento más profundo de la extracción de seguidores y seguidos, incluidos los casos límite de cuentas protegidas y muestreo, revisa nuestra guía de cómo extraer seguidores de Twitter.

Técnica 3: extrae el listado de miembros de una Comunidad {#technique-3}

Las Comunidades de X son grupos acotados por tema, lo que significa que la membresía ya está filtrada por interés auto-seleccionado. Extraer el listado de una Comunidad de tu nicho te entrega una audiencia que se inscribió al tema exacto. El endpoint /community-members acepta o el ID numérico de la Comunidad o la URL completa.

def get_community_members(community_id, max_pages=20):
    members, cursor = [], None
    for _ in range(max_pages):
        body = {"community_link": community_id}
        if cursor:
            body["next_cursor"] = cursor
        resp = requests.post(f"{BASE}/community-members", headers=POST_HEADERS,
                             json=body, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        members.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return members

Los resultados de Comunidad son perfiles compactos (id, username, nombre visible, imagen, verified, protected). Para enriquecerlos con números de seguidores, bios y antigüedad de la cuenta para filtrar, pasa los IDs recolectados por el endpoint de perfiles por lotes, que acepta hasta 100 IDs y cuenta como una sola solicitud. Los endpoints relacionados de Listas y Comunidades se cubren en nuestra guía de la API de Listas y Comunidades de X.

Técnica 4: mina la intención en tiempo real de la búsqueda de tweets {#technique-4}

Las otras técnicas encuentran a la gente por quién es o a quién sigue. La búsqueda de tweets las encuentra por lo que están diciendo ahora mismo. Alguien que publica "looking for a CRM recommendation" hoy es una audiencia distinta y a menudo más valiosa que alguien que solo encaja con un perfil estático, porque la intención es fresca. Busca los tweets, y luego extrae los autores únicos.

def find_active_voices(query, min_followers=100, max_pages=10):
    seen, voices, cursor = set(), [], None
    for _ in range(max_pages):
        body = {"query": query, "order": "latest"}
        if cursor:
            body["next_cursor"] = cursor
        resp = requests.post(f"{BASE}/search-tweets", headers=POST_HEADERS,
                             json=body, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        for tw in data.get("tweets", []):
            u = tw.get("user", {})
            uid = u.get("id")
            if uid and uid not in seen and u.get("followers_count", 0) >= min_followers:
                seen.add(uid)
                voices.append({
                    "username": u.get("username"),
                    "followers": u.get("followers_count", 0),
                    "bio": u.get("description", ""),
                    "sample_tweet": (tw.get("full_text") or "")[:160],
                })
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return voices

voices = find_active_voices(
    '("need a CRM" OR "looking for a CRM") lang:en -filter:retweets')

La cadena de consulta es donde esta técnica se gana su lugar. Unos cuantos patrones que sacan la intención:

El conjunto completo de operadores, incluidos los filtros de engagement que la API oficial deja caer en silencio, está en nuestra guía de operadores de búsqueda de Twitter.

Técnica 5: aísla los seguidores verificados {#technique-5}

Para listas de relaciones públicas, contacto con periodistas, investigación de inversionistas o evaluación de influencers, la porción de alto perfil de una audiencia importa más que el conteo crudo. /verified-followers devuelve solo las cuentas verificadas que siguen a un objetivo, con la misma forma y paginación que /followers.

def get_verified_followers(username, max_pages=10):
    verified, cursor = [], None
    for _ in range(max_pages):
        params = {"username": username}
        if cursor:
            params["next_cursor"] = cursor
        resp = requests.get(f"{BASE}/verified-followers", headers=AUTH,
                            params=params, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        verified.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return verified

verified = get_verified_followers("openai")
verified.sort(key=lambda u: u.get("followers_count", 0), reverse=True)

Ordenada por alcance, esta es una lista corta lista para usar de las cuentas más influyentes en la órbita de un objetivo. Para encontrar y calificar cuentas influyentes más allá de una sola lista de seguidores, nuestra API de influencers para cualquier nicho cubre el flujo más amplio.

Técnica 6: captura las cuentas que amplifican contenido {#technique-6}

Las personas que hacen retweet y citan contenido de tu espacio son una audiencia que ya actúa, no solo observa. Dos endpoints cubren la amplificación. /retweeters devuelve los usuarios que hicieron repost de un tweet. /quotes devuelve los tweets citados completos, que incluyen al usuario que cita más su comentario, útil para contacto etiquetado por sentimiento.

def get_retweeters(tweet_link, max_pages=10):
    users, cursor = [], None
    for _ in range(max_pages):
        body = {"tweet_link": tweet_link}
        if cursor:
            body["next_cursor"] = cursor
        resp = requests.post(f"{BASE}/retweeters", headers=POST_HEADERS,
                             json=body, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        users.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return users

def get_quoters(tweet_link, max_pages=10):
    quotes, cursor = [], None
    for _ in range(max_pages):
        body = {"tweet_link": tweet_link}
        if cursor:
            body["next_cursor"] = cursor
        resp = requests.post(f"{BASE}/quotes", headers=POST_HEADERS,
                             json=body, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        quotes.extend(data.get("tweets", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.1)
    return quotes

Los tweets citados son objetos de tweet, no objetos de usuario: alcanza la cuenta que cita a través de tweet["user"] y su comentario a través de tweet["full_text"]. El conjunto completo de engagement (respuestas, citas, retweeters) se cubre en nuestra guía de la API de engagement de Twitter.

Combina las fuentes y puntúa por traslape {#combine}

Cada técnica cubre un punto ciego distinto, así que el segmento más fuerte son las cuentas que aparecen en más de una. Corre varios métodos, deduplica por ID de usuario, y clasifica por en cuántas fuentes apareció cada cuenta:

def score_by_source(by_source):
    """by_source: {source_name: [user objects]} -> deduped users with source_count."""
    index = {}
    for source, users in by_source.items():
        for u in users:
            uid = u["id"]
            index.setdefault(uid, {"user": u, "sources": set()})["sources"].add(source)

    result = []
    for entry in index.values():
        u = entry["user"].copy()
        u["source_count"] = len(entry["sources"])
        u["sources"] = sorted(entry["sources"])
        result.append(u)

    result.sort(key=lambda r: (-r["source_count"], -r.get("followers_count", 0)))
    return result

combined = score_by_source({
    "followers_competitor_a": followers,
    "bio_ml_engineer": users,
    "intent_crm": voices,
    "community_indie_hackers": get_community_members("1966045657589813686"),
})

Las cuentas que aparecen en dos o más fuentes suelen ser la parte de más valor de la lista. Una persona que sigue a tu competidor, se describe con tu rol objetivo y publicó intención esta semana es un lead más fuerte que cualquier señal individual por sí sola.

Filtra los bots y las cuentas muertas {#filter}

La salida cruda del descubrimiento siempre carga ruido: bots, cuentas abandonadas y perfiles de granja de follows. Como cada endpoint devuelve el perfil completo, un filtro reutilizable limpia toda la lista sin llamadas extra:

from datetime import datetime, timezone, timedelta

def is_quality_account(user, min_followers=500, min_tweets=100, max_following_ratio=10):
    if user.get("protected", False):
        return False
    if user.get("followers_count", 0) < min_followers:
        return False
    if user.get("tweets_count", 0) < min_tweets:
        return False
    followers = user.get("followers_count", 1)
    if user.get("followings_count", 0) > followers * max_following_ratio:
        return False
    created = user.get("created_at")
    if created:
        try:
            dt = datetime.fromisoformat(created.replace("Z", "+00:00"))
            if dt > datetime.now(timezone.utc) - timedelta(days=30):
                return False
        except ValueError:
            pass
    if not (user.get("description") or "").strip():
        return False
    return True

qualified = [u for u in combined if is_quality_account(u)]

Un ratio desbalanceado de seguidos a seguidores, una bio vacía, una cuenta recién estrenada y casi cero tweets son las señales de bot más baratas. Ajusta los umbrales a tu nicho. Para una pasada más profunda de puntuar cuentas falsas e inactivas, revisa nuestra guía de cómo auditar seguidores falsos.

¿Qué cuesta extraer una audiencia contra la API oficial de X? {#cost}

El descubrimiento de audiencia es intensivo en lecturas por naturaleza: miles de perfiles por proyecto, a menudo refrescados con calendario. Esa es exactamente la carga donde el modelo de cobro decide la factura. La API oficial de X cobra por recurso consultado, así que cada perfil es una unidad facturable separada. Una API de Twitter/X de tarifa plana cobra por solicitud, y una solicitud de seguidores devuelve hasta 200 perfiles por el precio de una llamada.

La brecha se compone a escala. Extraer 10,000 seguidores de competidor más 10,000 perfiles de búsqueda por bio en la API oficial son unas 20,000 lecturas de usuario, unos $200, antes de cualquier filtrado. Las mismas dos extracciones en el plan Pro de un proveedor con precio de tarifa plana por solicitud aterrizan dentro de un solo presupuesto mensual de solicitudes. Para el desglose completo de costos proveedor por proveedor, revisa nuestra comparación de alternativas a la API de Twitter. (Las cifras de la API oficial de X reflejan el precio por recurso vigente tras la actualización de abril de 2026; nosotros cobramos una tarifa plana por solicitud en cada plan.)

Qué hacer con la audiencia una vez que la tienes {#what-next}

Una lista de cuentas es materia prima, no el resultado. Donde el valor de verdad aparece:

• Contacto y generación de leads. Los perfiles filtrados y deduplicados se vuelven una lista de contacto priorizada. Las puntuaciones de intención y traslape te dicen a quién alcanzar primero. Nuestro flujo de generación de leads en X se construye sobre exactamente esta salida, y la guía práctica de cómo encontrar leads en X recorre los filtros de calificación.
• Estrategia de contenido. Las bios, frases recurrentes y tweets de muestra que recolectaste mapean el lenguaje que tu audiencia usa de verdad. Refleja su redacción en ganchos e hilos en lugar de adivinar.
• Benchmarking de competidores y audiencia. Compara el traslape entre tus seguidores y los de un rival, o rastrea cómo crece la audiencia de un competidor en el tiempo, con el seguimiento de competidores en X. El método del lado de desarrollo está en nuestra guía de análisis de competencia en Twitter.
• Dimensionamiento de mercado por geografía. Agrega la audiencia por país para ver qué mercados son reales antes de comprometer un presupuesto. El método está en nuestra guía de geografía de audiencia de Twitter.

Cualquiera que sea el destino, la exportación es el mismo paso. Si prefieres saltarte el código, los mismos perfiles pueden ir directo a una hoja de cálculo por nuestro recorrido de cómo exportar datos de X a Google Sheets. El fragmento de abajo escribe la salida de cualquier técnica a CSV:

import csv

def export_users_to_csv(users, output_file="audience.csv"):
    fields = ["user_id", "username", "display_name", "description",
              "followers_count", "followings_count", "tweets_count",
              "location", "verified", "created_at"]
    with open(output_file, "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(f, fieldnames=fields)
        w.writeheader()
        for u in users:
            w.writerow({
                "user_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),
                "followings_count": u.get("followings_count", 0),
                "tweets_count": u.get("tweets_count", 0),
                "location": u.get("location", ""),
                "verified": u.get("verified", False),
                "created_at": u.get("created_at", ""),
            })

En la práctica: la construcción de audiencia de un equipo B2B SaaS {#in-practice}

Un equipo de marketing B2B SaaS de unas 12 personas llegó a este enfoque tras correr contacto a mano durante dos trimestres. Su proceso era una persona copiando usuarios de la Búsqueda avanzada a una hoja de cálculo, lo que topaba alrededor de unos cientos de cuentas por semana y no producía datos de calificación. Lo reconstruyeron como un pipeline: extraer los seguidores de sus tres competidores más cercanos, correr una búsqueda por bio de los dos puestos que tienen sus compradores, buscar tweets de intención de migración contra una herramienta establecida y luego combinar y puntuar por traslape. Las cuentas que llegaban a dos o más fuentes se volvieron una lista de contacto clasificada de unos miles de perfiles calificados, refrescada semanalmente.

La parte que los sorprendió fue la línea de costo. Su plan original de correr este volumen en la API oficial de X ponía precio a la carga de lectura en cientos de dólares al mes antes de filtrar. Mover la capa de datos a un scraper de Twitter de tarifa plana puso las mismas extracciones dentro de un plan mensual de menos de $200. Para trabajo intensivo en lecturas como este, un modelo de tarifa plana por solicitud corre hasta 50 veces más barato que el cobro por recurso, porque una solicitud de seguidores devuelve hasta 200 perfiles por el precio de una sola unidad.

Cómo probar esto tú mismo {#getting-started}

Puedes probar cada técnica de aquí sin escribir código primero. El Sorsa Playground sin código corre los mismos endpoints por una interfaz: elige un método, fija el número de páginas, ve el costo de la solicitud de antemano y descarga los resultados. Cuando estés para scriptearlo, el inicio rápido te da una solicitud funcional en unos minutos.

El montaje es un único encabezado ApiKey, sin revisión de cuenta de desarrollador y sin flujo OAuth, y las primeras 100 solicitudes son gratis: una asignación única que no necesita tarjeta, nunca vence y cubre los 40 endpoints (suficiente para hasta 10,000 tweets o 20,000 perfiles). Las extracciones de perfiles arrancan desde $0.01 por cada 1,000 y los tweets desde $0.02 por cada 1,000, y cada plan sostiene 20 solicitudes por segundo, que en una llamada de seguidores de 200 perfiles son hasta 4,000 perfiles por segundo. Para construcciones de audiencia más grandes o programadas, la página de precios tiene el cálculo por solicitud y una calculadora.

Preguntas frecuentes {#faq}

¿Cómo encuentras tu público objetivo en Twitter (X)? Encontrar tu público objetivo en X significa recolectar las cuentas específicas que vale la pena alcanzar como una lista estructurada en lugar de recorrer la app. Los métodos prácticos son la búsqueda por palabra clave en bios y tweets, extraer los seguidores de un competidor, scrapear los miembros de una Comunidad y reunir las cuentas que hacen retweet de posts relevantes. Una API los devuelve como perfiles completos que puedes filtrar y exportar.

¿Se pueden encontrar usuarios de Twitter por una palabra clave en su bio? Sí. Buscar bios, nombres visibles y nombres de usuario por una palabra clave saca las cuentas que se auto-identifican con un rol o nicho, como "Solidity developer" o "growth marketer". Un endpoint de búsqueda de usuarios hace esto y devuelve cada coincidencia como un perfil completo, incluidos el número de seguidores y la antigüedad de la cuenta, así que puedes calificar candidatos en código sin una segunda consulta.

¿Cómo obtienes una lista de los seguidores de un competidor? Los seguidores de un competidor son accesibles a través de un endpoint de seguidores que devuelve la lista pública de seguidores como perfiles completos, hasta 200 por solicitud, así que una lista de 10,000 seguidores toma unas 50 llamadas. Extraer varios competidores y quedarte con las cuentas que siguen a dos o más produce un segmento más filoso e interesado en la categoría que cualquier cuenta individual.

¿Hay una alternativa a la API de X con mejores límites de tasa para extracciones de audiencia? Sí. Sorsa API es una alternativa a la API de Twitter/X construida para trabajo intensivo en lecturas, con 20 solicitudes por segundo en cada plan y sin ventanas por endpoint. Cobra por solicitud en lugar de por recurso, así que una sola llamada de seguidores devuelve hasta 200 perfiles por una unidad de cuota, y el montaje es una sola clave API sin cola de aprobación.

¿Qué cuesta extraer 10,000 perfiles de seguidores? En la API oficial de X, 10,000 perfiles de seguidores se cobran como 10,000 lecturas de recurso a $0.010 cada una, unos $100. En un modelo de tarifa plana por solicitud, los mismos 10,000 perfiles toman unas 50 solicitudes a $0.002 cada una, unos diez centavos, porque un endpoint de seguidores devuelve hasta 200 perfiles por solicitud.

¿Se puede encontrar una audiencia en X sin programar? Sí. El Sorsa Playground corre los endpoints de descubrimiento por una interfaz web: elige un método como la búsqueda de usuarios o la extracción de seguidores, fija cuántas páginas extraer, ve el costo de la solicitud antes de correr, y exporta los resultados. Usa los mismos datos que la API, y las primeras 100 solicitudes son gratis sin tarjeta, así que una extracción inicial de audiencia no cuesta nada antes de comprometerte con un plan.

Revisado por Keksich, fundador de Sorsa, especialista en marketing e investigador de la API de X.

Cómo se armó esta guía: los seis métodos son los que corremos contra la capa de datos de X en vivo mientras construimos y operamos la API alternativa de Twitter/X de Sorsa, y cada endpoint, parámetro y comportamiento por solicitud de aquí se re-revisó contra la documentación de Sorsa API durante esta revisión. La comparación de costos usa el precio por recurso de la API oficial de X tal como se publicó tras su actualización de abril de 2026, cruzado con nuestras propias tarifas publicadas. Verificado el 11 de junio de 2026.