Rastreo

Reducir a Google el rastreo por nuestra web

Reducir a Google el rastreo por nuestra web
Autor
Carlos Sánchez
Temática
Rastreo
Publicado
Revisado

Es cierto que en pocas ocasiones de nuestra vida nos vamos a plantear como podemos hacer para que Google rastree nuestra web con menos frecuencia. Pero se puede dar el caso que al analizar los Logs y el Uptime de nuestra web, se de la correlación de que cae en picos donde Google rastrea nuestra web.

O si nos ponemos más trickis, estamos en un momento de cambios en producción donde queremos que Google no nos rastree con exceso para que no se le quede en caché contenido de poca calidad, pero a la vez no es un cambio tan drástico como para poner la web en 5XX (ni ponerle 5XX solo a Google).

El problema de la directiva Crawl-delay

La directiva Crawl-delay en el archivo robots.txt no funciona con Google.

Aunque otros motores de búsqueda como Bing la respetan para espaciar el tiempo entre peticiones.

También es verdad que bing se lo curra más y en BingWebmaster tienes hasta un control del rastreo donde le puedes decir a Bing las horas más interesantes para rastrearte.

Rastreo en bing webmaster

No obstante no todos los bots son tan considerados de cara a organizar nosotros el rastreo de nuestra web, de hecho en ocasiones debemos saber bloquear el acceso a user-agents incluso con medidas mucho más potentes que el robots.txt. Googlebot que además es un bot que en general queremos que acceda a nuestra web ignora la directiva del Crawl-delay por completo, y tampoco tenemos una opción de modificar el rastreo desde la Search Console.

Entonces podríamos darnos por vencido y decidir que mejor no tocar a Google y que rastree lo que quiera. Pero es cierto que en determinados proyectos puede haber un pico de rastreo de Google en fechas donde no se puede soportar tanta carga.

He visto este Crawl-delay aplicado para Googlebot directamente y en ocasiones puede conllevar a problemas de reglas aplicadas de forma inesperada, ya que Googlebot ignora esta directiva y eso tiene sus riesgos, eso lo podemos ver en este ejemplo:

Problema con directivas ignoradas robots.txt

Mi recomendación siempre sería tener preparado el servidor para momentos picos, pero puede ser que queramos limitar a Google porque nos rastrea de forma excesiva.

Bloqueo por rango de IP

El caso más probable cuando una web se nos tumba por un exceso de rastreo de Bots de Google, es que realmente no sean Bots de Google. Y aunque sea relativamente complejo de implementar, si no usamos ningún CDN que nos cubra esta función, podemos implementar en nuestra web un bloqueo a todos los user-agents de Google que no cumplan este rango de ip.

Si bien no es lo recomendable, este listado es muy importante para webs que por ejemplo están prohibidas en EEUU y es necesario bloquearlo, pero se necesita aparecer en Google.

Para lo que nos ocupa, en muchas ocasiones prohibiendo el rastreo a toda web que no entre dentro del rango de IP funciona bastante bien.

Esta práctica por ejemplo la aplica Airbnb, donde podemos ver que si fingimos ser Google nos bloquea:

bloqueo airbnb
Pero cuando usamos un servicio de Google, con el User-Agent de Google pero con el rango de IP de Google, podemos observar como nos deja pasar sin excesivos problemas.

Para quien se lo pregunte, ni esta implementación, ni la hiper personalización que hace para el usuario afecta negativamente a su posicionamiento, más bien lo contrario.

Ahora, ¿qué ocurre si hacemos estos cambios y aun así descubrimos que nuestro legítimo San Google es realmente quien nos está rastreando de forma excesiva? Pues tenemos un As bajo la manga.

Códigos 503 o 429 y cabecera Retry-After

La forma técnica correcta de obligar a Googlebot a detenerse es devolver un código de estado HTTP 5XX o 429.

Esto puede ir acompañado de la cabecera Retry-After. Así proteges tu infraestructura de forma inmediata y das a Google una instrucción estandarizada de cuándo es seguro volver. Si no, dejas a criterio de Google cuando volver a intentarlo, que si bien reducirá bastante el rastreo y tardará en hacer cambios en el índice, con el retry-after tienes el control.

Google actualizó el 6 de octubre su guía para reducir la frecuencia de rastreo y añadió explícitamente el uso de esta cabecera (tal y como la define el RFC 9110).

La guía muestra cómo el retraso puede indicarse en segundos:

HTTP/1.1 503 Service Unavailable
Retry-After: 120

O mediante una fecha y hora absolutas en UTC:

HTTP/1.1 503 Service Unavailable
Retry-After: Wed, 21 Oct 2026 07:28:00 GMT

