RSS Feed to JSON Parser — XML, Atom & JSON Feed Converter

Fetch and parse RSS 2.0, Atom, and JSON Feed formats into plain JSON. Handles single feeds or batch runs of up to 20 at a time, with optional health checks on each feed. Every item in the feed becomes its own row in the output dataset.

Built with async HTTPX for fetching and Python's built-in ElementTree for XML. No Playwright, no browser automation, no third-party feed libraries — just httpx and the standard library.

---

What does it do?

Give it a feed URL (or a list of them). It fetches the content, works out whether it's RSS, Atom, or JSON Feed, parses every item, and writes each one to the dataset as a clean JSON row. If you turn on health validation, it also checks for empty feeds, stale content, missing titles or links, and HTTP errors.

---

Features

1. Auto-detects the format — Tells RSS 2.0, RSS 1.0/RDF, Atom, and JSON Feed apart from the content itself
2. RSS 2.0 parsing — Title, link, description, pubDate, author, categories, GUID, comments, enclosures (URL, type, length)
3. Atom parsing — Entry title, link, summary, content, published/updated dates, structured authors, categories, enclosure links
4. JSON Feed support — Version 1.x with authors, tags, content_text, content_html
5. Batch mode — Up to 20 feeds in one run, fetched concurrently (up to 5 at a time)
6. Feed health validation — Optional checks: empty feeds, no updates in 30+ days, missing titles or links, HTTP errors, parse errors
7. HTTP metadata — Status code, content type, fetch duration per feed
8. Error isolation — If one feed fails, the others keep going
9. No external feed parsers — No feedparser dependency; just httpx and ElementTree
10. One row per item — Every feed item becomes its own dataset row, tagged with the source feed's URL and title

---

Why use this?

Problem	How this helps
Raw XML feeds are fiddly to deal with	Auto-detects the format and gives you clean JSON
feedparser has heavy install requirements	Pure httpx + ElementTree — no tricky dependencies
Need to watch feed health across many sources	Built-in health checks for stale, empty, or broken feeds
Checking feeds manually doesn't scale	Batch mode processes up to 20 feeds at once
Different feed formats need different parsers	Auto-detection handles RSS, Atom, and JSON Feed transparently
Want feed items to feed into a downstream pipeline	Structured JSON pushed straight to the Apify dataset

---

Who is it for?

Persona	What they use it for
Content curator	Aggregate articles from multiple blog feeds for newsletters
Data analyst	Collect feed metadata for trend analysis across publications
Developer	Parse feeds as a data source for apps and dashboards
Marketing manager	Monitor competitor blogs and industry news feeds
Researcher	Gather publication metadata from academic RSS and Atom feeds
Podcast producer	Extract episode metadata from podcast RSS feeds with enclosures
News aggregator operator	Ingest multiple news feeds into a central pipeline

---

Input Parameters

Field	Type	Required	Default	Description
mode	string	Yes	single	single or batch
feed_url	string	If mode=single	—	Full URL to the RSS/Atom/JSON Feed
feed_urls	array of strings	If mode=batch	[]	List of feed URLs (max 20)
validate_health	boolean	No	false	Turn on feed health validation

Example Input — Single Mode

{
  "mode": "single",
  "feed_url": "https://example.com/blog/feed.xml",
  "validate_health": true
}

Example Input — Batch Mode

{
  "mode": "batch",
  "feed_urls": [
    "https://example.com/blog/feed.xml",
    "https://example.org/rss"
  ],
  "validate_health": true
}

---

Output Format

Each dataset row represents one item from a parsed feed. The fields that appear depend on the feed format because the actor keeps each format's original field names — it doesn't rename them to a common set.

Fields present on every row

Field	Type	Description
source_url	string	The original feed URL
feed_title	string	Title of the source feed
feed_type	string	Detected format: rss, atom, or json_feed

Fields by format

RSS 2.0 items include: title, link, description, content_encoded, pub_date (ISO 8601), author, creator, guid, guid_is_permalink, comments, categories (array), enclosure_url, enclosure_type, enclosure_length.

Atom items include: title, link, summary, content, published (ISO 8601), updated (ISO 8601), id, authors (array of objects with name/email/uri), categories (array), enclosure_url.

JSON Feed items include: title, link, summary, content_text, content_html, published (ISO 8601), updated (ISO 8601), id, authors (array of objects with name/url/avatar), tags (array).

Feed-level metadata rows

When a feed has zero items, the actor pushes a metadata row instead, with:

Field	Type	Description
item_count	integer	Always 0 for empty feeds
http_status	integer	HTTP status code from the fetch
error	string	Error message if the feed couldn't be parsed
health_status	string	healthy, warning, unhealthy, unreachable, or unknown
health_issues	array	List of health issues found

Health validation status values

• healthy — No issues found
• warning — 1–2 minor issues (empty feed, stale content)
• unhealthy — 3+ issues
• unreachable — Couldn't connect or got a non-200 response
• unknown — Health validation was not requested

Example Output — RSS item

