获取任意账号粉丝的 Twitter 粉丝 API

#2026 年官方 X API 如何返回粉丝

官方 X API 通过 GET /2/users/{id}/followers 返回粉丝，每页最多 1,000 个，并按其按量付费价目表，把返回的每个粉丝都算作一次 $0.010 的读取：每 1,000 个 $10.00。想不写代码就看一个公开账号最新的 20 个粉丝，免费的 Twitter 最新粉丝追踪器可以在浏览器里显示。

简而言之，官方路线需要数字 ID、开发者账号和 OAuth，并对返回的每个粉丝收费；下面的细节来自 docs.x.com，查阅日期为 2026 年 11 月 2 日：

• 接口

  官方 X API

  /followers 和 /following，都在 GET /2/users/{id} 之下

• 指定哪个账号

  官方 X API

  只能用数字用户 ID，不能用用户名

• 访问条件

  官方 X API

  开发者账号、预付额度，以及带 follows.read 的 OAuth 2.0 用户令牌或应用 bearer 令牌

• 每页数量

  官方 X API

  最多 1,000（max_results）；下一页通过 pagination_token 获取

• 速率限制

  官方 X API

  每个应用和每个用户每 15 分钟 300 次请求

• 价格

  官方 X API

  每读取一个粉丝 $0.010；读取你自己的应用所有者的列表时为 $0.001

许多答案，包括 Google 的 AI 摘要，仍然说这个接口只面向 Enterprise 客户。那是 2023 年 6 月 26 日起的规则，当时 X 把关注查询从 Basic 和 Pro 层级中移除，现在已经过时：自 2026 年 2 月 6 日起向所有新开发者开放的按量付费，已经在公开价目表里列出了粉丝读取。

还有两条规则影响这项工作。同一个粉丝，无论你读取多少次，X 每个 UTC 日只计费一次；并且自 2026 年 4 月 20 日起，自助服务的应用不能再通过官方 X API 关注或取消关注账号。速率限制让一个应用每 15 分钟最多取 300 页、每页最多 1,000 个，也就是 30 万个粉丝；其他接口的情况见 X API 速率限制指南。

#用 Sorsa API 四步获取粉丝

想在代码里获取账号的粉丝，可以用 Sorsa API，一款 Twitter（X）API 与爬虫：GET /followers 每次请求最多返回 200 个粉丝资料，每 1,000 个 $0.007 起，接受用户名而不是数字 ID，只需一个 API 密钥，不需要开发者账号或 OAuth。所有套餐的每个密钥都是每秒 20 次请求。

1. 获取密钥。 注册后从控制台复制你的 API 密钥。前 100 次请求免费，无需绑卡。

2. 请求第一页。 把 username、user_id 或 user_link 发给 GET /followers（在新标签页打开），密钥放在 ApiKey 请求头里。

   curl -G "https://api.sorsa.io/v3/followers" \
     -H "ApiKey: YOUR_API_KEY" \
     --data-urlencode "username=lumen_kitchen_labs"
   

   {
     "users": [
       {
         "id": "1718233069912377344",
         "username": "quietpine_studio_co",
         "display_name": "Quiet Pine Studio",
         "description": "Ceramics and slow coffee. Ships from Asheville.",
         "location": "Asheville, NC",
         "created_at": "2023-10-28T11:04:52Z",
         "followers_count": 3120,
         "followings_count": 418,
         "tweets_count": 1876,
         "verified": false,
         "protected": false,
         "bio_urls": ["https://quietpine.example"]
       }
     ],
     "next_cursor": "1846521730994411520"
   }
   

   显示完整响应

3. 把 cursor 传回去。 把每个响应里的 next_cursor，作为下一次请求的 next_cursor 参数传回去。当它为空或缺失时，那一页就是最后一页。

