Python 版 Twitter API：2026 年获取 X 数据完整指南

作者：Sorsa 编辑部

更新于 2026 年 7 月：重新核实了 X 的按量付费定价，把 Sorsa 成本数字改用每千条目的批量费率来阐述，并新增了 100 次免费请求的起步优惠。

核心要点： 2026 年用 Python 获取 Twitter/X 数据有四条实用路线：X 的官方 SDK（pip install xdk）、Tweepy、带 bearer 令牌的朴素 requests，或一个第三方 REST API。官方路线按资源计费、需要 OAuth；一个只读的第三方 API 只需要一个 API 密钥、适合读密集型工作。

如果你搜"twitter api python"、指望一次快速的 pip install 加一段可用代码，当前的格局比旧教程说的更乱。X（前身为 Twitter）API 换了定价模型、换了认证，如今还推出了一个一年前不存在的官方 Python SDK。

我们开发并运营 Sorsa API 这个替代 Twitter/X API，所以只读路径是我们最了解的那条：这条路径把资料、推文、搜索和粉丝以干净的 JSON 从朴素 requests 返回，用请求头里的 API 密钥、没有 OAuth 流程、也没有要等的开发者账号审批。在读密集型工作上，Sorsa 比官方 X API 便宜最高 50 倍：批量接口把成本降到每 1,000 条推文从 $0.02、每 1,000 份资料从 $0.01 起，每个套餐保持固定每秒 20 次请求，每个新账号注册即送 100 次免费请求、无需绑卡。不是每个项目都合这个模子：有的需要发帖，有的因合规需要官方 API，有的开发者只想理解一切如何运作。本指南用可用的 Python 代码、一个并排对比、当前定价，以及一个会分页并把结果直接载入 pandas 的完整数据采集器，覆盖全部四种方法。你也可以在 Sorsa API playground 里不写代码就测试调用。

目录

• 变了什么：2026 年的 X API
• X API v2 最好的 Python 库（快速答案）
• 你该用哪种方式？
• 方法 1：官方 X Python SDK（XDK）
• 方法 2：Tweepy
• 方法 3：带 bearer 令牌的朴素 Python requests
• 方法 4：用 Python requests 调第三方 API
• 构建一个生产数据采集器：分页、重试和 pandas
• 对比：四种方法并排
• 如何拿到你的 API 凭据
• 常见任务：代码示例
• 实战：把只读拉取从官方 API 迁走
• 常见问题
• 如何开始

变了什么：2026 年的 X API

如果你上次碰 Twitter API 是 2023 年或更早，这里是有什么不同。

按量付费是默认。 2026 年初 X 用一个消费模型取代了它旧的订阅层级。对新注册没有 $100 的 Basic 或 $5,000 的 Pro 套餐，也没有免费额度。你预先买额度、按你读取的资源付费：每条帖子 $0.005、每份用户资料 $0.010、每条粉丝或关注记录 $0.010（数字于 2026 年 7 月核实）。读取你自己账号的数据（你的时间线、你的书签、你的粉丝）更便宜，为每资源 $0.001，但那个折扣费率在你读取别的账号时不适用。

2026 年 4 月更新后写入变贵了。 一条标准帖子现在每请求 $0.015，而一条含 URL 的帖子跳到 $0.20。关注、点赞和引用发帖动作从自助层级里彻底撤出，现在需要一份 Enterprise 合同。如果你在计划一个回关机器人或一个自动点赞器，那在标准的按量付费账号上已不再可能。

有一个硬性读取上限。 标准账号被限在每月 200 万次帖子读取。X 还把你支出的一部分作为 xAI (Grok) API 额度返还，在更高量下最多 20%。关于这对真实预算意味着什么的完整拆解，见我们的 X API 定价分析和 Twitter API 为何如此昂贵的解释文章。

X 发布了一个官方 Python SDK。 XDK（X Developer Kit）是一个自动生成、带类型提示、自动分页和流式支持的 SDK。用 pip install xdk 安装。它是 X 有史以来推出的第一个官方 Python 库。

Tweepy 仍然可用。 Tweepy 支持 X API v2，仍是最成熟的社区库。现有的 Tweepy 代码用当前凭据跑得好好的。

