XML Sitemap

TL;DR — An XML sitemap is a file that lists the pages on your site you want search engines to find. Each page gets one entry: its full URL and, optionally, the date it last meaningfully changed. It helps engines discover your pages — it doesn’t force them to index or rank anything. You put it at a URL like /sitemap.xml, point to it from your robots.txt, and submit it in Google Search Console and Bing Webmaster Tools.

What an XML sitemap is

An XML sitemap is a list of your URLs, written in a simple structured format, that you hand directly to search engines. Instead of making them discover every page by following links, you give them a clean inventory of the pages you care about.

Google describes a sitemap as “a file where you provide information about the pages, videos, and other files on your site.” The “XML” part just means it’s written in a tagged format that machines read easily. Here’s the smallest valid example:

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://www.example.com/foo.html</loc>
    <lastmod>2026-06-04</lastmod>
  </url>
</urlset>

Reading it top to bottom: the first line says “this is XML, encoded as UTF-8.” The <urlset> wraps the whole list. Each <url> is one page. <loc> is the page’s full web address. <lastmod> is the date it last changed in a meaningful way — and it’s optional.

What it does (and doesn’t do)

A sitemap helps engines find your pages faster — especially new pages, or pages that aren’t well linked from elsewhere on your site. That’s the upside.

The catch most people miss: submitting a sitemap doesn’t guarantee indexing. Google still decides whether each page is worth keeping. A sitemap is a way to help search engines find your content, not a command to index it. The real value for me is what you can see afterward in Search Console — how many of the URLs you submitted actually got indexed. That gap is a useful diagnostic.

What to put in it

Keep it clean. A sitemap should list only the pages you actually want indexed — your real, canonical pages that return a normal 200 response. Leave out redirects, duplicate URLs, and anything you’ve set to noindex. Think of it as a tidy inventory of your indexable set, nothing more.

One important point of confusion: leaving a URL out of your sitemap does not remove it from Google. A sitemap advertises pages; it doesn’t hide them. To actually keep a page out of the index you need a noindex tag — not a missing sitemap entry.

Where it goes and how to submit it

• Save it at a sensible URL — /sitemap.xml is the conventional default.
• Add a line to your robots.txt so engines can find it: Sitemap: https://www.example.com/sitemap.xml.
• Submit it in Google Search Console (Sitemaps report) and Bing Webmaster Tools.

Most modern platforms (WordPress, Shopify, Wix, Squarespace, Webflow) generate a sitemap for you automatically — you usually just need to submit it. Want the full anatomy, the limits, the tags Google ignores, and how hreflang works in sitemaps? Switch to the Advanced tab.

TL;DR — An XML sitemap is a UTF-8 file of canonical, indexable <loc> URLs, each optionally carrying a <lastmod>. It aids discovery, not indexing — the payoff is the submitted-vs-indexed signal in Search Console. Google ignores <priority> and <changefreq> and uses <lastmod> only when it’s verifiably accurate (significant updates, never a blanket “today”). One file caps at 50,000 URLs or 50MB uncompressed — past that, split and use a sitemap index. Include only 200, canonical, indexable URLs; excluding a URL is not the same as noindexing it. XML isn’t the only accepted format (RSS/Atom/txt work too), and sitemaps are the easiest place to manage hreflang at scale — though those annotations go live on a lag, not instantly. Reference it in robots.txt and submit it in Search Console + Bing Webmaster Tools.

What an XML sitemap actually is

An XML sitemap is a file, written to the sitemaps.org 0.9 protocol, that lists the URLs on your site you want engines to know about. Google’s own definition: “A sitemap is a file where you provide information about the pages, videos, and other files on your site, and the relationships between them.” It’s a discovery aid and a coverage diagnostic — explicitly not a guarantee: “A sitemap helps search engines discover URLs on your site, but it doesn’t guarantee that all the items in your sitemap will be crawled and indexed.”

That framing matters, because it’s where a lot of effort gets misspent. The sitemap isn’t a ranking lever and it isn’t an indexing command. Here’s an annotated minimal example:

<?xml version="1.0" encoding="UTF-8"?>            <!-- XML declaration; UTF-8 -->
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">  <!-- root + namespace -->
  <url>                                           <!-- one entry per page -->
    <loc>https://www.example.com/foo.html</loc>   <!-- required: absolute URL -->
    <lastmod>2026-06-04</lastmod>                 <!-- optional: last significant change -->
  </url>
