API de seguimiento de hashtags de Twitter

#Cómo funciona el seguimiento de hashtags mediante una API

Seguir un hashtag es reunir todos los posts públicos que llevan una misma etiqueta durante un periodo y convertirlos en tres respuestas: cuántos aparecieron cada día, quién los publicó y cuáles se leyeron más. Ninguna API de X tiene un endpoint para hashtags como tales. Todas las rutas pasan por la búsqueda, con la etiqueta escrita en la consulta.

Para un vistazo rápido sin código, la herramienta gratuita Analítica de hashtags de Twitter muestra los posts por hora, las voces principales y los posts destacados de cualquier etiqueta en las últimas 24 horas o 7 días. El resto de esta guía arma el mismo reporte en código, para cualquier periodo y cualquier cantidad de etiquetas.

En una consulta de búsqueda, #tidewaterdevdays coincide con los posts donde X reconoció la palabra como hashtag, con cualquier combinación de mayúsculas y minúsculas. La palabra sin símbolo, tidewaterdevdays, también atrapa los posts que la escriben sin el #, así que un reporte de campaña que deba contar solo los posts etiquetados conserva el #. Una etiqueta termina en el primer carácter que no sea letra, dígito o guion bajo, así que #c++ es la etiqueta #c, mientras que las etiquetas en japonés, árabe o cualquier otra escritura funcionan tal como están. Todos los demás filtros, desde el idioma hasta el mínimo de me gusta, están en nuestra guía de operadores de búsqueda de Twitter.

La búsqueda tiene dos órdenes. Latest recorre todas las coincidencias desde la más reciente hacia atrás, que es lo que necesita contar. Top devuelve solo las coincidencias con más interacción, así que sirve para una lista de lo mejor y es mala para contar.

La API oficial de X también tiene dos endpoints de conteos: GET /2/tweets/counts/recent para los últimos 7 días y GET /2/tweets/counts/all para el archivo, con totales por minuto, hora o día (resumen de conteos de X (se abre en una pestaña nueva)). Devuelven números y nada más: ni posts, ni autores, ni vistas. La propia nota de X agrega que los conteos pueden no coincidir exactamente con los resultados de búsqueda. Un rastreador que deba decir quién impulsó una etiqueta, o qué post la llevó, lee los posts mismos.

#Sigue un hashtag con Sorsa API en cuatro pasos

Sorsa API, una API y scraper de Twitter (X), ejecuta la sintaxis de búsqueda de X mediante un solo endpoint, POST /search-tweets, y devuelve cada post con el perfil completo de su autor. Una pasada por las páginas produce los tres resultados, así que el conteo, el ranking de autores y los posts destacados nunca requieren solicitudes separadas.

Para el seguimiento de hashtags, usa Sorsa API: una sola clave de API y ninguna cuenta de desarrollador, unos 20 posts por solicitud con los autores incluidos, desde $0.07 por cada 1,000 posts y 20 solicitudes por segundo en todos los planes.

1. Obtén una clave. Regístrate y copia tu clave de API desde el panel. Las primeras 100 solicitudes son gratis, sin tarjeta.

2. Envía la consulta. Pon la etiqueta y el periodo en query y pide primero los posts más recientes. El # va tal cual en el cuerpo JSON, sin codificación de URL.

   curl -X POST "https://api.sorsa.io/v3/search-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"query": "#tidewaterdevdays since:2026-10-19 until:2026-11-02",
          "order": "latest"}'
   

   {
     "tweets": [
       {
         "id": "2115444854355529755",
         "full_text": "Day one of #tidewaterdevdays, slides below #devrel",
         "created_at": "2026-10-28T14:05:31Z",
         "lang": "en",
         "likes_count": 312,
         "retweet_count": 41,
         "reply_count": 18,
         "quote_count": 6,
         "view_count": 28410,
         "is_reply": false,
         "user": {
           "id": "1366674638239301632",
           "username": "maren_codes_at_night",
           "display_name": "Maren",
           "followers_count": 18240,
           "verified": false
         }
       }
     ],
     "next_cursor": "DAADDAABCgABHVvqb2SWYBsKAAIdW-l6pZbQkAAIAAIAAAAC"
   }
   

   Ver respuesta completa

