# RSS Feed Reader - Bulk RSS & Atom Feed Parser (`logiover/bulk-rss-feed-reader`) Actor
Read and parse RSS, Atom and RDF feeds in bulk, or auto-discover feeds from any website. Extract thousands of articles with full metadata for news monitoring, content aggregation and AI/RAG pipelines. No API key, export to CSV or JSON.
- **URL**: https://apify.com/logiover/bulk-rss-feed-reader.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** News, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $3.50 / 1,000 results
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.
Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event
## 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 Feed Reader ๐ฐ โ Bulk RSS, Atom & RDF Feed Parser
**Read hundreds of RSS, Atom and RDF feeds in a single run and get one clean row per item.** This **RSS feed reader / RSS parser** fetches every feed you give it (or **auto-discovers feeds from plain website URLs**), normalizes the different feed dialects, de-duplicates items and returns full metadata for each entry โ title, link, GUID, publish date, author, categories, summary, full content and enclosure (podcast/media) URL.
Paste a list of feeds โ or just a list of websites โ and export the result as **JSON, CSV, Excel or via API**. **No API key, no login, no headless browser. One row per item.**
> Looking for an **RSS to JSON** or **RSS to CSV** converter, a **bulk RSS scraper**, an **Atom feed parser**, a **feed aggregator** or **RSS feed discovery** for **news monitoring**? This actor does all of it at scale.
---
### โจ Key features
- ๐ก **Reads every common feed format** โ RSS 2.0, RSS 1.0 / RDF and Atom, all normalized into one consistent item shape.
- ๐ **Feed auto-discovery** โ paste a normal website URL and the actor finds its feed via `` tags and common paths (`/feed`, `/rss.xml`, `/atom.xml`, and more).
- ๐งพ **Full item metadata** โ title, link, GUID, publish date, author, categories, content snippet, full HTML content and enclosure URL.
- ๐งน **Automatic de-duplication** โ items repeated across feeds (by GUID/link) are collapsed so your dataset stays clean.
- ๐๏ธ **Normalized ISO dates** โ every `pubDate` is parsed and output as an ISO 8601 timestamp you can sort and filter on.
- ๐ก๏ธ **Per-feed error isolation** โ one broken or slow feed never kills the run; the rest keep going.
- โก **Fast & cheap** โ pure HTTP with configurable concurrency, no browser. Many feeds ร many items = thousands of rows per run.
### ๐ก Use cases
- **News & brand monitoring** โ track mentions, topics and outlets across hundreds of news feeds in near real time.
- **Content aggregation** โ power a reader, dashboard or homepage from dozens of sources at once.
- **AI / RAG / LLM data pipelines** โ turn fresh feed content into structured rows to feed retrieval, summarization or fine-tuning workflows.
- **Competitive intelligence** โ watch competitor blogs, changelogs and press feeds and get notified of every new post.
- **Newsletter & podcast tracking** โ follow Substack/blog feeds and podcast RSS, capturing enclosure (audio/media) URLs per episode.
- **Research & archiving** โ snapshot what a set of sources published, with timestamps, for analysis or compliance.
### ๐ฆ What you get
One row per feed item, including:
| Field | Description |
|-------|-------------|
| `feedUrl` | The feed the item came from |
| `feedTitle` | Title of the source feed |
| `title` | Item / article title |
| `link` | Canonical URL of the item |
| `guid` | Unique item identifier (used for de-duplication) |
| `pubDate` | Publish date, normalized to ISO 8601 |
| `author` | Item author / creator (when provided) |
| `categories` | Tags / categories on the item |
| `contentSnippet` | Plain-text summary / description |
| `content` | Full HTML content (when the feed provides it) |
| `enclosureUrl` | Attached media URL (podcast audio, image, etc.) |
| `scrapedAt` | When this item was read, ISO 8601 |
#### Example output
```json
{
"feedUrl": "https://techcrunch.com/feed/",
"feedTitle": "TechCrunch",
"title": "A new startup wants to reinvent the RSS reader",
"link": "https://techcrunch.com/2026/06/14/rss-reader-startup/",
"guid": "https://techcrunch.com/?p=2847193",
"pubDate": "2026-06-14T16:32:00.000Z",
"author": "Jane Doe",
"categories": ["Startups", "Apps"],
"contentSnippet": "The team behind the project says RSS is overdue for a comeback...",
"content": "
The team behind the project says RSS is overdue for a comeback...
",
"enclosureUrl": "",
"scrapedAt": "2026-06-15T09:00:00.000Z"
}
````
### ๐ How to use it
1. Click **Try for free / Start**.
2. Paste your **Feed URLs** โ RSS, Atom or RDF feed links, one per line.
3. (Optional) Turn on **Discover feeds from websites** and paste plain site URLs (e.g. `https://example.com`) โ the actor will find their feeds for you.
4. (Optional) Set **Max items per feed** and **Max results** to cap the output, or leave at `0` for everything.
5. Click **Save & Start**.
6. Export the dataset as **JSON, CSV, Excel** or pull it via the **REST API**.
### โ๏ธ Input
| Option | Description | Default |
|--------|-------------|---------|
| `feedUrls` | List of RSS / Atom / RDF feed URLs (or website URLs when discovery is on) | โ (required) |
| `discoverFromWebsites` | Treat non-feed URLs as websites and auto-discover their feeds via `` tags and common feed paths | `false` |
| `maxItemsPerFeed` | Max items to take from each feed (`0` = all) | `0` |
| `maxResults` | Max total item rows across all feeds (`0` = unlimited) | `0` |
| `maxConcurrency` | How many feeds to fetch in parallel | `10` |
| `proxyConfiguration` | Apify proxy settings (recommended to avoid rate limits) | Apify Proxy on |
#### Example input
```json
{
"feedUrls": [
"https://hnrss.org/frontpage",
"http://feeds.bbci.co.uk/news/rss.xml",
"https://www.theverge.com/rss/index.xml",
"https://techcrunch.com/feed/"
],
"discoverFromWebsites": false,
"maxItemsPerFeed": 0,
"maxResults": 0
}
```
To let the actor find feeds for you, turn discovery on and pass plain sites:
```json
{
"feedUrls": ["https://www.theverge.com", "https://techcrunch.com"],
"discoverFromWebsites": true
}
```
### ๐ How it works
For each input URL the actor fetches the resource over HTTP (through the Apify proxy you configure, to avoid rate limiting and IP blocks).
- **Feeds** are parsed regardless of dialect โ it handles **RSS 2.0**, **RSS 1.0 / RDF** and **Atom**, mapping each into one consistent item shape with normalized ISO dates.
- **Websites** (when **Discover feeds from websites** is on) are scanned for feeds: the HTML is read for `` hints, and common paths like `/feed`, `/rss`, `/rss.xml`, `/atom.xml` and `/index.xml` are probed. Discovered feeds are then parsed like any other.
- **De-duplication** collapses items that repeat across feeds using their GUID/link, so the dataset stays clean.
- **Per-feed error isolation** means a single broken, empty or unreachable feed is skipped without stopping the run โ every other feed still produces rows.
Pure HTTP, high concurrency, no headless browser โ so many feeds ร many items turn into thousands of rows fast and cheaply.
### ๐งฐ Tips & best practices
- Keep **Apify Proxy** enabled โ many news sites rate-limit by IP, and rotating proxies keep large runs reliable.
- Use **Max items per feed** when you only care about the latest posts; leave it at `0` to backfill everything a feed exposes.
- Set **Max results** to put a hard ceiling on a run's size (and cost) when you're aggregating hundreds of feeds.
- Sort or filter the dataset by `pubDate` (already ISO 8601) to get a clean reverse-chronological timeline across all sources.
- Schedule the actor to poll your feeds on a cadence โ combined with de-duplication it becomes a steady stream of *new* items only.
- Not sure of a site's feed URL? Just paste the homepage and turn on **Discover feeds from websites**.
### โ FAQ
#### How do I convert RSS feeds to JSON or CSV?
Paste your feed URLs, run the actor, then download the dataset as **JSON, CSV** or Excel (or pull it via the REST API). Every feed item is one row, so it drops straight into a spreadsheet or a data pipeline โ an instant **RSS to JSON** and **RSS to CSV** converter.
#### Can I read many RSS feeds at once?
Yes โ this is a **bulk RSS reader**. Paste hundreds of feed URLs and the actor fetches them in parallel (configurable concurrency) and merges every item into a single dataset, with de-duplication across feeds.
#### Does it support Atom and RDF feeds, not just RSS?
Yes. It parses **RSS 2.0**, **RSS 1.0 / RDF** and **Atom** feeds and normalizes them all into the same item shape, so you don't have to care which dialect a source uses.
#### Can it find the RSS feed of a website automatically?
Yes โ turn on **Discover feeds from websites** and paste plain site URLs. The actor reads the page's `` tags and probes common feed paths (`/feed`, `/rss.xml`, `/atom.xml`, etc.) to locate the feed, then parses it. It works as a built-in **RSS feed discovery** tool.
#### Is this a free RSS reader without an API key?
There's **no API key and no login** to set up โ you just provide feed URLs. It runs on Apify like any other actor, so you only pay for the compute and (optional) proxy you use.
#### Can I use this for an AI / RAG / LLM news pipeline?
Absolutely. It outputs clean, structured rows (title, link, date, author, full content) that feed directly into **RAG / LLM** ingestion, summarization or classification pipelines. Schedule it to keep your knowledge base fresh with the latest items.
#### How does de-duplication work?
Items that appear in more than one feed are collapsed by their GUID/link, so the same article won't show up twice in your dataset even when you aggregate overlapping sources.
### ๐ Related actors by the same author
- **[Google News Scraper](https://apify.com/logiover/google-news-scraper)** โ scrape Google News results by keyword, topic or location.
- **[Substack Newsletter Scraper](https://apify.com/logiover/substack-newsletter-scraper)** โ pull posts and metadata from any Substack newsletter.
- **[Website to Markdown Crawler](https://apify.com/logiover/website-text-markdown-crawler)** โ crawl a site and get clean Markdown for LLMs and RAG.
- **[Apple Podcasts Episode Scraper](https://apify.com/logiover/apple-podcasts-episode-scraper)** โ extract episodes and metadata from Apple Podcasts.
### ๐ Changelog
#### 2026-06-15
- Initial release โ bulk RSS/Atom/RDF feed reader with feed auto-discovery and full item metadata, CSV/JSON export, no API key.
# Actor input Schema
## `feedUrls` (type: `array`):
List of RSS / Atom / RDF feed URLs to read. If 'Discover feeds from websites' is on, you can also paste plain website URLs and the actor will auto-find their feeds.
## `discoverFromWebsites` (type: `boolean`):
If an input URL is a normal website (not a feed), fetch its HTML and auto-discover RSS/Atom feeds via tags and common feed paths (/feed, /rss.xml, /atom.xml, etc.).
## `maxItemsPerFeed` (type: `integer`):
Maximum number of items to extract from each feed. Set to 0 for all available items.
## `maxResults` (type: `integer`):
Maximum total number of item rows to output across all feeds. Set to 0 for unlimited.
## `maxConcurrency` (type: `integer`):
How many feeds to fetch in parallel. Higher is faster but uses more proxies.
## `proxyConfiguration` (type: `object`):
Recommended to avoid rate limiting and IP blocks.
## Actor input object example
```json
{
"feedUrls": [
"https://hnrss.org/frontpage",
"http://feeds.bbci.co.uk/news/rss.xml",
"https://www.theverge.com/rss/index.xml",
"https://techcrunch.com/feed/"
],
"discoverFromWebsites": false,
"maxItemsPerFeed": 0,
"maxResults": 0,
"maxConcurrency": 10,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `results` (type: `string`):
The dataset containing all parsed feed items with title, link, publish date, author, categories and content.
# 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 = {
"feedUrls": [
"https://hnrss.org/frontpage",
"http://feeds.bbci.co.uk/news/rss.xml",
"https://www.theverge.com/rss/index.xml",
"https://techcrunch.com/feed/"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/bulk-rss-feed-reader").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 = { "feedUrls": [
"https://hnrss.org/frontpage",
"http://feeds.bbci.co.uk/news/rss.xml",
"https://www.theverge.com/rss/index.xml",
"https://techcrunch.com/feed/",
] }
# Run the Actor and wait for it to finish
run = client.actor("logiover/bulk-rss-feed-reader").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 '{
"feedUrls": [
"https://hnrss.org/frontpage",
"http://feeds.bbci.co.uk/news/rss.xml",
"https://www.theverge.com/rss/index.xml",
"https://techcrunch.com/feed/"
]
}' |
apify call logiover/bulk-rss-feed-reader --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=logiover/bulk-rss-feed-reader",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "RSS Feed Reader - Bulk RSS & Atom Feed Parser",
"description": "Read and parse RSS, Atom and RDF feeds in bulk, or auto-discover feeds from any website. Extract thousands of articles with full metadata for news monitoring, content aggregation and AI/RAG pipelines. No API key, export to CSV or JSON.",
"version": "1.0",
"x-build-id": "iQZ96CzAqLHsP5Laj"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/logiover~bulk-rss-feed-reader/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-logiover-bulk-rss-feed-reader",
"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/logiover~bulk-rss-feed-reader/runs": {
"post": {
"operationId": "runs-sync-logiover-bulk-rss-feed-reader",
"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/logiover~bulk-rss-feed-reader/run-sync": {
"post": {
"operationId": "run-sync-logiover-bulk-rss-feed-reader",
"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": [
"feedUrls"
],
"properties": {
"feedUrls": {
"title": "Feed URLs (or websites)",
"type": "array",
"description": "List of RSS / Atom / RDF feed URLs to read. If 'Discover feeds from websites' is on, you can also paste plain website URLs and the actor will auto-find their feeds.",
"items": {
"type": "string"
}
},
"discoverFromWebsites": {
"title": "Discover feeds from websites",
"type": "boolean",
"description": "If an input URL is a normal website (not a feed), fetch its HTML and auto-discover RSS/Atom feeds via tags and common feed paths (/feed, /rss.xml, /atom.xml, etc.).",
"default": false
},
"maxItemsPerFeed": {
"title": "Max Items Per Feed",
"minimum": 0,
"type": "integer",
"description": "Maximum number of items to extract from each feed. Set to 0 for all available items.",
"default": 0
},
"maxResults": {
"title": "Max Results (total)",
"minimum": 0,
"type": "integer",
"description": "Maximum total number of item rows to output across all feeds. Set to 0 for unlimited.",
"default": 0
},
"maxConcurrency": {
"title": "Max Concurrency",
"minimum": 1,
"maximum": 100,
"type": "integer",
"description": "How many feeds to fetch in parallel. Higher is faster but uses more proxies.",
"default": 10
},
"proxyConfiguration": {
"title": "Proxy Configuration",
"type": "object",
"description": "Recommended to avoid rate limiting and IP blocks.",
"default": {
"useApifyProxy": true
}
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```