API de Twitter con Node.js: obtener datos de X en 2026 (guía completa)

Por Sorsa Editorial

Publicado en junio de 2026, actualizado en julio de 2026: refleja el precio de pago por uso vigente de X (incluidos los cambios de costo de escritura de abril de 2026) y los XDKs oficiales de Python y TypeScript que X lanzó a finales de 2025.

Actualizado en julio de 2026: refrescado el precio de Sorsa a las tarifas por lotes por cada 1,000 y agregada la oferta inicial de 100 solicitudes gratis.

Conclusión clave: Hay cuatro formas prácticas de obtener datos de Twitter/X en Node.js en 2026: el XDK oficial de TypeScript, la librería twitter-api-v2, fetch simple con un bearer token, o una API REST de terceros de solo lectura. Las vías oficiales cobran por recurso y requieren credenciales OAuth; una API de solo clave conviene al trabajo intensivo en lecturas.

Si buscaste "twitter api nodejs" esperando un npm install rápido y un fragmento que devuelva tweets, el panorama de 2026 es más enredado de lo que sugieren los tutoriales viejos. X cambió su modelo de precios, cambió cómo se cobran las lecturas y, por primera vez, publicó un SDK oficial para JavaScript. La mayoría de las guías de Node que rankean todavía enseñan a publicar por una cuenta de desarrollador de pago y no se han puesto al día con nada de eso.

Nosotros construimos y operamos Sorsa API, una API alternativa de Twitter/X, así que la vía de solo lectura es la que mejor conocemos. Devuelve perfiles, tweets, resultados de búsqueda y seguidores como JSON limpio desde una sola llamada fetch, con una clave API en el encabezado ApiKey, sin flujo OAuth y sin aprobación de cuenta de desarrollador que esperar. En trabajo intensivo en lecturas resulta hasta unas 50 veces más barata que la API oficial de X, mantiene 20 solicitudes por segundo en todos los planes, y sale en unos $0.02 por cada 1,000 tweets en sus endpoints por lotes, con planes de tarifa plana desde $49 al mes. Cada clave nueva incluye 100 solicitudes gratis, sin tarjeta, así que puedes probarla antes de pagar. No todo proyecto encaja en ese molde: unos necesitan publicar, otros necesitan la API oficial por cumplimiento, y otros equipos solo quieren entender los internos. Esta guía cubre los cuatro métodos con código funcional de Node.js, precio vigente y un recolector completo que pagina y retrocede ante los límites de tasa. También puedes probar llamadas sin escribir código en el playground.

Contenido

• Qué cambió: la API de X y las herramientas de Node.js en 2026
• La mejor librería para la API de X en Node.js
• ¿Qué enfoque deberías usar?
• Método 1: el XDK oficial de TypeScript
• Método 2: twitter-api-v2
• Método 3: fetch simple con un bearer token
• Método 4: una API REST de solo lectura
• ¿Puedes llamar a la API de X desde el navegador?
• Construir un recolector de datos en Node.js
• Comparación: cuatro métodos, lado a lado
• Cómo obtener tus credenciales de API
• En la práctica: mover un recolector de Node de la API oficial
• Preguntas frecuentes
• Cómo empezar

