- Crawl budget Googlebot : optimiser l'indexation

1. Qu'est-ce que le crawl budget Googlebot et comment fonctionne-t-il ?

Le crawl budget est la limite de ressources que Googlebot alloue à un site donné — exprimé en nombre de pages crawlées par jour et en fréquence de visite. Google ajuste ce budget selon deux facteurs principaux : la crawl rate limit (capacité serveur) et la crawl demand (popularité et fraîcheur du contenu).

Comment Google mesure-t-il le crawl budget ?

Selon la documentation officielle Google (John Mueller, 2023), le crawl budget est calculé comme : Crawl budget = Crawl Rate × Crawl Demand. Un site rapide avec beaucoup de contenu populaire reçoit plus de budget. Un site lent avec beaucoup d'URLs de faible qualité se voit réduire son budget.

2. Comment analyser les logs serveur pour comprendre l'activité Googlebot ?

Les logs serveur (Nginx/Apache) sont la source de vérité sur le comportement Googlebot. Ils révèlent quelles pages sont crawlées, à quelle fréquence, et quels status codes sont retournés.

Parser les logs Nginx pour Googlebot

# Filtrer toutes les requêtes Googlebot dans les logs Nginx
grep "Googlebot" /var/log/nginx/access.log | head -100

# Compter les URLs les plus crawlées
grep "Googlebot" /var/log/nginx/access.log \
  | awk '{print $7}' \
  | sort | uniq -c | sort -rn \
  | head -50

# Identifier les erreurs 4xx/5xx crawlées par Googlebot
grep "Googlebot" /var/log/nginx/access.log \
  | awk '$9 >= 400 {print $9, $7}' \
  | sort | uniq -c | sort -rn

# Volume crawl par jour (dernière semaine)
grep "Googlebot" /var/log/nginx/access.log \
  | awk '{print $4}' \
  | cut -d: -f1 \
  | sed 's/\[//' \
  | sort | uniq -c

Script PHP d'analyse crawl budget

<?php
// analyze-crawl.php — analyse des logs serveur pour crawl budget
// Usage : php analyze-crawl.php /var/log/nginx/access.log

$logFile = $argv[1] ?? '/var/log/nginx/access.log';
$stats = [
    'total_googlebot'    => 0,
    'status_codes'       => [],
    'top_urls'           => [],
    'crawled_per_hour'   => [],
    'wasted_crawls'      => [], // URLs /admin/, /cart/, params URL
];

$wastedPatterns = ['/admin', '/cart', '/checkout', '?sort=', '?filter=', '?page=', '/wp-login'];

$handle = fopen($logFile, 'r');
while (($line = fgets($handle)) !== false) {
    if (strpos($line, 'Googlebot') === false) continue;

    // Parser la ligne de log Nginx (format combined)
    preg_match('/(\S+) \S+ \S+ \[([^\]]+)\] "(\S+) (\S+) \S+" (\d+)/', $line, $m);
    if (empty($m)) continue;

    [, $ip, $time, $method, $url, $status] = $m;
    $stats['total_googlebot']++;
    $stats['status_codes'][$status] = ($stats['status_codes'][$status] ?? 0) + 1;
    $stats['top_urls'][$url] = ($stats['top_urls'][$url] ?? 0) + 1;

    // Heure de crawl
    $hour = substr($time, 0, 11); // Ex: 07/May/2026:14
    $stats['crawled_per_hour'][$hour] = ($stats['crawled_per_hour'][$hour] ?? 0) + 1;

    // URLs parasites
    foreach ($wastedPatterns as $pattern) {
        if (strpos($url, $pattern) !== false) {
            $stats['wasted_crawls'][$url] = ($stats['wasted_crawls'][$url] ?? 0) + 1;
            break;
        }
    }
}
fclose($handle);

// Trier et afficher
arsort($stats['top_urls']);
arsort($stats['wasted_crawls']);
arsort($stats['status_codes']);

echo "=== CRAWL BUDGET ANALYSIS ===\n";
echo "Total requêtes Googlebot : " . $stats['total_googlebot'] . "\n\n";

echo "Status codes :\n";
foreach ($stats['status_codes'] as $code => $count) {
    $pct = round($count / $stats['total_googlebot'] * 100, 1);
    echo "  HTTP $code : $count ($pct%)\n";
}

echo "\nTop 20 URLs les plus crawlées :\n";
$i = 0;
foreach ($stats['top_urls'] as $url => $count) {
    if (++$i > 20) break;
    echo "  $count × $url\n";
}

echo "\nURLs parasites gaspillant le crawl :\n";
foreach (array_slice($stats['wasted_crawls'], 0, 20) as $url => $count) {
    echo "  ⚠️  $count × $url\n";
}

