> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sorsa.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Seguidores y cuentas seguidas

# Cómo obtener seguidores y cuentas seguidas de Twitter mediante API

Las listas de seguidores y cuentas seguidas de una cuenta pública de X (antes Twitter) permiten analizar su red social. Los seguidores muestran quién se interesa por una marca, tema o persona. Las cuentas seguidas revelan a quién presta atención: referentes, competidores y fuentes de información.

Sorsa API ofrece `/followers` para obtener seguidores y `/follows` para obtener cuentas seguidas. Ambos devuelven hasta 200 perfiles completos por solicitud y permiten recorrer la lista con cursores. Cada perfil incluye biografía, seguidores, número de publicaciones, ubicación, verificación, imagen y otros datos.

Esta guía cubre desde la primera solicitud hasta la recopilación a escala, el filtrado, el análisis de audiencias compartidas y la paginación.

> **Empieza gratis:** `/followers`, `/follows` y `/verified-followers` están disponibles con las primeras 100 solicitudes gratuitas, sin tarjeta ni caducidad. Con hasta 200 perfiles por solicitud, permiten consultar aproximadamente 20.000 seguidores antes de necesitar un plan de pago.

> **Nota:** encontrarás más métodos y ejemplos de análisis en la [guía de seguidores y cuentas seguidas](https://api.sorsa.io/blog/twitter-followers-api) del blog.

***

## Ejemplo básico: obtener seguidores

Una solicitud basta para recuperar la primera página de seguidores de una cuenta pública.

### cURL

```bash theme={null}
curl "https://api.sorsa.io/v3/followers?username=stripe" \
  -H "ApiKey: YOUR_API_KEY"
```

### Python

```python theme={null}
import requests

resp = requests.get(
    "https://api.sorsa.io/v3/followers",
    headers={"ApiKey": "YOUR_API_KEY"},
    params={"username": "stripe"},
)
for user in resp.json().get("users", []):
    print(f"@{user['username']} - {user.get('description', '')[:80]}")
```

### JavaScript

```javascript theme={null}
const resp = await fetch(
  "https://api.sorsa.io/v3/followers?username=stripe",
  { headers: { "ApiKey": "YOUR_API_KEY" } }
);
const { users } = await resp.json();
users.forEach((u) =>
  console.log(`@${u.username} - ${u.description?.slice(0, 80) ?? ""}`)
);
```

La solicitud GET incluye tu clave y un nombre de usuario. La respuesta es un objeto con un array `users` de hasta 200 perfiles y un `next_cursor` para la paginación.

> **Consejo:** consulta seguidores sin código con [Recent Followers](https://api.sorsa.io/playground/recent-followers) o [API Playground](https://api.sorsa.io/playground).

***

## Ejemplo básico: obtener cuentas seguidas

`/follows` funciona igual, pero devuelve las cuentas que sigue el usuario:

```bash theme={null}
curl "https://api.sorsa.io/v3/follows?username=stripe" \
  -H "ApiKey: YOUR_API_KEY"
```

```python theme={null}
resp = requests.get(
    "https://api.sorsa.io/v3/follows",
    headers={"ApiKey": "YOUR_API_KEY"},
    params={"username": "stripe"},
)
for user in resp.json().get("users", []):
    print(f"@{user['username']} ({user['followers_count']} followers)")
```

***

## Referencia de endpoints

Ambos utilizan GET y las mismas opciones de entrada.

### `GET /v3/followers`

Devuelve los usuarios que **siguen** a la cuenta indicada.

### `GET /v3/follows`

Devuelve las cuentas que el usuario indicado **sigue**.

### Parámetros de consulta

| Parámetro     | Tipo    | Obligatorio     | Descripción                                                                                                   |
| :------------ | :------ | :-------------- | :------------------------------------------------------------------------------------------------------------ |
| `username`    | string  | Uno de los tres | Nombre sin `@`. Ejemplo: `stripe`.                                                                            |
| `user_id`     | string  | Uno de los tres | ID numérico. Ejemplo: `44196397`.                                                                             |
| `user_link`   | string  | Uno de los tres | URL completa. Ejemplo: `https://x.com/stripe`.                                                                |
| `next_cursor` | integer | No              | Cursor de paginación. Envía el valor `next_cursor` de la respuesta anterior para obtener la siguiente página. |

Proporciona exactamente uno de `username`, `user_id` o `user_link`.

### Respuesta

```json theme={null}
{
  "users": [
    {
      "id": "1234567890",
      "username": "developer_jane",
      "display_name": "Jane Chen",
      "description": "Full-stack developer. Building things with APIs.",
      "location": "San Francisco, CA",
      "profile_image_url": "https://pbs.twimg.com/profile_images/...",
      "profile_background_image_url": "https://pbs.twimg.com/profile_banners/...",
      "followers_count": 4820,
      "followings_count": 312,
      "tweets_count": 1847,
      "favourites_count": 5231,
      "media_count": 89,
      "verified": false,
      "protected": false,
      "can_dm": true,
      "possibly_sensitive": false,
      "created_at": "2018-01-15T08:22:41Z",
      "bio_urls": ["https://janechen.dev"],
      "pinned_tweet_ids": ["1987654321098765432"]
    }
  ],
  "next_cursor": 1234567890
}
```

Cada usuario incluye: `id`, `username`, `display_name`, `description`, `location`, `created_at`, `followers_count`, `followings_count`, `favourites_count`, `tweets_count`, `media_count`, `profile_image_url`, `profile_background_image_url`, `bio_urls`, `pinned_tweet_ids`, `verified`, `can_dm`, `protected` y `possibly_sensitive`.

Cada página devuelve hasta **200 usuarios**. Si hay `next_cursor`, envíalo en la siguiente solicitud. Si falta o es nulo, has llegado al final.

***

## Recorrer una lista completa de seguidores

Una solicitud devuelve una página. Para recopilar la lista completa, repite las consultas con `next_cursor` hasta que no aparezca.

### Python

```python theme={null}
import requests
import time

API_KEY = "YOUR_API_KEY"

def get_all_followers(username, max_pages=50):
    """Fetch the complete follower list of a public account."""
    all_users = []
    cursor = None

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

        resp = requests.get(
            "https://api.sorsa.io/v3/followers",
            headers={"ApiKey": API_KEY},
            params=params,
            timeout=30,
        )
        resp.raise_for_status()
        data = resp.json()

        users = data.get("users", [])
        all_users.extend(users)
        print(f"Page {page + 1}: {len(users)} followers (total: {len(all_users)})")

        cursor = data.get("next_cursor")
        if not cursor:
            print("Reached end of list.")
            break
        time.sleep(0.05)  # stay under 20 req/s

    return all_users


followers = get_all_followers("stripe", max_pages=100)
print(f"\nTotal followers collected: {len(followers)}")
```

### JavaScript

```javascript theme={null}
const API_KEY = "YOUR_API_KEY";

async function getAllFollowers(username, maxPages = 50) {
  const allUsers = [];
  let cursor = null;

  for (let page = 0; page < maxPages; page++) {
    const params = new URLSearchParams({ username });
    if (cursor) params.set("next_cursor", cursor);

    const resp = await fetch(
      `https://api.sorsa.io/v3/followers?${params}`,
      { headers: { "ApiKey": API_KEY } }
    );
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);

    const data = await resp.json();
    allUsers.push(...(data.users || []));

    console.log(`Page ${page + 1}: ${data.users?.length || 0} followers (total: ${allUsers.length})`);

    cursor = data.next_cursor;
    if (!cursor) break;
    await new Promise((r) => setTimeout(r, 50));
  }
  return allUsers;
}

