API de Grok vs API de Twitter para datos de X

#Qué puede obtener Grok de X y qué devuelve

Grok solo puede leer posts públicos de X mediante una herramienta de búsqueda: la página de modelos (se abre en una pestaña nueva) de xAI dice que Grok "no tiene conocimiento de eventos actuales ni de datos más allá de lo que estaba en sus datos de entrenamiento", que para grok-4.7 terminan en mayo de 2026. En la app de Grok la búsqueda corre sola. Con la API de xAI la activas tú, y la herramienta se llama X Search (x_search).

Eso pone a Grok del lado de las respuestas de una línea que todo quien construye agentes conoce. Nuestra guía de la API de Twitter para agentes de IA cubre el otro lado: herramientas que devuelven datos de X a un modelo como JSON simple.

Una solicitud con X Search activado es una sola llamada a la Responses API de xAI, aquí con el SDK de OpenAI apuntando a api.x.ai:

import os

from openai import OpenAI

grok = OpenAI(api_key=os.environ["XAI_API_KEY"],
              base_url="https://api.x.ai/v1")
resp = grok.responses.create(
    model="grok-4.7",
    input="What are developers saying about MCP this week?",
    tools=[{"type": "x_search"}],
)
print(resp.output_text)

Detrás de esa llamada, el modelo corre tantas búsquedas como le parezca. La documentación de X Search (se abre en una pestaña nueva) lista cuatro funciones que puede llamar: búsqueda por palabras clave con los operadores de búsqueda de X, búsqueda semántica por significado, búsqueda de usuarios y una consulta de hilo que trae un post con sus posts padre y sus respuestas. Puedes limitarlo a 20 handles como máximo, o excluir 20, y fijar un rango de fechas en YYYY-MM-DD.

Lo que vuelve es el texto del modelo, los enlaces que citó y dos contadores de uso, x_posts_fetched y x_users_fetched. Los posts mismos se quedan dentro de la solicitud: no hay una lista de registros, ni un conjunto estable de campos, ni un cursor a la página siguiente. La propia documentación de xAI advierte que "los resultados varían porque el modelo elige sus propias consultas". La antigua Live Search API también desapareció: su guía ahora redirige a Web Search.

#X Search de Grok vs una API de datos de X, lado a lado

X Search está hecho para responder una pregunta, y una API de datos de X está hecha para devolver registros, así que las dos difieren más donde un trabajo necesita todos los posts que coinciden, cifras exactas o el mismo resultado dos veces. En cada una de esas filas ganan las API de datos, y Sorsa API lo hace por una pequeña fracción del precio por post de las otras dos.

• Qué devuelve

  Sorsa API

  Registros JSON, 41 campos por post con su autor

  X Search de xAI (Grok)

  la respuesta del modelo con enlaces

  API oficial de X

  Registros JSON, los campos que pides

• Quién elige los posts

  Sorsa API

  tú, con una consulta y operadores de X

  X Search de xAI (Grok)

  el modelo, con sus propias consultas

  API oficial de X

  tú

• Todas las coincidencias, página por página

  Sorsa API

  sí, next_cursor hasta que queda vacío

  X Search de xAI (Grok)

  no: el modelo se detiene cuando tiene una respuesta

  API oficial de X

  sí, con tokens de página

• Misma solicitud, mismos posts

  Sorsa API

  sí

  X Search de xAI (Grok)

  no: los resultados varían en cada ejecución

  API oficial de X

  sí

• Hasta cuándo hacia atrás

  Sorsa API

  hasta 2006

  X Search de xAI (Grok)

  un rango de fechas que tú fijas

  API oficial de X

  hasta 2006 con búsqueda en el archivo completo

• Precio por 1,000 posts

  Sorsa API

  desde $0.07

  X Search de xAI (Grok)

  $5.00 más tokens

  API oficial de X

  $5.00; $15.00 con autores desde el 22 de nov. de 2026

