

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.

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:

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:


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.
.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>.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># 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>LiteSpeed. Lee el .htaccess de Apache, pero no entero: LiteSpeed Enterprise entiende Header con always y con env=, pero no la condición expr= de Apache 2.4 (y una directiva que no reconoce no da error: simplemente no hace nada); OpenLiteSpeed solo lee las reglas de mod_rewrite. Así que aquí el estado y la cabecera los pone PHP: la regla reescribe a un script, y el script responde.
.htaccess, en la raíz o dentro de /tienda/# Mantenimiento: todo lo que no venga de tu IP se sirve desde mantenimiento.php,
# que es quien devuelve el 503 y la cabecera. Sin R=503, sin mod_headers y sin
# ErrorDocument: vale igual en LiteSpeed Enterprise y en OpenLiteSpeed
# (en OpenLiteSpeed, con «Auto Load from .htaccess» activado en Rewrite).
RewriteEngine On
RewriteCond %{REMOTE_ADDR} !^203\.0\.113\.10$
RewriteCond %{REQUEST_URI} !^/mantenimiento
RewriteRule ^ /mantenimiento.php [L]<?php
// 503 y Retry-After desde PHP: esto lo entiende cualquier servidor.
http_response_code(503);
header('Retry-After: 3600'); // segundos, o una fecha HTTP en GMT
header('Cache-Control: no-store'); // que ninguna caché se quede con el 503
header('Content-Type: text/html; charset=utf-8');
?>
<!doctype html>
<html lang="es">
<head><meta charset="utf-8"><title>Mantenimiento</title></head>
<body>
<h1>Volvemos en una hora</h1>
<p>Estamos haciendo cambios. Vuelve a intentarlo un poco más tarde.</p>
</body>
</html>.htaccess reescribe, limite.php contesta# El límite por IP de LiteSpeed (Per Client Throttling, en el WebAdmin) frena,
# pero no contesta 429 ni manda Retry-After: a las peticiones de más las deja
# esperando. Para decirle a un bot «vuelve en diez minutos», que lo diga PHP:
RewriteEngine On
RewriteCond %{HTTP_USER_AGENT} (AhrefsBot|SemrushBot) [NC]
RewriteCond %{REQUEST_URI} !^/limite\.php$
RewriteRule ^ /limite.php [L]<?php
http_response_code(429);
header('Retry-After: 600');
header('Content-Type: text/plain; charset=utf-8');
echo 'Demasiadas peticiones. Vuelve a intentarlo en diez minutos.';nginx. La cabecera se declara una sola vez con un map sobre $status: nginx no envía una cabecera cuyo valor quede vacío, así que Retry-After solo acompaña a los 503 y a los 429. El estado lo pone return o limit_req.
http { } y en el server { }# nginx no envía una cabecera cuyo valor esté vacío: con un map, Retry-After
# solo acompaña a los estados que la necesitan. Esto vale para todo lo de abajo.
map $status $retry_after {
503 3600; # mantenimiento: una hora
429 10; # límite de peticiones: diez segundos
default "";
}
server {
# …
add_header Retry-After $retry_after always; # «always»: también en los errores (1.7.5 o superior)
# Ojo: si una location tiene su propio add_header, no hereda este. Repítelo ahí.
}server { }# Se activa creando el archivo mantenimiento.flag en la raíz y se desactiva
# borrándolo: sin tocar la configuración ni recargar nginx.
set $mantenimiento 0;
if (-f $document_root/mantenimiento.flag) { set $mantenimiento 1; }
if ($remote_addr = 203.0.113.10) { set $mantenimiento 0; }
if ($mantenimiento) { return 503; }
error_page 503 @mantenimiento;
location @mantenimiento {
rewrite ^ /mantenimiento.html break;
}
# La página de mantenimiento, con el CSS incrustado: cualquier recurso aparte
# (una hoja de estilos, un logo) recibiría también el 503.location de /tienda/location /tienda/ {
set $mantenimiento 0;
if (-f $document_root/mantenimiento.flag) { set $mantenimiento 1; }
if ($remote_addr = 203.0.113.10) { set $mantenimiento 0; }
if ($mantenimiento) { return 503; }
# … lo que ya tuvieras aquí (try_files, fastcgi_pass…)
}
# El error_page 503 y el map de la cabecera del primer bloque ya cubren esto.# En http { }: una zona por IP, diez peticiones por segundo.
limit_req_zone $binary_remote_addr zone=porip:10m rate=10r/s;
# En el server { } o en la location que quieras proteger:
limit_req zone=porip burst=20 nodelay;
limit_req_status 429; # por defecto nginx responde 503, que es mentira (1.3.15 o superior)
# Con el map del primer bloque, cada 429 lleva Retry-After: 10Lí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.
- Persona5 peticiones por segundo, ráfaga de 60
Retry-After: 12Cualquier navegador. Es difícil llegar, incluso compartiendo IP en una oficina o en una red móvil. - Buscador verificado2 por segundo, ráfaga de 120
Retry-After: 60Googlebot o Bingbot desde una IP que es suya. Si llega al tope, Google baja el ritmo en todo el host. - Robot1 cada 2 segundos, ráfaga de 60
Retry-After: 120Herramientas SEO, scrapers, bots de IA… y el Googlebot de pega.
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.
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();
}.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>.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.phpEn 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.
nginx. Aquí no hace falta PHP: limit_req lleva el cubo de cada IP, y con una zona por fuente cada una tiene su ritmo. La fuente sale de cruzar el agente de usuario con las listas de IP que publican Google y Bing. Si tu hosting no te deja tocar nginx, el limitador en PHP de la otra pestaña funciona igual.
http { }# Las IP de los rastreadores de Google y de Bing (el archivo se genera abajo).
geo $ip_de_buscador {
default 0;
include /etc/nginx/ip-buscadores.conf;
}
# La fuente: buscador si el agente de usuario y la IP cuadran; robot si el agente
# lo delata, incluido el Googlebot que no sale de una IP de Google; persona, el resto.
map "$ip_de_buscador:$http_user_agent" $fuente {
default persona;
"~*^1:.*(googlebot|googleother|google-inspectiontool|bingbot)" buscador;
"~*(bot|crawl|spider|slurp|scrapy|python|curl|wget|httpclient|java/|go-http|headless)" robot;
}
# robots.txt no se limita nunca: con un 429 ahí, Google deja de rastrear toda
# la web mientras reintenta leerlo (hasta 12 horas).
map $request_uri $exento { "~^/robots\.txt" 1; default 0; }
# Una clave por zona, vacía si la petición es de otra fuente o está exenta: no cuenta.
map "$exento:$fuente" $clave_persona { "0:persona" $binary_remote_addr; default ""; }
map "$exento:$fuente" $clave_buscador { "0:buscador" $binary_remote_addr; default ""; }
map "$exento:$fuente" $clave_robot { "0:robot" $binary_remote_addr; default ""; }
limit_req_zone $clave_persona zone=personas:10m rate=5r/s;
limit_req_zone $clave_buscador zone=buscadores:10m rate=2r/s;
limit_req_zone $clave_robot zone=robots:10m rate=30r/m;
limit_req_status 429;
# Retry-After según el estado y la fuente: lo que tarda cada cubo en vaciarse
# (ráfaga ÷ ritmo). Sustituye al map $status del bloque anterior.
map "$status:$fuente" $retry_after {
"~^503:" 3600;
"429:persona" 12;
"429:buscador" 60;
"429:robot" 120;
default "";
}location de PHP# En la location de PHP, no en todo el server: cada página arrastra decenas de
# recursos estáticos, y esos no deben contar.
location ~ \.php$ {
limit_req zone=personas burst=60 nodelay;
limit_req zone=buscadores burst=120 nodelay;
limit_req zone=robots burst=60 nodelay;
# … lo que ya tuvieras aquí (include fastcgi_params, fastcgi_pass…)
}
# La cabecera la sigue poniendo el add_header Retry-After $retry_after always
# del server { }. Si esta location tiene sus propios add_header, repítelo aquí./etc/cron.daily/ip-buscadores#!/bin/sh
# /etc/cron.daily/ip-buscadores (con chmod +x): baja las listas de IP que publican
# Google y Bing, las pasa al formato de geo y recarga nginx. Necesita curl y jq.
# Lánzalo una vez a mano antes de añadir el geo: sin el archivo, nginx no arranca.
set -e
T=/tmp/ip-buscadores
mkdir -p "$T"
curl -fsS -o "$T/google.json" https://developers.google.com/static/crawling/ipranges/common-crawlers.json
curl -fsS -o "$T/bing.json" https://www.bing.com/toolbox/bingbot.json
jq -r '.prefixes[] | (.ipv4Prefix // .ipv6Prefix) + " 1;"' "$T/google.json" "$T/bing.json" > "$T/conf"
test -s "$T/conf"
cp "$T/conf" /etc/nginx/ip-buscadores.conf
nginx -t -q && nginx -s reloadfor 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.
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


