Exportar datos de Twitter a Google Sheets

#Cómo llegan los datos de Twitter a Google Sheets

Los datos de Twitter llegan a Google Sheets de una de cuatro maneras, y las cuatro necesitan una fuente de datos que devuelva JSON: un Apps Script que llama a una API con un temporizador, un complemento conector que envía una URL con un header desde dentro de la hoja, una herramienta de automatización como n8n, Make o Zapier con un paso de Google Sheets, o un archivo CSV que descargas y traes con Archivo > Importar. Para un archivo puntual, la herramienta gratuita Exportar tweets de Twitter a CSV escribe el CSV por ti.

Las fórmulas no cuentan como una quinta vía. IMPORTXML e IMPORTHTML leen una sola página web, y x.com no muestra una lista de seguidores ni una búsqueda a un visitante que no inició sesión, así que una fórmula no tiene nada que recorrer, y se rompe cada vez que x.com cambia su diseño.

• Apps Script (esta guía)

  Qué configuras

  Un script, pegado una vez

  Se actualiza sola

  Sí, con un activador por tiempo

  Recorre los resultados por páginas

  Sí, de cualquier longitud

• Complemento conector

  Qué configuras

  Una URL y un header en el formulario del complemento

  Se actualiza sola

  Sí, con el horario del complemento

  Recorre los resultados por páginas

  Depende del complemento

• n8n, Make o Zapier

  Qué configuras

  Un escenario con un paso de Google Sheets

  Se actualiza sola

  Sí

  Recorre los resultados por páginas

  Sí, con un bucle

• Archivo CSV

  Qué configuras

  Una descarga, luego Archivo > Importar

  Se actualiza sola

  No

  Recorre los resultados por páginas

  La herramienta lo hace

La fuente de datos es lo que decide el costo y el esfuerzo. La API oficial de X necesita una cuenta de desarrollador, una app y OAuth, y su plan de pago por uso cobra $0.005 por post leído y $0.010 por seguidor o perfil, con un tope de 3M 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, el perfil de un autor que se devuelve con un post también se cobra a $0.010, así que un post con su autor cuesta $0.015 (aviso de X del 23 de octubre (se abre en una pestaña nueva)). La guía sobre cómo hacer scraping de Twitter compara todas las formas de sacar datos públicos de X, más allá de las hojas de cálculo.

#Importa tweets a Google Sheets con Sorsa API

Sorsa API, una API y scraper de Twitter (X), responde a cualquier solicitud HTTP que lleve un header ApiKey, que es todo lo que necesita UrlFetchApp de Apps Script. Para llevar tweets, seguidores y perfiles a Google Sheets, usa Sorsa API: 20 tweets o 200 seguidores por solicitud, búsqueda hasta 2006, 20 solicitudes por segundo en todos los planes, y sin cuenta de desarrollador de X, app OAuth ni login de X.

El script de abajo agrega un menú "X data" a tu hoja de cálculo. Importa los posts nuevos de una búsqueda, exporta la lista completa de seguidores de una cuenta y te da una fórmula =X_PROFILES(). La configuración toma seis pasos.

1. Consigue una clave API. Regístrate y copia la clave del dashboard. Las primeras 100 solicitudes son gratis, no piden tarjeta y nunca vencen.

2. Abre el editor de scripts. En tu hoja de cálculo elige Extensiones > Apps Script. Se abre un proyecto vinculado a esta hoja.