const followers = await getAllFollowers("stripe");
```

El mismo patrón funciona con `/follows`: cambia la URL.

Consulta el comportamiento general en [Paginación](https://docs.sorsa.io/es/pagination).

***

## Obtener la lista completa de cuentas seguidas

El código es idéntico cambiando el endpoint. Las cuentas que sigue una persona pueden revelar más que sus seguidores: un fundador sigue a inversores, socios y competidores; un influencer, a sus fuentes de información.

```python theme={null}
def get_all_following(username, max_pages=50):
    """Fetch the complete list of accounts a user follows."""
    all_users = []
    cursor = None

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

        resp = requests.get(
            "https://api.sorsa.io/v3/follows",
            headers={"ApiKey": API_KEY},
            params=params,
            timeout=30,
        )
        resp.raise_for_status()
        data = resp.json()

        users = data.get("users", [])
        all_users.extend(users)

        cursor = data.get("next_cursor")
        if not cursor:
            break
        time.sleep(0.05)

    return all_users


following = get_all_following("naval", max_pages=20)
print(f"@naval follows {len(following)} accounts")

# Sort by follower count to see the biggest names
following.sort(key=lambda u: u.get("followers_count", 0), reverse=True)
for u in following[:10]:
    print(f"  @{u['username']} ({u['followers_count']:,} followers)")
