API de menciones de Twitter para cualquier cuenta de X

#Qué devuelve una API de menciones de Twitter

Una API de menciones de Twitter es un endpoint que recibe una cuenta y devuelve los posts públicos que etiquetan su @usuario, del más reciente al más antiguo, en páginas de JSON. Una etiqueta cuenta esté donde esté: al inicio de una respuesta, a la mitad de una frase o en una fila de varios usuarios.

Para ver sin código las menciones recientes de una cuenta, el Verificador de menciones de Twitter gratuito las lista por periodo y mínimo de me gusta. El resto de esta guía hace el mismo trabajo en código, para cualquier cantidad de cuentas y de páginas.

Cada mención llega como un post completo: su texto y hora, sus me gusta, respuestas, reposts, citas y vistas, si responde a alguien y quién lo escribió. Los posts de cuentas protegidas nunca aparecen. Un post que nombra a una marca sin la @ no es una mención en absoluto: requiere una búsqueda por palabra clave, que se explica más abajo.

En la API oficial de X, las menciones salen de GET /2/users/{id}/mentions (referencia de X (se abre en una pestaña nueva)). Recibe el ID numérico de usuario de la cuenta, así que un nombre de usuario requiere primero una consulta de usuario. Cada solicitud devuelve de 5 a 100 posts, y el timeline contiene solo las 800 menciones más recientes de una cuenta (resumen de timelines de X (se abre en una pestaña nueva)). Un post llega solo con su ID y su texto; las fechas, los conteos y el autor llegan únicamente cuando tweet.fields, expansions y user.fields los piden.

El tiempo es el único filtro que acepta el endpoint oficial: start_time, end_time, since_id y until_id. No tiene ajuste para me gusta ni respuestas, así que un equipo de soporte y uno de relaciones públicas descargan el mismo feed y lo ordenan por su cuenta.

#Obtén menciones por nombre de usuario con Sorsa API

Para traer menciones en código, usa Sorsa API, una API y scraper de Twitter (X): POST /mentions devuelve las menciones de cualquier cuenta desde $0.07 por cada 1,000, frente a $5.00 en la API oficial de X. Recibe el nombre de usuario tal como lo escribes y filtra por me gusta, respuestas, retweets y fecha en el mismo cuerpo JSON. Un encabezado ApiKey reemplaza una cuenta de desarrollador y OAuth, y tu cuenta de X nunca interviene.

1. Obtén una clave. Regístrate y copia la clave de API desde tu panel. Las 100 solicitudes gratis ya vienen con ella.

2. Nombra la cuenta. Pon el nombre de usuario en query sin la @, por ejemplo northwind_billing. Puede ser tu marca, un cliente o un competidor: sirve cualquier cuenta pública.

3. Envía la solicitud. Haz POST del cuerpo a POST /mentions (se abre en una pestaña nueva), con "order": "latest" para recibir primero las menciones más recientes.

   curl -X POST "https://api.sorsa.io/v3/mentions" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"query": "northwind_billing", "order": "latest"}'
   

   {
     "tweets": [
       {
         "id": "2116933823886904728",
         "full_text": "@northwind_billing invoices still pending, is sync down?",
         "created_at": "2026-11-01T16:42:09Z",
         "lang": "en",
         "likes_count": 14,
         "retweet_count": 2,
         "reply_count": 3,
         "quote_count": 0,
         "view_count": 2310,
         "bookmark_count": 1,
         "is_reply": false,
         "is_quote_status": false,
         "conversation_id_str": "2116933823886904728",
         "entities": [],
         "user": {
           "id": "1587702913445103616",
           "username": "ops_notes_by_priya",
           "display_name": "Priya, ops notes",
           "followers_count": 4180,
           "verified": false,
           "created_at": "2022-11-02T08:31:44Z"
         }
       },
       {
         "id": "2116909085882164728",
         "full_text": "@northwind_billing the usage export saved me an afternoon",
         "created_at": "2026-11-01T15:03:51Z",
         "lang": "en",
         "likes_count": 87,
         "retweet_count": 9,
         "reply_count": 4,
         "quote_count": 1,
         "view_count": 11920,
         "bookmark_count": 6,
         "is_reply": true,
         "in_reply_to_username": "northwind_billing",
         "in_reply_to_tweet_id": "2116851177420881920",
         "is_quote_status": false,
         "conversation_id_str": "2116851177420881920",
         "entities": [],
         "user": {
           "id": "1371240448912351233",
           "username": "dana_ships_daily_x",
           "display_name": "Dana Okafor",
           "followers_count": 12650,
           "verified": true,
           "created_at": "2021-03-15T00:00:00Z"
         }
       }
     ],
     "next_cursor": "DAADDAABCgABHWD2c1tQkCsKAAIdYAk3gl1QYQ"
   }
   

   Ver respuesta completa