• Precio por 1,000 perfiles

  Sorsa API

  desde $0.014

  X Search de xAI (Grok)

  $10.00

  API oficial de X

  $10.00

• Qué necesitas

  Sorsa API

  una clave API en un header

  X Search de xAI (Grok)

  una clave API de xAI

  API oficial de X

  una cuenta de desarrollador, OAuth o un Bearer token, créditos prepagados

Los precios de la API oficial de X salen de su lista de precios de pago por uso (se abre en una pestaña nueva), que además limita las lecturas a 3 millones de posts al mes; pasado eso, X solo vende contratos Enterprise desde unos $42,000 al mes. El aviso del 23 de octubre (se abre en una pestaña nueva) de X agrega que desde el 22 de noviembre de 2026 los autores y los medios que se devuelven con los posts también se cobran como lecturas, así que un resultado de búsqueda con su autor pasa de $0.005 a $0.015.

Para tener en cuenta

Pedirle a Grok que "devuelva los posts como JSON" no convierte su respuesta en registros. El modelo escribe ese JSON a partir de lo que leyó, y él decide cuántos posts leer. Conserva los ID de post que cita y obtén los registros por ID cuando los números importen: POST /tweet-info-bulk (se abre en una pestaña nueva) de Sorsa API devuelve hasta 100 posts por llamada, desde $0.014 por 1,000.

#Cuánto cuestan 10K, 100K y 1M de posts

Leer 1 millón de posts cuesta $5,000 más tokens con X Search de Grok, $5,000 en la API oficial de X ($15,000 con el autor de cada post desde el 22 de noviembre) y desde $70 en Sorsa API. La brecha se mantiene en cualquier tamaño, porque X Search y la API oficial de X cobran los dos por post, mientras que Sorsa API cobra por solicitud y cada solicitud de búsqueda devuelve unos 20 posts.

Los tokens no cambian la comparación. Sea cual sea la ruta por la que entran los posts, Grok cobra su lectura a la tarifa de grok-4.7 de $2.00 por millón de tokens de entrada y $6.00 por millón de tokens de salida, como en la página de precios de la API (se abre en una pestaña nueva) de xAI. Si un post recortado son unos 60 tokens, 1,000 posts suman unos $0.12 de entrada, poco al lado de $5.00 por los posts.

X Search tiene tres reglas de cobro que hacen que una pregunta cueste más de lo que parece:

• Se cobra cada elemento obtenido, no cada elemento citado: los posts padre, los posts citados y cada post de un hilo consultado cuentan a $5 por 1,000.
• Los conteos no se deduplican. Un post que devuelven dos búsquedas se cobra dos veces.
• El modelo fija el volumen. Puedes limitar las rondas de búsqueda y leer x_posts_fetched después, pero no puedes fijar la cantidad de posts antes de la llamada.

Una suscripción a Grok o a X no cubre nada de esto. La página de planes (se abre en una pestaña nueva) dice que los planes de pago incluyen acceso a la API, pero "el uso de la API se cobra por separado a las tarifas estándar del modelo y no se descuenta del fondo de uso de tu plan".

#Cómo darle a Grok posts de X sin procesar con Sorsa API

Para darle a Grok posts sin procesar, obtenlos de una API de datos de X, conserva los campos que tu pregunta necesita y pásalos a grok-4.7 en el prompt sin la herramienta X Search, de modo que Grok lea exactamente los posts que elegiste. Para esa obtención, usa Sorsa API, una API y scraper de Twitter (X): un header ApiKey y sin OAuth, unos 20 posts con perfiles completos de autor por llamada de búsqueda, desde $0.07 por 1,000, a 20 solicitudes por segundo en todos los planes.

1. Consigue dos claves. Regístrate y copia tu clave de Sorsa API en SORSA_API_KEY; pon tu clave de xAI en XAI_API_KEY. Las dos se quedan en tu servidor.

