Cómo crear un sistema para enviar URL de forma masiva al índice de Google y comprobar la indexación del sitio

Automatización de la Indexación y Monitoreo en Google para tu Sitio Web

Introducción

Los propietarios de sitios web a menudo necesitan monitorear la indexación de sus páginas y acelerar la inclusión de nuevas URLs en el índice de búsqueda de Google. En un entorno digital competitivo, es crucial que el contenido nuevo o las páginas de productos aparezcan rápidamente en los resultados de búsqueda, en lugar de esperar semanas a que los rastreadores de Google las descubran.

Verificar manualmente el estado de indexación o enviar URLs a través de Google Search Console puede convertirse en una tarea tediosa y que consume mucho tiempo, especialmente para tiendas online con cientos de productos o blogs con publicaciones frecuentes. Para solucionar esto, hemos automatizado el proceso utilizando las APIs de Google:

• Google Indexing API: Para enviar URLs en masa al índice de Google.
• Google Custom Search API: Para verificar si las páginas están indexadas.

Este enfoque te permite:

• Simplificar la indexación masiva de páginas nuevas.
• Comprobar al instante qué páginas están indexadas y cuáles no.
• Monitorear la efectividad de tus esfuerzos de SEO.

1. Configuración de un Proyecto y una Cuenta de Servicio en Google

Para usar las APIs de Google, necesitas configurar un proyecto y una cuenta de servicio. A continuación, te explicamos cómo:

Paso 1: Crear un Proyecto en Google Cloud Console

1. Visita console.cloud.google.com y crea un nuevo proyecto (por ejemplo, example-index). Crear Proyecto.

Paso 2: Crear una Cuenta de Servicio

1. En Google Cloud Console, ve a IAM y Administración > Cuentas de Servicio.
2. Crea una nueva cuenta de servicio, por ejemplo, vitaminator-com.
3. Asigna el rol de Propietario (Owner).

4. Una vez creada, haz clic en Listo (no se requieren datos adicionales).

Paso 3: Generar y Descargar una Clave JSON

1. Tras crear la cuenta de servicio, genera una clave JSON que contiene:
   • client_email: La dirección de correo de la cuenta de servicio.
   • private_key: La clave privada para la autenticación.
   • Otros datos de autenticación.

Ejemplo de Clave JSON:

{
  "type": "service_account",
  "project_id": "example-index",
  "private_key_id": "abc123",
  "private_key": "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n",
  "client_email": "example@example-index.iam.gserviceaccount.com",
  ...
}

Paso 4: Habilitar la Google Indexing API

1. En Google Cloud Console, ve a APIs y Servicios > Biblioteca.
2. Busca Indexing API y actívala para tu proyecto. Habilitar Indexing API.

2. Script de Node.js para Enviar URLs al Índice de Google

Hemos utilizado Node.js con la biblioteca googleapis para la autenticación mediante JWT. A continuación, se muestra el script para enviar URLs a la Google Indexing API:

const fs = require('fs');
const { google } = require('googleapis');
const request = require('request');
const key = require('./service_account.json');

const jwtClient = new google.auth.JWT(
  key.client_email,
  null,
  key.private_key,
  ['https://www.googleapis.com/auth/indexing']
);

const batch = fs.readFileSync('urls.txt').toString().split('\n');

jwtClient.authorize((err, tokens) => {
  if (err) return console.error('Error de autenticación:', err);

  const items = batch.map(url => ({
    'Content-Type': 'application/http',
    'Content-ID': '',
    body: `POST /v3/urlNotifications:publish HTTP/1.1\nContent-Type: application/json\n\n${JSON.stringify({ url, type: 'URL_UPDATED' })}`
  }));

  const options = {
    url: 'https://indexing.googleapis.com/batch',
    method: 'POST',
    headers: { 'Content-Type': 'multipart/mixed' },
    auth: { bearer: tokens.access_token },
    multipart: items
  };

  request(options, (err, resp, body) => {
    if (err) return console.error('Error al enviar:', err);
    console.log('✅ Respuesta de Google Index API:\n', body);
  });
});

Ejemplo de Respuesta:

{
  "urlNotificationMetadata": {
    "url": "https://vitaminator.com.ua/product/bluebonnet-nutrition-120"
  }
}

3. Verificación del Estado de Indexación con la Custom Search API

Para comprobar si las URLs están indexadas, configura un Motor de Búsqueda Personalizado (CSE):

Paso 1: Crear un Motor de Búsqueda Personalizado

1. Visita programmablesearchengine.google.com.
2. Añade tu sitio web (por ejemplo, example.com) y limita la búsqueda a este dominio.

Paso 2: Obtener una Clave de API

1. Obtén tu clave de API en Google Cloud Console > APIs y Servicios > Credenciales.

2. Habilita la Custom Search API para tu proyecto: Habilitar Custom Search API.

Credenciales Requeridas:

