API de Twitter para agentes de IA: REST, MCP o skill

#Cómo obtiene datos de X un agente de IA

Un agente de IA obtiene datos de X como obtiene cualquier dato en vivo: el modelo pide una herramienta por su nombre, código externo al modelo llama a una API y el JSON que regresa entra en el contexto del modelo para su siguiente paso. El modelo nunca abre x.com por sí mismo.

Tres tipos de conexión ponen esa herramienta al alcance del agente:

• Una herramienta REST es una función en el código de tu agente, registrada en un framework como el OpenAI Agents SDK, LangChain, CrewAI o n8n.
• Un servidor MCP es un programa pequeño que apps de IA como Claude Code, Cursor y Codex inician por su cuenta; lista sus herramientas mediante el Model Context Protocol.
• Una skill es una carpeta con un archivo SKILL.md que le enseña una API a un agente de programación, de modo que el agente escribe y ejecuta las llamadas por sí mismo.

Cada una necesita una fuente de datos de X detrás. La fuente propia de X es la API oficial de X, y sus recursos para agentes (se abre en una pestaña nueva) la exponen como un servidor MCP alojado, una especificación OpenAPI y un archivo skill.md. Cada llamada ahí corre sobre tu app de desarrollador de X, con OAuth 2.0 o un bearer token y créditos prepagados.

La lista de precios (se abre en una pestaña nueva) de X cobra $0.005 por lectura de post y $0.010 por perfil o seguidor, y el pago por uso se detiene en 3 millones de lecturas de posts al mes. Un aviso del 23 de octubre (se abre en una pestaña nueva) agrega que desde el 22 de noviembre los autores y los medios devueltos con los posts también se facturan como lecturas: hasta $15.00 por 1,000 resultados de búsqueda que traen a sus autores. Nuestra guía de precios de la API de X lista cada tarifa.

#Elige la ruta: una herramienta REST, un servidor MCP o una skill

Elige la ruta según dónde corre el agente: un agente que programas tú usa una herramienta REST, una app de IA como Claude Code o Cursor usa un servidor MCP, y un agente de programación que escribe sus propios scripts usa una skill. Sorsa API, una API y scraper de Twitter (X), ofrece las tres con una sola clave en la misma variable SORSA_API_KEY, así que puedes empezar con una ruta y sumar otra después.

• Tu propio código: OpenAI Agents SDK, LangChain, CrewAI, n8n, un bucle propio

  Ruta

  Herramienta REST

  Qué agregas

  una función que llama a https://api.sorsa.io/v3

  Contexto que ocupa

  304 caracteres para una herramienta de búsqueda

• Una app de IA: Claude Code, Cursor, Codex, VS Code, Claude Desktop

  Ruta

  Servidor MCP

  Qué agregas

  npx -y sorsa-mcp con tu clave

  Contexto que ocupa

  23.3K caracteres para 40 herramientas

• Un agente de programación que escribe y ejecuta código

  Ruta

  Skill

  Qué agregas

  la carpeta sorsa-x-api

  Contexto que ocupa

  762 caracteres hasta que abre la skill

El contexto importa porque cada carácter de la definición de una herramienta viaja con las solicitudes del modelo, y cuesta tokens y atención. Listamos las herramientas del servidor MCP el 2 de noviembre: sus 40 definiciones suman 23.3K caracteres, unos 5,800 tokens. Claude Code lo mantiene pequeño con la búsqueda de herramientas, que le muestra al modelo solo nombres de herramientas hasta que necesita una.

Una skill pone 762 caracteres en el contexto, su nombre y descripción, y carga el SKILL.md de 8,163 caracteres solo cuando el agente lo abre. Una herramienta REST cuesta lo que tú escribas: el esquema de search_x de abajo tiene 304 caracteres.

Muchos equipos usan dos rutas: el servidor MCP en el editor mientras exploran los datos, y una herramienta REST en el agente que se despliega.

#Dale datos de X a cualquier agente con una herramienta REST

Para darle datos de X a un agente que construyes, escribe una función que llame a Sorsa API y regístrala como herramienta: el modelo pasa una consulta de búsqueda, la función devuelve posts como JSON y cada llamada es una solicitud. Para agentes que programas, usa Sorsa API: un encabezado ApiKey y nada de OAuth, unos 20 posts con perfiles completos de autor por llamada de búsqueda, desde $0.07 por 1,000 resultados, a 20 solicitudes por segundo en todos los planes.