2. Busca los posts. 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". La búsqueda llega hasta 2006.

   curl -X POST "https://api.sorsa.io/v3/search-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"query": "\"grok api\" lang:en -filter:retweets", "order": "latest"}'
   

   {
     "tweets": [
       {
         "id": "2116193940272985298",
         "full_text": "Our digest now fetches posts first, then asks Grok.",
         "created_at": "2026-10-30T15:42:07Z",
         "lang": "en",
         "likes_count": 64,
         "retweet_count": 7,
         "reply_count": 12,
         "quote_count": 3,
         "view_count": 8120,
         "is_reply": false,
         "conversation_id_str": "2116193940272985298",
         "user": {
           "id": "1544001928374651904",
           "username": "maya_ships_prompts",
           "display_name": "Maya Ships Prompts",
           "followers_count": 4210,
           "verified": false
         }
       }
     ],
     "next_cursor": "DAADDAABCgABHV6x9mPAJxIKAAIdXrH2Y8"
   }
   

   Ver respuesta completa

3. Obtén y recorta las páginas. La función sigue next_cursor hasta un presupuesto de páginas y conserva seis campos por post, de modo que 200 posts siguen siendo un prompt corto.

   import os
   
   import requests
   
   SORSA = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": os.getenv("SORSA_API_KEY", "YOUR_API_KEY")}
   
   
   def fetch_posts(query: str, max_pages: int = 10) -> list[dict]:
       posts, cursor = [], None
       for _ in range(max_pages):
           body = {"query": query, "order": "latest"}
           if cursor:
               body["next_cursor"] = cursor
           r = requests.post(f"{SORSA}/search-tweets", json=body,
                             headers=HEADERS, timeout=30)
           r.raise_for_status()  # 403: key or quota; 429: over 20 req/s
           data = r.json()
           for t in data.get("tweets", []):
               posts.append({
                   "id": t["id"],
                   "at": t["created_at"],
                   "author": t["user"]["username"],
                   "followers": t["user"]["followers_count"],
                   "likes": t["likes_count"],
                   "text": t["full_text"][:500],
               })
           cursor = data.get("next_cursor")
           if not cursor:
               break
       return posts
   

4. Pregúntale a Grok solo sobre esos posts. Envía los posts recortados como prompt, sin tools, y pide ID de posts en la respuesta.

   import json
   
   from openai import OpenAI
   
   grok = OpenAI(api_key=os.environ["XAI_API_KEY"],
                 base_url="https://api.x.ai/v1")
   
   
   def ask_grok(question: str, posts: list[dict]) -> str:
       lines = "\n".join(json.dumps(p, ensure_ascii=False) for p in posts)
       resp = grok.responses.create(
           model="grok-4.7",
           input=[
               {"role": "system", "content":
                "Answer only from the posts given. Cite post ids."},
               {"role": "user", "content": f"{question}\n\nPosts:\n{lines}"},
           ],
       )
       return resp.output_text
   
   
   posts = fetch_posts('"grok api" lang:en -filter:retweets')
   print(ask_grok("What problems do developers report?", posts))
   

Diez páginas de búsqueda son 10 solicitudes y unos 200 posts, así que la parte de datos de esa corrida cuesta unos pocos centavos como máximo en cualquier plan de Sorsa API, y es lo mismo sin importar si después los lee Grok, Claude o GPT. Nuestra guía de la API de búsqueda de Twitter lista los operadores que acotan una consulta antes de que cueste algo.

#Lo que la gente le pregunta a Grok sobre cuentas de X

Muchas preguntas que la gente escribe en Grok sobre una cuenta tienen una respuesta exacta que una sola llamada a la API devuelve, como la cantidad de seguidores, un ID de usuario, una lista de seguidos o el estado de shadowban. La frase de un modelo sobre esas cifras puede estar desactualizada o redondeada; la consulta devuelve el valor tal como está en el momento de la llamada, en un campo que tu código puede leer.

