Index de sitemaps : définition, limites et lecture des sitemaps enfants

Format et limites d’un fichier d’index

Un fichier d’index liste des sitemaps, pas des pages. Les moteurs de recherche l’ouvrent, puis chaque fichier qu’il cite, et n’atteignent qu’ensuite les URL de vos pages. Les gros sites en ont besoin, car un seul sitemap contient au maximum 50 000 URL et 50 Mo. WordPress, Yoast SEO et Rank Math en utilisent un même sur les petits sites, parce qu’ils répartissent les URL par type de contenu. Notre guide montre où WordPress publie son index.

L’élément racine est sitemapindex, dans le même espace de noms qu’un sitemap ordinaire. Chaque fichier listé reçoit une entrée sitemap avec deux balises :

• loc : l’URL complète du sitemap enfant. Elle est obligatoire.
• lastmod : la date de dernière modification de ce fichier, au format W3C Datetime. Elle est facultative.

<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <sitemap>
    <loc>https://example.com/post-sitemap.xml</loc>
    <lastmod>2026-10-28T09:12:00+00:00</lastmod>
  </sitemap>
  <sitemap>
    <loc>https://example.com/page-sitemap.xml.gz</loc>
    <lastmod>2026-10-02</lastmod>
  </sitemap>
</sitemapindex>

Un index n’a ni changefreq ni priority. Attention au sens de lastmod ici : sitemaps.org le définit comme le moment où le fichier sitemap a changé, et non les pages qu’il contient. Un sitemap enfant peut être compressé en gzip, comme dans la seconde entrée.

Les limites viennent du protocole sitemaps.org, et Google en ajoute quelques-unes :

Règle	Valeur	Source
Sitemaps listés dans un index	50 000 au maximum	sitemaps.org, Google
Taille du fichier	50 Mo (52 428 800 octets) non compressé	sitemaps.org, Google
Compression	gzip autorisé	sitemaps.org
Fichiers d’index par site dans la Search Console	500	Google
Index dans un index	interdit	Google

Google indique que toutes les exigences des sitemaps s’appliquent aussi aux fichiers d’index : la limite de 50 Mo se mesure donc après décompression.

Imbrication et règle du même hôte

Google n’accepte pas d’index dans un index. L’aide du rapport Sitemaps indique qu’un index ne peut inclure que des fichiers sitemaps, et le rapport affiche une erreur d’imbrication quand il en trouve un. Le protocole ne dit rien à ce sujet, si bien que certains générateurs en imbriquent encore. Aplatissez l’arborescence : faites pointer le fichier principal directement vers les fichiers qui contiennent des URL. Avec plus de 50 000 sitemaps, répartissez-les dans plusieurs fichiers d’index et envoyez chacun d’eux.

Le protocole précise aussi qu’un index ne peut lister que des sitemaps du même site. Google ajoute deux détails :

• Les sitemaps enfants doivent se trouver dans le même répertoire que l’index, ou plus bas dans l’arborescence du site.
• La règle du même site ne s’applique pas si vous avez configuré l’envoi pour plusieurs sites, ce qui suppose de prouver que vous contrôlez chaque hôte.

Ainsi, un index situé à https://example.com/sitemap.xml ne doit lister ni https://cdn.example.net/products.xml ni http://www.example.com/posts.xml. Les deux comptent comme d’autres hôtes. Pour une URL située à un niveau supérieur ou sur un autre domaine, le rapport affiche « URL non autorisée ».

L’envoyer dans la Search Console et le déclarer dans le robots.txt

Dans le rapport Sitemaps, saisissez l’URL de l’index et cliquez sur « Envoyer ». Cet envoi unique couvre tous les sitemaps enfants. Pour un index, d’après la page d’aide, la colonne « Pages découvertes » compte toutes les URL de tous les sitemaps enfants. Vous pouvez aussi envoyer un sitemap enfant si vous voulez sa propre ligne et son propre état, mais ce n’est pas obligatoire.

• Les redirections ne sont pas suivies pour l’URL envoyée. Envoyez l’adresse finale, celle qui répond avec un code 200.
• Le rapport ne liste que les sitemaps envoyés depuis le rapport ou par l’API : un fichier que Google a trouvé dans le robots.txt n’y apparaît pas.

Dans le robots.txt, ajoutez une ligne avec l’URL complète, n’importe où dans le fichier :

Sitemap: https://example.com/sitemap_index.xml

Le protocole indique qu’avec un index, vous pouvez donner l’emplacement de ce seul fichier. Cette ligne fait partie du protocole sitemaps.org : elle n’est pas propre à Google.

Les erreurs courantes et leurs causes

La plupart des problèmes viennent des sitemaps enfants, pas du fichier d’index.

• Sitemap enfant sur un autre hôte. Un passage de http à https, ou de www à une adresse sans www, laisse d’anciennes URL dans l’index. Chaque loc doit utiliser le même schéma, http ou https, et le même hôte que l’index.
• URL relative. <loc>/post-sitemap.xml</loc> n’est pas valide. Google signale une URL incomplète.
• Sitemap enfant en erreur 404. Une extension a été désactivée, un type de contenu a été supprimé, ou un cache sert un ancien index.
• Sitemap enfant qui renvoie du HTML. Une page de connexion, une vérification de sécurité ou la page 404 du thème, envoyée avec un code 200. Notre article sur l’erreur de récupération du sitemap montre comment repérer ce cas avec un test en direct.
• Mauvais format de lastmod. 15/10/2026 n’est pas au format W3C Datetime. Écrivez 2026-10-15, ou 2026-10-15T14:30:00+00:00 avec l’heure et le fuseau horaire. Google signale « Date incorrecte ».
• Index imbriqué. Listez à la place les fichiers qu’il contient.

