API de Twitter con Python: guía completa para obtener datos de X en 2026

Por Sorsa Editorial

Actualizado en julio de 2026: re-verificado el precio de pago por uso de X, replanteadas las cifras de costo de Sorsa a las tarifas por lotes por cada 1,000 elementos, y agregada la oferta inicial de 100 solicitudes gratis.

Conclusión clave: Hay cuatro formas prácticas de obtener datos de Twitter/X con Python en 2026: el SDK oficial de X (pip install xdk), Tweepy, requests simple con un bearer token, o una API REST de terceros. Las vías oficiales cobran por recurso y requieren OAuth; una API de terceros de solo lectura necesita solo una clave API y conviene al trabajo intensivo en lecturas.

Si buscaste "twitter api python" esperando un pip install rápido y un fragmento funcional, el panorama actual es más enredado de lo que sugieren los tutoriales viejos. La API de X (antes Twitter) cambió su modelo de precios, cambió su autenticación y ahora publica un SDK oficial de Python que no existía hace un año.

Nosotros construimos y operamos Sorsa API, una API alternativa de Twitter/X, así que la vía de solo lectura es la que mejor conocemos: devuelve perfiles, tweets, búsqueda y seguidores como JSON limpio desde requests simple, con una clave API en el encabezado, sin flujo OAuth y sin aprobación de cuenta de desarrollador que esperar. En trabajo intensivo en lecturas Sorsa sale hasta 50 veces más barata que la API oficial de X: los endpoints por lotes bajan el costo a desde $0.02 por cada 1,000 tweets y desde $0.01 por cada 1,000 perfiles, cada plan mantiene 20 solicitudes por segundo, y cada cuenta nueva incluye 100 solicitudes gratis, sin tarjeta. No todo proyecto encaja en ese molde: unos necesitan publicar, otros necesitan la API oficial por cumplimiento, y otros desarrolladores solo quieren entender cómo funciona todo. Esta guía cubre los cuatro métodos con código funcional de Python, una comparación lado a lado, precio vigente, y un recolector de datos completo que pagina y carga los resultados directo a pandas. También puedes probar llamadas sin escribir código en el playground de Sorsa API.

Contenido

• Qué cambió: la API de X en 2026
• La mejor librería de Python para la API de X v2 (respuesta rápida)
• ¿Qué enfoque deberías usar?
• Método 1: SDK oficial de X para Python (XDK)
• Método 2: Tweepy
• Método 3: requests simple de Python con un bearer token
• Método 4: API de terceros con requests de Python
• Construir un recolector de datos de producción: paginación, reintentos y pandas
• Comparación: los cuatro métodos lado a lado
• Cómo obtener tus credenciales de API
• Tareas comunes: ejemplos de código
• En la práctica: mover las extracciones de solo lectura de la API oficial
• Preguntas frecuentes
• Cómo empezar

Qué cambió: la API de X en 2026

Si la última vez que tocaste la API de Twitter fue en 2023 o antes, esto es lo que es distinto.

El pago por uso es lo predeterminado. A inicios de 2026 X reemplazó sus viejos niveles de suscripción con un modelo de consumo. No hay plan Basic de $100 ni Pro de $5,000 para registros nuevos, y no hay nivel gratuito. Compras créditos por adelantado y pagas por recurso que lees: $0.005 por post, $0.010 por perfil de usuario y $0.010 por cada registro de seguidor o seguido (cifras verificadas en julio de 2026). Leer los datos de tu propia cuenta (tu cronología, tus marcadores, tus seguidores) es más barato a $0.001 por recurso, pero esa tarifa con descuento no aplica cuando lees otras cuentas.

Escribir se encareció tras la actualización de abril de 2026. Un post estándar ahora cuesta $0.015 por solicitud, y un post que contiene una URL salta a $0.20. Las acciones de follow, like y cita de post se quitaron de los niveles de autoservicio por completo y ahora requieren un contrato Enterprise. Si planeabas un bot de follow-back o un auto-liker, eso ya no es posible en una cuenta estándar de pago por uso.

Hay un tope duro de lectura. Las cuentas estándar están limitadas a 2 millones de lecturas de posts al mes. X también devuelve una porción de tu gasto como créditos de la API de xAI (Grok), hasta un 20 por ciento a volúmenes más altos. Para un desglose completo de lo que esto significa para un presupuesto real, consulta nuestro análisis de precios de la API de X y nuestra explicación de por qué la API de Twitter es tan cara.

