API do Twitter em Node.js: obter dados do X em 2026 (guia completo)

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 os XDKs oficiais de Python e TypeScript que o X lançou no fim de 2025.

Atualizado em julho de 2026: preço da Sorsa reapresentado nas taxas de lote por 1.000 e adicionada a oferta inicial de 100 requisições grátis.

Em resumo: Há quatro formas práticas de obter dados do Twitter (X) em Node.js em 2026: o XDK oficial de TypeScript, a biblioteca twitter-api-v2, fetch puro com um bearer token, ou uma API REST de terceiros somente leitura. As rotas oficiais cobram por recurso e exigem credenciais OAuth; uma API só com chave serve para trabalho de leitura intensa.

Se você pesquisou "twitter api nodejs" esperando um npm install rápido e um trecho que retorna tweets, o cenário de 2026 é mais bagunçado do que os tutoriais antigos sugerem. O X mudou o modelo de preços, mudou como as leituras são cobradas e, pela primeira vez, publicou um SDK oficial para JavaScript. A maioria dos guias de Node que ranqueiam ainda ensina a postar por uma conta de desenvolvedor paga e não acompanhou nada disso.

Nós construímos e operamos a Sorsa API, uma API alternativa do Twitter (X), então o caminho somente leitura é o que conhecemos melhor. Ela retorna perfis, tweets, resultados de busca e seguidores como JSON limpo de uma única chamada fetch, com uma chave de API no cabeçalho ApiKey, sem fluxo 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, mantém um fixo de 20 requisições por segundo em todos os planos e dá cerca de US$ 0,02 por 1.000 tweets nos endpoints em lote, com planos fixos a partir de US$ 49 por mês. Toda chave nova inclui 100 requisições grátis, sem cartão, para você testar antes de pagar. Nem todo projeto encaixa nesse formato: alguns precisam postar, alguns precisam da API oficial para conformidade, e algumas equipes só querem entender os internos. Este guia cobre os quatro métodos com código Node.js funcional, preço atual e um coletor completo que pagina e recua em rate limits. Você também pode testar chamadas sem escrever código no playground.

Índice

• O que mudou: a API do X e as ferramentas de Node.js em 2026
• A melhor biblioteca para a API do X em Node.js
• Qual abordagem usar?
• Método 1: o XDK oficial de TypeScript
• Método 2: twitter-api-v2
• Método 3: fetch puro com um bearer token
• Método 4: uma API REST somente leitura
• Dá para chamar a API do X do navegador?
• Construindo um coletor de dados em Node.js
• Comparação: quatro métodos, lado a lado
• Como obter suas credenciais de API
• Na prática: movendo um coletor Node da API oficial
• Perguntas frequentes
• Primeiros passos

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

Três coisas mudaram para desenvolvedores de Node desde 2023. A API do X passou para cobrança de pagamento por uso, sem plano gratuito, e agora 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, incluindo um pacote TypeScript que roda no Node, ao lado da veterana biblioteca de comunidade twitter-api-v2.

O pagamento por uso é o padrão. Não há plano gratuito nem plano Basic de US$ 100 para novos cadastros. Você compra créditos adiantado 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, mas essa taxa não vale quando você lê outras contas. Há também um teto rígido de 2 milhões de leituras de posts por mês em contas padrão. Para o detalhamento completo, veja nossa análise de preços da API do X e o texto sobre por que o preço da API do X subiu.

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 removidas dos níveis self-service e agora exigem um contrato Enterprise. Um bot de seguir de volta ou um auto-curtidor não é mais possível em uma conta padrão de pagamento por uso.

O X lançou SDKs oficiais. No fim de 2025, o X anunciou XDKs (X Developer Kit) de primeira parte para Python e TypeScript, confirmados no seu anúncio de desenvolvedor. O XDK de TypeScript é o primeiro cliente JavaScript oficial que o X publicou. Ele embrulha os endpoints v2 com modelos tipados, trata a paginação e suporta streaming.

A twitter-api-v2 ainda funciona. A biblioteca de comunidade twitter-api-v2 suporta v1.1 e v2, roda fluxos de leitura, escrita e DM, e continua o wrapper de Node mais usado. O código existente segue funcionando com as credenciais atuais.

As bibliotecas antigas estão mortas. Os pacotes twit e twitter no npm não recebem atualizações relevantes desde 2017 e só falam a v1.1. Se um tutorial mandar você fazer npm install twit, ele está desatualizado.

