实时追踪 Elon Musk 在 X 上的推文

#实时关注 Elon Musk 帖子的三种方式

实时关注 Elon Musk 的帖子有三种方式：X 自带的小铃铛、无需写代码的提醒服务，或一个轮询他时间线的小脚本。只有脚本能等待某个股票代码或关键词出现，并把每条帖子交给你自己的代码处理。

• 他主页上的小铃铛。 关注 @elonmusk，点小铃铛并选择“所有帖子”，X 就会把他的每条帖子推送到你的手机。按他 10 月的发帖节奏，一天会有几十条提醒，却没办法只保留与 Tesla 或 Dogecoin 有关的那几条，而且提醒只会发到登录了你 X 账号的手机上。任意账号的设置步骤见指南：有人发推时收到通知。
• 无需写代码的提醒服务。 自动化服务按定时器检查账号，并转发查到的内容。常见的服务在付费套餐下每隔几分钟检查一次，免费套餐则每小时一次，而且大多会转发每一条帖子，而不是你需要的那几条。
• 你自己的追踪器。 脚本每隔几秒向 API 请求他最新的帖子，保留新的那些，并套用你写的任何规则：cashtag、关键词、是否包含回复、最低点赞数。它可以向聊天群发消息、写入数据库或启动任务。

本指南的其余部分会一步步搭出第三种方式，然后用他真实的发帖节奏说明该多久轮询一次。

#用 Sorsa API 追踪 Elon Musk 的推文

要用代码追踪 Elon Musk 的帖子，请用 Sorsa API，一款 Twitter（X）API 与爬虫：一次 POST /user-tweets（在新标签页打开） 请求就返回他最新的 20 条帖子，包含完整正文、各项计数和他的用户资料，所有套餐都是每秒 20 次请求。它只需要在 ApiKey 请求头里放一个 API 密钥，不需要 X 开发者账号和 OAuth，也从不索要你的 X 登录信息，所以你自己的账号没有风险。

1. 获取密钥。 注册后，从控制台复制 API 密钥。账号里已经有 100 次免费请求：可以轮询 100 次，或者通过他的时间线回读 2,000 条他的帖子。

2. 使用他的用户 ID：44196397。 用户名随时可能更改，而数字形式的用户 ID 永远不变，所以追踪器发送的是 user_id。GET /username-to-id（在新标签页打开） 可以把任何用户名换成它的 ID，免费的 X（Twitter）ID 查询工具在浏览器里也能做到。

3. 请求他最新的帖子。 带上他的 ID 发一次 POST 请求，就会返回他时间线的最新一页，按从新到旧排序：一个 tweets 数组，以及用于获取更早一页的 next_cursor。每条帖子都带有它的 id、full_text、created_at、各项计数，以及作者的完整资料（包括 pinned_tweet_ids）。每个账号的时间线结构都一样；下面精简后的响应来自一个演示账号。

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

   显示完整响应

4. 只保留新帖子。 X 上每条帖子的 ID 都随时间递增，所以你处理过的最大 ID 就可以当检查点：比它大的都是新帖子。下面的循环把这个检查点存进文件，因此重启后既不会重复也不会漏掉帖子。它在判断新帖子到哪里为止时会忽略他的置顶帖，长时间中断后最多回读 5 页，并且在他发帖后的 30 分钟内每 10 秒轮询一次，其余时间每 60 秒一次。请把 Python 版本保存为 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. 启动并让它一直运行。 设置好密钥，然后在任何一台保持开机的机器上运行脚本。Node.js 版本请改存为 elon.mjs，这样才能使用顶层 await。

   export SORSA_API_KEY="YOUR_API_KEY"
   python3 elon_tracker.py
   

出现 429 错误说明密钥超过了每秒 20 次请求，出现 403 则说明请求额度已用完；循环会打印出这两种错误，并在下一轮重试。失败的请求不会计费。

#只在他提到某个股票代码或话题时提醒

如果只想收到某个市场的提醒，就要精确匹配 $TSLA 这样的 cashtag，把 dogecoin 这样的普通词按整词匹配，并把这两份列表分开。cashtag 是写在 $ 符号后面的股票代码，X 会把这种写法变成可搜索的链接。