3. Sigue el cursor. Envía next_cursor en el cuerpo de la siguiente solicitud hasta que llegue una respuesta sin él. El tamaño de las páginas varía, así que detente cuando falte el cursor, nunca por una página corta. Un 403 significa que falta la clave o que se quedó sin solicitudes; un 429 significa más de 20 solicitudes en un segundo, así que espera un segundo y reintenta.

4. Agrupa los posts. Conserva una fila por ID de post y luego cuenta por día y por autor. El script de abajo hace todo el trabajo e imprime el reporte.

   import re
   from collections import Counter
   from datetime import datetime, timezone
   
   import requests
   
   URL = "https://api.sorsa.io/v3/search-tweets"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   TAG = re.compile(r"#\w+")
   
   
   def collect(query):
       """Yield every post the search returns, newest first."""
       body = {"query": query, "order": "latest"}
       while True:
           r = requests.post(URL, headers=HEADERS, json=body, timeout=30)
           r.raise_for_status()
           page = r.json()
           yield from page.get("tweets", [])
           cursor = page.get("next_cursor")
           if not cursor:
               return
           body["next_cursor"] = cursor
   
   
   def utc_day(post):
       stamp = post["created_at"].replace("Z", "+00:00")
       t = datetime.fromisoformat(stamp)
       return t.astimezone(timezone.utc).date().isoformat()
   
   
   def track(tag, since, until):
       posts = {}
       for p in collect(f"{tag} since:{since} until:{until}"):
           posts[p["id"]] = p  # one row per post ID
       per_day, by_author, views, tags = Counter(), Counter(), Counter(), Counter()
       for p in posts.values():
           per_day[utc_day(p)] += 1
           by_author[p["user"]["username"]] += 1
           views[p["user"]["username"]] += p.get("view_count") or 0
           tags.update(m.lower() for m in TAG.findall(p["full_text"]))
       top = sorted(posts.values(), key=lambda p: p.get("view_count") or 0)
       return per_day, by_author, views, tags, top[::-1][:10]
   
   
   per_day, by_author, views, tags, top = track(
       "#tidewaterdevdays", "2026-10-19", "2026-11-02")
   for day, n in sorted(per_day.items()):
       print(day, n)
   print("Top authors:", by_author.most_common(5))
   print("Most viewed:", views.most_common(5))
   print("Related tags:", tags.most_common(10))
   

   const URL = "https://api.sorsa.io/v3/search-tweets";
   const headers = {
     ApiKey: "YOUR_API_KEY",
     "Content-Type": "application/json",
   };
   
   async function track(tag, since, until) {
     const body = { query: `${tag} since:${since} until:${until}`,
       order: "latest" };
     const posts = new Map();
     do {
       const res = await fetch(URL, {
         method: "POST", headers, body: JSON.stringify(body) });
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const page = await res.json();
       for (const p of page.tweets ?? []) posts.set(p.id, p);
       body.next_cursor = page.next_cursor;
     } while (body.next_cursor);
   
     const perDay = {}, byAuthor = {};
     for (const p of posts.values()) {
       const day = new Date(p.created_at).toISOString().slice(0, 10);
       perDay[day] = (perDay[day] ?? 0) + 1;
       const who = p.user.username;
       byAuthor[who] = (byAuthor[who] ?? 0) + 1;
     }
     return { perDay, byAuthor, total: posts.size };
   }
   
   const report = await track("#tidewaterdevdays", "2026-10-19",
     "2026-11-02");
   console.log(report.perDay, report.total);
   console.log(Object.entries(report.byAuthor)
     .sort((a, b) => b[1] - a[1]).slice(0, 5));
   

Los parámetros y campos de respuesta del endpoint están en la referencia de POST /search-tweets (se abre en una pestaña nueva). Para todo lo que hace la búsqueda más allá de los hashtags, desde consultas por palabra clave hasta las otras formas de encontrar posts, consulta la guía de la API de búsqueda de Twitter.

