Indice delle sitemap: cos'è, quali limiti ha e come leggerlo

Formato e limiti di un indice di sitemap

Un indice elenca sitemap, non pagine. I motori di ricerca lo aprono, poi aprono ogni file che nomina, e solo allora arrivano agli URL delle tue pagine. I siti grandi ne hanno bisogno perché una singola sitemap contiene al massimo 50.000 URL e 50 MB. WordPress, Yoast SEO e Rank Math lo usano anche sui siti piccoli, perché dividono gli URL per tipo di contenuto. La nostra guida mostra dove WordPress pubblica il suo indice.

L’elemento radice è sitemapindex, nello stesso spazio dei nomi di una sitemap normale. Ogni file elencato ha una voce sitemap con due tag:

• loc: l’URL completo della sitemap figlia. È obbligatorio.
• lastmod: quando il file è stato modificato l’ultima volta, nel formato W3C Datetime. È facoltativo.

<?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>

In un indice non ci sono changefreq né priority. Attenzione al significato di lastmod in questo caso: sitemaps.org lo definisce come il momento in cui è cambiato il file sitemap, non le pagine che contiene. Una sitemap figlia può essere compressa con gzip, come nella seconda voce.

I limiti vengono dal protocollo di sitemaps.org, e Google ne aggiunge alcuni:

Regola	Valore	Fonte
Sitemap elencate in un indice	50.000 al massimo	sitemaps.org, Google
Dimensione del file	50 MB (52.428.800 byte) non compressi	sitemaps.org, Google
Compressione	gzip consentito	sitemaps.org
File indice per sito in Search Console	500	Google
Indice dentro un indice	non consentito	Google

Google dice che ogni requisito delle sitemap vale anche per i file indice, quindi il limite di 50 MB si misura dopo la decompressione.

Regole su annidamento e stesso host

Google non accetta un indice dentro un indice. L’assistenza del report Sitemap dice che un indice può elencare solo file sitemap, e il report mostra un errore di annidamento quando ne trova uno. Il protocollo non dice nulla in proposito, quindi alcuni generatori li annidano ancora. Appiattisci la struttura: fai puntare il file principale direttamente ai file che contengono gli URL. Con più di 50.000 sitemap, dividile in più file indice e inviali uno per uno.

Il protocollo dice anche che un indice può elencare solo sitemap dello stesso sito. Google aggiunge due dettagli:

• Le sitemap figlie devono trovarsi nella stessa directory dell’indice o più in basso nella gerarchia del sito.
• La regola dello stesso sito non si applica se configuri l’invio tra siti diversi, cioè se dimostri di controllare ogni host.

Quindi un indice su https://example.com/sitemap.xml non deve elencare https://cdn.example.net/products.xml né http://www.example.com/posts.xml. Entrambi contano come altri host. Per un URL a un livello superiore o su un altro dominio, il report indica «URL non consentito».

Inviarlo in Search Console e nel robots.txt

Nel report Sitemap, inserisci l’URL dell’indice e fai clic su «Invia». Questo solo invio copre tutte le sitemap figlie. Per un indice, dice la pagina di assistenza, «Pagine rilevate» conta tutti gli URL di tutte le sitemap figlie. Puoi anche inviare una sitemap figlia quando vuoi una riga e uno stato propri, ma non è obbligatorio.

• Per l’URL che invii, i reindirizzamenti non vengono seguiti. Invia l’indirizzo finale, quello che risponde con lo stato 200.
• Il report elenca solo le sitemap inviate lì o tramite l’API, quindi un file che Google ha trovato nel robots.txt non compare.

Nel robots.txt, aggiungi una riga con l’URL completo, in qualsiasi punto del file:

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

Il protocollo dice che, con un indice, puoi indicare solo la posizione di quel file. La riga fa parte del protocollo di sitemaps.org, quindi non è specifica di Google.

Errori comuni e le loro cause

La maggior parte dei problemi viene dalle sitemap figlie, non dal file indice.