A melhor biblioteca para a API do X em Node.js {#the-best-library-for-the-x-api-in-nodejs}

Para a maioria dos projetos Node, a twitter-api-v2 é a melhor biblioteca de uso geral: é madura, totalmente tipada e suporta fluxos de leitura, escrita e DM por bearer token e OAuth. Se você quer uma ferramenta de primeira parte que segue a especificação da API exatamente, use o XDK oficial de TypeScript. Para coleta de dados somente leitura, muitas equipes pulam bibliotecas e chamam uma API REST de terceiros com fetch puro, que remove o OAuth por completo.

Veja como as principais opções se comparam.

Toda opção que mira a API oficial cobra pelo preço de pagamento por uso do X, então o custo é idêntico chame você o X com o XDK, a twitter-api-v2 ou fetch cru. A variável que você de fato 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 o caminho antes de escrever código. Para trabalho de leitura e escrita com suporte oficial, use o XDK ou a twitter-api-v2. 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, fetch puro mais um bearer token funciona. A escolha é, 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 a dança do 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 do X pelo XDK ou pela twitter-api-v2 é o caminho; nenhum provedor de terceiros posta em seu nome. Trabalhando em Python? Veja a versão em Python deste guia.

Método 1: o XDK oficial de TypeScript {#method-1-the-official-typescript-xdk}

O XDK de TypeScript é o primeiro SDK JavaScript oficial do X. Ele embrulha a API v2 com modelos tipados, trata a paginação, suporta streaming e funciona no Node.js, em navegadores e no React Native. Ele exige Node.js 16 ou mais novo e suporta autenticação por bearer token, OAuth 2.0 PKCE e OAuth 1.0a.

Instale:

npm install @xdevplatform/xdk

Um bearer token basta para ler dados públicos. Consulte um perfil:

import { Client } from "@xdevplatform/xdk";

// App-only auth: a bearer token covers read-only access to public data
const client = new Client({ bearerToken: process.env.X_API_BEARER_TOKEN });

async function main() {
  const user = await client.users.getByUsername("elonmusk");
  console.log(user.data?.username, user.data?.name);
}

main();

O SDK traz um paginador para endpoints de lista. Puxe os seguidores de um usuário com paginação automática:

import { Client, UserPaginator } from "@xdevplatform/xdk";

const client = new Client({ bearerToken: process.env.X_API_BEARER_TOKEN });

const followers = new UserPaginator(async (token) => {
  const res = await client.users.getFollowers("44196397", {
    maxResults: 100,
    paginationToken: token,
    userfields: ["id", "name", "username"],
  });
  return { data: res.data ?? [], meta: res.meta, includes: res.includes, errors: res.errors };
});

for await (const follower of followers) {
  console.log(follower.username);
}

O XDK também expõe client.posts para busca e timelines e client.stream para feeds em tempo real. É a escolha certa quando você quer suporte oficial, precisa de acesso de escrita e está começando um projeto novo. As trocas: o SDK é novo (v0.5 em fevereiro de 2026), a documentação ainda é rala, e você paga o preço por recurso do X em cada chamada.

Método 2: twitter-api-v2 {#method-2-twitter-api-v2}

A twitter-api-v2 é o cliente Node padrão há anos. Ela suporta v1.1 e v2, expõe clientes separados de somente leitura, leitura e escrita e DM, e trata paginação e cabeçalhos de rate limit. É o equivalente mais próximo em Node do Tweepy em Python.

Instale-a do npm:

npm install twitter-api-v2

Crie um cliente somente leitura a partir de um bearer token e consulte um perfil:

import { TwitterApi } from "twitter-api-v2";

const client = new TwitterApi(process.env.X_API_BEARER_TOKEN).readOnly;

const user = await client.v2.userByUsername("elonmusk", {
  "user.fields": ["description", "public_metrics", "created_at"],
});

console.log(user.data.username, user.data.public_metrics?.followers_count);

Busque nos últimos 7 dias. O método search retorna um paginador que você pode iterar diretamente:

const search = await client.v2.search("nodejs lang:en", {
  max_results: 20,
  "tweet.fields": ["created_at", "public_metrics"],
});

for await (const tweet of search) {
  console.log(tweet.text);
}

Busque os seguidores de um usuário como um paginador:

const followers = await client.v2.followers("44196397", { asPaginator: true });

for await (const follower of followers) {
  console.log(follower.username);
}

A twitter-api-v2 é o padrão seguro para a maioria dos desenvolvedores de Node: testada em batalha, bem documentada e com uma resposta para quase qualquer problema. As trocas batem com as do XDK: você ainda precisa de uma conta de desenvolvedor paga do X, ainda paga por recurso, e os rate limits são herdados da API oficial (tipicamente de 300 a 900 requisições por janela de 15 minutos, conforme o endpoint).

Método 3: fetch puro com um bearer token {#method-3-plain-fetch-with-a-bearer-token}

Sem biblioteca, sem wrapper. O Node 18 e mais novos trazem um fetch global, então você pode chamar a API do X v2 diretamente com um bearer token e zero dependências. Isso serve para desenvolvedores que querem controle total sobre requisições, ou que trabalham onde instalar pacotes é restrito.

Busque tweets recentes:

// Node 18+ has global fetch, so no dependencies are needed
const headers = { Authorization: `Bearer ${process.env.X_API_BEARER_TOKEN}` };

const url = new URL("https://api.x.com/2/tweets/search/recent");
url.searchParams.set("query", "nodejs lang:en");
url.searchParams.set("max_results", "20");
url.searchParams.set("tweet.fields", "created_at,public_metrics");

const res = await fetch(url, { headers });
const data = await res.json();

for (const tweet of data.data ?? []) {
  console.log(tweet.text);
}

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

async function searchAll(query, maxPages = 10) {
  const headers = { Authorization: `Bearer ${process.env.X_API_BEARER_TOKEN}` };
  const all = [];
  let nextToken;
  let pages = 0;

  do {
    const url = new URL("https://api.x.com/2/tweets/search/recent");
    url.searchParams.set("query", query);
    url.searchParams.set("max_results", "100");
    if (nextToken) url.searchParams.set("next_token", nextToken);

    const res = await fetch(url, { headers });
    const data = await res.json();
    all.push(...(data.data ?? []));
    nextToken = data.meta?.next_token;
    pages += 1;
  } while (nextToken && pages < maxPages);

  return all;
}

Isso funciona quando você quer dependências mínimas ou está depurando o comportamento da API. A desvantagem é óbvia: você trata paginação, códigos de erro, rate limit e retentativas por conta própria. Para um pipeline de produção, você acabará reconstruindo um wrapper. Esse método ainda precisa de uma conta de desenvolvedor do X e créditos de pagamento por uso, com um bearer token para acesso somente leitura.

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

Se um projeto 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 de volta. Para uma carga somente leitura, ela remove a maior parte da configuração da API oficial e transforma a coleta de dados em chamadas HTTP simples.

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

Obtenha um perfil de usuário:

const headers = { ApiKey: process.env.SORSA_API_KEY };

const res = await fetch("https://api.sorsa.io/v3/info?username=elonmusk", { headers });
const user = await res.json();

console.log(`@${user.username}: ${user.display_name}`);
console.log(`Followers: ${user.followers_count}`);

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:

const res = await fetch("https://api.sorsa.io/v3/search-tweets", {
  method: "POST",
  headers: { ApiKey: process.env.SORSA_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({ query: "nodejs lang:en", order: "latest" }),
});

const { tweets, next_cursor } = await res.json();

for (const tweet of tweets) {
  console.log(`${tweet.likes_count} likes: ${tweet.full_text}`);
}

Para consultas complexas, combine operadores como você faria na busca avançada; a lista completa está na nossa referência de operadores de busca, e o endpoint busca no arquivo completo de tweets em vez de só nos últimos 7 dias. Há um guia dedicado de busca de tweets via API se você quiser a versão a fundo.

Puxe uma lista de seguidores. Uma requisição retorna até 200 perfis:

const headers = { ApiKey: process.env.SORSA_API_KEY };

const res = await fetch("https://api.sorsa.io/v3/followers?username=elonmusk", { headers });
const { users, next_cursor } = await res.json();

console.log(`Got ${users.length} followers in one request`);

Busque até 100 tweets em uma única chamada com o endpoint de lote, que retorna objetos completos de tweet (métricas e autor incluídos) e conta como uma requisição:

const res = await fetch("https://api.sorsa.io/v3/tweet-info-bulk", {
  method: "POST",
  headers: { ApiKey: process.env.SORSA_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    tweet_links: ["1782368585664626774", "1782368585664626775"],
  }),
});

const { tweets } = await res.json();

Cada resposta de tweet carrega o perfil completo do autor e as métricas públicas (likes_count, retweet_count, reply_count, quote_count, view_count), então ler métricas de tweet via API e buscar listas de seguidores não custa chamadas extras. O cabeçalho é ApiKey, a URL base é https://api.sorsa.io/v3, e os formatos de resposta batem com a documentação da API exatamente.

Dá para chamar a API do X do navegador? {#can-you-call-the-x-api-from-the-browser}

Não. Você não pode chamar a API do X com segurança direto do JavaScript do lado do cliente, porque toda requisição autenticada precisa de um bearer token ou segredo OAuth, e qualquer coisa no código do navegador fica visível para quem abrir as dev tools. As chamadas também falham cross-origin na maioria dos casos. A correção padrão é um pequeno proxy do lado do servidor que segura as credenciais e expõe só os dados de que o seu front-end precisa.

O formato é simples. Uma função serverless na Vercel, no Cloudflare Workers, na Netlify ou em qualquer host lê o segredo de uma variável de ambiente, chama a API do lado do servidor e retorna JSON limpo ao navegador:

// /api/tweets  (serverless function, runs on the server, not in the browser)
export default async function handler(req, res) {
  const r = await fetch("https://api.sorsa.io/v3/search-tweets", {
    method: "POST",
    headers: { ApiKey: process.env.SORSA_API_KEY, "Content-Type": "application/json" },
    body: JSON.stringify({ query: req.query.q, order: "latest" }),
  });
  const data = await r.json();
  res.status(200).json(data);
}

O navegador então chama o seu próprio endpoint /api/tweets, nunca o provedor de dados, e a chave nunca sai do servidor. O XDK oficial de TypeScript tecnicamente roda no navegador e no React Native, mas isso não muda a regra: enviar um bearer token para o código do cliente o expõe, então mantenha as credenciais atrás de um endpoint de servidor, seja qual for o cliente que você use.

Construindo um coletor de dados em Node.js {#building-a-data-collector-in-nodejs}

Um coletor de produção precisa de três coisas além de uma única chamada: paginação por cursor para passar da primeira página, uma trava de páginas para uma consulta ampla não esgotar a sua cota, e uma retentativa em rate limits. Aqui vai um coletor somente leitura completo contra o endpoint de busca, paginando com next_cursor e recuando em um 429.

async function collectTweets(query, maxPages = 20) {
  const endpoint = "https://api.sorsa.io/v3/search-tweets";
  const headers = { ApiKey: process.env.SORSA_API_KEY, "Content-Type": "application/json" };
  const collected = [];
  let cursor;
  let pages = 0;

  while (pages < maxPages) {
    const body = { query, order: "latest" };
    if (cursor) body.next_cursor = cursor;

    const res = await fetch(endpoint, {
      method: "POST",
      headers,
      body: JSON.stringify(body),
    });

    // Flat 20 requests per second limit: on a 429, wait a second and retry the same page
    if (res.status === 429) {
      await new Promise((r) => setTimeout(r, 1000));
      continue;
    }

    const data = await res.json();
    collected.push(...(data.tweets ?? []));

    cursor = data.next_cursor;
    pages += 1;
    if (!cursor) break;
  }

  return collected;
}

// Usage
const tweets = await collectTweets("from:OpenAI -is:retweet");
console.log(`Collected ${tweets.length} tweets`);

Quando reconstruímos os nossos próprios coletores contra o endpoint de busca, a variável que de fato importou não foi a biblioteca, mas quantos recursos cada chamada retornava e como a cobrança reagia a isso. Um limite fixo por requisição é mais simples de acompanhar que janelas por endpoint: você espera um segundo em um 429 em vez de rastrear um timestamp de reset. A mecânica de cursores está coberta no guia de paginação, e o lado oficial está na nossa referência de rate limits da API do X. O mesmo loop troca de forma limpa para /user-tweets, /followers ou /mentions mudando o endpoint e o corpo.

Comparação: quatro métodos, lado a lado {#comparison-four-methods-side-by-side}

Os quatro métodos se dividem de forma limpa em dois eixos: se você pode escrever e como é cobrado. As três 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 pelo XDK ou pela twitter-api-v2. 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 inteiramente 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 a 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 projeto 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 uma API key, um API secret, um bearer token e access tokens. 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. As chaves novas vêm com 100 requisições grátis, então não há nada para comprar antes da sua primeira chamada.

Guarde qualquer credencial em uma variável de ambiente, nunca no código-fonte:

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

Se você está movendo código existente da API oficial, o guia de migração 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: movendo um coletor Node da API oficial {#in-practice-moving-a-node-collector-off-the-official-api}

Uma startup de análise social com cerca de 12 pessoas chegou até nós rodando um coletor Node noturno construído sobre a twitter-api-v2. O código estava bom; a conta, não. Cada execução pagava por post lido e por perfil de autor, e o teto mensal de 2 milhões de leituras de posts obrigava a equipe a vigiar 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 e o agendamento, substituíram o cliente twitter-api-v2 pelo padrão de fetch puro contra 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 Twitter para Node.js?

Sim. No fim de 2025, o X lançou um XDK oficial de TypeScript, instalado com npm install @xdevplatform/xdk, que roda no Node.js, em navegadores e no React Native. É o primeiro cliente JavaScript oficial que o X publicou, com modelos tipados, paginação automática e streaming. A veterana biblioteca de comunidade twitter-api-v2 continua uma alternativa forte e suporta a API v1.1 e a v2.

Qual é o melhor pacote npm para a API do Twitter?

Para a maioria dos projetos Node, a twitter-api-v2 é a melhor escolha de uso geral: é madura, totalmente tipada, suporta fluxos de leitura, escrita e DM, e trata paginação e retentativas de rate limit. Para suporte de primeira parte que segue a especificação da API, use o XDK oficial de TypeScript. Os antigos pacotes twit e twitter estão sem manutenção desde 2017 e só falam a API v1.1, então evite-os.

Dá para usar a API do Twitter em JavaScript do lado do cliente?

Não, não diretamente. Toda chamada autenticada à API do X precisa de um bearer token ou segredo OAuth, e qualquer credencial colocada no código do navegador fica exposta para quem inspeciona a página, além de a maioria das chamadas falhar cross-origin. O padrão comum é um pequeno proxy do lado do servidor, como uma função serverless, que segura o segredo, chama a API e retorna só os dados de que o seu front-end precisa.

Como obter tweets em Node.js 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 faz um POST de uma consulta ao endpoint de busca, tudo de uma única chamada fetch. Não há fluxo OAuth, análise de app nem compra de crédito, e o JSON mapeia direto para objetos JavaScript com o perfil do autor incluído em cada tweet.

Quanto a API do Twitter custa para um app Node.js 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á cerca de US$ 0,02 por 1.000 tweets e cerca de US$ 0,01 por 1.000 perfis nos endpoints em lote, em planos fixos a partir de US$ 49 por mês. Toda chave nova inclui 100 requisições grátis, sem cartão, para você testar antes de pagar.

Como lidar com rate limits da API do Twitter em Node.js?

A API oficial limita requisições por janela de 15 minutos (tipicamente de 300 a 900, conforme o endpoint) e retorna um 429 com um cabeçalho de reset quando você bate em um. A twitter-api-v2 e o XDK recuam automaticamente; com fetch puro você lê os cabeçalhos e espera antes de repetir. Uma API de taxa fixa como a Sorsa usa um limite por segundo (20 requisições por segundo), então, em um 429, você espera um segundo e repete a mesma chamada.

A twitter-api-v2 suporta a API do X v2?

Sim. A twitter-api-v2 suporta a API v1.1 e a v2, com clientes separados de somente leitura, leitura e escrita e DM, e tipagens completas de TypeScript. Ela funciona com a autenticação atual por bearer token e OAuth. Ela exige uma conta de desenvolvedor paga do X com créditos comprados, já que não há plano gratuito na API oficial no modelo de pagamento por uso.

Primeiros passos {#getting-started}

Escolha um método e rode um dos exemplos acima.

• Dados somente leitura: pegue uma chave no painel da Sorsa, defina-a como SORSA_API_KEY e rode qualquer trecho do Método 4. Toda chave nova inclui 100 requisições grátis, então esses exemplos rodam antes de você comprar qualquer coisa. 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 do XDK ou da twitter-api-v2 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.

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. Os detalhes do XDK oficial (o pacote @xdevplatform/xdk, o suporte a Node.js 16+, a paginação automática, o streaming e os três métodos de autenticação) vêm da documentação do XDK de TypeScript do X e do seu anúncio de lançamento. As capacidades da twitter-api-v2 (os clientes de somente leitura, leitura e escrita e DM, e os métodos userByUsername, search e followers) foram checadas contra a documentação do pacote. 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 que mudam, como contagens de download e estrelas no GitHub, são descritos em vez de citados; para um preço atual, a documentação no produto é a fonte da verdade.