旧库已死。 bear 的原始 python-twitter 包已归档，PyPI 上的 twitter 包也多年没更新。如果一篇教程叫你 pip install python-twitter，那篇教程已过时。（sns-sdks 发布的一个单独的、活跃维护的 v2 封装在下一节介绍。）

X API v2 最好的 Python 库（快速答案）

如果你只想要简版：Tweepy 是 X API v2 最好的通用 Python 库，因为它成熟、文档完善，并通过 bearer 令牌和 OAuth 流程支持读和写。如果你想要一个精确追踪 API 规格的第一方工具，用官方 XDK。对于只读数据采集，许多开发者彻底跳过库、用朴素 requests 调用一个第三方 REST API（见方法 4）。

以下是主要选项的对比。

上面每个面向官方 API 的库都通过 X 的按量付费定价计费。无论你用 XDK、Tweepy 还是裸 requests 调用 X，成本都相同，因为收费在 X 那一侧是按资源、而非按库。你实际能掌控的变量是你拉多少资源，这正是第三方 API 和批量接口改变成本账之处（下面介绍）。

你该用哪种方式？

写代码之前先挑路径。这能省下好几个小时。

如果你的项目只读取公开数据（资料、推文、搜索结果、粉丝），第三方 API 移除了 OAuth 那套繁琐。请求头里一个 API 密钥，你就开始拉数据，没有开发者账号申请、也没有额度购买。如果你需要发帖或执行写操作，通过 XDK、Tweepy 或裸 requests 用官方 X API。Sorsa 只读、不代你发帖。

方法 1：官方 X Python SDK（XDK）

XDK 是 X 的第一个官方 Python SDK。XDK 用有类型的模型封装整个 v2 API 面、自动处理分页，并支持全部三种认证方法（bearer 令牌、OAuth 2.0 PKCE、OAuth 1.0a）。

安装：

pip install xdk

搜索近期推文

import os
from xdk import Client

client = Client(bearer_token=os.environ["BEARER_TOKEN"])

response = client.posts.recent_search(query="python lang:en")

for post in response.data:
    print(f"@{post.author_id}: {post.text[:120]}")

这返回最近 7 天匹配你查询的帖子。response 对象包含分页令牌，所以你可以翻页而不必手动追踪游标。

查询一份用户资料

user = client.users.find_by_username(username="elonmusk")
print(f"@{user.data.username} - {user.data.public_metrics}")

发一条推文（需要 OAuth 2.0）

写操作需要用户上下文认证。把你的 Client ID 和 Client Secret 设为环境变量，然后：

client = Client(
    client_id=os.environ["CLIENT_ID"],
    client_secret=os.environ["CLIENT_SECRET"],
)

client.posts.create(post_data={"text": "Hello from the XDK!"})

XDK 在内部处理 OAuth 2.0 PKCE 流程，包括令牌刷新。

何时用 XDK

如果你想要官方支持、需要写权限、且在开始一个新项目，XDK 是对的选择。有类型的模型让 IDE 自动补全工作良好，而自动分页省下样板代码。缺点：这个 SDK 年轻（2026 年初上线，GitHub 关注者不多但在增长）、文档仍单薄，而且你为每次请求付 X 的按量付费定价，所以一次帖子读取花 $0.005、一次用户查询花 $0.010，这些收费在规模上累加。完整 SDK 文档在 docs.x.com/xdks/python/overview。

方法 2：Tweepy

Tweepy 自 2009 年就存在，仍是 Twitter API 最流行的 Python 库。它支持 X API v2、处理限速，并有大量社区文档。

安装：

pip install tweepy

搜索近期推文

import os
import tweepy

client = tweepy.Client(bearer_token=os.environ["BEARER_TOKEN"])

response = client.search_recent_tweets(
    query="python lang:en",
    max_results=10,
    tweet_fields=["created_at", "public_metrics"],
)

for tweet in response.data:
    metrics = tweet.public_metrics
    print(tweet.text[:120])
    print(f"  Likes: {metrics['like_count']}  Retweets: {metrics['retweet_count']}")

获取一个用户的粉丝

user = client.get_user(username="elonmusk")
followers = client.get_users_followers(
    id=user.data.id,
    max_results=100,
    user_fields=["description", "public_metrics"],
)

for follower in followers.data:
    print(f"@{follower.username} - {follower.public_metrics['followers_count']} followers")

发一条推文

