Acompanhe os tweets de Elon Musk no X em tempo real

#Três formas de seguir os posts de Elon Musk assim que saem

Há três formas de seguir os posts de Elon Musk assim que são publicados: o sininho do próprio X, um serviço de alertas no-code ou um script pequeno que consulta a timeline dele. Só o script consegue esperar por um ticker ou uma palavra e entregar cada post ao seu próprio código.

• O sininho no perfil dele. Siga @elonmusk, toque no sininho e escolha Todos os posts, e o X envia cada post para o seu celular. No ritmo de outubro, são dezenas de alertas por dia, sem como ficar só com os que falam de Tesla ou Dogecoin, e eles chegam apenas a celulares conectados à sua conta do X. Os passos para qualquer conta estão no guia sobre como ser avisado quando alguém postar.
• Um serviço de alertas no-code. Serviços de automação verificam uma conta em intervalos e encaminham o que encontram. Os mais comuns verificam a cada poucos minutos nos planos pagos e uma vez por hora nos gratuitos, e a maioria encaminha todos os posts, em vez dos poucos de que você precisa.
• Seu próprio tracker. Um script pede a uma API os posts mais recentes dele a cada poucos segundos, guarda os novos e aplica qualquer regra que você escrever: cashtags, palavras, com ou sem respostas, um mínimo de curtidas. Ele pode postar em um chat, gravar em um banco de dados ou disparar um job.

O restante deste guia constrói a terceira opção, passo a passo, e depois mostra o que o ritmo real de postagem dele significa para a frequência das consultas.

#Acompanhe os tweets de Elon Musk com a Sorsa API

Para acompanhar os posts de Elon Musk por código, use a Sorsa API, uma API e scraper do Twitter (X): uma única requisição POST /user-tweets (abre em uma nova aba) retorna os 20 posts mais recentes dele com o texto completo, as contagens e o perfil, e todos os planos rodam a 20 requisições por segundo. Ela precisa de uma chave de API em um header ApiKey, em vez de uma conta de desenvolvedor do X e OAuth, e nunca pede seu login do X, então sua própria conta não corre nenhum risco.

1. Pegue uma chave. Cadastre-se e copie a chave de API do seu painel. As 100 requisições grátis já estão nela: 100 consultas, ou 2.000 posts dele lidos de volta pela timeline.

2. Use o ID de usuário dele, 44196397. Um handle pode mudar a qualquer momento; o ID de usuário numérico nunca muda, então os trackers enviam user_id. GET /username-to-id (abre em uma nova aba) transforma qualquer handle no seu ID, e o Localizador de ID do X (Twitter) gratuito faz o mesmo no navegador.

3. Peça os posts mais recentes dele. Uma requisição POST com o ID dele retorna a página mais recente da timeline, do mais novo para o mais antigo: um array tweets e um next_cursor para a página anterior. Cada post traz seu id, full_text, created_at, suas contagens e o perfil completo do autor, incluindo pinned_tweet_ids. A timeline de toda conta tem o mesmo formato; a resposta reduzida abaixo vem de uma conta de demonstração.

   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 resposta completa

4. Guarde só os posts novos. Todo ID de post no X cresce com o tempo, então o maior ID que você já tratou funciona como checkpoint: tudo o que estiver acima dele é novo. O loop abaixo salva esse checkpoint em um arquivo, de modo que um reinício nem repete nem pula posts. Ele ignora o post fixado dele ao decidir onde terminam os posts novos, lê de volta até 5 páginas depois de uma pausa longa e consulta a cada 10 segundos durante 30 minutos depois que ele posta, e a cada 60 segundos no restante do tempo. Salve a versão em 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. Inicie e deixe rodando. Defina a chave e depois execute o script em qualquer máquina que fique ligada. Salve a versão em Node.js como elon.mjs, para que ela possa usar await no nível superior.

   export SORSA_API_KEY="YOUR_API_KEY"
   python3 elon_tracker.py
   

Um erro 429 significa que a chave passou de 20 requisições por segundo, e um 403 significa que as requisições dela acabaram; o loop mostra qualquer um dos dois e tenta de novo na rodada seguinte. Requisições com falha nunca são cobradas.

#Receba alertas só quando ele mencionar um ticker ou um assunto

Para ser alertado apenas sobre um mercado, filtre cashtags como $TSLA de forma exata, filtre palavras comuns como dogecoin como palavras inteiras e mantenha as duas listas separadas. Um cashtag é o símbolo de um ticker escrito depois de um sinal $, a forma que o X transforma em link pesquisável.

