Cómo seguir los tweets de Elon Musk en X en tiempo real

#Tres formas de seguir los posts de Elon Musk en cuanto salen

Hay tres formas de seguir los posts de Elon Musk en cuanto se publican: la campanita de X, un servicio de alertas sin código o un script pequeño que consulta su timeline. Solo el script puede esperar un ticker o una palabra y pasar cada post a tu propio código.

• La campanita de su perfil. Sigue a @elonmusk, toca la campanita y elige Todos los posts, y X envía cada post a tu teléfono. Con su ritmo de octubre son decenas de alertas al día, sin forma de quedarte solo con las que hablan de Tesla o Dogecoin, y solo llegan a teléfonos con la sesión de tu cuenta de X iniciada. Los pasos para cualquier cuenta están en la guía para recibir un aviso cuando alguien publique un tweet.
• Un servicio de alertas sin código. Los servicios de automatización revisan una cuenta con un temporizador y reenvían lo que encuentran. Los más comunes revisan cada pocos minutos en los planes de pago y una vez por hora en los gratuitos, y la mayoría reenvía todos los posts en lugar de los pocos que necesitas.
• Tu propio rastreador. Un script pide a una API sus posts más recientes cada pocos segundos, se queda con los nuevos y aplica la regla que escribas: cashtags, palabras, con o sin respuestas, un mínimo de me gusta. Puede publicar en un chat, escribir en una base de datos o iniciar un trabajo.

El resto de esta guía construye la tercera opción, paso a paso, y luego muestra qué implica su ritmo real de publicación para decidir cada cuánto consultar.

#Sigue los tweets de Elon Musk con Sorsa API

Para seguir los posts de Elon Musk desde código, usa Sorsa API, una API y scraper de Twitter (X): una sola solicitud POST /user-tweets (se abre en una pestaña nueva) devuelve sus 20 posts más recientes con el texto completo, los contadores y su perfil, y todos los planes admiten 20 solicitudes por segundo. Necesita una clave API en un encabezado ApiKey en lugar de una cuenta de desarrollador de X y OAuth, y nunca pide tu acceso a X, así que tu propia cuenta no corre ningún riesgo.

1. Consigue una clave. Regístrate y copia la clave API de tu panel. Las 100 solicitudes gratis ya vienen incluidas: 100 consultas, o 2,000 de sus posts leídos hacia atrás en su timeline.

2. Usa su ID de usuario, 44196397. Un nombre de usuario puede cambiar en cualquier momento; el ID numérico nunca cambia, por eso los rastreadores envían user_id. GET /username-to-id (se abre en una pestaña nueva) convierte cualquier nombre de usuario en su ID, y el Buscador de ID de X (Twitter) gratuito hace lo mismo en el navegador.

3. Pide sus posts más recientes. Una solicitud POST con su ID devuelve la página más reciente de su timeline, de lo más nuevo a lo más antiguo: un arreglo tweets y un next_cursor para la página anterior. Cada post trae su id, full_text, created_at, sus contadores y el perfil completo del autor, incluido pinned_tweet_ids. El timeline de cualquier cuenta tiene la misma forma; la respuesta recortada de abajo viene de una cuenta de demostración.

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

   {
     "tweets": [
       {
         "id": "2117211830570418176",
         "full_text": "Static fire complete. Next launch window opens Friday.",
         "created_at": "2026-11-02T13:40:12Z",
         "lang": "en",
         "is_reply": false,
         "is_quote_status": false,
         "likes_count": 1840,
         "retweet_count": 212,
         "reply_count": 97,
         "quote_count": 18,
         "view_count": 96400,
         "user": {
           "id": "1734502298114760704",
           "username": "orbital_freight_updates",
           "display_name": "Orbital Freight (demo)",
           "followers_count": 412300,
           "tweets_count": 18230,
           "pinned_tweet_ids": ["2098874410262118400"]
         }
       }
     ],
     "next_cursor": "DAABCgABG3kRk9Wf_-oKAAIbeRGT0_7_6ggAAwAAAAIAAA"
   }
   

   Ver respuesta completa

