# RSS to JSON (`phazonoverload/rss-to-json`) Actor

Converts RSS/Atom feeds to clean JSON output, preserving all feed metadata and item attributes.

- **URL**: https://apify.com/phazonoverload/rss-to-json.md
- **Developed by:** [Kevin Lewis](https://apify.com/phazonoverload) (community)
- **Categories:** Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 to JSON

**Convert any RSS or Atom feed into clean, structured JSON output.** This Apify Actor fetches RSS/Atom feeds and transforms them into well-organized JSON, preserving feed metadata, items, and XML attributes.

### What does RSS to JSON do?

This Actor takes an RSS or Atom feed URL and returns all feed data as clean JSON. It extracts feed-level metadata (title, description, language, copyright, image) and every item (title, link, publication date, content, categories, author, enclosures, media content, and more). XML attributes on elements like `media:thumbnail` are preserved in the `$` object.

Try it with any RSS feed URL — BBC News, Hacker News, your blog, podcasts, or any sythenticated feed.

### Why use RSS to JSON?

- **API-ready data** — Get RSS data in JSON format ready for APIs, databases, and integrations
- **Full attribute preservation** — XML attributes on elements (media:thumbnail dimensions, enclosure metadata, etc.) are kept intact
- **No browser overhead** — Pure HTTP request + XML parse, fast and efficient
- **Works with RSS 2.0, RSS 1.0, and Atom** — Supports all major feed formats
- **Apify platform advantages** — Schedule runs, access via API, integrate with Make/Zapier, use Apify proxy

### How to use RSS to JSON

1. Go to the [RSS to JSON](https://console.apify.com/actors) Actor page in Apify Console
2. Enter an RSS/Atom feed URL in the input
3. Click **Run**
4. Download the results as JSON, CSV, XML, or Excel

### Input

Provide a single input:

| Field | Type | Description |
|-------|------|-------------|
| `feedUrl` | string (required) | URL of the RSS or Atom feed |

Example input:

```json
{
    "feedUrl": "https://feeds.bbci.co.uk/news/rss.xml"
}
````

### Output

The Actor stores **feed metadata** in the key-value store and pushes **each item** as a separate dataset entry.

#### Feed metadata

```json
{
    "title": "BBC News",
    "description": "BBC News - News Front Page",
    "link": "https://www.bbc.co.uk/news",
    "feedUrl": "https://feeds.bbci.co.uk/news/rss.xml",
    "language": "en-gb",
    "lastBuildDate": "Mon, 04 May 2026 17:00:13 GMT",
    "copyright": "Copyright: (C) British Broadcasting Corporation...",
    "image": {
        "link": "https://www.bbc.co.uk/news",
        "url": "https://news.bbcimg.co.uk/nol/shared/img/bbc_news_120x60.gif",
        "title": "BBC News"
    }
}
```

#### Item output

```json
{
    "title": "Article Title",
    "link": "https://example.com/article",
    "pubDate": "Mon, 04 May 2026 12:00:00 GMT",
    "isoDate": "2026-05-04T12:00:00.000Z",
    "content": "Full article content...",
    "contentSnippet": "Truncated preview...",
    "categories": ["news", "technology"],
    "creator": "Author Name",
    "guid": "https://example.com/article#0",
    "enclosure": {
        "url": "https://example.com/media.mp3",
        "length": "12345678",
        "type": "audio/mpeg"
    },
    "mediaThumbnail": {
        "$": {
            "width": "240",
            "height": "134",
            "url": "https://example.com/thumb.jpg"
        }
    }
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data table

| Field | Description |
|-------|-------------|
| `title` | Item title |
| `link` | URL to the full item |
| `pubDate` | Publication date string |
| `isoDate` | ISO 8601 publication date |
| `content` | Full HTML content |
| `contentSnippet` | Plain text snippet |
| `summary` | Item summary (Atom) |
| `categories` | Array of category strings |
| `creator` | Author/creator (dc:creator) |
| `guid` | Unique item identifier |
| `enclosure` | Enclosure object (url, length, type) |
| `mediaContent` | Media content object |
| `mediaThumbnail` | Media thumbnail with attributes |
| `contentEncoded` | content:encoded value |
| `origLink` | Original feedburner link |
| `comments` | Comments URL |
| `source` | Source feed info |
| `itunes` | iTunes podcast extension data |

### Pricing / Cost estimation

This Actor makes a single HTTP request to fetch the RSS feed and parses the XML. It typically uses minimal compute units (fractions of a CU). Most runs cost less than $0.01. Under the Apify free tier, you get $5 of monthly usage credit — enough for thousands of RSS feed conversions.

### Tips

- **Atom feeds** work identically — the parser handles both RSS and Atom formats
- **Podcast RSS feeds** with iTunes extensions are supported via the `itunes` field
- For **large feeds** (1000+ items), the Actor processes all items in sequence
- The **feed metadata** is stored under the `feed-metadata` key in the key-value store

### FAQ, disclaimers, and support

**Is web scraping legal?** This Actor only processes RSS/Atom feeds that the publisher makes publicly available. Always review the feed publisher's Terms of Service before use.

**Known limitations:** Some non-standard RSS extensions may not be parsed. If your feed uses a custom XML namespace, the data may appear under different property names.

**Need help or want a custom solution?** Reach out on the [Issues](https://console.apify.com/actors) tab or contact the Apify team.

# Actor input Schema

## `feedUrl` (type: `string`):

URL of the RSS or Atom feed to convert to JSON

## Actor input object example

```json
{
  "feedUrl": "https://feeds.bbci.co.uk/news/rss.xml"
}
```

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "feedUrl": "https://feeds.bbci.co.uk/news/rss.xml"
};

// Run the Actor and wait for it to finish
const run = await client.actor("phazonoverload/rss-to-json").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "feedUrl": "https://feeds.bbci.co.uk/news/rss.xml" }

# Run the Actor and wait for it to finish
run = client.actor("phazonoverload/rss-to-json").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 '{
  "feedUrl": "https://feeds.bbci.co.uk/news/rss.xml"
}' |
apify call phazonoverload/rss-to-json --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=phazonoverload/rss-to-json",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RSS to JSON",
        "description": "Converts RSS/Atom feeds to clean JSON output, preserving all feed metadata and item attributes.",
        "version": "1.0",
        "x-build-id": "ivLdzTWu8lqI3ayBe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/phazonoverload~rss-to-json/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-phazonoverload-rss-to-json",
                "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/phazonoverload~rss-to-json/runs": {
            "post": {
                "operationId": "runs-sync-phazonoverload-rss-to-json",
                "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/phazonoverload~rss-to-json/run-sync": {
            "post": {
                "operationId": "run-sync-phazonoverload-rss-to-json",
                "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": [
                    "feedUrl"
                ],
                "properties": {
                    "feedUrl": {
                        "title": "RSS Feed URL",
                        "type": "string",
                        "description": "URL of the RSS or Atom feed to convert to JSON"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
