News Sitemaps

TL;DR — A news sitemap is a regular XML sitemap with a few extra “news” tags added, so you can point Google at your recent articles. The catch that makes it special: it should only list articles from the last two days — old ones get removed. It helps Google find breaking stories faster. It does not help you rank, and it isn’t what gets you into Google News. You can make it its own file or add the news tags to a sitemap you already have.

What a news sitemap is

If you already know what an XML sitemap is — a file listing your URLs that you hand to search engines — a news sitemap is that same idea with a twist. You add a small set of “news” tags to each entry, and instead of listing every page on your site, you list only your recent news articles.

The whole point is speed. News is time-sensitive, so Google offers this format to help it discover breaking articles quickly. Google’s own words: “If you are a news publisher, use news sitemaps to tell Google about your news articles and additional information about them.”

The one rule that surprises people

A normal sitemap lists everything and never really expires an entry. A news sitemap is the opposite: it should only contain articles created in the last two days (you’ll often see this called “48 hours”). Once an article is older than that, you take it out. That feels wrong the first time you hear it — but it’s exactly how Google wants it.

Removing an old article from your news sitemap does not remove it from Google. The article stays indexed and can still show up in search normally. You’re just telling Google “this one isn’t breaking news anymore,” not “forget this page exists.”

What it does — and doesn’t — do

• It speeds up discovery of your fresh articles. That’s the entire benefit.
• It is not a ranking factor. Having one won’t move you up the results.
• It does not get you into Google News or Top Stories. That comes from publishing quality content that follows Google’s news content policies — not from a sitemap.

If you want the “how do I actually qualify for Google News” side of this, that’s a separate topic — see the Google News SEO guide. This page is purely about the sitemap file itself.

Your two options

You can either:

1. Make a separate news sitemap — a dedicated file just for your recent articles, or
2. Add the news tags to an existing sitemap you already publish.

Both are fine with Google. A separate file is usually easier to keep track of in Search Console, because you get its own submitted-vs-indexed numbers.

Most news CMSs and SEO plugins generate this for you. Want the exact tags, the nesting, the URL limit, the tags you should stop copying from old tutorials, and how to submit it? Switch to the Advanced tab.

TL;DR — A news sitemap is a standard <urlset> with Google’s news: namespace added, where each <url> carries one <news:news> block (<news:publication> → <news:name> + <news:language>, plus <news:publication_date> and <news:title>). Only include articles created in the last two days (≈48 hours); past that, drop the URL or strip its <news:news> block — neither deindexes the article. Cap is 1,000 <news:news> tags per file (much stricter than the general 50,000-URL limit); split with a sitemap index beyond that. It speeds discovery, it’s not a ranking factor, and it doesn’t grant Google News eligibility. news:keywords / news:stock_tickers / genre tags were dropped in 2018 and aren’t in the current schema — don’t add them. Publisher Center isn’t required. Bing has no equivalent namespace.

A news sitemap is not a normal sitemap

Everything you know about generic sitemaps still applies — Google says plainly that “news sitemaps are based on generic sitemaps, so the general sitemap best practices also apply to news sitemaps.” So the UTF-8 encoding, absolute-URL, entity-escaping, and submission mechanics all carry over from the ordinary XML sitemap; I won’t re-derive them here.

What’s different is two things: an extra XML namespace with a handful of news tags, and a hard freshness window. Get those two right and you have a valid news sitemap.

You have a format choice up front, and Google is explicit that both work: “You can either extend your existing sitemap with news specific tags, or create a separate news sitemap that’s reserved just for your news articles. Either option is fine with Google, however creating a separate sitemap just for your news articles may enable better tracking of your content in Search in Search Console.” I lean toward a separate file for exactly that reason — a clean per-file submitted-vs-indexed number in Search Console is worth more than the minor convenience of one combined file.

The exact tag structure

Here is Google’s example, reproduced exactly — the nesting is the single most common thing tutorials get wrong:

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
    xmlns:news="http://www.google.com/schemas/sitemap-news/0.9">
  <url>
    <loc>http://www.example.org/business/article55.html</loc>
    <news:news>
      <news:publication>
        <news:name>The Example Times</news:name>
        <news:language>en</news:language>
      </news:publication>
      <news:publication_date>2008-12-23</news:publication_date>
      <news:title>Companies A, B in Merger Talks</news:title>
    </news:news>
  </url>
</urlset>

Read the nesting carefully, because this is where implementations go wrong:

• The root is the ordinary <urlset>, but it declares a second namespace: xmlns:news="http://www.google.com/schemas/sitemap-news/0.9". Google: “The news tags are defined in the news sitemap namespace: http://www.google.com/schemas/sitemap-news/0.9”.
• There is one <news:news> block per <url> — it sits alongside <loc>, not wrapping the whole file. Google is precise: “Each url sitemap tag can have only one news:news tag.”
• <news:name> and <news:language> are children of <news:publication>.
• <news:publication>, <news:publication_date>, and <news:title> are all direct children of <news:news>.

There is no single <news:news> wrapper around the entire sitemap. If you find yourself nesting one, you’ve got it wrong.

The required tags, one by one

• <news:news> — the parent for everything in the news: namespace. One per <url>.
• <news:publication> — parent of <news:name> and <news:language>. Google: “Each <news:news> parent tag may only have one <news:publication> tag.”
• <news:name> — your publication’s name. Google’s constraint: “It must exactly match the name as it appears on your articles on news.google.com, omitting anything in parentheses.”
• <news:language> — an ISO 639 language code (two or three letters). Google notes one exception: “For Simplified Chinese, use zh-cn and for Traditional Chinese, use zh-tw.”
• <news:publication_date> — the article’s publication date in W3C format, either YYYY-MM-DD or the full YYYY-MM-DDThh:mm:ssTZD form with a time-zone designator. The rule people miss: “Specify the original date and time when the article was first published on your site. Don’t specify the time when you added the article to your sitemap.” Stamping every entry with the sitemap-generation time is a real bug in some hand-rolled and older-plugin setups — it’s the original publish time that goes here.
• <news:title> — the article headline. Google: “Include the title of the article as it appears on your site. Don’t include the author name, publication name, or publication date in the <news:title> tag.”

The freshness rule: last two days (≈48 hours)

This is the defining feature of a news sitemap and the accuracy point worth pinning down. Google’s exact wording is “the last two days,” not “48 hours” — the industry just shorthands it. Here’s the rule verbatim: “Only include recent URLs for articles that were created in the last two days. Once the articles are older than two days, either remove those URLs from the news sitemap or remove the <news:news> metadata in your sitemap from the older URLs.”

So two valid ways to expire an old article:

1. Delete the URL from the news sitemap entirely, or
2. Keep the URL but strip its <news:news> block (leaving a plain sitemap entry).

Either satisfies the rule.

Removing from the news sitemap is not deindexing. This is the mental model to hold onto: the two-day window only controls what’s eligible for the news-specific fast-discovery pipeline. It does not affect whether the article stays indexed. Google keeps indexing and can keep ranking already-crawled URLs from its history normally — the same principle that applies to ordinary sitemaps, where leaving a URL out of the sitemap is not the same as noindexing it. Dropping an article out of your news sitemap at the 48-hour mark is expected maintenance, not a signal to forget the page.

Update the file, don’t spin up a new one. Google: “Update your news sitemap with fresh articles as they’re published. Don’t create a new sitemap with each update. Google News crawls news sitemaps as often as it crawls the rest of your site.” You maintain the same file continuously; there’s no per-article ping-a-new-file ritual.

An empty news sitemap is fine. If you prune old URLs and haven’t published in a few days, the file can go empty. Google: “You may see an Empty Sitemap warning in Search Console, but this is just to make sure it was intentional on your behalf. It won’t cause any problems with Google Search if the file is empty.” Reassuring if you run a lower-cadence site that only occasionally posts news-style content.

The 1,000-URL cap (stricter than you expect)

A news sitemap is capped far lower than an ordinary one. Google: “a sitemap may have up to 1,000 news:news tags. If there are more than 1,000 <news:news> tags in a news sitemap, split your sitemap into several smaller sitemaps.”

Note the contrast: a generic XML sitemap caps at 50,000 URLs or 50MB uncompressed. A news sitemap caps at 1,000 <news:news> tags — fifty times stricter. If you come to this with sitemap-index knowledge, don’t assume the same 50,000 ceiling; the news limit is 1,000, and you split past it exactly the way you’d split any sitemap: multiple files referenced from a sitemap index. In practice, the two-day window keeps most publishers well under 1,000 anyway — you’d need to be publishing 500+ articles a day to bump into it.

Tags you’ll see in old tutorials but shouldn’t use

If you copy a news sitemap example off a 2017 blog post — or open an old plugin’s settings screen — you’ll see tags that no longer exist in Google’s spec: news:keywords, news:stock_tickers, and genre/access tags. These are dead. Google dropped news:keywords support in February 2018, and none of these appear anywhere in the current documentation — the only tags Google now lists are publication, publication_date, and title.

