About

RSS and Atom remain the backbone of structured content syndication. Roughly 60% of news organizations still publish feeds, yet most browsers dropped native reader support after 2013. This tool parses raw XML feeds client-side, converts them to normalized JSON objects, and renders articles in a scannable interface. It handles both RSS 2.0 (channel → item) and Atom 1.0 (feed → entry) schemas. Feeds are fetched through a CORS proxy since browser same-origin policy blocks direct cross-domain XML requests. Parsed data is cached in LocalStorage with a 10-minute TTL to reduce redundant network calls.

Misconfigured feed URLs or malformed XML silently fail in most readers, leaving users staring at blank screens. This reader validates XML structure before parsing and surfaces specific error diagnostics. Image extraction follows a priority chain: enclosure → media:content → media:thumbnail → inline img tag in description. Note: some publishers serve partial content in feeds. The tool displays whatever the feed provides and cannot fetch full articles behind paywalls.

Formulas

The reader converts XML feed data into a normalized JSON structure. The parsing pipeline follows this transformation chain:

feedURL → CORSProxy(url) → fetch() → xmlText → DOMParser() → xmlDoc → normalize() → JSON

The CORS proxy wraps the target URL:

proxyURL = "https://api.allorigins.win/raw?url=" + encodeURIComponent(feedURL)

Cache validation uses a time-to-live check:

isCacheValid = (Date.now() − lastFetched) < TTL

where TTL = 600000 ms (10 min).

Output JSON schema per item:

{ title: String, link: String, description: String, pubDate: Date, source: String, image: String | NULL }

Feed type detection logic:

{

RSS 2.0 if querySelector("rss") ≠ NULLAtom if querySelector("feed") ≠ NULLRDF if root tagName contains "RDF"

Reference Data

Feed Format	Root Element	Item Element	Title Path	Link Path	Date Path	Description Path	Image Source	Spec Year	MIME Type
RSS 2.0	rss → channel	item	title	link	pubDate	description	enclosure @url	2009	application/rss+xml
RSS 1.0 (RDF)	rdf:RDF	item	title	link	dc:date	description	None standard	1999	application/rss+xml
Atom 1.0	feed	entry	title	link @href	updated / published	summary / content	None standard	2005	application/atom+xml
JSON Feed 1.1	items array	object in array	title	url	date_published	content_html	image	2021	application/feed+json
Common Feed Sources
BBC News	http://feeds.bbci.co.uk/news/rss.xml		RSS 2.0		~50 items		Media thumbnails via media:thumbnail
Reuters	https://www.reutersagency.com/feed/		RSS 2.0		~20 items		Enclosure images
TechCrunch	https://techcrunch.com/feed/		RSS 2.0		~20 items		Inline img in content
Hacker News	https://hnrss.org/frontpage		RSS 2.0		~30 items		No images
NASA	https://www.nasa.gov/rss/dyn/breaking_news.rss		RSS 2.0		~10 items		Enclosure images
NPR News	https://feeds.npr.org/1001/rss.xml		RSS 2.0		~15 items		Media content
The Verge	https://www.theverge.com/rss/index.xml		Atom 1.0		~20 items		Inline img in content
Ars Technica	https://feeds.arstechnica.com/arstechnica/index		RSS 2.0		~25 items		Media thumbnail
Reddit (any sub)	https://www.reddit.com/r/{sub}/.rss		Atom 1.0		~25 items		Inline img in content
Dev.to	https://dev.to/feed		RSS 2.0		~30 items		No images typically

Frequently Asked Questions

Most failures stem from CORS restrictions. Browsers block cross-origin XML requests by default. This tool routes requests through a public CORS proxy (allorigins.win). If the proxy itself is down or rate-limited, the fetch fails. Some publishers also block proxy IP ranges. Try the feed URL directly in a browser tab first - if it returns XML, the proxy is likely the bottleneck. The tool automatically attempts a fallback proxy if the primary one fails.

RSS 2.0 wraps items in with dates in RFC 822 format (pubDate). Atom 1.0 uses with ISO 8601 dates (updated/published) and stores links as attributes ( rather than element text). The parser detects the root element type and branches into format-specific extraction logic. Both are normalized to identical JSON objects for uniform rendering.

DOMParser returns a document with a element when XML is invalid. The reader checks for this element immediately after parsing. Common causes include unescaped ampersands (&) in URLs, unclosed tags, or encoding mismatches. The tool reports the specific parser error message rather than silently failing. Some feeds serve XHTML content inside CDATA blocks - the parser handles these correctly by extracting text content.

The extraction follows a four-step priority chain. First: element with type containing "image". Second: or elements (common in BBC, NPR feeds). Third: parsing the description/content HTML to find the first tag's src attribute. Fourth: checking for (podcast feeds). If none yield a result, the item renders without an image. Image URLs are validated to start with http:// or https://.

Yes. Feed URLs and their parsed content are stored in LocalStorage, which persists until manually cleared. Each feed entry includes a lastFetched timestamp. On reload, the reader checks if the cache age exceeds 10 minutes (600,000 ms). If valid, cached data renders instantly without network requests. You can force a refresh by clicking the refresh button on any feed, which bypasses the TTL check.

The parser processes all items the feed provides, but rendering is virtualized - only visible items are in the DOM. Most feeds serve 10-50 items by default. Feeds like Reddit or large news sites may return up to 100. Performance remains smooth because the parser runs synchronously for typical payloads (under 500KB of XML). For feeds exceeding this, consider that the bottleneck is typically the CORS proxy transfer speed, not parsing time.

The tool normalizes heterogeneous feed formats into a single consistent schema. RSS uses pubDate (RFC 822), Atom uses updated (ISO 8601), RDF uses dc:date - all are converted to ISO 8601 strings. Link extraction varies: RSS uses element text, Atom uses href attribute, some feeds use guid. The normalized JSON always provides title, link, description (HTML-stripped), pubDate, source (feed title), and image (nullable). This makes the JSON consumable by any downstream application without format-specific handling.