3. Pega el script. Reemplaza todo en Code.gs con el código de abajo, y luego fija SEARCH con tu consulta y ACCOUNT con el handle cuyos seguidores quieres. La consulta acepta cualquier operador de búsqueda de X; los operadores de búsqueda de Twitter los lista.

   // Twitter (X) data to Google Sheets with Sorsa API.
   // Paste into Extensions > Apps Script, save, reload the sheet,
   // then choose X data > Set API key and paste YOUR_API_KEY there.
   
   const API = 'https://api.sorsa.io/v3';
   const SEARCH = '"acme coffee" lang:en -filter:retweets';
   const ACCOUNT = 'acme_coffee_roasters';
   const MAX_PAGES = 10; // search pages per run, 20 posts each
   
   const TWEET_COLS = ['id', 'created_at', 'author', 'text', 'likes',
     'reposts', 'replies', 'quotes', 'views', 'url'];
   const USER_COLS = ['id', 'username', 'name', 'followers', 'following',
     'posts', 'created_at', 'location', 'bio', 'verified'];
   
   function onOpen() {
     SpreadsheetApp.getUi().createMenu('X data')
       .addItem('Set API key', 'setApiKey')
       .addItem('Import new search results', 'importSearch')
       .addItem('Export followers', 'exportFollowers')
       .addToUi();
   }
   
   function setApiKey() {
     const ui = SpreadsheetApp.getUi();
     const answer = ui.prompt('Paste your Sorsa API key');
     if (answer.getSelectedButton() !== ui.Button.OK) return;
     PropertiesService.getUserProperties()
       .setProperty('SORSA_API_KEY', answer.getResponseText().trim());
   }
   
   // One request: GET params go in the URL, POST params in a JSON body.
   function sorsa_(method, path, params) {
     const key = PropertiesService.getUserProperties()
       .getProperty('SORSA_API_KEY');
     if (!key) throw new Error('Run X data > Set API key first.');
     const options = { method: method, headers: { ApiKey: key },
       muteHttpExceptions: true };
     let url = API + path;
     if (method === 'get') {
       url += '?' + Object.keys(params).map((k) => [].concat(params[k])
         .map((v) => k + '=' + encodeURIComponent(v)).join('&')).join('&');
     } else {
       options.contentType = 'application/json';
       options.payload = JSON.stringify(params);
     }
     for (let attempt = 1; attempt <= 3; attempt++) {
       const res = UrlFetchApp.fetch(url, options);
       const code = res.getResponseCode();
       if (code === 200) return JSON.parse(res.getContentText());
       if (code !== 429) throw new Error(code + ' ' + res.getContentText());
       Utilities.sleep(1000 * attempt); // over 20 requests a second
     }
     throw new Error('429 three times in a row');
   }
   
   function sheet_(name, cols) {
     const book = SpreadsheetApp.getActiveSpreadsheet();
     const sh = book.getSheetByName(name) || book.insertSheet(name);
     if (sh.getLastRow() === 0) {
       sh.getRange('A:A').setNumberFormat('@'); // 19-digit IDs stay text
       sh.appendRow(cols);
       sh.setFrozenRows(1);
     }
     return sh;
   }
   
   function append_(sh, rows) {
     if (!rows.length) return;
     sh.getRange(sh.getLastRow() + 1, 1, rows.length, rows[0].length)
       .setValues(rows);
   }
   
   // Text that starts with = + or - would be read as a formula.
   function safe_(s) {
     s = s || '';
     return /^[=+-]/.test(s) ? "'" + s : s;
   }
   
   function tweetRow_(t) {
     const u = t.user || {};
     return [t.id, new Date(t.created_at), '@' + u.username,
       safe_(t.full_text), t.likes_count || 0, t.retweet_count || 0,
       t.reply_count || 0, t.quote_count || 0, t.view_count || 0,
       'https://x.com/' + u.username + '/status/' + t.id];
   }
   
   function userRow_(u) {
     return [u.id, u.username, safe_(u.display_name), u.followers_count,
       u.followings_count, u.tweets_count, new Date(u.created_at),
       safe_(u.location), safe_(u.description), u.verified];
   }
   
   // New posts for SEARCH, newest first, until the first ID already in
   // the sheet. They are appended oldest first, so the sheet reads as a log.
   function importSearch() {
     const sh = sheet_('Search', TWEET_COLS);
     const last = sh.getLastRow();
     const seen = new Set(last > 1 ?
       sh.getRange(2, 1, last - 1, 1).getDisplayValues().flat() : []);
     const rows = [];
     let cursor = null;
     pages: for (let page = 0; page < MAX_PAGES; page++) {
       const body = { query: SEARCH, order: 'latest' };
       if (cursor) body.next_cursor = cursor;
       const res = sorsa_('post', '/search-tweets', body);
       for (const t of res.tweets || []) {
         if (seen.has(t.id)) break pages;
         seen.add(t.id);
         rows.push(tweetRow_(t));
       }
       cursor = res.next_cursor;
       if (!cursor) break;
     }
     append_(sh, rows.reverse());
   }
   
   // Every follower of ACCOUNT, 200 per request. Each run stops after five
   // minutes, under the six-minute limit, and the next run resumes from
   // the saved cursor. Delete FOLLOWERS_CURSOR to start a new export.
   function exportFollowers() {
     const props = PropertiesService.getUserProperties();
     let cursor = props.getProperty('FOLLOWERS_CURSOR');
     if (cursor === 'done') return;
     const sh = sheet_('Followers', USER_COLS);
     const stopAt = Date.now() + 5 * 60 * 1000;
     while (Date.now() < stopAt) {
       const params = { username: ACCOUNT };
       if (cursor) params.next_cursor = cursor;
       const res = sorsa_('get', '/followers', params);
       append_(sh, (res.users || []).map(userRow_));
       cursor = res.next_cursor;
       props.setProperty('FOLLOWERS_CURSOR', cursor || 'done');
       if (!cursor) return;
     }
   }
   
   /**
    * Profiles for up to 100 handles from one request: =X_PROFILES(A2:A101)
    * @param {string[][]} handles A column of X handles, with or without @.
    * @return {Array[]} One row per handle, in the same order.
    * @customfunction
    */
   function X_PROFILES(handles) {
     const names = [].concat(handles).flat()
       .map((h) => String(h).trim().replace(/^@/, '')).slice(0, 100);
     const ask = names.filter((h) => h);
     if (!ask.length) return '';
     const res = sorsa_('get', '/info-batch', { usernames: ask });
     const found = {};
     for (const u of res.users || []) found[u.username.toLowerCase()] = u;
     const blank = USER_COLS.map(() => '');
     return names.map((h) => found[h.toLowerCase()] ?
       userRow_(found[h.toLowerCase()]) : blank);
   }
   
   // Run once: search every hour, followers every 10 minutes until done.
   function createTriggers() {
     ScriptApp.getProjectTriggers().forEach((t) => ScriptApp.deleteTrigger(t));
     ScriptApp.newTrigger('importSearch').timeBased().everyHours(1).create();
     ScriptApp.newTrigger('exportFollowers').timeBased().everyMinutes(10)
       .create();
   }
   

