Le sitemap (plan du site) est un fichier XML listant les URL d'un site, que son propriétaire fournit aux moteurs de recherche et aux crawlers. Pour la collecte de données, ce plan est précieux : au lieu de parcourir les liens de page en page à l'aveugle, vous disposez d'une liste d'adresses prête à l'emploi, souvent accompagnée de la date de dernière modification et d'une priorité. Le parsing du sitemap est donc généralement la première étape avant le parsing du HTML. Cet article prolonge notre panorama des formats de documents ; le sitemap étant un cas particulier de XML, les techniques générales de travail avec l'arbre sont décrites dans l'article sur le parsing XML.
Structure du fichier
Le sitemap standard est décrit par le schéma sitemaps.org. Chaque URL est un élément <url> avec un <loc> obligatoire et des <lastmod>, <changefreq>, <priority> facultatifs.
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<url>
<loc>https://example.com/product/101</loc>
<lastmod>2026-05-12</lastmod>
<priority>0.8</priority>
</url>
<url>
<loc>https://example.com/product/102</loc>
<lastmod>2026-06-01</lastmod>
</url>
</urlset>
Détail important : l'espace de noms http://www.sitemaps.org/schemas/sitemap/0.9. À cause de lui, une recherche « naïve » de la balise loc sans tenir compte du namespace ne renverra rien — c'est l'erreur la plus fréquente dans l'analyse des plans de site (plus de détails sur les namespaces dans l'article sur le XML).
Index de sitemaps et plans de site imbriqués
Sur les grands sites, un seul fichier ne suffit pas à contenir tous les liens (limite : 50 000 URL ou 50 Mo) ; on utilise alors un index de cartes — un fichier pointant vers d'autres sitemaps. L'élément racine est ici <sitemapindex>, contenant des <sitemap> avec leurs <loc>.
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<sitemap><loc>https://example.com/sitemap-products.xml</loc></sitemap>
<sitemap><loc>https://example.com/sitemap-articles.xml.gz</loc></sitemap>
</sitemapindex>
Un parseur fiable doit donc être récursif : lire d'abord l'index, puis télécharger et analyser chaque carte imbriquée. Notez que les fichiers imbriqués sont souvent servis en gzip (.xml.gz) — il faut les décompresser à la volée.
Où trouver le plan du site
L'adresse du sitemap figure généralement dans robots.txt, sur la ligne Sitemap:. À défaut, on vérifie les chemins standards /sitemap.xml et /sitemap_index.xml. Commencez par robots.txt : c'est le moyen le plus sûr de connaître l'emplacement actuel.
Python
L'approche la plus transparente : télécharger le fichier et l'analyser comme un XML ordinaire avec lxml, sans oublier le namespace et la récursion sur l'index.
import gzip
import requests
from lxml import etree
NS = {"sm": "http://www.sitemaps.org/schemas/sitemap/0.9"}
def fetch(url):
data = requests.get(url, timeout=30).content
if url.endswith(".gz"):
data = gzip.decompress(data)
return etree.fromstring(data)
def parse_sitemap(url, urls=None):
urls = urls if urls is not None else []
root = fetch(url)
# si c'est un index, on descend dans les cartes imbriquées
for loc in root.xpath("//sm:sitemap/sm:loc/text()", namespaces=NS):
parse_sitemap(loc.strip(), urls)
# liens ordinaires
for loc in root.xpath("//sm:url/sm:loc/text()", namespaces=NS):
urls.append(loc.strip())
return urls
links = parse_sitemap("https://example.com/sitemap.xml")
print(len(links), "URL trouvées")
Si vous ne voulez pas écrire vous-même la récursion et la gestion du gzip, il existe une bibliothèque spécialisée, ultimate-sitemap-parser : elle trouve la carte, parcourt les index et renvoie la liste à plat des pages.
from usp.tree import sitemap_tree_for_homepage
tree = sitemap_tree_for_homepage("https://example.com/")
for page in tree.all_pages():
print(page.url, page.last_modified)
JavaScript / Node.js
Sous Node, on analyse commodément la carte avec fetch et fast-xml-parser (le même que pour le XML).
const { XMLParser } = require("fast-xml-parser");
async function parseSitemap(url) {
const xml = await (await fetch(url)).text();
const parser = new XMLParser();
const doc = parser.parse(xml);
if (doc.sitemapindex) {
const maps = [].concat(doc.sitemapindex.sitemap);
const all = [];
for (const m of maps) all.push(...await parseSitemap(m.loc));
return all;
}
return [].concat(doc.urlset.url).map((u) => u.loc);
}
parseSitemap("https://example.com/sitemap.xml").then((urls) =>
console.log(urls.length)
);
Que faire des dates de mise à jour
Le champ <lastmod> est la principale raison d'aimer les plans de site. En le comparant à la date de votre passage précédent, vous ne téléchargez que les pages modifiées et évitez de charger le site inutilement. Cela transforme un scraping ponctuel en veille régulière efficace : vous ne parcourez pas tout le site, seulement le delta. Gardez en tête que lastmod n'est pas toujours renseigné, ni toujours honnête — utilisez-le comme un indice, pas comme une vérité absolue.
Une fois la liste d'URL constituée commence l'extraction proprement dite des données des pages — c'est le travail du parsing HTML. S'il faut parcourir régulièrement un grand site avec index de cartes, gzip et filtrage par date, nous mettons en place un parsing clé en main, planification et export du résultat au format voulu compris, par exemple CSV ou Excel.