</urlset>

Anatomy

• The XML declaration — <?xml version="1.0" encoding="UTF-8"?>. Google is unambiguous here: “The sitemap file must be UTF-8 encoded.” Get the encoding wrong and special characters break.
• <urlset> + namespace — the root element, with xmlns="http://www.sitemaps.org/schemas/sitemap/0.9". The namespace is what tells the parser this is a sitemap; the wrong or missing namespace is a common Search Console error.
• <url> — one block per page.
• <loc> — required. “Use fully-qualified, absolute URLs in your sitemaps” — not relative paths, and under ~2,048 characters. All values must be entity-escaped: & becomes &, ' becomes ', " becomes ", > becomes >, and a literal less-than becomes <.
• <lastmod> — optional; the date the page last significantly changed (more on the honesty rule below).

The ignored-tags truth

This is the single most out-of-date thing in most sitemap tutorials. Two legacy tags — <priority> and <changefreq> — are ignored by Google. Gary Illyes called priority “essentially a bag of noise,” and John Mueller has said priority and change frequency “doesn’t really play that much of a role with Sitemaps anymore.” Bing has confirmed the same: changefreq and priority no longer affect its crawling or ranking. You can leave them in (they do no harm) or strip them out — they simply don’t do anything.

<lastmod> is different — do not lump it in with the ignored tags. Google does use <lastmod>, but only when it trusts it, and that trust is roughly binary: either Google believes your dates or it doesn’t. The rule is that the date should reflect a significant change — “an update to the main content, the structured data, or links on the page is generally considered significant, however an update to the copyright date is not.” The failure mode I see constantly is stamping every URL with today’s date on every build. That’s self-defeating: Mueller has called it “just lazy,” noting it’s trivial for engines to recognize and only makes it harder for them to spot genuinely updated pages. Lie often enough and, in Google’s words, “eventually we’re not going to believe you anymore.” Bing leans even harder on <lastmod> as a freshness signal than Google does — so an accurate date helps you on both engines, and a fake one hurts you on both.

Placement, naming, encoding, and compression

• Placement/naming. There’s no required filename, but /sitemap.xml at the root is the convention. By default a sitemap only affects URLs at or below its own path, so keep it high enough to cover everything it lists. The one exception: you can host a sitemap for a different site if you’ve verified ownership of that site and its robots.txt points back to the sitemap’s actual location — Google calls this cross-submission, and it’s the mechanism behind a sitemap index aggregating sitemaps hosted elsewhere.
• Encoding. UTF-8, always.
• Compression. You’re allowed to gzip a sitemap (serve it as .xml.gz), which is worth doing on large files. Important nuance: the 50MB cap is measured uncompressed — gzip saves bandwidth, not headroom against the size limit.

Limits → split + sitemap index

A single sitemap is capped at 50,000 URLs or 50MB uncompressed, whichever comes first. Google states it directly: “All formats limit a single sitemap to 50MB (uncompressed) or 50,000 URLs.” When you blow past either limit, you split the list across multiple sitemap files and reference them all from a sitemap index — a sitemap of sitemaps. That’s its own sibling topic; the short version is that you submit the index, and one index can point at up to 50,000 child sitemaps, so you’ll never actually run out of capacity.

Which URLs to include — and “exclude ≠ noindex”

Include only URLs that are indexable, canonical, and return 200. That means no 3xx redirects, no non-canonical duplicates, no noindex pages, no robots-blocked URLs. A clean sitemap of exactly your indexable set is what makes the Search Console submitted-vs-indexed comparison meaningful — pollute it with junk and you’ve thrown away the diagnostic.

Now the mechanical point people get wrong: excluding a URL from your sitemap does not deindex it. The sitemap is an advertisement, not a gate. Removing a URL’s entry just stops you advertising that page; if Google already knows about it (via links, history, or another source) it stays in the index. The only mechanisms that actually remove a page are a noindex directive (with crawling allowed so Google can see it), a 404/410, or the removals tool. So “take it out of the sitemap” is never the right answer to “how do I deindex this.”

Accepted sitemap file formats

XML isn’t the only format Google accepts — worth knowing so you don’t assume you’re stuck hand-writing XML. Google calls XML “the most versatile of the sitemap formats,” but it also reads:

• RSS 2.0 / Atom feeds — handy because many CMSs already publish one; they carry page URLs only.
• mRSS — a media RSS feed, used for video.
• Plain text (.txt) — literally one URL per line, web-page URLs only, UTF-8.

XML is still the right default because it’s the only format that supports the extensions (lastmod metadata, image, video, and hreflang annotations). The others are URL-only.

hreflang in sitemaps

If you run a multilingual or multi-regional site, the sitemap is usually the easiest place to manage hreflang — you maintain the whole language cluster in one file instead of injecting return-tags into every page template. (It’s one of the three valid places hreflang can live; the <head> and HTTP headers are the others.)

How it’s implemented. Each <url> gets xhtml:link rel="alternate" children, one per language/region version, and you declare the namespace xmlns:xhtml="http://www.w3.org/1999/xhtml" on <urlset>:

<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
        xmlns:xhtml="http://www.w3.org/1999/xhtml">
  <url>
    <loc>https://www.example.com/english/page.html</loc>
    <xhtml:link rel="alternate" hreflang="en" href="https://www.example.com/english/page.html"/>
    <xhtml:link rel="alternate" hreflang="de" href="https://www.example.de/deutsch/page.html"/>
    <xhtml:link rel="alternate" hreflang="x-default" href="https://www.example.com/english/page.html"/>
  </url>
  <!-- each alternate URL repeats the FULL set, including itself (return tags) -->
</urlset>

The return-tag rule. This is the part that bites people. Every <url> element must list every alternate version of the page — including itself. Google: “Each <url> element must have a child element <xhtml:link rel="alternate" hreflang="[supported_language-code]"> that lists every alternate version of the page, including itself.” And it has to be bidirectional: “If page X links to page Y, page Y must link back to page X. If this is not the case for all pages that use hreflang annotations, those annotations may be ignored or not interpreted correctly.” Add an x-default entry for the unmatched-language fallback. A single broken or missing return-tag can invalidate the whole set.

The cap counts <loc> URLs only. A relief for big international sites: the 50,000-URL limit counts only the <loc> page URLs, not the hreflang alternates. So a sitemap with 50,000 pages, each with ten language alternates, still fits — it’s the location URLs that count, not the alternative URLs.

When it actually goes live — budget days, not minutes. Here’s the expectation to set, and it’s mechanism rather than a quotable line. Google parses your sitemap hreflang when it re-fetches the sitemap, but the annotations only take effect once all the URLs in the set have been (re)crawled and the return-tags reconciled against each other. That means there’s a real lag between publishing the hreflang and the alternates being honored, and one slow-to-recrawl or broken URL in the set can hold the rest up. Don’t expect it to flip on the moment you submit — plan for it to settle over days.

Reference it and submit it

• robots.txt — add a Sitemap: line with the full absolute URL. This also lets engines auto-discover it.
• Google Search Console — the Sitemaps report (or the Search Console API) is the primary submission method; it’s also where you read the submitted-vs-indexed diagnostic.
• Bing Webmaster Tools — submit there too; Bing fetches it quickly and rechecks regularly.

One automation note from how I think about this: a sitemap should be generated automatically from the pages you actually have, so it stays current. A hand-built sitemap rots the moment your site changes. The siblings to this page — the sitemaps overview, the sitemap index for large sites, and the image sitemap and video sitemap extensions — cover the rest of the family, and the broader discovery topic ties sitemaps to the other ways engines find your URLs.

AI summary

A condensed take on the Advanced version:

• An XML sitemap is a UTF-8 file listing the canonical, indexable URLs you want engines to know about — each <url> has a required <loc> (absolute URL) and an optional <lastmod>. Root is <urlset> with the sitemaps.org/0.9 namespace.
• It aids discovery, not indexing. Submitting it doesn’t guarantee a page gets indexed; the real payoff is the submitted-vs-indexed diagnostic in Search Console.
• <priority> and <changefreq> are ignored by Google (and Bing). Don’t lump <lastmod> in with them — it is used, but only when verifiably accurate (significant content changes, never a blanket “today” date).
• Limits: 50,000 URLs or 50MB uncompressed, whichever comes first. Past that, split files and use a sitemap index. Gzip is allowed but the 50MB cap is the uncompressed size.
• Include only 200, canonical, indexable URLs. Entity-escape & ' " < >. Excluding a URL ≠ noindexing it — removal needs noindex/404, not a missing sitemap entry.
• XML isn’t the only format — RSS/Atom and plain .txt work too (URL-only); XML is the only one that supports image/video/hreflang extensions.
• hreflang in sitemaps: xhtml:link rel="alternate" children + the xmlns:xhtml namespace; every <url> must list all alternates including itself, bidirectionally, plus x-default. The 50,000 cap counts only <loc> URLs, not the alternates. Processed on sitemap re-fetch but live only after all URLs in the set are recrawled/reconciled — budget days, not minutes.
• Submit it via the robots.txt Sitemap: line, Google Search Console, and Bing Webmaster Tools. Generate it automatically so it stays current.