4. Quédate solo con los posts nuevos. El ID de cada post en X crece con el tiempo, así que el ID más alto que ya procesaste sirve como punto de control: todo lo que esté por encima es nuevo. El bucle de abajo guarda ese punto de control en un archivo, de modo que un reinicio ni repite ni se salta posts. Ignora su post fijado al decidir dónde terminan los posts nuevos, lee hacia atrás hasta 5 páginas después de una pausa larga, y consulta cada 10 segundos durante 30 minutos después de que él publica, y cada 60 segundos el resto del tiempo. Guarda la versión de Python como elon_tracker.py.

   import os
   import time
   import requests
   
   API = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": os.environ.get("SORSA_API_KEY", "YOUR_API_KEY")}
   USER_ID = "44196397"  # @elonmusk; the ID never changes
   FAST, SLOW = 10, 60   # seconds between polls: busy / quiet
   BUSY_FOR = 30 * 60    # stay fast for 30 minutes after a post
   STATE = "elon_last_id.txt"
   
   
   def new_posts(last_id):
       """Posts above the checkpoint, oldest first."""
       found, body = [], {"user_id": USER_ID}
       for _ in range(5):  # at most 5 pages after a long pause
           r = requests.post(f"{API}/user-tweets", headers=HEADERS,
                             json=body, timeout=30)
           r.raise_for_status()
           page = r.json()
           tweets = page.get("tweets") or []
           pinned = {p for t in tweets
                     for p in t["user"].get("pinned_tweet_ids") or []}
           fresh = [t for t in tweets if int(t["id"]) > last_id]
           older = [t for t in tweets if int(t["id"]) <= last_id
                    and t["id"] not in pinned]
           found += fresh
           cursor = page.get("next_cursor")
           if not last_id or older or not cursor:
               break
           body["next_cursor"] = cursor
       return sorted(found, key=lambda t: int(t["id"]))
   
   
   def handle(post):
       """Print each new post; the next section adds a filter."""
       link = f"https://x.com/elonmusk/status/{post['id']}"
       print(post["created_at"], post["full_text"][:120], link)
   
   
   try:
       last_id = int(open(STATE).read())
   except (OSError, ValueError):
       last_id = 0  # the first run only sets the checkpoint
   last_post = 0.0
   
   while True:
       try:
           posts = new_posts(last_id)
           if posts and last_id:
               for post in posts:
                   handle(post)
               last_post = time.time()
           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("poll failed, trying again:", err)
       busy = time.time() - last_post < BUSY_FOR
       time.sleep(FAST if busy else SLOW)
   

   import fs from "node:fs";
   
   const API = "https://api.sorsa.io/v3";
   const HEADERS = {
     ApiKey: process.env.SORSA_API_KEY ?? "YOUR_API_KEY",
     "Content-Type": "application/json",
   };
   const USER_ID = "44196397"; // @elonmusk; the ID never changes
   const FAST = 10_000;          // ms between polls when busy
   const SLOW = 60_000;          // ms between polls when quiet
   const BUSY_FOR = 30 * 60_000; // stay fast for 30 min after a post
   const STATE = "elon_last_id.txt";
   const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
   
   async function newPosts(lastId) {
     const found = [];
     const body = { user_id: USER_ID };
     for (let i = 0; i < 5; i++) {
       const r = await fetch(`${API}/user-tweets`, {
         method: "POST", headers: HEADERS, body: JSON.stringify(body),
       });
       if (!r.ok) throw new Error(`HTTP ${r.status}`);
       const page = await r.json();
       const tweets = page.tweets ?? [];
       const pinned = new Set(
         tweets.flatMap((t) => t.user?.pinned_tweet_ids ?? []));
       const fresh = tweets.filter((t) => BigInt(t.id) > lastId);
       const older = tweets.filter(
         (t) => BigInt(t.id) <= lastId && !pinned.has(t.id));
       found.push(...fresh);
       if (!lastId || older.length || !page.next_cursor) break;
       body.next_cursor = page.next_cursor;
     }
     return found.sort((a, b) => (BigInt(a.id) < BigInt(b.id) ? -1 : 1));
   }
   
   function handle(post) {
     const link = `https://x.com/elonmusk/status/${post.id}`;
     console.log(post.created_at, post.full_text.slice(0, 120), link);
   }
   
   let lastId = 0n;
   try { lastId = BigInt(fs.readFileSync(STATE, "utf8").trim()); } catch {}
   let lastPost = 0;
   
   while (true) {
     try {
       const posts = await newPosts(lastId);
       if (posts.length && lastId) {
         posts.forEach(handle);
         lastPost = Date.now();
       }
       if (posts.length) {
         lastId = BigInt(posts.at(-1).id);
         fs.writeFileSync(STATE, String(lastId));
       }
     } catch (err) {
       console.error("poll failed, trying again:", err.message);
     }
     await sleep(Date.now() - lastPost < BUSY_FOR ? FAST : SLOW);
   }
   