{
  "source_url": "https://example.com/blog/feed.xml",
  "feed_title": "Example Blog",
  "feed_type": "rss",
  "title": "Getting Started with RSS Feed Parsing",
  "link": "https://example.com/blog/rss-parsing",
  "description": "Learn how RSS feed parsing works.",
  "pub_date": "2026-07-01T12:00:00+00:00",
  "author": "John Doe",
  "categories": ["tutorials", "rss"],
  "guid": "https://example.com/blog/rss-parsing",
  "enclosure_url": "https://example.com/podcast/episode42.mp3",
  "enclosure_type": "audio/mpeg"
}

---

API Usage

cURL

curl -X POST "https://api.apify.com/v2/acts/perryay~rss-feed-to-json-parser/runs" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "single",
    "feed_url": "https://example.com/blog/feed.xml"
  }'

Python (ApifyClient)

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("perryay/rss-feed-to-json-parser").call(
    run_input={
        "mode": "single",
        "feed_url": "https://example.com/blog/feed.xml",
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
for item in items:
    print(f"{item['title']} ({item.get('pub_date', item.get('published', ''))})")

---

Use Cases

1. Content Aggregation

Pull articles from 20+ blog feeds into a single dataset for newsletters, recommendation engines, or social media scheduling.

2. Feed Health Monitoring

Check your own feeds and partner feeds regularly to catch broken XML, expired SSL certificates, or stale content before anyone notices.

3. Podcast Episode Indexing

Parse podcast RSS feeds to pull out episode metadata — enclosures, titles, dates — for a searchable directory.

4. News API Feed Layer

Use the actor as an ingestion step: parse multiple news feeds, push items to the Apify dataset, and serve the structured data via the Apify API to a frontend.

5. Academic Research

Collect publication metadata from journal RSS feeds, conference Atom feeds, and preprint servers for bibliometric analysis.

6. SEO Content Analysis

Monitor competitor blogs by periodically fetching their feeds and analysing publishing frequency, topics, and content structure.

7. Social Media Cross-Posting

Parse a blog feed and use the structured items to trigger auto-posting to social media platforms.

8. Archival & Backup

Periodically archive feed content into datasets to keep a historical record of publications, even if the original feed goes offline.

---

FAQ

1. What feed formats are supported?

RSS 2.0, RSS 1.0/RDF (detected via <rdf:RDF>), Atom, and JSON Feed (version 1.x). The format is detected automatically from the content — you don't need to tell it what to expect.

2. Does this use feedparser or any other external feed library?

No. It uses Python's built-in ElementTree for XML and httpx for HTTP requests. No feedparser dependency.

3. What's the maximum batch size?

Up to 20 feeds per run. They're fetched concurrently, up to 5 at a time.

4. How are dates handled?

Dates are parsed from RFC 2822 (common in RSS) and ISO 8601 (common in Atom and JSON Feed), then converted to ISO 8601 format. RSS dates end up in the pub_date field; Atom and JSON Feed dates use the published field.

5. What does feed health validation check?

• Empty feed (zero items)
• Missing title or link
• Content not updated in more than 30 days
• HTTP errors during fetch
• Parse errors

6. Are media enclosures extracted?

Yes. For RSS feeds, the enclosure's URL, type, and file length are extracted. For Atom feeds, link rel="enclosure" is captured.

7. How are feed items delivered to the dataset?

Each item is pushed as a separate dataset row, enriched with the source URL and feed title. When a feed has no items, a feed-level metadata row is pushed instead with item count, HTTP status, and any health issues.

8. Can I run this on a schedule?

Yes. Set up an Apify schedule to run the actor daily or hourly to continuously monitor feeds.

9. Does it handle authenticated feeds?

No. Only public, unauthenticated feeds are supported. The actor sends no authentication headers.

10. What happens when a feed URL returns an error?

The error is recorded per-feed with the HTTP status code and message. Other feeds in the batch keep going.

11. Are non-UTF-8 feeds supported?

The actor reads the raw bytes from the HTTP response and passes them to the XML parser, which handles character encoding from the XML declaration. JSON feeds are expected to be UTF-8.

12. Can I filter items by date or category?

Not directly. The actor returns every item from the feed. Filtering can be done on your end after you retrieve the dataset.

---

MCP Integration

{
  "mcpServers": {
    "apify-feed-parser": {
      "command": "npx",
      "args": ["-y", "@apify/mcp-server-actors", "--actors=perryay/rss-feed-to-json-parser"]
    }
  }
}

---

Related Tools

• Article to Markdown Converter — Convert web articles and blog posts to clean Markdown
• Content Readability Analyzer — Score content readability with multiple algorithms
• Data Format Converter — Convert between JSON, YAML, TOML, CSV, and XML formats

---

SEO Keywords

RSS to JSON converter, Atom feed parser, JSON Feed parser, XML feed parser, RSS feed aggregator, feed URL parser, RSS to structured data, batch RSS parser, feed health checker, podcast RSS parser, news feed aggregator, blog feed scraper, XML to JSON converter, feed metadata extractor