# RSS Feed Monitor – New Items Only, Keyword Alerts (`mabun/rss-feed-monitor`) Actor

Read RSS 2.0, RSS 1.0 and Atom feeds, or paste a website URL and the feed is found automatically. Keyword include/exclude filters, max-age filter and monitor mode that returns only items you haven't seen. Clean JSON for Slack, n8n, Make or AI agents. $1 per 1,000 items.

- **URL**: https://apify.com/mabun/rss-feed-monitor.md
- **Developed by:** [Maximilian van Elst](https://apify.com/mabun) (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 $1.00 / 1,000 feed item returneds

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 Monitor – New Items Only, Keyword Alerts

**Turn any RSS or Atom feed – or just a website URL – into clean JSON.** Filter by keywords, and in **monitor mode** get only items you have not seen before. Built for news alerts, AI agents and Make / Zapier / n8n automations.

### What does RSS Feed Monitor do?

- Reads **RSS 2.0, RSS 1.0 (RDF) and Atom** and normalizes all of them into one schema
- **Auto-discovers feeds** from a homepage – paste `https://techcrunch.com/` and it finds the feed
- **Keyword include/exclude** filters (case-insensitive, word-start match: "agent" matches "agents", "ki" does not match "Ukraine")
- **Max age filter** – e.g. only items from the last 24 hours
- **Monitor mode (`onlyNew`)** – remembers items across runs; schedule it and receive only new items
- **Clean text** – HTML stripped, entities decoded, e-mail addresses removed from summaries
- Broken feeds are reported per URL and **not charged**

### Who is it for?

- **Marketers and PR teams** tracking brand, competitor or industry news
- **Analysts and researchers** monitoring blogs, journals or arXiv categories
- **Developers and AI agent builders** who need a reliable "what's new" tool
- **No-code automators** sending alerts to Slack, Telegram, e-mail or Notion

### Use cases: RSS keyword alerts and news monitoring

- 🔔 **Keyword alerts** – "AI", "LLM", your brand name → Slack every hour
- 📰 **News aggregation** – merge dozens of feeds into one deduplicated dataset
- 🤖 **AI agent tool** – "what's new on these sites since yesterday?"
- 🧪 **Research monitoring** – new papers from arXiv RSS feeds filtered by topic
- 📈 **Competitor tracking** – watch competitors' blogs and press pages

### How to monitor RSS feeds in 4 steps

1. Click **Start** – the prefilled input (Hacker News front page + techcrunch.com, max 10 items per feed) runs in a few seconds.
2. Add your feeds or websites and optional keywords.
3. For alerts: set `onlyNew: true`, choose a `monitorId`, and add a **schedule** (e.g. hourly).
4. Connect Slack, e-mail, Google Sheets or your webhook.

### Input example

```json
{
  "feedUrls": ["https://hnrss.org/frontpage", "https://techcrunch.com/", "https://rss.arxiv.org/rss/cs.AI"],
  "keywords": ["AI", "agent", "LLM"],
  "excludeKeywords": ["sponsored"],
  "maxAgeHours": 72,
  "maxItemsPerFeed": 50,
  "onlyNew": true,
  "monitorId": "ai-news",
  "includeContent": false
}
```

| Field | Meaning |
|---|---|
| `feedUrls` | RSS/Atom feed URLs or website URLs (feed auto-discovery) |
| `keywords` | Keep only items whose title or summary contains at least one keyword. Empty = all |
| `excludeKeywords` | Drop items containing any of these words |
| `maxAgeHours` | Ignore older items (0 = no limit) |
| `maxItemsPerFeed` | Upper limit per feed (cost cap) |
| `onlyNew` + `monitorId` | Monitor mode: only items not returned in earlier runs of the same monitor |
| `includeContent` | Add the full item content as plain text (if the feed provides it) |

### RSS to JSON: output example

Real record from a test run on 21 Oct 2026 (keywords `KI`, `agent`):

```json
{
  "id": "0560d9c4206f8ceae1f748617ef3379ead708ccd",
  "feedUrl": "https://www.heise.de/rss/heise-atom.xml",
  "feedTitle": "heise online News",
  "feedFormat": "atom",
  "title": "Nvidia will KI-Agenten per Hardware überwachen",
  "link": "https://www.heise.de/hintergrund/Nvidia-will-KI-Agenten-per-Hardware-ueberwachen-11494932.html?wt_mc=rss.red.ho.ho.atom.beitrag.beitrag",
  "published": "2026-10-21T13:08:00.000Z",
  "summary": "Offene KI-Modelle versprechen Unabhängigkeit. Mit OpenShell und speziellen Prozessoren will Nvidia jedoch die Handlungsräume von Agenten begrenzen.",
  "categories": [],
  "imageUrl": null,
  "matchedKeywords": ["ki", "agent"],
  "fetchedAt": "2026-10-21T19:40:32.260Z"
}
```

A website URL resolves to its feed, e.g. `https://www.tagesschau.de/` → `feedUrl: "https://www.tagesschau.de/index~atom.xml"`.

In monitor mode, a second run right after the first returned **0 items** – exactly as intended – and only costs the start fee.

### How much does RSS monitoring cost?

Pay-per-event pricing – platform compute is included:

| Event | Price |
|---|---|
| Actor start | **$0.005** per run |
| Feed item returned | **$0.001** per item ($1 per 1,000) |

Items skipped in monitor mode, filtered-out items and failed feeds cost nothing. The start fee is charged once per run, not per feed.

- Prefilled test run (2 feeds, max 10 items each): **≤ $0.025**
- Daily monitor, 20 new items per day: **~$0.75 per month**
- Hourly monitor, 20 new items per day: 24 × $0.005 + 20 × $0.001 ≈ **$0.14 per day (~$4 per month)**

Use `maxItemsPerFeed` and `maxAgeHours` as cost caps.

### RSS feed API: Python, JavaScript, cURL

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("mabun/rss-feed-monitor").call(run_input={
    "feedUrls": ["https://hnrss.org/frontpage"], "keywords": ["LLM", "agent"],
    "onlyNew": True, "monitorId": "hn-llm"
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["link"])
```

**JavaScript**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('mabun/rss-feed-monitor').call({ feedUrls: ['https://rss.arxiv.org/rss/cs.AI'], maxItemsPerFeed: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/mabun~rss-feed-monitor/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"feedUrls":["https://hnrss.org/frontpage"],"maxItemsPerFeed":10}'
```

### Use with AI agents (MCP)

Give Claude, ChatGPT, Cursor or LangChain agents a "read the latest news" tool via the Apify MCP server:
`https://mcp.apify.com?tools=mabun/rss-feed-monitor`
Example prompt: *"What did TechCrunch and Hacker News publish about AI agents in the last 24 hours?"*

### Integrations

- **Schedules** – hourly/daily monitoring with `onlyNew`
- **Webhooks** – call your endpoint when new items arrive
- **Make, Zapier, n8n, Slack, Google Sheets, Airtable** – via Apify's ready-made integrations

### FAQ

**What if a site has no feed?** Auto-discovery looks for `<link rel="alternate">` feed tags. If a site publishes none, the URL is reported as an error (free of charge).

**How does monitor mode remember items?** Item IDs are stored in a named key-value store in your account, separately per `monitorId`. On the first run with a new monitor you get the current items; afterwards only new ones.

**Can I monitor hundreds of feeds?** Yes – add them all to `feedUrls`. The start fee is charged once per run, not per feed.

**Does it return full articles?** No – titles, links, summaries and (optionally) the content the feed itself provides. It does not scrape article pages.

**Does it work with podcast or YouTube feeds?** Yes. Tested on 22 Oct 2026: a podcast RSS feed (NPR Planet Money) returned episode titles, links and summaries; a YouTube channel feed (`https://www.youtube.com/feeds/videos.xml?channel_id=…`) returned video titles, links and dates, but no descriptions. Audio and video files are not downloaded.

### Limitations

- Only content the feed publishes; no full-article scraping
- Some sites block automated requests or publish malformed feeds – these are reported as errors
- Keyword matching works on title and summary (plus content if `includeContent` is on)
- Feed content remains the publisher's copyright – use it in line with their terms

### Related Actors by the same developer

- [PDF to Text & RAG Chunks](https://apify.com/mabun/pdf-text-extractor-rag) – turn linked PDFs (e.g. arXiv papers) into text for LLMs
- [EU Tenders Monitor Germany & Austria (TED)](https://apify.com/mabun/ted-tenders-dach) – new public tenders, same monitor mode
- [EPO Patent Search & Monitor](https://apify.com/mabun/epo-patent-search) – new European patents, same monitor mode

### Support

Feed not working? Open an issue on the **Issues** tab with the URL.

# Actor input Schema

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

RSS/Atom feed URLs, or website URLs (the feed is auto-discovered from <link rel=alternate>).

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

Only keep items whose title or summary contains at least one keyword (case-insensitive, matches at word start: "agent" matches "agents", "ki" does not match "Ukraine"). Empty = keep all.

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

Drop items containing any of these words.

## `maxAgeHours` (type: `integer`):

Ignore items published earlier than this. 0 = no limit.

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

Upper limit of items returned per feed.

## `onlyNew` (type: `boolean`):

Remember items between runs (named key-value store) and return only new ones. Use with a schedule.

## `monitorId` (type: `string`):

Separate memory per monitor when monitor mode is on.

## `includeContent` (type: `boolean`):

Adds the full item content (if the feed provides it) as plain text.

## Actor input object example

```json
{
  "feedUrls": [
    "https://hnrss.org/frontpage",
    "https://techcrunch.com/"
  ],
  "keywords": [],
  "excludeKeywords": [],
  "maxAgeHours": 0,
  "maxItemsPerFeed": 10,
  "onlyNew": false,
  "monitorId": "default",
  "includeContent": false
}
```

# Actor output Schema

## `feedItems` (type: `string`):

Feed entries (feed title, item title, link, published date, summary, categories, matched keywords).

# 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://techcrunch.com/"
    ],
    "keywords": [],
    "excludeKeywords": [],
    "maxItemsPerFeed": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("mabun/rss-feed-monitor").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://techcrunch.com/",
    ],
    "keywords": [],
    "excludeKeywords": [],
    "maxItemsPerFeed": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("mabun/rss-feed-monitor").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://techcrunch.com/"
  ],
  "keywords": [],
  "excludeKeywords": [],
  "maxItemsPerFeed": 10
}' |
apify call mabun/rss-feed-monitor --silent --output-dataset

```

## MCP server setup

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

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/fcRDrJi9u30aB4Zi5/builds/BQ4UjelpCiJXBdTbf/openapi.json