Check your sitemap is
actually valid.

How to validate your XML sitemap

Validating takes less than a minute. You only need the sitemap's public URL, which is usually yoursite.com/sitemap.xml, or the address listed on the Sitemap: line of your robots.txt file. If you don't know it, the free sitemap finder looks in robots.txt and the common locations for you.

1. 1Find your sitemap URL (try /sitemap.xml, /sitemap_index.xml or the Sitemap: line in /robots.txt)
2. 2Paste it into the validator above. A bare domain works too: we try /sitemap.xml
3. 3Read the score, then work through the errors first and the warnings second
4. 4Fix the file, or the setting in your CMS or SEO plugin that generates it
5. 5Run the validator again until the errors are gone
6. 6If it's a sitemap index, validate each child sitemap it lists as well

What makes a sitemap valid

A valid sitemap is well-formed XML with a <urlset> root (or <sitemapindex> for an index), the sitemaps.org 0.9 namespace declared, and at least one <loc> entry. Every <loc> must be a complete absolute URL including the protocol, not a relative path.

Optional tags have rules too: <lastmod> must be a W3C date, <priority> a number from 0.0 to 1.0, and <changefreq> one of seven specific values. Get these wrong and parsers may skip the entry or the file.

Google adds two more rules of its own: the file must be UTF-8 encoded, and every value must be entity escaped, so a URL containing & has to be written as &amp;.

Example of a valid XML sitemap

This is the smallest sitemap that passes every check. The XML declaration and the namespace sit at the top, each page gets its own <url> block, and <lastmod> uses the YYYY-MM-DD format.

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://www.example.com/</loc>
    <lastmod>2026-10-20</lastmod>
  </url>
  <url>
    <loc>https://www.example.com/pricing</loc>
    <lastmod>2026-09-02</lastmod>
  </url>
</urlset>

Every check in your report, explained

The report starts with a 0 to 100 score. Each error takes 30 points off and each warning takes 8, so one error outweighs three warnings. Below the score, every check is listed as an error, a warning or a pass.

Sitemap could not be fetched (error)

The URL returned an error status, timed out after 15 seconds, or couldn't be reached. If a search engine can't download the file, nothing else in it matters.

Root element (error if missing)

The file must open with <urlset> or <sitemapindex>. If neither is there, it isn't a sitemap. This is often an HTML page, such as a 404 page or a login screen, served at the sitemap's address.

XML namespace (warning)

The root element should declare xmlns="http://www.sitemaps.org/schemas/sitemap/0.9". Some parsers are strict about it.

XML declaration (warning)

The first line should be <?xml version="1.0" encoding="UTF-8"?>.

Content type (warning)

The server should send the file as application/xml or text/xml. Anything else usually means it's being served as a web page.

URLs found (error if none)

How many <loc> entries the file holds. Zero means search engines get nothing from it.

50,000 URL and 50MB limits (error)

The two hard caps per file. Over either one, split the file and list the parts in a sitemap index.

Invalid URLs (error)

A <loc> that isn't a complete URL, most often a relative path like /about.

Different domain (warning)

URLs on a host other than the one the sitemap lives on. We treat www and non-www as the same host.

http:// URLs (warning)

Entries that don't match your https:// canonical URLs.

Duplicate URLs (warning)

The same URL listed more than once.

Invalid lastmod, priority or changefreq (warning)

Dates not in W3C format, priorities outside 0.0 to 1.0, or a changefreq that isn't always, hourly, daily, weekly, monthly, yearly or never.

The limits that break files

A single sitemap can contain at most 50,000 URLs and must be under 50MB uncompressed. Exceed either and search engines can reject the whole file, not just the overflow. The fix is to split your URLs across several sitemaps and list them in a sitemap index.

Size creeps up quietly on large sites, especially when every entry carries lastmod, priority and changefreq tags, so it's worth checking after a big content push.

Sitemap index files

A sitemap index is a sitemap of sitemaps. Instead of <url> entries it holds <sitemap> entries, each pointing at a child sitemap. Large sites and most CMS plugins use one, which is why your sitemap.xml may contain no page URLs at all.

An index follows the same rules as a sitemap: up to 50,000 entries, absolute URLs, and an optional <lastmod> in W3C format for when each child last changed. Google also asks that the child sitemaps sit on the same site as the index. Paste an index here and we check the index itself and count its child sitemaps. Each child is a separate file, so validate them one at a time.

Common mistakes worth fixing

Most real-world problems aren't exotic: relative URLs, http:// links on an https:// site, URLs pointing at a different domain, duplicated entries, and dates in DD-MM-YYYY instead of YYYY-MM-DD. None of them throw a visible error, they just quietly reduce what gets crawled.

Two more catch people out. A caching or security plugin can serve an HTML page at the sitemap's address, so the file looks fine in a browser but isn't XML. And an unescaped & in a URL breaks the XML itself.

1. 1Use absolute https:// URLs everywhere
2. 2Match the sitemap's host to the URLs inside it
3. 3Format dates as YYYY-MM-DD
4. 4Remove duplicate entries
5. 5Escape & as &amp; inside URLs
6. 6Split past 50,000 URLs or 50MB

How Google uses lastmod, priority and changefreq

Google says it ignores <priority> and <changefreq>. They still have to be valid if you include them, which is why we check them, but tuning them changes nothing in Google.

<lastmod> is the one that counts, and only when Google finds it consistently and verifiably accurate. Change it when the main content, structured data or links on a page change, not on every deploy or copyright-year update. A sitemap that marks every page as modified today teaches Google to stop trusting the dates.

What this validator doesn't check

A valid sitemap is a file search engines can read. It isn't proof that every page inside it deserves to be there. These checks are outside what this tool does:

Whether each listed page loads

We read the sitemap file, not the pages in it, so broken pages and redirects inside a valid sitemap won't show up here.

noindex, canonical and robots.txt rules

A sitemap should only list pages you want in search results: indexable, canonical and not blocked by robots.txt. Search Console's Page indexing report shows where that isn't the case.

Child sitemaps of an index

We count them but don't open them. Paste each one in separately.

Compressed files

Sitemaps can be gzipped (.xml.gz), but this tool reads plain XML. Check the uncompressed version.

A full XML schema check

We check the rules that commonly break sitemaps, not every rule in the sitemaps.org XSD schema. Image, video, news and hreflang tags aren't validated.

What to do after your sitemap passes

Validating doesn't send your sitemap anywhere. Google retired its sitemap ping endpoint in 2023, so there are two ways left to tell it where your sitemap lives, and you can use both.

A sitemap is a hint, not an instruction. Submitting one helps Google discover your pages but doesn't guarantee they get crawled or indexed. Pages still need to be worth indexing and reachable through internal links.

1. 1Submit it in Google Search Console under Indexing, then Sitemaps
2. 2Add a line like Sitemap: https://www.example.com/sitemap.xml to your robots.txt file
3. 3Check the Sitemaps report a few days later for its status and discovered pages
4. 4Validate again after big changes: a migration, a new CMS or a new SEO plugin