5. Ponlo en marcha y déjalo corriendo. Define la clave y ejecuta el script en cualquier máquina que se mantenga encendida. Guarda la versión de Node.js como elon.mjs, para que pueda usar await de nivel superior.

   export SORSA_API_KEY="YOUR_API_KEY"
   python3 elon_tracker.py
   

Un error 429 significa que la clave superó las 20 solicitudes por segundo, y un 403 significa que se le acabaron las solicitudes; el bucle imprime cualquiera de los dos y vuelve a intentarlo en la siguiente ronda. Las solicitudes fallidas nunca se cobran.

#Recibe una alerta solo cuando mencione un ticker o un tema

Para que te avisen solo de un mercado, busca coincidencias exactas con cashtags como $TSLA, busca palabras simples como dogecoin como palabras completas y mantén separadas las dos listas. Un cashtag es el símbolo de un ticker escrito después del signo $, la forma que X convierte en un enlace de búsqueda.

La separación importa porque muchos tickers también son palabras comunes. DOGE es el ticker de la moneda, un meme y el nombre de una oficina del gobierno de Estados Unidos creada en 2025, así que una regla sobre la palabra suelta se activa con posts que no tienen nada que ver con la moneda. Los tickers cortos como SOL o AI hacen lo mismo. Buscar $DOGE o la palabra dogecoin mantiene la alerta en el tema; la casilla del probador de abajo muestra qué cambia cuando también cuentan los tickers sin el signo.

TICKERS = {"TSLA", "DOGE", "BTC"}
WORDS = {"dogecoin", "starship", "tesla"}
PLAIN_TICKERS = False

Cambia la función handle() del bucle por la de abajo. Revisa el texto del propio post y el de cualquier post que cite, porque una respuesta de una palabra a un post citado con $TSLA sigue siendo sobre $TSLA, y envía cada coincidencia a un chat de Telegram. La guía de notificaciones enlazada en la primera sección explica cómo crear el bot de Telegram y agrega Slack.

import re

TICKERS = {"TSLA", "DOGE", "BTC"}          # matched as $TSLA only
WORDS = {"dogecoin", "starship", "tesla"}  # whole words, any case
PLAIN_TICKERS = False  # True also matches DOGE without the $ sign
TG = f"https://api.telegram.org/bot{os.environ['TG_BOT_TOKEN']}"


def hits(text):
    """The rule's matches in a post's text, as a sorted list."""
    text = re.sub(r"https?://\S+", " ", text)  # skip links
    tags = re.findall(r"\$([A-Za-z]{1,6})\b", text)
    found = {"$" + t.upper() for t in tags if t.upper() in TICKERS}
    terms = WORDS | ({t.lower() for t in TICKERS}
                     if PLAIN_TICKERS else set())
    for term in terms:
        pattern = rf"(?<![\w$]){re.escape(term)}(?!\w)"
        if re.search(pattern, text, re.IGNORECASE):
            found.add(term)
    return sorted(found)


def handle(post):
    """Alert when the post, or the post it quotes, matches."""
    quoted = (post.get("quoted_status") or {}).get("full_text", "")
    found = hits(post["full_text"] + "\n" + quoted)
    if not found:
        return
    link = f"https://x.com/elonmusk/status/{post['id']}"
    text = f"{' '.join(found)}\n{post['full_text'][:500]}\n{link}"
    requests.post(f"{TG}/sendMessage", timeout=30,
                  json={"chat_id": os.environ["TG_CHAT_ID"],
                        "text": text})

