SEO BasicsRankingCrawlingBasicsBlogStart Reading ->
<- Blog.Web Indexing

XML Sitemap Tags: lastmod, priority, and changefreq

An essential guide to XML sitemap tags: why Google ignores priority and changefreq, how to format lastmod according to W3C standards, and common CMS traps.

Oct 21, 2026.16 min read
Written by
Updated on: Oct 21, 2026Updated by: Muhammad Furquan
XML Sitemap Tags: lastmod, priority, and changefreq

An XML sitemap is one of the most fundamental technical assets on a modern website. By presenting a structured catalog of your indexable URLs directly to search engines, an XML sitemap helps crawlers discover fresh content, understand your site architecture, and track page modifications over time.

Within the XML sitemap standard, every URL entry can contain up to four distinct tags: <loc>, <lastmod>, <changefreq>, and <priority>. For nearly two decades, digital marketers and webmasters have vigorously debated how to configure these tags. Countless tutorials still recommend assigning a <priority> value of 1.0 to commercial landing pages or setting <changefreq> to daily on blog archives under the belief that doing so forces search engine crawlers to visit more frequently and rank pages higher.

However, modern search engine engineering tells a very different story. While all four tags remain syntactically valid according to the open sitemaps standard, major search engines treat them in radically different ways. Understanding which tags search engines actually utilize, which tags they completely ignore, and how to format timestamps with mathematical precision is essential for maintaining efficient technical SEO. This guide breaks down the technical reality of each tag, dispels longstanding industry myths, and provides practical formatting standards for high-performance crawling.

The Anatomy of a Standard XML Sitemap Entry

The XML Sitemaps protocol was originally introduced in 2005 and is formally maintained at Sitemaps.org Protocol Specification[2]Source 2The official open protocol schema specification for XML Sitemaps defining urlset, loc, lastmod, changefreq, and priority elements.View source ↗. The standard establishes an XML schema where a parent <urlset> container encloses individual <url> nodes.