4. Guarda y recarga la hoja. Presiona Ctrl+S (Cmd+S en Mac), cierra el editor y recarga la pestaña de la hoja de cálculo. El menú "X data" aparece junto a Ayuda.

5. Guarda la clave. Elige X data > Set API key y pega tu clave. El script la conserva en tus propiedades de usuario, así que nunca queda en una celda, en el código ni en una copia de la hoja que compartas.

6. Corre la primera importación. Elige X data > Import new search results y permite los dos permisos que pide Google: esta hoja de cálculo y las conexiones a un servicio externo. Aparece una pestaña Search con hasta 200 posts, los más antiguos arriba.

La búsqueda del script llama a POST /search-tweets (se abre en una pestaña nueva) con order en latest. Cada respuesta contiene hasta 20 posts, cada uno con el perfil completo de su autor, y un next_cursor para la página siguiente. Un cursor es un token que apunta a la página siguiente de resultados; la última página vuelve sin uno. Para llenar una hoja con los posts de una cuenta en lugar de una búsqueda, llama a POST /user-tweets (se abre en una pestaña nueva) con un username en el cuerpo; la guía para descargar todos los tweets de un usuario cubre ese endpoint a fondo.

{
  "tweets": [
    {
      "id": "2116630142857191424",
      "full_text": "Our Ethiopia natural roast is back on the menu.",
      "created_at": "2026-11-01T14:03:00Z",
      "lang": "en",
      "likes_count": 42,
      "retweet_count": 5,
      "reply_count": 3,
      "quote_count": 1,
      "view_count": 3810,
      "bookmark_count": 2,
      "user": {
        "id": "1500000000000000004",
        "username": "acme_coffee_roasters",
        "display_name": "Acme Coffee Roasters",
        "followers_count": 12840
      }
    }
  ],
  "next_cursor": "DAACCgACG3eLqJBAJxAKAAMbd4uokD-nGAgABAAAAAIAAA"
}

