Cómo hacer un análisis de la competencia en Twitter

#Las siete métricas de un análisis de la competencia en Twitter

Siete números sostienen un análisis de la competencia en X, y todos salen de datos que muestra cualquier cuenta pública. Para poner dos cuentas lado a lado antes de construir nada, la herramienta gratuita Comparar cuentas de Twitter alinea en el navegador sus seguidores, visualizaciones y engagement, con el líder marcado en cada uno.

1. Tasa de crecimiento de seguidores. Seguidores ahora menos seguidores de hace una semana, divididos entre la cifra anterior: una cuenta de 20K que crece 2% por semana le gana terreno a una de 200K que se queda quieta.

2. Tasa de engagement. Likes, reposts, respuestas y citas de un post, divididos entre los seguidores de la cuenta. Compara medianas, porque un solo post viral eleva un promedio durante semanas.

3. Frecuencia de publicación. Posts por semana, contados en las mismas cuatro semanas para todos los rivales.

4. Mezcla de contenido. La proporción de respuestas, citas y posts con foto o video.

5. Share of voice. Las menciones de una marca en una semana divididas entre las menciones de todas las marcas del conjunto.

6. Solapamiento de audiencia. La proporción de seguidores de un rival que también te siguen a ti, medida contra la más pequeña de las dos listas.

7. Proporción de verificados y de falsos. La parte de seguidores verificados de un rival y la parte de cuentas vacías: sin posts, sin avatar, con muchos más seguidos que seguidores.

Algunos números solo los ve el dueño de la cuenta: impresiones a lo largo del tiempo, clics en enlaces, visitas al perfil y demografía de los seguidores. Las visualizaciones por post sí son públicas, así que también puedes dividir el engagement entre las visualizaciones de cualquier rival; la guía de la API de analíticas de Twitter explica ambas fórmulas y los seis contadores que lleva cada post.

Por sí solo, el número de seguidores dice poco. Esos mismos siete números, leídos cada semana para todo el conjunto, muestran quién acelera, qué formatos funcionan en tu nicho y dónde se solapa la audiencia de un rival con la tuya.

#Elige de 3 a 10 rivales y una sola ventana

Un conjunto útil tiene de 3 a 10 cuentas en tres niveles, más tu propia cuenta como línea de referencia. Con más de 10, la lectura semanal se vuelve ruido; con menos de 3 no hay base de comparación.

• Rivales directos venden lo que tú vendes a los mismos compradores.
• Rivales indirectos compiten por la misma atención: una cuenta de medios, un creador o una herramienta que tus compradores usan en su lugar.
• Cuentas aspiracionales están donde quieres estar dentro de un año, de modo que la brecha se mide en lugar de adivinarse.

Tres lugares revelan los rivales que aún no conoces. Las cuentas que la gente menciona en los mismos posts que a ti suelen ser competidores. Una búsqueda en las biografías con las palabras de tu categoría, mediante POST /search-users (se abre en una pestaña nueva), lista al resto. Y las cuentas que tus seguidores también siguen compiten por el mismo feed; el Twitter Audience Overlap Checker gratuito lo mide para dos cuentas cualesquiera.

Fija una sola ventana para todos: los últimos 28 días, terminando el mismo día para cada cuenta. Una semana de lanzamiento dentro de una ventana de dos semanas parece el ritmo normal de un rival; cuatro semanas lo suavizan.

#Herramienta de panel o API: de dónde salen los números

Un panel por asientos empieza a contar el día que lo conectas, cobra por cada asiento y limita cuántos rivales sigues. Una API usada como capa de datos recupera el historial de un rival, cobra por solicitud sin límite de rivales y devuelve JSON para tu propia hoja, panel o agente.

• Historial

  Sorsa API

  Búsqueda desde 2006; timelines completos, sin tope de 3,200 posts

  Panel por asientos

  Desde el día en que te registras

  API oficial de X

  Los timelines se detienen en los últimos 3,200 posts; la búsqueda en el archivo se cobra por post

• Rivales

  Sorsa API

  Sin límite

  Panel por asientos

  Limitados por el plan

  API oficial de X

  Sin límite

• Precio

  Sorsa API

  Perfiles desde $0.014 por cada 1,000; posts desde $0.07 por cada 1,000

  Panel por asientos

  Por asiento al mes

  API oficial de X

  $10.00 por cada 1,000 perfiles; $5.00 por cada 1,000 posts