Qué cambió: la API de X y las herramientas de Node.js en 2026 {#what-changed-the-x-api-and-nodejs-tooling-in-2026}

Tres cosas cambiaron para quienes desarrollan en Node desde 2023. La API de X pasó al cobro de pago por uso sin nivel gratuito y ahora cobra por recurso leído. Escribir se encareció tras la actualización de abril de 2026. Y X publicó sus primeros SDKs oficiales, incluido un paquete de TypeScript que corre en Node, junto a la longeva librería de comunidad twitter-api-v2.

El pago por uso es lo predeterminado. No hay nivel gratuito ni plan Basic de $100 para registros nuevos. Compras créditos por adelantado y pagas por recurso: $0.005 por lectura de post, $0.010 por perfil de usuario y $0.010 por cada registro de seguidor o seguido. Leer los datos de tu propia cuenta cuesta $0.001 por recurso, pero esa tarifa no aplica cuando lees otras cuentas. También hay un tope duro de 2 millones de lecturas de posts al mes en cuentas estándar. Para el desglose completo, consulta nuestro desglose de precios de la API de X y la explicación de por qué subió el precio de la API de X.

Escribir se encareció. Tras la actualización de abril de 2026, un post estándar cuesta $0.015 por solicitud y un post que contiene una URL cuesta $0.20. Las acciones de follow, like y cita de post se quitaron de los niveles de autoservicio y ahora requieren un contrato Enterprise. Un bot de follow-back o un auto-liker ya no es posible en una cuenta estándar de pago por uso.

X lanzó SDKs oficiales. A finales de 2025 X anunció XDKs de primera parte (X Developer Kit) para Python y TypeScript, confirmado en su anuncio para desarrolladores. El XDK de TypeScript es el primer cliente oficial de JavaScript que X ha publicado. Envuelve los endpoints v2 con modelos tipados, maneja la paginación y admite streaming.

twitter-api-v2 todavía funciona. La librería de comunidad twitter-api-v2 admite v1.1 y v2, corre flujos de lectura, escritura y DM, y sigue siendo el wrapper de Node más usado. El código existente sigue funcionando con credenciales vigentes.

Las librerías viejas están muertas. Los paquetes twit y twitter en npm no han visto una actualización significativa desde 2017 y solo hablan v1.1. Si un tutorial te dice npm install twit, está desactualizado.

La mejor librería para la API de X en Node.js {#the-best-library-for-the-x-api-in-nodejs}

Para la mayoría de los proyectos de Node, twitter-api-v2 es la mejor librería de propósito general: es madura, completamente tipada y admite flujos de lectura, escritura y DM por bearer token y OAuth. Si quieres una herramienta de primera parte que siga la especificación de la API exactamente, usa el XDK oficial de TypeScript. Para recolección de datos de solo lectura, muchos equipos se saltan las librerías y llaman a una API REST de terceros con fetch simple, que elimina OAuth por completo.

Así se comparan las opciones principales.

Cada opción que apunta a la API oficial cobra a través del precio de pago por uso de X, así que el costo es idéntico llames a X con el XDK, con twitter-api-v2 o con fetch crudo. La variable que de verdad controlas es cuántos recursos extraes, que es donde los endpoints por lotes y una API de tarifa plana cambian las cuentas.

¿Qué enfoque deberías usar? {#which-approach-should-you-use}

Elige la vía antes de escribir código. Para trabajo de lectura y escritura con soporte oficial, usa el XDK o twitter-api-v2. Para datos de solo lectura a volumen con configuración mínima, una API REST de terceros elimina OAuth y la cola de aprobación. Para control total sin dependencias, fetch simple más un bearer token funciona. La elección es en su mayoría lectura contra escritura y cuánto volumen extraes.

Si tu proyecto solo lee datos públicos, una API de terceros elimina el baile de OAuth: una clave en un encabezado y empiezas a extraer datos, sin solicitud de cuenta de desarrollador y sin compra de créditos. Si necesitas publicar o correr acciones de escritura, la API oficial de X a través del XDK o twitter-api-v2 es la vía; ningún proveedor de terceros publica en tu nombre. ¿Trabajas en Python? Consulta la versión en Python de esta guía.

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

El XDK de TypeScript es el primer SDK oficial de JavaScript de X. Envuelve la API v2 con modelos tipados, maneja la paginación, admite streaming y funciona en Node.js, navegadores y React Native. Requiere Node.js 16 o más nuevo y admite autenticación por bearer token, OAuth 2.0 PKCE y OAuth 1.0a.

Instálalo:

npm install @xdevplatform/xdk

Un bearer token alcanza para leer datos públicos. Consulta un 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();

El SDK trae un paginador para los endpoints de lista. Extrae los seguidores de un usuario con paginación 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);
}

El XDK también expone client.posts para búsqueda y cronologías y client.stream para feeds en tiempo real. Es la elección correcta cuando quieres soporte oficial, necesitas acceso de escritura y estás empezando una implementación nueva. Las contrapartidas: el SDK es joven (v0.5 a febrero de 2026), los docs todavía son delgados, y pagas el precio por recurso de X en cada llamada.

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

twitter-api-v2 ha sido el cliente de Node por defecto durante años. Admite v1.1 y v2, expone clientes separados de solo lectura, lectura-escritura y DM, y maneja la paginación y los encabezados de límite de tasa. Es el equivalente de Node más cercano a Tweepy en Python.

Instálala desde npm:

npm install twitter-api-v2

Crea un cliente de solo lectura a partir de un bearer token y consulta un 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);

