Rankato

Free Sitemap Tester & Validator

Paste any sitemap URL. We'll parse it, count URLs, sample destinations, and tell you exactly what to fix — no login required.

Supports gzipSitemap Index

Paste any sitemap URL to begin

We'll validate the XML, count URLs, sample a handful to make sure they return HTTP 200, and flag common mistakes: HTTP URLs, missing lastmod, oversized files, and broken destinations.

The Sitemap Tester takes any sitemap URL — sitemap.xml, sitemap index, or gzipped variant — and gives you a complete diagnostic in seconds. It parses the XML, validates it against the sitemaps.org 0.9 schema, counts URLs, checks Google's per-file limits (50,000 URLs, 50 MB uncompressed), and samples a subset of URLs with real HEAD requests to catch broken destinations, redirect chains, and mixed protocols. It reports metadata coverage (lastmod, priority, changefreq) because Google specifically uses lastmod to prioritize what to recrawl. Every issue is classified error / warning / info, so you know what breaks indexing (invalid XML, oversized files, 4xx destinations) versus what merely wastes crawl budget (redirects in sitemap, missing lastmod, http:// entries on an https site). Ships with recommendations you can hand to a developer verbatim.

What a sitemap is actually for (and what it isn't)

An XML sitemap is a directory of the URLs on your site that you want search engines to know about — along with signals about when they last changed. It's a discovery aid: Google finds URLs through internal links, external links, and the sitemap. On a small site every URL is already reachable through internal links, so the sitemap mostly helps Google prioritize recrawling. On a large site (10k+ pages), the sitemap is essential — it's the fastest way for Google to discover newly-added URLs and the primary signal for which pages have changed and need re-indexing. What a sitemap doesn't do: it doesn't force Google to index a URL, it doesn't affect ranking, and it doesn't override robots.txt or noindex. If a URL is in the sitemap but blocked by robots, Google won't crawl it. If it's noindex, it stays out of the index. Sitemap inclusion is a suggestion, not a guarantee.

Google's hard limits every sitemap must respect

Google publishes three hard limits that our tester checks: 50,000 URLs per file, 50 MB uncompressed size, and a 500-sitemap limit inside a sitemap index. Exceed any of these and Google stops processing the file — no warning, no partial indexation. Sites with more than 50k URLs must split into multiple sitemaps and use a sitemap index. Most CMSes handle this automatically, but audits regularly turn up sitemaps that ballooned past the limit after a mass import or programmatic-page rollout. The 50 MB uncompressed limit typically bites when you have huge <lastmod> and <image:image> blocks. Serving the sitemap gzipped doesn't help — Google uncompresses it and re-checks the size against 50 MB. When our tester flags size_exceeded or url_count_exceeded, it's not a warning; the sitemap is functionally invalid.

Why lastmod is the most important field you're probably ignoring

Google confirmed in 2023 that it uses <lastmod> as a strong signal to schedule recrawls, and that missing or inaccurate lastmod values reduce the sitemap's usefulness. If lastmod is present and accurate, Google prioritizes recrawling URLs where lastmod moved recently. If lastmod is missing, Google falls back to its own change-detection heuristics — slower and less accurate. If lastmod is present but always identical (e.g. today's date on every URL, generated at request time), Google treats the whole file as untrustworthy and downweights the signal. Set lastmod to the actual last content change (or last significant one), format as ISO 8601 (2026-08-05T14:22:33+00:00), and only update it when a URL's content genuinely changed. Our tester reports coverage — the percentage of URLs with lastmod — and flags sitemaps where 0% have it (still surprisingly common).

Sitemap index vs urlset — pick the right root element

Two root elements exist. <urlset> lists actual URLs, one <url> block per page, each with a <loc> and optionally <lastmod>, <changefreq>, and <priority>. <sitemapindex> lists other sitemaps, each with a <loc> pointing to a <urlset> file and an optional <lastmod>. Use urlset when you have fewer than 50k URLs and a single file makes sense. Use sitemapindex when you have more URLs or you want to organize by section (sitemap-blog.xml, sitemap-products.xml, etc.), so partial recrawls don't reprocess the whole site. Our tester detects which root you have and validates accordingly. If a file has <urlset> but every <loc> points at another sitemap, that's an error we catch — you meant sitemapindex.

How to fix the top four sitemap mistakes we find

1. Redirected URLs. If a sitemap URL 301s, Google follows it but complains — every hop wastes crawl budget and dilutes signals. Fix: put the final URL directly in the sitemap. 2. Broken URLs (4xx/5xx). Ship a broken URL in the sitemap and Google downgrades trust in the whole file. Fix: run a link check quarterly and prune dead URLs. 3. http:// URLs on an https:// site. Google indexes each protocol as a separate URL, so an http entry can steal ranking from the https version. Fix: normalize every URL to https. 4. URLs blocked by robots.txt. Contradictory signal — sitemap says "index me," robots says "don't crawl me." Fix: pick one. Either allow crawling or remove from sitemap. Our tester samples up to 100 URLs and flags each of these. Rerun after fixes to confirm.

Tool FAQs

Everything you need to know about using Sitemap Tester.

Does this tool support gzipped sitemaps (.xml.gz)?+

Yes. If the URL ends with .gz, the response is gzipped, or the first two bytes are the gzip magic number, we decompress in memory and parse the XML. Google's 50 MB limit applies to the uncompressed size — that's what we measure and report.

How many URLs does it sample from the sitemap?+

Between 0 and 100, based on your selection. Default is 20. Samples are evenly spaced through the file (not random) so you get coverage from beginning, middle, and end — which catches problems like a sitemap where the first few URLs are healthy but old sections at the tail are broken. Every sampled URL gets a HEAD request (with GET fallback if HEAD returns 405) so we can classify it as OK / redirect / broken / timeout.

Why not fetch every URL in the sitemap?+

Two reasons. First, per-request rate limits and latency: checking 50,000 URLs would take hours per sitemap and hammer the target server. Second, sampling gives you a directional answer fast. If 5 out of 20 sampled URLs are broken, you know the sitemap is unhealthy — you don't need all 50,000 to confirm. For an exhaustive check, use a dedicated crawler (like our Website SEO Audit) that respects your target's rate limits.

What does the score mean?+

0–100. Starts at 100 and deducts for each issue: errors (invalid XML, oversized, broken URLs at scale) lose 25 points, warnings (missing lastmod, http URLs, redirects) lose 10, and a proportional deduction is taken for the ratio of broken/redirect URLs in the sample. A score of 80+ means the sitemap is in good shape; 60–80 means there's slack to tighten; below 60 usually means the sitemap is doing more harm than good.

Should I set priority and changefreq?+

They're ignored by Google. John Mueller has confirmed multiple times that Google no longer uses <priority> or <changefreq>. Bing still uses them mildly. Set them if you want, but don't over-optimize — every page at priority 1.0 is the same as no page at priority 1.0. The one field that matters is <lastmod>. Get that right and skip the other two.

How do I submit a sitemap to Google after fixing it?+

Two ways. Google Search Console → Sitemaps → paste the URL → Submit. That's the manual trigger and it's the fastest way to force Google to re-parse the file. The other way is passive: reference the sitemap in robots.txt with Sitemap: https://example.com/sitemap.xml. Google will pick it up on the next robots crawl. For Bing, use Bing Webmaster Tools. IndexNow is a separate protocol for pushing individual URL changes — different problem.