• ¿Cuántos seguidores tiene esta cuenta?

  Consulta con Sorsa API

  GET /info (se abre en una pestaña nueva)

  Qué devuelve

  followers_count, followings_count, tweets_count, created_at y 15 campos más

• ¿Cuál es el ID de usuario de esta cuenta?

  Consulta con Sorsa API

  GET /username-to-id/{user_handle} (se abre en una pestaña nueva)

  Qué devuelve

  el id numérico

• ¿A quién sigue esta cuenta?

  Consulta con Sorsa API

  GET /follows (se abre en una pestaña nueva)

  Qué devuelve

  hasta 200 cuentas por página, con next_cursor

• ¿Esta cuenta tiene shadowban?

  Consulta con Sorsa API

  GET /check-shadowban (se abre en una pestaña nueva)

  Qué devuelve

  is_shadowbanned y cada revisión como limpia, con ban o desconocida

• ¿Qué publicó esta cuenta esta semana?

  Consulta con Sorsa API

  POST /user-tweets (se abre en una pestaña nueva)

  Qué devuelve

  unos 20 posts por página, cada uno con el perfil completo de su autor

Dos de estas consultas tienen herramientas gratis que no necesitan código: el Buscador de ID de Twitter para un ID de usuario y la Prueba de shadowban de Twitter para bans de búsqueda. Para muchas cuentas a la vez, GET /info-batch (se abre en una pestaña nueva) devuelve 100 perfiles por llamada, desde $0.014 por 1,000 perfiles, frente a $10.00 por 1,000 perfiles con X Search.

#Cuál usar, trabajo por trabajo

Pregúntale a Grok cuando el resultado que quieres es una frase, y usa una API de datos de X cuando el resultado son los posts, una lista o una cifra; la mayoría de los productos necesita ambas, en ese orden: obtener y luego preguntar. Los criterios que lo deciden son los de la tabla de arriba: quién elige los posts, si obtienes todas las coincidencias, si una nueva ejecución devuelve los mismos posts y el precio por 1,000.

• Una pregunta puntual sobre la conversación de hoy

  Qué usar

  Grok, en la app

• Todos los posts que coinciden con una consulta, guardados en tu base de datos

  Qué usar

  Sorsa API, POST /search-tweets página por página

• Un dashboard de cantidades de seguidores o de engagement

  Qué usar

  Sorsa API, GET /info-batch y POST /tweet-info-bulk

• Los posts de una cuenta de hace años

  Qué usar

  Sorsa API, POST /user-tweets

• Un resumen diario de lo que la gente dice de tu producto

  Qué usar

  Sorsa API para obtener, luego Grok u otro modelo para resumir

• Verificar los posts que citó una respuesta de Grok

  Qué usar

  Sorsa API, POST /tweet-info-bulk con los ID

Para cualquier trabajo en el que los posts sean el producto, la opción es Sorsa API: posts con los 41 campos desde $0.07 por 1,000 en búsqueda y desde $0.014 por 1,000 por ID, todas las coincidencias página por página e historial hasta 2006. Es de solo lectura y nunca te pide tu login de X, así que tu cuenta de X no corre ningún riesgo. Para publicar o responder, combínala con la API oficial de X.

Los agentes que corren Grok con un horario siguen la misma regla; la guía de Hermes Agent muestra dónde queda su x_search integrado y cómo cambiar la fuente de datos. Cada precio de la API de X detrás de estas cifras está en nuestro desglose de precios de la API de X.

#Dale a Grok los posts que tú eliges

Grok te da una respuesta sobre X; para los posts, los conteos y el historial detrás de ella, obtenlos primero. Con Sorsa API eso cuesta desde $0.07 por 1,000 posts en lugar de $5.00 con X Search, los posts llegan con sus autores y todos sus campos, y tus primeras 100 solicitudes son gratis: suficiente para unos 2,000 posts con los que probar el pipeline de arriba.

#Preguntas frecuentes