X lanzó un SDK oficial de Python. El XDK (X Developer Kit) es un SDK autogenerado con type hints, paginación automática y soporte de streaming. Instálalo con pip install xdk. Es la primera librería oficial de Python que X ha publicado.

Tweepy todavía funciona. Admite la API de X v2 y sigue siendo la librería de comunidad más madura. El código existente de Tweepy corre bien con credenciales vigentes.

Las librerías viejas están muertas. El paquete original python-twitter de bear está archivado, y el paquete twitter en PyPI no se actualiza desde hace años. Si un tutorial te dice pip install python-twitter, ese tutorial está desactualizado. (Un wrapper de v2 separado y con mantenimiento activo publicado por sns-sdks se cubre en la siguiente sección.)

La mejor librería de Python para la API de X v2 (respuesta rápida)

Si solo quieres la versión corta: Tweepy es la mejor librería de Python de propósito general para la API de X v2, porque es madura, está bien documentada y admite lectura y escritura por flujos de bearer token y OAuth. Si quieres una herramienta de primera parte que siga la especificación de la API exactamente, usa el XDK oficial. Para recolección de datos de solo lectura, muchos desarrolladores se saltan las librerías por completo y llaman a una API REST de terceros con requests simple (revisa el Método 4).

Así se comparan las opciones principales.

Cada librería de la API oficial de arriba cobra a través del precio de pago por uso de X. El costo es idéntico llames a X con el XDK, con Tweepy o con requests crudo, porque el cargo es por recurso del lado de X, no por librería. La variable que de verdad controlas es cuántos recursos extraes, que es donde una API de terceros y los endpoints por lotes cambian las cuentas (cubierto abajo).

¿Qué enfoque deberías usar?

Elige la vía antes de escribir código. Ahorra horas.

Si tu proyecto solo lee datos públicos (perfiles, tweets, resultados de búsqueda, seguidores), una API de terceros elimina el baile de OAuth: una clave API en un encabezado y empiezas a extraer datos, sin solicitud de cuenta de desarrollador y sin compra de créditos. Si necesitas publicar o realizar acciones de escritura, usa la API oficial de X a través del XDK, Tweepy o requests crudo. Sorsa es de solo lectura y no publica en tu nombre.

Método 1: SDK oficial de X para Python (XDK)

El XDK es el primer SDK oficial de Python de X. Envuelve toda la superficie de la API v2 con modelos tipados, maneja la paginación automáticamente y admite los tres métodos de autenticación (bearer token, OAuth 2.0 PKCE, OAuth 1.0a).

Instálalo:

pip install xdk

Buscar tweets recientes

import os
from xdk import Client

client = Client(bearer_token=os.environ["BEARER_TOKEN"])

response = client.posts.recent_search(query="python lang:en")

for post in response.data:
    print(f"@{post.author_id}: {post.text[:120]}")

Esto devuelve posts que coinciden con tu consulta de los últimos 7 días. El objeto response incluye tokens de paginación, así que puedes recorrer las páginas sin rastrear cursores a mano.

Consultar un perfil de usuario

user = client.users.find_by_username(username="elonmusk")
print(f"@{user.data.username} - {user.data.public_metrics}")

Publicar un tweet (requiere OAuth 2.0)

Las operaciones de escritura necesitan autenticación en contexto de usuario. Fija tu Client ID y Client Secret como variables de entorno, y luego:

client = Client(
    client_id=os.environ["CLIENT_ID"],
    client_secret=os.environ["CLIENT_SECRET"],
)

client.posts.create(post_data={"text": "Hello from the XDK!"})

El XDK maneja el flujo OAuth 2.0 PKCE internamente, incluido el refresco de tokens.

Cuándo usar el XDK

El XDK es la elección correcta si quieres soporte oficial, necesitas acceso de escritura y estás empezando un proyecto nuevo. Los modelos tipados hacen que el autocompletado del IDE funcione bien, y la paginación automática ahorra código repetitivo. Las desventajas: el SDK es joven (lanzado a inicios de 2026, con un seguimiento pequeño pero creciente en GitHub), la documentación todavía es delgada, y pagas el precio de pago por uso de X por cada solicitud, así que una lectura de post cuesta $0.005 y una consulta de usuario cuesta $0.010 y esos cargos se apilan a escala. Los docs completos del SDK viven en docs.x.com/xdks/python/overview.