#Qué llega a cada columna

Cada post se convierte en una fila de diez columnas, y tres de ellas necesitan un cuidado que una copia simple del JSON haría mal. La tabla asigna cada columna a su campo en la respuesta.

• id

  Campo en la respuesta

  id

  Qué hace el script

  Lo escribe en una columna con formato de texto simple

• created_at

  Campo en la respuesta

  created_at

  Qué hace el script

  Convierte la cadena ISO 8601 en una fecha real

• author

  Campo en la respuesta

  user.username

  Qué hace el script

  Agrega la @

• text

  Campo en la respuesta

  full_text

  Qué hace el script

  Agrega un apóstrofo antes de un =, + o - inicial

• likes, reposts, replies, quotes, views

  Campo en la respuesta

  likes_count, retweet_count, reply_count, quote_count, view_count

  Qué hace el script

  Escribe 0 donde falta una cantidad

• url

  Campo en la respuesta

  armada con user.username e id

  Qué hace el script

  Enlaza al post en x.com

Las tres trampas, cada una una causa conocida de hojas rotas:

• Los ID de tweets pierden dígitos como números. Un ID de post de X tiene 19 dígitos y Google Sheets conserva 15 dígitos significativos, así que una celda numérica convierte los últimos cuatro en ceros y el ID ya no apunta al post. El script da formato de texto simple a la columna A antes de escribir la primera fila.
• El texto de un post puede parecer una fórmula. Un post que empieza con "=", "+" o "-" lo lee Sheets como una fórmula y muestra un error. El script pone un apóstrofo delante, que Sheets oculta y deja el texto como texto.
• Las fechas deben ordenarse como fechas. La API devuelve created_at en ISO 8601, así que new Date() la lee directamente, y la columna se ordena, filtra y grafica como fecha.

Los duplicados nunca llegan a la hoja. Antes de cada búsqueda el script lee los ID que ya están en la columna A, pide primero los posts más recientes y se detiene en el primer post que ya guardó, así que una corrida que no encuentra nada nuevo cuesta una solicitud.

#Mantén la hoja actualizada con un horario

Un activador por tiempo corre la importación por sí solo, y createTriggers() configura dos de una vez: la búsqueda cada hora y la exportación de seguidores cada 10 minutos hasta que termine. Abre el editor de scripts, elige createTriggers en la lista de funciones y presiona Ejecutar una vez. Google corre las funciones como tú, con tu clave, esté abierta la hoja o no.

Una búsqueda cada hora que encuentra una página de posts nuevos usa 720 solicitudes al mes, el 7% de las 10K del plan Starter. Apps Script en sí es gratis, y una corrida cada hora queda muy por dentro de sus límites en una cuenta de Google gratuita. Estos son los límites de la página de cuotas de Apps Script (se abre en una pestaña nueva) de Google que dan forma al script:

• Llamadas de URL Fetch al día

  Cuenta de Google gratuita

  20K

  Google Workspace

  100K

• Tiempo de ejecución de una corrida

  Cuenta de Google gratuita

  6 minutos

  Google Workspace

  6 minutos

• Tiempo de ejecución de activadores al día

  Cuenta de Google gratuita

  90 minutos

  Google Workspace

  6 horas

• Tiempo de ejecución de una función personalizada

  Cuenta de Google gratuita

  30 segundos

  Google Workspace

  30 segundos

Los activadores por tiempo también pueden correr cada 1, 5, 10, 15 o 30 minutos, o una vez al día a la hora que elijas. Google te envía un correo cuando falla una corrida activada, con el error que lanzó el script.