Official documentation

Primary-source documentation from the search engines.

Google

• Sitemaps overview — what a sitemap is, whether you need one, and that it doesn’t guarantee indexing.
• Build and submit a sitemap — the 50,000/50MB limits, UTF-8 requirement, absolute-URL rule, accepted formats, and the <lastmod> “significant update” definition.
• Manage sitemaps with a sitemap index file — splitting large sitemaps and the sitemap index.
• Tell Google about localized versions of your page — hreflang in sitemaps via xhtml:link, the return-tag rule, and x-default.
• Combine sitemap extensions — putting image/video/hreflang in one sitemap.
• Sitemaps report (Search Console help) — what each submission error means and how to fix it.
• sitemaps.org protocol — the underlying 0.9 spec all engines share.

Bing / Microsoft

• Keeping Content Discoverable with Sitemaps in AI-Powered Search (Jul 2025) — Bing’s stance that XML is preferred and <lastmod> is a key signal.
• The Importance of Setting the lastmod Tag in Your Sitemap (Feb 2023) — why Bing weights <lastmod> for recrawl decisions.

Quotes from the source

On-the-record statements from Google and Bing. Each link is a deep link that jumps to the quoted passage on the source page.

Google — what a sitemap is and does

• “A sitemap is a file where you provide information about the pages, videos, and other files on your site, and the relationships between them.” — Sitemaps overview. Jump to quote
• “A sitemap helps search engines discover URLs on your site, but it doesn’t guarantee that all the items in your sitemap will be crawled and indexed.” Jump to quote

Google — format, limits, and encoding

• “All formats limit a single sitemap to 50MB (uncompressed) or 50,000 URLs.” — Build and submit a sitemap. Jump to quote
• “The sitemap file must be UTF-8 encoded.” Jump to quote
• “Use fully-qualified, absolute URLs in your sitemaps.” Jump to quote

Google — the ignored tags, and the lastmod rules

• “we ignore those. It’s essentially a bag of noise.” — Gary Illyes, on <priority>/<changefreq>. Read the coverage
• “Priority and change frequency doesn’t really play that much of a role with Sitemaps anymore.” — John Mueller. Read the coverage
• “an update to the main content, the structured data, or links on the page is generally considered significant, however an update to the copyright date is not.” — on what <lastmod> should reflect. Jump to quote
• “setting today’s date in a sitemap file isn’t going to be something that works in favor of anyone, it’s just lazy.” — John Mueller. Read the coverage
• “it’s binary, or at least was last time I checked. we either trust it or not.” — Gary Illyes, on whether Google trusts your <lastmod>. Read the coverage

Google — the 50,000 cap counts location URLs, not hreflang alternates

• The 50,000-URL limit “is just the location URL” count — not the hreflang alternate URLs. — John Mueller. Read the coverage

Google — hreflang return tags

• “Each <url> element must have a child element <xhtml:link rel="alternate" hreflang="[supported_language-code]"> that lists every alternate version of the page, including itself.” — Localized versions docs. Jump to quote
• “If page X links to page Y, page Y must link back to page X. If this is not the case for all pages that use hreflang annotations, those annotations may be ignored or not interpreted correctly.” Jump to quote

Bing — XML and lastmod

• “XML remains the preferred format for sitemaps, as it supports structured metadata like lastmod, which helps Bing assess content freshness and relevance more effectively.” Jump to quote

XML sitemap checklist

Build it right

