Integración de Make.com con Twitter (X) en 2026

#Qué pasó con la app de Twitter (X) de Make

La app de X (antes Twitter) de Make desapareció para siempre: Make la retiró de la búsqueda de apps el 3 de abril de 2025, y los escenarios que aún usaban sus módulos empezaron a fallar el 30 de mayo de 2025. La nota de versión de Make (se abre en una pestaña nueva) da una sola razón, los requisitos de política de la API de X y sus precios, que según Make descartan "a reasonable integration" para sus clientes.

Desde entonces no se ha restablecido nada, como muestran las fechas:

• 3 de abril de 2025

  Qué cambió en Make

  La app de X sale de la búsqueda de apps; no se pueden crear escenarios nuevos con X

• 30 de mayo de 2025

  Qué cambió en Make

  Los escenarios de X existentes se detienen; aún se abren pero fallan en cada ejecución

• 19 de enero de 2026

  Qué cambió en Make

  El aviso de Make se actualiza por última vez, sin cambio de rumbo

• 2 de noviembre de 2026

  Qué cambió en Make

  Sigue sin haber una app de X en las integraciones de Make (comprobado para esta guía)

Make (antes Integromat) dirige a los clientes que publicaban en X hacia apps de gestión de redes sociales, y su app xAI, que accede a los modelos de Grok, no se vio afectada. Ninguna de las dos lee posts, perfiles ni seguidores de X. Leer datos de X ahora requiere una solicitud desde la app HTTP de Make, que habla con cualquier servicio con una API REST.

Llamar a la API oficial de X desde ese módulo necesita una app de desarrollador de X, un Bearer token o una conexión OAuth, y créditos prepagados: $0.005 por lectura de post y $0.010 por usuario o seguidor, con el pago por uso limitado a 3 millones de lecturas de posts al mes, según la página de precios de X (se abre en una pestaña nueva). Desde el 22 de noviembre de 2026, X también factura el autor de cada post como una lectura de usuario, así que un post con su autor suma $0.015 (aviso de X del 23 de octubre (se abre en una pestaña nueva)).

#Lee datos de X en Make con Sorsa API

Sorsa API, una API y scraper de Twitter (X), llena el vacío con una sola clave API y la app HTTP que ya tiene todo plan de Make. Para leer posts, menciones y seguidores en un escenario de Make, usa Sorsa API: 20 posts o 200 seguidores por solicitud, búsqueda desde 2006 y 20 solicitudes por segundo en todos los planes, sin cuenta de desarrollador de X y sin una conexión OAuth que renovar.

Los pasos construyen una búsqueda por palabra clave que devuelve los posts más recientes. Cada otro trabajo de abajo reutiliza el mismo keychain y módulo con una URL distinta.

1. Obtén una clave API. Regístrate y copia la clave del panel. Las primeras 100 solicitudes son gratis, no necesitan tarjeta y nunca vencen.

2. Guarda la clave en un keychain. Agrega el módulo Make a request de la app HTTP y define Authentication type como API key. En Credentials, crea un keychain: pega la clave en Key, define API key placement como In the header y API key parameter name como ApiKey. Así la clave queda fuera de los campos del módulo, y puedes rotarla después en Keys.

3. Apunta el módulo a Sorsa API. Define URL como https://api.sorsa.io/v3/search-tweets y Method como POST.

4. Envía la búsqueda como JSON. Define Body content type como application/JSON, Body input method como JSON string e ingresa un cuerpo con dos campos: query recibe cualquier búsqueda de X, operadores incluidos, y order recibe latest o popular. El curl de abajo es la misma solicitud, útil para probar una consulta antes de llevarla a Make.

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

5. Analiza la respuesta y ejecuta una vez. Define Parse response como Yes y haz clic en Run once. La salida del módulo ahora contiene Data con un arreglo tweets y un next_cursor, y todo módulo posterior puede asignar sus campos.

   {
     "tweets": [
       {
         "id": "1985417630058127650",
         "full_text": "Rebuilt our launch tracker as a make.com scenario.",
         "created_at": "2026-11-02T08:41:19Z",
         "lang": "en",
         "likes_count": 18,
         "retweet_count": 2,
         "reply_count": 4,
         "view_count": 1290,
         "user": {
           "id": "1601177354291937280",
           "username": "scenario_builder_notes",
           "display_name": "Scenario Builder Notes",
           "followers_count": 2315
         }
       }
     ],
     "next_cursor": "DAADDAABCgABG4V8kQ2W"
   }
   

   Ver respuesta completa