client = tweepy.Client(
    consumer_key=os.environ["API_KEY"],
    consumer_secret=os.environ["API_SECRET"],
    access_token=os.environ["ACCESS_TOKEN"],
    access_token_secret=os.environ["ACCESS_TOKEN_SECRET"],
)

client.create_tweet(text="Hello from Tweepy!")

何时用 Tweepy

Tweepy 是多数 Python 开发者的稳妥默认。它久经实战、社区庞大，几乎任何问题都有一个 Stack Overflow 答案。Tweepy 把限速处理、重试和分页封装进一个干净的接口。取舍与 XDK 相同：你仍需要一个 X 开发者账号、你仍按资源付费，而速率限制继承自官方 API（搜索通常每 15 分钟窗口 300 次请求，尽管这因接口而异）。如果你已经有 Tweepy 代码在跑，除非你需要 Tweepy 缺的某个功能，否则没有理由迁到 XDK。完整文档：docs.tweepy.org。

方法 3：带 bearer 令牌的朴素 Python requests

没有库、没有封装，就是 HTTP 请求。这个方式适合想要完全掌控发送和接收内容的开发者，或在安装第三方包受限的环境里工作的人。

搜索近期推文

import os
import requests

search_url = "https://api.x.com/2/tweets/search/recent"
headers = {"Authorization": f"Bearer {os.environ['BEARER_TOKEN']}"}
params = {
    "query": "python lang:en",
    "max_results": 10,
    "tweet.fields": "created_at,public_metrics,author_id",
}

response = requests.get(search_url, headers=headers, params=params)
data = response.json()

for tweet in data["data"]:
    print(tweet["text"][:120])
    print(f"  Likes: {tweet['public_metrics']['like_count']}")

获取一份用户资料

user_url = "https://api.x.com/2/users/by/username/elonmusk"
headers = {"Authorization": f"Bearer {os.environ['BEARER_TOKEN']}"}
params = {"user.fields": "description,public_metrics,created_at"}

response = requests.get(user_url, headers=headers, params=params)
user = response.json()["data"]

print(f"@{user['username']} - {user['public_metrics']['followers_count']} followers")

手动处理分页

search_url = "https://api.x.com/2/tweets/search/recent"
next_token = None
all_tweets = []

while True:
    params = {
        "query": "python lang:en",
        "max_results": 100,
        "tweet.fields": "created_at,public_metrics",
    }
    if next_token:
        params["next_token"] = next_token

    response = requests.get(search_url, headers=headers, params=params)
    data = response.json()
    all_tweets.extend(data.get("data", []))

    next_token = data.get("meta", {}).get("next_token")
    if not next_token:
        break

print(f"Collected {len(all_tweets)} tweets")

何时用裸 requests

当你想要除 requests 外零依赖、当你在调试 API 行为、或当你只调用一两个接口、而完整 SDK 是杀鸡用牛刀时，这管用。缺点很明显：分页、错误码、限速和重试逻辑你自己处理。对一次性脚本没问题。对一条生产环境的数据管道，你最终会写自己的封装，那时你就重新发明了 Tweepy。这个方法仍然需要一个 X 开发者账号和按量付费额度，请求头用一个 bearer 令牌做只读访问。

方法 4：用 Python requests 调第三方 API

如果你的项目只需要读取公开 Twitter 数据，就彻底跳过官方 API、调用第三方数据服务商。这是通往不用开发者账号获取 Twitter 数据的实用路线：没有 OAuth、没有申请步骤、没有额度购买流程，就是请求头里一个 API 密钥、标准 REST 调用、JSON 响应，以及在付费之前先测试的 100 次免费请求。以下是用 Sorsa 的 API 的样子。

获取一份用户资料

import requests

headers = {"ApiKey": "YOUR_SORSA_API_KEY"}

response = requests.get(
    "https://api.sorsa.io/v3/info",
    headers=headers,
    params={"username": "elonmusk"},
)

user = response.json()
print(f"@{user['username']}: {user['display_name']}")
print(f"Followers: {user['followers_count']}")
print(f"Tweets: {user['tweets_count']}")

响应一次请求就包含完整资料：ID、用户名、显示名、简介、位置、粉丝和关注数、推文和媒体数。还有认证状态、头像、账号创建日期、置顶推文和简介中的 URL。

搜索推文

