# RSS Feed Reader & Monitor: New Items to JSON + Full Text (`pewterdesk/rss-feed-monitor-full-text`) Actor

RSS feed reader and monitor for any RSS/Atom feed or website (feeds are auto-discovered). Each run returns only new items as clean JSON, with keyword filters and optional full article text as Markdown for LLMs. Built for schedules: old items are never billed twice.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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 & Monitor: New Items to JSON + Full Text

**RSS feed reader and RSS monitor:** turn any RSS or Atom feed (or a website that has one) into clean JSON, and get only the new items on every scheduled run. 

Monitor news sites, blogs, competitors, release notes, job boards, podcasts or any RSS/Atom feed. **Each run returns only the items you haven't seen yet**, so you can schedule it every 15 minutes and never pay twice for the same article.

- **Pass feeds or plain website URLs.** Feeds are auto-discovered from `<link rel="alternate">` and common paths such as `/feed` and `/rss.xml`.
- **Remembers what you've seen** across runs, in your own named key-value store. Run separate monitors with different *state names*. It also uses ETag and Last-Modified, so unchanged feeds cost nothing.
- **Full article text as clean Markdown.** Navigation, ads and boilerplate are removed, so it's ready for LLM summarisation, RAG or newsletters. The Actor uses the feed's own content when present, otherwise the article page, and respects robots.txt.
- **Keyword include and exclude filters** (whole-word), a maximum item age, and a per-feed cap.
- **Clean, consistent fields** across RSS 0.9x/1.0/2.0 and Atom: canonical link (tracking parameters stripped), ISO dates, author, categories, image and enclosures (podcasts).

### Typical setups

| Use case | Settings |
|---|---|
| Competitor and industry news alerts | Schedule hourly, add include keywords, connect the Slack or email integration |
| AI newsletter or digest | `fetchFullText: true`, then feed the Markdown to your LLM |
| Podcast and video monitoring | Use the enclosures field for audio and video URLs |
| Alerts for future posts only | `firstRunMode: "baseline"` on the first run |

### Input example

```json
{
  "feedUrls": ["https://github.blog/feed/", "https://simonwillison.net/", "https://feeds.bbci.co.uk/news/technology/rss.xml"],
  "onlyNewItems": true,
  "stateName": "tech-news",
  "fetchFullText": true,
  "includeKeywords": ["AI", "security"],
  "maxAgeDays": 7
}
```

### Output example

```json
{
  "type": "item",
  "feedUrl": "https://github.blog/feed/",
  "feedTitle": "The GitHub Blog",
  "title": "ReviewBench: An open benchmark for AI code review",
  "link": "https://github.blog/ai-and-ml/...",
  "published": "2026-10-05T15:59:40+00:00",
  "author": "...",
  "categories": ["AI & ML"],
  "summary": "...",
  "matchedKeywords": ["AI"],
  "fullTextStatus": "ok",
  "contentMarkdown": "## Why we built ReviewBench\n\n...",
  "wordCount": 1773,
  "firstSeenAt": "2026-10-11T19:05:00+00:00"
}
```

Feeds that can't be reached produce a free `type: "error"` row, so you can see broken sources at a glance.

### Pricing (pay per event)

| Event | Price |
|---|---|
| New item returned | $0.0005 |
| Full article text extracted (only when it succeeds) | $0.002 |
| Already-seen items, unchanged feeds, errors | free |

For example, 20 feeds checked hourly with about 3 new items a day each cost about $0.03 a day, or $0.18 a day with full text. If a run hits your spending limit, items that weren't delivered are kept and returned in the next run.

### FAQ

**Where is the memory stored?** In a named key-value store in *your* account (`rss-monitor-<stateName>`). Delete it, or use *Reset memory*, to start over.

**Paywalled or JavaScript-only sites?** Full text needs the article in the page HTML. Otherwise you still get the feed's title, summary and link, and `fullTextStatus` explains why.

**Is this allowed?** Feeds are published for syndication. The Actor fetches article pages politely, respects robots.txt, and identifies itself. Respect each publisher's terms when you republish content.

***

Built by **PewterDesk** ([pewterdesk.pages.dev](https://pewterdesk.pages.dev)). More tools: [apify.com/pewterdesk](https://apify.com/pewterdesk).

# Actor input Schema

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

RSS/Atom feed URLs, or plain website/blog URLs (the feed is auto-discovered).

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

Remember what was returned before (per 'State name') and skip it in later runs. Ideal with a schedule.

## `stateName` (type: `string`):

Separate memories for separate monitors (e.g. 'competitors', 'client-a'). Stored in your own named key-value store.

## `firstRunMode` (type: `string`):

What to do the first time a feed is seen.

## `resetState` (type: `boolean`):

Forget previously seen items for this state name.

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

Extract the full article as Markdown (from the feed if it carries it, otherwise from the article page; robots.txt respected). Billed only when extraction succeeds.

## `summaryMaxLength` (type: `integer`):

Characters of the feed summary to keep (0 = full).

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

Only return items whose title, summary or categories mention any of these (whole-word, case-insensitive).

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

Drop items mentioning any of these.

## `maxAgeDays` (type: `integer`):

Skip items older than this (0 = no limit).

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

Newest first. Older overflow is skipped and not returned later (0 = no limit).

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

How many feeds are fetched at once.

## Actor input object example

```json
{
  "feedUrls": [
    "https://github.blog/feed/",
    "https://feeds.bbci.co.uk/news/technology/rss.xml"
  ],
  "onlyNewItems": true,
  "stateName": "default",
  "firstRunMode": "return_all",
  "resetState": false,
  "fetchFullText": false,
  "summaryMaxLength": 1000,
  "maxAgeDays": 0,
  "maxItemsPerFeed": 50,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

New feed items since the previous run, optionally with full article Markdown (default dataset).

## `runSummary` (type: `string`):

Counts for this run (processed, failed, stopped at spending limit) as JSON.

# 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://github.blog/feed/",
        "https://feeds.bbci.co.uk/news/technology/rss.xml"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("pewterdesk/rss-feed-monitor-full-text").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://github.blog/feed/",
        "https://feeds.bbci.co.uk/news/technology/rss.xml",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("pewterdesk/rss-feed-monitor-full-text").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://github.blog/feed/",
    "https://feeds.bbci.co.uk/news/technology/rss.xml"
  ]
}' |
apify call pewterdesk/rss-feed-monitor-full-text --silent --output-dataset

```

## MCP server setup

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

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/tOmANopkJxOMA7eMe/builds/gDQ1ASOg0ZwXWGkwj/openapi.json