API do Twitter em Go: como obter dados do X em 2026 (guia)

Por Sorsa Editorial

Publicado em junho de 2026, atualizado em julho de 2026: reflete o preço de pagamento por uso atual do X (incluindo as mudanças de custo de escrita de abril de 2026) e o estado das ferramentas de Go, em que o X publica SDKs oficiais só para Python e TypeScript, não para Go. Atualização de julho de 2026: adicionada a oferta inicial de 100 requisições grátis e o preço por requisição da Sorsa reapresentado em base por 1.000.

Em resumo: Não existe um SDK oficial da API do X (Twitter) para Go em 2026; o X publica SDKs oficiais só para Python e TypeScript. As rotas práticas em Go são uma biblioteca de comunidade mantida como a gotwtr, net/http puro com um bearer token, ou uma API REST de terceiros somente leitura.

Se você pesquisou "twitter api golang" esperando um pacote oficial e suportado, não existe um. O X publicou SDKs de primeira parte para Python e TypeScript no fim de 2025 e deixou o Go para a comunidade. A maioria dos tutoriais de Go que ranqueiam para essa consulta é pior que ausente: eles ensinam a dghubble/go-twitter, que só fala a API v1.1 aposentada, contra um preço que não existe mais.

Nós construímos e operamos a Sorsa API, uma API alternativa do Twitter (X), e o Go é um encaixe natural para o caminho somente leitura: ela retorna perfis, tweets, resultados de busca e seguidores como JSON limpo que mapeia direto para structs de Go, com uma chave de API no cabeçalho ApiKey, sem handshake OAuth e sem aprovação de conta de desenvolvedor para esperar. Em trabalho de leitura intensa, sai até cerca de 50x mais barato que a API oficial do X: o preço em lote começa a partir de US$ 0,02 por 1.000 tweets e de US$ 0,01 por 1.000 perfis, o rate limit é fixo em 20 requisições por segundo em todos os planos, e uma conta nova começa com 100 requisições grátis (uma única vez, sem cartão, todos os endpoints incluídos) antes de qualquer plano pago. Nem todo projeto encaixa nesse formato: alguns precisam postar, e alguns precisam da API oficial para conformidade. Este guia cobre todas as rotas de Go com código funcional, preço atual e um coletor concorrente que respeita o rate limit. Você também pode testar chamadas sem escrever código no playground da API.

Índice

• O que mudou: a API do X e as ferramentas de Go em 2026
• A melhor biblioteca de Go para a API do X
• Qual abordagem usar?
• Método 1: uma biblioteca de comunidade (gotwtr)
• Método 2: net/http puro com um bearer token
• Método 3: uma API REST somente leitura
• Existe um SDK Go oficial para a API do X?
• Construindo um coletor de dados concorrente em Go
• Comparação: três rotas, lado a lado
• Como obter suas credenciais de API
• Na prática: cortando o custo de um coletor em Go
• Perguntas frequentes
• Primeiros passos