Cómo se envía Retry-After en Apache, LiteSpeed y nginx

Dos decisiones: en qué respuestas va (503 de mantenimiento, 429 de límite de peticiones) y con qué valor (segundos, o una fecha HTTP como Retry-After: Wed, 07 Oct 2026 18:00:00 GMT). Y una regla: la cabecera acompaña al estado, no a la ruta. Si la añades a todas las respuestas de un directorio, la verán también los 200, y ahí no significa nada.

Apache. Lo resuelven dos módulos que ya tienes: mod_rewrite pone el estado y mod_headers la cabecera, condicionada al estado con expr= (Apache 2.4.10 o superior). Vale igual en el .htaccess y en el VirtualHost.

Todo el sitio · .htaccess en la raíz, o el VirtualHost
# Mantenimiento de todo el sitio: 503 y Retry-After de una hora.
# Tu IP sigue entrando, y la página de mantenimiento (y su carpeta) no se bloquea.
<IfModule mod_rewrite.c>
  RewriteEngine On
  RewriteCond %{REMOTE_ADDR} !^203\.0\.113\.10$
  RewriteCond %{REQUEST_URI} !^/mantenimiento
  RewriteRule ^ - [R=503,L]
</IfModule>
ErrorDocument 503 /mantenimiento.html

# La cabecera solo cuando la respuesta es 503 (Apache 2.4.10 o superior).
# «always»: sin él, Apache solo añade cabeceras a las respuestas 2xx.
<IfModule mod_headers.c>
  Header always set Retry-After "3600" "expr=%{REQUEST_STATUS} == 503"
</IfModule>
Solo un directorio · .htaccess dentro de /tienda/
# Solo /tienda/ devuelve 503; el resto de la web sigue en pie.
# En el VirtualHost sería lo mismo dentro de <Location /tienda/> … </Location>
<IfModule mod_rewrite.c>
  RewriteEngine On
  RewriteCond %{REMOTE_ADDR} !^203\.0\.113\.10$
  RewriteRule ^ - [R=503,L]
</IfModule>
ErrorDocument 503 /mantenimiento.html

<IfModule mod_headers.c>
  Header always set Retry-After "7200" "expr=%{REQUEST_STATUS} == 503"
</IfModule>
429 a un bot concreto · Apache no limita peticiones por sí solo
# Limitar de verdad es cosa de un WAF o de mod_security. Pero si quieres frenar
# a un bot con 429 (que dice «vuelve luego») en vez de con 403 (que dice «fuera»):
<IfModule mod_rewrite.c>
  RewriteEngine On
  RewriteCond %{HTTP_USER_AGENT} (AhrefsBot|SemrushBot) [NC]
  RewriteRule ^ - [R=429,L]
</IfModule>

<IfModule mod_headers.c>
  Header always set Retry-After "600" "expr=%{REQUEST_STATUS} == 429"
</IfModule>

Comprueba que la cabecera sale solo en el estado que toca, y desde una IP que no esté en tu lista blanca (el móvil sin wifi vale): curl -sI https://tu-dominio.com/ | grep -iE "^(HTTP|retry-after)"

Límite por IP: 429 y Retry-After solo para quien rastrea de más

Un 503 de mantenimiento frena a todos por igual. Pero el rastreo excesivo casi siempre tiene nombre y apellidos: un scraper, una herramienta SEO con prisa, un bot de IA o alguien que se hace pasar por Googlebot. Para eso no hace falta tocar a nadie más: cuento las peticiones de cada IP y contesto 429 Too Many Requests solo a la que pasa de su cupo, con un Retry-After que le dice cuándo puede volver.

Entendamos el 429 como un limitador de velocidad

El cupo depende de quién sea, y el agente de usuario no basta para saberlo: cualquiera puede escribir «Googlebot». A Googlebot y a Bingbot les compruebo la IP, como en el bloqueo por rango de IP de más arriba, y les dejo más margen, porque Google no frena solo esa IP: cuando ve suficientes 429, baja el rastreo de todo el nombre de host, y lo recupera solo cuando dejan de llegar. Quien dice ser Googlebot desde una IP que no es de Google cuenta como un robot más.

El Retry-After sale de la misma cuenta en los tres: lo que tarda el cliente en recuperar la ráfaga entera, ráfaga ÷ ritmo. Pasado ese tiempo puede volver a toda velocidad; antes, solo al ritmo que le toca. Google lo admite con el 429 igual que con el 503. Y robots.txt queda fuera del límite: si Google recibe un 429 al pedirlo, deja de rastrear toda la web durante las primeras 12 horas mientras lo reintenta.

