Cómo recibir una notificación cuando alguien tuitea

#Activa las notificaciones de los posts de alguien

La alerta propia de X es la campana en cada perfil, y toma cuatro pasos en la app de X para iPhone o Android. Los nombres de abajo son los que usa hoy el Centro de ayuda de X.

1. Sigue la cuenta. La campana solo aparece en los perfiles que sigues.

2. Toca la campana en su perfil. Está junto al botón Siguiendo.

3. Elige Todos los posts. La otra opción, Solo posts con video en vivo, te avisa únicamente cuando transmiten en vivo.

4. Comprueba que las notificaciones push estén activadas. Toca el ícono de tu perfil, luego Configuración y privacidad, Notificaciones, Preferencias y Notificaciones push, y deja activados los posts. Los ajustes de tu teléfono también deben permitir que la app de X envíe notificaciones.

Para detener las alertas, toca la campana otra vez y elige Ninguna. Para ver todas las cuentas de las que recibes alertas de posts, abre la misma pantalla de Notificaciones push y toca posts. El Centro de ayuda de X (se abre en una pestaña nueva) lista los demás tipos de notificación: menciones, respuestas, reposts, likes, seguidores nuevos y mensajes.

#Lo que la campana no puede hacer

La campana es una alerta personal en el teléfono. Deja de bastar en cuanto necesitas los posts de más de una persona en un solo teléfono:

• Debes seguir la cuenta. Sin seguir no hay campana, así que la cuenta de un competidor o el feed de un regulador que prefieres no seguir queda en silencio.
• Un perfil a la vez. Vigilar 300 cuentas significa 300 campanas activadas a mano.
• Solo la oyen tus dispositivos. La alerta llega a los teléfonos con la sesión de tu cuenta de X iniciada. Un grupo de Telegram, un canal de Slack, un bot de trading o un compañero de equipo nunca la ven.
• Personas, no palabras. La campana no tiene opción de palabras clave: no puede esperar un cashtag, el nombre de un producto o que alguien diga "launch".

Los servicios de automatización sin código cubren una parte del vacío, pero también revisan X con un temporizador, desde cada pocos minutos en los planes de pago hasta una vez por hora en algunos gratis, y algunos te piden conectar tu propia cuenta de X. Un script pequeño que corres tú mismo cubre los cuatro límites: cualquier cuenta pública, palabras o ambas, revisadas con la frecuencia que elijas y entregadas a cualquier chat.

#Recibe alertas de muchas cuentas con una Lista de X

Para recibir alertas de muchas cuentas a la vez, ponlas en una Lista pública de X y lee el feed de la Lista con un temporizador: una solicitud devuelve los posts más recientes de hasta 5,000 cuentas. Una Lista de X es un grupo con nombre de cuentas en x.com. No necesitas seguir a nadie que agregues, también sirve cualquier Lista pública que mantenga otra persona, y el feed de la Lista muestra primero los posts más recientes de sus miembros.

Cada post en X lleva un ID numérico que crece con el tiempo. Tu script guarda como punto de control el ID más alto que ya envió; en cada revisión, todo lo que esté por encima de ese número es nuevo y se convierte en una alerta. Revisar cada minuto significa que ningún post espera más de un minuto.

Para alertas de tweets de muchas cuentas de X, usa Sorsa API, una API y scraper de Twitter (X): GET /list-tweets (se abre en una pestaña nueva) lee los posts más recientes de una Lista completa de hasta 5,000 cuentas en una solicitud, todos los planes corren a 20 solicitudes por segundo, y una revisión cuesta lo mismo si la Lista publicó una vez o veinte. Cada post llega con el perfil completo de su autor, con un solo header ApiKey en lugar de una cuenta de desarrollador.

Lado a lado con la campana:

• Cuentas por alerta

  Sorsa API con una Lista de X

  Hasta 5,000 en una solicitud

  La campana de X

  Una campana por perfil

• Hay que seguir la cuenta

  Sorsa API con una Lista de X

  No

  La campana de X

  Sí

• A dónde van las alertas

  Sorsa API con una Lista de X

  Telegram, Slack, correo, una base de datos

  La campana de X

  La app de X en tus dispositivos

