API de analítica de Twitter para cualquier cuenta

#Qué devuelve una API de analítica de Twitter

Una API de analítica de Twitter es un endpoint que devuelve en JSON, en lugar de un panel, los números detrás de los posts y las cuentas de X: los contadores de engagement de cada post, los totales de seguidores y de posts de cada cuenta, y los propios posts sobre los que contar. Lo que puede devolver depende de una sola división: números públicos que cualquiera puede leer y números privados que solo puede leer el autor.

Para ver primero en un navegador la tasa de engagement de una cuenta, la Calculadora de tasa de engagement de Twitter gratuita lee sus posts más recientes. El resto de esta guía hace el mismo trabajo en código, para cualquier cantidad de cuentas y de posts.

La tabla asocia cada número con el campo que lo contiene. Sorsa API devuelve los seis contadores públicos en cada post que envía; la API oficial de X guarda esos mismos contadores bajo public_metrics y los privados bajo non_public_metrics.

• Likes

  Campo de Sorsa API

  likes_count

  Campo de la API oficial de X

  like_count

  Quién puede leerla

  cualquiera

• Reposts

  Campo de Sorsa API

  retweet_count

  Campo de la API oficial de X

  retweet_count

  Quién puede leerla

  cualquiera

• Respuestas

  Campo de Sorsa API

  reply_count

  Campo de la API oficial de X

  reply_count

  Quién puede leerla

  cualquiera

• Citas

  Campo de Sorsa API

  quote_count

  Campo de la API oficial de X

  quote_count

  Quién puede leerla

  cualquiera

• Visualizaciones

  Campo de Sorsa API

  view_count

  Campo de la API oficial de X

  impression_count

  Quién puede leerla

  cualquiera

• Marcadores

  Campo de Sorsa API

  bookmark_count

  Campo de la API oficial de X

  bookmark_count

  Quién puede leerla

  cualquiera

• Clics en enlaces

  Campo de Sorsa API

  ninguno

  Campo de la API oficial de X

  url_link_clicks

  Quién puede leerla

  el autor

• Clics en el perfil

  Campo de Sorsa API

  ninguno

  Campo de la API oficial de X

  user_profile_clicks

  Quién puede leerla

  el autor

Las visualizaciones también son públicas. La documentación de métricas (se abre en una pestaña nueva) de X enumera las impresiones como una métrica pública que un bearer token simple lee en cualquier post; una persona que ve un post dos veces cuenta como dos impresiones.

Los números privados tienen tres puertas, todas vinculadas a la cuenta que escribió el post. La primera es el panel de analítica en x.com. La segunda es GET /2/tweets/analytics (se abre en una pestaña nueva) de la API oficial de X: hasta 100 IDs de tus posts, como totales o como series por hora, por día y por semana, firmadas con el token OAuth de tu cuenta. La tercera es la Engagement API Enterprise (se abre en una pestaña nueva) de X, con un contrato de ventas. Las métricas no públicas cubren solo los posts de los últimos 30 días.

Para los contadores públicos, la API oficial de X cobra cada post leído a $0.005, o $5.00 por cada 1,000, después de tener una cuenta de desarrollador y una app (precios de la API de X (se abre en una pestaña nueva)). A partir del 22 de noviembre de 2026, un post leído con su autor adjunto cuesta $0.015 (aviso de X (se abre en una pestaña nueva)). El timeline de una cuenta allí se detiene en sus 3,200 posts más recientes (se abre en una pestaña nueva), y el pago por uso se detiene en 3 millones de lecturas de posts al mes.

#Obtén métricas de engagement de cualquier cuenta con Sorsa API

Para obtener métricas de engagement de cuentas que no son tuyas, usa Sorsa API, una API y scraper de Twitter (X): cada post que devuelve trae los seis contadores y el perfil completo de su autor, desde $0.014 por cada 1,000 posts frente a $5.00 en la API oficial de X. Un encabezado ApiKey reemplaza la cuenta de desarrollador y OAuth, todos los planes funcionan a 20 solicitudes por segundo y tu propia cuenta de X nunca interviene.

El inicio más rápido es el timeline de una cuenta: una solicitud devuelve sus posts más recientes con sus contadores, y un cursor lleva a los más antiguos. Un cursor es un token que la API devuelve con cada página; lo envías de vuelta para obtener la siguiente página.

1. Consigue una clave. Regístrate y copia la clave API de tu panel. Las 100 solicitudes gratis ya vienen incluidas.