Apache y LiteSpeed. Ninguno de los dos trae un límite por IP que conteste 429 (el de LiteSpeed frena sin avisar), así que lo hace PHP, antes de que WordPress se ponga a trabajar. No necesita nada instalado, porque guarda los contadores en la carpeta temporal, y sirve también detrás de un nginx que no puedas tocar. Lo que sirve la caché de página o el CDN no pasa por PHP: ni cuenta ni cuesta.

limite-por-ip.php · en wp-content/mu-plugins/ (créala si no existe): WordPress lo carga solo, sin activarlo
<?php
/**
 * Plugin Name: Límite por IP (429 + Retry-After)
 * Description: 429 Too Many Requests a la IP que rastrea de más, con un cupo y un Retry-After según quién sea.
 */// En WordPress, en wp-content/mu-plugins/. En otra web en PHP, con auto_prepend_file.

if ( PHP_SAPI === 'cli' || defined( 'DOING_CRON' ) ) {
    return;
}

// Por cliente: peticiones por segundo y ráfaga. Es el mismo cubo que limit_req de nginx.
const RL_FUENTES = [
    'persona'  => [ 5, 60 ],     // un navegador no llega: lo estático no pasa por PHP
    'buscador' => [ 2, 120 ],    // Googlebot o Bingbot con la IP comprobada
    'robot'    => [ 0.5, 60 ],   // el resto, y quien dice ser Googlebot sin serlo
];
// Retry-After = lo que tarda en rellenarse la ráfaga: 12 s, 60 s y 120 s.

function rl_dir(): string {
    $dir = sys_get_temp_dir() . '/limite-por-ip-' . md5( __DIR__ );    // una carpeta por web
    if ( ! is_dir( $dir ) ) {
        @mkdir( $dir, 0700, true );
    }
    if ( mt_rand( 1, 1000 ) === 1 ) {    // de vez en cuando, fuera lo que lleva un día sin tocarse
        foreach ( glob( $dir . '/*' ) ?: [] as $viejo ) {
            if ( @filemtime( $viejo ) < time() - 86400 ) {
                @unlink( $viejo );
            }
        }
    }
    return $dir;
}

/* El cliente es la IP; en IPv6, su red /64, que es lo que tiene cada casa o cada servidor. */function rl_cliente( string $ip ): string {
    $bin = @inet_pton( $ip );
    return ( false !== $bin && strlen( $bin ) === 16 ) ? bin2hex( substr( $bin, 0, 8 ) ) . '/64' : $ip;
}

/* ¿De verdad es Googlebot o Bingbot? DNS inverso a su dominio y vuelta a la misma IP,
   como explica Google. La respuesta se guarda un día por IP. */function rl_buscador_verificado( string $ip, string $ua ): bool {
    if ( ! preg_match( '/googlebot|googleother|google-inspectiontool|bingbot/i', $ua ) ) {
        return false;
    }
    $guardado = rl_dir() . '/dns-' . md5( $ip );
    if ( is_file( $guardado ) && filemtime( $guardado ) > time() - 86400 ) {
        return file_get_contents( $guardado ) === '1';
    }
    $host = gethostbyaddr( $ip );
    $ok   = is_string( $host ) && preg_match( '/\.(googlebot\.com|search\.msn\.com)$/i', $host );
    if ( $ok ) {
        $ips = strpos( $ip, ':' ) !== false
            ? array_column( @dns_get_record( $host, DNS_AAAA ) ?: [], 'ipv6' )
            : ( gethostbynamel( $host ) ?: [] );
        $ok = in_array( inet_pton( $ip ), array_map( 'inet_pton', $ips ), true );
    }
    @file_put_contents( $guardado, $ok ? '1' : '0' );
    return $ok;
}

function rl_fuente( string $ip, string $ua ): string {
    if ( rl_buscador_verificado( $ip, $ua ) ) {
        return 'buscador';
    }
    $robot = '/bot|crawl|spider|slurp|scrapy|python|curl|wget|httpclient|java\/|go-http|headless/i';
    return ( '' === $ua || preg_match( $robot, $ua ) ) ? 'robot' : 'persona';
}