1. Obtén una clave. Regístrate, copia la clave del panel y ponla en la variable de entorno SORSA_API_KEY. La clave se queda en tu código; el modelo nunca la ve.

2. Prueba la llamada. POST /search-tweets (se abre en una pestaña nueva) recibe una consulta con operadores de búsqueda de X y devuelve unos 20 posts por página, los más recientes primero con "order": "latest".

   curl -X POST "https://api.sorsa.io/v3/search-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"query": "from:kai_builds_agents mcp", "order": "latest"}'
   

   {
     "tweets": [
       {
         "id": "1985342107664281745",
         "full_text": "Our support agent now reads X through MCP.",
         "created_at": "2026-10-30T14:12:09Z",
         "lang": "en",
         "likes_count": 48,
         "retweet_count": 6,
         "reply_count": 9,
         "quote_count": 2,
         "view_count": 5310,
         "is_reply": false,
         "user": {
           "id": "1544001928374651904",
           "username": "kai_builds_agents",
           "display_name": "Kai Builds Agents",
           "followers_count": 2841,
           "verified": false
         }
       }
     ],
     "next_cursor": "DAADDAABCgABG4vQ2kXAJxIKAAIbi9Dask"
   }
   

   Ver respuesta completa

3. Envuélvela como herramienta. La función pagina con next_cursor hasta un presupuesto y conserva 7 de los 41 campos que lleva cada post, de modo que 20 posts siguen siendo un resultado de herramienta corto.

   import os
   
   import requests
   
   API = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": os.getenv("SORSA_API_KEY", "YOUR_API_KEY")}
   KEEP = ("id", "full_text", "created_at", "likes_count", "view_count")
   
   
   def search_x(query: str, max_pages: int = 1) -> list[dict]:
       """Search public X posts with operators like from: and lang:.
   
       Args:
           query: X search query.
           max_pages: Pages to read, about 20 posts each.
       """
       posts, cursor = [], None
       for _ in range(max_pages):
           body = {"query": query, "order": "latest"}
           if cursor:
               body["next_cursor"] = cursor
           r = requests.post(f"{API}/search-tweets", json=body,
                             headers=HEADERS, timeout=30)
           r.raise_for_status()
           data = r.json()
           for t in data.get("tweets", []):
               post = {k: t.get(k) for k in KEEP}
               post["author"] = t["user"]["username"]
               post["followers"] = t["user"]["followers_count"]
               posts.append(post)
           cursor = data.get("next_cursor")
           if not cursor:
               break
       return posts
   

4. Registra la herramienta. La misma función funciona en el OpenAI Agents SDK, en LangChain o en cualquier API de LLM, y su docstring se convierte en la descripción de la herramienta. La Messages API de Claude recibe el esquema como input_schema; las herramientas de función de OpenAI llaman al mismo objeto parameters.

   from agents import Agent, Runner, function_tool
   
   agent = Agent(
       name="X researcher",
       instructions="Answer from public X posts and cite post IDs.",
       tools=[function_tool(search_x)],
   )
   result = Runner.run_sync(agent, "What are developers saying about MCP?")
   print(result.final_output)
   

   from langchain.agents import create_agent
   from langchain.tools import tool
   
   agent = create_agent(
       model="openai:gpt-5.5",
       tools=[tool(search_x, parse_docstring=True)],
       system_prompt="Answer from public X posts and cite post IDs.",
   )
   question = {"role": "user", "content": "What are developers saying about MCP?"}
   result = agent.invoke({"messages": [question]})
   

   {
     "name": "search_x",
     "description": "Search public X posts with operators like from: and lang:.",
     "input_schema": {
       "type": "object",
       "properties": {
         "query": {"type": "string", "description": "X search query."},
         "max_pages": {
           "type": "integer",
           "description": "Pages to read, about 20 posts each."
         }
       },
       "required": ["query"]
     }
   }
   

Cada post de la respuesta lleva 22 campos, y su objeto user, el perfil completo del autor, lleva 19 más. Un agente rara vez los necesita todos. Devolver 7 mantiene cortos los resultados de las herramientas, y eso importa: Claude Code, por ejemplo, avisa cuando un solo resultado de herramienta pasa de 10K tokens.

Más herramientas para el mismo agente

El mismo patrón cubre los otros trabajos que un agente hace en X: una función alrededor de un endpoint, cada llamada una solicitud.