Busca los últimos 7 días. El método search devuelve un paginador que puedes iterar directamente:

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

Trae los seguidores de un usuario como paginador:

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

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

twitter-api-v2 es la opción segura por defecto para la mayoría de quienes desarrollan en Node: probada en batalla, bien documentada y con una respuesta para casi cualquier problema. Las contrapartidas coinciden con el XDK: todavía necesitas una cuenta de desarrollador de X de pago, todavía pagas por recurso, y los límites de tasa se heredan de la API oficial (típicamente 300 a 900 solicitudes por ventana de 15 minutos, según el endpoint).

Método 3: fetch simple con un bearer token {#method-3-plain-fetch-with-a-bearer-token}

Sin librería, sin wrapper. Node 18 y más nuevo traen un fetch global, así que puedes llamar a la API de X v2 directamente con un bearer token y cero dependencias. Esto conviene a quienes quieren control total sobre las solicitudes, o que trabajan donde instalar paquetes está restringido.

Busca tweets recientes:

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

La API oficial pagina con un next_token en el meta de la respuesta. Recorre cada resultado con un guardián para que una consulta amplia no se desboque:

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

Esto funciona cuando quieres dependencias mínimas o estás depurando el comportamiento de la API. La desventaja es obvia: tú manejas la paginación, los códigos de error, el límite de tasa y los reintentos. Para un pipeline de producción terminarás reconstruyendo un wrapper. Este método todavía necesita una cuenta de desarrollador de X y créditos de pago por uso, con un bearer token para acceso de solo lectura.

Método 4: una API REST de solo lectura {#method-4-a-read-only-rest-api}

Si un proyecto solo lee datos públicos de Twitter, una API REST de terceros se salta la API oficial por completo: sin OAuth, sin paso de solicitud, sin flujo de compra de créditos, solo una clave en un encabezado y JSON de vuelta. Para una carga de solo lectura, elimina la mayor parte de la configuración de la API oficial y convierte la recolección de datos en llamadas HTTP simples.

Esta es la vía práctica para obtener datos de X sin una cuenta de desarrollador. Así se ve con Sorsa, usando nada más que fetch.

Obtén un perfil de usuario:

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

Busca tweets con el conjunto completo de operadores web. El endpoint de búsqueda devuelve unos 20 tweets por página y un next_cursor para la siguiente:

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 complejas, combina operadores como lo harías en la búsqueda avanzada; la lista completa está en nuestra referencia de operadores de búsqueda, y el endpoint busca en el archivo completo de tweets en lugar de solo los últimos 7 días. Hay una guía dedicada de cómo buscar tweets por API si quieres la versión a fondo.

Extrae una lista de seguidores. Una solicitud devuelve hasta 200 perfiles:

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`);

Trae hasta 100 tweets en una sola llamada con el endpoint por lotes, que devuelve objetos completos de tweets (métricas y autor incluidos) y cuenta como una solicitud:

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 respuesta de tweet carga el perfil completo del autor y las métricas públicas (likes_count, retweet_count, reply_count, quote_count, view_count), así que leer métricas de tweets por API y traer listas de seguidores no cuesta llamadas extra. El encabezado es ApiKey, la URL base es https://api.sorsa.io/v3, y las formas de respuesta coinciden exactamente con la documentación de la API.

¿Puedes llamar a la API de X desde el navegador? {#can-you-call-the-x-api-from-the-browser}

No. No puedes llamar de forma segura a la API de X directamente desde JavaScript del lado del cliente, porque cada solicitud autenticada necesita un bearer token o un secreto OAuth, y cualquier cosa en el código del navegador es visible para quien abra las herramientas de desarrollo. Las llamadas además fallan cross-origin en la mayoría de los casos. El arreglo estándar es un pequeño proxy del lado del servidor que sostiene las credenciales y expone solo los datos que tu front end necesita.

La forma es simple. Una función serverless en Vercel, Cloudflare Workers, Netlify o cualquier host lee el secreto de una variable de entorno, llama a la API del lado del servidor y devuelve JSON limpio al 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);
}

El navegador entonces llama a tu propio endpoint /api/tweets, nunca al proveedor de datos, y la clave nunca sale del servidor. El XDK oficial de TypeScript técnicamente corre en el navegador y en React Native, pero eso no cambia la regla: enviar un bearer token al código del cliente lo expone, así que mantén las credenciales detrás de un endpoint del servidor sin importar qué cliente uses.

Construir un recolector de datos en Node.js {#building-a-data-collector-in-nodejs}

Un recolector de producción necesita tres cosas más allá de una sola llamada: paginación por cursor para pasar de la primera página, un guardián de páginas para que una consulta amplia no agote tu cuota, y un reintento ante límites de tasa. Aquí hay un recolector de solo lectura completo contra el endpoint de búsqueda, paginando con next_cursor y retrocediendo ante un 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`);

Cuando reconstruimos nuestros propios recolectores contra el endpoint de búsqueda, la variable que de verdad importó no fue la librería sino cuántos recursos devolvía cada llamada y cómo reaccionaba el cobro a eso. Un límite fijo por segundo es más simple de ritmar que las ventanas por endpoint: esperas un segundo ante un 429 en lugar de rastrear una marca de tiempo de reinicio. La mecánica de los cursores se cubre en la guía de paginación, y el lado oficial está en nuestra referencia de límites de tasa de la API de X. El mismo bucle cambia con limpieza a /user-tweets, /followers o /mentions cambiando el endpoint y el cuerpo.

Comparación: cuatro métodos, lado a lado {#comparison-four-methods-side-by-side}

Los cuatro métodos se dividen con limpieza en dos ejes: si puedes escribir, y cómo te cobran. Las tres vías de la API oficial necesitan una cuenta de desarrollador y cobran por recurso. Una API de solo lectura cambia el acceso de escritura por una sola clave y cobro de tarifa plana por solicitud.

La división te dice cuál elegir: si necesitas publicar o correr acciones de escritura, ese es territorio de la API oficial a través del XDK o twitter-api-v2. Para acceso intensivo en lecturas a un precio de tarifa plana y predecible, una API de solo lectura es la vía más barata y simple, y devuelve los mismos datos públicos.

La brecha de costo en lecturas viene enteramente de la unidad de cobro. La API oficial cobra por cada post y cada perfil de autor en una respuesta; una API de tarifa plana cobra una solicitud sin importar cuántos elementos devuelva.

Para trabajo intensivo en lecturas el modelo por recurso es la forma cara de hacer un trabajo simple, y por eso la tarifa plana por solicitud gana en cuanto cruzas unas 10,000 lecturas al mes. Las escrituras son la excepción: publicar y los DMs viven solo en la API oficial, así que un proyecto pesado en escrituras pertenece ahí sin importar el costo de lectura.

Cómo obtener tus credenciales de API {#how-to-get-your-api-credentials}

Para la API oficial, crea una cuenta de desarrollador en developer.x.com, acepta los términos de desarrollador, describe tu caso de uso y crea un Project y una App para generar una clave API, un API secret, un bearer token y access tokens. Compra créditos antes de tu primera llamada, porque no hay nivel gratuito. Para una API de terceros de solo lectura, regístrate, genera una clave y pásala en un encabezado, sin paso de solicitud ni aprobación. Las claves nuevas vienen con 100 solicitudes gratis, así que no hay nada que comprar antes de tu primera llamada.

Guarda cualquiera de las credenciales en una variable de entorno, nunca en el código fuente:

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

Si estás moviendo código existente de la API oficial, la guía de migración mapea los endpoints oficiales y los nombres de campo a sus equivalentes de tarifa plana para que cambies el transporte sin reescribir la lógica.

En la práctica: mover un recolector de Node de la API oficial {#in-practice-moving-a-node-collector-off-the-official-api}

Una startup de analítica social de unas 12 personas llegó a nosotros corriendo un recolector nocturno de Node construido sobre twitter-api-v2. El código estaba bien; la factura no. Cada corrida pagaba por lectura de post y por perfil de autor, y el tope mensual de 2 millones de lecturas de posts obligaba al equipo a vigilar el volumen a medida que crecía su lista de cuentas rastreadas.

El arreglo fue un cambio de transporte, no una reescritura. Conservaron la lógica de recolección y la programación, reemplazaron el cliente de twitter-api-v2 por el patrón de fetch simple contra los endpoints de búsqueda y /followers, y dejaron OAuth por un único encabezado ApiKey. Como cada solicitud devuelve hasta 20 tweets o 200 perfiles de seguidores en lugar de cobrar por recurso, la misma extracción nocturna costó una fracción de lo que costaba, unas 30 a 50 veces menos en las partes intensivas en lecturas, y un límite por segundo reemplazó al tope mensual como lo único contra lo que ritmar. Para una carga de solo lectura, el modelo por recurso había sido la forma cara de hacer un trabajo simple.

Preguntas frecuentes {#faq}

¿Hay un SDK oficial de la API de Twitter para Node.js?

Sí. A finales de 2025 X lanzó un XDK oficial de TypeScript, instalado con npm install @xdevplatform/xdk, que corre en Node.js, navegadores y React Native. Es el primer cliente oficial de JavaScript que X ha publicado, con modelos tipados, paginación automática y streaming. La madura librería de comunidad twitter-api-v2 sigue siendo una alternativa fuerte y admite la API v1.1 y v2.

¿Cuál es el mejor paquete de npm para la API de Twitter?

Para la mayoría de los proyectos de Node, twitter-api-v2 es la mejor opción de propósito general: es madura, completamente tipada, admite flujos de lectura, escritura y DM, y maneja la paginación y los reintentos por límite de tasa. Para soporte de primera parte que sigue la especificación de la API, usa el XDK oficial de TypeScript. Los viejos paquetes twit y twitter están sin mantenimiento desde 2017 y hablan solo la API v1.1, así que evítalos.

¿Se puede usar la API de Twitter en JavaScript del lado del cliente?

No, no directamente. Cada llamada autenticada a la API de X necesita un bearer token o un secreto OAuth, y cualquier credencial colocada en el código del navegador queda expuesta a quien inspeccione la página, más la mayoría de las llamadas fallan cross-origin. El patrón estándar es un pequeño proxy del lado del servidor, como una función serverless, que sostiene el secreto, llama a la API y devuelve solo los datos que tu front end necesita.

¿Cómo obtener tweets en Node.js sin una cuenta de desarrollador?

Llama a una API REST de terceros de solo lectura. Con Sorsa, te registras, obtienes una clave API, la pasas en el encabezado ApiKey y envías por POST una consulta al endpoint de búsqueda, todo desde una sola llamada fetch. No hay flujo OAuth, ni revisión de app, ni compra de créditos, y el JSON mapea directo a objetos de JavaScript con el perfil del autor incluido en cada tweet.

¿Cuánto cuesta la API de Twitter para una app de Node.js en 2026?

En la API oficial de X pagas por recurso: $0.005 por lectura de post, $0.010 por perfil de usuario, $0.015 por post estándar y $0.20 por un post con URL, con un tope mensual de 2 millones de lecturas de posts. Una búsqueda que devuelve 20 tweets cuesta $0.30 una vez incluidos los perfiles de autor. Sorsa cobra por solicitud, lo que sale en unos $0.02 por cada 1,000 tweets y unos $0.01 por cada 1,000 perfiles en sus endpoints por lotes, en planes de tarifa plana desde $49 al mes. Cada clave nueva incluye 100 solicitudes gratis, sin tarjeta, así que puedes probar antes de pagar.

¿Cómo manejar los límites de tasa de la API de Twitter en Node.js?

La API oficial limita las solicitudes por ventana de 15 minutos (típicamente 300 a 900 según el endpoint) y devuelve un 429 con un encabezado de reinicio cuando llegas a uno. twitter-api-v2 y el XDK retroceden automáticamente; con fetch simple lees los encabezados y esperas antes de reintentar. Una API de tarifa plana como Sorsa usa un límite por segundo (20 solicitudes por segundo), así que ante un 429 esperas un segundo y reintentas la misma llamada.

¿twitter-api-v2 admite la API de X v2?

Sí. twitter-api-v2 admite la API v1.1 y v2, con clientes separados de solo lectura, lectura-escritura y DM y tipados completos de TypeScript. Funciona con la autenticación vigente por bearer token y OAuth. Sí requiere una cuenta de desarrollador de X de pago con créditos comprados, porque no hay nivel gratuito en la API oficial bajo el modelo de pago por uso.

Cómo empezar {#getting-started}

Elige un método y corre uno de los ejemplos de arriba.

• Datos de solo lectura: toma una clave del panel de Sorsa, fíjala como SORSA_API_KEY y corre cualquier fragmento del Método 4. Cada clave nueva incluye 100 solicitudes gratis, así que estos ejemplos corren antes de comprar nada. Los datos estructurados de X aterrizan en tu terminal en menos de un minuto, y el inicio rápido recorre la primera llamada. Los planes y límites están en la página de precios.
• Leer y escribir: crea una cuenta de desarrollador en developer.x.com, compra créditos y corre los ejemplos del XDK o de twitter-api-v2 con tu bearer token.
• Comparar proveedores: para una mirada más amplia a las opciones de solo lectura, consulta la comparación de alternativas a la API de Twitter.

Revisado por Keksich, fundador de Sorsa, especialista en marketing e investigador de la API de X.

Cómo verificamos esta guía {#how-we-verified-this-guide}

Escribimos y verificamos esta guía en junio de 2026 mientras operábamos la API a diario. Los detalles del XDK oficial (el paquete @xdevplatform/xdk, el soporte de Node.js 16+, la paginación automática, el streaming y los tres métodos de autenticación) salen de la documentación del XDK de TypeScript de X y de su anuncio de lanzamiento. Las capacidades de twitter-api-v2 (los clientes de solo lectura, lectura-escritura y DM, y los métodos userByUsername, search y followers) se revisaron contra la documentación de su paquete. El precio de la API de X refleja el modelo de pago por uso vigente incluidos los cambios de costo de escritura de abril de 2026. El comportamiento de los endpoints de Sorsa, el agrupamiento por solicitud y el precio de los planes salen de la documentación de Sorsa API; más sobre el equipo en nuestra página Acerca de. Los números que se mueven, como los conteos de descargas y las estrellas de GitHub, se describen en lugar de citarse; para un precio vigente los docs dentro del producto son la fuente de verdad.