Comment lire chaque sitemap enfant

Ouvrir cinquante fichiers un par un prend du temps. Voici trois façons de tous les voir.

Vérifier le fichier d’index avec le vérificateur de sitemap

Collez l’index dans le vérificateur de sitemap gratuit, ou ouvrez le fichier .xml ou .xml.gz. Il reconnaît un index et liste chaque sitemap enfant avec son lastmod dans un tableau « Sitemaps ». Il signale les URL relatives ou qui ne sont pas en http, les dates non valides, les doublons, les sitemaps enfants répartis sur plusieurs hôtes, les entrées url ou les balises changefreq et priority placées dans un index, et les fichiers de plus de 50 000 entrées ou de 50 Mo.

Il ne vérifie que ce fichier. La page ne se connecte jamais à d’autres sites : elle n’ouvre donc pas les sitemaps enfants et ne peut pas savoir si l’un d’eux renvoie une erreur 404 ou du HTML. Son verdict vous rappelle de vérifier aussi chaque sitemap listé.

Charger tous les sitemaps enfants avec XMLNest

L’extension XMLNest pour Chrome ouvre un index en ligne dans sa vue Lecture. Cliquez sur « Charger tous les sitemaps enfants » : elle demande les sitemaps enfants un par un, avec une ligne de progression et un bouton « Annuler ».

• Seuls les sitemaps enfants situés sur le même site que l’index (même schéma, même hôte et même port) sont demandés. Les autres affichent « Ignoré : sur un autre site, jamais demandé ».
• Jusqu’à 50 sitemaps enfants, de 50 Mo chacun ; les fichiers .gz sont décompressés.
• Les redirections ne sont pas suivies, et un index imbriqué est ignoré.
• Chaque échec indique sa raison : le code HTTP, « le XML est mal formé », ou « pas un sitemap » avec la balise racine trouvée, ce qui permet de repérer une page HTML.

Les URL de tous les sitemaps enfants chargés vont dans un seul tableau, avec une colonne qui indique leur fichier d’origine. L’onglet « Problèmes » applique les règles du vérificateur de sitemap à chaque fichier et liste les URL présentes dans deux sitemaps enfants. Notre article pour extraire les URL d’un sitemap présente l’export en CSV et en JSON.

Développer l’index avec Python

Cette fonction lit un index, suit chaque sitemap enfant situé sur le même hôte, décompresse le gzip et affiche chaque URL de page une seule fois. Elle n’utilise que la bibliothèque standard.

import gzip
import sys
import urllib.request
import xml.etree.ElementTree as ET
from urllib.parse import urlsplit

NS = "{http://www.sitemaps.org/schemas/sitemap/0.9}"

def fetch(url):
    req = urllib.request.Request(url, headers={"User-Agent": "expand-index/1.0"})
    with urllib.request.urlopen(req, timeout=30) as resp:
        data = resp.read()
    if data[:2] == b"\x1f\x8b":  # gzip, whatever the file name says
        data = gzip.decompress(data)
    return ET.fromstring(data)

def locs(root, entry):
    return [el.text.strip() for el in root.findall(f"{NS}{entry}/{NS}loc") if el.text]

def page_urls(index_url):
    root = fetch(index_url)
    if root.tag == NS + "urlset":
        return locs(root, "url")
    host = urlsplit(index_url).netloc
    pages = []
    for child in locs(root, "sitemap"):
        if urlsplit(child).netloc != host:
            print("skipped, other host:", child, file=sys.stderr)
            continue
        try:
            sub = fetch(child)
        except Exception as err:
            print("failed:", child, err, file=sys.stderr)
            continue
        if sub.tag != NS + "urlset":
            print("skipped, not a urlset:", child, file=sys.stderr)
            continue
        found = locs(sub, "url")
        print(f"{child}: {len(found)} URLs", file=sys.stderr)
        pages.extend(found)
    return pages

if __name__ == "__main__":
    for url in dict.fromkeys(page_urls(sys.argv[1])):
        print(url)

Lancez python expand_index.py https://example.com/sitemap.xml > urls.txt. Le compte rendu s’affiche à l’écran et les URL vont dans le fichier. Nous l’avons exécuté sur un index de test local à cinq entrées. Il a lu deux sitemaps enfants, dont un compressé en gzip, et renvoyé leurs cinq URL de pages. Il a ignoré un index imbriqué et un sitemap enfant situé sur un autre hôte, et signalé « HTTP Error 404 » pour un fichier manquant.

Liste de contrôle avant l’envoi

• La racine est sitemapindex, avec l’espace de noms de sitemaps.org, et chaque entrée a un loc complet.
• 50 000 entrées et 50 Mo non compressé au maximum ; pas d’index dans un index.
• Chaque sitemap enfant utilise le même hôte et le même schéma que l’index, dans le même répertoire ou plus bas.
• Chaque sitemap enfant répond 200 avec du XML, et non par une redirection, une erreur 404 ou du HTML.
• lastmod suit le format W3C Datetime et change quand le fichier change.
• Envoyez l’index une seule fois dans la Search Console, et ajoutez une ligne Sitemap: au robots.txt.