Track Elon Musk's tweets on X in real time

#Three ways to follow Elon Musk's posts as they happen

There are three ways to follow Elon Musk's posts as they go up: X's own bell, a no-code alert service, or a small script that polls his timeline. Only the script can wait for a ticker or a word and hand each post to your own code.

• The bell on his profile. Follow @elonmusk, tap the bell and choose All posts, and X pushes every post to your phone. At his October pace that is dozens of alerts a day with no way to keep only the ones about Tesla or Dogecoin, and they reach only phones signed in to your X account. The steps for any account are in the guide on how to get notified when someone tweets.
• A no-code alert service. Automation services check an account on a timer and forward what they find. The common ones check every few minutes on paid plans and once an hour on free ones, and most forward every post rather than the few you need.
• Your own tracker. A script asks an API for his newest posts every few seconds, keeps the new ones and applies any rule you write: cashtags, words, replies or not, a minimum number of likes. It can post to a chat, write to a database or start a job.

The rest of this guide builds the third option, step by step, and then shows what his real posting rhythm means for how often to poll.

#Track Elon Musk's tweets with Sorsa API

For tracking Elon Musk's posts from code, use Sorsa API, a Twitter (X) API and scraper: one POST /user-tweets (opens in a new tab) request returns his 20 newest posts with the full text, the counts and his profile, and every plan runs 20 requests per second. It needs one API key in an ApiKey header instead of an X developer account and OAuth, and it never asks for your X login, so your own account carries no risk.

1. Get a key. Sign up and copy the API key from your dashboard. The 100 free requests are already on it: 100 polls, or 2,000 of his posts read back through his timeline.

2. Use his user ID, 44196397. A handle can change at any time; the numeric user ID never does, so trackers send user_id. GET /username-to-id (opens in a new tab) turns any handle into its ID, and the free X (Twitter) ID Finder does the same in a browser.

3. Ask for his newest posts. One POST request with his ID returns the latest page of his timeline, newest first: a tweets array and a next_cursor for the page before it. Each post carries its id, full_text, created_at, its counts and the author's full profile, including pinned_tweet_ids. Every account's timeline has the same shape; the trimmed response below comes from a demo account.

   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"
   }
   

   Show full response

4. Keep only the new posts. Every post ID on X grows with time, so the highest ID you have handled works as a checkpoint: anything above it is new. The loop below saves that checkpoint to a file, so a restart neither repeats nor skips posts. It ignores his pinned post when deciding where the new posts end, reads back up to 5 pages after a long pause, and polls every 10 seconds for 30 minutes after he posts, every 60 seconds otherwise. Save the Python version as 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. Start it and leave it running. Set the key, then run the script on any machine that stays on. Save the Node.js version as elon.mjs instead, so it can use top-level await.

   export SORSA_API_KEY="YOUR_API_KEY"
   python3 elon_tracker.py
   

A 429 error means the key went past 20 requests per second, and a 403 means its requests ran out; the loop prints either one and tries again on the next round. Failed requests are never charged.

#Alert only when he mentions a ticker or a topic

To be alerted only about a market, match cashtags such as $TSLA exactly, match plain words such as dogecoin as whole words, and keep the two lists apart. A cashtag is a ticker symbol written after a $ sign, the form X turns into a searchable link.

The split matters because many tickers are also ordinary words. DOGE is the coin's ticker, a meme and the name of a US government office created in 2025, so a rule on the bare word fires on posts that have nothing to do with the coin. Short tickers such as SOL or AI do the same. Matching $DOGE or the word dogecoin keeps the alert on topic; the box in the tester below shows what changes when plain tickers count too.

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

Swap the handle() function in the loop for the one below. It checks the post's own text and the text of any post it quotes, because a one-word reply to a quoted $TSLA post is still about $TSLA, and sends each match to a Telegram chat. The notification guide linked in the first section walks through creating the Telegram bot and adds 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})

The filter runs on your side, so the poll costs the same either way. For words across many accounts at once, POST /search-tweets (opens in a new tab) takes X's own operators, as in from:elonmusk ($TSLA OR $DOGE OR dogecoin) with "order": "latest"; the guide to Twitter search operators lists the rest. For one account, the timeline is the more direct feed.

#How many times Elon Musk posts a day

Elon Musk made 1,504 posts on his main feed in October 2026, about 49 a day, counting original posts, quote posts and reposts but not replies. The count comes from the hourly tallies of Polymarket's XTracker (opens in a new tab), the counter its markets settle on, which leaves replies out unless they show on his main feed.

October was a busy month for him. The same counter recorded 866 posts in September 2026, about 29 a day, and 881 in August, so his pace nearly doubled in a month. His busiest day was October 8, with 126 posts. His replies come on top of all these numbers, which is why counts that include replies run much higher.