• GET /info-batch (se abre en una pestaña nueva) consulta 100 perfiles por llamada, por nombre de usuario o por ID de usuario.
• POST /tweet-info-bulk (se abre en una pestaña nueva) lee 100 posts por llamada a partir de sus IDs o enlaces, cada uno con su autor.
• GET /followers (se abre en una pestaña nueva) devuelve 200 seguidores por página y pagina con next_cursor.
• POST /check-follow (se abre en una pestaña nueva) responde en una sola llamada si una cuenta sigue a otra.

Los otros 40 endpoints, de respuestas y citas a Listas, Comunidades y tendencias, están en la página de endpoints de Sorsa API.

#Agrega el servidor MCP a Claude Code, Cursor o Codex

Para una app de IA que habla MCP, agrega el servidor MCP de Sorsa API: un comando inicia sorsa-mcp desde npm, y la app obtiene 40 herramientas de solo lectura con tu clave, de la búsqueda y los perfiles a las comprobaciones de seguimiento.

claude mcp add sorsa --scope user \
  -e SORSA_API_KEY=YOUR_API_KEY -- npx -y sorsa-mcp

{
  "mcpServers": {
    "sorsa": {
      "command": "npx",
      "args": ["-y", "sorsa-mcp"],
      "env": { "SORSA_API_KEY": "YOUR_API_KEY" }
    }
  }
}

En Claude Code el nombre del servidor, sorsa, va antes de -e, porque -e lee las palabras que le siguen como variables. Cursor lee el mismo servidor desde el archivo JSON de arriba. Luego hazle al agente una pregunta que necesite X, como qué dice la gente hoy sobre tu lanzamiento, y llamará a search_tweets por su cuenta.

Las líneas para Codex, VS Code, Claude Desktop y otras apps, y las soluciones para un servidor que no se conecta, están en nuestra guía del servidor MCP de Twitter. La página del servidor MCP de Twitter lista las 40 herramientas con lo que devuelve cada una.

#Instala la skill de agente para agentes de programación

Un agente de programación como Claude Code, Codex o Cursor aprende Sorsa API desde una skill: la carpeta sorsa-x-api le dice qué endpoint se ajusta a una tarea, cómo paginar con next_cursor y cuándo agrupar 100 IDs en lote, y el agente escribe las llamadas por sí mismo.

Las skills siguen el formato abierto Agent Skills (se abre en una pestaña nueva), así que una sola carpeta funciona en estos agentes. Instálala con la línea de comandos de skills, que pregunta a qué agentes agregarla, o cópiala a mano en la carpeta de skills de Claude Code:

npx skills add Sorsa-io/sorsa-x-api-skill

git clone https://github.com/Sorsa-io/sorsa-x-api-skill \
  ~/.claude/skills/sorsa-x-api

Luego define SORSA_API_KEY en el shell donde corre el agente. Una skill sirve para trabajos en los que el agente debe dejar código, como un script que exporta una semana de menciones cada lunes, en lugar de llamar a una herramienta por cada pregunta.

Para asistentes sin skills, la página de AI Docs (se abre en una pestaña nueva) contiene toda la referencia de la API en un solo archivo de texto para adjuntar. La página de construir con IA tiene prompts listos para Claude Code, Cursor y Codex.

#Por qué un agente que lee X debería ser de solo lectura

Un agente que lee posts lee texto escrito por desconocidos, así que una API que solo puede leer es la salvaguarda más simple: un post plantado no puede hacer que el agente publique, dé like, siga o envíe un DM cuando ninguna herramienta puede hacerlo.

Los equipos de seguridad llaman a esto inyección indirecta de prompts. OWASP (se abre en una pestaña nueva) coloca la inyección de prompts en primer lugar entre los riesgos de las aplicaciones de LLM y nombra el contenido de fuentes externas, como sitios web o archivos, como una de las vías de entrada. Un resultado de búsqueda es exactamente ese tipo de contenido. En la API oficial de X, un agente con un token con permisos de escritura puede ser dirigido a actuar sobre la cuenta, así que el consejo habitual es una puerta de enlace que bloquee toda solicitud de escritura antes de que llegue a X.

Para un agente que nunca debe actuar en X, usa Sorsa API: sus 45 endpoints leen datos públicos, así que la propia clave API es el límite y no hace falta ninguna puerta de enlace. El servidor MCP tampoco tiene herramienta de publicación: cuando llamamos a post_tweet el 2 de noviembre, respondió "Tool post_tweet not found". Ningún inicio de sesión ni cookie tuyos de X interviene en ningún punto, así que tu cuenta de X corre cero riesgo.