Método 2: Tweepy

Tweepy existe desde 2009 y sigue siendo la librería de Python más popular para la API de Twitter. Admite la API de X v2, maneja el límite de tasa y tiene extensa documentación de comunidad.

Instálala:

pip install tweepy

Buscar tweets recientes

import os
import tweepy

client = tweepy.Client(bearer_token=os.environ["BEARER_TOKEN"])

response = client.search_recent_tweets(
    query="python lang:en",
    max_results=10,
    tweet_fields=["created_at", "public_metrics"],
)

for tweet in response.data:
    metrics = tweet.public_metrics
    print(tweet.text[:120])
    print(f"  Likes: {metrics['like_count']}  Retweets: {metrics['retweet_count']}")

Obtener los seguidores de un usuario

user = client.get_user(username="elonmusk")
followers = client.get_users_followers(
    id=user.data.id,
    max_results=100,
    user_fields=["description", "public_metrics"],
)

for follower in followers.data:
    print(f"@{follower.username} - {follower.public_metrics['followers_count']} followers")

Publicar un tweet

client = tweepy.Client(
    consumer_key=os.environ["API_KEY"],
    consumer_secret=os.environ["API_SECRET"],
    access_token=os.environ["ACCESS_TOKEN"],
    access_token_secret=os.environ["ACCESS_TOKEN_SECRET"],
)

client.create_tweet(text="Hello from Tweepy!")

Cuándo usar Tweepy

Tweepy es la opción segura por defecto para la mayoría de quienes desarrollan en Python. Está probada en batalla, la comunidad es grande, y hay una respuesta en Stack Overflow para casi cualquier problema. Envuelve el manejo del límite de tasa, los reintentos y la paginación en una interfaz limpia. Las contrapartidas coinciden con el XDK: todavía necesitas una cuenta de desarrollador de X, todavía pagas por recurso, y los límites de tasa se heredan de la API oficial (típicamente 300 solicitudes por ventana de 15 minutos para búsqueda, aunque esto varía por endpoint). Si ya tienes código de Tweepy corriendo, no hay razón para migrar al XDK salvo que necesites una función que Tweepy no tenga. Docs completos: docs.tweepy.org.

Método 3: requests simple de Python con un bearer token

Sin librerías, sin wrappers, solo solicitudes HTTP. Este enfoque conviene a quienes quieren control total sobre lo que se envía y se recibe, o que trabajan en entornos donde instalar paquetes de terceros está restringido.

Buscar tweets recientes

import os
import requests

search_url = "https://api.x.com/2/tweets/search/recent"
headers = {"Authorization": f"Bearer {os.environ['BEARER_TOKEN']}"}
params = {
    "query": "python lang:en",
    "max_results": 10,
    "tweet.fields": "created_at,public_metrics,author_id",
}

response = requests.get(search_url, headers=headers, params=params)
data = response.json()

for tweet in data["data"]:
    print(tweet["text"][:120])
    print(f"  Likes: {tweet['public_metrics']['like_count']}")

Obtener un perfil de usuario

user_url = "https://api.x.com/2/users/by/username/elonmusk"
headers = {"Authorization": f"Bearer {os.environ['BEARER_TOKEN']}"}
params = {"user.fields": "description,public_metrics,created_at"}

response = requests.get(user_url, headers=headers, params=params)
user = response.json()["data"]

print(f"@{user['username']} - {user['public_metrics']['followers_count']} followers")

Manejar la paginación manualmente

search_url = "https://api.x.com/2/tweets/search/recent"
next_token = None
all_tweets = []

while True:
    params = {
        "query": "python lang:en",
        "max_results": 100,
        "tweet.fields": "created_at,public_metrics",
    }
    if next_token:
        params["next_token"] = next_token

    response = requests.get(search_url, headers=headers, params=params)
    data = response.json()
    all_tweets.extend(data.get("data", []))

    next_token = data.get("meta", {}).get("next_token")
    if not next_token:
        break

print(f"Collected {len(all_tweets)} tweets")

Cuándo usar requests crudo