He posts in bursts. In 401 of October's 744 hours he made no counted post at all, while 131 hours with five or more posts held 70% of the month's total. The busiest single hour had 22. By hour of day, 1 pm Eastern Time collected the most posts over the month, 139, followed by the hours after midnight; 5 am collected 9.

For a tracker, the bursts are good news: after one post, more tend to follow, so a loop that speeds up after each post and slows down in the quiet hours catches the burst quickly without paying for fast polls all night.

#How often to poll his timeline, and what it costs

Poll every 60 seconds for alerts within a minute, or every 10 seconds when seconds matter: at his October pace even the busiest hour, 22 posts, spreads over 60 polls, far below the 20 posts one poll returns. The interval is also the longest a new post can wait, because a post that lands just after a poll is seen on the next one.

Sorsa API counts one request per poll, whether the poll finds a new post or not, so the monthly cost follows the interval. In a 30-day month:

• 5 minutes

  Longest wait

  5 minutes

  Requests a month

  8,640

  Plan that covers it

  Starter, 10K

• 60 seconds

  Longest wait

  1 minute

  Requests a month

  43.2K

  Plan that covers it

  Pro, 100K

• 30 seconds

  Longest wait

  30 seconds

  Requests a month

  86.4K

  Plan that covers it

  Pro, 100K

• 10 s after a post, 60 s when quiet

  Longest wait

  1 minute for the first post of a burst, then 10 s

  Requests a month

  about 148K

  Plan that covers it

  Growth, 250K

• 15 seconds

  Longest wait

  15 seconds

  Requests a month

  172.8K

  Plan that covers it

  Growth, 250K

• 10 seconds

  Longest wait

  10 seconds

  Requests a month

  259.2K

  Plan that covers it

  Enterprise, 500K

The adaptive row is the loop above, priced on October's real rhythm: 10-second polls through the 343 hours in which he posted and 60-second polls through the 401 hours in which he didn't add up to about 148K requests, against about 268K for a flat 10 seconds over the same 31 days. Every plan runs 20 requests per second per key, so the same key can poll hundreds of other accounts beside his.

Reading back through his timeline costs from $0.07 per 1,000 posts on Sorsa API, 20 posts per request. The official X API (opens in a new tab) charges $5.00 per 1,000 posts read. It also needs a developer account, OAuth and prepaid credits, and its user timeline (opens in a new tab) holds only the 3,200 most recent posts, about two months of his main-feed posts at the October pace.

Good to know

Polymarket's tracker counts a deleted post only if it stayed up for about five minutes. Sorsa API returns posts that are live when you ask, so a post he deletes is gone from his timeline after that. Store each post your tracker catches, with its text and ID, the moment it arrives.

#Replies, reposts and his pinned post

POST /user-tweets returns his posts by default, and three settings change which ones. Many of his posts are short replies, so the choice decides how noisy the tracker is:

• Replies. Add "with_replies": true to the body to get his posts and his replies in one timeline, or send "type": "replies" for replies alone. Most ticker alerts work better without them.
• Reposts. Send "type": "retweets" for his reposts; each one carries the original post in retweeted_status. Polymarket's count includes reposts, so a tracker that wants to match it polls both timelines.
• Quote posts. A quote carries the quoted post in quoted_status, which is why the filter above reads both texts.
• The pinned post. His pinned post can sit at the top of the first page with an old ID. Comparing IDs instead of taking the first item skips it, and the loop's pinned check stops it from ending the read-back early.

Each post also carries likes_count, view_count and the other counts at the moment you read it. A post caught seconds after it went up has few likes yet, so a rule such as "alert on posts over 10K likes" belongs in a second pass that re-reads the post later.

#Use the same tracker for any public account

The tracker follows any public X account once you change one value, the user ID. A founder, a regulator, a company's support account or a sports newsroom all run through the same loop, filter and alert.

Past a handful of accounts, one poll per account adds up. Put the accounts in a public X List instead: one request then reads the newest posts of up to 5,000 accounts, and the guide to real-time Twitter monitoring runs that loop at a 5-second interval with keyword feeds beside it.

The same endpoints answer questions about his past posts. Page POST /search-tweets with from:elonmusk -filter:replies since:2026-10-01 until:2026-11-01 to count or export a window of his posts, and GET /info (opens in a new tab) returns his profile with tweets_count, the total on his profile. To export an account's whole history to a file, follow the guide to download all tweets from a user.

#Start tracking his posts today

Elon Musk posted about 49 times a day in October 2026, in bursts, and a timeline polled every 60 seconds, faster after each post, sees each one within a minute of posting. Sorsa API runs that tracker with one POST /user-tweets request per poll, his user ID 44196397 and one API key: 20 requests per second on every plan, posts read from $0.07 per 1,000, no developer account. Run the loop above on your 100 free requests, add your tickers to the filter, and point the alert at your chat.

#FAQ