# RSS and Atom Feed Reader: New Items as JSON, Monitor Mode (`transparent_meteorite/rss-atom-feed-reader-monitor`) Actor

Read RSS, Atom and JSON Feed URLs into clean JSON. Feed auto-discovery from any website, new-items-only monitoring, full content, enclosures and images. No login.

- **URL**: https://apify.com/transparent_meteorite/rss-atom-feed-reader-monitor.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** News, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.56 / 1,000 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.
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 and Atom Feed Reader: New Items as JSON, Monitor Mode

Use this to turn RSS, Atom, RSS 1.0 (RDF) and JSON Feed addresses into one clean JSON row per article, find the feed behind any website address, and run it on a schedule so each run returns only the items you have not seen before. It is plain HTTP only: no login, no proxy and no browser.

Give it feed URLs, website addresses, or both. For a website address the Actor reads the page's `<link rel="alternate">` feed links first and then tries a few common feed paths (for example `/feed` and `/atom.xml`), checking each site's robots.txt before it looks.

### Run in 30 seconds

1. Open the **Input** tab. The prefilled list (four public feeds, 10 items each) is a ready-to-run test.
2. Click **Start**. The test run reads the four feeds and finishes in about 10 seconds.
3. Open the **Feed items** table in the Output tab, or download the dataset as JSON, CSV, Excel or HTML.
4. Replace the list with your own feeds. Turn on **Only new items** and schedule the Actor to build a change feed.

### What does this Actor do?

For every feed it is given, the Actor downloads the feed (capped at a size you set), parses it and delivers a flat row per item, newest first:

| Group | Fields |
|---|---|
| Feed | `feedTitle`, `feedUrl`, `feedLink`, `feedType` (`rss`, `atom`, `rss1` or `jsonfeed`) |
| Item | `itemTitle`, `link`, `guid`, `publishedAt`, `updatedAt`, `author`, `categories` |
| Text | `summary`, `contentText` (plain text of the article body when the feed carries it), `contentHtml` (original HTML, off by default) |
| Media | `enclosureUrl`, `enclosureType`, `enclosureLength` (podcast audio, attachments), `mediaUrl`, `imageUrl` |
| Source | `discoveredFrom` (the website address a feed was found from), `scrapedAt` |

What the input switches do:

- **Feed discovery.** Put a normal web page in Feed URLs or Website URLs and the Actor finds its feed. Up to 5 feed links are taken from a page.
- **Only new items.** The Actor remembers what it delivered (and each feed's ETag and Last-Modified values) in a named key-value store between runs, so a feed that has not changed is answered with a cheap "not modified" and costs nothing. Use **Monitor name** to keep separate memory for separate schedules.
- **Filters.** Keep only items newer than a date or a phrase like `3 days`, or only items whose title, summary, body or categories contain one of your keywords. Items that appear in two feeds are returned once.

### Use cases

- Competitor and brand news feed: watch the blogs and newsroom feeds of companies you track and push only new posts to Slack or a sheet.
- Podcast and media monitoring: collect new episodes with their audio `enclosureUrl` and publication date.
- Content aggregation: merge many blogs into one dataset, deduplicated by link, for a newsletter or a search index.
- Change alerts for public bodies: follow regulator, status-page and release-notes feeds and trigger a workflow on each new item.
- Feed inventory: give a list of websites, get back the feed address of every site that publishes one.

### Input

| Field | What it does |
|---|---|
| **Feed URLs** (`feedUrls`) | RSS, Atom or JSON Feed addresses. A normal web page address also works; its feed is found automatically. |
| **Website URLs** (`siteUrls`) | Sites to look up feeds for. |
| **Max items per feed** (`maxItemsPerFeed`) | Newest items first. Default 50, prefill 10. |
| **Max items** (`maxItems`) | Hard stop across all feeds. Default 500, prefill 50. |
| **Only new items** (`onlyNewItems`) | Return only items not delivered by an earlier run with the same monitor name. |
| **Monitor name** (`monitorName`) | Separate memory per name. |
| **Only items since** (`sinceDate`) | A date such as `2026-10-01`, or a phrase such as `3 days`, `12 hours`, `2 weeks`. |
| **Keywords** (`keywords`) | Keep items containing at least one keyword (case-insensitive). |
| **Include content / Include HTML** | Add the plain-text body, and optionally the original HTML. |
| **Max feed size (MB)** (`maxFeedMegabytes`) | Download cap per feed. A larger feed is cut at the last complete item and a warning is logged. |

#### Example input

```json
{
  "feedUrls": ["https://feeds.bbci.co.uk/news/rss.xml", "https://hnrss.org/frontpage"],
  "maxItemsPerFeed": 10,
  "onlyNewItems": true,
  "monitorName": "morning-news"
}
```

### Output

One row per feed item in the default dataset. The **Feed items** view shows published time, feed, title, author, link, summary, categories, image and enclosure. Fields that a feed does not provide are `null`, never missing. A run summary (feeds read, items per feed, warnings) is saved in the key-value store under `OUTPUT`.

#### Sample output

A real row from a run of the prefilled input (the summary text is shortened here, everything else is as returned; empty media fields trimmed):

```json
{
  "feedTitle": "Hacker News: Front Page",
  "feedUrl": "https://hnrss.org/frontpage",
  "feedLink": "https://news.ycombinator.com/",
  "feedType": "rss",
  "itemTitle": "Show HN: Flide: Make Jev-like decision models up to 9.5x faster",
  "link": "https://github.com/OmniJev/Flide",
  "guid": "https://news.ycombinator.com/item?id=50421155",
  "publishedAt": "2026-11-09T04:43:12.000Z",
  "updatedAt": null,
  "author": "unikcc",
  "categories": [],
  "summary": "Decision models need their own inference engine. So we developed Flide ... Comments URL: https://news.ycombinator.com/item?id=50421155 Points: 9 # Comments: 1",
  "contentText": null,
  "enclosureUrl": null,
  "imageUrl": null,
  "discoveredFrom": null,
  "scrapedAt": "2026-11-09T07:47:02.134Z"
}
```

The prefilled run returned 40 items from four feeds (BBC News, NASA, Hacker News front page, GitHub Blog) in 8 seconds of run time.

### Pricing

Pay per item returned: **$0.00093 per item on the free plan** (Bronze $0.00086, Silver $0.00073, Gold $0.00056), plus a $0.00005 start fee per run. A 1,000-item run costs about $0.93 on the free plan. Items skipped by your filters, items already delivered in monitor mode and duplicates across feeds are never charged, and a feed answered with "not modified" returns nothing and costs nothing. The prefilled test run was charged for 40 items. Set the run-level **Maximum cost per run** to cap spend; the Actor stops cleanly when the cap is reached and keeps what it delivered.

### Use with the API, n8n, Make, Zapier or AI agents

**API** (one call, returns the rows as JSON):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~rss-atom-feed-reader-monitor/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"feedUrls":["https://feeds.bbci.co.uk/news/rss.xml","https://hnrss.org/frontpage"],"maxItemsPerFeed":10,"maxItems":50}'
```

The call waits up to 5 minutes. For bigger inputs, start the run with `/runs` instead and read the dataset when it finishes.

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/rss-atom-feed-reader-monitor").call(run_input={"feedUrls": ["https://feeds.bbci.co.uk/news/rss.xml", "https://hnrss.org/frontpage"], "maxItemsPerFeed": 10, "maxItems": 50})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row)
```

- **n8n, Make, Zapier:** use the Apify app's "Run Actor" step with actor `transparent_meteorite/rss-atom-feed-reader-monitor`, paste the input JSON, then map the dataset items to your sheet or CRM.
- **Clay:** add an HTTP API column that calls the run-sync endpoint above.
- **Schedules:** in Apify Console, Schedules, run it daily or weekly with the same input for a steady feed.
- **AI agents (MCP):** connect the Apify MCP server at `https://mcp.apify.com?tools=transparent_meteorite/rss-atom-feed-reader-monitor` to Claude, Cursor or any MCP client, and your agent can run RSS Autodiscovery Monitor on request.

### FAQ

**Which feed formats does it read?** RSS 2.0, RSS 1.0 (RDF), Atom and JSON Feed.

**Can I give it a normal website address?** Yes. It reads the page's feed links, and if there are none it tries a few common paths such as `/feed`, `/rss.xml`, `/atom.xml` and `/feed.xml`.

**How does monitor mode avoid repeats?** It stores a hash of each delivered item (by link, or guid, or title plus date) and each feed's ETag and Last-Modified in a named key-value store, and sends conditional requests next time. The store keeps the most recent 50,000 item hashes.

**Do I need a login or API key?** No.

**Why did a feed return no items?** The feed may have no items matching your keywords or date, it may have nothing new, or it may have failed; the run status message and the `OUTPUT` record list each feed's error.