4. 循环直到列表结束。 下面的函数会把任意列表接口读到末尾，每当密钥超过每秒 20 次请求时就等一秒。

   import time
   import requests
   
   API = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   
   def get_page(path, params):
       """One GET request; on 429 it waits a second and tries again."""
       while True:
           r = requests.get(API + path, headers=HEADERS, params=params,
                            timeout=30)
           if r.status_code == 429:  # more than 20 requests in one second
               time.sleep(1)
               continue
           r.raise_for_status()
           return r.json()
   
   
   def all_users(path, username):
       """Every account in a list endpoint, one page of 200 at a time."""
       params = {"username": username}
       while True:
           page = get_page(path, params)
           yield from page.get("users", [])
           cursor = page.get("next_cursor")
           if not cursor:
               return
           params["next_cursor"] = cursor
   
   
   followers = list(all_users("/followers", "lumen_kitchen_labs"))
   print(len(followers), "followers")
   

   // followers.mjs, Node.js 18 or later
   const API = "https://api.sorsa.io/v3";
   const headers = { ApiKey: "YOUR_API_KEY" };
   const pause = (ms) => new Promise((done) => setTimeout(done, ms));
   
   async function* allUsers(path, username) {
     const query = new URLSearchParams({ username });
     for (;;) {
       const res = await fetch(`${API}${path}?${query}`, { headers });
       if (res.status === 429) {
         await pause(1000); // more than 20 requests in one second
         continue;
       }
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const page = await res.json();
       yield* page.users ?? [];
       if (!page.next_cursor) return;
       query.set("next_cursor", page.next_cursor);
     }
   }
   
   const followers = [];
   for await (const user of allUsers("/followers", "lumen_kitchen_labs")) {
     followers.push(user);
   }
   console.log(followers.length, "followers");
   

403 表示密钥缺失或请求额度已用完；受保护的账号同样会返回错误，失败的请求从不收费。页面按从新到旧排列，所以第一页永远是最新的粉丝，下面的追踪一节就利用了这一点。

#获取用户关注的账号列表

要获取某个用户在 X 上关注的账号列表，用同样的用户名、ID 或个人主页链接调用 GET /follows（在新标签页打开）：Sorsa API 每次请求最多返回 200 个被关注的账号，从新到旧，使用同样的 cursor，所以第 4 步的循环只需改一个词。

following = list(all_users("/follows", "lumen_kitchen_labs"))
following.sort(key=lambda u: u["followers_count"], reverse=True)
for user in following[:10]:  # the biggest accounts it follows
    print(user["username"], user["followers_count"])

关注列表通常比粉丝列表短得多，所以整份读下来很便宜：一个关注了 1,500 个账号的用户只需 8 次请求。它能显示这个账号在读谁，从供应商和对手，到它关注的创作者和新闻来源。把它与粉丝列表放在一起读，还能看出谁互相关注：同时出现在两份列表里的 ID。想不写代码快速看一眼，上面的最新粉丝追踪器也会列出它最近关注的 20 个账号。

想把任一列表保存为 CSV 或 Excel 文件，导出 Twitter 粉丝指南介绍了能干净打开的文件。

#哪个接口回答哪个粉丝问题

Sorsa API 用各自的接口回答每个常见的粉丝问题，并且全部按请求计费，从不按返回的资料数量计费。

• 谁关注了这个账号？

  接口

  GET /followers

  每次请求

  最多 200 个粉丝

• 它关注了谁？

  接口

  GET /follows

  每次请求

  最多 200 个账号

• 它的粉丝里哪些是认证账号？

  接口

  GET /verified-followers（在新标签页打开）

  每次请求

  一页，同样的 cursor

• 账号 B 是否关注了账号 A？

  接口

  POST /check-follow（在新标签页打开）

  每次请求

  一个答案：follow 为 true 或 false

• 它有多少粉丝？

  接口

  GET /info（在新标签页打开）

  每次请求

  一份带 followers_count 的资料

• 多个账号的粉丝数

  接口

  GET /info-batch（在新标签页打开）

  每次请求

  最多 100 份资料

• 谁在某个 X 列表里，或关注了它？

  接口

  GET /list-members（在新标签页打开）、GET /list-followers（在新标签页打开）

  每次请求

  一页，同样的 cursor

只看认证粉丝

GET /verified-followers 接收与 GET /followers 相同的输入和 cursor，只返回带认证标识的账号。在大账号上，这样可以跳过大部分页面，因为认证账号在多数受众中只占少数：你不用去读那些反正也要过滤掉的行。

检查一个关注关系

POST /check-follow 用一次请求回答一个账号是否关注了另一个，每次检查 $0.0014 起，无论哪份列表有多长。username_1 是应被关注的账号，username_2 是你要检查的账号；任一方都可以用 user_id_* 或 user_link_*。

curl -X POST "https://api.sorsa.io/v3/check-follow" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username_1": "lumen_kitchen_labs",
       "username_2": "quietpine_studio_co"}'

答案只覆盖一个方向，所以互关需要把双方对调再调用两次。面向抽奖和活动的检查，除了关注还有转发、引用和回复，见 Twitter 核验 API指南。X 列表的成员和关注者有单独的指南：Twitter 列表 API。

#每条粉丝记录包含什么

每个粉丝都以完整的公开资料送达，共 19 个字段，与 Sorsa API 每个资料接口返回的对象相同，所以过滤和打分都不需要第二次请求。