A separação importa porque muitos tickers também são palavras comuns. DOGE é o ticker da moeda, um meme e o nome de um órgão do governo dos EUA criado em 2025, então uma regra sobre a palavra solta dispara em posts que não têm nada a ver com a moeda. Tickers curtos como SOL ou AI fazem o mesmo. Filtrar $DOGE ou a palavra dogecoin mantém o alerta no assunto; a caixa no testador abaixo mostra o que muda quando os tickers sem o $ também contam.

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

Troque a função handle() do loop pela abaixo. Ela confere o texto do próprio post e o texto de qualquer post que ele cita, porque uma resposta de uma palavra a um post citado com $TSLA ainda é sobre $TSLA, e envia cada ocorrência para um chat do Telegram. O guia de notificações indicado na primeira seção mostra como criar o bot do Telegram e acrescenta o 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})

O filtro roda do seu lado, então a consulta custa o mesmo de qualquer forma. Para palavras em muitas contas ao mesmo tempo, POST /search-tweets (abre em uma nova aba) aceita os operadores do próprio X, como em from:elonmusk ($TSLA OR $DOGE OR dogecoin) com "order": "latest"; o guia de operadores de busca do Twitter lista o restante. Para uma conta só, a timeline é o feed mais direto.

#Quantas vezes por dia Elon Musk posta

Elon Musk fez 1.504 posts no feed principal em outubro de 2026, cerca de 49 por dia, contando posts originais, posts com citação e reposts, mas não respostas. A contagem vem dos totais por hora do XTracker da Polymarket (abre em uma nova aba), o contador em que os mercados dela se baseiam para liquidar, que deixa as respostas de fora, a menos que apareçam no feed principal dele.

Outubro foi um mês movimentado para ele. O mesmo contador registrou 866 posts em setembro de 2026, cerca de 29 por dia, e 881 em agosto, então o ritmo dele quase dobrou em um mês. O dia mais movimentado foi 8 de outubro, com 126 posts. As respostas dele vêm somadas a todos esses números, e é por isso que contagens que incluem respostas ficam muito mais altas.

Ele posta em rajadas. Em 401 das 744 horas de outubro, ele não fez nenhum post contabilizado, enquanto 131 horas com cinco ou mais posts concentraram 70% do total do mês. A hora mais movimentada teve 22. Por hora do dia, 13h no horário do leste dos EUA reuniu o maior número de posts no mês, 139, seguida pelas horas depois da meia-noite; 5h reuniu 9.

Para um tracker, as rajadas são uma boa notícia: depois de um post, costumam vir mais, então um loop que acelera depois de cada post e desacelera nas horas tranquilas pega a rajada rápido sem pagar por consultas rápidas a noite toda.

#Com que frequência consultar a timeline dele, e quanto custa

Consulte a cada 60 segundos para ter alertas em até um minuto, ou a cada 10 segundos quando os segundos importam: no ritmo de outubro, até a hora mais movimentada, com 22 posts, se espalha por 60 consultas, muito abaixo dos 20 posts que uma consulta retorna. O intervalo também é o maior tempo que um post novo pode esperar, porque um post que chega logo depois de uma consulta só é visto na seguinte.

A Sorsa API conta uma requisição por consulta, ache ou não um post novo, então o custo mensal acompanha o intervalo. Em um mês de 30 dias:

• 5 minutos

  Maior espera

  5 minutos

  Requisições por mês

  8.640

  Plano que cobre

  Starter, 10 mil

• 60 segundos

  Maior espera

  1 minuto

  Requisições por mês

  43,2 mil

  Plano que cobre

  Pro, 100 mil

• 30 segundos

  Maior espera

  30 segundos

  Requisições por mês

  86,4 mil

  Plano que cobre

  Pro, 100 mil

• 10 s depois de um post, 60 s em silêncio

  Maior espera

  1 minuto para o primeiro post de uma rajada, depois 10 s

  Requisições por mês

  cerca de 148 mil

  Plano que cobre

  Growth, 250 mil

• 15 segundos

  Maior espera

  15 segundos

  Requisições por mês

  172,8 mil

  Plano que cobre

  Growth, 250 mil

• 10 segundos

  Maior espera

  10 segundos

  Requisições por mês

  259,2 mil

  Plano que cobre

  Enterprise, 500 mil

