Cómo buscar tweets con una API de búsqueda de Twitter

#Cómo funciona una API de búsqueda de Twitter

Una API de búsqueda de Twitter es un endpoint que ejecuta por ti la búsqueda de X sobre los tweets públicos. Envías una consulta, como "vector database" lang:en min_faves:20. Te llega una página de tweets que coinciden, con su texto, fecha, conteos y autor, más un cursor que trae la página siguiente.

Para probar una consulta antes de escribir código, ejecútala en la herramienta gratuita de búsqueda avanzada de Twitter. Muestra los primeros 20 posts que coinciden, y cada filtro que defines escribe su operador en la consulta, listo para pegar en una solicitud.

Tres ajustes deciden lo que llega. La consulta elige los tweets por palabras, cuentas, idioma, multimedia y engagement. El orden es Top, con las coincidencias de más engagement primero, o Latest, con las más nuevas primero. La ventana de fechas va dentro de la consulta como since: y until: en la sintaxis web de X, o en parámetros de tiempo aparte en la API oficial de X.

La API oficial de X divide la búsqueda en dos endpoints (documentación de búsqueda de X (se abre en una pestaña nueva)). GET /2/tweets/search/recent cubre los últimos 7 días y devuelve de 10 a 100 posts por solicitud; GET /2/tweets/search/all llega hasta marzo de 2006 con hasta 500. Los dos necesitan una cuenta de desarrollador aprobada, un Project y una App y un Bearer token, y los dos cobran $0.005 por cada post que devuelven.

#Busca tweets con Sorsa API en cuatro pasos

Para buscar tweets desde código, usa Sorsa API, una API y scraper de Twitter (X): resultados desde $0.07 por 1,000, cualquier fecha hasta 2006 y 20 solicitudes por segundo en todos los planes. Necesita un solo encabezado ApiKey en lugar de una cuenta de desarrollador y OAuth, lee la sintaxis de consultas del cuadro de búsqueda de x.com y nunca toca tu cuenta de X.

1. Consigue una clave. Regístrate y copia la clave API de tu panel. Las 100 solicitudes gratis ya vienen con ella.

2. Escribe la consulta. Escríbela como lo harías en x.com: palabras, "exact phrases", from:, lang:, min_faves: y since:.

3. Envía la solicitud. Haz POST de la consulta a POST /search-tweets (se abre en una pestaña nueva) en un cuerpo JSON, con "order": "latest" para los tweets más nuevos primero o "popular" para Top.

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

   {
     "tweets": [
       {
         "id": "2116173807613027825",
         "full_text": "Benchmarked three vector databases on 40M embeddings.",
         "created_at": "2026-10-30T14:22:07Z",
         "lang": "en",
         "likes_count": 214,
         "retweet_count": 37,
         "reply_count": 19,
         "quote_count": 6,
         "view_count": 18450,
         "bookmark_count": 92,
         "is_reply": false,
         "is_quote_status": false,
         "conversation_id_str": "2116173807613027825",
         "entities": [],
         "user": {
           "id": "1620350095193014349",
           "username": "indexlab_notes_daily",
           "display_name": "Index Lab Notes",
           "followers_count": 8312,
           "verified": false,
           "created_at": "2023-01-31T09:15:42Z"
         }
       }
     ],
     "next_cursor": "DAADDAABCgABHV3t2nWAJ8kKAAIdXcTm0Zvw"
   }
   

   Ver respuesta completa

4. Sigue el cursor. Cada tweet trae el perfil completo de su autor, así que no hace falta una segunda consulta. Envía next_cursor de vuelta en el mismo cuerpo para la página siguiente, y detente cuando una respuesta llegue sin él.

Una respuesta 403 significa que falta la clave o que no quedan solicitudes, y un 401 significa que la clave es incorrecta. Un 429 significa más de 20 solicitudes en un segundo: espera un segundo y envíala de nuevo. Las solicitudes fallidas nunca se cobran.

Pega abajo tu propia consulta para revisarla y obtener la solicitud en curl, Python o Node.js, con las comillas dentro del cuerpo JSON ya escapadas. El verificador también señala los nombres de operadores de la API oficial de X, que la sintaxis web no usa.

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

import requests

r = requests.post(
    "https://api.sorsa.io/v3/search-tweets",
    headers={"ApiKey": "YOUR_API_KEY"},
    json={"query": '"vector database" lang:en min_faves:20',
          "order": "latest"},
    timeout=30,
)
page = r.json()
for t in page["tweets"]:
    print(t["user"]["username"], t["full_text"])
print(page.get("next_cursor"))

const res = await fetch("https://api.sorsa.io/v3/search-tweets", {
  method: "POST",
  headers: { ApiKey: "YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    query: '"vector database" lang:en min_faves:20',
    order: "latest",
  }),
});
const page = await res.json();
for (const t of page.tweets) console.log(t.user.username, t.full_text);
console.log(page.next_cursor);