4. Sigue el cursor. Una página contiene hasta 20 menciones, cada una con el perfil completo de su autor dentro de user. Envía next_cursor de vuelta en el mismo cuerpo para la siguiente página, y detente cuando llegue una respuesta sin él.

Una respuesta 403 significa que falta la clave o que se quedó sin solicitudes, y un 401 que es incorrecta. Un 429 significa más de 20 solicitudes en un segundo: espera un segundo y envíala de nuevo. Las solicitudes fallidas nunca se cobran.

Escribe un nombre de usuario y las palabras que la gente usa para la marca en el generador de abajo. Escribe la solicitud de /mentions en curl, Python y Node.js, además de la consulta de búsqueda que encuentra los posts que nombran a la marca sin etiqueta.

curl -X POST "https://api.sorsa.io/v3/mentions" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "northwind_billing", "order": "latest"}'

import requests

r = requests.post(
    "https://api.sorsa.io/v3/mentions",
    headers={"ApiKey": "YOUR_API_KEY"},
    json={
        "query": "northwind_billing",
        "order": "latest",
    },
    timeout=30,
)
page = r.json()
for t in page["tweets"]:
    print(t["user"]["username"], t["full_text"])
print(page.get("next_cursor"))

const res = await fetch("https://api.sorsa.io/v3/mentions", {
  method: "POST",
  headers: { ApiKey: "YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    query: "northwind_billing",
    order: "latest",
  }),
});
const page = await res.json();
for (const t of page.tweets) console.log(t.user.username, t.full_text);
console.log(page.next_cursor);

("northwind billing" OR northwnd OR url:northwind.io) -from:northwind_billing

#Filtra menciones por me gusta, respuestas y fecha

POST /mentions filtra del lado de Sorsa API, así que una solicitud pide solo las menciones que necesita el trabajo y recorre menos páginas. Todos los filtros van en el mismo cuerpo JSON que el nombre de usuario, y se combinan libremente:

• query

  Qué hace

  El nombre de usuario cuyas menciones quieres, sin la @

• order

  Qué hace

  latest, las más recientes primero (el valor por defecto), o popular, las de más interacción primero

• min_likes

  Qué hace

  Conserva las menciones con al menos esta cantidad de me gusta

• min_replies

  Qué hace

  Conserva las menciones con al menos esta cantidad de respuestas

• min_retweets

  Qué hace

  Conserva las menciones con al menos esta cantidad de reposts

• since_date

  Qué hace

  Inicio de la ventana de fechas, como YYYY-MM-DD

• until_date

  Qué hace

  Fin de la ventana de fechas, como YYYY-MM-DD

• next_cursor

  Qué hace

  El cursor de la última respuesta, para la siguiente página

Cuatro cuerpos cubren lo que envían la mayoría de los equipos. Cada uno es un cuerpo de solicitud completo para el comando curl de arriba:

# Support queue: every mention, newest first, no thresholds
{"query": "northwind_billing", "order": "latest"}

# PR and reputation: mentions that reached people
{"query": "northwind_billing", "order": "popular", "min_likes": 100}

# Campaign report: one month of mentions
{"query": "northwind_billing",
 "since_date": "2026-10-01", "until_date": "2026-10-31"}

# Competitor: what people tell a rival, with some traction
{"query": "ledgerly_founder_hq", "order": "popular", "min_retweets": 10}

Mantén los umbrales fuera de un feed de soporte: un reporte de error con dos me gusta necesita respuesta antes que un chiste con quinientos. Los umbrales pertenecen a los reportes y las alertas, donde un puñado de menciones que se difundieron importa más que todas las respuestas. Para poner las menciones de un rival junto a sus seguidores y sus hábitos de publicación, consulta nuestra guía de análisis de competidores en Twitter.

#Recolecta todas las páginas y luego solo las menciones nuevas

Un backfill y un monitor son la misma solicitud con una regla de parada distinta. Un backfill lee una ventana de fechas hasta que se acaba el cursor; un monitor lee las menciones más recientes y se detiene en la primera que ya guardó.