2. Obtén los posts de la cuenta. Envía el nombre de usuario a POST /user-tweets (se abre en una pestaña nueva). Cada página tiene hasta 20 posts, de los más nuevos a los más antiguos, con los contadores y el perfil del autor.

   curl -X POST "https://api.sorsa.io/v3/user-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"username": "harborline_roasters"}'
   

   {
     "tweets": [
       {
         "id": "2116184394037384839",
         "full_text": "Winter blend ships Monday. First 200 orders get a tin.",
         "created_at": "2026-10-30T15:04:11Z",
         "lang": "en",
         "likes_count": 212,
         "retweet_count": 31,
         "reply_count": 24,
         "quote_count": 6,
         "view_count": 9640,
         "bookmark_count": 41,
         "is_reply": false,
         "is_quote_status": false,
         "conversation_id_str": "2116184394037384839",
         "user": {
           "id": "1503315520518280839",
           "username": "harborline_roasters",
           "display_name": "Harborline Roasters",
           "followers_count": 8450,
           "followings_count": 312,
           "tweets_count": 3921,
           "verified": false
         }
       }
     ],
     "next_cursor": "DAABCgABG5xQ2bW8AAAKAAIbmN8T0ZbQ6QgAAwAAAAIAAA"
   }
   

   Ver respuesta completa

3. Retrocede por las páginas hasta la fecha que necesitas. Envía next_cursor en el siguiente cuerpo y detente cuando llegue vacío o cuando los posts sean anteriores a tu fecha de inicio. El bucle de abajo escribe una fila por post en un archivo CSV.

   import csv
   import requests
   
   API = "https://api.sorsa.io/v3/user-tweets"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   FIELDS = ["id", "created_at", "likes_count", "retweet_count",
             "reply_count", "quote_count", "view_count", "bookmark_count"]
   
   
   def account_posts(username, since="2026-10-01"):
       body, rows = {"username": username}, []
       while True:
           r = requests.post(API, headers=HEADERS, json=body, timeout=30)
           r.raise_for_status()
           data = r.json()
           page = data.get("tweets", [])
           rows += [t for t in page if t["created_at"] >= since]
           old = all(t["created_at"] < since for t in page)
           if not data.get("next_cursor") or old:
               return rows
           body["next_cursor"] = data["next_cursor"]
   
   
   posts = account_posts("harborline_roasters")
   with open("metrics.csv", "w", newline="") as f:
       w = csv.DictWriter(f, fieldnames=FIELDS, extrasaction="ignore")
       w.writeheader()
       w.writerows(posts)
   print(len(posts), "posts written")
   

   import { writeFileSync } from "node:fs";
   
   const API = "https://api.sorsa.io/v3/user-tweets";
   const HEADERS = {
     ApiKey: "YOUR_API_KEY",
     "Content-Type": "application/json",
   };
   const FIELDS = ["id", "created_at", "likes_count", "retweet_count",
     "reply_count", "quote_count", "view_count", "bookmark_count"];
   
   async function accountPosts(username, since = "2026-10-01") {
     const body = { username };
     const rows = [];
     for (;;) {
       const res = await fetch(API, {
         method: "POST", headers: HEADERS, body: JSON.stringify(body),
       });
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const data = await res.json();
       const page = data.tweets ?? [];
       rows.push(...page.filter((t) => t.created_at >= since));
       const old = page.every((t) => t.created_at < since);
       if (!data.next_cursor || old) return rows;
       body.next_cursor = data.next_cursor;
     }
   }
   
   const posts = await accountPosts("harborline_roasters");
   const lines = posts.map((t) => FIELDS.map((k) => t[k]).join(","));
   writeFileSync("metrics.csv", [FIELDS.join(","), ...lines].join("\n"));
   console.log(posts.length, "posts written");
   

4. Guarda cada ejecución como una instantánea. Los contadores siguen creciendo después de que se publica un post, así que guarda cada consulta con su fecha (ID del post, momento de captura, los seis contadores). Dos instantáneas con un día de diferencia muestran qué posts siguen ganando terreno, y un contador graficado contra created_at a lo largo de un mes muestra si los posts de la cuenta están alcanzando más o menos gente.

Un estado 429 significa más de 20 solicitudes en un segundo: espera un segundo y vuelve a enviarla. Un 403 significa que falta la clave o que se quedó sin solicitudes, y un 401 que es incorrecta; las solicitudes fallidas nunca se cobran.

#Mantén las métricas al día: actualiza los posts que sigues de 100 en 100