• Sitemap figlia su un altro host. Un passaggio da http a https, o da www a un indirizzo senza www, lascia vecchi URL nell’indice. Ogni loc deve usare lo schema e l’host dell’indice.
• URL relativo. <loc>/post-sitemap.xml</loc> non è valido. Google segnala un URL incompleto.
• La sitemap figlia restituisce 404. Un plugin è stato disattivato, un tipo di contenuto è stato rimosso, oppure una cache serve un vecchio indice.
• La sitemap figlia restituisce HTML. Una pagina di accesso, una verifica di sicurezza o la pagina 404 del tema, inviata con lo stato 200. Il nostro articolo sullo stato Impossibile recuperare mostra come accorgersene con un test in tempo reale.
• Formato di lastmod sbagliato. 15/10/2026 non è W3C Datetime. Scrivi 2026-10-15, oppure 2026-10-15T14:30:00+00:00 con ora e fuso orario. Google segnala «Data non valida».
• Indice annidato. Elenca invece i file che contiene.

Come leggere ogni sitemap figlia

Aprire cinquanta file uno per uno è lento. Ecco tre modi per vederli tutti.

Controllare il file indice con il Sitemap Checker

Incolla l’indice nel Sitemap Checker gratuito, oppure apri il file .xml o .xml.gz. Lo strumento riconosce un indice ed elenca ogni sitemap figlia con il suo lastmod in una tabella «Sitemap». Segnala URL relativi o non http, date non valide, duplicati, sitemap figlie su più host, voci url o changefreq e priority inserite in un indice, e file con più di 50.000 voci o oltre 50 MB.

Controlla solo quel file. La pagina non si collega mai ad altri siti, quindi non apre le sitemap figlie e non può dire se una restituisce un 404 o HTML. Il suo verdetto ricorda di controllare anche ogni sitemap elencata.

Caricare tutte le sitemap figlie con XMLNest

L’estensione XMLNest per Chrome apre un indice online nella sua vista Lettura. Fai clic su «Carica tutte le sitemap figlie» e l’estensione le richiede una alla volta, con una riga di avanzamento e un pulsante «Annulla»:

• Vengono richieste solo le sitemap figlie dello stesso sito dell’indice (stesso schema, host e porta). Le altre mostrano «Saltata: su un altro sito, mai richiesta».
• Fino a 50 sitemap figlie, di 50 MB ciascuna al massimo; i file .gz vengono decompressi.
• I reindirizzamenti non vengono seguiti, e un indice annidato viene saltato.
• Ogni errore ne indica il motivo: lo stato HTTP, «l’XML non è ben formato» oppure «non è una sitemap» con il tag radice trovato, ed è così che si riconosce una pagina HTML.

Gli URL di tutte le sitemap figlie caricate finiscono in un’unica tabella, con una colonna per il file di origine. La scheda «Problemi» applica a ogni file le regole del Sitemap Checker ed elenca gli URL presenti in due sitemap figlie. Il nostro articolo su come estrarre gli URL da una sitemap descrive l’esportazione in CSV e JSON.

Espandere l’indice con Python

Questa funzione legge un indice, segue ogni sitemap figlia sullo stesso host, decomprime il gzip e stampa una sola volta ogni URL di pagina. Usa solo la libreria 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, qualunque sia il nome del file
        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)

Esegui python expand_index.py https://example.com/sitemap.xml > urls.txt. Il resoconto compare sullo schermo e gli URL finiscono nel file. L’abbiamo eseguito su un indice di prova locale con cinque voci. Ha letto due sitemap figlie, una delle quali compressa con gzip, e ha restituito i loro cinque URL di pagina. Ha saltato un indice annidato e una sitemap figlia su un altro host, e ha segnalato «HTTP Error 404» per un file mancante.

Lista di controllo prima dell’invio

• La radice è sitemapindex con lo spazio dei nomi di sitemaps.org, e ogni voce ha un loc completo.
• Al massimo 50.000 voci e 50 MB non compressi; nessun indice dentro un indice.
• Ogni sitemap figlia è sullo stesso host e usa lo stesso schema dell’indice, nella stessa directory o più in basso.
• Ogni sitemap figlia risponde 200 con XML, non con un reindirizzamento, un 404 o HTML.
• lastmod usa W3C Datetime e cambia quando cambia il file.
• Invia l’indice una sola volta in Search Console e aggiungi una riga Sitemap: al robots.txt.