Leaving old ones in an existing file doesn’t break anything (deprecated tags are harmless, just ignored), so you don’t need to urgently strip them from a legacy sitemap. But don’t add them, and don’t treat any tutorial that presents news:keywords as a “required tag” as current — that’s the single most common inaccuracy floating around on this topic.

Do you need Google Publisher Center? No.

A correctly formatted news sitemap works whether or not you’ve ever touched Google Publisher Center. There’s no gating where <news:name> has to be “registered” somewhere to count. Old tutorials imply you must register a publication in Publisher Center first — that’s stale.

What changed: Google stopped taking manual Google News publication submissions in Publisher Center in April 2024, and the switch to automatically generated publication pages completed in late March 2025. Google’s own framing now is that “Content from publishers that adheres to our content policies is automatically eligible for consideration in Google News and across news surfaces” and “Publishers are automatically considered for ‘Top stories’ or the News tab of Search. They just need to produce high-quality content and comply with Google News content policies.” The old Publisher Center UI that once handled genre/tag control for news is gone along with manual submissions. For the full timeline, see the Google News SEO guide; for the sitemap format itself, Publisher Center is simply not a prerequisite.

Submitting and maintaining it

Submission is identical to any sitemap — there’s nothing news-specific here:

• robots.txt — add a Sitemap: line with the full absolute URL of the news sitemap.
• Google Search Console — submit it in the Sitemaps report; that’s also where you read its submitted-vs-indexed numbers and any warnings.
• Keep updating the same file as you publish, and prune past the two-day mark.

If something’s off, Google points you to Search Console: “If you’re having trouble with your sitemap, you can investigate the errors with Google Search Console.”

Bing has no equivalent

Bing does not support Google’s news:news XML extension — there’s no equivalent news: namespace for it to read. Bing’s news-inclusion model is a genuinely manual submission-and-review process via PubHub in Bing Webmaster Tools, where you submit URLs or RSS feeds so Bing can distinguish news from non-news content. The closest Bing analog to “get my breaking article crawled fast” is IndexNow, the push protocol Bing supports for instantly notifying it of new or updated URLs. So a standard XML sitemap plus IndexNow is the Bing-side story; the news-sitemap format is a Google thing. (The PubHub mechanics are out of scope here — see the Google News SEO guide’s Bing section.)

Where this sits in the sitemap family

A news sitemap is one member of the sitemap family. The sitemaps overview is the place to start if you’re new to the topic; the ordinary XML sitemap covers the base mechanics this format inherits; and when you outgrow 1,000 news URLs, the sitemap index is how you tie the split files together. For the eligibility side of Google News — which the sitemap deliberately doesn’t touch — see the Google News SEO guide.

AI summary

A condensed take on the Advanced version:

• A news sitemap is a standard <urlset> extended with Google’s news: namespace. Each <url> carries one <news:news> block: <news:publication> (holding <news:name> + <news:language>), plus <news:publication_date> and <news:title>. One <news:news> per <url>; it does not wrap the whole file.
• Two format options, both fine with Google: a separate news-only file, or news tags added to an existing sitemap. Separate file = cleaner Search Console tracking.
• Freshness window: the last two days (≈48 hours). Older than that, either delete the URL or strip its <news:news> block. Removing it from the news sitemap does not deindex the article — it stays indexed and rankable.
• Update the same file continuously — don’t create a new file per publish. An empty news sitemap is fine (benign “Empty Sitemap” warning at most).
• Cap: 1,000 <news:news> tags per file — far stricter than the generic 50,000-URL / 50MB limit. Split past it with a sitemap index.
• It speeds discovery only. Not a ranking factor; does not grant Google News eligibility (that’s content-policy compliance).
• Dead tags: news:keywords, news:stock_tickers, genre/access — dropped in 2018, absent from the current schema. Safe to leave in a legacy file, but don’t add them.
• Publisher Center is not required for the sitemap to work; manual News submission there ended April 2024, automation finished March 2025.
• <news:publication_date> = original publish time, not the sitemap-generation time. <news:title> = headline only, no author/publication/date.
• Bing: no news: equivalent — PubHub/RSS submission, with IndexNow as the fast push lever.

Official documentation

Primary-source documentation on news sitemaps.

Google

• Create a News Sitemap — the authoritative spec: the news: namespace, the required tags, the two-day window, and the 1,000-URL cap.
• Build and submit a sitemap — the generic sitemap rules (UTF-8, absolute URLs, submission) that news sitemaps inherit.
• Manage large sitemaps with a sitemap index file — splitting past the 1,000-URL cap and referencing files from a sitemap index.
• News content across Google — that publishers are automatically considered for Top Stories / the News tab by complying with content policies.
• Publisher Center: automatic publication pages — the 2024–2025 transition to automatic eligibility.