• Clave de API: por ejemplo, AIzaSyAk3234234234d-gZAk8wmJE4IGFo_w8
• CX: por ejemplo, e35e2de1234566c5

Paso 3: Script para Verificar el Estado de Indexación

Usa este script de Node.js para comprobar si las URLs están indexadas:

const fs = require('fs');
const axios = require('axios');
const urls = fs.readFileSync('urls.txt').toString().split('\n');
const apiKey = 'TU_CLAVE_API';
const cx = 'TU_CX';

(async () => {
  for (const url of urls) {
    try {
      const resp = await axios.get('https://www.googleapis.com/customsearch/v1', {
        params: { key: apiKey, cx, q: `site:${url}` }
      });

      const status = resp.data.items && resp.data.items.length > 0 ? '✅ Indexada' : '❌ No indexada';
      console.log(`${url} — ${status}`);
      fs.appendFileSync('index-check-results.txt', `${url} — ${status}\n`);

      // Pausa de 1 segundo para evitar superar los límites de la API
      await new Promise(r => setTimeout(r, 1000));
    } catch (e) {
      console.error('Error al verificar:', e.response?.data || e.message);
    }
  }
})();

4. Límites y Cuotas de las APIs

• Google Indexing API: 200 solicitudes por día (por defecto).
• Custom Search API: 100 solicitudes por día (cuota gratuita).
• Prácticas para Evitar Superar los Límites:
  • Añade pausas entre solicitudes.
  • Divide las URLs en lotes más pequeños.
  • Solicita un aumento de cuota a través de Google Cloud Console si es necesario.

5. Flujo de Trabajo Completamente Automatizado

Esta solución proporciona un proceso completamente automatizado para:

• Enviar URLs al índice de Google.
• Verificar el estado de indexación de cada página.
• Guardar los resultados en un archivo.
• Integración opcional con CMS, bots de Telegram o Google Sheets para funciones avanzadas.

Este enfoque ahorra tiempo, acelera los procesos de SEO y garantiza un monitoreo transparente de la indexación.

Descarga el Archivo Listo para Usar: Inserta tus claves de API y comienza a automatizar. Descargar Aquí.

6. Guía de Instalación y Uso

Requisitos

1. Node.js (versión 18 o superior). Descárgalo desde nodejs.org. Verifica la instalación con:

   node -v
   npm -v
   

2. Cuenta de Google Cloud Console con:

   • Indexing API habilitada.
   • Cuenta de Servicio creada y clave JSON descargada.
   • Custom Search API habilitada y un motor de búsqueda personalizado (CSE) configurado para tu sitio.

Pasos de Instalación

1. Descomprime el archivo en una carpeta (por ejemplo, ~/Desktop/example).

   cd ~/Desktop/example
   

2. Instala las dependencias:

   npm install
   

Configuración de las Claves

1. Clave de la Cuenta de Servicio (Indexing API):

   • Coloca tu clave JSON en el archivo service_account.json. Ejemplo:

     {
       "type": "service_account",
       "project_id": "vitaminor-index",
       "private_key_id": "abc123",
       "private_key": "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n",
       "client_email": "your-service-account@project-id.iam.gserviceaccount.com"
     }
     

   • Advertencia: Este archivo no debe compartirse públicamente.

2. Claves de la Custom Search API:

   • Abre el archivo chekindex.js y reemplaza:

     const apiKey = "TU_CLAVE_API"; // Clave de API de Google
     const cx = "TU_CX";            // ID del Motor de Búsqueda Personalizado
     

     con tus valores de clave de API y CX de Google Cloud Console.

Archivos en el Archivo

• urls.txt: Lista de URLs para enviar o verificar (una por línea).
• index.js: Script para enviar URLs a la Google Indexing API.
• chekindex.js: Script para verificar el estado de indexación mediante la Custom Search API.
• index-check-results.txt: Archivo de salida para los resultados de verificación.

Ejecución de los Scripts

1. Enviar URLs al Índice de Google:

   node index.js
   

   Ejemplo de Salida:

   ✅ Respuesta de Google Index API:
   {
     "urlNotificationMetadata": {
       "url": "https://vitaminator.com.ua/product/example"
     }
   }
   

2. Verificar el Estado de Indexación:

   node chekindex.js
   

   Ejemplo de Salida:

   https://vitaminator.com.ua/product/bluebonnet-nutrition-120 — ✅ Indexada
   https://vitaminator.com.ua/product/1000-tart-cherry-extract-solgar-90 — ❌ No indexada
   

   Los resultados se guardan en index-check-results.txt.

¡Listo!

Ahora tienes una herramienta automatizada y potente para:

• Enviar páginas al índice de Google.
• Verificar su estado de indexación.
• Guardar los resultados para análisis posteriores.

Agradecimientos especiales a Brander por la inspiración y los recursos que contribuyeron a esta guía.