之所以要分开，是因为很多股票代码同时也是普通词。DOGE 既是这个币的代码，也是一个梗，还是 2025 年成立的一个美国政府机构的名称，所以对裸词设置的规则，会被与这个币毫无关系的帖子触发。SOL 或 AI 这类短代码也有同样的问题。匹配 $DOGE 或词 dogecoin，能让提醒保持在主题内；下面测试器里的选项会展示把普通代码也算进去后有什么变化。

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

把循环里的 handle() 函数换成下面这个。它会检查帖子本身的文字，以及它所引用帖子的文字，因为对一条引用了 $TSLA 帖子的单字回复，说的依然是 $TSLA，然后把每个匹配项发送到一个 Telegram 聊天。第一节中链接的通知指南，会带你创建 Telegram 机器人，并补充了 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})

过滤在你这一侧运行，所以不论怎样，轮询的费用都一样。如果要同时监控许多账号上的关键词，POST /search-tweets（在新标签页打开） 支持 X 自己的搜索运算符，例如 from:elonmusk ($TSLA OR $DOGE OR dogecoin) 配合 "order": "latest"；其余运算符见 Twitter 搜索运算符指南。只盯一个账号时，直接读时间线更省事。

#Elon Musk 每天发多少条帖子

Elon Musk 在 2026 年 10 月的主页上发了 1,504 条帖子，平均每天约 49 条，统计包括原创帖、引用帖和转发，但不含回复。这个数字来自 Polymarket 的 XTracker（在新标签页打开） 的每小时统计，也就是其预测市场结算所依据的计数器，除非回复出现在他的主页上，否则不计入。

10 月对他来说是忙碌的一个月。同一个计数器记录到 2026 年 9 月有 866 条，平均每天约 29 条，8 月有 881 条，所以他的发帖节奏在一个月里几乎翻了一倍。最忙的一天是 10 月 8 日，发了 126 条。他的回复还要在这些数字之外另算，这也是包含回复的统计数字高得多的原因。

他的发帖是一阵一阵的。10 月的 744 个小时里，有 401 个小时他一条计入统计的帖子都没发，而有 5 条及以上的 131 个小时，却占了当月总数的 70%。最忙的单个小时发了 22 条。按一天中的小时划分，美国东部时间下午 1 点整月累计的帖子最多，为 139 条，其次是午夜过后的几个小时；凌晨 5 点为 9 条。

对追踪器来说，这种爆发式的节奏是好消息：发出一条之后，往往还会跟着更多，所以一个在每条帖子之后加快、在安静时段放慢的循环，既能很快抓住一波爆发，又不必整夜为高频轮询付费。

#多久轮询一次他的时间线，要花多少钱

想在一分钟内收到提醒就每 60 秒轮询一次，要精确到秒就每 10 秒一次：按他 10 月的节奏，即使是最忙的那个小时（22 条帖子），也会分摊在 60 次轮询里，远低于一次轮询返回的 20 条。轮询间隔同时也是一条新帖子最长要等的时间，因为刚好落在某次轮询之后的帖子，要到下一次轮询才会被看到。

Sorsa API 每次轮询计一次请求，不管这次轮询有没有发现新帖子，所以月费用取决于轮询间隔。按 30 天的一个月计算：

• 5 分钟

  最长等待

  5 分钟

  每月请求数

  8,640

  能覆盖的套餐

  Starter，1 万

• 60 秒

  最长等待

  1 分钟

  每月请求数

  4.32 万

  能覆盖的套餐

  Pro，10 万

• 30 秒

  最长等待

  30 秒

  每月请求数

  8.64 万

  能覆盖的套餐

  Pro，10 万

• 发帖后 10 秒，安静时 60 秒

  最长等待

  一波爆发的第一条为 1 分钟，之后 10 秒

  每月请求数

  约 14.8 万

  能覆盖的套餐

  Growth，25 万

• 15 秒

  最长等待

  15 秒

  每月请求数

  17.28 万

  能覆盖的套餐

  Growth，25 万