这些字段分为六组，多数受众分析会用到前四组：

• 身份

  字段

  id、username、display_name、created_at

• 影响力

  字段

  followers_count、followings_count

• 活跃度

  字段

  tweets_count、media_count、favourites_count、pinned_tweet_ids

• 话题与地点

  字段

  description、bio_urls、location

• 标记

  字段

  verified、protected、can_dm、possibly_sensitive

• 图片

  字段

  profile_image_url、profile_background_image_url

三条规则让数据保持可靠：

• 一切以 ID 为准。 id 中的账号 ID 永远不变，并且以字符串形式返回；用户名则可以由主人随时更改。如果你只需要粉丝 ID，就保留每条记录的 id：它们随完整资料一起返回，不额外收费。在 JavaScript 里也要把 ID 保存为字符串：X 的 ID 长达 19 位，而 JavaScript 的数字只在 16 位以内保持精确。
• 预计列表与总数会相差几个百分点。 followers_count 是 X 的实时总数，而列表不包含已被封禁或停用的账号。
• 资料按今天的状态读取。 每条记录显示的是粉丝当前的简介和数据，不是他们关注当天的状态。

须知

GET /followers 不带关注日期，因为 X 的公开粉丝列表不显示关注发生的时间。要给新粉丝标注日期，就按计划定期检查，并记录每个 ID 首次出现的日期；下一节会演示怎么做。

#追踪新粉丝和取关者

要用 API 追踪新粉丝，保留你上次看到的粉丝 ID 并做对比：由于页面按从新到旧排列，一次检查只读到遇见已知 ID 为止，所以只要自上次以来新增的粉丝少于 200 个，就只需一次请求。

取关者需要整份列表：上周完整读取中有、今天却没有的 ID，就是已经离开的。每天或每小时跑一次低成本的检查，每周或每月做一次完整读取。两个函数都复用第 4 步的 get_page 和 all_users。

def new_followers(username, known):
    """Followers added since the last check. Pages come newest first,
    so the loop stops at the first page that holds a known ID."""
    params, found = {"username": username}, []
    while True:
        page = get_page("/followers", params)
        users = page.get("users", [])
        fresh = [u for u in users if u["id"] not in known]
        found += fresh
        cursor = page.get("next_cursor")
        if len(fresh) < len(users) or not cursor:
            return found
        params["next_cursor"] = cursor


def unfollowed(username, last_full_read):
    """IDs from the last full read that no longer follow."""
    now = {u["id"] for u in all_users("/followers", username)}
    return last_full_read - now, now

把一个 ID 算作取关之前，先用 GET /info-batch 查一下它：被封禁或删除的账号也会从所有粉丝列表中消失。这些检查按你的计划运行，成本依然很小：25 个各有 5 万粉丝的账号，每天检查、每月完整读取一次，每月约需 7,000 次请求。

#过滤粉丝并找出受众重合

每条粉丝记录已经带有它的数据、简介和标记，所以过滤列表只需几行代码，不需要额外请求。它的 location 是用户自己填的；想要 X 自己判定的国家，Twitter 地理位置 API指南介绍了如何用 GET /about 按国家绘制受众分布。

followers = list(all_users("/followers", "lumen_kitchen_labs"))
shortlist = [
    u for u in followers
    if u["followers_count"] >= 1000          # some reach
    and u["tweets_count"] >= 100             # posts regularly
    and not u["protected"]
    and "coffee" in (u.get("description") or "").lower()
]

同时关注了你两个以上对手的账号，是你所在市场里互动最积极的人。把每个对手的列表读一遍，统计每个 ID 出现的次数：

from collections import Counter

rivals = ["lumen_kitchen_labs", "copperleaf_cookware", "saltmarsh_pantry"]
lists = {h: {u["id"] for u in all_users("/followers", h)} for h in rivals}
seen = Counter(i for ids in lists.values() for i in ids)
core = {i for i, n in seen.items() if n >= 2}
smallest = min(len(ids) for ids in lists.values())
print(f"{len(core)} accounts follow 2+ rivals, "
      f"{len(core) / smallest:.1%} of the smallest audience")

重合度要对照最小的受众来衡量，而不是总数：2,000 个共同粉丝对一个 5,000 粉丝的账号意义重大，对一个 200 万粉丝的账号则微不足道。想不写代码比较两个账号，免费的 Twitter 受众重合检查工具可以在浏览器里完成，而如何把这些核心账号变成潜在客户，则是如何在 Twitter 上寻找潜在客户的主题。

