Go 版 Twitter API：2026 年如何获取 X 数据（指南）

作者：Sorsa 编辑部

发布于 2026 年 6 月，更新于 2026 年 7 月 4 日：反映 X 当前的按量付费定价（含 2026 年 4 月的写入成本变化）和 Go 工具的现状。X 只为 Python 和 TypeScript 提供官方 SDK，没有 Go 版。本次更新新增 100 次免费请求的起步选项，并把 Sorsa 按请求价格改用每千为单位表述。

核心要点： 2026 年没有面向 Go 的官方 X（Twitter）API SDK；X 只为 Python 和 TypeScript 提供官方 SDK。Go 里的实用路线是维护中的社区库（比如 gotwtr）、带 bearer 令牌的朴素 net/http，或只读的第三方 REST API。

如果你搜 “twitter api golang”，指望有一个官方、有支持的包，那是没有的。X 在 2025 年底为 Python 和 TypeScript 推出了第一方 SDK，把 Go 留给了社区。多数在这个查询上排名靠前的 Go 教程比“没有”还糟：它们教 dghubble/go-twitter，那个只面向已退役的 v1.1 API，对着一套不再存在的定价。

我们开发并运营 Sorsa API 这个 Twitter/X API 替代方案，而 Go 天然契合只读路径：用户资料、推文、搜索结果和粉丝都以干净的 JSON 返回，可直接映射进 Go 结构体，只需 ApiKey 请求头里的一个 API 密钥，没有 OAuth 握手，也没有要等的开发者账号审批。在读密集型工作上，最多可比官方 X API 便宜 50 倍：批量定价从每 1,000 条推文 $0.02、每 1,000 份用户资料 $0.01 起，速率限制是所有套餐统一 20 次/秒。注册即送 100 次免费请求（一次性、无需绑卡、包含每一个接口），付费之前就能用。不是每个项目都合这个模子：有的要发帖，有的因合规必须用官方 API。本指南用可用代码、当前定价，以及一个尊重速率限制的并发采集器，覆盖每一条 Go 路线。你也可以在在线试用工具 Playground 里不写代码就测试调用。

目录

• 变了什么：2026 年的 X API 和 Go 工具
• X API 最好的 Go 库
• 你该用哪种方式？
• 方法 1：社区库（gotwtr）
• 方法 2：带 bearer 令牌的朴素 net/http
• 方法 3：只读 REST API
• 有面向 X API 的官方 Go SDK 吗？
• 用 Go 构建一个并发数据采集器
• 对比：三条路线，并排
• 如何拿到你的 API 凭据
• 实战：削减一个 Go 采集器的成本
• 常见问题
• 如何开始