Agrega Flow Control > Iterator después del módulo HTTP y define su Array como el arreglo tweets bajo Data. Cada post viaja entonces por el escenario como su propio bundle con el perfil completo de su autor dentro, así que una fila de hoja o un mensaje de Slack puede mostrar el handle y el número de seguidores sin una segunda solicitud. Una respuesta 401 significa que la clave es incorrecta, y un 403 significa que falta la clave o que la cuenta no tiene solicitudes.

#Qué endpoint para qué escenario de Make

Cada trabajo de Make corresponde a un endpoint de Sorsa API, y el método del endpoint decide cómo lo pagina el módulo HTTP. La tabla lista los endpoints que más usan los escenarios de Make; la lista completa de endpoints de Sorsa API tiene los 45.

• Búsqueda por palabra clave o hashtag

  Endpoint

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

  Qué envías

  query, order

  Por solicitud

  Unos 20 posts

  Paginación en Make

  Bucle Repeater

• Posts de una cuenta

  Endpoint

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

  Qué envías

  username

  Por solicitud

  Unos 20 posts

  Paginación en Make

  Bucle Repeater

• Menciones de una marca

  Endpoint

  POST /mentions (se abre en una pestaña nueva)

  Qué envías

  query (el handle), min_likes, since_date

  Por solicitud

  Unos 20 posts

  Paginación en Make

  Bucle Repeater

• Un feed de una Lista de X

  Endpoint

  GET /list-tweets (se abre en una pestaña nueva)

  Qué envías

  list_id

  Por solicitud

  Unos 20 posts

  Paginación en Make

  Paginación integrada

• Exportación de seguidores

  Endpoint

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

  Qué envías

  username

  Por solicitud

  Hasta 200 seguidores

  Paginación en Make

  Paginación integrada

Un monitor que corre cada pocos minutos rara vez necesita una segunda página, porque unos 20 de los posts más recientes por solicitud cubren la mayoría de las palabras clave entre dos ejecuciones. La paginación importa para rellenos históricos y exportaciones, y la sección siguiente la configura.

El generador de abajo escribe el módulo para tu trabajo: elígelo, escribe una consulta, un handle o un ID de Lista, y copia los ajustes o descarga un blueprint con el módulo HTTP y un Iterator. En Make, abre un escenario vacío, elige Import blueprint en el menú de tres puntos y selecciona el archivo, y luego pega tu clave en el encabezado ApiKey o cambia el módulo al keychain del paso 2.

{
  "name": "Sorsa API: search-tweets to Iterator",
  "flow": [
    {
      "id": 1,
      "module": "http:ActionSendData",
      "version": 3,
      "parameters": {
        "handleErrors": false,
        "useNewZLibDeCompress": true
      },
      "mapper": {
        "ca": "",
        "qs": [],
        "url": "https://api.sorsa.io/v3/search-tweets",
        "gzip": true,
        "method": "post",
        "headers": [
          {
            "name": "ApiKey",
            "value": "YOUR_API_KEY"
          }
        ],
        "timeout": "",
        "useMtls": false,
        "authPass": "",
        "authUser": "",
        "bodyType": "raw",
        "serializeUrl": false,
        "shareCookies": false,
        "parseResponse": true,
        "followRedirect": true,
        "useQuerystring": false,
        "followAllRedirects": false,
        "rejectUnauthorized": true,
        "contentType": "application/json",
        "data": "{\"query\": \"make.com lang:en -filter:retweets\", \"order\": \"latest\"}"
      },
      "metadata": {
        "designer": {
          "x": 0,
          "y": 0
        }
      }
    },
    {
      "id": 2,
      "module": "builtin:BasicFeeder",
      "version": 1,
      "parameters": {},
      "mapper": {
        "array": "{{1.data.tweets}}"
      },
      "metadata": {
        "designer": {
          "x": 300,
          "y": 0
        }
      }
    }
  ],
  "metadata": {
    "instant": false,
    "version": 1,
    "scenario": {
      "roundtrips": 1,
      "maxErrors": 3,
      "autoCommit": true,
      "autoCommitTriggerLast": true,
      "sequential": false,
      "confidential": false,
      "dataloss": false,
      "dlq": false,
      "freshVariables": false
    },
    "designer": {
      "orphans": []
    }
  }
}