Para tener en cuenta

La búsqueda se detiene después de MAX_PAGES páginas, 200 posts por defecto. Si una consulta muy activa recibe más de 200 posts nuevos entre dos corridas, se omiten los más antiguos. Sube MAX_PAGES o corre el activador con más frecuencia para nombres de marca y hashtags con mucho tráfico.

#Exporta una lista completa de seguidores a Google Sheets

Para exportar todos los seguidores de una cuenta a Google Sheets, recorre GET /followers (se abre en una pestaña nueva) de a 200 perfiles y agrega cada página; una lista de 10K seguidores toma 50 solicitudes. Elige X data > Export followers, y el script llena una pestaña Followers con el ID, handle, nombre, cantidad de seguidores y de seguidos, cantidad de posts, fecha de ingreso, ubicación, bio e indicador de verificado de cada seguidor.

Las listas largas no caben en una sola corrida, y el script está hecho para eso. Apps Script detiene cualquier ejecución a los 6 minutos, así que exportFollowers() trabaja cinco, guarda el cursor en tus propiedades de usuario y termina. La corrida siguiente, desde el menú o desde el activador de 10 minutos, parte de ese cursor, y la corrida que recibe una página sin cursor marca la exportación como terminada. Una lista de 300K seguidores son 1,500 páginas de 200 y llena la pestaña en tantas corridas como haga falta, sin pedir ninguna página dos veces.

Los seguidores son donde la brecha de precio es más amplia. La API oficial de X cobra $0.010 por cada seguidor que devuelve, así que una lista de 100K cuesta $1,000; Sorsa API devuelve la misma lista desde $0.70, desde $0.007 por 1,000 seguidores. Tus 100 solicitudes gratis cubren los primeros 20K seguidores. Para guardar una lista de seguidores como archivo CSV o Excel en lugar de una hoja, mira cómo exportar seguidores de Twitter.

#Llena una tabla de perfiles con una fórmula

=X_PROFILES(A2:A101) convierte una columna de hasta 100 handles en una tabla de perfiles con una solicitud. Escribe los handles en la columna A, con o sin la @, y pon la fórmula en B2: las filas se derraman a la derecha y hacia abajo, una por handle, en el mismo orden, con una fila en blanco donde una cuenta no existe. La función llama a GET /info-batch (se abre en una pestaña nueva), que devuelve hasta 100 perfiles por solicitud, desde $0.014 por 1,000.

Una función personalizada sigue las reglas de Google para ellas, listadas en la guía de funciones personalizadas de Google (se abre en una pestaña nueva):

• Debe terminar en 30 segundos, lo que una solicitud cumple con holgura.
• Se vuelve a ejecutar solo cuando cambian los handles del rango. Para actualizar las cantidades, edita una celda del rango o vuelve a escribir la fórmula.
• Lee la clave de las propiedades de usuario del dueño de la hoja, así que funciona para todos los que pueden editar la hoja sin compartir la clave.
• Nunca le pases NOW() ni RAND(): Google deja una función personalizada con un argumento volátil en "Cargando..." para siempre.

Para un historial con fechas de las cantidades de seguidores, conserva la fórmula para la vista en vivo y copia sus filas a una pestaña de registro con un activador diario.

#Cuánto cuesta y cuánto cabe en una hoja

Sorsa API cobra por solicitud, no por fila, así que el precio de una hoja depende de cuántas filas devuelve cada solicitud, y cada tipo de fila cuesta una fracción de la tarifa de la API oficial de X. La tabla muestra el precio por 1,000 filas de cada tipo de dato que escribe el script.

• Tweets de una búsqueda o de una línea de tiempo

  Sorsa API, por 1,000 filas

  desde $0.07

  Filas por solicitud

  20

  API oficial de X, por 1,000 filas

  $5.00

• Seguidores de una cuenta

  Sorsa API, por 1,000 filas

  desde $0.007

  Filas por solicitud

  200

  API oficial de X, por 1,000 filas

  $10.00

