# RSS Feed Reader & News Monitor: RSS, Atom, JSON Feed (`manageable_gully/rss-feed-reader`) Actor

Read and monitor RSS, Atom and JSON feeds in bulk (or paste a website URL and the feed is found for you): only-new-items mode for scheduled news and blog monitoring, keyword and date filters, optional full article text, merged output feed. $0.50 per 1,000 items.

- **URL**: https://apify.com/manageable_gully/rss-feed-reader.md
- **Developed by:** [WebIntel Tools](https://apify.com/manageable_gully) (community)
- **Categories:** News, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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 & News Monitor: Parse RSS, Atom and JSON Feeds to JSON

Read any number of **RSS, Atom and JSON feeds** and get clean, consistent JSON, CSV or Excel. Don't know the feed URL? Paste the website or blog address and the Actor finds the feed for you. Schedule it with **only-new-items** mode to monitor news, blogs, podcasts, releases, job boards or competitors, and pipe new items to Slack, Google Sheets, Zapier, Make or your own API.

### What you can use it for

- **News monitoring:** watch dozens of news sites and blogs and get only new articles that mention your brand or keywords.
- **Slack, Telegram or email alerts:** schedule hourly runs with **only new items** and send the results through a webhook or Zapier/Make.
- **AI newsletters and summaries:** collect the week's posts with full article text, then summarize them with an LLM.
- **Competitor and release tracking:** follow product blogs, changelogs and GitHub release feeds.
- **Podcast data:** episode titles, dates and audio enclosure URLs from podcast feeds.

### How to use it

1. Paste feed URLs or plain website URLs under **Feed URLs** (the feed is discovered automatically).
2. Turn on **Only new items** if you'll run it on a schedule.
3. Add keyword or date filters if you want.
4. Click **Start**, then create a schedule and an integration for alerts.

### Why this feed reader

- **Every format:** RSS 0.9x / 1.0 (RDF) / 2.0, Atom 1.0 and JSON Feed 1.0/1.1, normalized into one schema.
- **Feed discovery:** works with plain website URLs (`<link rel="alternate">` tags, then common paths like `/feed`, `/rss.xml`, `/atom.xml`, `/index.xml`).
- **Only new items:** remembers what each feed contained last time and returns only what's new. Unchanged feeds are skipped cheaply with ETag / Last-Modified conditional requests. Use separate *monitor names* for separate schedules.
- **Filters:** keywords to include or exclude (title, summary, content, author, categories) and a *published after* date, absolute (`2026-10-01`) or relative (`24 hours`, `7 days`).
- **Full article text (optional):** opens each item's link and extracts the main text as Markdown, ready for LLMs, summaries or RAG.
- **Merged output feed:** saves all returned items as one filtered RSS 2.0, Atom or JSON Feed file (`OUTPUT_FEED` in the key-value store). It works as a simple feed aggregator / feed generator.
- **Podcasts and media:** enclosures (audio/video URL, type, size) and thumbnail images included.
- **Cheap and polite:** plain HTTP, no browser, 256 MB memory. Respects robots.txt, never logs in, refuses private or internal addresses.

### Input example

```json
{
  "feedUrls": [{"url": "https://hnrss.org/frontpage"}, {"url": "https://blog.python.org"}, {"url": "https://github.blog/feed/"}],
  "maxItemsPerFeed": 20,
  "onlyNewItems": true,
  "includeKeywords": ["release", "security"],
  "publishedAfter": "7 days",
  "fetchFullText": false,
  "outputFeedFormat": "rss"
}
```

### Output (one item per feed entry)

```json
{
  "inputUrl": "https://blog.python.org/",
  "feedUrl": "https://blog.python.org/rss.xml",
  "feedTitle": "Python Insider", "feedFormat": "rss20", "feedLanguage": null,
  "title": "Python 3.16.0 alpha 1 is now available",
  "link": "https://blog.python.org/2026/10/python-3160-alpha-1-is-now-available/",
  "guid": "https://blog.python.org/2026/10/python-3160-alpha-1-is-now-available/", "itemId": "288a44c8c89ab69ffd52",
  "published": "2026-10-13T00:00:00+00:00", "updated": null,
  "author": "Savannah Ostrowski", "summary": "The first developer preview of Python 3.16 is ready for testing. ...",
  "categories": ["releases"], "image": null,
  "enclosures": [],
  "fullText": "# Python 3.16.0 alpha 1 is now available\n\n...",
  "fetchedAt": "2026-10-17T07:13:08+00:00"
}
```

Feeds that fail (not found, not a feed, blocked by robots.txt) produce a single row with `inputUrl` and `error`, and are not charged.

### Scheduled monitoring in 3 steps

1. Add your feeds and turn on **Only new items since the last run**.
2. Create a schedule (e.g. every hour) in Apify Console.
3. Add an integration (Slack, email, webhook, Google Sheets, Zapier, Make) that fires when the run succeeds.

### Limits

- Only reads what sites publish as feeds, plus the linked article page when full text is on. No logins, paywalls or JavaScript rendering.
- Feeds usually contain only the latest 10 to 100 entries. Older items are not available from the feed itself.
- Use the content in line with each publisher's terms and copyright.

### Pricing

Pay per event, no monthly rent:

- **$0.0005 per feed item** returned
- **$0.001 per full article text** (optional)

| Example | Cost |
|---|---|
| 1,000 feed items | $0.50 |
| 1,000 items with full article text | $1.50 |
| Hourly monitor of 20 feeds, about 200 new items a day, for 30 days | $3.04 |

Errors, skipped items and unchanged feeds are free.

You can set a **maximum cost per run** in the run options; the Actor stops cleanly when it is reached. New to Apify? The free plan includes $5 of platform credit every month, so you can try this Actor at no cost.

### API, integrations and AI agents (MCP)

Run it from your own code with the [Apify API](https://docs.apify.com/api/v2) and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/manageable_gully~rss-feed-reader/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" -d @input.json
```

```python
from apify_client import ApifyClient
run = ApifyClient("<YOUR_APIFY_TOKEN>").actor("manageable_gully/rss-feed-reader").call(run_input={...})
```

- **No-code:** use the Apify app in **n8n, Make or Zapier** ("Run Actor", then "Get dataset items"), or send results to Google Sheets, Slack or a webhook.
- **AI agents (MCP):** add `https://mcp.apify.com?tools=manageable_gully/rss-feed-reader` to Claude, Cursor, VS Code or any MCP client and the agent can call this Actor as a tool.
- **Schedules:** run it hourly, daily or weekly from Apify Console.

### FAQ

**What if a website has no RSS feed?** The Actor first looks for feeds linked from the page and at common paths (`/feed`, `/rss.xml`, `/atom.xml`). If none exists, that URL gets an error row and is not charged. For pages without feeds, use [Web Page to Markdown](https://apify.com/manageable_gully/page-to-markdown) instead.

**Can I build my own combined RSS feed?** Yes. The merged, filtered feed is saved as RSS 2.0, Atom or JSON Feed (`OUTPUT_FEED` in the key-value store), so you can subscribe to it from any reader.

**Can AI agents use it?** Yes. It is available as a tool through the Apify MCP server (`https://mcp.apify.com?tools=manageable_gully/rss-feed-reader`) and the Apify API, and it returns structured JSON that agents can read directly.

### More tools from WebIntel Tools

- [Web Page to Markdown](https://apify.com/manageable_gully/page-to-markdown): clean Markdown and RAG chunks from any URL, for LLMs
- [Product Hunt Scraper](https://apify.com/manageable_gully/product-hunt-scraper): daily, weekly and monthly Product Hunt launches with websites
- [Google Jobs Scraper](https://apify.com/manageable_gully/google-jobs-scraper): Google for Jobs listings with salaries and apply links
- [PDF & Image OCR Extractor](https://apify.com/manageable_gully/pdf-ocr-extractor): PDFs and images to text, Markdown and tables (incl. Hebrew/Arabic)

See [all WebIntel Tools Actors](https://apify.com/manageable_gully).

*Made by WebIntel Tools. This Actor was built and is maintained with AI assistance. Report issues on the Issues tab; they are monitored daily.*

# Actor input Schema

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

RSS, Atom or JSON Feed URLs. You can also paste a normal website or blog URL: the Actor looks for the feed (link tags, then common paths such as /feed and /rss.xml).

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

Newest items first. 0 = everything in the feed (up to 1,000).

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

For scheduled monitoring. Remembers which items each feed contained at the last run (in a named key-value store) and outputs only items that appeared since. The first run returns the newest items (up to the per-feed max). Unchanged feeds are skipped with conditional requests (ETag / Last-Modified).

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

Keeps separate 'already seen' lists for different schedules or tasks that read the same feeds.

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

Only items published after this date. Absolute (2026-10-01) or relative (24 hours, 7 days, 2 weeks). Items without a date are skipped when this is set.

## `includeKeywords` (type: `array`):

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

## `excludeKeywords` (type: `array`):

Drop items containing any of these (case-insensitive).

## `fetchFullText` (type: `boolean`):

Open each item's link and extract the main article text as Markdown (robots.txt respected, no logins or paywalls). Charged separately, only when text is found.

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

Add the feed's own full content (content:encoded / Atom content) as HTML. Makes items larger.

## `outputFeedFormat` (type: `string`):

Also save all returned items as one merged, filtered feed in the key-value store (record OUTPUT_FEED). Plug it into any feed reader, Slack or Zapier.

## `outputFeedTitle` (type: `string`):

Title of the merged output feed.

## `discoverFeeds` (type: `boolean`):

If a URL is a normal web page, look for its RSS/Atom/JSON feed.

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

How many feeds are fetched in parallel.

## `timeoutSecs` (type: `integer`):

How long to wait for each feed or page.

## Actor input object example

```json
{
  "feedUrls": [
    {
      "url": "https://hnrss.org/frontpage"
    },
    {
      "url": "https://blog.python.org"
    }
  ],
  "maxItemsPerFeed": 50,
  "onlyNewItems": false,
  "stateKey": "default",
  "fetchFullText": false,
  "includeContentHtml": false,
  "outputFeedFormat": "none",
  "outputFeedTitle": "Merged feed",
  "discoverFeeds": true,
  "maxConcurrency": 5,
  "timeoutSecs": 30
}
```

# Actor output Schema

## `results` (type: `string`):

One item per feed entry (after filters and only-new deduplication), with optional full article text.

## `feed` (type: `string`):

Merged RSS/Atom/JSON feed of the delivered items (only when an output feed format is selected).

# 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": [
        {
            "url": "https://hnrss.org/frontpage"
        },
        {
            "url": "https://blog.python.org"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("manageable_gully/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": [
        { "url": "https://hnrss.org/frontpage" },
        { "url": "https://blog.python.org" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("manageable_gully/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": [
    {
      "url": "https://hnrss.org/frontpage"
    },
    {
      "url": "https://blog.python.org"
    }
  ]
}' |
apify call manageable_gully/rss-feed-reader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,manageable_gully/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/v2KcdkRDezJifVqOC/builds/caWGiDUROCpExeb3I/openapi.json