• File is UTF-8 encoded, with <?xml version="1.0" encoding="UTF-8"?> on line one.
• Root is <urlset> with xmlns="http://www.sitemaps.org/schemas/sitemap/0.9".
• Every <loc> is a fully-qualified, absolute URL under ~2,048 characters.
• All values are entity-escaped (& ' " > <).
• <priority> and <changefreq> removed or accepted-as-ignored (Google ignores them).
• <lastmod> present only where it reflects a significant change — never a blanket “today” on every URL.
• File is under 50,000 URLs and 50MB uncompressed; if not, split and add a sitemap index.

Include the right URLs

• Only canonical, indexable, 200-status URLs.
• No 3xx redirects, no non-canonical duplicates, no noindex/robots-blocked URLs.
• Remember: leaving a URL out is not a way to deindex it — use noindex for that.

Ship and monitor it

• Sitemap: line added to robots.txt with the full absolute URL.
• Submitted in Google Search Console and Bing Webmaster Tools.
• Generated automatically from real URLs so it stays current.
• Watch the submitted-vs-indexed numbers in Search Console; split by section/type to see which part of the site is under-indexed.

XML sitemap — cheat sheet

Tag reference

Include vs exclude

Fast facts

• Limits: 50,000 URLs or 50MB uncompressed, whichever first → split + sitemap index.
• Encoding: UTF-8. URLs: absolute, entity-escaped.
• Gzip allowed (.xml.gz); the 50MB cap is the uncompressed size.
• hreflang 50,000 cap counts <loc> URLs only, not the alternates.
• Excluding a URL ≠ noindexing it.
• Accepted formats: XML (the versatile one), RSS/Atom, plain .txt.

A minimal valid XML sitemap

The smallest correct sitemap — declaration, namespaced <urlset>, one <url> with a required <loc> and an optional <lastmod>:

<?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-06-22</lastmod>
  </url>
  <url>
    <loc>https://www.example.com/blog/post-with-an-ampersand?a=1&amp;b=2</loc>
    <lastmod>2026-06-18</lastmod>
  </url>
</urlset>

Note the second <loc>: the & in the query string is entity-escaped to &. Raw &, ', ", <, and > characters will break the XML.

Gzip it for large files

You can serve a sitemap gzipped to save bandwidth — name it .xml.gz:

# Compress a sitemap; Google and Bing both accept .xml.gz
gzip -k sitemap.xml          # produces sitemap.xml.gz, keeps the original

Remember the size limit is checked uncompressed — gzip cuts transfer size, not the 50MB/50,000-URL ceiling. (On Windows, use any zip tool that produces a true gzip stream, or Compress-Archive is not gzip — prefer 7-Zip’s gzip output.)

Reference it in robots.txt

Point engines at it with a Sitemap: line (full absolute URL; auto-discovery works from here):

User-agent: *
Allow: /

Sitemap: https://www.example.com/sitemap.xml

Validate it

Before you submit, sanity-check the file:

• Fetch it and confirm it returns 200 with a real XML body (not your HTML 404 page — “Unsupported format” in Search Console usually means you submitted an HTML page by mistake).
• Check well-formedness locally with xmllint:

# Confirms the XML parses; flags unescaped & < > and mismatched tags
xmllint --noout sitemap.xml && echo "well-formed"

• Submit and watch the Search Console Sitemaps report for the parsed URL count and any errors, then track submitted-vs-indexed over the following days.

Tools for building and checking your XML sitemap

• Google Index Checker — once your sitemap is live, this is how you check the other side of the diagnostic: whether a URL you submitted is actually indexable. It surfaces status code, redirects, noindex, and canonical signals for a URL, then routes you to Search Console’s URL Inspection for Google’s real answer. Useful for chasing down why a submitted URL isn’t showing up in the indexed count.

Ready-to-paste prompts for sitemap work

Audit a sitemap file for spec compliance. Paste the raw XML content of your sitemap (or a representative chunk of it) and ask an AI assistant to check it against the rules in this article:

Here is the content of my XML sitemap. Check it against these rules and list
every violation with the line/URL affected:
1. The declaration and encoding must be `<?xml version="1.0" encoding="UTF-8"?>`.
2. `<urlset>` must declare xmlns="http://www.sitemaps.org/schemas/sitemap/0.9".
3. Every <loc> must be a fully-qualified absolute URL, with & ' " < > properly
   entity-escaped (&amp; &apos; &quot; &gt; &lt;).
4. Flag any <priority> or <changefreq> tags as harmless-but-ignored, not errors.
5. Flag any <lastmod> value that is identical across most/all URLs (a sign of a
   fake "always today" date) as suspicious rather than a hard error.
6. Confirm the file is under 50,000 <url> entries and, if you can estimate file
   size, under 50MB uncompressed.

[paste sitemap XML here]

Expect back a list of concrete violations (not a rewrite) — treat generic “looks fine” output as a signal to check the file yourself with xmllint instead.

Review hreflang return tags in a sitemap. If you’re managing hreflang via sitemap xhtml:link blocks, paste a section of the file and ask for a bidirectionality check:

This is a section of my XML sitemap using xhtml:link rel="alternate" hreflang
tags. For each <url> block, list every hreflang alternate it declares, then
tell me which alternates are NOT reciprocated (page A links to page B, but B's
block doesn't link back to A) and whether an x-default entry is present for
each language cluster.

[paste sitemap XML section here]

This catches the exact failure mode covered above — one missing return tag can get the whole hreflang set ignored — faster than eyeballing a large file by hand.

Resources worth your time

My related writing

• When Should You Worry About Crawl Budget? — where clean sitemaps fit into crawl efficiency, and why your sitemap should list only indexable URLs.
• Enterprise Technical SEO — the automate-it-or-it-rots posture, and sitemaps at scale.
• Website Migration: The Definitive Guide — why I keep a sitemap of the old URLs around after a migration to watch them drop out of the index in GSC.
• Hreflang: The Easy Guide — the three valid places hreflang can live, including the sitemap, and the tradeoffs.
• The Beginner’s Guide to Technical SEO — where sitemaps sit in the bigger picture.

My speaking

• How Search Works (SlideShare) — my walkthrough of crawling, discovery, and indexing. (Standing disclaimer: “This is my understanding of systems… not going to be 100% complete or accurate.”)

From others

• Google’s Sitemaps documentation — the canonical source for formats, limits, and extensions.
• sitemaps.org — the cross-engine 0.9 protocol all of this is built on.
• Bing’s Sitemaps in AI-Powered Search — Bing’s louder-than-Google take on <lastmod>.
• Bing’s The Importance of Setting the lastmod Tag in Your Sitemap — explains how Bing uses <lastmod> for recrawl prioritization.
• Search Engine Roundtable — sitemap coverage — aggregated Google and Bing statements on sitemaps, including Gary Illyes on <priority> and John Mueller on <lastmod> accuracy.
• Google Search Central Blog: What Googlebot looks for in your sitemap — Google’s own post confirming <lastmod> and removing the ping protocol.
• Search Engine Journal — XML Sitemaps — industry coverage of sitemap best practices and common mistakes.

Test yourself: XML sitemaps

Five questions on the XML sitemap format specifics — tags, limits, and hreflang. Pick an answer for each, then check.

XML sitemap

An 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.

Related: Sitemap, Sitemap index, Image sitemap, Video sitemap

XML sitemap

An XML sitemap is a structured file — built around the sitemaps.org 0.9 protocol — in which you list the URLs on your site that you want search engines to know about. Each entry lives in a <url> block with a required <loc> (a fully-qualified, absolute URL) and an optional <lastmod> date. Google calls a sitemap “a file where you provide information about the pages, videos, and other files on your site, and the relationships between them.”

A sitemap helps engines discover URLs, but it doesn’t guarantee they’ll be crawled or indexed — it’s a coverage and diagnostic tool, not a ranking lever. Its real day-to-day value is the submitted-vs-indexed comparison in Google Search Console: it tells you which of the URLs you’ve advertised actually made it into the index.

The format has hard limits — 50,000 URLs or 50MB uncompressed, whichever comes first — and files must be UTF-8 encoded with all special characters entity-escaped. Two legacy tags, <priority> and <changefreq>, are ignored by Google; <lastmod> is used, but only when it’s consistently and verifiably accurate. When a site exceeds the limits, you split it across multiple sitemaps and reference them from a sitemap index file. XML sitemaps can also carry image, video, and hreflang (xhtml:link) extensions, and they aren’t the only accepted format — Google also reads RSS/Atom feeds and plain-text URL lists.

Related: Sitemap, Sitemap index, Image sitemap, Video sitemap

Changelog