**Does it respect robots.txt?** Feed discovery checks robots.txt before fetching a page. Feeds you list directly are fetched as the publisher intends them to be: feeds are published for machines to read.

**Can it read feeds behind a paywall or login?** No.

### Limits

- Public `http` and `https` feeds only. Addresses on localhost or private networks are refused.
- Up to 1,000,000 items per run in total and 100,000 per feed; the Actor reads four feeds at a time and spaces requests to the same host.
- Feed size is capped per feed (default 5 MB, maximum 50 MB); a larger feed is read up to the last complete item.
- A run stops reading new feeds after about 4.5 minutes and keeps what it has, so very long feed lists should be split across runs.
- It returns what the feed contains. Many feeds carry only a summary; the Actor does not open the article page to fetch the full text.
- Feed discovery takes at most 5 feed links from a page.

### Related actors

- [Company News Monitor](https://apify.com/transparent_meteorite/company-news-monitor) for brand and keyword news across publisher feeds.
- [Wayback Page Change Tracker](https://apify.com/transparent_meteorite/wayback-page-change-tracker) for pages that have no feed.
- [Sitemap Link Inventory](https://apify.com/transparent_meteorite/sitemap-link-inventory) to list every URL a site publishes.

### Support

Found a bug or need a field? Open an issue on the Issues tab with the run URL and you will get a reply there.

### Changelog

- **0.1**: First build: RSS, Atom, RSS 1.0 and JSON Feed reading, feed auto-discovery, new-items-only monitor mode, keyword and date filters.

# Actor input Schema

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

RSS, Atom or JSON Feed addresses. A normal web page address also works: its feed is found automatically.

## `siteUrls` (type: `array`):

Website or blog addresses (e.g. https://example.com). The actor reads the page's feed links (link rel=alternate) and falls back to common paths such as /feed and /rss.xml. Respects robots.txt.

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

Newest items first. You are charged per item returned.

## `maxItems` (type: `integer`):

Hard stop across all feeds. Also protects your budget.

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

Remember what was delivered (and each feed's ETag / Last-Modified) between runs and return only items you have not received before. Schedule the actor to monitor feeds. Unchanged feeds are skipped with a conditional request.

## `monitorName` (type: `string`):

Separate memory per name, so two schedules can watch different feeds independently. Used with Monitor mode.

## `sinceDate` (type: `string`):

A date like 2026-10-01 or 2026-10-01T12:00:00Z, or a phrase like 3 days, 12 hours, 2 weeks. Items without a date are kept.

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

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

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

Add the plain-text article body when the feed carries it (content:encoded, Atom content, JSON Feed content).

## `includeHtml` (type: `boolean`):

Also return the feed's original HTML content in contentHtml.

## `maxFeedMegabytes` (type: `number`):

Download cap per feed. A larger feed is cut at the last complete item and a warning is logged.

## Actor input object example

```json
{
  "feedUrls": [
    "https://feeds.bbci.co.uk/news/rss.xml",
    "https://www.nasa.gov/feed/",
    "https://hnrss.org/frontpage",
    "https://github.blog/feed/"
  ],
  "maxItemsPerFeed": 10,
  "maxItems": 50,
  "onlyNewItems": false,
  "monitorName": "default",
  "includeContent": true,
  "includeHtml": false,
  "maxFeedMegabytes": 5
}
```

# Actor output Schema

## `items` (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 = {
    "feedUrls": [
        "https://feeds.bbci.co.uk/news/rss.xml",
        "https://www.nasa.gov/feed/",
        "https://hnrss.org/frontpage",
        "https://github.blog/feed/"
    ],
    "maxItemsPerFeed": 10,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/rss-atom-feed-reader-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://feeds.bbci.co.uk/news/rss.xml",
        "https://www.nasa.gov/feed/",
        "https://hnrss.org/frontpage",
        "https://github.blog/feed/",
    ],
    "maxItemsPerFeed": 10,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/rss-atom-feed-reader-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://feeds.bbci.co.uk/news/rss.xml",
    "https://www.nasa.gov/feed/",
    "https://hnrss.org/frontpage",
    "https://github.blog/feed/"
  ],
  "maxItemsPerFeed": 10,
  "maxItems": 50
}' |
apify call transparent_meteorite/rss-atom-feed-reader-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/rss-atom-feed-reader-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/tBTxuESGvbjBHgZGL/builds/KwyPcLtt2GbMgn1OF/openapi.json