Esto funciona cuando quieres cero dependencias más allá de requests, cuando estás depurando el comportamiento de la API, o cuando llamas a solo uno o dos endpoints y un SDK completo es demasiado. La desventaja es obvia: tú manejas la paginación, los códigos de error, el límite de tasa y la lógica de reintento. Para un script puntual está bien. Para un pipeline de producción terminarás escribiendo tu propio wrapper, momento en el que has reinventado Tweepy. Este método todavía requiere una cuenta de desarrollador de X y créditos de pago por uso, y el encabezado usa un bearer token para acceso de solo lectura.

Método 4: API de terceros con requests de Python

Si tu proyecto solo necesita leer datos públicos de Twitter, sáltate la API oficial por completo y llama a un proveedor de datos de terceros. Esta es la vía práctica para datos de Twitter sin una cuenta de desarrollador: sin OAuth, sin paso de solicitud, sin flujo de compra de créditos, solo una clave API en un encabezado, llamadas REST estándar, respuestas JSON, y 100 solicitudes gratis para probar antes de pagar nada. Así se ve con la API de Sorsa.

Obtener un perfil de usuario

import requests

headers = {"ApiKey": "YOUR_SORSA_API_KEY"}

response = requests.get(
    "https://api.sorsa.io/v3/info",
    headers=headers,
    params={"username": "elonmusk"},
)

user = response.json()
print(f"@{user['username']}: {user['display_name']}")
print(f"Followers: {user['followers_count']}")
print(f"Tweets: {user['tweets_count']}")

La respuesta incluye el perfil completo en una solicitud: ID, nombre de usuario, nombre visible, bio, ubicación, conteos de seguidores y seguidos, conteos de tweets y multimedia, estado de verificación, imágenes de perfil, fecha de creación de la cuenta, tweets fijados y URLs de la bio.

Buscar tweets

response = requests.post(
    "https://api.sorsa.io/v3/search-tweets",
    headers=headers,
    json={"query": "python programming", "order": "popular"},
)

for tweet in response.json()["tweets"]:
    print(f"@{tweet['user']['username']}: {tweet['full_text'][:120]}")
    print(f"  Likes: {tweet['likes_count']}  Views: {tweet['view_count']}")

Cada solicitud de búsqueda devuelve hasta 20 tweets, y cada tweet incluye el perfil completo del autor en el campo user. No hay solicitud extra (ni cargo extra) para obtener el número de seguidores o el estado de verificación de quien publicó, a diferencia de la API oficial donde expandir los datos de usuario suma $0.010 por usuario. El endpoint de búsqueda admite los mismos operadores avanzados que escribirías en la búsqueda de X (from:, to:, since:, until:, frases entre comillas, hashtags). La lista completa está en nuestra guía de operadores de búsqueda de Twitter.

Obtener seguidores

response = requests.get(
    "https://api.sorsa.io/v3/followers",
    headers=headers,
    params={"username": "elonmusk"},
)

for follower in response.json()["users"][:5]:
    print(f"@{follower['username']} - {follower['followers_count']} followers")

El endpoint /followers devuelve hasta 200 perfiles completos por solicitud, con paginación mediante un parámetro next_cursor.

Traer varios tweets en lote

response = requests.post(
    "https://api.sorsa.io/v3/tweet-info-bulk",
    headers=headers,
    json={
        "tweet_links": [
            "https://x.com/elonmusk/status/1234567890",
            "https://x.com/OpenAI/status/9876543210",
            "1122334455667788",
        ]
    },
)

for tweet in response.json()["tweets"]:
    print(f"@{tweet['user']['username']}: {tweet['full_text'][:100]}")

El endpoint /tweet-info-bulk acepta hasta 100 URLs o IDs de tweets en una sola solicitud y devuelve objetos completos de tweets con datos de autor. Una llamada, 100 tweets.

Por qué este enfoque funciona para proyectos de solo lectura

Los Métodos 1 a 3 requieren una cuenta de desarrollador de X (con un paso de solicitud), créditos comprados, tokens OAuth y cobro por recurso. El Método 4 necesita una clave API en un encabezado. Sorsa usa precio de tarifa plana por solicitud: una llamada es una solicitud de tu cuota sin importar cuántos tweets o perfiles devuelva, así que una búsqueda que devuelve 20 tweets cuesta lo mismo que una sola consulta por ID. En el plan Pro de Sorsa ($199 al mes por 100,000 solicitudes) eso sale en $0.00199 por solicitud. Enrutado por endpoints por lotes, eso es desde $0.02 por cada 1,000 tweets vía /tweet-info-bulk y desde $0.01 por cada 1,000 perfiles vía /followers, y el límite de tasa es de 20 solicitudes por segundo en todos los planes, sin ventanas de 15 minutos.