Bing / Microsoft

• PubHub Publisher Guidelines — Bing’s manual news-submission model (there is no news: sitemap equivalent).
• How to submit your news website to Bing — the PubHub submission flow.
• IndexNow — the push protocol Bing supports for instant crawl notification of new/updated URLs.

Quotes from the source

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

Google — what a news sitemap is and the format choice

• “If you are a news publisher, use news sitemaps to tell Google about your news articles and additional information about them.” — Google, Create a News Sitemap. Jump to quote
• “Either option is fine with Google, however creating a separate sitemap just for your news articles may enable better tracking of your content in Search in Search Console.” Jump to quote

Google — the two-day freshness rule and update cadence

• “Only include recent URLs for articles that were created in the last two days.” Jump to quote
• “Update your news sitemap with fresh articles as they’re published. Don’t create a new sitemap with each update.” Jump to quote
• “It won’t cause any problems with Google Search if the file is empty.” Jump to quote

Google — the namespace, the 1,000-URL cap, and the required tags

• “http://www.google.com/schemas/sitemap-news/0.9” — the news sitemap namespace. Jump to quote
• “a sitemap may have up to 1,000 news:news tags” — the per-file cap. Jump to quote
• “It must exactly match the name as it appears on your articles on news.google.com” — on <news:name>. Jump to quote
• “For Simplified Chinese, use zh-cn and for Traditional Chinese, use zh-tw.” — the <news:language> exception. Jump to quote
• “Specify the original date and time when the article was first published on your site. Don’t specify the time when you added the article to your sitemap.” — on <news:publication_date>. Jump to quote
• “Don’t include the author name, publication name, or publication date in the <news:title> tag.” Jump to quote

Google — automatic News eligibility (Publisher Center transition)

• “Content from publishers that adheres to our content policies is automatically eligible for consideration in Google News and across news surfaces.” — Publisher Center Help. Jump to quote
• “Publishers are automatically considered for ‘Top stories’ or the News tab of Search. They just need to produce high-quality content and comply with Google News content policies.” Jump to quote

Gary Illyes, Google — separate vs. combined sitemaps and removal cadence (via Search Engine Journal)

• “it’s usually simpler to have separate site map for news and for web. Just remove the URLs altogether from the news site map when they become too old for news.” Read the coverage
• “Including the URLs in both site maps, while not very nice, but it will not cause any issues for you.” Read the coverage

News sitemap checklist

Build it right

• Root <urlset> declares both namespaces — the standard http://www.sitemaps.org/schemas/sitemap/0.9 and xmlns:news="http://www.google.com/schemas/sitemap-news/0.9".
• Exactly one <news:news> block per <url>, sitting alongside <loc>.
• <news:name> and <news:language> are inside <news:publication>.
• <news:publication>, <news:publication_date>, and <news:title> are all direct children of <news:news>.
• <news:name> exactly matches your publication name on news.google.com (drop anything in parentheses).
• <news:language> is an ISO 639 code (zh-cn / zh-tw for Chinese).
• <news:publication_date> is the original publish time (W3C format), not the sitemap-generation time.
• <news:title> is the headline only — no author, publication name, or date.

Keep it fresh

• Only articles from the last two days (≈48 hours) are listed.
• Older articles are removed — either the whole URL or just its <news:news> block.
• You update the same file as you publish; you don’t spin up a new file each time.
• Under 1,000 <news:news> tags; if not, split and use a sitemap index.
• No news:keywords, news:stock_tickers, or genre tags added (dead since 2018).

Ship and monitor it

• Referenced with a Sitemap: line in robots.txt (full absolute URL).
• Submitted in Google Search Console and watched in the Sitemaps report.
• An occasional “Empty Sitemap” warning is understood to be benign.
• You’re not relying on Publisher Center registration to make it “count” — it isn’t required.

News sitemap — cheat sheet

Required tags and nesting

News sitemap vs. generic XML sitemap

Dead tags — don’t add these

Fast facts

• Speeds discovery only — not a ranking factor, not a Google News eligibility gate.
• Removing an article from the news sitemap ≠ deindexing it.
• Separate file or a section of an existing sitemap — both fine.
• Publisher Center not required; manual News submission there ended April 2024.
• Bing: no news: namespace — PubHub/RSS submission, IndexNow for speed.

Should you use a news sitemap — and how?

Walk this if you’re deciding whether to build one and which shape it should take.

Common mistakes

The recurring ways news sitemaps go wrong, why each is wrong, and what to do instead.

1. Adding news:keywords or news:stock_tickers

