# RSS & Atom Feed Monitor - New Items Only + Feed Finder (`lindenbyte/rss-feed-monitor-new-items`) Actor

Read any RSS, Atom, RDF or JSON Feed (or just paste a website / YouTube channel URL and it finds the feed). Schedule it and get only NEW items since the last run, with keyword and date filters. Pay only for new items.

- **URL**: https://apify.com/lindenbyte/rss-feed-monitor-new-items.md
- **Developed by:** [Lindenbyte Studio](https://apify.com/lindenbyte) (community)
- **Categories:** Developer tools, News, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.56 / 1,000 new 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 & Atom Feed Monitor: New Items Only + Feed Finder

Read **any RSS, Atom, RSS 1.0/RDF or JSON Feed** and get clean, normalised items: title, link, date, author, plain-text summary, categories, image, and podcast/video enclosures. You don't need the feed URL: paste a **website, blog, news site or YouTube channel** and the Actor finds the feed for you. Then schedule it. In **monitoring mode** each run outputs **only the items that are new since the last run**, and you pay only for those new items.

**Step-by-step tutorial:** [Get alerts for new blog posts and YouTube videos without duplicates](https://dev.to/lindenbyte/get-alerts-for-new-blog-posts-and-youtube-videos-without-duplicates-2a81)

### Why this one

- **New items only, across runs.** The Actor remembers every item it has seen in each feed (by guid, link, or title + date) and outputs just the new ones. Schedule it hourly or daily for a clean stream of new posts, releases, videos or episodes, with no duplicates to clean up in Zapier, Make or Slack.
- **Pay only for new items.** Items you already got, items your filters remove, and the silent baseline are all free. A feed with nothing new costs nothing beyond the small start fee.
- **Finds the feed for you.** For a homepage or blog URL it reads the `<link rel="alternate">` feed tags and then tries the common paths (`/feed`, `/rss`, `/feed.xml`, `/rss.xml`, `/atom.xml`, `/index.xml`, `/feed.json`). YouTube `channel/UC...`, `@handle` and playlist URLs become their official video feeds.
- **Feed finder mode.** Paste a list of websites and get one row per working feed, with its format, item count and the date of the latest item. It also shows you which blogs are dead.
- **Handles real-world feeds.** RSS 2.0, RSS 0.9x, RSS 1.0/RDF, Atom 1.0, JSON Feed 1.0/1.1, CDATA, HTML entities, Atom XHTML content, gzip, byte-order marks, non-UTF-8 encodings (e.g. ISO-8859-1), and wrong `Content-Type` headers.
- **Keyword and date filters.** Include/exclude keywords (matched in the title and summary) and `publishedAfter` (`2026-11-01` or relative, like `7 days`).
- **Polite and fast.** Conditional GET (ETag / Last-Modified), so an unchanged feed is a tiny HTTP 304. A per-host throttle, retries with backoff on 429/5xx, and a pure HTTP client: no browser, no proxy.

### Use cases

- **Content monitoring.** Track industry blogs, newsletters, changelogs and documentation updates.
- **Competitor blog watch.** Get every new post from competitors' blogs the day it is published (pair it with our Sitemap Monitor for pages that are not in a feed).
- **News alerts to Slack, email, Zapier or Make.** Schedule the Actor and connect an integration or webhook ("Run succeeded", then read the dataset). Only new items arrive, so each alert is new.
- **Podcast new-episode tracking.** Get the audio enclosure URL, file size and episode artwork for every new episode.
- **YouTube upload alerts.** Paste channel URLs and get every new video with its link, description and thumbnail.
- **GitHub release tracking.** Use `https://github.com/<owner>/<repo>/releases.atom` to follow releases of the libraries you depend on.
- **Security advisories.** Monitor vendor and distribution advisory feeds, with keywords for the products you run.
- **Feed finder.** Find the RSS feed of hundreds of websites at once, for a reader, an aggregator or a lead list of active blogs.

### Input

| Field | What it does |
|---|---|
| `startUrls` | Feed URLs, or any website / blog / YouTube channel / playlist URL (the feed is found automatically) |
| `onlyNewItems` | Monitoring mode (default **on**): output only items not seen on previous runs, per feed |
| `emitOnBaseline` | First run of a monitor: output the current items (on, the default) or just remember them (off) |
| `statusRowWhenEmpty` | On (default): a run with nothing new adds one free `run-status` row. Off: empty dataset |
| `stateKey` | Name of the monitor; different names keep separate memories |
| `maxItemsPerFeed` | Cost cap: max items output per feed per run, newest first (default 50) |
| `includeKeywords` / `excludeKeywords` | Case-insensitive keywords matched in the title and summary |
| `publishedAfter` | Only items published after a date or a relative time (`24 hours`, `7 days`, `2 weeks`) |
| `includeContent` | Add `contentHtml` (the full HTML content from the feed) |
| `useAllDiscoveredFeeds` | Monitor every feed a website advertises (posts, podcast, categories), not only the main one |
| `discoverOnly` | Feed finder mode: list the feeds, don't read the items |

#### Example: daily new-posts monitor, filtered

```json
{
  "startUrls": ["https://wordpress.org/news/", "https://github.com/apify/crawlee/releases.atom", "https://www.youtube.com/@GoogleDevelopers"],
  "onlyNewItems": true,
  "emitOnBaseline": false,
  "includeKeywords": ["release", "security", "AI"]
}
```

Create a schedule (Console > Schedules), then add an integration (Slack, email, Zapier, Make or a webhook) that fires on each successful run.

#### Example: find the feeds of many websites

```json
{ "startUrls": ["github.blog", "https://www.theverge.com/", "daringfireball.net"], "discoverOnly": true }
```

### Output

One row per item. This is a real example (YouTube channel feed found from an `@handle` URL):

```json
{
  "feedUrl": "https://www.youtube.com/feeds/videos.xml?channel_id=UC_x5XG1OV2P6uZZ5FSM9Ttw",
  "feedTitle": "Google for Developers",
  "siteUrl": "https://www.youtube.com/channel/UC_x5XG1OV2P6uZZ5FSM9Ttw",
  "feedType": "atom",
  "guid": "yt:video:vLAegkGGWrM",
  "title": "Building with Gemini in Google Antigravity",
  "link": "https://www.youtube.com/watch?v=vLAegkGGWrM",
  "published": "2026-11-12T17:00:11.000Z",
  "updated": "2026-11-12T17:04:24.000Z",
  "author": "Google for Developers",
  "summary": "See what you can build using our latest Gemini models in Google Antigravity. From in-browser animation and multimodal prototyping to autonomous codebase modernization, ...",
  "categories": [],
  "enclosure": null,
  "imageUrl": "https://i3.ytimg.com/vi/vLAegkGGWrM/hqdefault.jpg",
  "isNew": true,
  "firstSeenAt": "2026-11-16T09:38:22.029Z",
  "inputUrl": "https://www.youtube.com/@GoogleDevelopers",
  "scrapedAt": "2026-11-16T09:38:22.029Z"
}
```

Podcast items include the audio file:

```json
"enclosure": { "url": "https://wordpress.org/news/podcast-download/17684/episode-86-my-first-wordpress-experience.mp3", "type": "audio/mpeg", "length": 10013967 }
```

In feed finder mode each row has `inputUrl`, `feedUrl`, `feedTitle`, `feedType` (rss / atom / rdf / json), `discoveredVia` (direct / link-tag / common-path / youtube), `itemCount`, `latestItemTitle` and `latestItemPublished`.

A per-feed run summary (items in the feed, new, filtered, HTTP 304, errors) is saved to the key-value store record `RUN-SUMMARY`. Feeds that fail are listed there and in the log, not in the dataset, so you never pay for an error row. If no feed at all can be read (site down, blocked or rate-limited), the run still finishes normally with a status message saying so, so check the status message or `RUN-SUMMARY` when a scheduled run returns nothing.

**Empty runs leave one free status row.** When a run outputs no items (nothing new since the last run, a silent baseline, or no feed readable), the dataset gets exactly one row with `"type": "run-status"`, a `status` (`no-new-items`, `baseline-recorded`, `no-feed-readable`, `no-feeds-found`) and a human-readable `title`. It is never charged. Item rows never have this `type`, so filter it out in your integration, or set `statusRowWhenEmpty` to `false` to get an empty dataset instead.

### Pricing

Pay per result: you pay a small fee per run plus a fee per item output (or per feed found in feed finder mode). Already-seen items, filtered items and silent baselines are free. Set a maximum charge per run in the run options to cap your cost.

### Limits (honest)

- A feed shows only its latest N items (often 10 to 50). If more than N posts are published between two runs, the older ones fall out of the feed before the Actor can see them. Schedule more often for busy feeds.
- "New" means the item's identity (guid, else link, else title + date) was not seen before. A publisher that changes guids re-publishes items as new; edited items with the same guid are not reported again.
- Discovery reads one page per URL plus at most 6 common paths. Sites with no feed at all return a clear error for that URL (this is not a website-to-RSS generator).
- YouTube `@handle` URLs need one plain fetch of the channel page. If YouTube shows a consent or bot page, the Actor says so: use the `youtube.com/channel/UC...` URL instead.
- Feeds behind logins, paywalls or bot protection (Cloudflare challenges) are not supported. No proxies are used.
- Monitoring state lives in the named key-value store `rss-feed-monitor-state` in your account. Changing `stateKey` starts a fresh baseline.

### Legal

Reads public feeds that publishers provide for automated consumption, plus one public page per URL for discovery, with a clear user agent. Author names are output only as the feed publishes them. Respect each publisher's terms when you republish content. Not affiliated with YouTube, Google, GitHub, WordPress or any publisher whose feed it reads.

### More from Lindenbyte

- [Sitemap Monitor: All URLs + New Pages Since Last Run](https://apify.com/lindenbyte/sitemap-monitor-new-pages): Extract every URL from a site's XML sitemaps and get only the pages added since the last run.
- [Bulk Website Screenshots + PDF + Visual Change Detection](https://apify.com/lindenbyte/bulk-website-screenshots): Full-page or viewport screenshots (and PDFs) of many URLs, with optional visual change detection.
- [Shopify Catalog & Change Monitor: Prices, Stock, New Products](https://apify.com/lindenbyte/shopify-catalog-change-monitor): Public product catalogs of Shopify stores, or only new products, price changes and restocks since the last run.
- [Bulk Website Tech Stack Detector (7,000+ technologies)](https://apify.com/lindenbyte/bulk-website-tech-stack-detector): Detect the CMS, ecommerce platform, analytics and frameworks behind a list of websites.

See all our Actors at [apify.com/lindenbyte](https://apify.com/lindenbyte).

# Actor input Schema

## `startUrls` (type: `array`):

RSS, Atom, RDF or JSON Feed URLs, or any website / blog / news page / YouTube channel URL. For a web page the feed is found automatically (<link rel="alternate"> tags, then common paths like /feed and /rss.xml). YouTube: youtube.com/channel/UC..., youtube.com/@handle and playlist URLs work.

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

Remembers which items each feed already had (in your named key-value store 'rss-feed-monitor-state') and outputs only items that were not there on the previous run. Schedule the Actor (hourly/daily) to get a stream of new posts, releases, videos or episodes. Already-seen items are free. Off = output the current items of every feed on every run.

## `emitOnBaseline` (type: `boolean`):

Only for monitoring mode. The first run for a feed has nothing to compare to. On = output the current items (up to 'Max items per feed'). Off = silently remember them and output nothing, so you only ever get truly new items (cheapest way to start).

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

Only for monitoring mode. Monitors with different names keep separate memories (e.g. one per schedule, client or Slack channel). Change it to start a fresh baseline. Leave empty to use the name "default".

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

Cost cap: at most this many items are output (and charged) per feed per run, newest first. In monitoring mode, new items above the cap are output on the next run (except on the baseline run, which only samples the newest).

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

Optional. Case-insensitive; matched against the item title and summary/content. An item is kept if it contains at least one keyword. Filtered items are free.

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

Optional. Case-insensitive; items whose title or summary/content contains any of these are dropped (free).

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

Optional. A date (2026-11-01, 2026-11-01T08:00:00Z) or a relative time such as '7 days', '24 hours', '2 weeks', '1 month'. Items without a date are kept.

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

Add a contentHtml field with the item's full HTML content as published in the feed (content:encoded, Atom content, JSON content_html). Off keeps the dataset small; a plain-text summary is always included.

## `useAllDiscoveredFeeds` (type: `boolean`):

When a web page advertises several feeds (posts, comments, podcast, categories), monitor all of them (max 10 per page). Off = only the main feed (comment feeds are skipped).

## `discoverOnly` (type: `boolean`):

Do not read items. Output one row per working feed found for each URL (feed URL, title, format, item count, date of the latest item). Use it to find the RSS feed of many websites at once.

## `statusRowWhenEmpty` (type: `boolean`):

When a run outputs no items (nothing new since the last run, baseline recorded silently, or no feed readable), add ONE free status row (type 'run-status', not charged) so integrations and dataset checks can tell the run worked. Turn off if your integration should get an empty dataset instead. Real items never have type 'run-status'.

## Actor input object example

```json
{
  "startUrls": [
    "https://wordpress.org/news/",
    "https://blog.apify.com/rss/",
    "https://github.blog/feed/"
  ],
  "onlyNewItems": true,
  "emitOnBaseline": true,
  "maxItemsPerFeed": 50,
  "includeKeywords": [],
  "excludeKeywords": [],
  "includeContent": false,
  "useAllDiscoveredFeeds": false,
  "discoverOnly": false,
  "statusRowWhenEmpty": true
}
```

# Actor output Schema

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

No description

## `feeds` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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 = {
    "startUrls": [
        "https://wordpress.org/news/",
        "https://blog.apify.com/rss/",
        "https://github.blog/feed/"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("lindenbyte/rss-feed-monitor-new-items").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 = {
    "startUrls": [
        "https://wordpress.org/news/",
        "https://blog.apify.com/rss/",
        "https://github.blog/feed/",
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("lindenbyte/rss-feed-monitor-new-items").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 '{
  "startUrls": [
    "https://wordpress.org/news/",
    "https://blog.apify.com/rss/",
    "https://github.blog/feed/"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call lindenbyte/rss-feed-monitor-new-items --silent --output-dataset

```

## MCP server setup

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

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/ubu6734PU9BY7dppT/builds/aaD9UGDdjsRy6zmej/openapi.json