#Cuenta los posts de un hashtag por día

Para contar un hashtag por día, lee todos los posts del periodo con el orden Latest, conserva una fila por ID de post y agrupa las filas por la fecha UTC del created_at de cada post. La fecha en la consulta solo decide qué posts obtienes; la fecha de cada post decide dónde se cuenta.

Esa separación importa en los bordes. since: y until: funcionan en UTC, y until: deja fuera su propia fecha, así que since:2026-10-28 until:2026-10-29 es solo el 28 de octubre. Los posts cercanos a la medianoche aún pueden aparecer en una ventana vecina, y por eso el script cuenta por created_at y descarta repetidos por ID en lugar de confiar en la ventana.

Un periodo largo se lee más rápido como una ventana por día. Los días no dependen unos de otros, así que corren en paralelo: una clave maneja 20 solicitudes por segundo, unos 400 posts por segundo, y un año de una etiqueta de 5,000 posts al día se lee en unos 76 minutos. El historial llega hasta 2006, así que un rastreador iniciado hoy puede contar la campaña del año pasado tan fácilmente como la de esta semana.

Tres decisiones de la consulta cambian el conteo, así que anótalas junto al número:

• Reposts. La búsqueda de X deja fuera los reposts simples por defecto y conserva las respuestas. Agrega include:nativeretweets para contar también los reposts, y distínguelos por retweeted_status.
• Respuestas. Agrega -filter:replies para contar solo los posts que inician una conversación.
• Variantes. Une grafías y etiquetas hermanas con OR: (#tidewaterdevdays OR #tidewater2026).

En este ejemplo, la etiqueta de una conferencia ficticia sube de 420 posts el 19 de octubre a 4,812 el 28 de octubre, su primer día, y suma unos 25K posts de 9,214 autores en 14 días. Leerlos todos cuesta desde $1.76 en Sorsa API, frente a $126 en la API oficial de X.

Para tener en cuenta

X fecha cada post en UTC, así que un día del reporte es un día UTC. Para un equipo en Nueva York, el 28 de octubre en hora local va de las 04:00 UTC del 28 a las 04:00 UTC del 29: convierte created_at a tu zona horaria antes de agrupar si el reporte sigue los días locales.

#Encuentra los autores, posts y hashtags relacionados principales

Los autores principales salen de agrupar los mismos posts por user.username: cuenta los posts de cada cuenta y luego suma sus vistas y me gusta, porque la cuenta que más publica y la cuenta que más se lee rara vez son la misma. Cada métrica que necesita un reporte de hashtag sale de campos que llegan con cada post, así que ninguna cuesta una solicitud adicional.

• Posts por día

  Cómo calcularla

  IDs de post por fecha UTC

  Campo

  created_at

• Posts por hora

  Cómo calcularla

  IDs de post por hora UTC, para ver cómo se forma un pico

  Campo

  created_at

• Autores únicos

  Cómo calcularla

  Cuentas distintas

  Campo

  user.id

• Autores principales por posts

  Cómo calcularla

  Posts por cuenta

  Campo

  user.username

• Autores principales por alcance

  Cómo calcularla

  Seguidores de cada cuenta

  Campo

  user.followers_count

• Vistas

  Cómo calcularla

  Suma de las vistas de los posts etiquetados

  Campo

  view_count

• Interacción

  Cómo calcularla

  Me gusta, reposts, respuestas y citas

  Campo

  likes_count, retweet_count, reply_count, quote_count

• Idiomas

  Cómo calcularla

  Posts por idioma

  Campo

  lang

• Hashtags relacionados

  Cómo calcularla

  Etiquetas encontradas en el texto

  Campo

  full_text

Las vistas son el número que X muestra bajo cada post. Sumadas sobre una etiqueta, son la cifra pública más cercana a sus impresiones, y superan al "alcance" por suma de seguidores con que empiezan muchos reportes, ya que los seguidores no ven todos los posts. Conserva ambas y di cuál es cuál.

Compara los posts con los autores únicos antes de confiar en un pico. Miles de posts de unas pocas docenas de cuentas es un empujón, y una etiqueta que miles de personas usan una vez cada una es una conversación. Ordenar a los autores por vistas en lugar de por cantidad de posts suele subir a las voces reales a los primeros lugares.

Los hashtags relacionados salen del texto del post. El campo entities lista multimedia y enlaces, no etiquetas, así que el script extrae cada #palabra de full_text con una expresión regular y las cuenta. Los vecinos más comunes de la etiqueta de una campaña muestran las etiquetas hermanas que conviene agregar a la consulta y las comunidades que alcanzó.

#Cuánto cuesta el seguimiento de hashtags

Leer los posts de un hashtag cuesta desde $0.07 por cada 1,000 en Sorsa API y $5.00 por cada 1,000 en la API oficial de X, unas 70 veces más, antes del cargo de X por los autores. Desde el 22 de noviembre de 2026, X cobra cada autor devuelto con un post a $0.010, la tarifa de lectura de usuario, así que los posts con sus autores cuestan hasta $15.00 por cada 1,000 ahí (aviso de X del 23 de octubre (se abre en una pestaña nueva)). En Sorsa API el perfil del autor viene dentro de cada post sin costo adicional.

La ruta oficial también necesita una cuenta de desarrollador aprobada, una app OAuth y créditos prepagados. Su plan de pago por uso se detiene en 3 millones de lecturas de posts al mes; una etiqueta muy activa que pase de ahí necesita un contrato Enterprise desde unos $42,000 al mes (lista de precios de X (se abre en una pestaña nueva)). Sorsa API pide una clave en un encabezado, nunca te pide tu inicio de sesión de X, y su precio por cada 1,000 posts baja a medida que crecen los planes.

La mayoría de las etiquetas son más pequeñas de lo que parecen. Una etiqueta de producto o de evento con unos cientos de posts al día necesita unas 15 solicitudes diarias para seguirla, y las 100 solicitudes gratis leen unos 2,000 posts, suficiente para dimensionar cualquier etiqueta antes de pagar.

#Mantén en marcha un rastreador de hashtags

Para mantener un rastreador al día, ejecútalo con un calendario y pide solo los posts más nuevos que el último que guardaste, con since_id: fijado en el ID de ese post: #tidewaterdevdays since_id:2117039272883781709. Así cada ejecución lee solo las páginas nuevas, y una hora tranquila cuesta una solicitud.

Elige el intervalo según el ritmo de la etiqueta: cada hora para una campaña en curso, cada pocos minutos durante un evento en vivo. Sorsa API funciona por consulta periódica; no tiene stream ni webhooks, y a 20 solicitudes por segundo una ronda de decenas de etiquetas termina en segundos. Para alertas por Slack o correo cuando una etiqueta se dispare, nuestra guía de monitoreo de Twitter en tiempo real arma el programador y el envío.

Guarda cada post en una tabla con su ID como clave y actualiza la fila cuando vuelvas a ver el post. Las vistas y los me gusta siguen creciendo durante días después de que aparece un post, así que vuelve a leer los últimos dos o tres días antes de publicar las cifras finales de una campaña.

Para saber cuándo una etiqueta despega, revisa las listas de tendencias de X de los lugares que te interesan: GET /trends devuelve la lista actual de un lugar, y la guía de la API de tendencias de Twitter muestra cómo vigilarla. Para varias etiquetas a la vez, ejecuta una consulta por etiqueta en paralelo, para que cada conteo quede separado.

#Empieza a seguir tu hashtag

Un rastreador de hashtags es una búsqueda de la etiqueta con el orden Latest, cada página leída una vez y los posts contados por día UTC y por autor. Sorsa API hace la lectura desde $0.07 por cada 1,000 posts con todos los autores incluidos, 20 solicitudes por segundo en todos los planes e historial hasta 2006; tus primeros 2,000 posts son gratis.

#Preguntas frecuentes