#Paginación: sigue next_cursor en Make

Sorsa API pagina con un cursor: cada respuesta lleva next_cursor, un token que apunta a la página siguiente, y la última página lo devuelve vacío. Cómo sigue Make el cursor depende de si el endpoint lo espera en la cadena de consulta o en el cuerpo JSON.

Endpoints GET: la paginación integrada del módulo HTTP

El módulo HTTP actual pagina por sí mismo con su tipo de paginación Token or cursor-based, y envía el cursor como parámetro de consulta, que es donde lo leen los endpoints de lista GET de Sorsa API. La documentación HTTP de Make (se abre en una pestaña nueva) lista los campos; para /followers y /list-tweets toman estos valores:

• Pagination type: Token or cursor-based.
• Items path: users para seguidores, tweets para el feed de una Lista.
• Next page token/cursor path y Page token/cursor parameter name: ambos next_cursor.
• Page size parameter: vacío, porque Sorsa API fija el tamaño de página.
• Output format y Limit: Array of items, y el máximo de elementos que una ejecución puede devolver, hasta 10K.

Un Limit de 10K seguidores toma 50 solicitudes de 200 seguidores cada una. Los mismos ajustes funcionan en /follows, /verified-followers, /list-members y /list-followers.

Endpoints POST: un bucle Repeater

La búsqueda, las cronologías y las menciones son endpoints POST que reciben next_cursor en el cuerpo JSON, como los define la referencia de la API, así que la paginación integrada no puede manejarlos. Cinco módulos sí pueden:

1. Repite. Agrega Flow Control > Repeater con Repeats definido como el máximo de páginas que una ejecución puede leer, por ejemplo 10.

2. Lee el cursor. Agrega Tools > Get variable para una variable llamada cursor.

3. Detente al final. Pon después un filtro que deje pasar la primera repetición, o un cursor que exista.

4. Pide la página. Agrega el módulo HTTP de los pasos anteriores y suma next_cursor al cuerpo, asignado a la variable. Envuelve ese campo en la función if() de Make para que la primera solicitud lo omita.

5. Guarda el siguiente cursor. Agrega Tools > Set variable que guarde el next_cursor de la respuesta como cursor, con Variable lifetime definido como One execution.

Las repeticiones posteriores a la última página se detienen en el filtro, así que gastan un crédito de Make y ninguna solicitud de Sorsa API.

Para tener en cuenta

Mantén la paginación integrada fuera de /search-tweets, /user-tweets y /mentions. Envía el cursor en la cadena de consulta, mientras que la referencia de la API define esos endpoints con el cursor en el cuerpo JSON, así que el bucle Repeater es la forma de paginarlos.

#Posts nuevos a Google Sheets o Slack

Un escenario de Make puede registrar cada post nuevo sobre una palabra clave o de un conjunto de cuentas, cada uno una sola vez y sin duplicados, con cuatro módulos: el módulo HTTP, un Iterator, un filtro y el destino. Make no tiene un trigger para posts nuevos en X, y Sorsa API no tiene webhooks, así que el escenario consulta con una programación y deja pasar solo los posts nuevos.

1. Prográmalo. Define que el escenario corra a intervalos regulares, por ejemplo cada 15 minutos, el valor predeterminado de Make.

2. Pide los posts más recientes. Usa el módulo HTTP en POST /search-tweets con order definido como latest. Para vigilar cuentas, únelas como operadores from: con OR en una sola consulta. Para cientos de cuentas, agrégalas a una Lista pública de X y llama a GET /list-tweets con su list_id: una solicitud lee el feed de una Lista de hasta 5,000 cuentas.

3. Divide los posts. Agrega un Iterator sobre el arreglo tweets.

4. Deja pasar solo los posts nuevos. Define un filtro en el enlace posterior al Iterator: created_at posterior a la hora de la ejecución menos 16 minutos, que Make escribe como addMinutes(now; -16). El minuto extra cubre el desfase de la programación, y los filtros no cuestan créditos.