#Escribe una consulta que funcione en código

Una consulta para /search-tweets es la misma cadena que escribirías en el cuadro de búsqueda de x.com, así que puedes armarla en el navegador y pegarla en la solicitud sin cambios. Siete reglas cubren casi todos los problemas que encuentran los desarrolladores:

• Un espacio significa AND, OR debe ir en mayúsculas, un - al inicio excluye una palabra o un operador, y los paréntesis agrupan: (rust OR golang) -hiring.
• Las frases exactas van entre comillas dobles. Dentro de una cadena JSON sin procesar esas comillas necesitan una barra invertida, "\"vector database\""; en Python y Node.js pasa un diccionario o un objeto y la librería las escapa por ti.
• Los hashtags, los cashtags y las menciones se escriben tal cual: #buildinpublic, $NVDA, @acme_cloud_status. La consulta viaja en un cuerpo JSON, así que nada necesita codificación de URL.
• Las fechas van en la consulta: since:2026-10-01 incluye ese día, until:2026-11-01 se detiene antes de él, ambos en UTC.
• Los mínimos de engagement son min_faves:, min_retweets: y min_replies:; un signo menos convierte un mínimo en un máximo, como en -min_faves:1000.
• Los retweets nativos se dejan fuera a menos que añadas include:nativeretweets, y -filter:replies conserva solo los posts de primer nivel.
• En una consulta caben unos 22 operadores. Reparte las listas más largas de cuentas o palabras clave en varias consultas.

Cinco patrones cubren la mayor parte de lo que buscan los equipos, cada uno listo para pegar en el campo query:

# Mentions of a brand, without its own posts
("acme cloud" OR @acme_cloud_status) -from:acme_cloud_status

# The most liked posts on a topic
"vector database" min_faves:100 -filter:replies lang:en

# One account's posts on a subject in October
from:acme_cloud_status outage since:2026-10-01 until:2026-11-01

# Posts that link to a site
url:github.com rust -filter:replies

# Images under a hashtag
#buildinpublic filter:images

Todos los operadores, con sus particularidades y ejemplos, están en nuestra lista de operadores de búsqueda de Twitter.

#Obtén todas las páginas y mantén la búsqueda en marcha

Para recopilar más de una página, envía de nuevo el mismo cuerpo con el next_cursor de la última respuesta, y detente cuando una respuesta no lo traiga. Las páginas tienen unos 20 tweets y su tamaño varía, así que una página corta nunca significa que la búsqueda terminó; solo lo significa la falta de cursor.

El bucle de abajo escribe cada tweet en un archivo JSON Lines a medida que llega y omite los IDs que ya guardó. Un presupuesto de páginas lo detiene, para que una consulta amplia no se lleve todas tus solicitudes.

import json
import requests

API = "https://api.sorsa.io/v3/search-tweets"
HEADERS = {"ApiKey": "YOUR_API_KEY"}


def search(query, order="latest", max_pages=50):
    body = {"query": query, "order": order}
    for _ in range(max_pages):
        r = requests.post(API, json=body, headers=HEADERS, timeout=30)
        r.raise_for_status()
        page = r.json()
        yield from page.get("tweets", [])
        cursor = page.get("next_cursor")
        if not cursor:
            break
        body["next_cursor"] = cursor


seen = set()
with open("tweets.jsonl", "w", encoding="utf-8") as f:
    for t in search('"vector database" lang:en min_faves:20'):
        if t["id"] not in seen:
            seen.add(t["id"])
            f.write(json.dumps(t) + "\n")

const API = "https://api.sorsa.io/v3/search-tweets";
const headers = {
  ApiKey: "YOUR_API_KEY",
  "Content-Type": "application/json",
};

async function* search(query, order = "latest", maxPages = 50) {
  const body = { query, order };
  for (let i = 0; i < maxPages; i++) {
    const res = await fetch(API, {
      method: "POST",
      headers,
      body: JSON.stringify(body),
    });
    if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
    const page = await res.json();
    yield* page.tweets ?? [];
    if (!page.next_cursor) break;
    body.next_cursor = page.next_cursor;
  }
}

const query = '"vector database" lang:en min_faves:20';
for await (const t of search(query)) {
  console.log(t.id, t.user.username, t.full_text.slice(0, 60));
}

Una búsqueda que sigue en marcha es el mismo bucle con un temporizador. Pide los tweets más nuevos, añade since_id: con el ID más alto que guardaste la vez anterior, lee hasta que se acabe el cursor y luego guarda el nuevo ID más alto. Cuando no se publicó nada nuevo, una revisión cuesta una sola solicitud, así que revisar con frecuencia una consulta tranquila sale barato.