response = requests.post(
    "https://api.sorsa.io/v3/search-tweets",
    headers=headers,
    json={"query": "python programming", "order": "popular"},
)

for tweet in response.json()["tweets"]:
    print(f"@{tweet['user']['username']}: {tweet['full_text'][:120]}")
    print(f"  Likes: {tweet['likes_count']}  Views: {tweet['view_count']}")

每次搜索请求返回最多 20 条推文，每条推文在 user 字段里都包含完整作者资料。要拿到发推者的粉丝数或认证状态，没有额外请求（也没有额外收费），不像官方 API，那里展开用户数据每个用户加 $0.010。搜索接口支持你会在 X 搜索里敲的那些高级操作符（from:、to:、since:、until:、带引号短语、话题标签）。完整列表在我们的 Twitter 搜索操作符速查表里。

获取粉丝

response = requests.get(
    "https://api.sorsa.io/v3/followers",
    headers=headers,
    params={"username": "elonmusk"},
)

for follower in response.json()["users"][:5]:
    print(f"@{follower['username']} - {follower['followers_count']} followers")

/followers 接口每次请求返回最多 200 份完整资料，通过 next_cursor 参数分页。

批量获取多条推文

response = requests.post(
    "https://api.sorsa.io/v3/tweet-info-bulk",
    headers=headers,
    json={
        "tweet_links": [
            "https://x.com/elonmusk/status/1234567890",
            "https://x.com/OpenAI/status/9876543210",
            "1122334455667788",
        ]
    },
)

for tweet in response.json()["tweets"]:
    print(f"@{tweet['user']['username']}: {tweet['full_text'][:100]}")

/tweet-info-bulk 接口在单次请求里接收最多 100 个推文 URL 或 ID，并返回带作者数据的完整推文对象。一次调用，100 条推文。

为什么这个方式适合只读项目

方法 1 到 3 需要一个 X 开发者账号（带申请步骤）、购买的额度、OAuth 令牌和按资源计费。方法 4 只需要请求头里的一个 API 密钥。Sorsa 采用按请求计费：无论一次调用返回多少条推文或资料，都从你的额度里算一次请求，所以一次返回 20 条推文的搜索和一次单 ID 查询花费相同。在 Sorsa Pro 套餐（$199/月含 10 万次请求）上，那折算为每次请求 $0.00199。经批量接口路由，那是通过 /tweet-info-bulk 每 1,000 条推文从 $0.02 起、通过 /followers 每 1,000 份资料从 $0.01 起，速率限制是每个套餐每秒 20 次请求、没有 15 分钟窗口。

取舍是没有写入访问：你无法通过只读的第三方 API 发帖、点赞或关注。如果你需要那些，写入用方法 1 或 2、读密集型工作用第三方 API。那种混合正是我们为一个跑情感分析管道的金融科技客户搭的：他们此前在一个遗留 Pro 套餐上每月付 $5,000，我们把所有读取（提及追踪、竞品监测、粉丝分析）迁到第三方服务商、并为发布告警保留一个极简的官方设置，他们的总花费降到每月不到 $250。如果你从官方 API 过来，我们的 X API 迁移指南映射了接口和字段名。

构建一个生产数据采集器：分页、重试和 pandas

上面的单次调用示例足以测试你的密钥，但真实的数据工作还需要三样东西。一是分页、以越过前 20 条结果，二是错误处理、好让一个坏响应不会弄死一次长运行，三是把 JSON 变成你能分析的东西的方式。以下是一个完整、可运行的采集器，对着 Sorsa 做完这三件事，然后把结果载入一个 pandas DataFrame 并存成 CSV。

import os
import time
import requests
import pandas as pd

API_KEY = os.environ["SORSA_API_KEY"]   # 从环境读取密钥，绝不硬编码
BASE = "https://api.sorsa.io/v3"
HEADERS = {"ApiKey": API_KEY}


def post_with_retry(path, payload, retries=3):
    """向 Sorsa 发 POST，对瞬时错误和 429 响应做指数退避。"""
    for attempt in range(retries):
        try:
            response = requests.post(f"{BASE}{path}", headers=HEADERS, json=payload, timeout=30)
            response.raise_for_status()
            return response.json()
        except requests.HTTPError as error:
            status = error.response.status_code
            if status == 429 and attempt < retries - 1:   # 限速：等待并重试
                time.sleep(2 ** attempt)
                continue
            raise   # 401（错误密钥）、400（错误参数）和最后一次 429 在此抛出
        except requests.RequestException:
            if attempt == retries - 1:
                raise
            time.sleep(2 ** attempt)