La contrapartida es que no hay acceso de escritura: no puedes publicar, dar like ni seguir a través de una API de terceros de solo lectura. Si necesitas esas, usa los Métodos 1 o 2 para las escrituras y una API de terceros para el trabajo intensivo en lecturas. Ese híbrido es exactamente lo que montamos para un cliente fintech que corría un pipeline de sentimiento: venían pagando $5,000 al mes en un plan Pro legado, movimos todas las lecturas (rastreo de menciones, monitoreo de competidores, análisis de seguidores) a un proveedor de terceros y conservamos una configuración oficial mínima para publicar alertas, y su gasto total bajó a menos de $250 al mes. Si vienes de la API oficial, nuestra guía de migración de la API de X mapea los endpoints y los nombres de campo.

Construir un recolector de datos de producción: paginación, reintentos y pandas

Los ejemplos de una sola llamada de arriba alcanzan para probar tu clave, pero el trabajo de datos real necesita tres cosas más: paginación para pasar de los primeros 20 resultados, manejo de errores para que una respuesta mala no mate una corrida larga, y una forma de convertir el JSON en algo que puedas analizar. Aquí hay un recolector completo y ejecutable que hace los tres contra Sorsa, y luego carga los resultados en un DataFrame de pandas y los guarda en CSV.

import os
import time
import requests
import pandas as pd

API_KEY = os.environ["SORSA_API_KEY"]   # read the key from the environment, never hard-code it
BASE = "https://api.sorsa.io/v3"
HEADERS = {"ApiKey": API_KEY}


def post_with_retry(path, payload, retries=3):
    """POST to Sorsa with exponential backoff on transient errors and 429 responses."""
    for attempt in range(retries):
        try:
            response = requests.post(f"{BASE}{path}", headers=HEADERS, json=payload, timeout=30)
            response.raise_for_status()
            return response.json()
        except requests.HTTPError as error:
            status = error.response.status_code
            if status == 429 and attempt < retries - 1:   # rate limited: wait and retry
                time.sleep(2 ** attempt)
                continue
            raise   # 401 (bad key), 400 (bad params), and the final 429 surface here
        except requests.RequestException:
            if attempt == retries - 1:
                raise
            time.sleep(2 ** attempt)


def collect_tweets(query, order="latest", max_pages=5):
    """Collect tweets for a query, following next_cursor pagination up to max_pages."""
    cursor, rows = None, []
    for page in range(max_pages):
        payload = {"query": query, "order": order}
        if cursor:
            payload["next_cursor"] = cursor
        data = post_with_retry("/search-tweets", payload)
        batch = data.get("tweets", [])
        rows.extend(batch)
        print(f"page {page + 1}: +{len(batch)} tweets (total {len(rows)})")
        cursor = data.get("next_cursor")
        if not cursor:        # no cursor means there are no more pages
            break
    return rows


if __name__ == "__main__":
    tweets = collect_tweets('"machine learning" lang:en', max_pages=3)
    df = pd.json_normalize(tweets)
    df.to_csv("tweets.csv", index=False)
    print(f"Saved {len(df)} rows to tweets.csv")

Unas cuantas cosas que vale señalar:

• La paginación usa next_cursor. Cada respuesta de /search-tweets devuelve hasta 20 tweets más un next_cursor. Pasa ese cursor de vuelta en el cuerpo de la siguiente solicitud y repite hasta que quede vacío. El guardián max_pages evita que una consulta amplia se desboque y queme tu cuota. Los docs de Sorsa cubren el flujo del cursor en detalle.
• Reintentos y retroceso. raise_for_status() convierte las respuestas fallidas en excepciones. Un 429 (excediste el límite de 20 solicitudes por segundo) dispara un retroceso exponencial corto y un reintento. Un 401 significa una clave mala y se muestra de inmediato, así que lo notas en lugar de recolectar nada en silencio.
• La clave vive en una variable de entorno. Fíjala una vez con export SORSA_API_KEY='your_key' y léela con os.environ. Nunca subas la clave al control de versiones.