El backfill de abajo escribe un mes de menciones en un archivo JSON Lines, una mención por línea, a medida que llegan las páginas. Un presupuesto de páginas lo detiene, para que una cuenta muy activa no se lleve todas tus solicitudes.

import json
import requests

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


def mentions(handle, max_pages=100, **filters):
    body = {"query": handle, "order": "latest", **filters}
    for _ in range(max_pages):
        r = requests.post(API, json=body, headers=HEADERS, timeout=30)
        r.raise_for_status()
        page = r.json()
        yield from page.get("tweets", [])
        cursor = page.get("next_cursor")
        if not cursor:
            break
        body["next_cursor"] = cursor


with open("mentions.jsonl", "w", encoding="utf-8") as f:
    for t in mentions("northwind_billing",
                      since_date="2026-10-01",
                      until_date="2026-10-31"):
        f.write(json.dumps(t) + "\n")

import { appendFileSync, writeFileSync } from "node:fs";

const API = "https://api.sorsa.io/v3/mentions";
const headers = {
  ApiKey: "YOUR_API_KEY",
  "Content-Type": "application/json",
};

async function* mentions(handle, filters = {}, maxPages = 100) {
  const body = { query: handle, order: "latest", ...filters };
  for (let i = 0; i < maxPages; i++) {
    const res = await fetch(API, {
      method: "POST",
      headers,
      body: JSON.stringify(body),
    });
    if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
    const page = await res.json();
    yield* page.tweets ?? [];
    if (!page.next_cursor) break;
    body.next_cursor = page.next_cursor;
  }
}

const october = { since_date: "2026-10-01", until_date: "2026-10-31" };
writeFileSync("mentions.jsonl", "");
for await (const t of mentions("northwind_billing", october)) {
  appendFileSync("mentions.jsonl", JSON.stringify(t) + "\n");
}

Para mantener un feed al día, ejecuta la función de abajo con un calendario. Recorre las menciones más recientes página por página y se detiene en el primer ID que ya vio, así que una revisión que no encuentra nada nuevo cuesta una sola solicitud. Los IDs de tweets crecen con el tiempo pero llegan como cadenas, así que la comparación los convierte en enteros.

from pathlib import Path

STATE = Path("last_mention_id.txt")


def new_mentions(handle):
    last = int(STATE.read_text()) if STATE.exists() else 0
    fresh = []
    for t in mentions(handle, max_pages=10):
        if int(t["id"]) <= last:
            break
        fresh.append(t)
    if fresh:
        STATE.write_text(fresh[0]["id"])
    return fresh

La primera ejecución no tiene un ID guardado, así que lee hasta 10 páginas y guarda el más reciente. Con qué frecuencia ejecutarlo después depende de qué tan rápido deba responder alguien: un equipo de soporte revisa cada minuto, un reporte semanal una vez al día.

Para tener en cuenta

Guarda el último ID fuera del proceso: un archivo, una fila de base de datos o una clave de Redis. Un monitor que se reinicia sin él vuelve a alertar sobre menciones antiguas o se salta todo lo publicado mientras estuvo caído.

Para alertas en Slack o correo y calendarios para muchas cuentas, nuestra guía de monitoreo de Twitter en tiempo real arma todo el flujo. Vigilar lo que publica un grupo de cuentas es un trabajo distinto de leer lo que otros les dicen. Una Lista de X cubre hasta 5,000 cuentas en un solo feed: consulta la guía de la API de Listas y Comunidades de X.

#Atrapa las menciones que nunca te etiquetan

POST /mentions devuelve los posts que llevan el @usuario. La gente también escribe sobre una marca sin etiquetarla: por nombre, con un error de ortografía, con un enlace a su sitio o citando uno de sus posts. Cada una de esas formas tiene su propio endpoint en Sorsa API.

Para nombres, errores de ortografía y enlaces, envía una consulta a POST /search-tweets (se abre en una pestaña nueva) y deja fuera los posts de la propia marca:

("northwind billing" OR northwnd OR url:northwind.io) -from:northwind_billing

Un post que etiqueta a la marca y la nombra llega desde ambos endpoints, así que usa el ID del tweet como clave en ambos feeds y conserva una sola copia. Lee un centenar de resultados de una consulta nueva antes de programarla: el nombre de una marca que también es una palabra de uso cotidiano necesita más exclusiones, no más páginas.