• Why it’s wrong: Google dropped news:keywords in February 2018, and neither it, news:stock_tickers, nor genre/access tags appear anywhere in the current schema. Old tutorials and old plugin UIs still show them, which is why they keep getting copied.
• Do instead: Use only the current tags — publication, publication_date, title. Leaving old ones in a legacy file is harmless, but don’t add them to anything new.

2. Assuming you must register in Google Publisher Center first

• Why it’s wrong: There’s no gating that makes <news:name> “activate” via Publisher Center. Manual News submission there ended in April 2024, and automatic eligibility completed in March 2025 — a correctly formatted news sitemap works regardless.
• Do instead: Just publish the sitemap. Eligibility for Google News comes from content-policy compliance, not from any registration step.

3. Generating a brand-new sitemap file on every publish

• Why it’s wrong: Google explicitly says “Don’t create a new sitemap with each update” — it crawls the news sitemap on the same cadence as the rest of your site, so per-article file churn buys you nothing.
• Do instead: Update the same file continuously as articles publish and age out.

4. Believing a news sitemap gets you into Google News or Top Stories

• Why it’s wrong: The sitemap only speeds discovery of content Google can already find. It’s not a ranking factor and not an eligibility gate.
• Do instead: Treat it as a discovery accelerator; earn Google News placement through quality content that follows the news content policies (see the Google News SEO guide).

5. Panicking when the news sitemap goes empty

• Why it’s wrong: If you prune old URLs and haven’t published recently, an empty file is expected. Google says it “won’t cause any problems with Google Search if the file is empty.”
• Do instead: Ignore the benign “Empty Sitemap” warning in Search Console — it’s there only to confirm the emptiness was intentional.

6. Reading the two-day window as “Google stops indexing after 48 hours”

• Why it’s wrong: The window only controls the news-specific fast-discovery signal. Removing an article from the news sitemap doesn’t deindex it — Google keeps indexing and ranking already-crawled URLs from history.
• Do instead: Prune old articles out of the news sitemap on schedule and let them live in your regular sitemap / index as normal.

7. Stamping <news:publication_date> with the sitemap-generation time

• Why it’s wrong: Google says to use “the original date and time when the article was first published,” not when you added it to the sitemap. Some hand-rolled and older-plugin setups get this backwards.
• Do instead: Emit the article’s true first-published timestamp.

8. Getting the nesting wrong

• Why it’s wrong: <news:name>/<news:language> belong inside <news:publication>, and there’s exactly one <news:news> per <url> — not one wrapping the whole file. Wrong nesting is the single most common structural error.
• Do instead: Mirror Google’s example exactly (see the Scripts tab) and validate the XML before submitting.

A minimal valid news sitemap

The whole shape — standard <urlset> with the news: namespace added, one <news:news> block per <url>, with the nesting exactly as Google specifies:

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
    xmlns:news="http://www.google.com/schemas/sitemap-news/0.9">
  <url>
    <loc>https://www.example.com/2026/07/03/merger-talks.html</loc>
    <news:news>
      <news:publication>
        <news:name>The Example Times</news:name>
        <news:language>en</news:language>
      </news:publication>
      <news:publication_date>2026-07-03T09:15:00-04:00</news:publication_date>
      <news:title>Companies A and B in Merger Talks</news:title>
    </news:news>
  </url>
</urlset>

Notes baked in: the <news:publication_date> uses the full W3C form with a time-zone designator and reflects the original publish time; the <news:title> is the headline only; and there’s exactly one <news:news> per <url>.

Validate the XML before you submit

Confirm it’s well-formed (this catches unescaped &/</>, mismatched tags, and broken nesting):

# Well-formedness check — flags structural errors before Search Console does
xmllint --noout news-sitemap.xml && echo "well-formed"

Extract every article URL and its publish date

Pull <loc> + <news:publication_date> pairs out of a live news sitemap — useful for auditing which articles are still inside the two-day window. Note the news: prefix needs its namespace registered:

# Requires xmllint (libxml2). --recover tolerates minor issues; -o - prints to stdout.
xmllint --xpath "//*[local-name()='url']" news-sitemap.xml

For a cleaner pull with Python’s standard library (no dependencies), handling the namespace explicitly:

import xml.etree.ElementTree as ET
from datetime import datetime, timezone, timedelta

NS = {
    "sm": "http://www.sitemaps.org/schemas/sitemap/0.9",
    "news": "http://www.google.com/schemas/sitemap-news/0.9",
}

tree = ET.parse("news-sitemap.xml")
cutoff = datetime.now(timezone.utc) - timedelta(days=2)