• Acceso

  Sorsa API

  Una clave API

  Panel por asientos

  Un inicio de sesión por asiento

  API oficial de X

  Cuenta de desarrollador, OAuth, como máximo 3 millones de lecturas de posts al mes

• Salida

  Sorsa API

  JSON para tus hojas, paneles y agentes

  Panel por asientos

  Los gráficos y exportaciones del proveedor

  API oficial de X

  JSON

La fila de precio es la que crece con tu conjunto. La API oficial de X cobra cada post y cada perfil que devuelve, a las tarifas de su página de precios (se abre en una pestaña nueva), mientras que una solicitud de Sorsa API trae hasta 100 perfiles o 20 posts.

#Ejecuta el análisis con Sorsa API en cinco pasos

Para sacar los números de un análisis de la competencia, usa Sorsa API, una API y scraper de Twitter (X): una solicitud devuelve hasta 100 perfiles de rivales y los posts llegan de 20 en 20 por solicitud, desde 2006. Todos los planes funcionan a 20 solicitudes por segundo con una sola clave API, sin cuenta de desarrollador ni OAuth. Los cinco pasos de abajo arman la ejecución semanal de principio a fin; el flujo de análisis de la competencia (se abre en una pestaña nueva) de la documentación incluye el mismo trabajo en un solo script.

1. Consigue una clave. Regístrate y copia tu clave API del panel. Las primeras 100 solicitudes son gratis y nunca vencen.

2. Toma una captura de todo el conjunto. Envía todos los nombres de usuario a GET /info-batch (se abre en una pestaña nueva), hasta 100 por solicitud, repitiendo el parámetro usernames.

   curl -G "https://api.sorsa.io/v3/info-batch" \
     -H "ApiKey: YOUR_API_KEY" \
     --data-urlencode "usernames=northwind_roastery" \
     --data-urlencode "usernames=harbor_bean_supply" \
     --data-urlencode "usernames=kestrel_coffee_lab"
   

   {
     "users": [
       {
         "id": "1638204417762983936",
         "username": "northwind_roastery",
         "display_name": "Northwind Roastery",
         "description": "Small-batch coffee, roasted every Monday.",
         "bio_urls": ["https://example.com/subscribe"],
         "followers_count": 48210,
         "followings_count": 612,
         "tweets_count": 9314,
         "media_count": 2207,
         "verified": true,
         "pinned_tweet_ids": ["1851130250081816914"],
         "created_at": "2023-03-15T09:12:44Z"
       },
       {
         "id": "1702553980148703232",
         "username": "harbor_bean_supply",
         "display_name": "Harbor Bean Supply",
         "description": "Green coffee for roasters. Ships worldwide.",
         "bio_urls": [],
         "followers_count": 31904,
         "followings_count": 1480,
         "tweets_count": 5120,
         "media_count": 860,
         "verified": false,
         "pinned_tweet_ids": [],
         "created_at": "2023-09-14T16:40:03Z"
       }
     ]
   }
   

   Ver respuesta completa