$wastedTotal = array_sum($stats['wasted_crawls']);
$pctWasted = $stats['total_googlebot'] > 0 ? round($wastedTotal / $stats['total_googlebot'] * 100, 1) : 0;
echo "\n📊 Budget gaspillé : $wastedTotal requêtes ($pctWasted% du total)\n";

3. Quelles URLs parasites gaspillent votre crawl budget ?

Les URLs parasites sont des pages de faible valeur SEO que Googlebot crawle en gaspillant du budget qui devrait aller vers vos pages importantes. Identifier et bloquer ces URLs est la première action à effectuer.

Script pour identifier les pages orphelines (404 liées)

<?php
// find-404-linked.php — trouver les liens internes vers des 404
// Nécessite un export Screaming Frog ou liste d'URLs depuis GSC

function checkInternalLinks(array $urls, string $baseUrl): array {
    $errors = [];

    foreach ($urls as $url) {
        $ch = curl_init();
        curl_setopt_array($ch, [
            CURLOPT_URL            => $baseUrl . $url,
            CURLOPT_NOBODY         => true,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_FOLLOWLOCATION => true,
            CURLOPT_TIMEOUT        => 10,
            CURLOPT_USERAGENT      => 'CrawlBudgetChecker/1.0',
        ]);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 404 || $httpCode === 410) {
            $errors[] = ['url' => $url, 'status' => $httpCode];
        }

        usleep(100000); // 100ms entre requêtes (ne pas surcharger)
    }

    return $errors;
}

// Exemple d'utilisation
$internalUrls = [
    '/blog/ancien-article',
    '/services/service-supprime',
    '/contact-old',
];

$broken = checkInternalLinks($internalUrls, 'https://monsite.com');
foreach ($broken as $err) {
    echo "❌ HTTP {$err['status']} : {$err['url']}\n";
}

4. Comment configurer robots.txt pour optimiser le crawl budget ?

Le fichier robots.txt est l'outil le plus direct pour contrôler quelles URLs Googlebot peut crawler. Un robots.txt bien configuré peut économiser 20-40% du crawl budget sur des sites moyens.

robots.txt optimal pour un site PHP standard

# robots.txt — optimisation crawl budget
# Dernière mise à jour : 07/05/2026

User-agent: *
# Pages administrateur
Disallow: /admin/
Disallow: /wp-admin/
Disallow: /dashboard/
Disallow: /login
Disallow: /register
Disallow: /logout

# Pages transactionnelles (pas de valeur SEO)
Disallow: /cart/
Disallow: /checkout/
Disallow: /order/
Disallow: /payment/
Disallow: /account/
Disallow: /wishlist/