for url in tree.findall("sm:url", NS):
    loc = url.findtext("sm:loc", namespaces=NS)
    pub = url.findtext("news:news/news:publication_date", namespaces=NS)
    # Flag anything that has slipped past the two-day window and should be pruned.
    stale = ""
    if pub:
        try:
            dt = datetime.fromisoformat(pub.replace("Z", "+00:00"))
            if dt.tzinfo is None:
                dt = dt.replace(tzinfo=timezone.utc)
            if dt < cutoff:
                stale = "  <-- older than 2 days: remove or strip <news:news>"
        except ValueError:
            stale = "  <-- unparseable date"
    print(f"{pub}  {loc}{stale}")

Count <news:news> tags (stay under 1,000)

A quick regex-style count to confirm you’re under the per-file cap. It counts opening <news:news> tags, so it won’t double-count the closing tags:

# Count of <news:news> opening tags — must be <= 1000 per file
grep -o "<news:news>" news-sitemap.xml | wc -l

If that number climbs toward 1,000, split into multiple news sitemaps and reference them from a sitemap index.

Reference it in robots.txt

Point engines at the news sitemap the same way you would any sitemap — a Sitemap: line with the full absolute URL:

User-agent: *
Allow: /

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

Then submit that same URL in the Google Search Console Sitemaps report.

Chrome DevTools Console: audit a live news sitemap

Paste this into the DevTools Console on the sitemap’s own URL (so it’s same-origin and readable). It reports the article count and flags any entries older than two days:

// Run this in the Console while viewing your news-sitemap.xml URL directly.
(async () => {
  const xml = await (await fetch(location.href)).text();
  const doc = new DOMParser().parseFromString(xml, "application/xml");
  const NEWS = "http://www.google.com/schemas/sitemap-news/0.9";
  const urls = [...doc.getElementsByTagName("url")];
  const cutoff = Date.now() - 2 * 24 * 60 * 60 * 1000;
  let stale = 0;
  urls.forEach((u) => {
    const loc = u.getElementsByTagName("loc")[0]?.textContent;
    const date = u.getElementsByTagNameNS(NEWS, "publication_date")[0]?.textContent;
    const old = date && Date.parse(date) < cutoff;
    if (old) { stale++; console.warn("Older than 2 days:", loc, date); }
  });
  console.log(`Articles: ${urls.length} (cap 1000). Older than 2 days: ${stale}.`);
})();

If it reports more than 1,000 articles or any stale entries, your generator isn’t pruning correctly.

Routine maintenance: keeping a news sitemap healthy

A news sitemap isn’t a set-it-and-forget-it file — the two-day freshness rule means it needs recurring upkeep. Two procedures cover it: a daily prune (the core maintenance task) and a periodic health check (catching drift before it causes problems).

Daily: prune articles past the two-day window

Run this every day, ideally as part of your publishing pipeline rather than a manual step.

1. Pull the current news sitemap. Fetch the live file (or query your CMS’s news sitemap generator directly if it’s dynamically built).
2. Compare each <news:publication_date> against the two-day cutoff. Anything with a publish time older than ~48 hours is out of window. Done looks like: every remaining entry has a <news:publication_date> inside the last two days.
3. Remove or strip each stale entry. Either delete the <url> block entirely or keep the <loc> and remove just its <news:news> block. Done looks like: the regenerated file has zero entries older than two days.
4. Confirm the article is still otherwise indexed. Pruning from the news sitemap is not deindexing — spot-check that a recently-pruned URL still returns 200 and is still in your regular sitemap. Done looks like: the URL is absent from the news sitemap but present in the general sitemap / index as expected.
5. Leave it empty if there’s nothing to list. If you haven’t published in the last two days, ship the empty file rather than padding it with stale entries. Done looks like: a valid, empty <urlset> — an “Empty Sitemap” warning in Search Console is expected and not an error to chase.

Weekly (or per-deploy): structural health check

1. Validate the XML. Run it through an XML well-formedness check (see the Scripts tab) or the sitemap-validator tool at /tools/sitemap-validator. Done looks like: no parse errors.
2. Count <news:news> tags. Confirm the file is under the 1,000-tag cap. Done looks like: count comfortably below 1,000 (if you’re routinely close, plan a sitemap-index split before you hit it, not after).
3. Scan for dead tags. Grep for news:keywords, news:stock_tickers, or genre tags creeping back in from a plugin update or template change. Done looks like: zero matches.
4. Check Search Console’s Sitemaps report. Confirm the file is still being read without errors and note the submitted-vs-indexed trend. Done looks like: no new warnings since the last check, and indexed count roughly tracking submitted count.
5. Verify the robots.txt reference is still correct. Confirm the Sitemap: line still points at the live, absolute URL of the news sitemap (URLs change more often than people expect after a domain or path migration). Done looks like: the URL in robots.txt returns 200 and matches the file you’re actually maintaining.