def collect_tweets(query, order="latest", max_pages=5):
    """为一个查询采集推文，跟随 next_cursor 分页直到 max_pages。"""
    cursor, rows = None, []
    for page in range(max_pages):
        payload = {"query": query, "order": order}
        if cursor:
            payload["next_cursor"] = cursor
        data = post_with_retry("/search-tweets", payload)
        batch = data.get("tweets", [])
        rows.extend(batch)
        print(f"page {page + 1}: +{len(batch)} tweets (total {len(rows)})")
        cursor = data.get("next_cursor")
        if not cursor:        # 没有游标意味着没有更多页
            break
    return rows


if __name__ == "__main__":
    tweets = collect_tweets('"machine learning" lang:en', max_pages=3)
    df = pd.json_normalize(tweets)
    df.to_csv("tweets.csv", index=False)
    print(f"Saved {len(df)} rows to tweets.csv")

有几点值得点出：

• 分页用 next_cursor。 每个 /search-tweets 响应返回最多 20 条推文外加一个 next_cursor。把那个游标放进下一个请求的 body 里、重复直到游标为空。max_pages 守卫阻止一个宽泛查询失控、烧穿你的额度。Sorsa 文档详细覆盖了游标流程。
• 重试和退避。 raise_for_status() 把失败响应变成异常。一个 429（你超出了每秒 20 次请求的限制）触发一次短暂的指数退避和一次重试。一个 401 意味着错误密钥、立即抛出，好让你注意到它、而非静默地什么也采集不到。
• 密钥活在一个环境变量里。 用 export SORSA_API_KEY='your_key' 设一次、用 os.environ 读它。绝不要把密钥提交到源码管理。

把数据载入 pandas

pandas.json_normalize 一行就把嵌套的推文对象（包括 user.* 下内嵌的作者）扁平化成一个平表：

df = pd.json_normalize(tweets)

# 保留多数分析需要的列
columns = [
    "id", "full_text", "created_at", "lang",
    "likes_count", "retweet_count", "reply_count", "view_count",
    "user.username", "user.followers_count", "user.verified",
]
df = df[columns]

# 示例：每条推文的互动率
df["engagement_rate"] = (
    df["likes_count"] + df["retweet_count"] + df["reply_count"]
) / df["view_count"].clip(lower=1)

df.to_csv("tweets.csv", index=False)      # 便携，可在 Excel 或 Sheets 打开
df.to_parquet("tweets.parquet")           # 紧凑，重复分析时重新加载快

从这里你可以按作者分组、计算互动率、跑情感分类（见我们的 Twitter 情感分析指南），或为一个模型构建训练数据集。因为每条推文已经包含完整作者资料，你不需要为每个作者第二次调用去拿粉丝数或认证状态。这正是这个模式在规模上保持便宜的主要原因。

对比：四种方法并排

如何拿到你的 API 凭据

X 开发者账号（方法 1 到 3）

1. 前往 developer.x.com、用你的 X 账号登录、并在其中创建一个 Project 和一个 App。
2. 对于只读访问，复制你的 Bearer Token。这单个令牌足以做搜索、用户查询和时间线。
3. 对于发帖和其他写操作，打开 User Authentication Settings 并把权限设为 Read and Write，然后生成四个 OAuth 1.0a 凭据：API Key（Consumer Key）、API Key Secret（Consumer Secret）、Access Token 和 Access Token Secret。四个全都需要才能发帖。
4. 在开发者控制台购买额度。按量付费没有最低消费，但你的余额必须大于零，任何已认证调用才会成功。

把凭据存进环境变量、绝不放在代码里：

export BEARER_TOKEN='AAAAAAAAAAAAAAAAAAAAAxxxxxxx'
export API_KEY='your_api_key'
export API_SECRET='your_api_secret'
export ACCESS_TOKEN='your_access_token'
export ACCESS_TOKEN_SECRET='your_access_token_secret'

关于门户逐屏截图的详解，包括在哪里找 bearer 令牌、以及如何把权限切换到 Read and Write，见我们关于如何获取 Twitter/X API 密钥的指南。关于每个凭据每次请求的花费，见上面的“变了什么”一节。