import time

newest = None
while True:
    query = '"vector database" lang:en'
    if newest:
        query += f" since_id:{newest}"
    fresh = list(search(query))
    if fresh:
        newest = max(fresh, key=lambda t: int(t["id"]))["id"]
        print(len(fresh), "new tweets")
    time.sleep(300)

La búsqueda funciona por sondeo: no hay un stream al que suscribirse. Para alertas, horarios y entrega a Slack o al correo, nuestra guía de monitoreo de Twitter en tiempo real construye todo el pipeline, y nuestra guía de la API de Twitter en Python añade reintentos y búsquedas en paralelo.

Para tener en cuenta

Usa "order": "latest" siempre que recopiles o cuentes tweets: recorre todas las coincidencias desde la más nueva hacia atrás. "popular", la pestaña Top, devuelve solo las coincidencias con más engagement, así que dos ejecuciones de Top de la misma consulta pueden devolver conjuntos distintos.

#Busca tweets por hashtag

Para buscar por hashtag, pon la etiqueta en la consulta exactamente como la escribirías, #buildinpublic. Coincide con los tweets en los que la etiqueta aparece como hashtag, en cualquier combinación de mayúsculas y minúsculas, y se combina con todos los demás operadores.

Añade las palabras sueltas con OR cuando la gente también escribe la frase sin la etiqueta: (#buildinpublic OR "build in public") min_faves:10 -filter:replies lang:en. Para varias etiquetas, únelas con OR; para símbolos de acciones o monedas, usa cashtags como $NVDA.

Con Sorsa API el # va al cuerpo JSON tal cual. En la solicitud GET de la API oficial de X tiene que convertirse en %23, porque un # sin codificar termina la URL y el servidor nunca ve la etiqueta. Para contar un hashtag a lo largo del tiempo, ejecuta una búsqueda Latest por día con since: y until: y cuenta los tweets que devuelve cada día.

#Elige el endpoint para la búsqueda que necesitas

La búsqueda por palabras clave es una de las cinco formas de encontrar tweets en Sorsa API. El endpoint adecuado depende de tu punto de partida: palabras, una cuenta, un conjunto de cuentas o las propias personas.

Cada uno de los otros cuatro lee un punto de partida distinto. POST /mentions (se abre en una pestaña nueva) toma un handle y devuelve los tweets que lo mencionan, con filtros de likes, respuestas, retweets y fechas en el cuerpo. POST /search-users (se abre en una pestaña nueva) encuentra cuentas cuyo nombre o bio coinciden con una palabra. POST /user-tweets (se abre en una pestaña nueva) lee el timeline propio de una cuenta, unos 20 tweets por solicitud. Los miembros de una Lista de X llegan como un solo feed desde GET /list-tweets (se abre en una pestaña nueva), así que una Lista de hasta 5,000 cuentas se vigila con una solicitud por página.

Los equipos de marca suelen combinar dos de ellos: /search-tweets para lo que la gente dice de un producto, y /mentions para lo que le dice a su cuenta. Nuestra guía de la API de menciones de Twitter cubre el segundo.

#Cuánto cuesta buscar tweets

En Sorsa API, los resultados de búsqueda cuestan desde $0.07 por 1,000 tweets: una solicitud devuelve unos 20 tweets y se cobra como una solicitud, contenga lo que contenga. La API oficial de X cobra cada post que devuelve, $0.005 cada uno, que son $5.00 por 1,000 (lista de precios de X (se abre en una pestaña nueva)).

El precio oficial sube cuando se suman los autores. A partir del 22 de noviembre de 2026, X cobra cada usuario devuelto mediante expansiones a $0.010 (aviso de X del 23 de octubre (se abre en una pestaña nueva)), así que 1,000 resultados con un autor distinto cada uno pueden costar $15.00. Sorsa API pone el perfil completo del autor dentro de cada tweet sin cargo adicional.

El volumen también tiene un techo ahí: el pago por uso se detiene en 3 millones de lecturas de posts al mes, y más allá X solo vende contratos Enterprise. Sorsa API no tiene un techo de 3 millones: los planes escalan hasta 10M de solicitudes al mes, y tus 100 solicitudes gratis cubren unos 2,000 resultados de búsqueda sin tarjeta. El desglose completo de los precios de la API de X tiene todas las tarifas oficiales.

#La búsqueda de la API oficial de X, lado a lado

La búsqueda de la API oficial de X cuesta unas 71 veces más por 1,000 resultados que Sorsa API. Su búsqueda reciente solo ve los últimos 7 días y permite 450 solicitudes cada 15 minutos por app. La tabla pone los tres endpoints de búsqueda uno junto a otro, con los límites oficiales de la tabla de límites de velocidad de X (se abre en una pestaña nueva).

• Fechas cubiertas

  /search-tweets de Sorsa API

  Hasta marzo de 2006

  Búsqueda reciente de X

  Últimos 7 días

  Búsqueda de archivo completo de X

  Hasta marzo de 2006

• Resultados por solicitud

  /search-tweets de Sorsa API

  Unos 20

  Búsqueda reciente de X

  10 a 100

  Búsqueda de archivo completo de X

  10 a 500

• Límite de velocidad

  /search-tweets de Sorsa API

  20 solicitudes por segundo por clave

  Búsqueda reciente de X

  450 solicitudes cada 15 minutos por app

  Búsqueda de archivo completo de X

  1 solicitud por segundo, 300 cada 15 minutos

• Precio por 1,000 resultados

  /search-tweets de Sorsa API

  Desde $0.07

  Búsqueda reciente de X

  $5.00

  Búsqueda de archivo completo de X

  $5.00

• Perfil del autor

  /search-tweets de Sorsa API

  Dentro de cada tweet

  Búsqueda reciente de X

  Se cobra $0.010 cada uno desde el 22 de nov. de 2026

  Búsqueda de archivo completo de X

  Se cobra $0.010 cada uno desde el 22 de nov. de 2026

• Sintaxis de consultas

  /search-tweets de Sorsa API

  Búsqueda web de x.com

  Búsqueda reciente de X

  Operadores v2, 512 caracteres

  Búsqueda de archivo completo de X

  Operadores v2, 1,024 caracteres

• Configuración

  /search-tweets de Sorsa API

  Una clave API

  Búsqueda reciente de X

  Cuenta de desarrollador, App, Bearer token

  Búsqueda de archivo completo de X

  Cuenta de desarrollador, App, Bearer token

Los endpoints oficiales además devuelven solo id y text por defecto: las fechas, los conteos y los autores llegan solo cuando tweet.fields, expansions y user.fields los piden. En Sorsa API cada tweet llega con todos sus campos.

#Sintaxis web frente a los operadores de la API oficial de X

La API oficial de X lee sus propios nombres de operadores, así que una consulta copiada del cuadro de búsqueda de x.com puede fallar ahí. Rechaza min_faves: y min_retweets: con un error 400, y recibe las fechas como parámetros start_time y end_time, no dentro de la consulta. Sorsa API acepta la sintaxis web, así que la columna izquierda funciona tal cual está escrita.

• Al menos 20 likes

  Sintaxis web (x.com, Sorsa API)

  min_faves:20

  API oficial de X v2

  min_likes:20

• Al menos 5 reposts

  Sintaxis web (x.com, Sorsa API)

  min_retweets:5

  API oficial de X v2

  min_reposts:5

• Solo octubre de 2026

  Sintaxis web (x.com, Sorsa API)

  since:2026-10-01 until:2026-11-01

  API oficial de X v2

  parámetros start_time y end_time

• Solo respuestas

  Sintaxis web (x.com, Sorsa API)

  filter:replies

  API oficial de X v2

  is:reply

• Posts con multimedia o enlaces

  Sintaxis web (x.com, Sorsa API)

  filter:media, filter:links

  API oficial de X v2

  has:media, has:links

• Retweets

  Sintaxis web (x.com, Sorsa API)

  Se dejan fuera por defecto

  API oficial de X v2

  Se dejan fuera de las búsquedas por palabra clave desde el 4 de mayo de 2026

• Palabras, cuentas, idioma

  Sintaxis web (x.com, Sorsa API)

  from:, to:, #, @, "phrase", lang:

  API oficial de X v2

  Los mismos

Dos cambios de 2026 explican por qué las guías más viejas no coinciden. X desactivó min_likes:, min_replies: y min_reposts: el 19 de enero de 2026. Los volvió a activar el 4 de mayo, cuando la búsqueda pasó a un nuevo índice que además quitó los retweets de los resultados por palabra clave (registro de cambios de X (se abre en una pestaña nueva)). Las páginas y las respuestas de IA que dicen que la API oficial de X ignora los filtros de engagement describen los meses intermedios.

¿Vas a mover toda una integración fuera de los endpoints oficiales? Nuestra guía para migrar desde la API oficial de X relaciona cada parámetro y operador v2 con Sorsa API.

#Empieza a buscar tweets hoy

Buscar tweets desde código se reduce a una consulta y un cursor. Con Sorsa API, la consulta que ya escribes en x.com va a POST /search-tweets y devuelve unos 20 tweets por solicitud con sus autores, de cualquier fecha hasta 2006. Los resultados cuestan desde $0.07 por 1,000, frente a $5.00 en la API oficial de X, y tus 100 solicitudes gratis cubren los primeros 2,000.

#Preguntas frecuentes