# RSS Feed Reader: Bulk RSS, Atom & JSON Feeds to Dataset (`globose_talent_mn9/rss-feed-reader`) Actor

Read many RSS, Atom, RDF and JSON feeds at once, or just paste website URLs and the feed is found automatically. Clean items with title, link, date, author, categories, summary, content, image and enclosures. Only-new monitoring, keyword and date filters. $0.30 per 1,000 items.

- **URL**: https://apify.com/globose_talent_mn9/rss-feed-reader.md
- **Developed by:** [Andrew Shamah](https://apify.com/globose_talent_mn9) (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 $0.30 / 1,000 feed items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## RSS Feed Reader: bulk RSS, Atom & JSON feeds to a clean dataset

Read **hundreds of RSS, Atom, RDF and JSON feeds in one run** and get one clean, normalized row per article, post, episode or video. Don't know the feed URL? **Just paste the website**: the Actor finds the feed automatically (`<link rel="alternate">` tags, then common paths like `/feed`, `/rss.xml`, `/atom.xml`).

Turn on **only-new monitoring** and schedule it, and every run returns just the items published since the last run, ready to pipe into Slack, email, Google Sheets, a webhook, Zapier, Make or an LLM.

### Why this feed reader

- **All formats, one schema:** RSS 0.9x/2.0, RSS 1.0 (RDF), Atom 1.0 and JSON Feed 1.x, including podcast enclosures, Media RSS images and YouTube channel feeds.
- **Feed autodiscovery** from any website or blog URL.
- **Only-new items** between runs (per-feed memory, separate monitors via `stateKey`).
- **Filters:** keywords, last N days or a fixed date, per-feed and total limits.
- **Full content** (HTML and optional plain text for LLM/RAG pipelines), images and enclosures.
- **Cheap and fair:** $0.30 per 1,000 items. Feeds that fail and invalid inputs are **free** and still reported.
- Light (256 MB, plain HTTP, no browser), so runs are fast and cost little.

### Input example

```json
{
  "feedUrls": ["https://hnrss.org/frontpage", "https://blog.cloudflare.com", "https://www.theverge.com/rss/index.xml"],
  "maxItemsPerFeed": 20,
  "keywords": ["AI", "security"],
  "onlyNewItems": true,
  "stateKey": "tech-news"
}
```

### Output example

```json
{
  "feedTitle": "The Verge",
  "feedUrl": "https://www.theverge.com/rss/index.xml",
  "siteUrl": "https://www.theverge.com/",
  "feedFormat": "atom",
  "itemId": "3f1c0a8e9b2d4c71",
  "title": "Windows 11 tries new shortcuts for Xbox gaming mode",
  "url": "https://www.theverge.com/...",
  "guid": "https://www.theverge.com/...",
  "published": "2026-10-31T15:12:19.000Z",
  "updated": "2026-10-31T15:12:19.000Z",
  "author": "Terrence O'Brien",
  "categories": ["Gaming", "Microsoft", "Tech"],
  "summary": "Plain-text summary…",
  "contentHtml": "<p>Full article HTML when the feed includes it…</p>",
  "imageUrl": "https://platform.theverge.com/wp-content/uploads/...jpg",
  "enclosures": [],
  "commentsUrl": null,
  "inputUrl": "https://www.theverge.com/rss/index.xml",
  "fetchedAt": "2026-10-31T16:50:00.000Z"
}
```

Rows for inputs that could not be read contain `inputUrl`, `feedUrl` and `error` and are not charged. A per-feed report (items found, returned, skipped as old/seen/keyword) is saved as `REPORT` in the run's key-value store.

### Pricing

Pay per event: **$0.0003 per item returned** ($0.30 per 1,000) plus a tiny Actor-start fee. Set *Maximum cost per run* and the Actor stops cleanly at your limit.

### Use cases

- News and brand monitoring: keyword alerts across many publishers.
- Content aggregation for newsletters, dashboards and apps.
- Feeding LLM/RAG pipelines with fresh articles (use `includeContentText`).
- Podcast episode and YouTube upload tracking (`https://www.youtube.com/feeds/videos.xml?channel_id=…`).
- Competitor blog and changelog tracking.

### Monitoring setup (only new items)

1. Turn on **Only new items** and give the monitor a **state name**.
2. Create an Apify **Schedule** (e.g. hourly).
3. Add an integration (Slack, email, webhook, Google Sheets). The first run returns the current items; later runs return only new ones.

### FAQ

**Does it scrape websites?** No. It reads the public feeds that sites publish for exactly this purpose. Autodiscovery reads only the page's `<head>` links and a few standard feed paths.

**Why did a site return an error?** Some sites have no feed, or block automated requests. Error rows are free.

**Items without dates?** They are kept even when you use date filters.

# Actor input Schema

## `feedUrls` (type: `array`):

One RSS/Atom/JSON feed URL or website per line. For a normal website (e.g. https://blog.cloudflare.com) the feed is discovered automatically.

## `feedUrlsText` (type: `string`):

Paste many feeds or websites separated by new lines, spaces or commas.

## `maxItemsPerFeed` (type: `integer`):

Newest-first in most feeds. You pay per item returned.

## `maxItemsTotal` (type: `integer`):

0 = no limit.

## `maxAgeDays` (type: `integer`):

Optional. Skip items published earlier (items without a date are kept).

## `publishedAfter` (type: `string`):

Optional absolute date (overrides 'last N days').

## `keywords` (type: `array`):

Optional. Keep only items whose title, summary or categories contain at least one of these words (case-insensitive).

## `onlyNewItems` (type: `boolean`):

Remembers item IDs per feed between runs, so scheduled runs return only fresh items. Ideal with Apify Schedules + Slack/email/webhook integrations.

## `stateKey` (type: `string`):

Use a different name for each separate monitor so they don't share 'already seen' history.

## `autodiscover` (type: `boolean`):

If a URL is a web page, look for <link rel=alternate> feeds and common paths like /feed and /rss.xml.

## `allDiscoveredFeeds` (type: `boolean`):

By default only the first (main) feed of each website is read. Turn on to read up to 10 (e.g. posts + comments + categories).

## `includeContentHtml` (type: `boolean`):

Include the item's full HTML content (content:encoded / Atom content) when the feed provides it.

## `includeContentText` (type: `boolean`):

Add a plain-text version of the content (handy for LLMs and search).

## `maxConcurrency` (type: `integer`):

How many feeds or websites to fetch at the same time.

## Actor input object example

```json
{
  "feedUrls": [
    "https://hnrss.org/frontpage",
    "https://blog.cloudflare.com"
  ],
  "maxItemsPerFeed": 5,
  "maxItemsTotal": 0,
  "onlyNewItems": false,
  "stateKey": "default",
  "autodiscover": true,
  "allDiscoveredFeeds": false,
  "includeContentHtml": true,
  "includeContentText": false,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `overview` (type: `string`):

All items returned, newest feeds first.

## `report` (type: `string`):

Items found, returned and skipped per feed.

# 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 = {
    "feedUrls": [
        "https://hnrss.org/frontpage",
        "https://blog.cloudflare.com"
    ],
    "maxItemsPerFeed": 5
};

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

# Prepare the Actor input
run_input = {
    "feedUrls": [
        "https://hnrss.org/frontpage",
        "https://blog.cloudflare.com",
    ],
    "maxItemsPerFeed": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("globose_talent_mn9/rss-feed-reader").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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",
    "https://blog.cloudflare.com"
  ],
  "maxItemsPerFeed": 5
}' |
apify call globose_talent_mn9/rss-feed-reader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,globose_talent_mn9/rss-feed-reader"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Qe46C6gk67TbZOfnT/builds/31S7WYMlpQn5wuFhO/openapi.json