• Alertas por palabras clave

  Sorsa API con una Lista de X

  Sí, con operadores de búsqueda de X

  La campana de X

  No

• Con qué frecuencia revisa

  Sorsa API con una Lista de X

  La eliges tú, hasta cada pocos segundos

  La campana de X

  La fija X

• Tu login de X

  Sorsa API con una Lista de X

  Nunca se pide

  La campana de X

  Obligatorio

La guía de monitoreo de Twitter en tiempo real aplica la misma idea con un intervalo de 5 segundos en muchas Listas y feeds de palabras clave. Crear una Lista en masa y exportar sus miembros se cubre en la guía de la API de Listas de Twitter.

#Envía los posts nuevos a Telegram o Slack

Un script de Python de unas 80 líneas revisa la Lista cada minuto y publica cada lote de posts nuevos en un chat de Telegram, un canal de Slack o en ambos. Seis pasos lo ponen en marcha.

1. Consigue una clave. Regístrate y copia la clave API de tu dashboard. Las 100 solicitudes gratis ya están en ella.

2. Crea la Lista. En x.com abre Listas, crea una Lista nueva, deja sin marcar Privada y agrega las cuentas. El ID de la Lista es el número largo al final de la dirección de la Lista, después de /i/lists/.

3. Prepara el lado del chat. Para Slack, crea una app, activa Incoming Webhooks, agrega un webhook para tu canal y copia su URL. Para Telegram, escríbele a BotFather en Telegram, envía /newbot y copia el token del bot. Agrega el bot a tu grupo, publica cualquier mensaje ahí, luego abre esta dirección en un navegador y copia el ID del chat que sigue a "chat":{"id":.

   https://api.telegram.org/bot<token>/getUpdates
   

4. Revisa la Lista una vez. Esta solicitud devuelve la página más reciente del feed de la Lista, hasta 20 posts con sus autores.

   curl -G "https://api.sorsa.io/v3/list-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     --data-urlencode "list_id=1851937264019283746"
   

   {
     "tweets": [
       {
         "id": "2117204918263512064",
         "full_text": "Mainnet upgrade is live. Bridges reopen at 14:00 UTC.",
         "created_at": "2026-11-02T13:12:40Z",
         "lang": "en",
         "is_reply": false,
         "likes_count": 41,
         "retweet_count": 12,
         "reply_count": 6,
         "view_count": 3870,
         "user": {
           "id": "1658112940377133056",
           "username": "northwind_protocol_hq",
           "display_name": "Northwind Protocol",
           "followers_count": 64120,
           "verified": true
         }
       },
       {
         "id": "2117204657719308288",
         "full_text": "Our Q4 roadmap call starts in 30 minutes.",
         "created_at": "2026-11-02T13:11:38Z",
         "lang": "en",
         "is_reply": false,
         "likes_count": 9,
         "retweet_count": 2,
         "reply_count": 1,
         "view_count": 1104,
         "user": {
           "id": "1702291101836602498",
           "username": "lumenforge_labs_team",
           "display_name": "Lumenforge Labs",
           "followers_count": 18832,
           "verified": false
         }
       }
     ],
     "next_cursor": "DAABCgABG3kRk8f__-oKAAIbeRGT0_7_6ggAAwAAAAIAAA"
   }
   

   Ver respuesta completa

5. Corre el script de alertas. Guárdalo como x_alerts.py. La primera ejecución solo registra el ID más reciente, para que no te inunden posts viejos; cada revisión posterior envía lo que es nuevo.

   import os
   import time
   import requests
   
   API = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": os.environ.get("SORSA_API_KEY", "YOUR_API_KEY")}
   LIST_ID = os.environ["X_LIST_ID"]
   TG_TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN")
   TG_CHAT = os.environ.get("TELEGRAM_CHAT_ID")
   SLACK_URL = os.environ.get("SLACK_WEBHOOK_URL")
   INTERVAL = 60          # seconds between checks
   STATE = "last_id.txt"  # the checkpoint survives restarts
   ORIGINALS_ONLY = True  # skip replies and reposts
   
   
   def new_posts(last_id):
       """Read the List's feed back to the checkpoint, oldest first."""
       posts, params = [], {"list_id": LIST_ID}
       for _ in range(5):  # at most 5 pages per check
           r = requests.get(f"{API}/list-tweets", headers=HEADERS,
                            params=params, timeout=30)
           r.raise_for_status()
           page = r.json()
           tweets = page.get("tweets") or []
           fresh = [t for t in tweets if int(t["id"]) > last_id]
           posts += fresh
           cursor = page.get("next_cursor")
           if not last_id or len(fresh) < len(tweets) or not cursor:
               break
           params["next_cursor"] = cursor
       return sorted(posts, key=lambda t: int(t["id"]))
   
   
   def line(t):
       user = t["user"]["username"]
       link = f"https://x.com/{user}/status/{t['id']}"
       return f"@{user}: {t['full_text'][:300]}\n{link}"
   
   
   def messages(lines, limit=4000):
       """Pack posts into as few chat messages as fit."""
       msg = ""
       for ln in lines:
           if msg and len(msg) + len(ln) + 2 > limit:
               yield msg
               msg = ""
           msg = f"{msg}\n\n{ln}" if msg else ln
       if msg:
           yield msg
   
   
   def send(text):
       if TG_TOKEN:
           url = f"https://api.telegram.org/bot{TG_TOKEN}/sendMessage"
           requests.post(url, json={"chat_id": TG_CHAT, "text": text},
                         timeout=30)
       if SLACK_URL:
           requests.post(SLACK_URL, json={"text": text}, timeout=30)
       time.sleep(1.1)  # both chats take about one message a second
   
   
   try:
       last_id = int(open(STATE).read())
   except (OSError, ValueError):
       last_id = 0
   
   while True:
       try:
           posts = new_posts(last_id)
           keep = [t for t in posts if not ORIGINALS_ONLY or not (
               t.get("is_reply") or t.get("retweeted_status"))]
           if last_id and keep:  # the first run only sets the checkpoint
               for text in messages([line(t) for t in keep]):
                   send(text)
           if posts:
               last_id = int(posts[-1]["id"])
               with open(STATE, "w") as f:
                   f.write(str(last_id))
       except requests.RequestException as err:
           print("check failed, retrying next round:", err)
       time.sleep(INTERVAL)
   

6. Déjalo corriendo. Pon las claves en variables de entorno e inicia el script en cualquier máquina que se quede encendida: un servidor pequeño, un contenedor o una computadora de repuesto. Omite las líneas de Telegram o de Slack si usas un solo chat.

   export SORSA_API_KEY="YOUR_API_KEY"
   export X_LIST_ID="1851937264019283746"
   export TELEGRAM_BOT_TOKEN="123456789:YOUR_BOT_TOKEN"
   export TELEGRAM_CHAT_ID="-1001234567890"
   export SLACK_WEBHOOK_URL="https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
   nohup python3 x_alerts.py > x_alerts.log 2>&1 &
   

Cada alerta lleva el handle del autor, el texto y un enlace al post, así que un toque lo abre en X. Cuando varios miembros publican entre dos revisiones, llegan agrupados en un solo mensaje.

El script se mantiene dentro de los límites de cada chat. Las preguntas frecuentes de bots de Telegram (se abre en una pestaña nueva) piden a los bots no enviar más de un mensaje por segundo a un chat y 20 por minuto a un grupo, y un mensaje admite hasta 4,096 caracteres. Los límites de tasa de Slack (se abre en una pestaña nueva) permiten a un webhook entrante un mensaje por segundo y responden con un error HTTP 429 a un exceso sostenido. Agrupar los posts en mensajes de hasta 4,000 caracteres y pausar un segundo entre ellos mantiene ambos canales tranquilos y completos.

#Qué tan rápido llega la alerta y cuánto cuesta

Una alerta llega dentro de un intervalo de revisión desde el post, y la factura mensual sigue al intervalo, no a la cantidad de posts: Sorsa API cuenta una solicitud por revisión sin importar si encuentra veinte posts nuevos o ninguno. En un mes de 30 días, una Lista revisada cada minuto usa 43.2K solicitudes, que los 100K del plan Pro cubren dos veces:

• 5 minutos

  Solicitudes al mes, una Lista

  8.6K

  Plan que lo cubre

  Starter, 10K al mes

• 1 minuto

  Solicitudes al mes, una Lista

  43.2K

  Plan que lo cubre

  Pro, 100K al mes

• 30 segundos

  Solicitudes al mes, una Lista

  86.4K

  Plan que lo cubre

  Pro, 100K al mes

• 15 segundos

  Solicitudes al mes, una Lista

  173K

  Plan que lo cubre

  Growth, 250K al mes

Una Lista es un solo feed sin importar su tamaño, así que vigilar 5,000 cuentas cuesta lo mismo que vigilar cinco. Más de 5,000 cuentas significa una Lista más, y una solicitud más por revisión. El constructor de abajo calcula los feeds, las solicitudes y el plan para tu lista de vigilancia.

La API oficial de X cobra al revés, por post entregado. Su precio de pago por uso (se abre en una pestaña nueva) cobra $0.005 por cada post que devuelve su stream o su búsqueda, $5.00 por 1,000, hasta 3M de lecturas de posts al mes, después de una cuenta de desarrollador aprobada y de configurar una app OAuth. Desde el 22 de noviembre de 2026, X también cobra el autor que se devuelve con cada post como una lectura de usuario a $0.010, según el aviso de X del 23 de octubre (se abre en una pestaña nueva), así que un post con su autor cuesta $0.015. Una lista de vigilancia de 5,000 cuentas que publican tres veces al día cada una envía 450K posts al mes: $2,250 a la tarifa actual y $6,750 con autores. En Sorsa API la misma Lista revisada cada minuto se queda en el plan Pro a $199 al mes.

Las solicitudes fallidas nunca se cobran, y GET /key-usage-info (se abre en una pestaña nueva) muestra las solicitudes que le quedan a tu clave sin gastar ninguna.

#Alertas de una cuenta, una palabra clave o una mención

Cambia la solicitud dentro de new_posts() y el mismo script alerta sobre una cuenta, sobre palabras de los miembros de tu Lista o sobre palabras de cualquiera en X. Cada uno de estos feeds devuelve unos 20 posts por página, los más recientes primero, con los mismos campos de post.

• Una cuenta. POST /user-tweets (se abre en una pestaña nueva) con "username" y "type": "posts" lee los posts propios de esa cuenta sin respuestas, así que no hace falta una Lista.
• Tu Lista, pero solo cuando importa. POST /search-tweets (se abre en una pestaña nueva) con el operador list: alerta solo cuando los miembros de la Lista usan tus palabras, por ejemplo una palabra de lanzamiento o un cashtag.
• Cualquiera que diga una palabra. Quita list: de la consulta para atrapar el nombre de una marca, un hashtag o un ticker de cualquier cuenta pública. La guía de los operadores de búsqueda de Twitter explica lang:, min_faves: y el resto de la sintaxis.
• Menciones de un handle. POST /mentions (se abre en una pestaña nueva) devuelve los posts que etiquetan a una cuenta, y la guía de la API de menciones de Twitter lo combina con una búsqueda por nombre para los posts que nunca la etiquetan.

Dentro del script, la revisión de Lista y palabra clave reemplaza la llamada a list-tweets por esta búsqueda. since_id: limita cada revisión a los posts más nuevos que tu punto de control:

query = (f"list:{LIST_ID} (mainnet OR $NWND) -filter:replies "
         f"since_id:{last_id}")
r = requests.post(f"{API}/search-tweets", headers=HEADERS,
                  json={"query": query, "order": "latest"}, timeout=30)

Para tener en cuenta

Las alertas cubren solo datos públicos. Una Lista privada no se puede leer, y las cuentas protegidas nunca aparecen en ningún feed, así que mantén la Lista pública. Sorsa API es de solo lectura por diseño: nunca publica, da like ni sigue, y nunca te pide tu login de X, así que la cuenta que usas en X no corre ningún riesgo.

#Configura tu primera alerta de tweets

Para una cuenta que sigues, la campana se configura en un minuto y no cuesta nada. Para una lista de vigilancia, un chat de equipo o alertas por palabras, pon las cuentas en una Lista pública de X y deja que Sorsa API la revise: una solicitud cubre hasta 5,000 cuentas, una revisión cada minuto cabe en el plan Pro, y el script de arriba publica cada lote nuevo en Telegram o Slack. Tus 100 solicitudes gratis cubren las primeras 100 revisiones.

#Preguntas frecuentes