3. Lee las últimas cuatro semanas de cada rival. Recorre POST /user-tweets (se abre en una pestaña nueva), 20 posts por solicitud, hasta que una página completa sea más antigua que la ventana. Cada post trae sus likes, reposts, respuestas, citas, visualizaciones y marcadores, así que las métricas no necesitan más llamadas.

   import statistics
   from datetime import datetime, timedelta, timezone
   
   import requests
   
   BASE = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   WEEKS = 4
   
   
   def posted(t):
       return datetime.fromisoformat(t["created_at"].replace("Z", "+00:00"))
   
   
   def recent_posts(handle):
       since = datetime.now(timezone.utc) - timedelta(weeks=WEEKS)
       body, posts = {"username": handle, "with_replies": True}, []
       while True:
           r = requests.post(f"{BASE}/user-tweets", headers=HEADERS,
                             json=body, timeout=30)
           r.raise_for_status()
           page = r.json()
           fresh = [t for t in page.get("tweets", []) if posted(t) >= since]
           posts += fresh
           if not fresh or not page.get("next_cursor"):
               return posts
           body["next_cursor"] = page["next_cursor"]
   
   
   def metrics(handle, followers):
       posts = recent_posts(handle)
       own = [t for t in posts
              if not t["is_reply"] and not t.get("retweeted_status")]
       rates = [100 * (t["likes_count"] + t["retweet_count"]
                       + t["reply_count"] + t["quote_count"]) / followers
                for t in own]
       media = sum(any(e["type"] in ("photo", "video")
                       for e in t.get("entities") or []) for t in own)
       replies = sum(t["is_reply"] for t in posts)
       return {
           "posts_wk": round(len(own) / WEEKS, 1),
           "median_er": round(statistics.median(rates), 3) if rates else 0,
           "reply_pct": round(100 * replies / len(posts), 1) if posts else 0,
           "media_pct": round(100 * media / len(own), 1) if own else 0,
       }
   

   const BASE = "https://api.sorsa.io/v3";
   const headers = { ApiKey: "YOUR_API_KEY", "Content-Type": "application/json" };
   const since = Date.now() - 28 * 24 * 3600 * 1000;
   
   async function recentPosts(username) {
     const body = { username, with_replies: true };
     const posts = [];
     for (;;) {
       const res = await fetch(`${BASE}/user-tweets`, {
         method: "POST", headers, body: JSON.stringify(body),
       });
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const page = await res.json();
       const fresh = (page.tweets ?? []).filter(
         (t) => Date.parse(t.created_at) >= since);
       posts.push(...fresh);
       if (!fresh.length || !page.next_cursor) return posts;
       body.next_cursor = page.next_cursor;
     }
   }
   
   function medianRate(posts, followers) {
     const rates = posts
       .filter((t) => !t.is_reply && !t.retweeted_status)
       .map((t) => (t.likes_count + t.retweet_count
         + t.reply_count + t.quote_count) / followers * 100)
       .sort((a, b) => a - b);
     return rates.length ? rates[Math.floor(rates.length / 2)] : 0;
   }
   

4. Cuenta el share of voice de cada marca. Pide a POST /mentions (se abre en una pestaña nueva) las menciones de cada nombre de usuario en la misma semana, 20 menciones por solicitud, y divide cada conteo entre el total. Añade min_likes cuando una marca recibe miles de menciones y solo quieres las que provocaron alguna reacción.

   def mentions(handle, since, until):
       body = {"query": handle, "since_date": since, "until_date": until}
       count = 0
       while True:
           r = requests.post(f"{BASE}/mentions", headers=HEADERS,
                             json=body, timeout=30)
           r.raise_for_status()
           page = r.json()
           count += len(page.get("tweets", []))
           if not page.get("next_cursor"):
               return count
           body["next_cursor"] = page["next_cursor"]
   
   
   brands = ["northwind_roastery", "harbor_bean_supply", "kestrel_coffee_lab"]
   week = {b: mentions(b, "2026-10-26", "2026-11-02") for b in brands}
   total = sum(week.values()) or 1
   sov = {b: round(100 * n / total, 1) for b, n in week.items()}
   

5. Guarda una fila por rival y compárala con la semana pasada. Añade las filas a un archivo CSV con una programación semanal (cron, un flujo de GitHub Actions, cualquier ejecutor de tareas); el crecimiento es la diferencia entre el número de seguidores de esta semana y el de la semana pasada.

   import csv
   from datetime import date
   from pathlib import Path
   
   PATH = "competitors.csv"
   FIELDS = ["week", "handle", "followers", "growth_pct", "posts_wk",
             "median_er", "reply_pct", "media_pct", "sov_pct"]
   
   
   def last_followers():
       if not Path(PATH).exists():
           return {}
       with open(PATH, newline="", encoding="utf-8") as f:
           return {r["handle"]: int(r["followers"]) for r in csv.DictReader(f)}
   
   
   profiles = requests.get(f"{BASE}/info-batch", headers=HEADERS,
                           params={"usernames": brands}, timeout=30).json()
   last, rows = last_followers(), []
   for u in profiles["users"]:
       h, f = u["username"], u["followers_count"]
       prev = last.get(h) or f
       rows.append({"week": date.today().isoformat(), "handle": h,
                    "followers": f,
                    "growth_pct": round(100 * (f - prev) / prev, 2),
                    "sov_pct": sov.get(h, 0), **metrics(h, f)})
   
   new_file = not Path(PATH).exists()
   with open(PATH, "a", newline="", encoding="utf-8") as f:
       out = csv.DictWriter(f, fieldnames=FIELDS)
       if new_file:
           out.writeheader()
       out.writerows(rows)
   

