Comment créer un sitemap XML à partir d’une liste d’URL ?

Pour créer un sitemap XML à partir d’une liste d’URL, il faut nettoyer les adresses, générer une entrée <url> avec une balise <loc> pour chaque page, puis publier le fichier sur votre site. Voici une méthode simple, avec un exemple Python prêt à utiliser.
✓ Vérifié le 9 octobre 2026 · 5 min de lecture

Préparer la liste d’URL

Commencez par enregistrer une URL complète par ligne dans un fichier nommé urls.txt :

https://www.exemple.com/
https://www.exemple.com/page-1/
https://www.exemple.com/page-2/

Avant de générer le sitemap, conservez uniquement les URL :

  • absolues, avec https:// ou http:// ;
  • rattachées au site concerné ;
  • accessibles et destinées à apparaître dans les résultats de recherche ;
  • correspondant idéalement à l’URL canonique de chaque page.

Supprimez également les lignes vides, les doublons, les URL mal formées, les pages supprimées et les variantes inutiles avec paramètres.

Créer un sitemap XML manuellement

Un sitemap XML minimal contient une déclaration XML, un élément racine <urlset> et une entrée <url> par page. La balise obligatoire dans chaque entrée est <loc>.

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://www.exemple.com/</loc>
  </url>
  <url>
    <loc>https://www.exemple.com/page-1/</loc>
  </url>
  <url>
    <loc>https://www.exemple.com/page-2/</loc>
  </url>
</urlset>

Enregistrez ce contenu dans un fichier nommé sitemap.xml, au format UTF-8.

Ajouter la date de dernière modification

La balise <lastmod> est facultative. Utilisez-la uniquement lorsque la date correspond à une modification significative et vérifiable de la page.

<url>
  <loc>https://www.exemple.com/article/</loc>
  <lastmod>2025-01-15</lastmod>
</url>

Les balises <changefreq> et <priority> ne sont pas nécessaires pour Google, qui indique ignorer leurs valeurs.

Générer automatiquement le sitemap avec Python

Le script suivant lit urls.txt, ignore les lignes invalides, supprime les doublons et génère sitemap.xml.

from pathlib import Path
from urllib.parse import urlparse
from xml.sax.saxutils import escape

INPUT_FILE = "urls.txt"
OUTPUT_FILE = "sitemap.xml"

def is_absolute_http_url(url):
    parsed = urlparse(url)
    return parsed.scheme in ("http", "https") and bool(parsed.netloc)

raw_urls = Path(INPUT_FILE).read_text(encoding="utf-8").splitlines()

urls = []
seen = set()

for line in raw_urls:
    url = line.strip()

    if not url:
        continue

    if not is_absolute_http_url(url):
        print(f"URL ignorée : {url}")
        continue

    if url not in seen:
        urls.append(url)
        seen.add(url)

if len(urls) > 50000:
    raise ValueError(
        "La liste dépasse 50 000 URL : il faut créer plusieurs sitemaps."
    )

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

for url in urls:
    lines.append("  <url>")
    lines.append(f"    <loc>{escape(url)}</loc>")
    lines.append("  </url>")

lines.append("</urlset>")

Path(OUTPUT_FILE).write_text(
    "n".join(lines) + "n",
    encoding="utf-8"
)

print(f"{len(urls)} URL générées dans {OUTPUT_FILE}")

L’échappement XML est important : par exemple, le caractère & doit être converti en &amp; dans une URL affichée dans le fichier XML.

Gérer plus de 50 000 URL

Un sitemap standard ne doit pas dépasser 50 000 URL ni 50 Mo non compressé. Si votre liste dépasse l’une de ces limites, répartissez-la dans plusieurs fichiers :

  • sitemap-1.xml ;
  • sitemap-2.xml ;
  • sitemap-3.xml, si nécessaire.

Créez ensuite un fichier d’index :

<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <sitemap>
    <loc>https://www.exemple.com/sitemap-1.xml</loc>
  </sitemap>
  <sitemap>
    <loc>https://www.exemple.com/sitemap-2.xml</loc>
  </sitemap>
