Why doesn’t Search Console show all the data from your indexed sitemaps?

What’s the difference between a reporting problem and an indexing problem?

Let’s clearly distinguish the two levels: a indexing problem means that Googlebot cannot discover, crawl, or index your URLs. A reporting problem means that the indexing is functioning normally, but the Search Console interface does not correctly display the data.

Here, Mueller clarifies that if you are using a sitemap index (a parent file that groups several child sitemaps), Search Console may only show a partial view of the statistics. Your pages are indeed crawled and indexed — it’s just that you do not see the entire dashboard.

How does a sitemap index technically work?

A sitemap index is an XML file that lists other sitemap files. Typically, on a large site, you break down your URLs into several thematic or chronological sitemaps (products, blog, categories, etc.) and then reference them all in a sitemap_index.xml file.

Google crawls the sitemap index, discovers the child sitemaps, and then goes through each listed file. Technically, this works perfectly for crawling and indexing. The catch lies in the aggregation of metrics in the Search Console interface: the data from the child sitemaps does not always report correctly.

What is the concrete impact on data visibility?

You may observe situations where Search Console shows a significantly lower number of discovered or indexed URLs than reality, while your pages are indeed appearing in search results. You only see a part of the picture, as Mueller puts it.

This opacity complicates monitoring: it's difficult to quickly detect an indexing drop or errors on a specific segment if the metrics are fragmented or invisible. Hence the recommendation to submit each sitemap file individually to achieve granular reporting.

• Partial reporting: Search Console does not necessarily display aggregated statistics from the child sitemaps in a sitemap index.
• Indexing unaffected: your URLs are crawled and indexed despite this display issue.
• Proposed solution: submit each child sitemap separately in Search Console to visualize complete data.
• Impact monitoring: without granular visibility, detecting anomalies on a subset of URLs becomes more complex.
• Metric fragmentation: the data exists in Google's backend, but the interface does not aggregate it correctly.

Is this statement consistent with field observations?

Absolutely. For years, SEOs have noticed discrepancies in numbers between the number of URLs submitted via a sitemap index and those actually displayed in the Search Console report. Many initially suspected a crawl or indexing issue, when in fact it was simply an interface glitch.

Mueller confirms here what many had empirically deduced: Google does ingest the content, but the reporting layer does not follow suit. This aligns with past statements about recurring bugs in Search Console, especially concerning coverage metrics that fluctuate without apparent reason. [To be verified]: no public data specifies the exact frequency of these aggregation issues or the specific configurations that trigger them.

What nuances should be added to this recommendation?

Submitting each sitemap individually addresses the visibility issue, but it introduces an operational complexity. On a site with 20, 30, or even 100 sitemaps, manual management becomes unmanageable. You multiply checkpoints, which burdens tracking and increases the risk of human error (forgetting a file, duplication, desynchronization).

Moreover, this solution does not fix the root cause: the Search Console reporting glitch. You’re circumventing the symptom without Google having resolved the underlying issue. Some SEOs prefer to maintain a sitemap index for architectural cleanliness and rely on third-party tools (Screaming Frog, OnCrawl, Botify) for detailed monitoring.

In which cases does this rule not apply?

If your site has fewer than 50,000 URLs and a single sitemap suffices, you are not concerned. Similarly, if you have a robust monitoring infrastructure (server logs, third-party indexing tools, programmatically utilized Search Console API), the lack of reporting in the native interface becomes secondary.

Finally, if you manage a site in a headless CMS or with dynamically generated sitemaps via API, automating individual submissions is trivial. The issue is mostly problematic for sites in monolithic CMS (WordPress, Magento, Drupal) where manual management remains the norm and the fragmentation of sitemaps complicates the overall view.

What should you do if you are using a sitemap index?

First step: audit your current setup. List all the child sitemap files declared in your sitemap index, then check for each one if Search Console displays data. If some files are invisible or show zero discovered URLs despite containing hundreds of entries, you are affected.

Next, manually submit each child sitemap in Search Console. Wait a few days for Google to recrawl and aggregate the metrics. Compare the new data with your server logs to validate consistency. This operation may reveal hidden anomalies: 404 errors, misconfigured canonicals, unintentional noindex tags.

What mistakes to avoid when managing multiple sitemaps?

Never duplicate a URL in multiple child sitemaps submitted individually. This creates confusion for Google and can skew coverage metrics. Use clear segmentation: one sitemap per type of content, per language, or per update frequency.

Avoid also submitting a sitemap index AND its child files in parallel without consistency. If you are submitting the children individually, remove the sitemap index from Search Console to prevent duplicate reporting. Otherwise, you will end up with a mix of partial data that is difficult to interpret.

How to check that your setup is optimal?

Use the URL inspection tool in Search Console to test a representative sample of each child sitemap. Verify that Google correctly detects the parent sitemap and shows the last read date. Cross-reference this information with your server logs: Googlebot should regularly crawl each sitemap file submitted.

Then, compare the number of submitted URLs (the sum of all your sitemaps) with the number of indexed URLs in Search Console. A discrepancy greater than 20-30% warrants further investigation. Automate these checks via the Search Console API if you manage a large site — manual monitoring quickly becomes unmanageable.

• List all child sitemap files and check their visibility in Search Console
• Submit each child sitemap individually to obtain granular data
• Avoid URL duplication between multiple sitemaps submitted separately
• Remove the sitemap index if you submit children individually to avoid duplicate reporting
• Cross-reference Search Console data with server logs to validate consistency
• Automate monitoring via the Search Console API for large sites