RSS to JSON Converter Online — Free Feed Parser

Parse RSS 2.0 and Atom 1.0 feeds into clean, normalised JSON — channel metadata, items, dates, and enclosures. 100% in your browser, no upload.

RSS / Atom XML Input

JSON Output

What is an RSS to JSON Converter?

An RSS to JSON converter parses an RSS 2.0 or Atom 1.0 feed and emits a normalised JSON document with channel metadata and an array of items. It auto-detects the format, reads each item's title, link, description, publication date, GUID, and any enclosure (the audio file in a podcast feed) — flattening two different XML dialects into one clean JSON shape your code can consume without branching.

RSS and Atom dominate syndication: every blog, podcast, and news site publishes one. Their XML is verbose and namespaced, and the two specs disagree on field names — RSS says description, Atom says summary; RSS says pubDate, Atom says updated. The OpenFormatter converter normalises both into a single JSON shape, runs in your browser with the native DOMParser, and never sends your feed XML over the network.

How to convert RSS to JSON online — 4 steps

Paste the feed XML. Drop the RSS or Atom feed source — exported from your CMS, captured by curl, or copied from view-source — into the Input panel.
Click Convert. The browser parses the XML, detects RSS vs Atom, and walks the channel/feed and items/entries.
Inspect the JSON. You get top-level format, title, link, description, count, and an items array — each with title, link, pubDate, guid, optional enclosure.
Use the JSON. Drop it into a JavaScript fetch wrapper, an API mock, a static-site build script, or a podcast aggregator backend.

Sample RSS feed and JSON output

A two-item RSS 2.0 channel showing how items, dates, GUIDs, and enclosures map into the JSON shape.

RSS input

<rss version="2.0">
  <channel>
    <title>OpenFormatter Blog</title>
    <link>https://openformatter.com/blog</link>
    <item>
      <title>Why JSON Matters</title>
      <link>https://openformatter.com/...</link>
      <pubDate>Mon, 28 Apr 2026 09:00:00 GMT</pubDate>
      <guid>https://openformatter.com/...</guid>
    </item>
  </channel>
</rss>

JSON output

{
  "format": "rss",
  "title": "OpenFormatter Blog",
  "link": "https://openformatter.com/blog",
  "count": 1,
  "items": [
    {
      "title": "Why JSON Matters",
      "link": "https://openformatter.com/...",
      "pubDate": "Mon, 28 Apr 2026 ...",
      "guid": "https://openformatter.com/..."
    }
  ]
}

RSS & Atom in One

Auto-detects RSS 2.0 (item, description, pubDate) and Atom 1.0 (entry, summary, updated), normalising both into a single JSON shape your consumer code never has to branch on.

Enclosure Support

Podcast feed enclosures are captured as nested objects with url, length, and type — drop them straight into a podcast player UI or download script.

Client-Side Only

Feed XML is parsed in JavaScript on your machine. Authenticated CMS exports, draft podcast feeds, and internal newsletters never leave the device.

Common use cases

check_circleBuilding a custom blog reader or news aggregator that consumes feeds as JSON in JavaScript
check_circlePowering a static site generator that pulls feed items at build time and renders them as HTML
check_circleInspecting a podcast feed before publishing, to verify enclosures, GUIDs, and pubDates are correct
check_circleWriting a feed health-monitor that ingests RSS as JSON and alerts when items stop appearing
check_circleConverting a WordPress, Ghost, or Hugo RSS export into JSON for migration to a new CMS
check_circleMocking RSS API responses in unit and integration tests with predictable JSON fixtures
check_circlePulling competitive content streams (RSS) into BI dashboards via JSON for tracking and analysis
check_circleBuilding a Slack / Discord bot that posts new blog or podcast entries from RSS as JSON-driven messages

RSS 2.0 vs Atom 1.0 — what changes

RSS 2.0 is older and looser — it uses <item>, <description>, <pubDate> (RFC 822 dates), and a free-form <guid>. Atom 1.0 is newer and stricter — it uses <entry>, <summary>, <updated> (RFC 3339 dates), and a URI <id>. Most blogs and podcasts publish RSS 2.0; most newer sources (and some Google services) prefer Atom. The OpenFormatter converter detects which one you pasted and emits the same JSON shape either way — your downstream code stays simple.

More feed and XML tooling?

Format JSON, validate XML, or convert XML to other formats — all browser-side.

JSON Formatter XML Validator XML to JSON

Frequently Asked Questions

Does the converter support both RSS 2.0 and Atom 1.0?

Yes. The parser auto-detects the format: if it finds <item> elements (RSS 2.0), it reads description, link, pubDate, and guid. If it finds <entry> elements (Atom 1.0), it reads summary, link href, updated, and id. Both are normalised into the same JSON shape with description, link, pubDate, and guid keys — your downstream code does not need to branch on the format.

How are pubDate fields formatted in the JSON output?

The original date string is preserved verbatim in the JSON. RSS 2.0 uses RFC 822 ("Mon, 28 Apr 2026 09:00:00 GMT") and Atom 1.0 uses RFC 3339 ("2026-04-28T09:00:00Z"). The converter does not normalise to a single format — that would risk losing time-zone fidelity. Parse the string in your code with new Date() (which accepts both) or with a library like date-fns or Luxon.

What about RSS enclosure elements (podcasts, attachments)?

RSS enclosures — used by every podcast feed — are surfaced as a JSON object with url, length (in bytes), and type (MIME) keys nested under the item. So your podcast item gains an enclosure: { url: "...", length: "12345678", type: "audio/mpeg" } property. Items without an enclosure simply omit the field, keeping the JSON tidy.

Are namespaced elements like itunes:* preserved?

The current converter focuses on the standard RSS / Atom fields and exposes enclosure attributes. Custom namespace elements (itunes:duration, itunes:author, media:content) are not surfaced as top-level keys — for full namespace handling, use the XML to JSON converter, which preserves all elements verbatim with namespace prefixes.

Can I fetch a live RSS URL with this tool?

No — the tool works with XML you paste directly. Fetching a feed from a remote URL would require either a CORS-permissive feed host or a server-side proxy, which would defeat the privacy benefit of running locally. To grab a feed, run "curl https://example.com/feed.xml" in a terminal, copy the output, and paste it here.

How are items with multiple <link> elements (Atom) handled?

For Atom feeds the converter takes the first <link> element and prefers its href attribute (the canonical web link). Atom self-link, alternate-link, and related-link distinctions are flattened to a single string. If you need all link relations, run the input through the XML to JSON converter to keep every <link> element with its rel attribute.

Does the conversion send the feed XML to a server?

No. Parsing happens via the browser's built-in DOMParser entirely on your machine — the XML you paste never leaves the browser. Internal feeds, draft podcast XML, and authenticated feed exports stay private. Open DevTools → Network and click Convert — there are no requests.

What does the output look like?

A top-level object with format ("rss" or "atom"), title, link, description, count (number of items), and an items array. Each item has title, link, description, pubDate, guid, and optionally an enclosure object. The shape is consistent across RSS and Atom feeds, so a single mapping function in your code handles both.