```

***

## Aplicaciones prácticas

### Filtrar seguidores por criterios del perfil

Como cada usuario incluye metadatos completos, puedes segmentar la audiencia por sus atributos sin llamadas adicionales:

```python theme={null}
followers = get_all_followers("competitor_handle", max_pages=20)

# High-value accounts: 1K+ followers, active (100+ tweets), not protected
qualified = [
    u for u in followers
    if u.get("followers_count", 0) >= 1000
    and u.get("tweets_count", 0) >= 100
    and not u.get("protected", False)
]
print(f"Qualified leads: {len(qualified)} out of {len(followers)} total")

# Accounts with websites in their bio (potential business leads)
with_websites = [u for u in followers if u.get("bio_urls")]
print(f"Accounts with website links: {len(with_websites)}")

# Filter by location keyword (self-reported)
in_usa = [
    u for u in followers
    if "usa" in (u.get("location") or "").lower()
    or "united states" in (u.get("location") or "").lower()
    or ", us" in (u.get("location") or "").lower()
]
print(f"US-based followers: {len(in_usa)}")
```

`location` es texto libre introducido por el usuario. Para datos de país más fiables, utiliza `/about`. Consulta el proceso en [Geografía de la audiencia](https://docs.sorsa.io/es/Audience-Geography).

### Encontrar audiencias compartidas entre competidores

Obtén las listas de varios competidores e identifica usuarios que sigan a dos o más. Son personas que han mostrado interés en el tema varias veces.

```python theme={null}
from collections import Counter

competitors = ["competitor1", "competitor2", "competitor3"]
all_ids = []

for handle in competitors:
    followers = get_all_followers(handle, max_pages=10)
    ids = [u["id"] for u in followers]
    all_ids.extend(ids)
    print(f"@{handle}: {len(followers)} followers collected")

# Count how many competitor lists each user appears in
counts = Counter(all_ids)
overlap = {uid: count for uid, count in counts.items() if count >= 2}
print(f"\nUsers following 2+ competitors: {len(overlap)}")
```

Consulta cómo combinar seguidores, búsquedas de biografías y miembros de comunidades en [Descubrimiento del público objetivo](https://docs.sorsa.io/es/target-audiences-Discovery).

### Descubrir a quién siguen los referentes del sector

Consulta las cuentas seguidas de un experto para descubrir perfiles especializados, nuevas voces y herramientas a las que presta atención.

```python theme={null}
following = get_all_following("pmarca", max_pages=10)

print(f"@pmarca follows {len(following)} accounts. Top by follower count:")
following.sort(key=lambda u: u.get("followers_count", 0), reverse=True)
for u in following[:15]:
    print(f"  @{u['username']} ({u['followers_count']:,} followers)")
    print(f"    {u.get('description', '')[:70]}\n")