Una vez que sabes qué posts sigues, actualiza sus contadores por ID: POST /tweet-info-bulk (se abre en una pestaña nueva) acepta hasta 100 enlaces o IDs de posts y devuelve cada post con sus contadores actuales en una solicitud, desde $0.014 por cada 1,000 posts. Las métricas de 1 millón de posts cuestan desde $14 de esa forma.

La primera página del timeline de la cuenta hace parte del trabajo gratis: ya incluye los 20 posts más recientes con sus contadores actuales. Una cuenta que publica dos veces al día mantiene al día sus últimos 10 días con esa sola solicitud; solo los posts más antiguos necesitan la llamada por lotes.

curl -X POST "https://api.sorsa.io/v3/tweet-info-bulk" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"tweet_links": ["2116184394037384839", "2115861688481928839"]}'

En Python, corta tu lista de IDs en tramos de 100 y envía cada tramo como tweet_links; la respuesta es un solo arreglo tweets sin cursor.

HEADERS = {"ApiKey": "YOUR_API_KEY"}


def refresh(ids):
    out = []
    for i in range(0, len(ids), 100):
        r = requests.post(
            "https://api.sorsa.io/v3/tweet-info-bulk",
            headers=HEADERS, json={"tweet_links": ids[i:i + 100]},
            timeout=60)
        r.raise_for_status()
        out += r.json().get("tweets", [])
    return out

Las tarjetas comparan una pasada por una lista de posts: los seis contadores de cada post, leídos una vez.

#Respuestas, citas y retweeters por API

Los contadores dicen cuánta gente interactuó; tres endpoints más dicen quiénes fueron y qué escribieron. Cada uno acepta un enlace o un ID de post, y cada respuesta y cada cita llega como un post completo con sus propios contadores y su autor.

• Respuestas bajo un post

  Endpoint de Sorsa API

  /comments (se abre en una pestaña nueva)

  Qué devuelve

  hasta 20 respuestas por página, por Relevance, Recency o Likes

• Posts que citan un post

  Endpoint de Sorsa API

  /quotes (se abre en una pestaña nueva)

  Qué devuelve

  hasta 20 citas por página, con el texto agregado

• Cuentas que hicieron repost

  Endpoint de Sorsa API

  /retweeters (se abre en una pestaña nueva)

  Qué devuelve

  perfiles con su número de seguidores, de los más nuevos a los más antiguos

• Totales de muchas cuentas

  Endpoint de Sorsa API

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

  Qué devuelve

  hasta 100 perfiles por solicitud

Cada uno responde una pregunta distinta. Las respuestas ordenadas por Likes ponen en la primera página las respuestas con más likes, así que una sola solicitud muestra cómo recibió la audiencia un post. Las citas traen el comentario que agregó la gente, la materia prima para analizar el tono o el sentimiento. Los seguidores de quienes hicieron repost suman la audiencia a la que llegó un post de forma indirecta.

BASE = "https://api.sorsa.io/v3"
HEADERS = {"ApiKey": "YOUR_API_KEY"}


def pages(path, body, key, limit=10):
    for _ in range(limit):
        r = requests.post(f"{BASE}/{path}", headers=HEADERS,
                          json=body, timeout=30)
        r.raise_for_status()
        data = r.json()
        yield from data.get(key, [])
        if not data.get("next_cursor"):
            return
        body = {**body, "next_cursor": data["next_cursor"]}


post = "https://x.com/harborline_roasters/status/2116184394037384839"
top = list(pages("comments", {"tweet_link": post, "order_by": "Likes"},
                 "tweets", limit=1))[:5]
quotes = list(pages("quotes", {"tweet_link": post}, "tweets"))
fans = list(pages("retweeters", {"tweet_link": post}, "users"))
reach = sum(u.get("followers_count", 0) for u in fans)
print(len(quotes), "quotes,", len(fans), "retweeters,", reach, "reach")

En la API oficial de X, los posts que citan salen de GET /2/tweets/:id/quote_tweets a $0.005 cada uno, y quienes hicieron retweet, de GET /2/tweets/:id/retweeted_by a $0.010 cada uno, $10.00 por cada 1,000 cuentas. Cada uno de esos dos endpoints permite 75 solicitudes cada 15 minutos (límites de uso de la API de X (se abre en una pestaña nueva)). Las respuestas no tienen un endpoint propio allí: salen de una búsqueda por conversation_id, que en la búsqueda reciente llega hasta 7 días atrás.