</sitemapindex>

Déclarez ensuite l’URL de l’index plutôt que celle de chaque fichier individuel.

Publier et déclarer le sitemap

Publier le fichier sur le site

Placez le fichier à une adresse publique, par exemple :

https://www.exemple.com/sitemap.xml

Il doit être accessible sans authentification, retourner une réponse HTTP correcte et rester lisible par les robots des moteurs de recherche. Le placer à la racine du site est généralement recommandé.

Ajouter le sitemap dans robots.txt

Ajoutez cette ligne dans le fichier robots.txt :

Sitemap: https://www.exemple.com/sitemap.xml

Si vous utilisez un sitemap index, indiquez uniquement l’URL de l’index.

Le soumettre dans Google Search Console

  1. Publiez le fichier sur votre site.
  2. Vérifiez son accessibilité dans un navigateur.
  3. Ouvrez le rapport Sitemaps dans Google Search Console.
  4. Saisissez l’URL du sitemap.
  5. Cliquez sur Envoyer.

La soumission indique à Google où trouver le fichier. Elle ne garantit ni l’exploration ni l’indexation de toutes les URL.

Vérifier le sitemap XML

Avant de le considérer comme terminé, contrôlez les points suivants :

  • le XML est bien formé ;
  • chaque URL est absolue et utilise le bon domaine ;
  • les URL ne sont pas dupliquées ;
  • les pages ne redirigent pas et ne renvoient pas d’erreur ;
  • le fichier est encodé en UTF-8 ;
  • les limites de 50 000 URL et 50 Mo sont respectées ;
  • le sitemap est accessible sans blocage serveur ou authentification.

Google Search Console peut notamment signaler des erreurs XML, des URL inaccessibles, des URL relatives ou un fichier trop volumineux.

La méthode en résumé

  1. Placez une URL complète par ligne dans urls.txt.
  2. Nettoyez la liste et supprimez les doublons.
  3. Générez une entrée <url><loc>...</loc></url> pour chaque adresse.
  4. Enregistrez le fichier en UTF-8 sous sitemap.xml.
  5. Publiez-le à la racine du site.
  6. Déclarez-le dans robots.txt et Google Search Console.

À retenir

  • Un sitemap XML aide les moteurs de recherche à découvrir les URL, sans garantir leur exploration ou leur indexation.
  • Chaque adresse doit être absolue, accessible et idéalement canonique.
  • Un fichier standard est limité à 50 000 URL et 50 Mo non compressé.
  • Les URL doivent être correctement échappées dans le XML.
  • Publiez le sitemap puis déclarez-le dans Google Search Console ou dans robots.txt.

Passez à la pratique

Utilisez directement les outils Outiko associés à ce guide.

Questions fréquentes

Quel format doit avoir la liste d’URL ?
Utilisez un fichier texte, comme urls.txt, avec une URL absolue par ligne, par exemple https://www.exemple.com/page/. Les lignes vides et les doublons doivent être supprimés.
Faut-il ajouter toutes les URL du site dans le sitemap ?
Non. Incluez les URL que vous souhaitez voir apparaître dans les résultats de recherche, notamment les pages accessibles et canoniques. Évitez les pages supprimées, les redirections et les variantes inutiles avec paramètres.
La balise <code><lastmod></code> est-elle obligatoire ?
Non. Elle est facultative et doit uniquement indiquer une date de modification significative, exacte et vérifiable. Une date approximative ou systématiquement actualisée réduit sa fiabilité.
Que faire avec plus de 50 000 URL ?
Répartissez les URL dans plusieurs fichiers sitemap, puis créez un sitemap index contenant l’URL complète de chaque fichier.
La soumission dans Google Search Console garantit-elle l’indexation ?
Non. Elle indique à Google où trouver le sitemap, mais ne garantit ni l’exploration de toutes les URL ni leur indexation.

Sources & vérification

Les informations de ce guide s’appuient sur les sources ci-dessous. Elles sont conservées pour faciliter les vérifications et les mises à jour.