Si tu agente debe publicar, mantén la publicación en una herramienta aparte sobre la API oficial de X, a $0.015 por post, y deja que una persona apruebe cada post antes de que salga.

Para tener en cuenta

Trata lo que devuelven las herramientas como datos, no como instrucciones. Dile al modelo en su prompt de sistema que el texto de los posts es material citado, y mantén cada clave en tu código o entorno, nunca en el prompt, para que ningún post ni resultado de herramienta pueda extraerla.

#Lo que cuestan los datos de X para un agente, por cada 1,000 resultados

En Sorsa API, los datos de X de un agente cuestan de $0.007 a $0.07 por 1,000 resultados, según el trabajo, frente a $5.00 a $15.00 en la API oficial de X. Los $15.00 son el precio de X desde el 22 de noviembre para los posts que llegan con sus autores. Los precios de Sorsa API parten de la tarifa más baja por solicitud, y una llamada es una solicitud en todos los planes, sin importar lo que devuelva.

• Buscar posts sobre un tema

  Endpoint

  POST /search-tweets

  Por llamada

  unos 20 posts con autores

  Sorsa API, por 1,000

  desde $0.07

  API oficial de X, por 1,000

  $5.00, o $15.00 con autores

• Leer posts por ID

  Endpoint

  POST /tweet-info-bulk

  Por llamada

  hasta 100 posts con autores

  Sorsa API, por 1,000

  desde $0.014

  API oficial de X, por 1,000

  $5.00, o $15.00 con autores

• Consultar perfiles

  Endpoint

  GET /info-batch

  Por llamada

  hasta 100 perfiles

  Sorsa API, por 1,000

  desde $0.014

  API oficial de X, por 1,000

  $10.00

• Leer una lista de seguidores

  Endpoint

  GET /followers

  Por llamada

  hasta 200 seguidores

  Sorsa API, por 1,000

  desde $0.007

  API oficial de X, por 1,000

  $10.00

Una ejecución de investigación hace concreta la escala: un agente busca un tema, obtiene 20 posts con sus autores y luego consulta 100 perfiles. En la API oficial de X esa ejecución cuesta $1.10 hoy y $1.30 desde el 22 de noviembre. En Sorsa API cuesta desde $0.0028, y las solicitudes fallidas nunca se cobran.

GET /key-usage-info (se abre en una pestaña nueva) muestra cuántas solicitudes quedan y nunca cuenta como una, así que un agente puede revisar su presupuesto antes de un trabajo largo.

#Mantén baratas y fiables las llamadas de un agente a X

Los agentes desperdician llamadas cuando entran en bucle, así que dale a cada herramienta de X un presupuesto de páginas, agrupa las consultas en lotes y devuelve solo los campos que lee el modelo.

• Agrupa las consultas. Envía hasta 100 IDs de posts en una sola llamada a POST /tweet-info-bulk, o 100 nombres de usuario en una sola llamada a GET /info-batch, en lugar de 100 llamadas individuales.
• Presupuesta las páginas. Un argumento max_pages evita que un agente lea una búsqueda de 50K posts página por página. Detente en cuanto next_cursor regrese vacío.
• Usa caché dentro de una tarea. La misma consulta hecha dos veces en una tarea devuelve los mismos posts, así que conserva la primera respuesta.
• Maneja 429 y 403. Cada clave funciona a 20 solicitudes por segundo en todos los planes: ante un 429, espera un segundo y reintenta. Un 403 significa que falta la clave o que la cuenta se quedó sin solicitudes.
• Consulta con una programación. Cada solicitud devuelve datos frescos, así que un agente de monitoreo se mantiene al día repitiendo su búsqueda con una programación y since: en la consulta. La guía de monitoreo de Twitter en tiempo real muestra el bucle.

El esquema de respuesta se mantiene estable, así que el código de tu herramienta sigue funcionando.

#Dale datos de X a tu agente hoy

Tu agente puede leer X en minutos: una herramienta REST para los agentes que construyes, el servidor MCP para Claude Code y Cursor, o la skill para agentes de programación. Sorsa API ofrece las tres con una sola clave de solo lectura, con posts desde $0.014 por 1,000 frente a $5.00 en la API oficial de X y 20 solicitudes por segundo en todos los planes, en producción desde 2022, con más de 6 mil millones de solicitudes procesadas. Tus primeras 100 solicitudes son gratis, suficientes para que un agente lea hasta 10K posts.

#Preguntas frecuentes