function rl_aplicar(): void {
    // Con la sesión de WordPress iniciada no se cuenta (sin fijar aún el usuario actual).
    if ( function_exists( 'wp_validate_auth_cookie' ) && wp_validate_auth_cookie( '', 'logged_in' ) ) {
        return;
    }
    // robots.txt, nunca: con un 429 ahí, Google deja de rastrear toda la web hasta 12 horas.
    if ( strpos( $_SERVER['REQUEST_URI'] ?? '', '/robots.txt' ) === 0 ) {
        return;
    }
    $ip = $_SERVER['REMOTE_ADDR'] ?? '';
    if ( '' === $ip ) {
        return;
    }
    $fuente             = rl_fuente( $ip, $_SERVER['HTTP_USER_AGENT'] ?? '' );
    [ $ritmo, $rafaga ] = RL_FUENTES[ $fuente ];

    // El cubo del cliente: cada petición gasta una ficha; se recuperan $ritmo por segundo, hasta $rafaga.
    $f = @fopen( rl_dir() . '/' . md5( $fuente . rl_cliente( $ip ) ), 'c+' );
    if ( ! $f ) {
        return;                        // sin carpeta temporal no se limita a nadie
    }
    flock( $f, LOCK_EX );
    $ahora  = microtime( true );
    $cubo   = explode( ' ', (string) stream_get_contents( $f ) );
    $antes  = isset( $cubo[1] ) ? (float) $cubo[1] : $ahora;
    $fichas = isset( $cubo[1] ) ? (float) $cubo[0] : $rafaga;
    $fichas = min( $rafaga, $fichas + ( $ahora - $antes ) * $ritmo );
    $pasa   = $fichas >= 1;
    if ( $pasa ) {
        $fichas--;
    }
    ftruncate( $f, 0 );
    rewind( $f );
    fwrite( $f, $fichas . ' ' . $ahora );
    flock( $f, LOCK_UN );
    fclose( $f );
    if ( $pasa ) {
        return;
    }

    // Retry-After con sentido: los segundos que tarda en volver a tener la ráfaga entera.
    $espera = (int) ceil( ( $rafaga - $fichas ) / $ritmo );
    http_response_code( 429 );
    header( 'Retry-After: ' . $espera );
    header( 'Cache-Control: no-store' );
    header( 'Content-Type: text/plain; charset=utf-8' );
    echo 'Demasiadas peticiones. Vuelve a intentarlo en ' . $espera . ' segundos.';
    exit;
}

// En WordPress, cuando ya se puede mirar la sesión; en cualquier otro PHP, en el acto.
if ( function_exists( 'add_action' ) ) {
    add_action( 'plugins_loaded', 'rl_aplicar', 0 );
} else {
    rl_aplicar();
}
Fuera de WordPress · .htaccess en la raíz, con LiteSpeed Enterprise o con Apache y mod_php
# PHP ejecuta el limitador antes que cualquier otro archivo de la web (ruta absoluta).
<IfModule LiteSpeed>
  php_value auto_prepend_file /home/usuario/web/limite-por-ip.php
</IfModule>
<IfModule mod_php.c>
  php_value auto_prepend_file /home/usuario/web/limite-por-ip.php
</IfModule>
Con PHP-FPM · .user.ini en la raíz, porque ahí PHP no lee el .htaccess
; PHP relee este archivo cada cinco minutos.
auto_prepend_file = /home/usuario/web/limite-por-ip.php

En OpenLiteSpeed no vale ninguno de los dos: la misma línea de php_value va en el WebAdmin, en Virtual Hosts → General → php.ini Override.

Para comprobarlo · una ráfaga con agente de robot; cada petición lleva un parámetro distinto para esquivar la caché
for i in $(seq 100); do
  echo "$i $(curl -s -o /dev/null -A 'prueba-bot' -w '%{http_code} %header{retry-after}' "https://tu-dominio.com/?limite=$i")"
done | grep -m1 ' 429 '
# 61 429 120   ← la primera respuesta 429, con su Retry-After (curl 7.84 o superior)
# A ti, navegando, no te afecta: el cubo del robot y el de tu navegador van aparte.

Dos avisos antes de ponerlo en marcha. Si la web va detrás de Cloudflare, Bunny o cualquier otro proxy, la IP que ve el servidor es la del proxy, y con ella todo el mundo compartiría cupo: primero haz que vea la del visitante (set_real_ip_from y real_ip_header en nginx, mod_remoteip en Apache, «Use Client IP in Header» en LiteSpeed). Y si el 429 le llega a Googlebot a diario, ya no es un pico: sube su cupo o arregla la carga, porque Google avisa de que los errores que duran más de uno o dos días pueden acabar sacando URLs del índice.

Si te gusta este artículo, me ayudarías un montón compartiendo mi contenido:
¿Quieres que mis artículos te salgan más en Google?
Añadir como fuente preferida en Google
Formación
No se te da mal el SEO técnico

Te falta mi máster. Accede a una formación avanzada que te permitirá aplicar e implementar SEO en cualquier tipo de web.

Accede al Máster de SEO Técnico
Tal vez te interesen otros artículos:
Artículos de SEO