# Paramètres URL parasites
Disallow: /*?sort=
Disallow: /*?filter=
Disallow: /*?ref=
Disallow: /*?utm_
Disallow: /*?sessionid=
Disallow: /*?affiliate=
Disallow: /*&print=1

# Recherche interne
Disallow: /search?
Disallow: /recherche?
Disallow: /*?q=
Disallow: /*?s=

# APIs et fichiers techniques
Disallow: /api/
Disallow: /ajax/
Disallow: /*.json$
Disallow: /feed/
Disallow: /cgi-bin/

# Fichiers temporaires et développement
Disallow: /tmp/
Disallow: /test/
Disallow: /dev/
Disallow: /.git/
Disallow: /.env

# Autoriser les assets nécessaires au rendu (CSS/JS pour Googlebot)
Allow: /assets/css/
Allow: /assets/js/
Allow: /assets/images/

# Sitemap(s) — obligatoire pour le crawl budget
Sitemap: https://monsite.com/sitemap.xml
Sitemap: https://monsite.com/sitemap-blog.xml
Sitemap: https://monsite.com/sitemap-products.xml

# Crawl rate limits par bot
User-agent: Bingbot
Crawl-delay: 2

User-agent: AhrefsBot
Crawl-delay: 10

User-agent: SemrushBot
Crawl-delay: 10

Vérifier robots.txt avec l'API Google

# Tester le robots.txt directement depuis la ligne de commande
curl -s "https://monsite.com/robots.txt"

# Vérifier si une URL est bloquée (outil Google)
# https://search.google.com/search-console/robots-testing-tool

# Tester manuellement avec Python (robots.txt parser)
python3 -c "
from urllib.robotparser import RobotFileParser
rp = RobotFileParser()
rp.set_url('https://monsite.com/robots.txt')
rp.read()
urls = ['/admin/', '/blog/article', '/search?q=test', '/api/data.json']
for url in urls:
    allowed = rp.can_fetch('Googlebot', 'https://monsite.com' + url)
    status = '✅ Autorisé' if allowed else '❌ Bloqué'
    print(f'{status} : {url}')
"

5. Sitemap XML : comment signaler les priorités à Googlebot ?

Le sitemap XML permet de guider Googlebot vers les pages importantes et de signaler les mises à jour via lastmod. Un sitemap bien structuré améliore la répartition du crawl budget vers les pages qui comptent.

Sitemap XML optimisé pour le crawl budget

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">

  <!-- Pages critiques : priorité 1.0, changefreq daily -->
  <url>
    <loc>https://monsite.com/</loc>
    <lastmod>2026-05-07</lastmod>
    <changefreq>daily</changefreq>
    <priority>1.0</priority>
  </url>

  <!-- Pages importantes : priorité 0.8, changefreq weekly -->
  <url>
    <loc>https://monsite.com/blog/angular-ssr-guide</loc>
    <lastmod>2026-05-01</lastmod>
    <changefreq>weekly</changefreq>
    <priority>0.8</priority>
  </url>

  <!-- Pages secondaires : priorité 0.5, changefreq monthly -->
  <url>
    <loc>https://monsite.com/about</loc>
    <lastmod>2026-01-15</lastmod>
    <changefreq>monthly</changefreq>
    <priority>0.5</priority>
  </url>

</urlset>

Générateur de sitemap PHP dynamique

<?php
// sitemap.php — générer dynamiquement le sitemap.xml
// Mettre en cache le résultat (Redis/fichier) pour ne pas régénérer à chaque crawl

header('Content-Type: application/xml; charset=utf-8');

// Pages statiques critiques
$staticPages = [
    ['url' => '/', 'lastmod' => '2026-05-07', 'priority' => '1.0', 'freq' => 'daily'],
    ['url' => '/blog/', 'lastmod' => '2026-05-07', 'priority' => '0.9', 'freq' => 'daily'],
    ['url' => '/about', 'lastmod' => '2026-01-01', 'priority' => '0.5', 'freq' => 'monthly'],
    ['url' => '/contact', 'lastmod' => '2026-01-01', 'priority' => '0.5', 'freq' => 'monthly'],
];

// Articles de blog depuis base de données
$pdo = new PDO('mysql:host=localhost;dbname=monsite', 'user', 'password');
$articles = $pdo->query(
    "SELECT slug, updated_at FROM articles WHERE status = 'published' ORDER BY updated_at DESC LIMIT 1000"
)->fetchAll(PDO::FETCH_ASSOC);

echo '<?xml version="1.0" encoding="UTF-8"?>' . "\n";
echo '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">' . "\n";

$baseUrl = 'https://monsite.com';

// Pages statiques
foreach ($staticPages as $page) {
    echo "  <url>\n";
    echo "    <loc>" . $baseUrl . htmlspecialchars($page['url']) . "</loc>\n";
    echo "    <lastmod>" . $page['lastmod'] . "</lastmod>\n";
    echo "    <changefreq>" . $page['freq'] . "</changefreq>\n";
    echo "    <priority>" . $page['priority'] . "</priority>\n";
    echo "  </url>\n";
}

// Articles blog
foreach ($articles as $article) {
    $lastmod = date('Y-m-d', strtotime($article['updated_at']));
    echo "  <url>\n";
    echo "    <loc>" . $baseUrl . "/blog/" . htmlspecialchars($article['slug']) . "</loc>\n";
    echo "    <lastmod>" . $lastmod . "</lastmod>\n";
    echo "    <changefreq>monthly</changefreq>\n";
    echo "    <priority>0.7</priority>\n";
    echo "  </url>\n";
}

echo '</urlset>';

6. Pagination et paramètres URL : comment éviter la dilution du crawl budget ?

La pagination génère souvent des centaines d'URLs de faible valeur (/blog?page=2, /products?sort=price&page=5) qui gaspillent le crawl budget sans apporter de valeur SEO significative.

Gestion des paramètres URL dans Google Search Console

// Ancienne GSC (Search Console ancien) avait "Paramètres d'URL"
// Désormais : utiliser la combinaison canonical + robots.txt

// Pour les paramètres de tracking (UTM, ref, etc.) :
// → Le canonical sur chaque page doit pointer vers l'URL propre (sans params)
// → Nginx : rewrite pour supprimer les paramètres avant de servir le contenu

// nginx.conf — supprimer paramètres parasites
location / {
    # Rediriger les URLs avec paramètres de tracking vers URL propre
    if ($args ~* "utm_|ref=|affiliate=|sessionid=") {
        rewrite ^(.*)$ $uri permanent;
    }

    try_files $uri $uri/ /index.php?$query_string;
}

7. Vitesse du site et crawl rate : pourquoi un serveur lent réduit l'indexation ?

Googlebot adapte la fréquence de crawl à la vitesse de réponse de votre serveur. Un TTFB élevé (Time To First Byte > 500ms) provoque une réduction automatique du crawl rate — moins de pages crawlées par jour.

Optimisations serveur pour améliorer le crawl rate

• Cache opcode PHP — activer OPcache (réduit TTFB de 50-70% sur PHP)
• Cache HTTP (Nginx) — fastcgi_cache pour les pages statiques, TTL 5-60 minutes
• CDN Cloudflare — TTFB < 50ms depuis les PoPs globaux, cache assets statiques
• Compression Gzip/Brotli — Nginx : gzip on; brotli on; (réduction 70% du poids HTML)
• Keep-Alive HTTP — réduire le nombre de connexions TCP (Googlebot réutilise les connexions)
• HTTP/2 ou HTTP/3 — multiplexage des requêtes, plus efficace pour Googlebot moderne
• Monitoring uptime — Pingdom ou UptimeRobot pour détecter les 5xx avant qu'ils impactent le crawl

Configuration Nginx cache pour crawl budget optimal

# nginx.conf — cache FastCGI pour optimiser TTFB et crawl rate

fastcgi_cache_path /var/cache/nginx levels=1:2 keys_zone=SITE_CACHE:100m max_size=1g inactive=60m;
fastcgi_cache_key "$scheme$request_method$host$request_uri";

server {
    location ~ \.php$ {
        fastcgi_pass php-fpm;
        fastcgi_cache SITE_CACHE;
        fastcgi_cache_valid 200 301 302 5m;    # Cache 5 min pour pages normales
        fastcgi_cache_valid 404 1m;             # Cache court pour 404
        fastcgi_cache_bypass $cookie_session;   # Pas de cache si utilisateur connecté
        fastcgi_no_cache $cookie_session;

        add_header X-Cache-Status $upstream_cache_status;
    }

    # Headers cache pour assets statiques
    location ~* \.(css|js|webp|woff2)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";
    }
}

8. Stratégies spécifiques pour les grands sites (10 000+ pages)

Les grands sites e-commerce, les sites d'actualités ou les portails avec des millions de pages doivent adopter des stratégies avancées pour que Googlebot indexe les pages les plus importantes en priorité.

• Sitemap index — diviser le sitemap en sous-sitemaps de 50 000 URLs max (sitemap-blog.xml, sitemap-products.xml, sitemap-categories.xml)
• Priorité via maillage interne — lier fréquemment les pages importantes depuis la homepage et les pages populaires (PageRank interne)
• Noindex sur contenu mince — pages de tags génériques, archives vides, pages de profils inactifs
• Crawl budget par section — utiliser des répertoires dédiés (/news/ vs /archive/) pour que Googlebot identifie les sections fraîches
• Supprimer le contenu obsolète — pages de produits retirés → 410 Gone (plus efficace que 404 pour signaler à Googlebot de ne plus revenir)
• IndexNow API — notifier Bing/Yandex instantanément (pas Google) lors de mises à jour (réduction du délai d'indexation)

Index Sitemaps pour grands sites

<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <sitemap>
    <loc>https://monsite.com/sitemap-static.xml</loc>
    <lastmod>2026-05-07</lastmod>
  </sitemap>
  <sitemap>
    <loc>https://monsite.com/sitemap-blog-1.xml</loc>  <!-- Articles 1-50000 -->
    <lastmod>2026-05-07</lastmod>
  </sitemap>
  <sitemap>
    <loc>https://monsite.com/sitemap-blog-2.xml</loc>  <!-- Articles 50001-100000 -->
    <lastmod>2026-04-30</lastmod>
  </sitemap>
  <sitemap>
    <loc>https://monsite.com/sitemap-products.xml</loc>
    <lastmod>2026-05-07</lastmod>
  </sitemap>
</sitemapindex>

FAQ — Crawl Budget et Googlebot

Conclusion : optimiser le crawl budget pour une indexation complète

Le crawl budget est un levier SEO technique souvent négligé, particulièrement critique pour les sites de taille moyenne (10 000+ pages). Une optimisation systématique — robots.txt précis, URLs parasites supprimées, TTFB < 200ms, sitemap à jour — permet à Googlebot de concentrer ses ressources sur vos pages à valeur ajoutée.

Checklist finale — Crawl Budget Googlebot

• Logs serveur analysés — identifier URLs parasites et erreurs crawlées par Googlebot
• robots.txt optimisé — bloquer admin, cart, search?, paramètres de tri/session
• URLs parasites canonicalisées — ?sort=, ?filter=, ?utm_ → canonical URL propre
• Sitemap.xml propre — uniquement pages indexables + lastmod à jour + soumis GSC
• TTFB < 200ms — OPcache PHP + cache Nginx + CDN configurés
• Erreurs 404 orphelines — liens internes vers 404 corrigés en 301 ou supprimés
• Pages minces en noindex — archives vides, tags génériques, profils inactifs
• 410 pour contenu supprimé — produits retirés, pages obsolètes → HTTP 410 Gone
• GSC statistiques exploration — monitorer le crawl budget hebdomadairement
• Pagination canonicalisée — self-referencing canonical sur chaque page de pagination