Sorsa API 密钥（方法 4）

1. 在 api.sorsa.io/overview 创建一个账号。
2. 你的 API 密钥在仪表盘的密钥页面上立即生成。
3. 开始发请求。每个新账号包含 100 次免费请求：一次性、无需绑卡、永不过期、覆盖全部 40 个接口。没有申请流程、开始时无需购买额度。

Sorsa 文档里的快速上手不到一分钟就带你走一遍第一次调用，包括 ApiKey 请求头格式。

常见任务：代码示例

如何按关键词搜索推文

四种方法都支持关键词搜索。方法 1 到 3 用 X API v2 的近期搜索接口（最近 7 天，或在遗留 Pro 上用完整存档）。方法 4 搜索完整的公开存档。要构建复杂查询，组合操作符："machine learning" from:OpenAI since:2026-01-01 -is:retweet 返回 @OpenAI 自 2026 年 1 月以来提及该短语的原创帖子。要一个可视化构建器，用 Sorsa playground 里的搜索构建器；完整的操作符参考在上面链接的搜索操作符速查表里。

如何获取历史推文

官方 API 上的近期搜索接口只覆盖最近 7 天，除非你有遗留的全量存档访问。第三方 API 直接搜索完整存档，而日期操作符（since:、until:）让你向后翻较旧的帖子。关于大规模历史拉取及其中的取舍，见我们关于历史 Twitter 数据的指南。

如何获取一个用户的粉丝

在官方 API 上，粉丝列表每页 100 个用户分页，每份资料都是可计费的 $0.010 资源，所以 1,000 个粉丝在用户读取上约花 $10。通过 Sorsa，/followers 每次请求返回最多 200 份资料，所以 1,000 个粉丝是 5 次请求、在 Pro 套餐上约 $0.01。更多细节在我们的 Twitter 粉丝 API 指南里。

如何按 ID 获取推文数据

当你有一份推文 ID 列表时，批量查询是高效的路径。在官方 API 上，GET /2/tweets?ids=... 接收最多 100 个 ID、按每条返回的推文 $0.005 计费。用 Sorsa，POST /tweet-info-bulk 接收最多 100 个 URL 或 ID、算作一次请求，返回带作者数据的完整推文对象。

实战：把只读拉取从官方 API 迁走

我们常见的一个模式：一个团队在官方 X API 上用 Tweepy 起步，因为旧教程就是这么教的，然后在只读取数据的项目上撞上摩擦。一个分析团队找到我们时，已经建了一个每日采集器、为几千个被追踪账号拉取资料和近期推文。代码能用，但每次运行都烧掉可计费的帖子和用户读取，开发者账号审批和 OAuth 刷新逻辑增加了设置时间。每月 200 万次读取的上限还意味着他们随着账号列表增长而得密切盯着量。

修法不是重写，只是在传输层做一次替换。采集逻辑、pandas 归一化和调度全都保持不变。他们把 Tweepy 客户端换成方法 4 里的朴素 requests 模式、把它指向搜索和 /followers 接口，并彻底丢掉了 OAuth 流程（一个 ApiKey 请求头取代令牌管理）。因为每次请求返回最多 20 条推文或 200 份粉丝资料、而非按资源计费，同样的每日拉取花了此前的一个零头。每秒限制取代了每月上限、成为唯一需要把控节奏的东西。对只读负载，官方 API 此前一直是把简单事做贵的方式。

常见问题

2026 年有面向 Python 的免费 Twitter API 吗？

不来自 X。官方 X API 在按量付费下没有免费访问：你必须在做任何请求之前购买额度，而新账号得不到免费额度。Sorsa 给每个新账号 100 次免费请求：一次性、无需绑卡、永不过期、覆盖全部 40 个接口，通过批量接口足够覆盖多达 1 万条推文或 2 万份资料。完整拆解见我们对 2026 年 Twitter API 是否免费的分析。

在 Python 里获取 Twitter 数据最简单的方式是什么？

用 requests 库调用第三方 REST API：拿一个 API 密钥、在请求头里传它、把你的查询 POST 到一个搜索接口。JSON 直接映射到 Python 字典、再进 pandas。这比“官方 API 加 Tweepy”更简单，因为没有 OAuth 流程、也没有要等的开发者账号审批。