Tools for building and maintaining a news sitemap

This site’s tools

• /tools/sitemap-validator — check that your news sitemap XML is well-formed and structured correctly before you submit it. Use it after any template or plugin change, not just once at launch.
• /tools/xml-sitemap-generator — useful if you’re building a sitemap from a URL list and need the base <urlset> structure right, before layering the news: namespace on top.
• /tools/news-seo-checker — checks news-specific SEO signals on an article (the eligibility side this article deliberately doesn’t cover) — pair it with a valid news sitemap rather than treating either alone as sufficient.
• /tools/robots-txt-tester and /tools/robots-txt-generator — confirm your Sitemap: line is present and correctly formed, or generate one if you’re setting this up from scratch.
• /tools/gsc-workbench — for digging into Search Console sitemap and indexing data beyond what the standard UI surfaces.

Third-party tools

• Google Search Console — the only place to actually submit the news sitemap and see its submitted-vs-indexed numbers and any parsing warnings.
• Bing Webmaster Tools (PubHub) — Bing’s manual news-submission path, since there’s no news: namespace for Bing to read from a sitemap.
• Screaming Frog — can crawl and validate a news sitemap’s XML structure at scale if you’re auditing a large publisher’s setup.

Confirming a news sitemap change actually took effect

The XML is well-formed and correctly nested

• Test to run: xmllint --noout news-sitemap.xml (or the sitemap-validator tool at /tools/sitemap-validator) against the live file.
• Expected result: No parse errors; the validator confirms <news:news> sits once per <url> with <news:publication> → <news:name>/<news:language> correctly nested inside.
• Failure interpretation: A parse error usually means an unescaped character or mismatched tag; a structural flag usually means the nesting is wrong (most common: a stray top-level <news:news> wrapper).
• Monitoring window: Immediate — this is a static check, run it right after any template or generator change.
• Rollback trigger: Any parse error, or any <news:news> block not nested exactly as Google’s spec shows.

The sitemap is reachable and referenced correctly

• Test to run: curl -I https://yoursite.com/news-sitemap.xml for a 200, plus a check that robots.txt contains the matching Sitemap: line.
• Expected result: 200 status on the sitemap URL; the robots.txt Sitemap: line matches that exact absolute URL.
• Failure interpretation: A non-200 means the file moved or broke; a missing or stale robots.txt line means engines may not discover the file on their own.
• Monitoring window: Immediate.
• Rollback trigger: Non-200 response, or a robots.txt mismatch.

Search Console accepts the sitemap without errors

• Test to run: Submit (or re-check) the sitemap in the Google Search Console Sitemaps report.
• Expected result: Status reads “Success,” with a submitted count that’s non-zero (or an acknowledged, intentional “Empty Sitemap” state) and no parsing warnings.
• Failure interpretation: A “Couldn’t fetch” or “Has errors” status usually traces back to the well-formedness or namespace checks above.
• Monitoring window: Check within a day of submission; Search Console typically reprocesses a resubmitted sitemap within hours.
• Rollback trigger: Persistent fetch or parsing errors after a re-check.

Pruning is working — no stale entries slip through

• Test to run: Run the DevTools Console snippet or the Python script from the Scripts tab against the live file to flag any <news:publication_date> older than two days.
• Expected result: Zero entries flagged as stale.
• Failure interpretation: Any flagged entry means your prune job didn’t run, ran against the wrong file, or the publish-date field is being read incorrectly.
• Monitoring window: Daily, since the two-day window is a moving target.
• Rollback trigger: Any article older than two days still carrying a <news:news> block.

The tag count stays under the 1,000 cap

• Test to run: grep -o "<news:news>" news-sitemap.xml | wc -l.
• Expected result: A count comfortably below 1,000.
• Failure interpretation: A count approaching or exceeding 1,000 means you need a sitemap-index split before Google starts rejecting entries past the limit.
• Monitoring window: Weekly, or immediately after a spike in publishing volume.
• Rollback trigger: Count at or above 1,000 with no split in place.

The standing KPIs for a news sitemap

Submitted vs. indexed count (Search Console)

• What it tells you: Whether Google is actually reading and using the URLs you list, not just accepting the file.
• How to pull it: Google Search Console → Sitemaps report → click the sitemap → compare “Discovered” against indexed status for those URLs.
• Benchmark / realistic range: Depends heavily on publishing volume and content quality — there’s no universal healthy percentage. Watch for a large, sustained gap between discovered and indexed as the signal worth investigating, not a specific number.
• Cadence: Weekly.

