Sitemap Validator
Paste your XML sitemap to confirm it is well-formed and complete, and spot missing locs, invalid URLs, bad dates and size-limit issues. Free, client-side, no account.
Your sitemap XML
Checks
Entries
An XML sitemap is the list of URLs you want search engines to discover, and a single malformed tag can stop a crawler from reading the whole file. This free sitemap validator parses your XML the way a crawler does, confirms it is well-formed, identifies whether it is a urlset or a sitemap index, and flags missing locs, invalid URLs, bad lastmod dates and size-limit problems. It is built for SEOs and site owners who want their pages discovered and found, with a sitemap a crawler can actually parse.
How to use it
Paste your sitemap XML
Drop in the contents of your sitemap.xml. The validator parses it live, with nothing to upload and no button to press.
Read the structural checks
See whether the XML is well-formed, whether the root is a urlset or a sitemapindex, and how many entries it contains, with any errors and warnings listed in order.
Fix what is flagged
Work through the missing locs, invalid URLs, non-W3C dates and out-of-range priorities, then re-paste to confirm the file is clean before it ships.
Why it's useful
Catches what breaks parsing first
A crawler stops at the first XML error, so a stray unescaped ampersand or unclosed tag can invalidate the entire sitemap. The validator surfaces well-formedness problems and a missing root element before anything else, because nothing downstream matters until the file parses.
Checks the fields that count
It confirms every entry has a loc with an absolute http(s) URL, validates lastmod against W3C date format, flags priorities outside 0.0 to 1.0, and warns when the file exceeds the 50,000-URL limit, the checks that actually affect discovery.
Nothing leaves your browser
The whole validation runs client-side with the browser's own XML parser. Your sitemap is never uploaded or stored, so you can safely check staging files and client sites without signing in.
What a valid XML sitemap needs
The structure a crawler parses
A sitemap is a list of URLs wrapped in a small, strict XML structure. The root element is <urlset> for a normal sitemap that lists pages, or <sitemapindex> for a sitemap that points at other sitemaps. Each entry needs a <loc> holding a full, absolute URL, from the scheme through the path; relative URLs and bare paths are invalid. Everything else, lastmod, changefreq and priority, is optional.
Because it is XML, well-formedness is non-negotiable: tags must be closed and properly nested, and special characters in URLs must be escaped, so an & inside a <loc> becomes &. A crawler stops at the first parse error and may discard the whole file, which is why this validator checks well-formedness and the root element before anything else. Get the structure right and the rest is detail; get it wrong and none of the detail is read.
Lastmod, priority, and the fields worth your time
Not every optional field earns its keep. Google largely ignores changefreq and priority today, so there is little point tuning them, and a page at priority 1.0 is not crawled sooner than one at 0.5. The validator still flags a priority outside the valid 0.0 to 1.0 range, because that is a sign of a mistake rather than a ranking lever.
Make lastmod honest
lastmod is the one optional field worth getting right. It should be the date the page's content meaningfully changed, written in W3C format, either a date like 2026-01-31 or a full timestamp with a timezone. An accurate lastmod helps a crawler schedule revisits efficiently. A lastmod that resets to today on every page every day is quickly recognised as noise and ignored, so only update it when the content truly changed.
Size limits and what belongs in the file
Size limits are real and enforced. A single sitemap file may contain at most 50,000 URLs and 50 MB uncompressed. Past either limit, split the URLs across several sitemaps and list those sitemaps in a <sitemapindex>, which can itself reference up to 50,000 sitemaps. The validator warns you as a file approaches the URL limit so you can plan the split before a crawler rejects the file.
Include only canonical, indexable URLs that return a 200 status. Listing redirects, noindex pages, or URLs blocked in robots.txt wastes crawl budget and muddies the signal about which pages matter. This validator checks structure, not live responses: it does not fetch each URL, so it cannot confirm a page returns 200. Paste the rendered XML your server actually serves at /sitemap.xml, so you validate exactly what ships to crawlers rather than a copy that has drifted.
They use Otorank
Questions
What makes a sitemap valid, which fields matter, where the size limits sit, and what this validator does and does not check.
A <urlset> sitemap lists individual page URLs. A <sitemapindex> lists other sitemap files, used to group many sitemaps once you pass the per-file limits. The validator detects which root your file uses and checks the matching entries.
A single sitemap file may contain at most 50,000 URLs and 50 MB uncompressed. Beyond that, split the URLs into multiple sitemaps and reference them from a sitemap index. The validator warns as a file nears the URL limit.
lastmod must be a W3C date, either a date such as 2026-01-31 or a full timestamp with a timezone offset. It should reflect when the content genuinely changed; the validator flags any lastmod that is not a valid W3C date.
No. It checks the XML structure, not live responses, so it cannot confirm each URL returns 200. Paste the file your server actually serves at /sitemap.xml to validate what really ships, then verify status codes separately.
No. Everything is parsed in your browser with the native XML parser; nothing is transmitted or stored, so you can safely validate staging files and client sites without signing in.