Cargar los datos en pandas

pandas.json_normalize aplana los objetos de tweet anidados (incluido el autor incrustado bajo user.*) en una tabla plana en una línea:

df = pd.json_normalize(tweets)

# Keep the columns most analyses need
columns = [
    "id", "full_text", "created_at", "lang",
    "likes_count", "retweet_count", "reply_count", "view_count",
    "user.username", "user.followers_count", "user.verified",
]
df = df[columns]

# Example: engagement rate per tweet
df["engagement_rate"] = (
    df["likes_count"] + df["retweet_count"] + df["reply_count"]
) / df["view_count"].clip(lower=1)

df.to_csv("tweets.csv", index=False)      # portable, opens in Excel or Sheets
df.to_parquet("tweets.parquet")           # compact, fast to reload for repeated analysis

Desde aquí puedes agrupar por autor, computar tasas de engagement, correr clasificación de sentimiento (consulta nuestra guía de análisis de sentimientos en Twitter) o construir un dataset de entrenamiento para un modelo. Como cada tweet ya incluye el perfil completo del autor, no necesitas una segunda llamada por autor para obtener los conteos de seguidores o el estado de verificación, que es la razón principal por la que este patrón se mantiene barato a escala.

Comparación: los cuatro métodos lado a lado

Cómo obtener tus credenciales de API

Cuenta de desarrollador de X (Métodos 1 a 3)

1. Ve a developer.x.com, inicia sesión con tu cuenta de X y crea un Project y una App adentro.
2. Para acceso de solo lectura, copia tu Bearer Token. Este único token alcanza para búsqueda, consultas de usuario y cronologías.
3. Para publicar y otras acciones de escritura, abre User Authentication Settings y fija los permisos en Read and Write, y luego genera las cuatro credenciales OAuth 1.0a: API Key (Consumer Key), API Key Secret (Consumer Secret), Access Token y Access Token Secret. Las cuatro se requieren para publicar.
4. Compra créditos en la Developer Console. El pago por uso no tiene gasto mínimo, pero tu saldo debe estar por encima de cero antes de que cualquier llamada autenticada tenga éxito.

Guarda las credenciales en variables de entorno, nunca en el código:

export BEARER_TOKEN='AAAAAAAAAAAAAAAAAAAAAxxxxxxx'
export API_KEY='your_api_key'
export API_SECRET='your_api_secret'
export ACCESS_TOKEN='your_access_token'
export ACCESS_TOKEN_SECRET='your_access_token_secret'

Para un recorrido captura por captura del portal, incluido dónde encontrar el bearer token y cómo cambiar los permisos a Read and Write, revisa nuestra guía de cómo obtener una clave API de Twitter/X. Para lo que cuesta cada credencial por solicitud, revisa la sección Qué cambió de arriba.

Clave API de Sorsa (Método 4)

1. Crea una cuenta en api.sorsa.io/overview.
2. Tu clave API se genera de inmediato en la página de claves del panel.
3. Empieza a hacer solicitudes. Cada cuenta nueva incluye 100 solicitudes gratis: por única vez, sin tarjeta, nunca vencen y cubren los 40 endpoints. Sin proceso de solicitud, sin compra de créditos para empezar.

El inicio rápido en los docs de Sorsa recorre tu primera llamada en menos de un minuto, incluido el formato del encabezado ApiKey.

Tareas comunes: ejemplos de código

Cómo buscar tweets por palabra clave

Los cuatro métodos admiten la búsqueda por palabra clave. Los Métodos 1 a 3 usan el endpoint de búsqueda reciente de la API de X v2 (últimos 7 días, o el archivo completo en el Pro legado). El Método 4 busca en el archivo público completo. Para construir consultas complejas, combina operadores: "machine learning" from:OpenAI since:2026-01-01 -is:retweet devuelve posts originales de @OpenAI que mencionan la frase desde enero de 2026. Para un constructor visual, usa el constructor de búsquedas dentro del playground de Sorsa; la referencia completa de operadores está en la guía de operadores de búsqueda enlazada arriba.

Cómo obtener tweets históricos