Time from publish to first crawl

• What it tells you: Whether the news sitemap is actually delivering its one benefit — faster discovery of breaking content — versus just existing as a formality.
• How to pull it: Compare your article’s publish timestamp against its first crawl timestamp in server logs (via the log-file-analyzer tool at /tools/log-file-analyzer) or against the “last crawled” data available through Search Console’s URL Inspection tool.
• Benchmark / realistic range: Depends on your site’s overall crawl frequency and authority — establish your own baseline by measuring this for a handful of recent articles rather than assuming an industry figure.
• Cadence: Spot-check monthly, or immediately after a breaking story where speed actually mattered.

<news:news> tag count vs. the 1,000 cap

• What it tells you: How much headroom you have before you’re forced into a sitemap-index split.
• How to pull it: grep -o "<news:news>" news-sitemap.xml | wc -l (see the Scripts tab), run as part of your regular health check.
• Benchmark / realistic range: Should track your publishing rate — most single-site publishers stay well under 1,000 unless publishing 500+ articles a day in a rolling two-day window.
• Cadence: Weekly, or after any known spike in publishing volume.

Stale-entry count (articles past the two-day window)

• What it tells you: Whether your pruning process is actually running on schedule.
• How to pull it: The DevTools Console snippet or Python script from the Scripts tab, checking every <news:publication_date> against the two-day cutoff.
• Benchmark / realistic range: Should be zero at all times — this isn’t a range, it’s a pass/fail check. Any non-zero count means the prune job missed a run.
• Cadence: Daily (ideally automated as part of the publishing pipeline).

Test yourself: News Sitemaps

Five quick questions on how news sitemaps work. Pick an answer for each, then check.

Resources worth your time

My related writing

• The Beginner’s Guide to Technical SEO — where sitemaps and discovery sit in the bigger picture.
• When Should You Worry About Crawl Budget? — why fast discovery matters and where clean sitemaps fit into crawl efficiency.
• Enterprise Technical SEO — the automate-it-or-it-rots posture that a news sitemap especially depends on (it has to prune itself every two days).

My speaking

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

From around the industry

• Google — Create a News Sitemap — the authoritative spec for the news: namespace, tags, the two-day window, and the 1,000-URL cap.
• Google SEO Tips For News Articles: Lastmod Tag, Separate Sitemaps (Search Engine Journal) — Gary Illyes on keeping news and web sitemaps separate and pruning old URLs.
• Google News May No Longer Support Stock Tickers & Genre (Search Engine Roundtable) — corroborates the 2018 deprecation of the old news tags.
• Rank Math — Working With the News Sitemap — a WordPress-side implementation walkthrough that confirms genre/stock-ticker/keyword removal from the plugin itself.
• State of Digital Publishing — News Sitemap module — a clear publisher-focused breakdown that makes the “discovery, not rankings” point explicitly.
• Bing — PubHub Publisher Guidelines — the manual news-submission model Bing uses in place of a news: sitemap namespace.

News sitemap

A news sitemap is a sitemap (a standalone file or a section of an existing sitemap) that uses Google's news: XML namespace to tell Google about your recent articles — only those published in the last two days. It speeds discovery of breaking content; it isn't a ranking factor and isn't required for Google News eligibility.

Related: Sitemap, XML sitemap, Google News SEO

News sitemap

A news sitemap is a regular XML sitemap extended with Google’s news: namespace, used to tell Google specifically about your recent news articles. Structurally it’s an ordinary <urlset> where each <url> carries a <news:news> block containing the publication name and language, the original publication date, and the article title. You can put those tags in a standalone file reserved for news, or add them to a section of a sitemap you already have — Google accepts both, though a separate file gives you cleaner tracking in Search Console.

What makes it different from a standard XML sitemap is the freshness window. Google says to only include articles created in the last two days (commonly shorthanded as 48 hours); once articles are older than that, you either remove the URL from the news sitemap or strip the <news:news> metadata from it. A news sitemap is also capped at 1,000 <news:news> tags per file — much stricter than the 50,000-URL limit on ordinary sitemaps — and you split past that with a sitemap index.

A news sitemap is not a ranking factor and it doesn’t grant Google News eligibility; that comes from complying with Google’s content policies, not from the sitemap. It only speeds up discovery of content Google can already find. The old news:keywords, news:stock_tickers, and genre tags were dropped by Google in 2018 and aren’t part of the current schema, and you don’t need to register anything in Google Publisher Center for a correctly formatted news sitemap to work.

Related: Sitemap, XML sitemap, Google News SEO