O que mudou: a API do X e as ferramentas de Go em 2026 {#what-changed-the-x-api-and-go-tooling-in-2026}

Três coisas mudaram para desenvolvedores de Go desde que os tutoriais antigos foram escritos. A API do X passou para cobrança de pagamento por uso, sem plano gratuito, e cobra por recurso lido. Escrever ficou mais caro após a atualização de abril de 2026. E o X publicou seus primeiros SDKs oficiais, mas só para Python e TypeScript, então desenvolvedores de Go ainda dependem de bibliotecas de comunidade ou de HTTP puro.

O pagamento por uso é o padrão. Não há plano gratuito nem plano Basic mensal para novos cadastros. Você compra créditos e paga por recurso: US$ 0,005 por post lido, US$ 0,010 por perfil de usuário e US$ 0,010 por registro de seguidor ou de seguindo. Ler os dados da sua própria conta custa US$ 0,001 por recurso, e contas padrão têm teto de 2 milhões de leituras de posts por mês. Os números por trás de um orçamento real estão na nossa análise de preços da API do X.

Escrever ficou mais caro. Após a atualização de abril de 2026, um post padrão custa US$ 0,015 por requisição e um post com URL custa US$ 0,20. As ações de follow, curtida e quote foram retiradas dos níveis self-service e agora exigem um contrato Enterprise.

Os SDKs oficiais chegaram só para Python e TypeScript. No fim de 2025, o X anunciou XDKs de primeira parte para essas duas linguagens. Não há SDK Go oficial. As bibliotecas de comunidade preenchem a lacuna, e a mais forte para a API v2 é a gotwtr, que cobre toda a API v2 com um bearer token OAuth 2.0.

As bibliotecas antigas de Go estão quase todas mortas. A dghubble/go-twitter, a biblioteca que quase todo tutorial antigo de Go usa, mira a API v1.1 que o X aposentou. Qualquer guia que chama client.Statuses.Update ou client.Search.Tweets com campos da v1.1 está desatualizado.

A melhor biblioteca de Go para a API do X {#the-best-go-library-for-the-x-api}

Para trabalho novo de v2 em Go, a gotwtr é a melhor biblioteca de uso geral: ela mira a API v2, autentica com um bearer token OAuth 2.0 e cobre usuários, tweets, busca, seguidores, timelines e escritas. Não há SDK Go oficial para preferir a ela. Para coleta de dados somente leitura, muitas equipes de Go pulam bibliotecas e chamam uma API REST de terceiros com o pacote padrão net/http, que remove o OAuth por completo.

Veja como as principais opções se comparam.

Seja qual for a biblioteca que você escolha para a API oficial, o custo é idêntico, porque o X cobra por recurso do lado dele, não por biblioteca. A variável que você controla é quantos recursos puxa, que é onde os endpoints em lote e uma API de taxa fixa mudam a conta.

Qual abordagem usar? {#which-approach-should-you-use}

Escolha a rota antes de escrever código. Para leitura e escrita contra a API v2 com uma biblioteca tipada, use a gotwtr. Para dados somente leitura em volume com configuração mínima, uma API REST de terceiros remove o OAuth e a fila de aprovação. Para controle total sem dependências, o pacote padrão net/http basta. A decisão é, na maior parte, leitura contra escrita, e quanto volume você puxa.

Se o seu projeto só lê dados públicos, uma API de terceiros remove o fluxo OAuth: uma chave em um cabeçalho e você começa a puxar dados, sem candidatura de conta de desenvolvedor e sem compra de crédito. Se você precisa postar ou rodar ações de escrita, a API oficial pela gotwtr é o caminho; nenhum provedor de terceiros posta em seu nome. Trabalhando em outra linguagem? Veja a versão em Python deste guia.

Método 1: uma biblioteca de comunidade (gotwtr) {#method-1-a-community-library-gotwtr}

A gotwtr é um cliente de Go para a API do X v2. Ela autentica com um bearer token OAuth 2.0, retorna respostas tipadas e cobre todo o conjunto de endpoints v2. É o mais próximo que o Go tem de um cliente de Twitter completo e atual.

Instale:

go get github.com/sivchari/gotwtr

Busque nos últimos sete dias e imprima os resultados:

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

Consulte tweets específicos por ID:

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

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

A gotwtr também cobre consulta de usuário (RetrieveSingleUserWithUserName), listas de seguidores e de seguindo (Followers, Following), timelines de usuário (UserTweetTimeline), escritas (PostTweet) e streaming filtrado ou amostrado (ConnectToStream, VolumeStreams). É a escolha certa quando você quer acesso v2 tipado e talvez também escreva. As trocas: é mantida pela comunidade, e não de primeira parte, você ainda precisa de uma conta de desenvolvedor paga do X, e paga o preço por recurso do X em cada chamada.

Método 2: net/http puro com um bearer token {#method-2-plain-nethttp-with-a-bearer-token}

Sem biblioteca, sem wrapper. O pacote padrão net/http do Go e o encoding/json bastam para chamar a API do X v2 com um bearer token. Essa rota serve para desenvolvedores que querem controle total sobre requisições e structs de resposta, ou que preferem evitar dependências de terceiros.

Defina um struct para os campos que você quer e consulte um perfil:

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

A API oficial pagina a busca com um next_token no meta da resposta. Percorra cada resultado com uma trava para uma consulta ampla não esgotar a sua cota:

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
}

Isso funciona quando você quer zero dependências ou está depurando o comportamento da API. A desvantagem é que você é dono da paginação, do tratamento de códigos de status, do rate limit e das retentativas. Para um trabalho pontual, tudo bem; para um pipeline de produção, você acaba escrevendo um pequeno cliente próprio. Essa rota ainda exige uma conta de desenvolvedor e créditos de pagamento por uso.

Método 3: uma API REST somente leitura {#method-3-a-read-only-rest-api}

Se um serviço Go só lê dados públicos do Twitter, uma API REST de terceiros pula a API oficial por completo: sem OAuth, sem etapa de candidatura, sem fluxo de compra de crédito, só uma chave em um cabeçalho e JSON que decodifica direto em structs.

Essa é a rota prática para obter dados do X sem uma conta de desenvolvedor. Veja como fica com a Sorsa, usando só a biblioteca padrão.

Obtenha um perfil de usuário:

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

Busque tweets com o conjunto completo de operadores da web. O endpoint de busca retorna cerca de 20 tweets por página e um next_cursor para a próxima página:

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
}

Puxe uma lista de seguidores. Uma requisição retorna até 200 perfis, então uma conta de 1.000 seguidores são cinco requisições em vez de dez páginas paginadas:

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

// GET https://api.sorsa.io/v3/followers?username=elonmusk returns up to 200 users

Para consultas complexas, combine operadores como você faria na busca avançada; a lista completa está na nossa referência de operadores de busca. Cada resposta de tweet carrega o perfil do autor e as métricas públicas, então buscar listas de seguidores e ler os números de engajamento não adiciona chamadas extras. O cabeçalho é ApiKey, a URL base é https://api.sorsa.io/v3, e os nomes de campo batem com a documentação da API exatamente. Para puxar até 100 tweets em uma requisição, poste os IDs deles em /tweet-info-bulk, que conta como uma única requisição e retorna objetos completos de tweet.

Existe um SDK Go oficial para a API do X? {#is-there-an-official-go-sdk-for-the-x-api}

Não. Em 2026, o X publica SDKs oficiais só para Python e TypeScript; não há SDK Go oficial. A própria página de ferramentas e bibliotecas do X lista esses dois SDKs de primeira parte mais ferramentas de desenvolvedor, e o gerador de XDK de código aberto atualmente publica templates só para Python e TypeScript, com o Go documentado como alvo futuro de contribuição, e não como um pacote lançado.

Para Go, isso deixa três opções reais, todas cobertas acima: a biblioteca de comunidade gotwtr para acesso v2 tipado, net/http puro para controle total, ou uma API de terceiros somente leitura para trabalho de leitura intensa. Para checagens manuais rápidas sem escrever Go nenhum, o X também publica o xurl, uma ferramenta oficial de linha de comando parecida com o curl e com OAuth embutido, útil para cutucar endpoints antes de ligá-los ao código.

Se um SDK Go chegar depois, ele será gerado da mesma especificação OpenAPI que os de Python e TypeScript, então o escopo dele vai lembrar o deles. Até lá, trate qualquer tutorial que afirme um "SDK Go oficial" como impreciso.

Construindo um coletor de dados concorrente em Go {#building-a-concurrent-data-collector-in-go}

A vantagem real do Go para coleta de dados é a concorrência, mas concorrência contra uma API com rate limit precisa de um limitador, ou você troca velocidade por erros 429. O padrão que funciona: espalhe requisições entre goroutines, controle-as por um único rate limiter dimensionado para o limite da API, e colete resultados sob um mutex. Contra um limite fixo de 20 requisições por segundo, um ticker que libera um slot a cada 50 milissegundos mantém toda goroutine dentro do orçamento.

Este coletor busca tweets recentes de muitas consultas de uma vez enquanto fica sob o limite. Ele reutiliza a função searchTweets e o struct sorsaTweet do Método 3.

package main

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

func collectForQueries(apiKey string, queries []string) map[string][]sorsaTweet {
	const ratePerSecond = 20
	ticker := time.NewTicker(time.Second / ratePerSecond) // one slot every 50ms
	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 // wait for a rate-limit slot before calling
			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))
	}
}

O ticker é quem faz o trabalho de verdade: toda goroutine bloqueia nele, então, não importa quantas você lance, as chamadas saem à taxa permitida. Quando reconstruímos os nossos próprios coletores, um limite fixo por segundo se mostrou mais simples de acompanhar que janelas por endpoint, porque um único ticker cobre o cliente inteiro em vez de orçamentos separados por endpoint. Para passar da primeira página de cada consulta, siga o next_cursor na resposta e pare em um valor vazio; o guia de paginação tem o loop, e o lado oficial está na nossa referência de rate limits da API do X. Em um 429, espere um segundo e repita a mesma chamada.

Comparação: três rotas, lado a lado {#comparison-three-routes-side-by-side}

As três rotas de Go se dividem em dois eixos: se você pode escrever e como é cobrado. As duas rotas de API oficial precisam de uma conta de desenvolvedor e cobram por recurso. Uma API somente leitura troca o acesso de escrita por uma única chave e cobrança fixa por requisição.

A divisão diz qual escolher: se você precisa postar ou rodar ações de escrita, esse é o território da API oficial pela gotwtr. Para acesso de leitura intensa a um preço fixo e previsível, uma API somente leitura é a rota mais barata e mais simples, e retorna os mesmos dados públicos.

A diferença de custo na leitura vem da unidade de cobrança. A API oficial cobra por cada post e cada perfil de autor em uma resposta; uma API de taxa fixa cobra uma requisição, não importa quantos itens retorne.

Para trabalho de leitura intensa, o modelo por recurso é a forma cara de fazer um trabalho simples, e é por isso que uma taxa fixa por requisição vence assim que você cruza cerca de 10.000 leituras por mês. As escritas são a exceção: postar e enviar DMs vivem só na API oficial, então um serviço de escrita intensa pertence a ela, seja qual for o custo de leitura.

Como obter suas credenciais de API {#how-to-get-your-api-credentials}

Para a API oficial, crie uma conta de desenvolvedor em developer.x.com, aceite os termos de desenvolvedor, descreva o seu caso de uso e crie um Project e um App para gerar um bearer token e credenciais OAuth. Compre créditos antes da primeira chamada, já que não há plano gratuito. Para uma API REST de terceiros somente leitura, cadastre-se, gere uma chave e passe-a em um cabeçalho, sem etapa de candidatura ou aprovação e com 100 requisições grátis para testar antes de comprar qualquer coisa.

Leia qualquer credencial do ambiente, nunca do código-fonte:

# .env or your shell environment
X_API_BEARER_TOKEN=your-x-bearer-token
SORSA_API_KEY=your-sorsa-api-key

Em Go, leia-as com os.Getenv como mostrado nos exemplos acima; para carregar um arquivo .env em desenvolvimento, um pacote como o godotenv é opcional. Se você está portando código existente da API oficial, o guia de migração da API oficial do X mapeia os endpoints e nomes de campo oficiais para os equivalentes de taxa fixa, para você trocar o transporte sem reescrever a lógica.

Na prática: cortando o custo de um coletor em Go {#in-practice-cutting-the-cost-of-a-go-collector}

Uma equipe de inteligência de mercado com cerca de 12 pessoas chegou até nós rodando um serviço Go que acompanhava contas de concorrentes. Ele usava uma biblioteca da era v1.1, que quebrou quando o X aposentou aqueles endpoints, então a equipe o reescreveu contra a API v2 oficial com net/http puro. O código estava limpo; a conta, não. Cada execução noturna pagava por post lido e por perfil de autor, e o teto mensal de 2 milhões de leituras de posts fazia com que vigiassem o volume conforme a lista de contas acompanhadas crescia.

A correção foi uma troca de transporte, não uma reescrita. Eles mantiveram a lógica de coleta com goroutines e o agendamento, apontaram o cliente para os endpoints de busca e /followers e trocaram o OAuth por um único cabeçalho ApiKey. Como cada requisição retorna até 20 tweets ou 200 perfis de seguidores em vez de cobrar por recurso, a mesma extração noturna custou uma fração do que custava, cerca de 30 a 50 vezes menos nas partes de leitura intensa, e um limite por segundo substituiu o teto mensal como a única coisa a acompanhar. Para uma carga somente leitura, o modelo por recurso tinha sido a forma cara de fazer um trabalho simples.

Perguntas frequentes {#faq}

Existe um SDK oficial da API do X (Twitter) para Go?

Não. Em 2026, o X publica SDKs oficiais só para Python e TypeScript; não há SDK Go oficial. A opção de comunidade mantida para a API v2 é a gotwtr, que usa um bearer token OAuth 2.0 e cobre usuários, tweets, busca, seguidores e timelines. O gerador de SDK de código aberto do X lista o Go como alvo futuro, mas nenhum pacote Go foi lançado, então trate qualquer afirmação de "SDK Go oficial" como imprecisa.

Qual é a melhor biblioteca de Go para a API do Twitter?

Para trabalho novo de v2, a gotwtr é a melhor biblioteca de uso geral de Go: ela mira a API v2, autentica com um bearer token e cobre leituras e escritas. O pacote mais antigo go-twitter, do dghubble, é muito citado, mas só fala a API v1.1 aposentada, então não serve para projetos novos. Para dados somente leitura em volume, muitas equipes de Go pulam bibliotecas e chamam uma API REST de terceiros com o pacote padrão net/http.

Como obter tweets em Go sem uma conta de desenvolvedor?

Chame uma API REST de terceiros somente leitura. Com a Sorsa, você se cadastra, pega uma chave de API, passa-a no cabeçalho ApiKey e envia uma requisição com net/http; o JSON decodifica direto em structs de Go. Não há fluxo OAuth, análise de app nem compra de crédito, e uma conta nova inclui 100 requisições grátis para começar. Cada resposta de tweet inclui o perfil do autor e as métricas públicas, então uma única requisição retorna dados completos.

Quanto a API do X custa para um app em Go em 2026?

Na API oficial do X você paga por recurso: US$ 0,005 por post lido, US$ 0,010 por perfil de usuário, US$ 0,015 por post padrão e US$ 0,20 por um post com URL, com teto mensal de 2 milhões de leituras de posts. Uma busca que retorna 20 tweets custa US$ 0,30 quando os perfis de autor são incluídos. A Sorsa cobra por requisição, o que dá a partir de US$ 0,02 por 1.000 tweets e de US$ 0,01 por 1.000 perfis nos endpoints em lote, e uma conta nova começa com 100 requisições grátis.

Como lidar com rate limits da API do X em Go?

A API oficial limita requisições por janela de 15 minutos (tipicamente de 300 a 900, conforme o endpoint) e retorna um 429 quando você bate em um. Em Go, controle as chamadas concorrentes por um único rate limiter, como um time.Ticker ou o golang.org/x/time/rate, dimensionado para o limite, para as goroutines não o excederem. Uma API de taxa fixa como a Sorsa usa um limite por segundo de 20 requisições, então um ticker liberando um slot a cada 50 milissegundos mantém você dentro do orçamento.

Dá para usar só o net/http para chamar a API do X em Go?

Sim. Os pacotes padrão net/http e encoding/json do Go conseguem chamar a API do X v2 com um bearer token no cabeçalho Authorization e decodificar a resposta nos seus próprios structs. Você trata paginação, códigos de status e retentativas por conta própria, o que serve para alguns endpoints ou um trabalho pontual. Para um pipeline maior, você acaba escrevendo um pequeno cliente, ponto em que uma biblioteca ou uma API de terceiros economiza tempo.

A gotwtr suporta a API do X v2?

Sim. A gotwtr é feita para a API do X v2 e autentica com um bearer token OAuth 2.0. Ela cobre busca, consulta de usuário, seguidores e seguindo, timelines e ações de escrita como postar, e entregou cobertura completa de endpoints v2 na sua linha 1.x. Ela exige uma conta de desenvolvedor paga do X com créditos comprados, já que a API oficial não tem plano gratuito no pagamento por uso.

Primeiros passos {#getting-started}

Escolha uma rota e rode um dos exemplos acima.

• Dados somente leitura: pegue uma chave no painel da Sorsa, que começa com 100 requisições grátis e sem cartão, defina-a como SORSA_API_KEY e rode qualquer exemplo do Método 3. Dados estruturados do X caem no seu terminal em menos de um minuto, e o início rápido percorre a primeira chamada. Planos e limites estão na página de preços.
• Leitura e escrita: crie uma conta de desenvolvedor em developer.x.com, compre créditos e rode os exemplos de gotwtr ou net/http com o seu bearer token.
• Comparando provedores: para um olhar mais amplo sobre opções somente leitura, veja a comparação de alternativas à API do Twitter, e, para as trocas de scraping gerenciado, nosso guia de como fazer scraping do X.

Revisado por Keksich, fundador da Sorsa, profissional de marketing e pesquisador da API do X.

Como verificamos este guia {#how-we-verified-this-guide}

Escrevemos e verificamos este guia em junho de 2026 operando a API diariamente. A ausência de um SDK Go oficial e a existência dos SDKs de Python e TypeScript foram confirmadas contra a documentação oficial de ferramentas e bibliotecas do X e o seu anúncio de desenvolvedor dos XDKs. Os nomes de método da gotwtr e a cobertura v2 foram checados contra a referência do pacote no índice de pacotes do Go. O preço da API do X reflete o modelo atual de pagamento por uso, incluindo as mudanças de custo de escrita de abril de 2026. O comportamento dos endpoints da Sorsa, o agrupamento em lote por requisição e o preço dos planos vêm da documentação da Sorsa API; mais sobre a equipe está na nossa página sobre a Sorsa. Números de versão de biblioteca e contagens de estrelas mudam, então são descritos e não fixados; para um preço atual, a documentação no produto é a fonte da verdade.