Each <url> entry can contain four specific child elements:

  1. <loc> (Location): The absolute, canonical URL of the page. This is the only mandatory tag in an XML sitemap entry. It must begin with the correct protocol (https://) and specify the exact host, path, and optional trailing slash.
  2. <lastmod> (Last Modification): The date and optional time when the page was last significantly updated.
  3. <changefreq> (Change Frequency): A theoretical hint indicating how frequently the page content is expected to change (e.g., always, hourly, daily, weekly, monthly, yearly, never).
  4. <priority> (Priority): A relative weighting value ranging from 0.0 to 1.0 that indicates the priority of a particular URL relative to other URLs on your own site.

A fully populated XML sitemap entry structured according to the official protocol appears as follows:

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://example.com/indexing/sitemap-tags</loc>
    <lastmod>2026-10-21T12:00:00+00:00</lastmod>
    <changefreq>weekly</changefreq>
    <priority>0.8</priority>
  </url>
</urlset>

While this snippet validates cleanly against any XML linter, how search engines parse and execute these instructions depends heavily on each crawler's internal ranking and crawling architecture.

Which Sitemap Tags Does Google Actually Use?

Diagram illustrating the four standard XML sitemap tags and their support status across major search engines.
While all four tags are valid in the Sitemaps protocol, Google only evaluates loc and lastmod, completely ignoring changefreq and priority.

To prevent automated manipulation and optimize crawl capacity, Google has adopted a strict, evidence-based approach to sitemap metadata.

According to the Google Search Central Documentation on Building and Submitting Sitemaps[1]Source 1Google's official guide to building and submitting sitemaps, detailing tag support, size limits, and lastmod verification.View source ↗, Google handles the four standard tags with explicit rules:

  • <loc>: Required and fully used. Google uses the location tag to discover new URLs and cross-reference canonical preferences.
  • <lastmod>: Fully used, but only if it is consistently and verifiably accurate.
  • <changefreq>: Completely ignored. Google does not look at change frequency values when scheduling crawls.
  • <priority>: Completely ignored. Google does not look at priority ratings when determining crawl frequency or search rankings.
+-----------------------------------------------------------------------------------+
|                  SEARCH ENGINE SITEMAP TAG EVALUATION ENGINE                      |
+-----------------------------------------------------------------------------------+
|                                                                                   |
|  Incoming XML Entry:                                                              |
|  <url>                                                                            |
|    <loc>https://example.com/page</loc> ---------> [ EVALUATED: URL Added to Queue ]|
|                                                                                   |
|    <lastmod>2026-10-21</lastmod> ---------------> [ VALIDATED: Checked for Truth ] |
|                                                        |                          |
|                                                        +-- Match: Fast Recrawl    |
|                                                        +-- False: Signal Ignored  |
|                                                                                   |
|    <changefreq>daily</changefreq> --------------> [ STRIPPED: Completely Ignored ]|
|                                                                                   |
|    <priority>1.0</priority> --------------------> [ STRIPPED: Completely Ignored ]|
|  </url>                                                                           |
|                                                                                   |
+-----------------------------------------------------------------------------------+

Why Google Ignores Priority

When the <priority> tag was conceived, the intention was to allow site owners to tell search engines which pages were most important relative to other pages on their domain. For example, a webmaster might assign 1.0 to the homepage, 0.8 to major category hubs, and 0.3 to archival blog posts.

In practice, webmasters routinely abused the tag. Automated plugins and over-eager site owners began assigning <priority>1.0</priority> to every single URL in their sitemaps. When every page is assigned maximum priority, the relative signal becomes completely meaningless.

Furthermore, Google already possesses sophisticated internal algorithms (such as PageRank, internal link topology, user search behavior, and click depth) to determine the relative importance of a page within a site. Because internal link architecture provides a tamper-resistant map of site hierarchy, Google has zero need to rely on self-declared priority values.

Setting priority to 1.0 will not increase your rankings, will not accelerate initial indexation, and will not cause Google to favor that page over your competitors.

Why Google Ignores Change Frequency

The <changefreq> tag was originally intended to help search engines budget crawl resources by indicating how often a page changes. A news homepage might declare hourly, while a legal disclaimer page might declare yearly.

Just as with the priority tag, webmasters quickly degraded the reliability of change frequency. Millions of websites marked static pages as always or daily in an attempt to attract constant Googlebot attention.

Modern search engines do not rely on static declarations to determine crawl intervals. Instead, Googlebot tracks historical update intervals algorithmically. If Googlebot visits a page five times over two months and observes no meaningful content changes, it naturally lengthens the crawl interval, regardless of whether your sitemap claims the page changes daily.

Search Engine Tag Support Comparison

While Google explicitly ignores priority and changefreq, other search engines have varying degrees of support across their indexers:

Sitemap Tag Protocol Role Googlebot Support Bingbot Support Yandex Support Best Practice Recommendation
<loc> Mandatory Fully Supported Fully Supported Fully Supported Include on every valid canonical URL
<lastmod> Optional Supported (if accurate) Supported (IndexNow favored) Supported Populate accurately on real content updates
<changefreq> Optional Completely Ignored Completely Ignored Weakly Evaluated Omit to reduce sitemap file weight
<priority> Optional Completely Ignored Completely Ignored Weakly Evaluated Omit to reduce sitemap file weight

Because Google and Bing dominate the overwhelming majority of search traffic in international markets, spending time configuring or troubleshooting <priority> and <changefreq> yields zero technical ROI.

Mastering the lastmod Tag: Formatting and Requirements

Unlike priority and change frequency, the <lastmod> tag is actively utilized by Google and represents a critical efficiency mechanism in technical crawling.

When Googlebot scans an XML sitemap, it reads the <lastmod> date for each URL. If Googlebot has already crawled that URL on October 15, and the sitemap indicates that the page was modified on October 21, Googlebot immediately schedules a high-priority recrawl to fetch the fresh content. Conversely, if the sitemap indicates that the page has not changed since October 15, Googlebot can skip that URL, preserving server bandwidth and focusing its crawl capacity on pages that actually require updating.

The importance of this tag was reinforced in the Google Search Central Announcement on Simplifying Sitemap Pings[4]Source 4Official announcement on deprecating sitemap ping endpoints due to Google's primary reliance on accurate sitemap lastmod timestamps.View source ↗, where Google announced the deprecation of unauthenticated sitemap ping endpoints because Googlebot relies directly on accurate <lastmod> timestamps inside XML sitemaps to schedule recrawls.

Valid W3C Datetime Standards

To be parsed correctly by search engines, the <lastmod> value must adhere strictly to the W3C Datetime format, which is a profile of the international ISO 8601 standard as detailed in the W3C Note on Date and Time Formats[3]Source 3The W3C technical note defining the international ISO 8601 profile for date and time representation used in web standards.View source ↗.

Search engines accept two primary levels of granularity for <lastmod>:

  1. Date Only (Complete Date):

    YYYY-MM-DD

    Example: 2026-10-21 This is the simplest, most common, and most robust format. For blogs, standard content websites, and informational publishers, date-only formatting provides more than enough precision.

  2. Complete Date Plus Hours, Minutes, and Seconds with Timezone Offset:

    YYYY-MM-DDThh:mm:ss+hh:mm

    Example (UTC): 2026-10-21T12:30:00+00:00 or 2026-10-21T12:30:00Z
    Example (Eastern Time -04:00): 2026-10-21T08:30:00-04:00
    This format is ideal for fast-moving publications such as news outlets, financial portals, and live event websites where updates occur multiple times per day.

Common Date Formatting Errors That Break Sitemaps

Providing malformed date strings will cause Google Search Console to throw a Sitemap could not be read or Invalid date format warning. Below is a comparison of valid versus invalid timestamp declarations:

Syntax Type Code Snippet Validation Status Failure Cause
Valid ISO Date <lastmod>2026-10-21</lastmod> Valid Standard YYYY-MM-DD compliance
Valid ISO Timestamp <lastmod>2026-10-21T14:45:00Z</lastmod> Valid UTC Zulu designation
Valid Offset Timestamp <lastmod>2026-10-21T10:45:00-04:00</lastmod> Valid Explicit timezone offset
Invalid Slash Format <lastmod>10/21/2026</lastmod> Invalid Non-ISO format; fails schema validation
Invalid Text Month <lastmod>21 Oct 2026</lastmod> Invalid Textual month strings are disallowed
Missing Timezone <lastmod>2026-10-21T14:45:00</lastmod> Invalid Time included without UTC or timezone offset
Unix Timestamp <lastmod>1792584000</lastmod> Invalid Raw epoch integers are not supported

Always ensure your CMS or sitemap generation script outputs four-digit years, two-digit zero-padded months, and two-digit zero-padded days separated by hyphens.

What Counts as a Significant Update?

Flowchart showing how Googlebot verifies sitemap lastmod timestamps against server headers and rendered content.
Google only trusts sitemap lastmod timestamps when they consistently match actual changes in content and HTTP headers.

Google evaluates <lastmod> through an internal verification heuristic often described as an honesty check. Google does not blindly trust every timestamp it encounters; it actively validates whether the page content has meaningfully changed.

When Googlebot recrawls a URL following a modified <lastmod> signal, it compares the newly fetched content against its cached version of the page. If it finds that the main content, structured data, or substantive links were actually updated, it reinforces trust in that sitemap's <lastmod> data.

However, if a website systematically updates <lastmod> timestamps across thousands of URLs without making any genuine content changes, Googlebot detects the discrepancy. Once Googlebot determines that a site's <lastmod> values are untrustworthy, it completely disables the signal for that entire domain. From that point forward, Googlebot reverts to its own algorithmic crawl frequency, ignoring your sitemap dates entirely.

+-----------------------------------------------------------------------------------+
|                  GOOGLEBOT LASTMOD HONESTY VALIDATION CYCLE                       |
+-----------------------------------------------------------------------------------+
|                                                                                   |
|  [ Step 1: Search Console detects updated <lastmod> in XML Sitemap ]              |
|       |                                                                           |
|       v                                                                           |
|  [ Step 2: Googlebot schedules and fetches the updated URL ]                      |
|       |                                                                           |
|       v                                                                           |
|  [ Step 3: Compares new DOM and HTTP headers against cached copy ]                |
|       |                                                                           |
|       +--> Did substantive body content, data, or links change?                   |
|                |                                                                  |
|                |-- YES --> [ High Trust: Future lastmod signals honored promptly ]|
|                |                                                                  |
|                +-- NO  --> [ Devaluation: lastmod flagged as spam or artificial;  |
|                                         site-wide lastmod trust disabled ]        |
|                                                                                   |
+-----------------------------------------------------------------------------------+

Updates That Justify Changing lastmod

You should update the <lastmod> tag when you make changes that materially alter the information provided to the reader or search engine:

  • Adding new paragraphs, statistics, or revised technical instructions to an article.
  • Updating pricing, product availability, or core product descriptions on an e-commerce page.
  • Modifying structured data (schema markup) or canonical declarations.
  • Adding high-value media, infographics, or downloadable assets.
  • Publishing major design or layout overhauls that change heading structures or main body accessibility.

Updates That Should NOT Trigger lastmod

To prevent your site from losing <lastmod> trust, ensure your CMS does not update the timestamp for trivial or automated site-wide events:

  • Correcting a minor typographical error or punctuation mark in body copy.
  • Automated updates to the site-wide footer (such as incrementing a copyright year).
  • Regenerating a dynamic sidebar widget (such as a list of recent comments or related posts).
  • Modifying global CSS stylesheets or JavaScript asset hashes that do not alter page semantics.
  • Touching a database record during bulk user role migrations or CMS maintenance.

How Modern CMS Platforms and Plugins Handle Sitemap Tags

Different content management systems and SEO plugins handle XML sitemap tags with varying degrees of automation and accuracy. Knowing how your platform operates allows you to identify configuration traps before they harm your crawl efficiency.

WordPress (Core Sitemaps vs SEO Plugins)

  1. WordPress Core (/wp-sitemap.xml): Introduced in WordPress 5.5, the native sitemap generator includes <loc> and <lastmod> for posts and pages. Core WordPress deliberately excludes <priority> and <changefreq> out of the box, reflecting modern search engine standards. Core WordPress pulls <lastmod> directly from the post_modified_gmt database field.
  2. Yoast SEO: Yoast historically included priority and changefreq but has gradually phased out emphasis on these fields. In modern versions, Yoast focuses heavily on <loc> and <lastmod>. It accurately maps lastmod to post revisions and provides filters to prevent attachment pages from polluting the sitemap.
  3. Rank Math: Rank Math allows site owners to enable or disable individual sitemap tags. While it still offers settings for priority and changefreq for users who want them for smaller legacy engines, technical SEOs should leave these disabled to minimize XML payload size.

Shopify and Headless E-commerce

  1. Shopify Native Sitemaps (/sitemap.xml): Shopify automatically generates and updates sitemaps for products, collections, pages, and blog posts. Shopify includes <lastmod> on all product and article entries. However, Shopify merchants should be aware that automated inventory updates (such as an inventory sync app modifying stock counts) can update the product's updated_at timestamp, inadvertently updating <lastmod> without any visible content change.
  2. Custom and Headless Implementations: When generating sitemaps via Node.js, Next.js, or server-side scripts, developers frequently make the mistake of using new Date().toISOString() for every page during build time. This practice causes the entire sitemap to show the deployment timestamp on every page. Google will quickly recognize that thousands of pages did not actually change on deployment and will stop trusting the sitemap dates. Always pull the actual content modification timestamp from your CMS database or git commit log.

Technical Sitemap Best Practices

To ensure maximum crawl efficiency, eliminate file bloat, and maintain high trust with search engine indexers, adhere to the following operational standards:

Focus Area Recommended Practice Unfavorable Practice Technical Reason
Mandatory Tags Include only <loc> and <lastmod> Bloating sitemaps with <priority> and <changefreq> Reduces XML file size and parsing overhead; eliminates ignored metadata
Date Precision Use YYYY-MM-DD or full ISO 8601 with timezone Using localized dates like MM/DD/YYYY or raw timestamps Prevents XML validation and Search Console parsing failures
Update Integrity Update only on substantive content changes Updating <lastmod> on automated site-wide touches Protects domain-level <lastmod> trust from being disabled by Googlebot
Canonical Hygiene Include only HTTP 200 indexable canonical URLs Including redirects (301), broken pages (404), or noindex URLs Prevents crawl budget waste and conflicting indexing signals
File Limits Keep sitemaps under 50,000 URLs and 50MB uncompressed Exceeding standard protocol thresholds without index splitting Guarantees search engine parsers can fetch and process the document

Actionable Takeaway

When maintaining your XML sitemaps, remember that simplicity and honesty outperform complexity. Strip out <priority> and <changefreq> from your configuration to streamline file size, format your <lastmod> tags strictly in W3C ISO 8601 syntax, and ensure timestamps reflect genuine, high-value editorial revisions. By providing clean, truthful metadata, you maximize Googlebot's recrawling efficiency and accelerate search discovery across your entire website.

Sources

Sources

  1. Google Search Central. Build and submit a sitemap.

  2. Sitemaps.org. Sitemap XML Format Specification.

  3. W3C (World Wide Web Consortium). Date and Time Formats Note.

  4. Google Search Central Blog. Simplifying the sitemap ping interface.

Share

About the Contributors