在 Python 里如何把推文载入一个 pandas DataFrame？

把推文对象收集进一个列表，然后调用 pandas.json_normalize(tweets)，一行就把嵌套字段（包括内嵌的作者）扁平化成一个 DataFrame。用 df.to_csv("tweets.csv", index=False) 存成一个便携文件，或用 df.to_parquet(...) 存成一个能快速重新加载的紧凑列式文件。从那里你可以用普通的 pandas 过滤、分组和计算互动指标。

在 Python 里如何翻页遍历推文？

每个响应都包含一个 next_cursor（官方 API 上是 next_token）。把它放进下一个请求、重复直到游标为空。始终用一个 max_pages 守卫给循环设上限，好让一个宽泛查询不会失控、消耗你的额度。上面的采集器脚本展示了这个模式。

能在 Python 里不用 API 密钥获取 Twitter 数据吗？

技术上能，通过用 Twikit 或 Playwright 这样的库做网页抓取，但爬虫每 2 到 4 周就在 X 轮换内部令牌和 GraphQL 标识符时失效，而且你有账号封禁风险。要可靠访问，一个 API 密钥（来自 X 或一个第三方服务商）是实用路径。技术做法见我们的抓取 X 指南，托管选项见我们的 Twitter 爬虫对比。

Twitter API 访问对 Python 开发者要花多少钱？

在官方 X API 上：每条帖子读取 $0.005、每份用户资料读取 $0.010、每条创建的标准帖子 $0.015、含 URL 的帖子 $0.20。一次返回 20 条推文的搜索花 $0.10，而获取 1,000 份粉丝资料约花 $10。有一个每月 200 万次帖子读取的上限。在 Sorsa 上，按请求计费折算为批量接口上每 1,000 条推文从 $0.02、每 1,000 份资料从 $0.01 起，套餐从每月 $49 起、起步有 100 次免费请求。

Tweepy 在 2026 年还能用吗？

能。Tweepy 支持 X API v2、与当前认证（bearer 令牌和 OAuth）配合。Tweepy 需要付费的 X API 额度：在按量付费下，没有一个活跃的、买了额度的 X 开发者账号，就无法使用 Tweepy。

在 Python 里如何处理 Twitter API 速率限制？

官方 API 按 15 分钟窗口执行限制（通常 300 到 900 次请求，取决于接口），撞上时返回一个带 Retry-After 头的 429。Tweepy 和 XDK 自动退避；用裸 requests，你检查这些头、在重试前睡眠。逐接口限制的完整表见我们的 X API 速率限制指南。像 Sorsa 这样的第三方 API 用每秒限制（每秒 20 次请求）取代窗口，所以遇到 429 你等一秒再重试。

如何开始

挑一个方法、跑上面某个示例。

• 只读数据： 从 Sorsa 仪表盘拿一个密钥、把它粘进任意方法 4 示例里的 headers 字典、跑脚本。你的头 100 次请求免费、无需绑卡，你会在不到一分钟内在终端里得到结构化的 Twitter 数据。Sorsa API 文档覆盖全部 40 个接口。
• 读写： 在 developer.x.com 创建一个 X 开发者账号、购买额度，并用你的 bearer 令牌跑 XDK 或 Tweepy 示例。
• 还没代码： 上面链接的浏览器版 playground 让你通过一个网页 UI 测试任意接口，在写一行 Python 之前。

对只读服务商的更广视角，见我们的 Twitter API 替代方案对比。

审校：Keksich（Sorsa 创始人，X API 研究者）

我们如何核实本指南

我们在 2026 年 7 月对照一手来源核查了每一个外部论断。官方 XDK 的细节（pip install xdk 包、自动生成的客户端、自动分页、流式，以及三种认证方法）来自 X 对 Python 和 TypeScript XDK 的开发者公告，以及 docs.x.com 上的 XDK 文档。Tweepy 持续的 v2 支持对照 Tweepy 文档做了确认。X API 定价数字反映当前的按量付费模型，包括 2026 年 4 月的写入成本变化，而 Sorsa 接口行为、按请求批量和套餐定价来自 Sorsa API 文档。我们不引用推文数或库的 star 数，因为那些数字会变；凡一个数字可能过时之处，我们改为描述其机制。如果你发现一个自发布以来已变动的数字，产品内文档永远是当前的事实来源。