A linha adaptativa é o loop acima, com o preço calculado sobre o ritmo real de outubro: consultas de 10 segundos nas 343 horas em que ele postou e de 60 segundos nas 401 horas em que não postou somam cerca de 148 mil requisições, contra cerca de 268 mil para 10 segundos fixos nos mesmos 31 dias. Todos os planos rodam a 20 requisições por segundo por chave, então a mesma chave pode consultar centenas de outras contas além da dele.

Ler de volta a timeline dele custa a partir de US$ 0,07 por 1.000 posts na Sorsa API, 20 posts por requisição. A API oficial do X (abre em uma nova aba) cobra US$ 5,00 por 1.000 posts lidos. Ela também exige uma conta de desenvolvedor, OAuth e créditos pré-pagos, e sua timeline de usuário (abre em uma nova aba) guarda apenas os 3.200 posts mais recentes, cerca de dois meses de posts do feed principal dele no ritmo de outubro.

Bom saber

O tracker da Polymarket só conta um post apagado se ele ficou no ar por cerca de cinco minutos. A Sorsa API retorna os posts que estão no ar quando você pergunta, então um post que ele apaga some da timeline dele depois disso. Guarde cada post que o seu tracker captar, com o texto e o ID, no momento em que ele chegar.

#Respostas, reposts e o post fixado dele

POST /user-tweets retorna por padrão os posts dele, e três configurações mudam quais são. Muitos dos posts dele são respostas curtas, então a escolha decide o quanto o tracker é barulhento:

• Respostas. Acrescente "with_replies": true ao corpo para receber os posts e as respostas dele em uma única timeline, ou envie "type": "replies" só para as respostas. A maioria dos alertas de ticker funciona melhor sem elas.
• Reposts. Envie "type": "retweets" para os reposts dele; cada um traz o post original em retweeted_status. A contagem da Polymarket inclui reposts, então um tracker que queira bater com ela consulta as duas timelines.
• Posts com citação. Uma citação traz o post citado em quoted_status, e é por isso que o filtro acima lê os dois textos.
• O post fixado. O post fixado dele pode ficar no topo da primeira página com um ID antigo. Comparar IDs em vez de pegar o primeiro item o ignora, e a verificação de fixados do loop impede que ele encerre a leitura de volta mais cedo.

Cada post também traz likes_count, view_count e as outras contagens do momento em que você o lê. Um post captado segundos depois de publicado ainda tem poucas curtidas, então uma regra como "alertar em posts com mais de 10 mil curtidas" pertence a uma segunda passada, que lê o post de novo mais tarde.

#Use o mesmo tracker para qualquer conta pública

O tracker segue qualquer conta pública do X depois que você muda um valor, o ID de usuário. Um fundador, um órgão regulador, a conta de suporte de uma empresa ou a redação de um jornal esportivo passam todos pelo mesmo loop, filtro e alerta.

Passando de um punhado de contas, uma consulta por conta vai somando. Em vez disso, coloque as contas em uma lista pública do X: uma única requisição passa a ler os posts mais recentes de até 5.000 contas, e o guia de monitoramento do Twitter em tempo real executa esse loop com intervalo de 5 segundos, com feeds de palavras-chave ao lado.

Os mesmos endpoints respondem a perguntas sobre os posts antigos dele. Percorra POST /search-tweets com from:elonmusk -filter:replies since:2026-10-01 until:2026-11-01 para contar ou exportar uma janela de posts dele, e GET /info (abre em uma nova aba) retorna o perfil dele com tweets_count, o total que aparece no perfil. Para exportar o histórico inteiro de uma conta para um arquivo, siga o guia para baixar todos os tweets de um usuário.

#Comece a acompanhar os posts dele hoje

Elon Musk postou cerca de 49 vezes por dia em outubro de 2026, em rajadas, e uma timeline consultada a cada 60 segundos, mais rápido depois de cada post, vê cada um deles em até um minuto depois de publicado. A Sorsa API roda esse tracker com uma requisição POST /user-tweets por consulta, o ID de usuário dele, 44196397, e uma chave de API: 20 requisições por segundo em todos os planos, posts lidos a partir de US$ 0,07 por 1.000, sem conta de desenvolvedor. Rode o loop acima com suas 100 requisições grátis, acrescente seus tickers ao filtro e aponte o alerta para o seu chat.

#FAQ