# RSS Feed Monitor & Parser: New Items to JSON, Sheets, Slack (`lepidata/rss-monitor`) Actor

RSS & Atom feed monitor: new items only, as JSON with dates, links and summaries. Works with Apify's Sheets & Slack integrations. $0.90 per 1,000 items.

- **URL**: https://apify.com/lepidata/rss-monitor.md
- **Developed by:** [Lepi Data](https://apify.com/lepidata) (community)
- **Categories:** News, Automation, Integrations
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 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 Feed Monitor & Parser: New Items to JSON, Sheets, Slack

Give it a list of RSS, Atom or RDF feeds and run it on a schedule. Each run returns **only the items that are new since your last run**: title, link, publish date, the feed's short summary and its item id. Plug the dataset into Google Sheets, Slack, Make, n8n, Zapier or a webhook for alerts.

### Common uses

- **News monitoring and keyword alerts**: track blogs, Reddit or Hacker News feeds, and get new items only.
- **RSS to JSON / CSV / Google Sheets**: parse any RSS or Atom feed into clean rows.
- **RSS to Slack, Discord or email** through Apify integrations, Make, n8n or Zapier.
- **Podcast and YouTube channel feeds**: get new episodes and videos as they appear.

### Example inputs

Paste any of these into the JSON input tab:

**Tech news**

```json
{"feedUrls": ["https://hnrss.org/frontpage"], "maxItemsPerFeed": 20}
```

**Two feeds at once**

```json
{"feedUrls": ["https://hnrss.org/frontpage", "https://www.nasa.gov/feed/"], "maxItemsPerFeed": 10}
```

**Start silent, alert only on new items**

```json
{"feedUrls": ["https://www.nasa.gov/feed/"], "startFromNow": true, "stateKey": "nasa"}
```

### What you get

| Field | Meaning |
|---|---|
| `type` | `item` for a new item; free status rows otherwise |
| `feedTitle`, `feedUrl` | Which feed it came from |
| `title`, `link`, `published`, `guid` | As the feed gives them (dates in ISO 8601) |
| `summary` | The feed's own summary, HTML removed, max 500 characters |

The Actor reads feeds only. It **never opens the article pages** and never returns full article text, so you get a pointer to new content, not a copy of it.

### Pricing

**$0.90 per 1,000 new items** (pay per event `item`). Free (apart from Apify's tiny per-run start fee): feeds that haven't changed (the Actor asks with ETag / If-Modified-Since and most servers answer "not modified"), feeds that can't be read (`feed-error` rows with the reason), the `startFromNow` baseline, and the charge-limit row. Set a maximum charge per run and the Actor stops cleanly when it's reached; undelivered items come through on a later run and are never billed twice.

Free-plan accounts can check up to 20 feeds and get up to 25 new items per run to try it out; the run ends with one free row explaining the limit. Paid Apify plans get full results.

### Options

- `startFromNow`: first run records what's in each feed now, for free, so you only pay for items published afterwards. With it off, the first run returns every item currently in each feed (up to `maxItemsPerFeed`) as new, and those are billed.
- `stateKey`: keep separate monitors apart. Same key = same memory of seen items.
- `maxItemsPerFeed` (default 100): newest first; extra new items in one run are skipped.

### Good to know

- Item identity is the feed's guid/id, else the link. If a publisher changes an item's guid, it shows up as new once.
- Publisher refresh hints are honored: RSS `<ttl>` and `sy:updatePeriod`/`sy:updateFrequency`, plus HTTP 429 / `Retry-After`. Until that interval has passed (at most 7 days), the feed is not requested and you get a free `feed-skipped-refresh-interval` row with `nextAllowedAt`.
- robots.txt is checked for every feed. Feeds disallowed for crawlers, or whose robots.txt can't be read, are skipped as free rows.
- Only public http/https feeds; private, internal and cloud-metadata addresses are refused. Feeds are capped at 2 MB and 20 seconds.
- Remembered state holds short hashes of item ids, not feed content. The one exception: if your charge limit stops a run, the items not yet delivered (title, link, date, summary, id only; at most 500 items / 512 KB per feed) are kept so the next run can return them first without asking the publisher again.

### FAQ

**What does it access?** Only the public feeds you list, which publishers provide for automated reading, and only if robots.txt allows it. It returns titles, links, dates and the publisher's own short summaries, never full articles. Respect each publisher's terms if you republish anything.

**How often should I run it?** Hourly or daily suits most feeds. Don't poll more often than the publisher's feed allows; the monitor skips a feed (free) until the refresh interval the feed publishes has passed.

# Actor input Schema

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

RSS 2.0, Atom or RDF feed URLs (not web pages). Public http/https only; private, internal and unusual addresses are refused with a free error row. Up to 1,000 per run.

## `startFromNow` (type: `boolean`):

On the first run for a feed, record the items it has now without returning or charging for them. Later runs return only items published after that. Ignored for feeds already tracked under this state key.

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

Name for this monitor. Runs with the same key remember which items you already got. Use different keys for separate monitors.

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

Newest items first. New items beyond this limit are skipped and not returned later.

## Actor input object example

```json
{
  "feedUrls": [
    "https://hnrss.org/frontpage",
    "https://www.nasa.gov/feed/"
  ],
  "startFromNow": false,
  "stateKey": "default",
  "maxItemsPerFeed": 100
}
```

# Actor output Schema

## `items` (type: `string`):

All rows from this run.

# 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://www.nasa.gov/feed/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lepidata/rss-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://www.nasa.gov/feed/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("lepidata/rss-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://www.nasa.gov/feed/"
  ]
}' |
apify call lepidata/rss-monitor --silent --output-dataset

```

## MCP server setup

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