El filtro se ejecuta de tu lado, así que la consulta cuesta lo mismo en ambos casos. Para buscar palabras en muchas cuentas a la vez, POST /search-tweets (se abre en una pestaña nueva) acepta los operadores propios de X, como en from:elonmusk ($TSLA OR $DOGE OR dogecoin) con "order": "latest"; la guía de operadores de búsqueda de Twitter enumera el resto. Para una sola cuenta, el timeline es la fuente más directa.

#Cuántas veces publica Elon Musk al día

Elon Musk publicó 1,504 posts en su feed principal en octubre de 2026, unos 49 al día, contando posts originales, posts citados y reposts, pero no respuestas. La cifra sale de los conteos por hora de XTracker de Polymarket (se abre en una pestaña nueva), el contador en el que se resuelven sus mercados, que deja fuera las respuestas a menos que aparezcan en su feed principal.

Octubre fue un mes movido para él. El mismo contador registró 866 posts en septiembre de 2026, unos 29 al día, y 881 en agosto, así que su ritmo casi se duplicó en un mes. Su día más activo fue el 8 de octubre, con 126 posts. Sus respuestas se suman a todas estas cifras, y por eso los conteos que las incluyen son mucho más altos.

Publica en ráfagas. En 401 de las 744 horas de octubre no hizo ningún post contado, mientras que 131 horas con cinco o más posts concentraron el 70% del total del mes. La hora individual más activa tuvo 22. Por hora del día, la 1 pm, hora del este, reunió más posts en el mes, 139, seguida de las horas después de medianoche; las 5 am reunieron 9.

Para un rastreador, las ráfagas son una buena noticia: después de un post suelen venir más, así que un bucle que se acelera después de cada post y se relaja en las horas tranquilas atrapa la ráfaga rápido sin pagar consultas rápidas toda la noche.

#Cada cuánto consultar su timeline y cuánto cuesta

Consulta cada 60 segundos para recibir alertas en menos de un minuto, o cada 10 segundos cuando importan los segundos: con su ritmo de octubre, incluso la hora más activa, con 22 posts, se reparte en 60 consultas, muy por debajo de los 20 posts que devuelve una sola. El intervalo también es lo máximo que puede esperar un post nuevo, porque un post que aparece justo después de una consulta se ve en la siguiente.

Sorsa API cuenta una solicitud por consulta, encuentre o no un post nuevo, así que el costo mensual depende del intervalo. En un mes de 30 días:

• 5 minutos

  Espera máxima

  5 minutos

  Solicitudes al mes

  8,640

  Plan que lo cubre

  Starter, 10,000

• 60 segundos

  Espera máxima

  1 minuto

  Solicitudes al mes

  43,200

  Plan que lo cubre

  Pro, 100,000

• 30 segundos

  Espera máxima

  30 segundos

  Solicitudes al mes

  86,400

  Plan que lo cubre

  Pro, 100,000

• 10 s después de un post, 60 s en calma

  Espera máxima

  1 minuto para el primer post de una ráfaga, luego 10 s

  Solicitudes al mes

  unas 148,000

  Plan que lo cubre

  Growth, 250,000

• 15 segundos

  Espera máxima

  15 segundos

  Solicitudes al mes

  172,800

  Plan que lo cubre

  Growth, 250,000

• 10 segundos

  Espera máxima

  10 segundos

  Solicitudes al mes

  259,200

  Plan que lo cubre

  Enterprise, 500,000

La fila adaptativa es el bucle de arriba, calculado con el ritmo real de octubre: las consultas cada 10 segundos durante las 343 horas en que publicó y las consultas cada 60 segundos durante las 401 horas en que no, suman unas 148,000 solicitudes, frente a unas 268,000 con un intervalo fijo de 10 segundos en esos mismos 31 días. Todos los planes admiten 20 solicitudes por segundo por clave, así que la misma clave puede consultar cientos de otras cuentas además de la suya.

