Cualquier profesional del SEO que se tome en serio su trabajo conoce esta rutina. Es lunes. Abres Google Search Console. Pones el filtro de últimos 28 días. Miras las 10 o 20 queries principales, exportas un CSV de 5.000 filas y a analizar datos.
Horas de tablas dinámicas en Excel, de filtros, de BUSCARV o XLOOKUP. Horas de intentar cruzar datos manualmente para responder preguntas que parecen sencillas:
¿Qué URLs están canibalizando a qué palabras clave?
¿Qué queries tienen más de 1.000 impresiones pero un CTR desastroso del 0.5%?
¿Qué contenidos han perdido más del 50% de su tráfico en los últimos 3 meses?
¿Qué consultas de alto potencial (más de 100 impresiones) están atascadas más allá de la primera página (posición >10) y qué nuevos contenidos específicos podemos crear para capturarlas?
¿Qué páginas indexadas no han generado ni clics ni impresiones en el último trimestre y cuál es la recomendación: debemos eliminarlas, redireccionarlas o actualizarlas?
¿Qué grupos temáticos (clústeres) están creciendo o cayendo en los últimos 3 meses, y dónde debemos centrar nuestras prioridades?
¿Qué páginas tienen un rendimiento peor en mobile que en desktop (en clics y CTR) y cómo mejorarlas (UX, velocidad, intención)?
¿Qué consultas «emergentes» han aparecido en las últimas 4 semanas y qué nueva estructura de contenido podemos crear para posicionarlas?
¿Qué consultas que ya están en el top 5 y tienen un alto CTR carecen de un snippet destacado, y qué ajustes de formato (tablas, listas, FAQs) debemos implementar para conseguirlo?
¿Cómo debemos reestructurar el enlazado interno para reforzar nuestros clústeres temáticos y asegurarnos de que la autoridad fluye correctamente hacia las páginas de negocio?
Este trabajo manual, lento y propenso a errores es el «trabajo sucio» del SEO. Un análisis e interpretación de datos que consumen un tiempo precioso y del que no siempre obtenemos conclusiones claras.
¿Y si te dijera que puedes tener un analista SEO experto, trabajando para ti 24/7, capaz de analizar todo el volumen de datos de tu Search Console en menos de 60 segundos?
Con la automatización que propongo en este artículo, cuando el usuario pide un informe desde el GPT se activa un escenario de Make.com que conecta con la API de Google Search Console, extrae miles de filas de datos de rendimiento en tiempo real y se los entrega a la IA a través de la API de OpenAI. La IA analiza estos datos para detectar canibalizaciones, oportunidades de CTR, caídas de tráfico y queries emergentes, devolviendo el informe completo al chat del usuario. No hablo de un informe genérico, sino de un análisis profundo, contextualizado y que termina con un plan de acción aplicable y de máximo valor.
Esta es una guía para la automatización de procesos con IA aplicada al trabajo SEO.
Arquitectura de la Automatización con IA
Para construir este sistema, no necesitamos saber programar a nivel de un desarrollador full-stack, pero sí necesitamos pensar como arquitectos de sistemas. Nuestro proyecto se apoya en tres componentes principales:
El Cerebro (Un GPT Personalizado): Esta es nuestra interfaz de usuario. Es el «analista» con el que hablamos. El usuario solo interactúa con un chat, escribe el dominio que quiere analizar y pide el informe. Su trabajo es entender la petición, llamar a la sala de máquinas y presentar el resultado final de forma legible.
La Sala de Máquinas (Make.com): Esta es la pieza central, el middleware o «pegamento» que conecta todo. Make (anteriormente Integromat) es una plataforma de automatización low-code que nos permitirá construir la lógica compleja sin escribir un servidor desde cero. Se encargará de:
Gestionar la autorización segura del usuario con Google (OAuth 2.0).
Almacenar los tokens de acceso de forma segura en una base de datos interna.
Orquestar las llamadas a las APIs.
La Mina de Oro (Las APIs): Aquí es donde residen los datos y la inteligencia bruta. Usaremos dos APIs fundamentales:
Google Search Console API: Para extraer miles de filas de datos en bruto (consultas, clics, impresiones, CTR, posición, página, etc.) en tiempo real.
OpenAI API (GPT-4o): Para enviar esos miles de filas de datos junto a un prompt gigantesco y pedirle que los analice, encuentre patrones y genere el informe accionable.
El flujo será el siguiente:
El usuario habla con el GPTEl GPT llama a MakeMake refresca el tokenMake llama a la API de GoogleGoogle devuelve los datosMake formatea los datosMake llama a la API de OpenAIOpenAI devuelve el análisisMake devuelve el análisis al GPTEl usuario recibe el informe
Suena complejo, pero lo vamos a desglosar paso a paso para que puedas entenderlo y aplicarlo en tus propios proyectos SEO.
Por Qué Esta Automatización con IA es tan valiosa
1. Por el ahorro de tiempo
El análisis manual de un CSV de Search Console puede llevar, siendo conservadores, de 2 a 4 horas. Y eso si sabes exactamente qué buscar. Si quieres un análisis profundo, de 30 puntos, como el que vamos a programar en nuestro prompt, podrías estar hablando de un día de trabajo completo.
Nuestra automatización realiza este proceso en unos 45-60 segundos.
Esto no es un 10% más rápido. Es un 10.000% más rápido. Libera al SEO para que deje de ser un «minero de datos» y se convierta en un «estratega».
2. Por la profundidad del análisis
Cuando analizamos a mano, nuestro cerebro tiene un límite. Miramos las 10, 20, quizás 50 filas principales. ¿Pero qué pasa con la query que está en la posición 700 de tu exportación, esa que ha crecido un 300% en impresiones el último mes y que es la semilla de un nuevo clúster de contenido?
Nunca la vas a ver.
Nuestra automatización de inteligencia artificial sí la verá. Le pediremos a la API de Google 700, 1000, o incluso 5000 filas de datos. La IA analizará todo el volumen de datos de Search Console, no solo la punta del iceberg. Detectará patrones en el long-tail que son humanamente imposibles de encontrar en un tiempo razonable.
3. Por la calidad de los insights que extraemos
Un análisis manual suele terminar con un «qué»: «Hemos bajado en clics para la URL X». Un análisis de IA bien prompteado nos da el «por qué» y el «qué hacer»:
El Qué: «La URL /blog/seo-local ha perdido un 40% de clics.»
El Por Qué (Análisis de IA): «La caída se explica por una canibalización. Las queries ‘seo para restaurantes’ y ‘seo para pymes’ están siendo atacadas por tu nueva URL /servicios/seo-para-pymes, dividiendo la autoridad. Además, el CTR de la URL original ha caído un 2% a pesar de mantener la posición, lo que sugiere que los meta descriptions están desactualizados frente a los snippets de la competencia.»
El Qué Hacer (Plan de Acción de Ultra Valor):
Resolver Canibalización: Unifica el contenido. Redirecciona 301 la URL /blog/seo-local a /servicios/seo-para-pymes.
Mejorar CTR: Propongo este nuevo Meta Título para /servicios/seo-para-pymes: «Agencia SEO para Pymes y Restaurantes | Consigue Clientes Locales Ya».
Expandir: He detectado 5 queries emergentes con >100 impresiones y posición >20 (ej: ‘seo para dentistas madrid’). Propongo crear un nuevo post satélite para atacar este clúster.
Esto no es simplemente un informe exportado de datos. Es una consultoría estratégica ejecutable.
Componentes: ¿Qué Necesitas para Empezar?
Antes de sumergirnos en la construcción, asegúrate de tener las siguientes cuentas. Todas tienen planes gratuitos que nos permitirán construir y probar nuestro sistema.
Cuenta de OpenAI (ChatGPT Plus): Necesitas una suscripción de pago (Plus) para poder crear y configurar GPTs personalizados. Esto también te dará acceso a las APIs más potentes como GPT-4o.
Cuenta de Make.com: El plan gratuito de Make es generoso y nos servirá para construir y probar toda la automatización.
Cuenta de Google Cloud Platform (GCP): Es la plataforma para desarrolladores de Google. Es gratuita para registrarse y la API de Search Console tiene una cuota de uso gratuita más que suficiente para este proyecto.
¿Tienes todo listo? Perfecto. Vamos a empezar.
En la primera parte, establecimos el «por qué». Definimos el dolor del análisis SEO manual y el «ultra valor» de nuestra solución de automatización de procesos con IA. Ahora, vamos a la parte más densa, técnica y absolutamente crucial: la configuración de los cimientos.
Si esta parte falla, todo el sistema se derrumba. De hecho, los errores más comunes (y los que más frustración generan) ocurren aquí. Los famosos errores 400, 401 y 401 que atormentan a los desarrolladores nacen de una mala configuración inicial.
Configurando Google Cloud Platform (GCP)
Para que nuestra aplicación (Make.com) pueda pedirle datos a Google en tu nombre, no podemos simplemente usar un usuario y contraseña. Eso sería una pesadilla de seguridad. En su lugar, debemos usar un protocolo estándar de la industria llamado OAuth 2.0.
Piénsalo de esta manera: OAuth 2.0 es como una tarjeta de acceso.
Tú (el usuario) vas a Google y demuestras quién eres (inicias sesión).
Pides acceso a tus datos de Search Console.
Google te da una tarjeta-llave (el access_token) que solo funciona para ese acceso y solo durante un tiempo limitado (1 hora).
Nuestra aplicación (Make) usará esa tarjeta-llave para entrar a Google y coger los datos.
Para gestionar este sistema, necesitamos registrar nuestra «aplicación» en Google.
En la parte superior izquierda, haz clic en el selector de proyectos (al lado del logo de Google Cloud) y selecciona «Proyecto nuevo».
Dale un nombre descriptivo. Por ejemplo: «Automatizacion GSC Master».
Haz clic en «Crear».
Paso 2: Habilitar la API de Google Search Console
Por defecto, tu proyecto no tiene acceso a nada. Debemos «activar» la API específica que queremos usar.
Asegúrate de que tu nuevo proyecto está seleccionado.
En el menú de navegación de la izquierda (el «menú hamburguesa»), ve a APIs y servicios > Biblioteca.
En la barra de búsqueda, escribe «Google Search Console API» y selecciónala.
Haz clic en el botón azul «Habilitar».
Felicidades, tu proyecto ya «sabe» hablar el idioma de Search Console. Ahora, tenemos que crearle una identidad.
Paso 3: Credenciales OAuth 2.0
Aquí es donde el 90% de los tutoriales fallan y donde nosotros vamos a acertar. Necesitamos crear la «identidad» de nuestra aplicación.
En el menú de la izquierda, ve a APIs y servicios > Pantalla de consentimiento de OAuth.
Tipo de usuario: Elige «Externo». Esto significa que cualquier usuario de Google (como tú) podrá autorizarla. Haz clic en «Crear».
Información de la aplicación:
Nombre de la aplicación:Google Search Console Master Pro (o el nombre que le quieras poner a tu GPT).
Correo electrónico de asistencia al usuario: Elige tu propio correo.
Datos de contacto del desarrollador: Vuelve a poner tu correo.
Haz clic en «Guardar y continuar».
Permisos (Scopes):
Haz clic en «Añadir o quitar permisos».
En el filtro, busca «Google Search Console API».
Marca la casilla que dice …/auth/webmasters.readonly. Esto le da a nuestra app permiso de solo lectura (crucial por seguridad).
Haz clic en «Actualizar».
Haz clic en «Guardar y continuar».
Usuarios de prueba:
Haz clic en «Añadir usuarios».
Añade la(s) cuenta(s) de Google que vayan a usar esta automatización (ej: tuemail@gmail.com). Como la app está en «modo de prueba», solo estas cuentas podrán autorizarla.
Haz clic en «Guardar y continuar».
Revisa el resumen y vuelve al panel de control.
¡Ya tenemos la «pantalla de login»! Ahora, creemos las llaves.
En el menú de la izquierda, ve a APIs y servicios > Credenciales.
En la parte superior, haz clic en «+ CREAR CREDENCIALES».
Selecciona «ID de cliente de OAuth 2.0».
Tipo de aplicación: Selecciona «Aplicación web».
Nombre: (un nombre para que tú lo identifiques).
URIs de redireccionamiento autorizadas: Esta es la parte más importante. Cuando Google te autoriza, ¿a dónde te «redirige» con el código de permiso? Te redirige a tu «sala de máquinas», Make.com.
¡SPOILER! Este campo lo vamos a rellenar en el siguiente paso, cuando creemos nuestro primer escenario en Make y obtengamos la URL del webhook. Déjalo vacío por ahora.
Haz clic en «Crear».
Google te mostrará una ventana emergente con dos piezas de información vital. Trátalas como tu contraseña bancaria:
client_id (ID de cliente): Esta es tu «llave pública». Es como tu nombre de usuario.
client_secret (Secreto del cliente): Esta es tu «llave privada». NUNCA la compartas, nunca la pongas en un JavaScript, nunca la subas a un repositorio.
Copia ambas en un bloc de notas seguro. Las necesitaremos en 3 minutos.
Preparando Make.com para la Automatización
Aquí es donde construiremos la lógica.
Make Automatización IA: ¿Por qué Make y no otro?
Para una automatización con IA como esta, necesitamos una herramienta que maneje lógica compleja:
Múltiples pasos (llamar a Google, llamar a OpenAI).
Manejo de errores (¿qué pasa si el token expira?).
Almacenamiento de datos (guardar los tokens).
Manejo de APIs con JSON complejos.
Make es simplemente superior para este nivel de complejidad.
El Módulo «Data Store»
Nuestro escenario 1 necesitará guardar el access_token y, más importante, el refresh_token en algún lugar. Usaremos la base de datos interna de Make: Data Store.
En tu panel de Make, ve a «Data stores» en el menú de la izquierda.
Haz clic en «Add data store».
Dale un nombre: seo_results
Data structure (Estructura de datos): Aquí definimos los «cajones» donde guardaremos las cosas.
Haz clic en «Add item».
Name:access_tokenType:Text
Haz clic en «Add item».
Name:refresh_tokenType:Text
Haz clic en «Save».
Ya tenemos nuestro «almacén» de tokens. La Key (la llave) para buscar en este almacén será el propio dominio del sitio web.
Ya tenemos los cimientos. Tenemos las llaves de Google Cloud y un almacén en Make. Tenemos nuestras credenciales de Google Cloud y un almacén de datos (Data Store) en Make listo para guardar nuestros tokens.
Vamos a construir el primer escenario: el «Guardián de Llaves». Su misión es gestionar la autorización del usuario de forma segura, canjear el código temporal por tokens permanentes y guardarlos en nuestro Data Store.
Este es, sin duda, el escenario más crítico desde el punto de vista de la seguridad y la funcionalidad. Los errores típicos (como el redirect_uri_mismatch, el 400 Bad Request o el Duplicate key) se originan todos aquí.
Vamos a construirlo, módulo por módulo.
Automatización en Make: Escenario 1 – (save_token)
Ve a Make, crea un nuevo escenario y dale un nombre: save_token. Este escenario tendrá 4 módulos conectados en línea:
Este módulo es la dirección a la que Google redirigirá al usuario después de que haga clic en «Permitir» en la pantalla de consentimiento. Es nuestra redirect_uri oficial.
Haz clic en el botón + y busca «Webhooks».
Selecciona «Custom webhook».
Haz clic en «Add» (Añadir) para crear un nuevo webhook.
Dale un nombre descriptivo: save_token_hook.
NO AÑADAS ESTRUCTURA DE DATOS AÚN.
Haz clic en «Save» (Guardar).
Make te mostrará la URL única de este webhook. CÓPIALA AL PORTAPAPELES. (Será algo como https://hook.eu2.make.com/hwov9ioymhw1tf2nykcl…).
¡ACCIÓN INMEDIATA! (Paso Crítico) Vuelve a tu pestaña de Google Cloud Console.
Ve a APIs y servicios > Credenciales.
Haz clic para editar tu «ID de cliente de OAuth 2.0» (el que creamos en la Parte 2).
Ve a la sección «URIs de redireccionamiento autorizadas».
Haz clic en + AÑADIR URI.
PEGA la URL de tu webhook que acabas de copiar.
Haz clic en «Guardar».
Acabas de decirle a Google: «Cualquier código de autorización que generes, envíalo únicamente a esta dirección segura de Make». Esto resuelve el redirect_uri_mismatch para siempre.
Módulo 2: HTTP
Cuando el Módulo 1 reciba al usuario, Google incluirá dos parámetros en la URL: code (el código temporal) y state (el dominio que le pasamos).
Ahora, nuestro servidor (Make) debe contactar a Google «por la puerta de atrás» (de servidor a servidor) y canjear ese code por los tokens reales. Aquí es donde usamos nuestro client_secret.
Añade un nuevo módulo después del Webhook. Busca «HTTP».
Selecciona «Make a request».
Configura cada campo EXACTAMENTE así:
URL:https://oauth2.googleapis.com/token
Method:POST
Body type (Tipo de cuerpo):Application/x-www-form-urlencoded. (¡Crítico! Si usas JSON, te dará un Error 400).
Parse response (Analizar respuesta):Yes. (¡Crítico! Si lo dejas en No, Make recibirá los tokens como un trozo de texto y no podrás mapearlos. Este es el error que nos hizo darnos de cabezazos contra la pared).
Fields (Campos): Añade estos 5 ítems:
Key:client_idValue:TU_CLIENT_ID (El que copiaste de Google Cloud).
Key:codeValue: Mapea (arrastra) la variable code del Módulo 1 (Webhook).
Key:grant_typeValue: Escribe el texto exacto: authorization_code
Key:redirect_uriValue: Pega la URL de tu Webhook (Módulo 1) aquí. Debe coincidir exactamente con la que pusiste en Google Cloud.
Módulo 3: El Data Store
Este módulo se ejecutará si el Módulo 2 tiene éxito (es decir, si Google nos devuelve los tokens).
Añade un nuevo módulo. Busca «Data store».
Selecciona «Add/replace a record» (Añadir/reemplazar un registro).
Data store: Selecciona tu base de datos: seo_results
Key (Clave): Aquí está la segunda clave de la «armonización». El state que nos llega del Módulo 1 viene con https:// y una barra / al final (ej: https://ernestogbustamante.com/). Nuestro GPT, sin embargo, nos pasará el dominio limpio (ej: ernestogbustamante.com). Debemos guardar y buscar usando la misma clave limpia.
Pega esta fórmula en el campo Key para limpiar el state: replace( replace( replace( {{1.state}}; "https://"; "" ); "http://"; "" ); "/"; "" )
Overwrite an existing record (Sobrescribir): Ponlo en Yes. (Esto soluciona el DataError: Duplicate key error si un usuario se autoriza por segunda vez).
Record:
access_token: Haz clic en el campo. Busca las variables del Módulo 2 (HTTP). Expande el objeto Data y arrastra la variable access_token.
refresh_token: Haz lo mismo, arrastra la variable refresh_token del Módulo 2.
Nota sobre el Mapeo: Si las variables access_token y refresh_token no te aparecen, es por el «problema del huevo y la gallina». Sigue la guía de «ejecución ciega» que detallo en la sección de Troubleshooting (Parte 5).
Módulo 4: La Respuesta (UX)
Finalmente, una vez que el token está guardado, no podemos dejar al usuario colgado en una pantalla en blanco que dice «Accepted». Debemos devolverle una página HTML amigable.
Añade un nuevo módulo. Busca «Webhooks».
Selecciona «Webhook response».
Status: 200 (El código para «OK»).
Body: Pega este código HTML simple:
<!DOCTYPE html><htmllang="es"><head><metacharset="UTF-8"><title>Autorización completada</title><style>body { background-color: #0d0d0d; color: #fff; font-family: Arial, sans-serif; text-align: center; padding: 60px; }
.success { font-size: 24px; color: #00ff99; margin-bottom: 20px; }
</style></head><body><h1>Conexión con Google Search Console...</h1><pclass="success">✅ ¡Autorización completada!</p><p>Ya puedes cerrar esta ventana y volver al chat para pedir tu análisis.</p></body></html>
Custom Headers: Añade un ítem:
Name:Content-Type
Value:text/html
¡Felicidades! Acabas de construir la parte más difícil de toda la automatización de inteligencia artificial: un flujo de autenticación OAuth 2.0 seguro, robusto y que maneja el almacenamiento de tokens.
Guarda este escenario y pon el interruptor principal en ON.
El save_token está activo y esperando. En la siguiente parte, construiremos la máquina que usará esas llaves.
En la parte 3, hemos construido el escenario save_token, que gestiona la autorización y almacena nuestros tokens. Ahora, vamos a construir el escenario launchAutoSEOAnalysisDirect, o como me gusta llamarlo, el «Analista SEO».
Esta automatización de tareas con IA es la que el GPT llamará cada vez que el usuario pida un informe. Su trabajo es:
Recibir el dominio.
Buscar los tokens en la base de datos.
Refrescar el access_token (porque el antiguo estará caducado).
Llamar a la API de Google Search Console con el token nuevo y las fechas correctas.
Formatear la respuesta masiva de Google.
Enviar esos datos a OpenAI con un prompt de análisis avanzado.
Devolver el análisis final al GPT.
Automatización de Tareas con IA: Escenario 2 – El «Analista SEO»
Crea un nuevo escenario en Make y llámalo launchAutoSEOAnalysisDirect.
Módulo 1: Webhook (Custom webhook)
Añade un trigger «Webhooks» > «Custom webhook».
Haz clic en «Add», dale un nombre (ej: launch_seo_hook).
NO AÑADAS ESTRUCTURA DE DATOS.
Guarda. Copia esta nueva URL del webhook. La necesitaremos para la configuración del GPT en el Paso 5.
Módulo 2: Data Store (Get a record)
Añade un módulo «Data store» > «Get a record».
Data store:seo_results
Key (Clave): Aquí está la «armonización». El GPT nos pasará una variable site (del Módulo 1). Debemos limpiarla con la misma fórmula que usamos para guardarla.
Pega esta fórmula en el campo Key: replace( replace( replace( {{1.site}}; "https://"; "" ); "http://"; "" ); "/"; "" )
Esto asegura que si el usuario escribe https://dominio.com/ o dominio.com, siempre buscaremos la clave dominio.com.
Módulo 3: HTTP (Make a request) – El refresco de token
Este es el módulo que nos puede salvar del Error 401 Unauthorized. El access_token que guardamos en el Módulo 2 caduca cada hora. No podemos usarlo. En su lugar, usamos el refresh_token (que no caduca) para pedirle a Google un access_token nuevo y fresco en cada ejecución.
Añade un módulo «HTTP» > «Make a request».
Configúralo:
URL:https://oauth2.googleapis.com/token
Method:POST
Body type:Application/x-www-form-urlencoded
Parse response:Yes (¡Fundamental!)
Fields (Añade estos 5 ítems):
Key:client_idValue:TU_CLIENT_ID (El mismo de antes).
Key:client_secretValue:[TU_CLIENT_SECRET_DE_GOOGLE_CLOUD] (El mismo de antes).
Key:grant_typeValue: Escribe el texto exacto: refresh_token
Key:refresh_tokenValue: Mapea (arrastra) el refresh_token que obtuviste del Módulo 2 (Data Store).
Key:redirect_uriValue: Pega la URL del webhook de tu Escenario 1 (save_token).
Módulo 4: HTTP (Make a request) – La Extracción de Datos GSC
Ahora que tenemos un access_token fresco (del Módulo 3), podemos llamar a la API de Google Search Console.
Añade otro módulo «HTTP» > «Make a request».
Method:POST
URL: Esta es la URL de la API. Aquí evitamos un posible Error 403 Forbidden. Debemos asegurarnos de pasar el dominio limpio (del Módulo 2) y formatearlo como https://dominio.com/, para que coincida con la propiedad que tenemos verificada.
Pega esta fórmula exacta en el campo URL: https://searchconsole.googleapis.com/webmasters/v3/sites/{{ encodeURL("https://" + 2.Key + "/") }}/searchAnalytics/query
Headers: Añade 2 ítems:
Item 1 (Autorización):
Name:Authorization
Value:Bearer {{3.data: access_token}} (¡Mapea el token del Módulo 3 (HTTP Refresh), NO del Data Store!)
Item 2 (Tipo de Contenido):
Name:Content-Type
Value:application/json
Body type:Raw
Content type:JSON (application/json)
Parse response:Yes
Request content: Aquí le decimos a Google qué datos queremos. Usamos fechas dinámicas para los últimos 30 días y un límite de 700 filas (para no saturar el contexto de OpenAI, lo que nos puede dar el Error 4000: Context Length).
La respuesta de Google (del Módulo 4) es un JSON complejo. Necesitamos formatearlo en una tabla simple (en formato Markdown) que la IA pueda entender.
Añade un módulo «Tools» > «Text aggregator».
Source Module: Elige el Módulo 4 (el HTTP de GSC).
Row separator:New row (Nueva línea).
Text: Pega esta línea. Es una fila de tabla Markdown que mapea dinámicamente cada fila de la respuesta de Google. | {{4.data.rows[].keys[0]}} | {{4.data.rows[].keys[1]}} | {{4.data.rows[].clicks}} | {{4.data.rows[].impressions}} | {{formatNumber(4.data.rows[].ctr * 100; 2; "."; ",")}}% | {{formatNumber(4.data.rows[].position; 1; "."; ",")}} |
Módulo 6: OpenAI (Create a Chat Completion)
Aquí es donde ocurre la magia. Le pasamos nuestro «ultra-prompt» y los datos formateados a GPT-4o.
Añade un módulo «OpenAI» > «Create a Chat Completion (GPT and o1 models)».
Conecta tu cuenta de OpenAI (con tu clave API de OpenAI).
Model:gpt-4o-latest
Select MethodChat
Messages: Añade 2 ítems:
Item 1 (El Prompt del Sistema):
Role:system
Content: Aquí pegas el «ultra-prompt» que define la personalidad y las 30 tareas del analista SEO. Este prompt es el alma de la automatización.
Eres un experto en SEO técnico y de contenidos con acceso a datos reales de Google Search Console. Tu tarea es analizar los datos enviados a continuación (keywords, clics, impresiones, CTR, posición, páginas y fechas) y generar una optimización profesional, avanzada y accionable.
Debes realizar TODO este análisis en el mismo output:
✅ Detecta URLs que hayan perdido más del 50% de su tráfico orgánico, ordénalas por pérdida absoluta de clics y explica qué clusters de keywords explican esa caída.
✅ Identifica todas las keywords que aparecen en más de 2 URLs distintas y propón cuál debe ser la URL principal y qué hacer con las demás (fusionar, redireccionar o reoptimizar).
✅ Muestra queries con más de 100 impresiones y posición media superior a 10, agrúpalas por temas y propone títulos de contenido nuevo para capturar ese tráfico.
✅ Localiza queries con muchas impresiones (>500) y CTR por debajo del 1 % estando en top 5, y propón mejoras de meta título y descripción.
✅ Lista URLs indexadas sin clics ni impresiones en el último trimestre y recomienda si deben eliminarse, redireccionarse o actualizarse.
✅ Identifica grupos de queries o clusters que estén creciendo o cayendo en los últimos 3 meses, resume prioridades de ataque o defensa.
✅ Verifica la riqueza semántica de cada URL cruzando sus keywords actuales con términos de alto volumen que falten (usa Keyword Planner si es necesario) y propone mejoras.
✅ Detecta URLs que tienen peor rendimiento en mobile que en desktop (clics y CTR) y sugiere hipótesis de mejora (contenido, UX, velocidad o intención).
✅ Encuentra queries nuevas emergentes en las últimas 4 semanas que no existían antes y propón clústeres o estructura de contenidos para capturarlas.
✅ Filtra por país y localiza mercados secundarios que traigan tráfico inesperado; propone qué páginas traducir o internacionalizar primero.
✅ Identifica queries en posición media 1–5 con alto CTR pero sin snippet destacado, propone ajustes (tablas, listas, FAQs) para intentar capturar el Featured Snippet.
✅ Detecta contenido con caída sostenida en los últimos 6 meses, sugiere cómo actualizarlo para recuperar tráfico (nuevos H2, secciones, refresh de fecha).
✅ Propón mejoras de enlazado interno: qué páginas deben enlazarse entre sí para reforzar clusters y distribuir autoridad.
✅ Si detectas URLs con bajo CTR y alto volumen de impresiones, genera variantes de title y description más atractivas.
✅ Si detectas URLs con bajo ratio de conversión (si hay datos), sugiere hipótesis para mejorar la intención de búsqueda y la conversión orgánica.
✅ Si detectas keywords que estén generando tráfico inesperado (tráfico “oculto”), explica cómo capitalizarlo con nuevo contenido o ampliación del actual.
✅ Si detectas caídas fuertes en queries branded (marca), indica medidas para reforzar la autoridad y reputación.
✅ Genera alertas proactivas si detectas anomalías: drops inusuales, clusters sin contenido nuevo o canibalizaciones recurrentes.
📌 Resumen del problema: Describe todos los hallazgos clave de forma estructurada.
📌 Canibalizaciones detectadas: Lista URLs y keywords afectadas, y propuestas para resolverlas.
📌 Sugerencias accionables: Resume todas las acciones ordenadas por prioridad (contenido, títulos, enlazado, estructura, semántica).
📌 Nueva versión optimizada: Escribe un ejemplo real de mejora (title, H1, estructura o snippet) para una de las URLs críticas detectadas. Usa un lenguaje claro, profesional y enfocado a consultores SEO o clientes que necesiten tomar decisiones rápidas.
📊 Análisis SEO extraído de Google Search Console | Keyword | URL | Clicks | Impressions | CTR | Position | |—|—|—|—|—|—|
Item 2 (Los Datos del Usuario):
Role:user
Content: Aquí pasamos la tabla de datos que generamos en el Módulo 5. {{5.text}}
Módulo 7: Webhook (Webhook response)
Finalmente, devolvemos la respuesta de OpenAI (el informe SEO) al GPT.
Añade un módulo «Webhooks» > «Webhook response».
Body: El GPT espera un JSON. Le devolvemos el informe dentro de una clave summary (que es la que definimos en nuestro esquema OpenAPI en el siguiente paso). { "summary": {{6.choices[].message.content}} }
Guarda este escenario y pon el interruptor principal en ON.
Las dos máquinas están construidas, probadas y armonizadas. El escenario save_token maneja la seguridad y el escenario launchAutoSEOAnalysisDirect hace el trabajo pesado. En la última parte, construiremos el GPT personalizado.
En las partes anteriores, hemos construido los cimientos en Google Cloud y las dos funcionalidades principales en Make.com: el save_token y el launchAutoSEOAnalysisDirect (Analista SEO). Ahora, vamos a construir la interfaz con la que hablaremos con nuestro sistema: el GPT Personalizado.
Aquí es donde la automatización con ChatGPT cobra vida. Configuraremos el GPT para que sepa cuándo hablar con el usuario y cuándo llamar a nuestras acciones de Make.
Automatización con ChatGPT: Configurando el GPT Personalizado
Ve a ChatGPT, haz clic en «Explore GPTs» y luego en «Create a GPT». Entrarás en el editor de GPTs. Haz clic en la pestaña «Configure».
Aquí configuraremos dos partes clave: las Instructions (el prompt principal del GPT) y las Actions (la conexión a nuestra API de Make).
Paso 1: Las Instrucciones (El Cerebro del GPT)
Las instrucciones le dicen al GPT cómo comportarse, cómo responder, y lo más importante, cómo formatear el enlace de autorización.
En el campo Instructions, pega el siguiente bloque de código JSON. Reemplaza los dos marcadores de posición con tus URLs reales.
¡IMPORTANTE!
TU_CLIENT_ID: El ID de cliente de Google Cloud.
URL_DE_TU_WEBHOOK_SAVE_TOKEN: La URL de tu Escenario 1 (el que creamos en la Parte 3, el …4l1bc).
{
"instructions": "Cuando un usuario te dé un dominio, guárdalo en tu contexto. RESPONDE así, SIN EXCEPCIÓN, reemplazando {site} con el dominio que te dieron:\n\n\"👉 [Autorizar Google Search Console](https://accounts.google.com/o/oauth2/v2/auth?client_id=TU_CLIENT_ID&redirect_uri=URL_DE_TU_WEBHOOK_SAVE_TOKEN&response_type=code&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fwebmasters.readonly&state={site}&access_type=offline&prompt=consent)\n\nUna vez conectado, vuelve aquí y dime **'Dame el resultado para {site}'** para recibir tu informe SEO completo.\"\n\nCuando el usuario vuelva y diga 'Dame el resultado para [un dominio]', extrae ese [un dominio] directamente de su mensaje y lanza la acción `launchAutoSEOAnalysisDirect` con `{ \"site\": \"[un dominio]\" }`.\nResponde SOLO con el `summary` limpio, sin texto adicional, sin comentarios extra."
}
Análisis de estas instrucciones:
redirect_uri Le dice a Google a dónde enviar al usuario (a nuestro Módulo 1 del save_token).
state={site} Pasa el dominio del usuario a través del proceso de autorización, para que sepamos para qué sitio guardar el token.
access_type=offline Esto es CRUCIAL. Le pide a Google que nos devuelva un refresh_token además del access_token.
launchAutoSEOAnalysisDirect Le dice al GPT el nombre de la «Acción» que debe llamar cuando el usuario pida el informe.
Responde SOLO con el summary limpio Evita que el GPT añada «¡Aquí tienes tu informe!» y nos da la respuesta en crudo.
Paso 2: Las Acciones (Los Brazos del GPT)
Aquí es donde el GPT aprende a «hablar» con nuestro escenario de Make.
Baja hasta la sección «Actions» (Acciones).
Haz clic en «Add actions» (Añadir acciones).
Aquí debemos pegar un Esquema OpenAPI. Este es el «manual de instrucciones» que le dice al GPT cómo llamar a nuestro escenario launchAutoSEOAnalysisDirect.
Pega el siguiente código JSON. Reemplaza el marcador de posición con tu URL real.
¡IMPORTANTE!
URL_DE_TU_WEBHOOK_LAUNCHAUTOSEO: La URL de tu Escenario 2 (el que creamos en la Parte 4).
{
"openapi": "3.1.0",
"info": {
"title": "SEO Auto Analysis",
"version": "1.0.0",
"description": "Lanza análisis SEO reales desde Google Search Console con OAuth. Accede al token guardado automáticamente y devuelve el informe real."
},
"servers": [
{
"url": "URL_DE_TU_WEBHOOK_LAUNCHAUTOSEO"
}
],
"paths": {
"/": {
"post": {
"operationId": "launchAutoSEOAnalysisDirect",
"summary": "Lanza el análisis SEO real desde Google Search Console.",
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"type": "object",
"properties": {
"site": {
"type": "string"
}
},
"required": ["site"]
}
}
}
},
"responses": {
"200": {
"description": "Informe SEO final.",
"content": {
"application/json": {
"schema": {
"type": "object",
"properties": {
"summary": {
"type": "string"
}
},
"required": ["summary"]
}
}
}
}
}
}
}
}
}
Análisis de este esquema:
servers.url: Le dice al GPT a qué URL de Make debe llamar.
operationId:launchAutoSEOAnalysisDirect. Coincide con el nombre que pusimos en las instructions.
requestBody: Le dice al GPT que debe enviar un JSON con un campo site.
responses.200.summary: Le dice al GPT que espere recibir un JSON de vuelta con un campo summary (que es el que le dijimos a Make que enviara en el Módulo 7 del Escenario 2).
Paso 3: Guardar y Probar
¡Ya está! Haz clic en «Save» (Guardar) en la esquina superior derecha y publica tu GPT.
Ahora, el flujo completo está listo:
Tú: «conectate a ernestogbustamante.com»
GPT: Te da el enlace de autorización (usando las instructions).
Tú: Haces clic. Google te autoriza. Eres redirigido a Make.
Make (Escenario 1): Se ejecuta en segundo plano. Canjea el code y guarda tus tokens. Ves la página de «Éxito».
Tú: Vuelves al GPT y dices: «Dame el resultado para ernestogbustamante.com»
GPT: Te pide permiso para hablar con http://hook.eu2.make.com/. Pulsas «Confirmar».
Make (Escenario 2): Se ejecuta. Busca tu token, lo refresca, llama a Google, obtiene 700 filas de datos, las envía a OpenAI, recibe el análisis y lo devuelve como summary.
GPT: Recibe el summary y te muestra el informe de «ultra valor».
Manual de Supervivencia: Troubleshooting
Construir esto no es trivial. En nuestro propio proceso, nos encontramos con cada uno de los siguientes errores. Aquí te dejo la guía de troubleshooting que ojalá hubiéramos tenido:
Error 400: redirect_uri_mismatch
Causa: La URL de tu webhook de Make (save_token) NO coincide exactamente con la que tienes en la «URI de redireccionamiento autorizada» en Google Cloud Console.
Solución: Cópiala y pégala de nuevo en Google Cloud.
Error 400: Bad Request (en el Escenario 1 – Módulo 2 HTTP)
Causa: La petición a oauth2.googleapis.com/token es incorrecta.
Solución: Asegúrate de que el Body type es Application/x-www-form-urlencoded y que la casilla Parse response está en Yes.
Error 401: Unauthorized (en el Escenario 2 – Módulo 4 HTTP)
Causa: Estás usando un access_token caducado (el que guardaste en el Data Store).
Solución: Implementa el Módulo 3 (HTTP Refresh) en tu Escenario 2, y asegúrate de que el Módulo 4 usa el token nuevo ({{3.data: access_token}}).
Error 403: Forbidden (en el Escenario 2 – Módulo 4 HTTP)
Causa: Estás pidiendo datos de una propiedad para la que tu cuenta de Google no tiene permisos. Esto suele pasar por un mismatch http:// vs https://.
Solución: Arregla la URL en el Módulo 4 para que fuerce el protocolo correcto, usando la clave limpia del Data Store: .../sites/{{ encodeURL("https://" + 2.Key + "/") }}/...
DataError: Duplicate key error (en el Escenario 1 – Módulo 3 Data Store)
Causa: Estás intentando guardar un token para un dominio que ya existe.
Solución: Activa la opción Overwrite an existing record a Yes en el módulo Data Store.
Error [429]: Credits Consumed (en el Escenario 2 – Módulo 6 OpenAI)
Causa: Tu cuenta de OpenAI se ha quedado sin créditos.
Solución: Ve a tu panel de billing de OpenAI y añade fondos.
Error [4000]: Context Length Exceeded (en el Escenario 2 – Módulo 6 OpenAI)
Causa: La suma de tu prompt + los datos de GSC es demasiado grande para el modelo.
Solución: Reduce el rowLimit en el Módulo 4 (HTTP GSC) de 1000 a un número más bajo, como 700.
El GPT devuelve un análisis vacío o dice que «no hay datos».
Causa: El rowLimit era demasiado bajo (ej: 10) o las fechas en el Request content del Módulo 4 eran fijas y antiguas (ej: 2024-05-01).
Solución: Usa las fechas dinámicas (formatDate(addDays(now…))) y un rowLimit de 700.
Conclusión: Automatiza el SEO con IA y Make para obtener insights accionables en cuestión de segundos
La automatización de inteligencia artificial te permite construir tú mismo un cyborg SEO: la experiencia estratégica de un humano fusionada con la velocidad de análisis y la capacidad de procesamiento de datos de una IA.
Hemos convertido horas de trabajo manual en un análisis de 60 segundos. Hemos desbloqueado insights del long-tail que antes eran invisibles. Hemos creado un asistente personal que nos entrega planes de acción, no solo datos.
Si has seguido este tutorial, acabas de construir tu propio analista SEO. El siguiente paso es tuyo. ¿Qué más vas a automatizar?