Dos tareas tienen su propia página. Para comprobar si una cuenta siguió, hizo retweet, citó o respondió, la guía de la API de verificación de Twitter lo responde en una sola comprobación. Para leer las respuestas de un post sin código, consulta cómo ver los comentarios en X.

#Cómo calcular la tasa de engagement con datos de la API

La tasa de engagement es la proporción de personas que interactuaron con un post, y los campos de la API te dan las dos versiones habituales. Por visualizaciones, suma likes, reposts, respuestas y citas, divide entre las visualizaciones y multiplica por 100. Por seguidores, divide la misma suma entre el followers_count del autor, que cada post trae en su objeto user.

Toma el post de la respuesta de arriba: 212 likes, 31 reposts, 24 respuestas y 6 citas suman 273 interacciones. Frente a 9,640 visualizaciones eso da 2.83%; frente a 8,450 seguidores, 3.23%. La Calculadora de tasa de engagement de Twitter usa las mismas dos fórmulas, así que tu código y la herramienta gratuita coinciden en cualquier cuenta.

from statistics import median


def engagement(posts):
    followers = posts[0]["user"]["followers_count"]
    for t in posts:
        acts = (t["likes_count"] + t["retweet_count"]
                + t["reply_count"] + t["quote_count"])
        views = t["view_count"] or 1
        t["er_views"] = round(100 * acts / views, 2)
        t["er_followers"] = round(100 * acts / followers, 2)
    return median(t["view_count"] for t in posts)

Reporta la mediana de visualizaciones junto a la tasa. Un solo post viral eleva un promedio durante meses, mientras que la mediana muestra lo que consigue un post típico. Deja fuera de la mediana los posts con menos de dos días, porque sus visualizaciones todavía están subiendo.

Para tener en cuenta

Las visualizaciones cuentan pantallas, no personas. X cuenta una impresión cada vez que un post aparece en una pantalla, así que un lector que pasa dos veces por encima suma dos visualizaciones. Compara las tasas por visualizaciones entre cuentas de tamaño parecido, y usa la tasa por seguidores para comparar audiencias.

#Cuánto cuesta al mes un pipeline de analítica de X

El costo de un pipeline de analítica depende de tres números: cuántas cuentas sigues, cuántos posts publica cada una al día y durante cuántos días vuelves a leer cada post. Mueve los controles deslizantes para ver un mes en ambas APIs.

La diferencia viene de la unidad. La API oficial de X cobra cada post que devuelve, cada día que lo vuelves a leer, y se detiene en 3 millones de lecturas de posts al mes; por encima de eso, solo queda un contrato Enterprise desde unos $42,000 al mes. Sorsa API cobra la solicitud, y una solicitud trae hasta 100 posts por ID o 20 de un timeline.

Para un panel sobre competidores, clientes o creadores, elige Sorsa API: las métricas de tweets cuestan desde $0.014 por cada 1,000 posts en lugar de $5.00. Todos los planes funcionan a 20 solicitudes por segundo, una clave API reemplaza la cuenta de desarrollador, y la misma clave lee respuestas, citas, retweeters y búsqueda hasta 2006. Es de solo lectura, así que nunca toca tu cuenta de X.

#Analiza un tema, no solo una cuenta

El análisis de engagement también funciona sobre una conversación: busca los posts sobre un tema y luego ordénalos por sus contadores. POST /search-tweets (se abre en una pestaña nueva) acepta los operadores de búsqueda propios de X, devuelve unos 20 posts por página con los seis contadores y el autor, y llega hasta 2006.

curl -X POST "https://api.sorsa.io/v3/search-tweets" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "\"cold brew\" min_faves:50 lang:en", "order": "popular"}'

Agrega since: y until: a la consulta para fijar una ventana de fechas. Suma las interacciones por autor para ver quién impulsa el tema, o ejecuta una consulta por marca sobre las mismas fechas para medir el share of voice. La guía de la API de búsqueda de Twitter explica los operadores, y el análisis de competencia en Twitter convierte los mismos datos en una referencia comparativa.

#Empieza hoy con una cuenta

Los likes, reposts, respuestas, citas, visualizaciones y marcadores de cada post público se pueden leer por API, de cualquier cuenta; solo los clics y los seguimientos se quedan con el autor. Sorsa API devuelve los seis contadores con el perfil del autor, 100 posts por solicitud por ID, desde $0.014 por cada 1,000 frente a $5.00 en la API oficial de X. Obtén el último mes de una cuenta con el bucle de arriba, actualízalo a diario, y las 100 solicitudes gratis cubren tus primeros 10,000 posts.

#Preguntas frecuentes