#用 API 寻找并筛查 Twitter 影响者

要用 API 寻找并筛查 Twitter 影响者，先按简介关键词和话题搜索创作者，分批补全他们的资料，再按近期互动和受众质量给每个人打分。Sorsa API 基于公开指标覆盖每一步，全程只读：点赞、回复、转发、引用和浏览量。

按领域发现创作者

• 按简介和名字： POST /search-users（在新标签页打开） 按关键词查找账号，简介也在范围内，每页约 20 个；可按粉丝档位、认证状态、所在地和发帖数过滤。
• 按他们带动的话题： POST /search-tweets（在新标签页打开） 支持 X 的搜索运算符，某个话题下热门帖子的作者就是它的活跃声音。
• 从精选列表入手： GET /list-members 读取别人已经为某个领域建好的 X 列表，GET /info-batch 则每次补全 100 份候选资料。

用真实互动来筛查

互动率是近期帖子上的互动（点赞、回复、转发和引用）按每条帖子计，再除以粉丝数或浏览量。POST /user-tweets（在新标签页打开） 每次请求返回约 20 条近期帖子及全部计数，POST /tweet-info-bulk（在新标签页打开） 则一次读取最多 100 条指定帖子。这里没有黑箱评分：输入是 X 的公开计数，公式由你自己调整。

def engagement_rate(username):
    """Interactions per post, per follower and per view."""
    # the latest page of posts; API and HEADERS come from step 4
    r = requests.post(API + "/user-tweets", headers=HEADERS,
                      json={"username": username}, timeout=30)
    r.raise_for_status()
    posts = r.json().get("tweets", [])
    if not posts:
        return None
    acts = sum(p["likes_count"] + p["reply_count"] + p["retweet_count"]
               + p["quote_count"] for p in posts)
    views = sum(p.get("view_count") or 0 for p in posts)
    followers = max(posts[0]["user"]["followers_count"], 1)
    return {"by_followers": acts / len(posts) / followers,
            "by_views": acts / views if views else None}

想不写代码快速检查一个账号，免费的 Twitter 互动率计算器用的就是同样的算术。

识别虚假粉丝和买来的互动

读取创作者最新粉丝的一两页，查找那些很少同时偶然出现的信号：

• 互动远低于粉丝数所暗示的水平；
• 粉丝样本里满是上个月刚注册、简介为空、使用默认头像或没有发帖的账号；
• 关注成千上万、却几乎没人关注的失衡账号；
• 近期帖子浏览量很高，点赞和回复却几乎没有。

完整的方法，包括十个信号和一个给整份粉丝列表打分的脚本，见 Twitter 机器人检测指南。

合作之后检查活动效果

POST /user-tweets 跟踪创作者的帖子，POST /mentions（在新标签页打开） 用 min_likes 和 since_date 到 until_date 的范围查找提到你品牌的帖子，POST /check-quoted（在新标签页打开） 和 GET /check-comment（在新标签页打开） 确认约定的引用或回复已经发布，每次检查 $0.0014 起。

对 500 位创作者的整个流程约需 540 次请求：25 页搜索、5 次批量调用、500 次时间线拉取和 10 页粉丝。按 Sorsa API 的最低费率约为 $0.76，只占其最小套餐 1 万次请求的一小部分；同样的读取按官方 X API 费率约为 $75。

#每 1,000 个粉丝的数据要花多少钱

Sorsa API 读取粉丝每 1,000 个 $0.007 起，而官方 X API 是每 1,000 个 $10.00：同一份公开列表，便宜 1,000 倍。

按这些费率，10 万个粉丝 $0.70 起，对比 $1,000；100 万个 $7 起，对比 $10,000。即便是 X 对你自己应用的粉丝所收的 $0.001，折合也是每 1,000 个 $1.00。Sorsa API 按请求计费，不按资料计费：一页 200 个粉丝就是一次请求，失败的请求不收费，用 GET /key-usage-info（在新标签页打开） 查余额也是免费的。官方的每项价格都在 X API 定价指南里拆解过。

周期性的任务，成本就是它们一个月内读取量的总和。下面的规划器会把你关注的账号数和检查频率，换算成两个 API 上的请求数和费用。

#今天就获取你的前 2 万个粉丝

要在代码里获取粉丝、关注列表并做关注检查，可以用 Sorsa API：每次请求 200 个粉丝，每 1,000 个 $0.007 起，一个 API 密钥，无需开发者账号。你的 100 次免费请求可以读取前 2 万个粉丝；对任意一个公开账号运行第 4 步的循环，看整份列表被取回来。

#常见问题