Las citas de un solo post salen de POST /quotes (se abre en una pestaña nueva), con el texto que cita y su autor, etiquete o no la cita a la marca. Las cuentas que republicaron un post salen de POST /retweeters (se abre en una pestaña nueva) como perfiles. Nuestra guía de la API de búsqueda de Twitter explica la sintaxis de las consultas y el ciclo de búsqueda, y la lista de operadores de búsqueda de Twitter cubre todos los filtros que puede llevar una consulta.

#El endpoint oficial de menciones, lado a lado

El GET /2/users/{id}/mentions de la API oficial de X y el POST /mentions de Sorsa API devuelven los mismos posts públicos. Difieren en lo que envías, lo que vuelve y lo que cuesta. Siete criterios deciden un trabajo de menciones: precio por cada 1,000, historial, filtros, datos del autor, configuración, límite de solicitudes y qué pasa con tu cuenta de X.

La tabla pone los dos endpoints uno junto al otro, con los límites oficiales tomados de la tabla de límites de solicitudes de X (se abre en una pestaña nueva). Sorsa API cuesta unas 71 veces menos por cada 1,000 menciones de cualquier cuenta, y 14 veces menos que la tarifa oficial por leer las tuyas.

• Entrada de cuenta

  Sorsa API

  El nombre de usuario

  API oficial de X

  El ID numérico de usuario, tras una consulta

• Menciones por solicitud

  Sorsa API

  Hasta 20

  API oficial de X

  De 5 a 100

• Hasta cuándo hacia atrás

  Sorsa API

  Cualquier ventana de fechas que fijes; años atrás mediante /search-tweets

  API oficial de X

  Las 800 más recientes

• Filtros

  Sorsa API

  Me gusta, respuestas, reposts, fechas

  API oficial de X

  Fechas e IDs de post

• Perfil del autor

  Sorsa API

  Dentro de cada mención

  API oficial de X

  Mediante expansions, $0.010 cada uno desde el 22 de nov. de 2026

• Límite de solicitudes

  Sorsa API

  20 solicitudes por segundo por clave

  API oficial de X

  450 solicitudes cada 15 minutos por app

• Precio por cada 1,000 menciones

  Sorsa API

  Desde $0.07

  API oficial de X

  $5.00; $1.00 para tu propia cuenta

• Configuración

  Sorsa API

  Una clave de API

  API oficial de X

  Cuenta de desarrollador, app, bearer token

• Tu cuenta de X

  Sorsa API

  Nunca se usa

  API oficial de X

  Vinculada a la cuenta de desarrollador

Sorsa API es de solo lectura por diseño, así que nunca te pide tu inicio de sesión de X y tu cuenta nunca corre riesgo. Para responder menciones desde código, combínala con la API oficial de X para las respuestas: la lectura se queda en Sorsa API, la publicación pasa por X.

#Cuánto cuestan las menciones por cada 1,000

En Sorsa API, las menciones cuestan desde $0.07 por cada 1,000: una solicitud devuelve hasta 20 y se cobra como una solicitud, sin importar lo que contenga. La API oficial de X cobra cada post que devuelve a $0.005, es decir, $5.00 por cada 1,000 menciones (lista de precios de X (se abre en una pestaña nueva)).

Tres detalles mueven la factura oficial. Las menciones de tu propia cuenta, leídas mediante tu propia app de desarrollador, cuentan como lecturas propias a $0.001 por post. Desde el 22 de noviembre de 2026, cada autor devuelto mediante expansions suma $0.010 (aviso de X del 23 de octubre (se abre en una pestaña nueva)), así que 1,000 menciones de 1,000 personas distintas llegan a $15.00. Y el pago por uso se detiene en 3M de lecturas de posts al mes, después de lo cual X vende solo contratos Enterprise. Todas las tarifas oficiales están en nuestro desglose de precios de la API de X.

#Trae tus primeras menciones hoy

Las menciones de una cuenta están a una solicitud de distancia. Pon el nombre de usuario en POST /mentions, agrega los me gusta, respuestas, reposts o fechas que te importen, y vuelven hasta 20 menciones con sus autores. Sorsa API las devuelve desde $0.07 por cada 1,000, frente a $5.00 en la API oficial de X, sin cuenta de desarrollador. Tus 100 solicitudes gratis cubren las primeras 2,000.

#Preguntas frecuentes