Una respuesta 403 significa que la clave falta o se quedó sin solicitudes; un 429 significa más de 20 solicitudes en un segundo, así que haz una pausa y reintenta. Las solicitudes fallidas nunca se cobran.

#Una plantilla de análisis de la competencia en Twitter que se rellena sola

La plantilla es una hoja con una fila por rival y por semana, y cada columna corresponde a un campo que devuelve la API. Pega la fila de encabezados en Google Sheets o Excel, o deja que el script del paso 5 escriba el archivo por ti.

week,handle,followers,growth_pct,posts_wk,median_er,reply_pct,media_pct,sov_pct

Cada columna, el campo del que sale y la fórmula:

• followers

  De dónde sale

  followers_count, GET /info-batch

  Fórmula

  Tal como se devuelve

• growth_pct

  De dónde sale

  Dos filas semanales

  Fórmula

  (esta semana − la semana pasada) ÷ la semana pasada × 100

• posts_wk

  De dónde sale

  created_at, POST /user-tweets

  Fórmula

  Posts propios en 28 días ÷ 4

• median_er

  De dónde sale

  likes_count, retweet_count, reply_count, quote_count

  Fórmula

  Mediana de (suma ÷ seguidores × 100) por post

• reply_pct

  De dónde sale

  is_reply

  Fórmula

  Respuestas ÷ todos los posts de la ventana × 100

• media_pct

  De dónde sale

  entities[].type es photo o video

  Fórmula

  Posts con multimedia ÷ posts propios × 100

• sov_pct

  De dónde sale

  POST /mentions

  Fórmula

  Menciones de la marca ÷ menciones de todo el conjunto × 100

Añade columnas a medida que crezca el análisis: views a partir de view_count para el engagement por visualizaciones, bio a partir de description para detectar una nueva frase de posicionamiento, verified_share a partir de la auditoría de audiencia de más abajo. Un ejemplo práctico: si tu mediana de engagement es 0.41% y la de un rival es 1.2% con el mismo número de seguidores, ordena los posts del rival por engagement y lee los diez primeros antes de cambiar nada.

#Mira atrás, antes de empezar a hacer seguimiento

El pasado de un competidor se puede buscar: Sorsa API lee los posts de un rival desde 2006, de modo que una comparación puede empezar con los datos del año pasado el mismo día que la configuras. Los paneles cuentan desde el día en que los conectas, y el timeline de usuario de la API oficial de X devuelve solo los últimos 3,200 posts, según docs.x.com (se abre en una pestaña nueva).

Para estudiar cómo manejó un rival la temporada navideña del año pasado, envía los operadores propios de X a POST /search-tweets (se abre en una pestaña nueva): from: elige la cuenta, since: y until: fijan las fechas, y cada solicitud devuelve unos 20 posts con sus contadores.

curl -X POST "https://api.sorsa.io/v3/search-tweets" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "from:northwind_roastery since:2025-11-01 until:2026-01-01",
       "order": "latest"}'

La misma consulta con el nombre de una marca en lugar de from: devuelve lo que la gente dijo del rival en esa ventana, que es un share of voice que puedes medir para cualquier mes pasado.

#Cuatro señales que un panel rara vez muestra

Además de las siete métricas, cuatro señales públicas muestran lo que hace un rival antes de que se note en sus números.

Posts patrocinados. Cada post que devuelve Sorsa API lleva paid_partnership, el indicador que X muestra en las colaboraciones pagadas. Busca los posts que etiquetan a un rival y quédate con los marcados: sus autores son los creadores a quienes el rival paga.

body = {"query": "@northwind_roastery", "order": "latest"}
r = requests.post(f"{BASE}/search-tweets", headers=HEADERS, json=body)
paid = [t for t in r.json()["tweets"] if t.get("paid_partnership")]
print({t["user"]["username"] for t in paid})

Dónde vive su audiencia. GET /about (se abre en una pestaña nueva) devuelve el país que X asigna a una cuenta. Ejecútalo con una muestra de 1,000 seguidores de un rival y verás en qué mercados llega; la guía de la API de ubicación de Twitter muestra qué tan cerca queda una muestra de la lista completa.

