# RSS Feed to JSON Parser — XML & Atom Feed Converter (`perryay/rss-feed-to-json-parser`) Actor Fetch and parse RSS 2.0, Atom, and JSON Feed formats into structured JSON output. Supports single feeds and batch analysis up to 20 feeds. Validates feed health, detects common issues, and extracts per-item metadata including title, link, dates, authors, categories, and enclosures. - **URL**: https://apify.com/perryay/rss-feed-to-json-parser.md - **Developed by:** [Perry AY](https://apify.com/perryay) (community) - **Categories:** Developer tools, Automation - **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.025 / actor start This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## 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 ```json { "mode": "single", "feed_url": "https://example.com/blog/feed.xml", "validate_health": true } ```` #### Example Input — Batch Mode ```json { "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 ```json { "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 ```bash 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) ```python 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 ``), 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 ```json { "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](https://apify.com/perryay/article-to-markdown-converter)** — Convert web articles and blog posts to clean Markdown - **[Content Readability Analyzer](https://apify.com/perryay/content-readability-analyzer)** — Score content readability with multiple algorithms - **[Data Format Converter](https://apify.com/perryay/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 # Actor input Schema ## `mode` (type: `string`): Choose single feed parsing or batch processing of multiple feeds. ## `feed_url` (type: `string`): The RSS/Atom/JSON Feed URL to parse. ## `feed_urls` (type: `array`): List of feed URLs to parse in batch mode (max 20). ## `validate_health` (type: `boolean`): Enable feed health validation checks (empty feeds, stale updates, missing metadata). ## Actor input object example ```json { "mode": "single", "feed_url": "https://example.com/blog/feed.xml", "feed_urls": [ "https://example.com/blog/feed.xml", "https://example.org/rss" ], "validate_health": false } ``` # Actor output Schema ## `results` (type: `string`): Each item from parsed feeds, delivered via the default dataset # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "mode": "single", "feed_url": "https://example.com/blog/feed.xml", "feed_urls": [ "https://example.com/blog/feed.xml", "https://example.org/rss" ] }; // Run the Actor and wait for it to finish const run = await client.actor("perryay/rss-feed-to-json-parser").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "mode": "single", "feed_url": "https://example.com/blog/feed.xml", "feed_urls": [ "https://example.com/blog/feed.xml", "https://example.org/rss", ], } # Run the Actor and wait for it to finish run = client.actor("perryay/rss-feed-to-json-parser").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "mode": "single", "feed_url": "https://example.com/blog/feed.xml", "feed_urls": [ "https://example.com/blog/feed.xml", "https://example.org/rss" ] }' | apify call perryay/rss-feed-to-json-parser --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=perryay/rss-feed-to-json-parser", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "RSS Feed to JSON Parser — XML & Atom Feed Converter", "description": "Fetch and parse RSS 2.0, Atom, and JSON Feed formats into structured JSON output. Supports single feeds and batch analysis up to 20 feeds. Validates feed health, detects common issues, and extracts per-item metadata including title, link, dates, authors, categories, and enclosures.", "version": "1.0", "x-build-id": "dgDo8Ly7krNC0W9l7" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/perryay~rss-feed-to-json-parser/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-perryay-rss-feed-to-json-parser", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/perryay~rss-feed-to-json-parser/runs": { "post": { "operationId": "runs-sync-perryay-rss-feed-to-json-parser", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/perryay~rss-feed-to-json-parser/run-sync": { "post": { "operationId": "run-sync-perryay-rss-feed-to-json-parser", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "mode" ], "properties": { "mode": { "title": "Analysis Mode", "enum": [ "single", "batch" ], "type": "string", "description": "Choose single feed parsing or batch processing of multiple feeds.", "default": "single" }, "feed_url": { "title": "Feed URL", "type": "string", "description": "The RSS/Atom/JSON Feed URL to parse.", "default": "" }, "feed_urls": { "title": "Feed URLs (Batch Mode)", "type": "array", "description": "List of feed URLs to parse in batch mode (max 20).", "items": { "type": "string" }, "default": [] }, "validate_health": { "title": "Validate Feed Health", "type": "boolean", "description": "Enable feed health validation checks (empty feeds, stale updates, missing metadata).", "default": false } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```