El endpoint de búsqueda reciente en la API oficial solo cubre los últimos 7 días salvo que tengas acceso al archivo completo legado. Una API de terceros busca en el archivo completo directamente, y los operadores de fecha (since:, until:) te dejan paginar hacia atrás por posts más viejos. Para extracciones históricas grandes y las contrapartidas involucradas, consulta nuestra guía de datos históricos de Twitter.

Cómo obtener los seguidores de un usuario

En la API oficial, las listas de seguidores se paginan a 100 usuarios por página y cada perfil es un recurso facturable de $0.010, así que 1,000 seguidores cuestan unos $10 en lecturas de usuario. A través de Sorsa, /followers devuelve hasta 200 perfiles por solicitud, así que 1,000 seguidores son 5 solicitudes, unos $0.01 en el plan Pro. Hay más detalle en nuestra guía de la API de seguidores de Twitter.

Cómo traer datos de tweets por ID

Cuando tienes una lista de IDs de tweets, las consultas por lotes son la vía eficiente. En la API oficial, GET /2/tweets?ids=... acepta hasta 100 IDs y cobra $0.005 por cada tweet devuelto. Con Sorsa, POST /tweet-info-bulk acepta hasta 100 URLs o IDs y cuenta como una solicitud, devolviendo objetos completos de tweets con datos de autor.

En la práctica: mover las extracciones de solo lectura de la API oficial

Un patrón que vemos seguido: un equipo empieza en la API oficial de X con Tweepy porque es lo que muestran los tutoriales viejos, y luego choca con fricción en un proyecto que solo lee datos. Un equipo de analítica llegó a nosotros tras construir un recolector diario que extraía perfiles y tweets recientes de unos pocos miles de cuentas rastreadas. El código funcionaba, pero cada corrida quemaba lecturas facturables de posts y usuarios, la aprobación de cuenta de desarrollador y la lógica de refresco de OAuth sumaban tiempo de configuración, y el tope mensual de 2 millones de lecturas significaba que tenían que vigilar el volumen de cerca a medida que crecía su lista de cuentas.

El arreglo no fue una reescritura, solo un cambio en la capa de transporte. La lógica de recolección, la normalización con pandas y la programación se quedaron iguales. Reemplazaron el cliente de Tweepy con el patrón de requests simple del Método 4, lo apuntaron a los endpoints de búsqueda y /followers, y dejaron el flujo OAuth por completo (un encabezado ApiKey en lugar de gestión de tokens). Como cada solicitud devuelve hasta 20 tweets o 200 perfiles de seguidores en lugar de cobrar por recurso, la misma extracción diaria costó una fracción de lo que costaba, y un límite por segundo reemplazó al tope mensual como lo único contra lo que ritmar. Para una carga de solo lectura, la API oficial había sido la forma cara de hacer un trabajo simple.

Preguntas frecuentes

¿Hay una API de Twitter gratuita para Python en 2026?

No desde X. La API oficial de X no tiene acceso gratuito bajo el pago por uso: debes comprar créditos antes de hacer cualquier solicitud, y las cuentas nuevas no reciben créditos gratis. Sorsa le da a cada cuenta nueva 100 solicitudes gratis: por única vez, sin tarjeta, nunca vencen y cubren los 40 endpoints, suficiente para hasta 10,000 tweets o 20,000 perfiles por endpoints por lotes. Para un desglose completo, consulta nuestro análisis de si la API de Twitter es gratis en 2026.

¿Cuál es la forma más fácil de obtener datos de Twitter en Python?

Llama a una API REST de terceros con la librería requests: obtén una clave API, pásala en un encabezado y envía por POST tu consulta a un endpoint de búsqueda. El JSON mapea directo a dicts de Python y a pandas. Es más simple que la API oficial más Tweepy porque no hay flujo OAuth ni aprobación de cuenta de desarrollador que esperar.

¿Cómo cargar tweets en un DataFrame de pandas en Python?

Recolecta los objetos de tweet en una lista, y luego llama a pandas.json_normalize(tweets) para aplanar los campos anidados (incluido el autor incrustado) en un DataFrame en una línea. Guarda con df.to_csv("tweets.csv", index=False) para un archivo portable, o df.to_parquet(...) para un archivo columnar compacto que puedes recargar rápido. Desde ahí puedes filtrar, agrupar y computar métricas de engagement con pandas normal.

¿Cómo paginar por los tweets en Python?

