Skip to content

New RSS posts disappear because the feed reuses a GUID

Inspect RSS item identities when new posts are missed or old posts reappear, repair GUID generation, and verify stable item-to-article mappings across updates.

By Crawlito · 5 min read

In short

  • An RSS item's GUID identifies the item rather than the current position in the feed.
  • Reusing one identity for different posts can confuse consumers that deduplicate items.
  • Keep a post's identity stable across ordinary edits and distinct from other posts.
On this page

If a new RSS post appears in the XML but a feed reader treats it as an old item, inspect the item's GUID. A generator that reuses an identifier across different posts can confuse consumers that track item identity. Repair the identity mapping, then verify that new posts get distinct identifiers while ordinary edits preserve the existing post's identity.

A valid XML document is not enough. The feed can parse correctly and still describe different articles as the same item.

Compare the feed item with the article

Download the public feed and find the missing post by title or link. Record its GUID, link, title, and publication date.

The RSS 2.0 specification defines guid as an item identifier and describes the isPermaLink attribute. A GUID is not simply the item's current list position or the feed generation time.

Check whether another item has the same value. Also compare an older saved feed if available. The collision may occur across different publications even when only one of them remains in the current feed window.

Do not assume every reader handles the conflict identically. Reproduce the actual consumer's behavior and use the identifier collision as a concrete publishing defect.

The RSS discovery guide covers general feed publication. This guide focuses on identity across items and updates.

Look for unstable or reused generators

Inspect the code or CMS mapping that produces the GUID. Common hypothetical mistakes include using an array index, a shared category ID, or the same hard-coded value in every item.

A different failure uses the build time as each item's identity. Then an ordinary deployment can make old articles appear new to a consumer that tracks GUIDs.

Create a mapping sample:

ArticleFirst publication GUIDAfter ordinary edit
First guideStable identity ASame identity A
Second guideDistinct identity BSame identity B
New guideNew identity CSame identity C

These labels illustrate the requirement, not values to copy into a production feed.

Use a stable content identifier or the site's deliberate permalink-based design. The best choice depends on how your CMS handles URL changes and content migrations.

Do not change every existing GUID casually. That can cause consumers to treat the whole archive as newly published.

If the GUID is an opaque identifier rather than a navigable URL, set its meaning according to the RSS specification. Do not leave a consumer to interpret an internal database token as a public permalink.

If your design uses the article URL as the GUID, confirm that it is the intended public address and remains stable under ordinary content updates.

An illustrative opaque identifier is:

xml
<guid isPermaLink="false">urn:example:article:4821</guid>
<link>https://www.example.com/blog/setup-guide</link>

The value is an example of a relationship, not a universal naming scheme.

Keep the link and identity roles distinct. The link tells readers where to open the content; the GUID tells a consumer which item this is.

The canonical URL guide can help align public destinations, but a canonical tag on the article does not repair a reused feed identifier.

Repair the source mapping with migration awareness

Fix the generator that assigns identity to new items. Preserve existing correct identifiers where possible.

For collided historical items, decide a scoped correction with awareness that consumers may have stored the old identity. Document which items need new distinct values and why.

Do not reset all publication dates to today as part of the repair. That changes another signal and can make the timeline misleading.

If the problem came from a CMS import, compare source IDs and destination IDs. A migration that renumbered records may need a stable mapping rather than exposing the new database sequence as a replacement for every public identity.

Keep a before and after feed artifact. It should show which identifiers changed and which remained stable.

For agencies, the deliverable should be a clear identity contract and a tested example, not just “feed validates.”

Parse the published feed and find collisions

A small read-only check can flag repeated GUIDs in the current RSS file:

python
from collections import Counter
import xml.etree.ElementTree as ET

root = ET.parse("feed.xml").getroot()
values = [
    item.findtext("guid", default="").strip()
    for item in root.findall("./channel/item")
]
print({value: count for value, count in Counter(values).items()
       if value and count > 1})

This checks the current file only. It cannot identify a value reused for an item that has already left the feed window, so keep historical comparison evidence where relevant.

Also inspect missing GUIDs and links according to the feed's intended contract. Do not automatically infer a collision from a blank optional field without reviewing the rest of the item and consumer behavior.

Verify that the public file is the newly generated version, not an older cached response.

Test publication and ordinary edits separately

Publish a controlled test item through the normal workflow and observe its distinct identity. Then edit that same item without creating a new article.

Confirm that its identity remains stable and its content fields update as intended. Next publish a second item and verify that it receives a different identity.

Test with the actual reader or consumer that exposed the issue, using a controlled subscription where practical. A fresh subscription and an existing subscription can behave differently because one has history.

Do not claim that every subscriber immediately receives a corrected item. Consumers have their own polling and retention behavior.

The content freshness guide helps keep a substantive update distinct from a new publication. Feed identity should reflect that editorial distinction.

Include feed identity in future migrations

When changing CMS, route structure, or feed plugins, preserve a sample of existing item identities and their public destinations.

Check the first feed generated by the new system before announcing the move. A visually identical blog can still republish every item under a new identity.

Keep the feed's stable public URL and redirect behavior deliberate as well. A correct item mapping inside an undiscoverable feed does not help existing subscribers.

For reporting, separate three observations: the feed parses, item identities are coherent, and the tested consumer shows the expected result. Each adds evidence without implying universal delivery.

Document the mapping owner so future developers know that GUID stability is part of the publishing contract rather than an arbitrary implementation detail.

Check category feeds as well as the main feed if they are generated from the same records. The same article appearing in several feeds is different from two distinct articles accidentally sharing one identity within a feed. Decide how the publishing system represents that relationship, then test the output consistently.

For a migration rehearsal, choose an unchanged article, an edited article, and a newly published article. Compare each record's GUID before and after the change rather than comparing only feed order. Sorting can move an item without changing its identity. Likewise, an updated title does not establish that a new item has been created. A small record-by-record comparison provides stronger evidence than a screenshot of a reader's latest-items list.

Frequently asked questions

Is a GUID the same as the item's title?

No. Titles can change or repeat. Use a deliberate stable identity for the item.

Should editing an article create a new GUID?

Not for an ordinary update to the same item under a stable-identity design. Keep new publication and revision distinct.

Does a collision check prove every reader has updated?

No. It verifies the published feed's current identities. Consumer processing needs separate observation.

Use the free Crawlito check on a newly published article after confirming that its feed item has a distinct, stable identity.

Filed under Structure and schema. Topics: rss, content-discovery, troubleshooting