Sitemap Index
A sitemap index is a sitemap of sitemaps — how large sites split past the 50,000-URL limit, how many URLs you can cover, and the splitting strategy that actually pays off.
1 evidence signal on this page
- Related live toolGoogle Index Checker
A sitemap index is a sitemap of sitemaps: a single file that lists your other sitemap files instead of listing URLs. You need one once a single sitemap would exceed 50,000 URLs or 50MB uncompressed, or when you want to organize a large multi-section/region site. An index can reference up to 50,000 child sitemaps, each holding up to 50,000 URLs — so one index covers 2.5 billion URLs, and the 500-index-per-site limit in Search Console puts the theoretical ceiling at 1.25 trillion. You'll never run out of capacity. Children live on the same site at the same directory level or lower, you don't nest an index inside an index, and you submit only the index. The real payoff is splitting by section or content type so you can read submitted-vs-indexed per segment in Search Console.
TL;DR — A sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. is a sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. of sitemaps. A single sitemap can only hold 50,000 URLs, so big sites split their URLs across several sitemaps and then list those sitemaps in one small “index” file. You submit just the index, and search engines follow it to all the rest.
What a sitemap index is
A normal XML sitemapAn XML sitemap is a UTF-8 file listing the canonical URLs on your site (with optional lastmod) so search engines can discover and prioritize them. It's a discovery and diagnostic aid, not a guarantee of indexing — and Google ignores its priority and changefreq tags. is a list of your page URLs. A sitemap indexA sitemap index is a sitemap of sitemaps — a single file that lists your other sitemap files instead of listing URLs directly. It's how large sites stay under the 50,000-URL / 50MB-per-sitemap limit while submitting just one file. is one level up: it’s a file that lists your other sitemaps instead of listing pages. Think of it as a table of contents that points at several chapters, where each chapter is a sitemap full of URLs.
You hand search engines the index, and they read it to find every sitemap it references, then read each of those to find your URLs. Evidence for this claim A sitemap index contains sitemap entries with a required loc value and an optional lastmod value. Scope: Sitemaps.org protocol structure for sitemap index files. Confidence: high · Verified: Sitemaps.org: Sitemap index XML tag definitions
Why you’d need one
A single sitemap has hard limits: it can hold at most 50,000 URLs, and the file can’t be bigger than 50MB uncompressed. The moment you have more URLs than that — or the file gets too big — you have to split it into multiple sitemaps. The sitemap index is what ties those pieces back together so you only submit one thing.
Evidence for this claim A sitemap index can list up to 50,000 sitemap files, and each sitemap is limited to 50,000 URLs or 50 MB uncompressed. Scope: Google-supported sitemap and sitemap-index limits. Confidence: high · Verified: Google Search Central: Manage sitemaps with a sitemap index fileYou don’t have to wait until you hit the limit, either. Plenty of large sites use an index just to keep things tidy — one sitemap for the blog, one for products, one per language — even when each part is well under 50,000 URLs.
How much can it cover?
A lot. An index can list up to 50,000 child sitemaps, and each of those can hold up to 50,000 URLs. Multiply that out and a single index already covers 2.5 billion URLs. Whatever size your site is, you will never run out of sitemap capacity.
How you use it
- Split your URLs across multiple sitemap files (most SEO plugins and frameworks do this for you automatically).
- Put a sitemap index file at the top that lists each of those sitemaps.
- Submit only the index in Google Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. and Bing Webmaster ToolsMicrosoft's free portal for monitoring and improving how a site appears in Bing search — the peer to Google Search Console, plus IndexNow instant indexing, richer backlink data, and keyword volumes. Because Bing's index also feeds Microsoft Copilot, it doubles as a window into AI-search visibility.. That one submission covers all the children.
Want the anatomy, the exact limits, the “don’t nest an index in an index” rule, and the splitting trick that turns your sitemaps into an indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. diagnostic? Switch to the Advanced tab.
TL;DR — A sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. is a sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. of sitemaps — a
<sitemapindex>file listing<sitemap>entries (<loc>+ optional<lastmod>) instead of URLs. You need one once a single sitemap would exceed 50,000 URLs or 50MB uncompressed, or to organize a large multi-section/region site. An index can reference up to 50,000 child sitemaps × 50,000 URLs each = 2.5 billion URLs per index; with up to 500 index files per site in Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results., the theoretical ceiling is 1.25 trillion — a number no real site approaches. Children stay on the same site at the same directory level or lower, you don’t nest an index inside an index (no tag for it, no tooling support), and you submit only the index. The payoff worth chasing: split by section/content type so you can read submitted-vs-indexed per segment.
What a sitemap index file actually is
A sitemap indexA sitemap index is a sitemap of sitemaps — a single file that lists your other sitemap files instead of listing URLs directly. It's how large sites stay under the 50,000-URL / 50MB-per-sitemap limit while submitting just one file. is a sitemap whose entries are other sitemaps. Where a regular
sitemap wraps <url> blocks in a <urlset>, an index wraps <sitemap> blocks in a
<sitemapindex>. Each <sitemap> has a <loc> pointing at one of your sitemap
files and, optionally, a <lastmod>. That’s the whole structure — it carries no
page URLs of its own. Evidence for this claim A sitemap index contains sitemap entries with a required loc value and an optional lastmod value. Scope: Sitemaps.org protocol structure for sitemap index files. Confidence: high · Verified: Sitemaps.org: Sitemap index XML tag definitions
It exists for one reason: the sitemaps format has hard size limits, and big sites blow past them. So you split your URLs across many sitemaps and use an index to present them to search engines as a single unit.
When you need one
Two triggers:
- You hit the size limits. A single sitemap maxes out at 50,000 URLs or 50MB uncompressed, whichever comes first. Google’s guidance is direct: “If you have a sitemap that exceeds the size limits, you’ll need to split up your large sitemap into multiple sitemaps.” Evidence for this claim A sitemap index can list up to 50,000 sitemap files, and each sitemap is limited to 50,000 URLs or 50 MB uncompressed. Scope: Google-supported sitemap and sitemap-index limits. Confidence: high · Verified: Google Search Central: Manage sitemaps with a sitemap index file Once you’ve split, an index ties the pieces together.
- You want to organize a large site — even under the limit. Multi-section sites (blog vs. products vs. category pages) and multi-region/multi-language sites are far easier to manage and monitor as separate sitemaps under one index. That organizational use is, in my view, the better reason to reach for an index, and I come back to it in the Frameworks tab.
Anatomy
The index is small and dull by design — <sitemapindex>, then a <sitemap> block
per child, each with a <loc> and an optional <lastmod>:
<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<sitemap>
<loc>https://www.example.com/sitemap1.xml.gz</loc>
<lastmod>2024-08-15</lastmod>
</sitemap>
<sitemap>
<loc>https://www.example.com/sitemap2.xml.gz</loc>
<lastmod>2024-08-15</lastmod>
</sitemap>
</sitemapindex>Notes that matter:
- The namespace is the same
sitemaps.org/schemas/sitemap/0.9you use on a regular sitemap; the file is UTF-8 and<loc>values are fully-qualified absolute URLs. - Children can be gzipped —
.xml.gzis fine, and the 50MB cap is measured on the uncompressed size. - The optional
<lastmod>here describes when that child sitemap last changed, not when individual pages changed.
How many can you submit — and how many pages is that?
This is where people lowball the ceiling. Stack the limits up:
- Google Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. accepts up to 500 sitemap index files per site: “You can submit up to 500 sitemap index files for each site in your Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. account.”
- Each index can list up to 50,000 child sitemaps.
- Each child sitemap can hold up to 50,000 URLs.
Do the multiplication and the theoretical ceiling is 500 × 50,000 × 50,000 = 1.25 trillion URLs (1,250,000,000,000). Treat that as a ceiling no real site approaches, not a target — the takeaway is simply that you will never run out of sitemap capacity. And you rarely need to get fancy with multiple index files at all: a single sitemap index, without submitting any others, already covers 50,000 × 50,000 = 2.5 billion URLs. If you’ve got 2.5 billion indexable URLs, your sitemap setup is not your problem.
Location rules
The child sitemaps an index references have to live on the same site as the index,
and at the same directory level or lower than the index file. An index at
https://www.example.com/sitemap-index.xml can point at
https://www.example.com/sitemaps/products.xml, but not at a sitemap on a different
host or sitting above its own path. Break this and Search Console flags the children
as “URL not allowed.” (Cross-domain references are only valid when both domains are
verified in Search Console — but for an ordinary single-site index you don’t go
there.)
Don’t nest an index inside an index
A sitemap index lists sitemaps, not other indexes. Neither sitemaps.org’s live
protocol page nor Google’s sitemap-index documentation states this in so many
words today — I checked both directly rather than trust an older paraphrase. What
the protocol does say is narrower: the <loc> tag inside a <sitemapindex> is
defined as identifying “a Sitemap, an AtomAn RSS or Atom feed is an XML file listing a site's most recently published or updated URLs. Search engines accept it as a sitemap-style discovery signal for fresh content — not a replacement for a full XML sitemap. file, RSS file or a simple text
file” — an index file isn’t on that list, and the format has no tag for nesting
one index under another. Every sitemap generator, plugin, and search engine I’m
aware of treats index-of-indexes as unsupported on that basis; it’s a strong
practitioner convention grounded in the format’s structure rather than a single
quotable sentence from either doc. Treat it as a hard rule: one level of indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed.
only. If you find yourself wanting an index-of-indexes, you almost certainly have
room to reorganize within the 2.5-billion-URL ceiling a single index already gives
you.
Check the index structure and child locations before submission with the XML Sitemap Validator Free
- Paste the sitemap index XML or fetch its deployed URL.
- Fix nested indexes and child entries that violate host or directory rules.
- Validate again, then submit the one clean index and monitor child fetch status in Search Console.
The completed XML Sitemap Validator result reports that a sitemap index contains another sitemap index and recommends referencing URL sitemaps directly instead.
Submit only the index
You submit the index file, and that single submission pulls in every child sitemap it references — you don’t need to submit the children one by one. John Mueller put it plainly: “You can submit the individual ones, but you don’t really need to.” Submitting both the index and its children isn’t harmful, just redundant. One clean submission of the index is the move.
That said, submitting a sitemap — index or not — is a discovery aid, not an indexing guarantee. The index helps engines find your sitemaps; it doesn’t promise the URLs inside them get crawled or indexed.
Splitting strategy — for reporting, not crawl efficiency
Here’s the part that’s underplayed everywhere else. How you split your sitemaps across an index does not change how Google crawls or indexes your pages. The reason to split thoughtfully is monitoring. Mueller’s framing is the one I lean on: “I generally recommend splitting a sitemap file into logical parts of your site so that you can monitor those parts individually (eg, category pages vs detail pages…). … It doesn’t change how Google crawls & indexes them, it’s really just so that you can track them better on your side.”
The practical payoff: the Search Console Sitemaps reportThe Google Search Console report where you submit sitemaps and watch how Google processes them — type, last read date, status, and how many URLs were discovered. It confirms Google read your list; it doesn't prove anything got indexed. shows submitted-vs-indexed counts per sitemap. Split your index by section or content type — blog, products, categories, docs, per region — and you can see which segment is under-indexed instead of staring at one site-wide number. That’s a diagnostic I use constantly. (It’s the same reason I’ll keep a sitemap of old URLs around during a migration: so I can watch that specific set drop out of the index in GSC.)
So split by what you want to measure, not by some imagined crawl benefit. The crawl benefit isn’t there; the reporting benefit is real.
How it relates to the rest of the sitemap family
A sitemap index sits on top of your regular XML sitemapsAn XML sitemap is a UTF-8 file listing the canonical URLs on your site (with optional lastmod) so search engines can discover and prioritize them. It's a discovery and diagnostic aid, not a guarantee of indexing — and Google ignores its priority and changefreq tags., and the broader sitemaps overview is the place to start if you’re new to the whole topic. Your image and video sitemaps are just more child files an index can reference, and the whole apparatus is part of how search engines handle discovery. None of those need linking out from here — they’re siblings in the same cluster.
AI summary
A condensed take on the Advanced version:
- A sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. is a sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. of sitemaps — a
<sitemapindex>file listing<sitemap>entries (<loc>+ optional<lastmod>), not page URLs. - You need one when a single sitemap would exceed 50,000 URLs or 50MB uncompressed, or when you want to organize a large multi-section/region site (the organizational use is the better reason).
- Capacity is effectively unlimited: up to 50,000 child sitemaps per index × 50,000 URLs each = 2.5 billion URLs per index. With up to 500 index files per site in Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results., the theoretical ceiling is 1.25 trillion URLs — a number no real site approaches.
- Rules: children live on the same site, at the same directory level or
lower; don’t nest an index inside an index (the format has no tag for it,
and no generator or search engine supports it); children may be gzipped
(
.xml.gz). - Submit only the index — one submission covers all children. Submitting the children too is redundant, not harmful (Mueller: “you don’t really need to”).
- Splitting is for reporting, not crawl efficiency. It doesn’t change crawlingCrawling is how search engines use automated bots (like Googlebot and Bingbot) to discover URLs and download pages. A page has to be crawlable to be indexed, but crawling on its own isn't a ranking factor. or indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed.; split by section/content type so you can read submitted-vs-indexed per segment in the Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. Sitemaps reportThe Google Search Console report where you submit sitemaps and watch how Google processes them — type, last read date, status, and how many URLs were discovered. It confirms Google read your list; it doesn't prove anything got indexed..
Official documentation
Primary-source documentation on sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. files and the limits behind them.
- Manage large sitemaps with a sitemap index file — splitting past the limits, the sitemap indexA sitemap index is a sitemap of sitemaps — a single file that lists your other sitemap files instead of listing URLs directly. It's how large sites stay under the 50,000-URL / 50MB-per-sitemap limit while submitting just one file. format, and the 500-index-files-per-site cap.
- Build and submit a sitemap — the 50,000-URL / 50MB-uncompressed limit, UTF-8, and absolute-URL rules that apply to every sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing..
- Sitemaps overview — what a sitemap is and the “discovery, not a guarantee of indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed.” framing.
sitemaps.org
- Sitemaps XML protocol — the canonical spec: the
<sitemapindex>format, the 50,000-sitemaps / 50MB index limit, and the “an index file can not list other index files” rule.
Quotes from the source
On-the-record statements from Google and the sitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing..org protocol. Each link is a deep link that jumps to the quoted passage on the source page.
Google — splitting and submission limits
- “If you have a sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. that exceeds the size limits, you’ll need to split up your large sitemap into multiple sitemaps.” — Google, Manage large sitemaps. Jump to quote
- “You can submit up to 500 sitemap indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. files for each site in your Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. account.” Jump to quote
sitemaps.org — the protocol size limits (see the footnote below for the no-nesting rule’s sourcing, which isn’t a standalone quote)
- “Sitemap indexA sitemap index is a sitemap of sitemaps — a single file that lists your other sitemap files instead of listing URLs directly. It's how large sites stay under the 50,000-URL / 50MB-per-sitemap limit while submitting just one file. files may not list more than 50,000 Sitemaps and must be no larger than 50MB (52,428,800 bytes) and can be compressed.” — sitemaps.org protocol. Jump to quote
John Mueller, Google — splitting for monitoring, and submitting only the index
- “I generally recommend splitting a sitemap file into logical parts of your site so that you can monitor those parts individually (eg, category pages vs detail pages…). … It doesn’t change how Google crawls & indexes them, it’s really just so that you can track them better on your side.” Jump to quote
- “You can submit the individual ones, but you don’t really need to.” Jump to quote
<loc> definition (a sitemap index’s <loc> may point to “a Sitemap, an AtomAn RSS or Atom feed is an XML file listing a site's most recently published or updated URLs. Search engines accept it as a sitemap-style discovery signal for fresh content — not a replacement for a full XML sitemap. file, RSS file or a simple text file,” not another index) plus universal tooling practice, not a single citable line. Sitemap index — limits cheat sheet
The numbers that define your capacity
| Limit | Value |
|---|---|
| URLs per single sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. | 50,000 (or 50MB uncompressed, whichever first) |
| Size per single sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. | 50MB uncompressed (gzipCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits. allowed) |
| Child sitemaps per indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. file | up to 50,000 |
| Sitemap indexA sitemap index is a sitemap of sitemaps — a single file that lists your other sitemap files instead of listing URLs directly. It's how large sites stay under the 50,000-URL / 50MB-per-sitemap limit while submitting just one file. files per site (in GSCA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results.) | up to 500 |
| URLs a single index covers | 50,000 × 50,000 = 2.5 billion |
| Theoretical ceiling per site | 500 × 50,000 × 50,000 = 1.25 trillion (theoretical — no real site approaches it) |
Fast facts
- A sitemap index lists sitemaps, not URLs —
<sitemapindex>wrapping<sitemap>blocks (<loc>+ optional<lastmod>). - You need one once a single sitemap would exceed 50,000 URLs or 50MB, or to organize a large multi-section/region site.
- Children must be on the same site, at the same directory level or lower than the index.
- Children can be gzipped (
.xml.gz). - Don’t nest an index inside an index (no tag for it, not supported by any generator or engine).
- Submit only the index — it covers all children; submitting children too is redundant.
- Split by section/content type for reporting, not for crawl efficiency — it doesn’t change crawlingCrawling is how search engines use automated bots (like Googlebot and Bingbot) to discover URLs and download pages. A page has to be crawlable to be indexed, but crawling on its own isn't a ranking factor./indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed..
How to split a sitemap index (split for what you measure)
The mental model that matters here: how you split doesn’t change crawlingCrawling is how search engines use automated bots (like Googlebot and Bingbot) to discover URLs and download pages. A page has to be crawlable to be indexed, but crawling on its own isn't a ranking factor. — it changes what you can monitor. Google crawls and indexes the same URLs whether they sit in one sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. or fifty. So choose your split lines to match the segments you want to read independently in the Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. Sitemaps reportThe Google Search Console report where you submit sitemaps and watch how Google processes them — type, last read date, status, and how many URLs were discovered. It confirms Google read your list; it doesn't prove anything got indexed. (submitted vs. indexedStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed., per sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing.).
Split by content type
/sitemaps/blog.xml,/sitemaps/products.xml,/sitemaps/categories.xml,/sitemaps/docs.xml.- Best when different templates have different indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. behavior — e.g. thin product variants under-indexing while your blog sails through. You’ll see exactly which template is the problem.
Split by section
- One child sitemap per major site section or subfolder.
- Best for large sites where teams own different sections — each owner gets a clean coverage number for their area.
Split by region / language
- One child per locale (
/sitemaps/en.xml,/sitemaps/de.xml, …). - Best for international sites: you can spot a whole locale that isn’t getting picked up, separate from any hreflangHreflang is an annotation (in HTML, HTTP headers, or XML sitemaps) that tells search engines which language and optional region a page targets, and which alternate versions exist. It only works when every page in the cluster references all the others. issues.
The decision rule
- Ask: “If one of these segments were under-indexed, would I want to see it in isolation?” If yes, that’s a split line. If the answer is “I’d never analyze that separately,” don’t split there — you’re just making more files to maintain.
A migration use I rely on
- During a site migrationA site migration is any significant change to a website's URL structure, domain, platform, protocol, or hosting that can affect how search engines crawl, index, and rank it. The risk scales with how much you change at once. I’ll keep a sitemap of the old URLs in the index for a while — not to get them indexed, but to watch them drop out of the index in GSC as the new URLs take over. The segment-level reporting is the whole point.
The crawl-efficiency angle people expect from splitting isn’t real. The reporting angle is, and it’s worth designing your index around.
A minimal valid sitemap index
This is the entire shape of a sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. file — a <sitemapindex> root, then one
<sitemap> block per child sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing., each with a <loc> and an optional <lastmod>.
Children may be gzipped (.xml.gz); the 50MB cap is measured uncompressed.
<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<sitemap>
<loc>https://www.example.com/sitemaps/blog.xml.gz</loc>
<lastmod>2026-06-22</lastmod>
</sitemap>
<sitemap>
<loc>https://www.example.com/sitemaps/products.xml.gz</loc>
<lastmod>2026-06-22</lastmod>
</sitemap>
<sitemap>
<loc>https://www.example.com/sitemaps/categories.xml.gz</loc>
<lastmod>2026-06-22</lastmod>
</sitemap>
</sitemapindex>Rules baked into that example:
- Root is
<sitemapindex>(not<urlset>) on thesitemaps.org/schemas/sitemap/0.9namespace; the file is UTF-8. - Each
<loc>is a fully-qualified absolute URL on the same site, at the same directory level or lower than this index. <lastmod>is optional and describes when that child sitemap changed.- Don’t add a
<sitemap>entry pointing at another sitemap indexA sitemap index is a sitemap of sitemaps — a single file that lists your other sitemap files instead of listing URLs directly. It's how large sites stay under the 50,000-URL / 50MB-per-sitemap limit while submitting just one file. — one level only.
How you submit it
You submit only this index file — one submission, and search engines follow it to every child sitemap. There’s no need to submit the children separately.
# robots.txt — point engines at the index (the Sitemap: line takes the index URL)
Sitemap: https://www.example.com/sitemap-index.xmlThen add the same index URL in Google Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. (Sitemaps reportThe Google Search Console report where you submit sitemaps and watch how Google processes them — type, last read date, status, and how many URLs were discovered. It confirms Google read your list; it doesn't prove anything got indexed.) and Bing Webmaster ToolsMicrosoft's free portal for monitoring and improving how a site appears in Bing search — the peer to Google Search Console, plus IndexNow instant indexing, richer backlink data, and keyword volumes. Because Bing's index also feeds Microsoft Copilot, it doubles as a window into AI-search visibility.. That’s it — the children come along for the ride.
Patrick's relevant free tools
- XML Sitemap Validator — Paste, upload, or fetch a sitemap by URL — errors, warnings, and a health score with line numbers. Pasted and uploaded sitemaps are validated entirely in your browser.
- XML Sitemap Generator — Generate an XML sitemap from a capped, robots-respecting same-site crawl. Noindex, off-canonical, failed, and uncertain URLs remain visibly separate; lastmod dates are emitted only when the page provides evidence.
Tools for building and checking a sitemap index
- Google Index Checker — once you’ve submitted the indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed., use this to spot-check whether specific URLs from a child sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. actually made it into Google’s index, rather than waiting on the aggregate Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. number.
- Google Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. — Sitemaps reportThe Google Search Console report where you submit sitemaps and watch how Google processes them — type, last read date, status, and how many URLs were discovered. It confirms Google read your list; it doesn't prove anything got indexed. — the primary place to watch a submitted index: fetch status per child sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing., and submitted-vs-indexed counts you can read per segment if you split thoughtfully.
- Bing Webmaster ToolsMicrosoft's free portal for monitoring and improving how a site appears in Bing search — the peer to Google Search Console, plus IndexNow instant indexing, richer backlink data, and keyword volumes. Because Bing's index also feeds Microsoft Copilot, it doubles as a window into AI-search visibility. — Sitemaps — the equivalent report for Bing; submit the same index URL there too.
- Your sitemap generator / CMSA content management system (CMS) is software that lets users create, manage, and publish digital content — like blog posts and pages — without writing raw code. WordPress, Drupal, and Joomla are the most common open-source CMS platforms. plugin — most frameworks and SEO plugins build the index and child files for you automatically as your URL count grows; the manual XML in the Scripts tab is for when you need to see (or hand-build) the shape yourself.
Sitemap index pre-submission checklist
Run through this before you point Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. or Bing Webmaster ToolsMicrosoft's free portal for monitoring and improving how a site appears in Bing search — the peer to Google Search Console, plus IndexNow instant indexing, richer backlink data, and keyword volumes. Because Bing's index also feeds Microsoft Copilot, it doubles as a window into AI-search visibility. at a new or restructured indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed.:
- Every child sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. is under 50,000 URLs and 50MB uncompressed (with headroom — don’t build right up to the ceiling).
- The index file lists only sitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing., never another sitemap indexA sitemap index is a sitemap of sitemaps — a single file that lists your other sitemap files instead of listing URLs directly. It's how large sites stay under the 50,000-URL / 50MB-per-sitemap limit while submitting just one file..
- Every child
<loc>lives on the same site, at the same directory level or lower than the index file. - Index and children are valid XML, UTF-8, with the correct root element
(
<sitemapindex>for the index,<urlset>for each child). -
robots.txthas aSitemap:line pointing at the index, not at one of the children. - Your split lines (section, content type, or region) match something you’ll actually want to monitor separately in Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. — don’t split arbitrarily.
- Only the index is queued for submission — you don’t also need to submit every child sitemap one by one.
Mistakes to avoid with a sitemap index
- Nesting an indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. inside an index. The format has no tag for it — a
sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. index’s
<loc>only identifies a sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing., AtomAn RSS or Atom feed is an XML file listing a site's most recently published or updated URLs. Search engines accept it as a sitemap-style discovery signal for fresh content — not a replacement for a full XML sitemap., RSS, or text file, never another index — and no generator or search engine supports it. Do instead: keep one level of indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed., and if you’re tempted to go deeper you almost certainly have room to reorganize your split within the 2.5-billion-URL ceiling a single index already gives you. - Submitting every child sitemap individually on top of the index. Not harmful, just redundant — the index submission already pulls in every child it references. Do instead: submit the index alone in Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. and Bing Webmaster ToolsMicrosoft's free portal for monitoring and improving how a site appears in Bing search — the peer to Google Search Console, plus IndexNow instant indexing, richer backlink data, and keyword volumes. Because Bing's index also feeds Microsoft Copilot, it doubles as a window into AI-search visibility..
- Splitting sitemaps expecting a crawl-budget or ranking win. How you split doesn’t change how Google crawls or indexes your pages. Do instead: split purely for reporting — pick lines you actually want to monitor independently in the Sitemaps reportThe Google Search Console report where you submit sitemaps and watch how Google processes them — type, last read date, status, and how many URLs were discovered. It confirms Google read your list; it doesn't prove anything got indexed..
- Pointing a child sitemap at a different host, subdomain, or a directory above the index. Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. flags this as “URL not allowed.” Do instead: keep every child on the same site, at the index’s directory level or lower.
- Letting a sitemap grow past 50,000 URLs or 50MB uncompressed instead of splitting ahead of time. Do instead: split proactively once a section is approaching the limit, not after it’s already broken.
Common issues with a sitemap index
Symptom: Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. shows “Couldn’t fetch” on the indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed..
Likely cause: the index URL 404s, times out, or is blocked by robots.txt.
Fix: open the exact index URL in a browser (or the Sitemap
Validator) and confirm it returns 200 with valid
XML before resubmitting.
Symptom: The index fetches fine, but one specific child sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. shows an
error.
Likely cause: a <loc> inside that child points at a 404’d, non-canonical, or
wrong-domain URL, or the child itself has malformed XML.
Fix: open that child sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. directly and spot-check its <loc> entries; fix
or regenerate that file, then wait for the next fetch.
Symptom: “Sitemap indexA sitemap index is a sitemap of sitemaps — a single file that lists your other sitemap files instead of listing URLs directly. It's how large sites stay under the 50,000-URL / 50MB-per-sitemap limit while submitting just one file. file can’t reference another sitemap index” (or the
entry is silently ignored).
Likely cause: you nested an index inside an index, which no generator or
search engine supports — the format’s <loc> tag has no provision for
pointing at another index file.
Fix: flatten to one level — the top-level index should only ever point at
sitemaps that list URLs, not at other indexes.
Symptom: “URL not allowed” on a child sitemap entry. Likely cause: that child lives on a different host/subdomain than the index, or sits above the index’s own directory path. Fix: move the child to the same site, at the same directory level or lower (cross-domain references only work when both domains are verified in Search Console — and for an ordinary single-site index you shouldn’t need that).
Symptom: An index or child sitemap gets rejected for size. Likely cause: it exceeds 50,000 URLs, or 50MB uncompressed for a sitemap / 50MB for the index file itself. Fix: split further — add another child sitemap (or, for a very large site, another index) rather than trying to squeeze more in.
Prove the new sitemap index actually took
Test: Load the indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. URL directly (browser or curl -I).
Expected result: HTTP 200HTTP 200 OK is the standard 2xx success status code, meaning the server received, understood, and fulfilled the request and is returning the resource. It's the code every page you want indexed should return — but a 200 alone doesn't guarantee Google will index the page., valid XML, <sitemapindex> root.
Failure interpretation: a 404/timeout here means Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. can’t reach it
either — fix this before anything else.
Monitoring window: immediate.
Rollback trigger: sustained non-200 response — revert to the prior sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing.
setup.
Test: Submit the index in the Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. Sitemaps reportThe Google Search Console report where you submit sitemaps and watch how Google processes them — type, last read date, status, and how many URLs were discovered. It confirms Google read your list; it doesn't prove anything got indexed. (or run it through the Sitemap Validator first). Expected result: status flips to a successful fetch and per-child sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. rows appear. Failure interpretation: “Couldn’t fetch” means a URL, hosting, or robots.txtA plain-text file at the root of a host that tells crawlers which URLs they may and may not request. It controls crawling, not indexing — a blocked URL can still be indexed if it's linked from elsewhere. problem, not an indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. problem yet. Monitoring window: hours to a day for the first fetch. Rollback trigger: repeated fetch failures across resubmissions.
Test: Spot-check each child sitemap’s URL count against what your site actually has for that segment. Expected result: counts are in the right ballpark for that section/content type. Failure interpretation: a big mismatch usually means the generator is including stale, non-canonical, or duplicate URLs. Monitoring window: immediate, right after generation. Rollback trigger: none — fix the generator logic and regenerate.
Test: Check submitted-vs-indexed counts per sitemap in the Sitemaps reportThe Google Search Console report where you submit sitemaps and watch how Google processes them — type, last read date, status, and how many URLs were discovered. It confirms Google read your list; it doesn't prove anything got indexed.. Expected result: indexed count trends toward the submitted count for each segment over time. Failure interpretation: one segment stuck well below its submitted count points at a problem specific to that segment (thin contentThin content is web content that provides little or no value to users. Google's spam policies name it 'thin content with little or no added value' — and it's about value per page, not word count., duplication, noindexNoindex is a directive that tells search engines to keep a page out of their index, so it won't appear in search results. It works only on pages a crawler can actually fetch — a page blocked in robots.txt can never be noindexed. left on by mistake) rather than the index itself. Monitoring window: 2–4 weeks for the trend to be meaningful. Rollback trigger: a segment’s indexed count actively falling after the change, not just staying flat.
Test: Confirm robots.txt still carries the correct Sitemap: line.
Expected result: the line resolves to the current index URL.
Failure interpretation: a missing or stale line doesn’t break discovery for
engines that already know your index, but it removes one of your discovery
signals for anything crawlingCrawling is how search engines use automated bots (like Googlebot and Bingbot) to discover URLs and download pages. A page has to be crawlable to be indexed, but crawling on its own isn't a ranking factor. fresh.
Monitoring window: immediate.
Rollback trigger: line missing or pointing at a retired file — restore it.
Standing KPIs for a sitemap index
Metric: Submitted vs. indexedStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. count, per sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. segment. What it tells you: which section, content type, or region is under-indexed, instead of one blended site-wide number. How to pull it: the Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. SitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. report, read per submitted sitemap. Benchmark / realistic range: no fixed target — there’s no honest universal number here. Healthy looks like the indexed count trending close to the submitted count for that segment; a persistent, large gap on one segment (and not the others) is the signal worth chasing, not a specific percentage. Cadence: weekly during a migration or a large rollout; monthly otherwise.
Metric: Sitemap fetch status, per index and per child. What it tells you: whether engines can actually read the files you’ve submitted at all — a precondition for everything else on this list. How to pull it: the status column in the Sitemaps reportThe Google Search Console report where you submit sitemaps and watch how Google processes them — type, last read date, status, and how many URLs were discovered. It confirms Google read your list; it doesn't prove anything got indexed. (or the Sitemap Validator for an on-demand check). Benchmark / realistic range: this one isn’t a range — “Success” is the only acceptable state; “Couldn’t fetch” or “Has errors” is a fail state to fix immediately, not something to tolerate at some rate. Cadence: check whenever you touch the sitemap generation code or add a new child; otherwise a monthly spot check.
Metric: URL count and file size per sitemap, against the limits. What it tells you: how much headroom you have before a segment needs splitting further. How to pull it: your sitemap generator’s own counts, or the Sitemap Validator. Benchmark / realistic range: stay comfortably under 50,000 URLs and 50MB uncompressed per file — leave real headroom rather than running up to the ceiling. Cadence: monitor as your URL count grows; re-split a segment once it’s approaching the limit, not after it’s already broken.
AI prompts for a sitemap index
Prompt: sanity-check a proposed split. Paste in a short description of your site’s sections (roughly how many URLs each has) and ask an AI to sanity-check your split lines before you build the indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed.:
I'm building a sitemap index for a site with these sections and approximate
URL counts:
- Blog: <N> URLs
- Product pages: <N> URLs
- Category pages: <N> URLs
- <other sections>
I want to split these into child sitemaps under one sitemap index so I can
read submitted-vs-indexed coverage per section in Google Search Console.
Given these counts, suggest a sensible way to split them into child
sitemaps (staying well under 50,000 URLs and 50MB uncompressed per file),
and flag any section that's small enough it probably doesn't need its own
child sitemap.Expect back: a proposed grouping of your sections into child sitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing., with a note on any section too small to bother separating.
Prompt: review an existing sitemap indexA sitemap index is a sitemap of sitemaps — a single file that lists your other sitemap files instead of listing URLs directly. It's how large sites stay under the 50,000-URL / 50MB-per-sitemap limit while submitting just one file. for structural mistakes. Paste in the raw XML of your sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. index (or a representative excerpt) and ask for a structural review:
Here is my sitemap index XML:
<paste your <sitemapindex> XML here>
Check it against these rules and flag any violation:
1. The root element is <sitemapindex>, not <urlset>.
2. No <sitemap> entry points at another sitemap index file.
3. Every <loc> is a fully-qualified, absolute URL on the same site as this
index.
4. No <loc> sits at a directory level above this index's own path.
List any entries that break these rules and explain which rule each one
breaks.Expect back: a line-by-line list of any entries that violate the nesting or location rules, so you can fix them before resubmitting.
Resources worth your time
My related writing
- When Should You Worry About Crawl Budget? — where clean, complete sitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. fit into crawl efficiency on large sites.
- Website Migration: The Pre- and Post-Launch Checklist — including keeping a sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. of old URLs around to watch them drop out of the indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. in GSCA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results..
- Enterprise Technical SEO — automation-first sitemaps and the submitted-vs-indexed diagnostic at scale.
- The Beginner’s Guide to Technical SEO — where sitemaps and discovery sit in the bigger picture.
Official
- Google — Manage large sitemaps with a sitemap index file.
- sitemaps.org protocol — the canonical
<sitemapindex>spec and limits.
From others
- r/TechSEO — the community for sitemap, crawl, and indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. debugging.
- Bing Webmaster Tools — Submit a sitemap — Bing’s guidance on submitting sitemap indexA sitemap index is a sitemap of sitemaps — a single file that lists your other sitemap files instead of listing URLs directly. It's how large sites stay under the 50,000-URL / 50MB-per-sitemap limit while submitting just one file. files and verifying them in Bing Webmaster ToolsMicrosoft's free portal for monitoring and improving how a site appears in Bing search — the peer to Google Search Console, plus IndexNow instant indexing, richer backlink data, and keyword volumes. Because Bing's index also feeds Microsoft Copilot, it doubles as a window into AI-search visibility..
- Search Engine Journal — Sitemaps coverage — includes verbatim coverage of Mueller sitemap Q&As and crawl/indexing write-ups.
- Onely — Sitemap resources — technical SEOTechnical SEO is the practice of making a site easy for search engines to crawl, render, index, and (now) be eligible for AI answers. It's the foundation that lets your content and links rank — not a ranking trick of its own. deep-dives from a crawlingCrawling is how search engines use automated bots (like Googlebot and Bingbot) to discover URLs and download pages. A page has to be crawlable to be indexed, but crawling on its own isn't a ranking factor.-focused agency; covers large-scale sitemap issues and indexation diagnostics.
Test yourself: Sitemap index
Five quick questions on what a sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. is and how to use one. Pick an answer for each, then check.
Sitemap index
A sitemap index is a sitemap of sitemaps — a single file that lists your other sitemap files instead of listing URLs directly. It's how large sites stay under the 50,000-URL / 50MB-per-sitemap limit while submitting just one file.
Related: Sitemap, XML sitemap
Sitemap index
A sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. file is a sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. of sitemaps. Instead of listing page URLs, it lists other sitemap files — each in a <sitemap> block with a <loc> and an optional <lastmod>, all wrapped in a <sitemapindex> root element. You reach for one when a single sitemap would blow past the format’s hard limits (50,000 URLs or 50MB uncompressed, whichever comes first) or when you simply want to organize a large multi-section or multi-region site into separate files.
The capacity is enormous. A sitemap index can reference up to 50,000 child sitemaps, and each child can hold up to 50,000 URLs — so one index already covers 2.5 billion URLs. Google Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. accepts up to 500 sitemap index files per site, which puts the theoretical ceiling at 1.25 trillion URLs. No real site approaches that; the practical takeaway is that you will never run out of sitemap capacity.
A few rules matter. The child sitemaps must live on the same site as the index and at the same directory level or lower. You don’t nest a sitemap index inside another sitemap index — the sitemaps.org protocol disallows it. And you submit only the index file: that one request pulls in every child sitemap it references, so there’s no need to submit the children separately.
Related: Sitemap, XML sitemap
Build-time retrieval analysis plus live signals for this exact article. The automatic chunk report includes a deterministic readiness score and is ready without a model download.
Search Console
sampleGA4 traffic (28d)
sampleCloudflare traffic (7d)
sampledCrUX field data (28d, phone)
sampleGoogle NLP entities
localChangelog
Updated Jul 18, 2026.
Editorial summary and recorded change details.Summary
Corrected an over-attributed source claim: the 'don't nest an index inside an index' rule was presented as a verbatim sitemaps.org quote, but a live re-check of both sitemaps.org's protocol page and Google's sitemap-index docs found no such sentence on either. Reworded every instance (Advanced, Quotes, cheat sheet, AI summary, anti-patterns, troubleshooting, quiz) to source the rule honestly from the protocol's <loc> tag definition and universal tooling practice instead.
Change details
-
Reworded the Advanced-lens nesting section and the Quotes-lens footnote to stop presenting the no-nesting rule as a direct sitemaps.org quote, and instead cite the protocol's <loc> tag definition plus practitioner/tooling convention.
-
Updated the matching quiz answer explanation, cheat sheet line, AI summary line, anti-patterns bullet, and troubleshooting entry to match the corrected sourcing.
Full comparison unavailable — no prior snapshot was archived for this revision.