• Perfiles de una lista de handles

  Sorsa API, por 1,000 filas

  desde $0.014

  Filas por solicitud

  100

  API oficial de X, por 1,000 filas

  $10.00

Google también tiene un techo. Una hoja de cálculo admite hasta 20 millones de celdas, según los límites de archivos de Google Drive (se abre en una pestaña nueva), así que con las diez columnas del script una hoja de cálculo admite poco menos de 2 millones de filas. Elige un tipo de datos y una cantidad de filas para ver las dos facturas y cuánto de una hoja ocupan.

Las solicitudes fallidas nunca se cobran, y los planes solo se diferencian en cuántas solicitudes incluyen cada mes.

#Usa un complemento conector, n8n, Make o Zapier en su lugar

Sorsa API funciona con cualquier herramienta que pueda enviar una solicitud HTTPS con un header personalizado, así que las vías sin código no necesitan un script. No hay un complemento de Sorsa API para Google Sheets; un complemento conector general del Google Workspace Marketplace hace el trabajo cuando le das tres cosas:

• la URL, por ejemplo https://api.sorsa.io/v3/followers?username=acme_coffee_roasters;
• un header llamado ApiKey con tu clave como valor, nunca la clave en la URL;
• el arreglo users o tweets como los datos que se escriben, y next_cursor como el token de paginación, si el complemento recorre los resultados por páginas.

Las herramientas de automatización aceptan la misma solicitud. La guía de la API de Twitter en n8n construye un flujo con un Schedule Trigger, un nodo HTTP Request con una credencial Header Auth, un nodo Split Out y un nodo de Google Sheets que agrega filas. El módulo HTTP de Make y la acción Custom Request de Zapier envían la misma solicitud; las guías de la API de Twitter en Make y en Zapier cubren su configuración.

Para una copia única sin ninguna herramienta, descarga el CSV de una herramienta de exportación gratuita y elige Archivo > Importar > Subir en Google Sheets. La herramienta gratuita Exportar seguidores de Twitter a CSV hace lo mismo con las listas de seguidores.

#Soluciona los errores de Apps Script y de la API

La mayoría de los fallos aparecen como un mensaje en el registro de ejecución de Apps Script o en el correo de fallo de Google, y cada uno tiene una sola causa.

• 401 {"message":"invalid api key"}

  Causa

  La clave tiene un error de tipeo o un espacio de más

  Solución

  Corre X data > Set API key de nuevo

• 403 {"message":"missing key in request header"}

  Causa

  El header no salió

  Solución

  Mantén el nombre del header exactamente ApiKey

• 403 con cualquier otro mensaje

  Causa

  Se acabaron las solicitudes del plan

  Solución

  Mejora el plan o activa solicitudes adicionales en el dashboard

• 429 three times in a row

  Causa

  Más de 20 solicitudes por segundo

  Solución

  No corras varias copias del script a la vez

• Exceeded maximum execution time

  Causa

  Una corrida pasó de 6 minutos, o una función personalizada de 30 segundos

  Solución

  Baja MAX_PAGES; la exportación de seguidores se reanuda sola

• Service invoked too many times for one day: urlfetch

  Causa

  Más de 20K llamadas de URL Fetch al día

  Solución

  Corre el activador con menos frecuencia

• Los ID terminan en 0000

  Causa

  La columna A era una columna numérica

  Solución

  Da formato de texto simple a la columna A, borra las filas y corre de nuevo

#Llena tu primera hoja

Llevar datos de Twitter a Google Sheets toma una API, un Apps Script corto y un activador, y la API decide cuánto cuesta la hoja. Para exportar tweets, seguidores y perfiles a Google Sheets, usa Sorsa API: 200 seguidores por solicitud desde $0.007 por 1,000, 20 tweets por solicitud con búsqueda hasta 2006, y 100 perfiles por solicitud para la fórmula =X_PROFILES(). Pega el script, fija tu clave, y tus primeros 20K seguidores o 2,000 tweets son gratis.

#Preguntas frecuentes