```

***

## Seguidores verificados

`/verified-followers` funciona como `/followers`, pero devuelve solo cuentas verificadas con marca azul, dorada o gris. Resulta útil para:

1. **Filtrar perfiles destacados** sin procesar toda la lista.
2. **Ahorrar solicitudes en cuentas grandes.** Recorrer 10 millones de seguidores para encontrar 5.000 verificados requiere unas 50.000 solicitudes; `/verified-followers` permite obtenerlos en unas 25.

```bash theme={null}
curl "https://api.sorsa.io/v3/verified-followers?username=stripe" \
  -H "ApiKey: YOUR_API_KEY"
```

La respuesta y la paginación son idénticas a `/followers`. Recorre `next_cursor` del mismo modo. Consulta la [referencia](https://docs.sorsa.io/es/api-reference/usuarios/seguidores-verificados).

***

## Estimar el consumo a escala

Cada página devuelve hasta 200 usuarios. Como referencia:

| Tamaño de la cuenta     | Páginas | Solicitudes |
| :---------------------- | :------ | :---------- |
| 1.000 seguidores        | 5       | 5           |
| 10.000 seguidores       | 50      | 50          |
| 100.000 seguidores      | 500     | 500         |
| 1.000.000 de seguidores | 5.000   | 5.000       |

A 20 solicitudes por segundo, los mínimos teóricos para 50 y 500 llamadas son 2,5 y 25 segundos. Una cadena de cursores es secuencial: cada página depende de la anterior. La duración real también incluye latencia, pausas y reintentos. Para cuentas de millones de seguidores, considera una muestra, como las primeras 50 páginas (unos 10.000 seguidores), salvo que necesites cobertura completa.

Las 100 solicitudes gratuitas cubren unos 20.000 seguidores; Starter (10.000 solicitudes mensuales), unos 2 millones; Pro (100.000), unos 20 millones. Consulta los [precios](https://api.sorsa.io/pricing).

***

## Actualidad de los datos y casos especiales

**Orden de seguidores.** `/followers` utiliza el orden proporcionado por X, generalmente cronológico inverso. Las primeras páginas contienen los seguidores más recientes.

**Cuentas protegidas.** Las listas de cuentas privadas no son accesibles. El endpoint devuelve un error.

**Contador frente a lista recuperada.** `followers_count` es un contador de X en tiempo real. La lista disponible puede diferir por cuentas suspendidas, desactivadas o eliminadas recientemente. En cuentas grandes puede haber una diferencia de varios puntos porcentuales; no exijas igualdad exacta con el contador. Es un comportamiento de la plataforma.

**Los perfiles son actuales.** Los datos reflejan el perfil en el momento de la solicitud, no cuando comenzó el seguimiento. El `id` numérico es estable; el nombre de usuario puede cambiar.

**Muestras de cuentas muy grandes.** Para cuentas con más de unos 500.000 seguidores, las primeras 50–100 páginas (hasta 10.000–20.000 perfiles) sirven para estudiar seguidores recientes. Es una muestra ordenada, no aleatoria ni representativa de toda la audiencia. La recopilación completa suele ser innecesaria salvo que requieras cobertura total.

***

## Próximos pasos

* [Descubrimiento del público objetivo](https://docs.sorsa.io/es/target-audiences-Discovery): combina seguidores, biografías, comunidades y contenido.
* [Análisis de competidores](https://docs.sorsa.io/es/Competitor-Analysis): incorpora relaciones de seguimiento a tu análisis.
* [Geografía de la audiencia](https://docs.sorsa.io/es/Audience-Geography): distribución por país con `/about`.
* [Paginación](https://docs.sorsa.io/es/pagination): patrones para grandes volúmenes.
* [Referencia de la API](https://docs.sorsa.io/es/api-reference-guide): especificación de estos y los demás endpoints.