• 10 秒

  最长等待

  10 秒

  每月请求数

  25.92 万

  能覆盖的套餐

  Enterprise，50 万

自适应那一行就是上面的循环，按 10 月的真实节奏计价：他发过帖的 343 个小时里每 10 秒轮询一次，没发帖的 401 个小时里每 60 秒轮询一次，加起来约 14.8 万次请求，而在同样的 31 天里始终保持每 10 秒轮询则需要约 26.8 万次。每个套餐的每个密钥都是每秒 20 次请求，所以同一个密钥除了他的账号，还能轮询数百个其他账号。

在 Sorsa API 上回读他的时间线，每 1,000 条帖子 $0.07 起，每次请求 20 条。官方 X API（在新标签页打开） 每读取 1,000 条帖子收费 $5.00，还需要开发者账号、OAuth 和预付额度，而且它的用户时间线（在新标签页打开）只保留最近 3,200 条帖子，按 10 月的节奏，大约只相当于他两个月的主页帖子。

须知

Polymarket 的追踪器只统计在线超过约五分钟的已删除帖子。Sorsa API 返回的是你请求时仍然在线的帖子，所以他删掉的帖子，之后就不会再出现在他的时间线上。每条帖子一到，就把它的正文和 ID 存下来。

#回复、转发和他的置顶帖

POST /user-tweets 默认返回他的帖子，有三个设置会改变返回哪些帖子。他的很多帖子是简短回复，所以这个选择决定追踪器有多吵：

• 回复。 在请求体里加上 "with_replies": true，可以在同一条时间线里同时拿到他的帖子和回复；只要回复则发送 "type": "replies"。多数股票代码提醒不带回复效果更好。
• 转发。 发送 "type": "retweets" 获取他的转发；每条转发都在 retweeted_status 中带有原帖。Polymarket 的计数包含转发，所以想与之对齐的追踪器要同时轮询两条时间线。
• 引用帖。 引用帖会在 quoted_status 中带有被引用的帖子，这就是上面的过滤器要同时读取两段文字的原因。
• 置顶帖。 他的置顶帖可能带着一个很旧的 ID 排在第一页的最前面。比较 ID 而不是直接取第一项，就能跳过它，而循环里对置顶帖的检查，则避免它提前结束回读。

每条帖子还带有你读取那一刻的 likes_count、view_count 和其他计数。发出几秒钟就被抓到的帖子，点赞还很少，所以像“超过 1 万点赞的帖子才提醒”这样的规则，应该放在稍后重新读取帖子的第二轮处理里。

#用同一个追踪器监控任何公开账号

只要改一个值（用户 ID），这个追踪器就能跟踪任何公开的 X 账号。创始人、监管机构、公司的客服账号或体育媒体编辑部，都可以走同一个循环、过滤器和提醒。

账号一多，每个账号一次轮询就会累积起来。可以改为把这些账号放进一个公开的 X 列表：一次请求就能读取多达 5,000 个账号的最新帖子，实时 Twitter 监控指南就是按 5 秒的间隔运行这个循环，并配上关键词信息流。

同样的接口也能回答关于他过往帖子的问题。对 POST /search-tweets 翻页，查询 from:elonmusk -filter:replies since:2026-10-01 until:2026-11-01，就能统计或导出他某一时间段的帖子；GET /info（在新标签页打开） 返回他的资料，其中 tweets_count 是他个人主页上的总数。想把某个账号的全部历史导出到文件，请参考下载某个用户的全部推文指南。

#今天就开始追踪他的帖子

Elon Musk 在 2026 年 10 月平均每天发约 49 条帖子，而且是一阵一阵地发；每 60 秒轮询一次他的时间线，并在每条帖子之后提速，就能在发出后一分钟内看到每一条。Sorsa API 用每次轮询一次 POST /user-tweets 请求、他的用户 ID 44196397 和一个 API 密钥，就能运行这个追踪器：所有套餐都是每秒 20 次请求，读取帖子每 1,000 条 $0.07 起，不需要开发者账号。用你那 100 次免费请求跑一遍上面的循环，把你的股票代码加进过滤器，再把提醒指向你的聊天。

#常见问题