Leer hacia atrás en su timeline cuesta desde $0.07 por cada 1,000 posts en Sorsa API, con 20 posts por solicitud. La API oficial de X (se abre en una pestaña nueva) cobra $5.00 por cada 1,000 posts leídos. Además exige una cuenta de desarrollador, OAuth y créditos prepagados, y su timeline de usuario (se abre en una pestaña nueva) guarda solo los 3,200 posts más recientes, unos dos meses de posts de su feed principal con el ritmo de octubre.

Para tener en cuenta

El rastreador de Polymarket cuenta un post eliminado solo si estuvo publicado unos cinco minutos. Sorsa API devuelve los posts que están en línea cuando los pides, así que un post que él borra desaparece de su timeline a partir de ese momento. Guarda cada post que atrape tu rastreador, con su texto y su ID, en el momento en que llega.

#Respuestas, reposts y su post fijado

POST /user-tweets devuelve sus posts por defecto, y tres ajustes cambian cuáles. Muchos de sus posts son respuestas cortas, así que esta elección decide cuánto ruido tiene el rastreador:

• Respuestas. Agrega "with_replies": true al cuerpo para obtener sus posts y sus respuestas en un solo timeline, o envía "type": "replies" para recibir solo las respuestas. La mayoría de las alertas por ticker funcionan mejor sin ellas.
• Reposts. Envía "type": "retweets" para sus reposts; cada uno trae el post original en retweeted_status. El conteo de Polymarket incluye los reposts, así que un rastreador que quiera coincidir con él consulta ambos timelines.
• Posts citados. Una cita trae el post citado en quoted_status, y por eso el filtro de arriba lee ambos textos.
• El post fijado. Su post fijado puede aparecer arriba de la primera página con un ID antiguo. Comparar IDs en lugar de tomar el primer elemento lo omite, y la comprobación de fijados del bucle evita que termine antes de tiempo la lectura hacia atrás.

Cada post también trae likes_count, view_count y los demás contadores tal como están en el momento en que lo lees. Un post atrapado unos segundos después de publicarse todavía tiene pocos me gusta, así que una regla como "alertar con posts de más de 10,000 me gusta" corresponde a una segunda pasada que vuelva a leer el post más tarde.

#Usa el mismo rastreador con cualquier cuenta pública

El rastreador sigue a cualquier cuenta pública de X cuando cambias un solo valor, el ID de usuario. Un fundador, un regulador, la cuenta de soporte de una empresa o la redacción deportiva de un medio pasan por el mismo bucle, filtro y alerta.

Pasado un puñado de cuentas, una consulta por cuenta se acumula. Mejor pon las cuentas en una Lista pública de X: una sola solicitud lee entonces los posts más recientes de hasta 5,000 cuentas, y la guía de monitoreo de Twitter en tiempo real ejecuta ese bucle con un intervalo de 5 segundos y feeds de palabras clave al lado.

Los mismos endpoints responden preguntas sobre sus posts pasados. Pagina POST /search-tweets con from:elonmusk -filter:replies since:2026-10-01 until:2026-11-01 para contar o exportar una ventana de sus posts, y GET /info (se abre en una pestaña nueva) devuelve su perfil con tweets_count, el total que aparece en su perfil. Para exportar a un archivo todo el historial de una cuenta, sigue la guía para descargar todos los tweets de un usuario.

#Empieza hoy a seguir sus posts

Elon Musk publicó unas 49 veces al día en octubre de 2026, en ráfagas, y un timeline consultado cada 60 segundos, más rápido después de cada post, ve cada uno en el minuto siguiente a su publicación. Sorsa API ejecuta ese rastreador con una solicitud POST /user-tweets por consulta, su ID de usuario 44196397 y una clave API: 20 solicitudes por segundo en todos los planes, posts leídos desde $0.07 por cada 1,000, sin cuenta de desarrollador. Ejecuta el bucle de arriba con tus 100 solicitudes gratis, agrega tus tickers al filtro y dirige la alerta a tu chat.

#Preguntas frecuentes