Movimientos discretos de estrategia. Una nueva línea en la biografía, un enlace nuevo en bio_urls o un post fijado nuevo suelen llegar antes que un anuncio. Compáralos semana a semana en la captura de /info-batch, y recorre GET /follows (se abre en una pestaña nueva) una vez al mes: los nuevos seguidos de socios, fichajes o inversionistas son públicos.

Calidad de la audiencia. GET /verified-followers (se abre en una pestaña nueva) lista solo las cuentas verificadas que siguen a un rival, y GET /followers (se abre en una pestaña nueva) devuelve 200 seguidores por solicitud para las comprobaciones de solapamiento y de seguidores falsos. La guía de la API de seguidores de Twitter cubre la paginación, el solapamiento por ID y las señales de las cuentas vacías.

#Cuánto cuesta al mes seguir a los competidores

Seguir a 10 rivales cada semana cuesta desde $0.68 al mes en solicitudes de Sorsa API ($0.97 con la tarifa Pro), frente a $143.77 en la API oficial de X. El ejemplo lee 100 posts y 100 menciones por rival cada semana y toma una muestra de 1,000 seguidores por rival cada mes; cambia los números para calcular el costo de tu propio conjunto.

La diferencia viene de la unidad de cobro. La API oficial de X cobra cada post y cada perfil que devuelve, y exige una cuenta de desarrollador y OAuth. 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. A partir del 22 de noviembre de 2026 también cobra a la tarifa estándar los objetos devueltos mediante expansiones, según el aviso de X del 23 de octubre (se abre en una pestaña nueva). Si expandes el autor de cada mención a $0.010, el ejemplo anterior sube a $187.10.

Para hacer seguimiento de competidores en X, elige Sorsa API: los perfiles de rivales cuestan desde $0.014 por cada 1,000 en lugar de $10.00 en la API oficial de X, y los seguidores desde $0.007 por cada 1,000, 1,000 veces menos. Releer los contadores de posts que ya sigues mediante POST /tweet-info-bulk (se abre en una pestaña nueva) toma 100 posts por solicitud, desde $0.014 por cada 1,000, 250 veces menos que $5.00. Toda la ejecución semanal toma unos segundos a 20 solicitudes por segundo. Sorsa API es de solo lectura y nunca pide tu inicio de sesión de X, así que tu propia cuenta nunca corre riesgo.

#Con qué frecuencia ejecutarlo y qué hacer con los resultados

Ejecuta la captura cada semana y una pasada a fondo cada trimestre. La ejecución semanal (perfiles, cuatro semanas de posts, menciones) detecta un cambio de ritmo o de formato en cuestión de días. La pasada trimestral añade la auditoría de audiencia, la búsqueda en el historial y una nueva revisión de qué rivales merecen estar en el conjunto. Durante el lanzamiento de un rival, revisa sus menciones a diario: la guía de monitoreo de Twitter en tiempo real consulta todo un conjunto de cuentas en una sola solicitud.

Un hallazgo es útil cuando se convierte en una prueba con un número asociado. Escríbelo como una hipótesis y una métrica:

• Los posts con video de un rival logran 2.4 veces su mediana de engagement: publica dos videos por semana durante cuatro semanas y compara tu mediana.
• Dos rivales responden a la mayoría de las menciones dentro del día y crecen más rápido: responde todas las menciones durante un mes y observa el crecimiento.
• El share of voice de un rival se duplicó tras una campaña con creadores: revisa sus posts con paid_partnership para ver los creadores y el formato.

Conserva el CSV semanal: doce semanas de filas muestran si una prueba movió tu línea o si todo el nicho se movió junto.

#Compara hoy a tus primeros rivales

Un análisis de la competencia en Twitter son siete números leídos cada semana para de 3 a 10 rivales. Sorsa API rellena toda la hoja con tres endpoints: perfiles de rivales desde $0.014 por cada 1,000, posts desde 2006 sin tope de 3,200 posts, y seguidores desde $0.007 por cada 1,000, con una sola clave API a 20 solicitudes por segundo. Tus primeras 100 solicitudes son gratis, suficientes para una primera comparación de 10 rivales.

#Preguntas frecuentes