Cada respuesta incluye un next_cursor (o next_token en la API oficial). Pásalo de vuelta en la siguiente solicitud y repite hasta que quede vacío. Siempre acota el bucle con un guardián max_pages para que una consulta amplia no se desboque y consuma tu cuota. El script del recolector de arriba muestra el patrón.

¿Se pueden obtener datos de Twitter con Python sin una clave API?

Técnicamente sí, por web scraping con librerías como Twikit o Playwright, pero los scrapers se rompen cada 2 a 4 semanas cuando X rota los tokens internos y los identificadores GraphQL, y arriesgas baneos de cuenta. Para acceso confiable, una clave API (de X o de un proveedor de terceros) es la vía práctica. Consulta nuestra guía de cómo scrapear X para el enfoque técnico o nuestra comparación de scrapers de Twitter para las opciones administradas.

¿Cuánto cuesta el acceso a la API de Twitter para quienes desarrollan en Python?

En la API oficial de X: $0.005 por lectura de post, $0.010 por lectura de perfil de usuario, $0.015 por post estándar creado y $0.20 por un post que contiene una URL. Una búsqueda que devuelve 20 tweets cuesta $0.10, y traer 1,000 perfiles de seguidores cuesta unos $10. Hay un tope de 2 millones de lecturas de posts al mes. En Sorsa, el cobro de tarifa plana por solicitud sale desde $0.02 por cada 1,000 tweets en endpoints por lotes y desde $0.01 por cada 1,000 perfiles, con planes desde $49 al mes y 100 solicitudes gratis para empezar.

¿Tweepy todavía funciona en 2026?

Sí. Tweepy admite la API de X v2 y funciona con la autenticación vigente (bearer tokens y OAuth). Requiere créditos de la API de X de pago: no hay forma de usar Tweepy sin una cuenta de desarrollador de X activa con créditos comprados bajo el pago por uso.

¿Cómo manejar los límites de tasa con la API de Twitter en Python?

La API oficial aplica límites por ventana de 15 minutos (típicamente 300 a 900 solicitudes según el endpoint) y devuelve un 429 con un encabezado Retry-After cuando llegas a uno. Tweepy y el XDK retroceden automáticamente; con requests crudo revisas los encabezados y duermes antes de reintentar. Para una tabla completa de límites por endpoint, consulta nuestra guía de límites de tasa de la API de X. Una API de terceros como Sorsa usa un límite por segundo (20 solicitudes por segundo) en lugar de ventanas, así que ante un 429 esperas un segundo y reintentas.

Cómo empezar

Elige un método y corre uno de los ejemplos de arriba.

• Datos de solo lectura: toma una clave del panel de Sorsa, pégala en el dict headers de cualquier ejemplo del Método 4 y corre el script. Tus primeras 100 solicitudes son gratis, sin tarjeta, y tendrás datos estructurados de Twitter en tu terminal en menos de un minuto. La documentación de Sorsa API cubre los 40 endpoints.
• Leer y escribir: crea una cuenta de desarrollador de X en developer.x.com, compra créditos y corre los ejemplos del XDK o de Tweepy con tu bearer token.
• Sin código todavía: el playground en el navegador enlazado arriba te deja probar cualquier endpoint por una interfaz web antes de escribir una línea de Python.

Para una mirada más amplia a los proveedores de solo lectura, consulta nuestra comparación de alternativas a la API de Twitter.

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

Cómo verificamos esta guía

Revisamos cada afirmación externa contra fuentes primarias en julio de 2026. Los detalles del XDK oficial (el paquete pip install xdk, el cliente autogenerado, la paginación automática, el streaming y los tres métodos de autenticación) salen del anuncio para desarrolladores de X de los XDKs de Python y TypeScript y de la documentación del XDK en docs.x.com. El soporte continuo de v2 de Tweepy se confirmó contra la documentación de Tweepy. Las cifras de precio de la API de X reflejan el modelo de pago por uso vigente, incluidos los cambios de costo de escritura de abril de 2026, y el comportamiento de los endpoints de Sorsa, el agrupamiento por solicitud y el precio de los planes salen de la documentación de Sorsa API. No citamos conteos de tweets ni de estrellas de librerías, porque esos números se mueven; donde una cifra podría envejecer, describimos el mecanismo en su lugar. Si detectas un número que ha cambiado desde la publicación, los docs dentro del producto son siempre la fuente de verdad vigente.