变了什么：2026 年的 X API 和 Go 工具 {#what-changed-the-x-api-and-go-tooling-in-2026}

自旧教程写就以来，Go 开发者面前有三件事变了。X API 转向了没有免费版的按量付费计费，并按资源读取收费。2026 年 4 月更新后，写入变贵了。X 还推出了首批官方 SDK，但只给 Python 和 TypeScript，所以 Go 开发者仍然依赖社区库或裸 HTTP。

按量付费是默认。 新注册没有免费版，也没有月度 Basic 套餐。你买额度、按资源付费：帖子读取每条 $0.005，用户资料每份 $0.010，粉丝或关注记录每条 $0.010。读取自己账号的数据每资源 $0.001，标准账号每月上限 200 万次帖子读取。一份真实预算背后的数字，见我们的 X API 价格详解。

写入变贵了。 2026 年 4 月更新后，标准帖子每请求 $0.015，含 URL 的帖子 $0.20。关注、点赞和引用帖子动作从自助档位撤出，现在需要 Enterprise 合同。

官方 SDK 只落地了 Python 和 TypeScript。 2025 年底 X 为这两种语言宣布了第一方 XDK。没有官方 Go SDK。社区库填了这个缺口，其中面向 v2 API 最强的是 gotwtr，用一个 OAuth 2.0 bearer 令牌覆盖完整的 v2 范围。

旧的 Go 库大多废了。 dghubble/go-twitter（几乎每个旧 Go 教程都用它）面向 X 已退役的 v1.1 API。任何用 v1.1 字段调用 client.Statuses.Update 或 client.Search.Tweets 的指南都已过时。

X API 最好的 Go 库 {#the-best-go-library-for-the-x-api}

做 Go 里新的 v2 工作，gotwtr 是最好的通用库：面向 v2 API，用一个 OAuth 2.0 bearer 令牌认证，覆盖用户、推文、搜索、粉丝、时间线和写入。没有官方 Go SDK 能压过它。而做只读数据采集，很多 Go 团队会跳过库，用标准 net/http 包调用第三方 REST API，彻底去掉 OAuth。

下面是主要选项的对比。

无论你为官方 API 挑哪个库，成本都一样，因为 X 在自己那一侧按资源计费，不按库。你能控制的变量是拉取多少资源，而批量接口和按请求计费的 API，恰恰改变的就是这笔成本账。

你该用哪种方式？ {#which-approach-should-you-use}

写代码之前先挑路线。要用一个有类型的库对 v2 API 读写，用 gotwtr。要以最少配置大量拿只读数据，第三方 REST API 去掉了 OAuth 和审批队列。要无依赖地完全掌控，标准 net/http 包就够。这个决定大体是读对写，以及你拉多少量。

如果你的项目只读取公开数据，第三方 API 去掉了 OAuth 流程：请求头里一个密钥，就能开始拉数据，没有开发者账号申请，也没有额度购买。如果你要发帖或跑写操作，通过 gotwtr 的官方 API 是那条路，没有第三方服务商代你发帖。用另一种语言？见本指南的 Python 版。

方法 1：社区库（gotwtr） {#method-1-a-community-library-gotwtr}

gotwtr 是一个面向 X API v2 的 Go 客户端，用一个 OAuth 2.0 bearer 令牌认证，返回有类型的响应，覆盖完整的 v2 接口集，是 Go 里最接近一个完整、当前的 Twitter 客户端的东西。

安装：

go get github.com/sivchari/gotwtr

搜索最近七天并打印结果：

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/sivchari/gotwtr"
)

func main() {
	client := gotwtr.New(os.Getenv("X_API_BEARER_TOKEN"))

	tsr, err := client.SearchRecentTweets(context.Background(), "golang lang:en", &gotwtr.SearchTweetsOption{
		TweetFields: []gotwtr.TweetField{gotwtr.TweetFieldAuthorID, gotwtr.TweetFieldCreatedAt},
		MaxResults:  20,
	})
	if err != nil {
		panic(err)
	}

	for _, t := range tsr.Tweets {
		fmt.Println(t.Text)
	}
}

按 ID 查询特定推文：

ts, err := client.RetrieveMultipleTweets(context.Background(), []string{"1782368585664626774"})
if err != nil {
	panic(err)
}

for _, t := range ts.Tweets {
	fmt.Println(t.Text)
}

gotwtr 还覆盖用户查询（RetrieveSingleUserWithUserName）、粉丝和关注列表（Followers、Following）、用户时间线（UserTweetTimeline）、写入（PostTweet），以及过滤或抽样流式（ConnectToStream、VolumeStreams）。当你想要有类型的 v2 访问、并且可能也要写入时，它是对的选择。取舍在于：这个库是社区维护的，不是第一方；你仍需要一个付费的 X 开发者账号；而且每次调用都要付 X 的按资源定价。

方法 2：带 bearer 令牌的朴素 net/http {#method-2-plain-nethttp-with-a-bearer-token}

没有库，没有封装。Go 标准的 net/http 包加 encoding/json，就够用一个 bearer 令牌调用 X API v2。这条路适合想完全掌控请求和响应结构体的开发者，或者偏好避开第三方依赖的人。

为你想要的字段定义一个结构体，查询一份资料：

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

type userResponse struct {
	Data struct {
		ID            string `json:"id"`
		Username      string `json:"username"`
		Name          string `json:"name"`
		PublicMetrics struct {
			FollowersCount int `json:"followers_count"`
		} `json:"public_metrics"`
	} `json:"data"`
}

func main() {
	req, _ := http.NewRequest(http.MethodGet, "https://api.x.com/2/users/by/username/elonmusk", nil)

	q := req.URL.Query()
	q.Set("user.fields", "public_metrics,created_at")
	req.URL.RawQuery = q.Encode()
	req.Header.Set("Authorization", "Bearer "+os.Getenv("X_API_BEARER_TOKEN"))

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	var u userResponse
	json.NewDecoder(resp.Body).Decode(&u)

	fmt.Printf("@%s has %d followers\n", u.Data.Username, u.Data.PublicMetrics.FollowersCount)
}

官方 API 用响应 meta 里的 next_token 给搜索分页。翻完每一页，带一个守卫，别让一个宽泛查询耗尽你的额度：

func searchRecent(token, query string) ([]map[string]any, error) {
	var all []map[string]any
	nextToken := ""

	for {
		req, _ := http.NewRequest(http.MethodGet, "https://api.x.com/2/tweets/search/recent", nil)
		q := req.URL.Query()
		q.Set("query", query)
		q.Set("max_results", "100")
		q.Set("tweet.fields", "created_at,public_metrics")
		if nextToken != "" {
			q.Set("next_token", nextToken)
		}
		req.URL.RawQuery = q.Encode()
		req.Header.Set("Authorization", "Bearer "+token)

		resp, err := http.DefaultClient.Do(req)
		if err != nil {
			return nil, err
		}

		var body struct {
			Data []map[string]any `json:"data"`
			Meta struct {
				NextToken string `json:"next_token"`
			} `json:"meta"`
		}
		json.NewDecoder(resp.Body).Decode(&body)
		resp.Body.Close()

		all = append(all, body.Data...)
		if body.Meta.NextToken == "" {
			break
		}
		nextToken = body.Meta.NextToken
	}

	return all, nil
}

想要零依赖、或者在调试 API 行为时，这管用。缺点是分页、状态码处理、限速和重试都归你。一次性任务没问题；生产环境的数据管道，你最终会自己写一个小客户端。这条路仍然需要一个开发者账号和按量付费额度。

方法 3：只读 REST API {#method-3-a-read-only-rest-api}

如果一个 Go 服务只读取公开 Twitter 数据，第三方 REST API 能彻底跳过官方 API。没有 OAuth、没有申请步骤、没有额度购买流程，就是请求头里一个密钥，加直接解码进结构体的 JSON。

这是不用开发者账号获取 X 数据的实用路线。下面是用 Sorsa、只用标准库的写法。

获取一份用户资料：

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

type sorsaUser struct {
	ID             string `json:"id"`
	Username       string `json:"username"`
	DisplayName    string `json:"display_name"`
	FollowersCount int    `json:"followers_count"`
}

func main() {
	req, _ := http.NewRequest(http.MethodGet, "https://api.sorsa.io/v3/info?username=elonmusk", nil)
	req.Header.Set("ApiKey", os.Getenv("SORSA_API_KEY"))

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	var u sorsaUser
	json.NewDecoder(resp.Body).Decode(&u)

	fmt.Printf("@%s (%s): %d followers\n", u.Username, u.DisplayName, u.FollowersCount)
}

用完整的网页操作符集搜索推文。搜索接口每页返回约 20 条推文和一个用于下一页的 next_cursor：

import "bytes"

type sorsaTweet struct {
	ID         string `json:"id"`
	FullText   string `json:"full_text"`
	LikesCount int    `json:"likes_count"`
}

type searchResponse struct {
	Tweets     []sorsaTweet `json:"tweets"`
	NextCursor string       `json:"next_cursor"`
}

func searchTweets(apiKey, query string) (*searchResponse, error) {
	payload, _ := json.Marshal(map[string]string{"query": query, "order": "latest"})

	req, _ := http.NewRequest(http.MethodPost, "https://api.sorsa.io/v3/search-tweets", bytes.NewReader(payload))
	req.Header.Set("ApiKey", apiKey)
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var out searchResponse
	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
		return nil, err
	}
	return &out, nil
}

拉取一份粉丝列表。一次请求最多返回 200 份用户资料，所以一个 1,000 粉丝的账号是五次请求，而不是十页翻页：

type followersResponse struct {
	Users      []sorsaUser `json:"users"`
	NextCursor string      `json:"next_cursor"`
}

// GET https://api.sorsa.io/v3/followers?username=elonmusk 返回最多 200 个用户

复杂查询就像在高级搜索里那样组合操作符，完整的操作符列表在我们的高级搜索语法参考里。每个推文响应都带着作者资料和公开指标，所以获取粉丝列表和读取互动数字都不增加额外调用。请求头是 ApiKey，基础 URL 是 https://api.sorsa.io/v3，字段名与 API 文档完全一致。想一次请求拉多达 100 条推文，把它们的 ID POST 到 /tweet-info-bulk，这只算一次请求并返回完整的推文对象。

有面向 X API 的官方 Go SDK 吗？ {#is-there-an-official-go-sdk-for-the-x-api}

没有。截至 2026 年，X 只为 Python 和 TypeScript 发布官方 SDK，没有官方 Go SDK。X 自己的“工具与库”页面列出那两个第一方 SDK 外加开发者工具。开源的 XDK 生成器目前只为 Python 和 TypeScript 提供模板，Go 被记为一个未来的贡献目标，还不是已发布的包。

对 Go 来说，这就留下上面讲过的三个现实选项：社区库 gotwtr 用于有类型的 v2 访问，朴素 net/http 用于完全掌控，或只读第三方 API 用于读密集型工作。想完全不写 Go 就做快速手动检查，X 还提供 xurl，一个内置 OAuth 的官方 curl 式命令行工具，在把接口接进代码之前戳一戳很有用。

如果日后真出了 Go SDK，也会从和 Python、TypeScript 相同的 OpenAPI 规格生成，所以范围会跟那些相像。在那之前，任何声称有“官方 Go SDK”的教程都不准确。

用 Go 构建一个并发数据采集器 {#building-a-concurrent-data-collector-in-go}

Go 在数据采集上真正的优势是并发，但对一个限速 API 的并发需要一个节流器，否则你就是用 429 错误换速度。管用的模式：把请求扇出到多个 goroutine，让它们通过一个按 API 限制大小的单一限速器放行，并在一个互斥锁下收集结果。对着统一 20 次/秒的限制，一个每 50 毫秒释放一个槽位的 ticker，让每个 goroutine 都待在预算内。

这个采集器一次为许多查询拉取近期推文，同时待在限制之下，复用方法 3 里的 searchTweets 函数和 sorsaTweet 结构体。

package main

import (
	"fmt"
	"sync"
	"time"
)

func collectForQueries(apiKey string, queries []string) map[string][]sorsaTweet {
	const ratePerSecond = 20
	ticker := time.NewTicker(time.Second / ratePerSecond) // 每 50 毫秒一个槽位
	defer ticker.Stop()

	results := make(map[string][]sorsaTweet)
	var mu sync.Mutex
	var wg sync.WaitGroup

	for _, query := range queries {
		wg.Add(1)
		go func(q string) {
			defer wg.Done()

			<-ticker.C // 调用前等一个速率限制槽位
			res, err := searchTweets(apiKey, q)
			if err != nil {
				return
			}

			mu.Lock()
			results[q] = res.Tweets
			mu.Unlock()
		}(query)
	}

	wg.Wait()
	return results
}

func main() {
	queries := []string{"golang", "rustlang", "typescript"}
	all := collectForQueries("YOUR_SORSA_API_KEY", queries)
	for q, tweets := range all {
		fmt.Printf("%s: %d tweets\n", q, len(tweets))
	}
}

ticker 在干真正的活：每个 goroutine 都阻塞在它上面，所以无论你启动多少个，调用都以被允许的速率发出。我们重建自己的采集器时发现，一个统一的每秒限制比逐接口的窗口更好控节奏，因为一个 ticker 覆盖整个客户端，而不是每接口一份单独的预算。想越过每个查询的第一页，就跟随响应里的 next_cursor，遇到空值就停；分页指南里有那个循环，官方侧的细节在我们的 X API 速率限制参考里。遇到 429，等一秒再重试同一次调用。

对比：三条路线，并排 {#comparison-three-routes-side-by-side}

三条 Go 路线在两个维度上分野：你能不能写入，以及怎么计费。两条官方 API 路线都需要开发者账号、按资源计费。只读 API 用写权限换来一个单一密钥和按请求计费。

这个分野告诉你该挑哪个：要发帖或跑写操作，那是官方 API 通过 gotwtr 的地盘。而要以固定、可预测的价格做读密集型访问，只读 API 是更便宜、更简单的路线，返回的还是同样的公开数据。

读取上的成本差距来自计费单位。官方 API 对响应里每条帖子和每份作者资料收费；按请求计费的 API 无论返回多少条目都只收一次请求。

对读密集型工作，按资源模型就是把一件简单的事做贵的方式，这也是为什么一旦你越过每月约 1 万次读取，按请求计费就胜出。写入是例外：发帖和私信只活在官方 API 上，所以写入密集型服务不管读取成本如何都属于那里。

如何拿到你的 API 凭据 {#how-to-get-your-api-credentials}

用官方 API，就在 developer.x.com 创建开发者账号、同意开发者条款、说明用例，再创建一个 Project 和 App 来生成 bearer 令牌和 OAuth 凭据。第一次调用之前先买额度，因为没有免费版。用只读第三方 API，就注册、生成一个密钥、在请求头里带上，没有申请或审批步骤，还有 100 次免费请求让你在买任何东西之前先测。

两种凭据都从环境读取，绝不写进源码：

# .env 或你的 shell 环境
X_API_BEARER_TOKEN=your-x-bearer-token
SORSA_API_KEY=your-sorsa-api-key

Go 里用上面示例展示的 os.Getenv 读取；开发时要加载 .env 文件，godotenv 之类的包是可选的。如果你在移植现有的官方 API 代码，从官方 X API 迁移的指南把官方接口和字段名映射到对应项，让你不用重写逻辑就能换掉传输层。

实战：削减一个 Go 采集器的成本 {#in-practice-cutting-the-cost-of-a-go-collector}

一个约 12 人的市场情报团队找到我们，当时在跑一个追踪竞品账号的 Go 服务。服务用的是一个 v1.1 时代的库，X 退役那些接口时就坏了，于是团队用朴素 net/http 对着官方 v2 API 重写了服务。代码干净，账单不干净。每次夜间运行都按帖子读取和作者资料付费，而每月 200 万次帖子读取的上限，意味着随着被追踪账号列表增长，他们得盯着量。

修法是换传输层，不是重写。他们保留了 goroutine 采集逻辑和调度，把客户端指向搜索和 /followers 接口，并把 OAuth 换成一个 ApiKey 请求头。因为每次请求最多返回 20 条推文或 200 份粉丝资料、而不是按资源计费，同样的夜间拉取只花了此前的一个零头，读密集的部分约省 30 到 50 倍。一个每秒限制取代了每月上限，成为唯一需要控节奏的东西。对只读负载来说，按资源模型此前一直是把简单事做贵的方式。

常见问题 {#faq}

有面向 Go 的官方 X（Twitter）API SDK 吗？

没有。截至 2026 年，X 只为 Python 和 TypeScript 发布官方 SDK，没有官方 Go SDK。面向 v2 API 维护中的社区选项是 gotwtr，用一个 OAuth 2.0 bearer 令牌，覆盖用户、推文、搜索、粉丝和时间线。X 的开源 SDK 生成器把 Go 列为未来目标，但没有 Go 包发布，所以任何“官方 Go SDK”的说法都不准确。

Twitter API 最好的 Go 库是什么？

做新的 v2 工作，gotwtr 是最好的通用 Go 库：面向 v2 API，用一个 bearer 令牌认证，覆盖读写。dghubble 的旧 go-twitter 包被广泛引用，但只面向已退役的 v1.1 API，不适合新搭建。而要大量做只读数据，很多 Go 团队会跳过库，用标准 net/http 包调用第三方 REST API。

如何在 Go 里不用开发者账号获取推文？

调用一个只读第三方 REST API。用 Sorsa，你注册、拿一个 API 密钥、在 ApiKey 请求头里带上、用 net/http 发一个请求，JSON 直接解码进 Go 结构体。没有 OAuth 流程、没有应用审核、没有额度购买，而且注册即送 100 次免费请求。每个推文响应都包含作者资料和公开指标，所以一次请求就返回完整数据。

2026 年 X API 对一个 Go 应用要花多少钱？

在官方 X API 上按资源付费：帖子读取每条 $0.005，用户资料每份 $0.010，标准帖子每条 $0.015，含 URL 的帖子 $0.20，每月上限 200 万次帖子读取。一次返回 20 条推文的搜索，一旦算上作者资料就是 $0.30。Sorsa 改为按请求计费，批量接口上折算为每 1,000 条推文 $0.02、每 1,000 份用户资料 $0.01 起，而且注册即送 100 次免费请求。

在 Go 里如何处理 X API 速率限制？

官方 API 按 15 分钟窗口限制请求（通常 300 到 900，取决于接口），撞上时返回 429。Go 里让并发调用通过一个按限制大小的单一限速器放行，比如一个 time.Ticker 或 golang.org/x/time/rate，让 goroutine 不超出限制。Sorsa 这类按请求计费的 API 用 20 次/秒的限制，所以一个每 50 毫秒释放一个槽位的 ticker 就能让你待在预算内。

能在 Go 里只用 net/http 调用 X API 吗？

能。Go 标准的 net/http 和 encoding/json 包，可以用 Authorization 请求头里的一个 bearer 令牌调用 X API v2，并把响应解码进你自己的结构体。分页、状态码和重试都得你自己处理，这对少数几个接口或一次性任务没问题。更大的数据管道，你最终会写一个小客户端，那时一个库或一个第三方 API 就省时间了。

gotwtr 支持 X API v2 吗？

支持。gotwtr 为 X API v2 打造，用一个 OAuth 2.0 bearer 令牌认证，覆盖搜索、用户查询、粉丝和关注、时间线，以及发帖等写操作，并在其 1.x 系列里提供了完整的 v2 接口覆盖。使用 gotwtr 需要一个买了额度的付费 X 开发者账号，因为官方 API 在按量付费下没有免费版。

如何开始 {#getting-started}

挑一条路线，跑上面某个示例。

• 只读数据： 从 Sorsa 控制台拿一个密钥，注册即送 100 次免费请求，无需绑卡，设为 SORSA_API_KEY，跑任意方法 3 的示例。结构化 X 数据不到一分钟就落到你的终端，快速上手带你走一遍第一次调用。套餐和限制见定价页面。
• 读写： 在 developer.x.com 创建开发者账号、买额度，用你的 bearer 令牌跑 gotwtr 或 net/http 示例。
• 对比服务商： 只读选项的更全面视角见 Twitter API 替代方案对比，托管抓取的取舍见我们的抓取 X指南。

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

我们如何核实本指南

本指南在 2026 年 6 月一边每天运营该 API、一边撰写并核实。没有官方 Go SDK、且存在 Python 和 TypeScript SDK 这两点，对照 X 官方的“工具与库”文档及其对 XDK 的开发者公告做了确认。gotwtr 的方法名和 v2 覆盖对照 Go 包索引上的包参考核查。X API 定价反映当前的按量付费模型，包括 2026 年 4 月的写入成本变化。Sorsa 接口行为、按请求批量和套餐定价来自 Sorsa API 文档；团队的更多信息见我们的关于页面。库的版本号和 star 数会变，所以以描述而非固定值给出；要拿当前价格，产品内文档才是准确来源。