5. Escribe o envía. Agrega Google Sheets > Add a row o Slack > Create a message, y asigna full_text, user.username, created_at e id.

Para una deduplicación estricta, agrega un Data store con el ID del post como clave después del filtro: Check the existence of a record, deja pasar solo los posts que aún no están guardados y Add/replace a record una vez escrita la fila. Compara los IDs como claves de texto exactas. Un ID de post tiene 19 dígitos, más de lo que un número en una fórmula guarda con exactitud, y ordenar IDs como texto pone "9" después de "10" siempre que las longitudes difieren.

La guía para exportar datos de Twitter a Google Sheets cubre el lado de la hoja: disposición de columnas, listas grandes de seguidores y una ruta con Apps Script que no necesita Make en absoluto. Para alertas en segundos y monitoreo de palabras clave a escala, consulta monitoreo de Twitter en tiempo real.

#Lo que cuestan los datos de X en Make

Un escenario de Make que lee datos de X paga dos facturas: una a la fuente de datos y otra en créditos de Make. Sorsa API cobra por solicitud, no por post: una página de búsqueda de unos 20 posts es una solicitud, así que los posts cuestan desde $0.07 por 1,000 frente a $5.00 por 1,000 en la API oficial de X, y las solicitudes fallidas nunca se cobran.

La brecha crece en seguidores y en posts con autores, porque Sorsa API devuelve 200 seguidores por solicitud y cada post con el perfil de su autor incluido:

• Posts de búsqueda, cronologías, menciones y Listas

  Sorsa API, por 1,000

  desde $0.07

  API oficial de X, por 1,000

  $5.00

• Posts con sus autores, desde el 22 de noviembre de 2026

  Sorsa API, por 1,000

  desde $0.07

  API oficial de X, por 1,000

  $15.00

• Seguidores

  Sorsa API, por 1,000

  desde $0.007

  API oficial de X, por 1,000

  $10.00

• Perfiles consultados en lotes de 100

  Sorsa API, por 1,000

  desde $0.014

  API oficial de X, por 1,000

  $10.00

Make factura su parte por ejecución de módulo: un crédito por operación, y un módulo se ejecuta una vez por cada bundle que procesa, como explica la guía de créditos de Make (se abre en una pestaña nueva). El módulo HTTP y el Iterator cuestan un crédito cada uno por ejecución, cada módulo posterior al Iterator cuesta un crédito por post que lo alcanza, y los filtros y routers no cuestan nada. El plan Free de Make incluye 1,000 créditos al mes.

Una programación de 15 minutos se ejecuta 2,880 veces en un mes de 30 días: 2,880 solicitudes de Sorsa API, que caben en los 10K del plan Starter, y 5,760 créditos de Make antes de escribir el primer post. La calculadora de abajo suma ambas facturas para tu programación.

El precio es una de cinco comprobaciones antes de conectar una fuente de datos de X a Make. Sorsa API pasa cada una con un número:

• Configuración

  Sorsa API en un escenario de Make

  Una clave API en un keychain; sin app de desarrollador y sin conexión OAuth que renovar

• Velocidad

  Sorsa API en un escenario de Make

  20 solicitudes por segundo en todos los planes, cuentas gratuitas incluidas

• Cobertura

  Sorsa API en un escenario de Make

  Búsqueda desde 2006, cronologías, menciones, seguidores y Listas en 45 endpoints

• Seguridad de la cuenta

  Sorsa API en un escenario de Make

  Nunca pide tu inicio de sesión ni tus cookies de X, así que ninguna cuenta tuya de X corre riesgo

• Fiabilidad

  Sorsa API en un escenario de Make

  En producción desde 2022; un esquema de respuesta estable, así que tus campos se mantienen igual

#Construye tu primer escenario de X en Make

Make eliminó su app de X en 2025, y un solo módulo HTTP con un encabezado de clave hace ahora toda la lectura. Construye ese módulo sobre Sorsa API: un keychain ApiKey en lugar de una app OAuth, 20 posts o 200 seguidores por solicitud, desde $0.07 por 1,000 posts, y 100 solicitudes gratis que cubren tus primeros 2,000 posts.

¿Trabajas con otra herramienta? Las guías de la API de Twitter en n8n y la API de Twitter en Zapier configuran las mismas lecturas en esas plataformas.

#Preguntas frecuentes