# RSS & Atom Feed Reader - Monitor Feeds, Only New Items (`paperlinenstudio/rss-feed-reader`) Actor

Read any RSS, Atom or JSON feed - or just paste a website URL and the feed is auto-discovered. Clean items with title, link, date, author, text, image and podcast enclosures. Date and keyword filters, an 'only new items' mode for scheduled monitoring and a per-feed error summary.

- **URL**: https://apify.com/paperlinenstudio/rss-feed-reader.md
- **Developed by:** [Paper & Linen Studio](https://apify.com/paperlinenstudio) (community)
- **Categories:** News, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.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 & Atom Feed Reader – Monitor Feeds, Only New Items

Turn **any RSS, Atom or JSON feed into clean, structured data**, or just paste a **website URL** and let the Actor find the feed for you. You get one row per article, episode or post with title, link, publication date (normalized to ISO 8601 UTC), author, categories, summary, plain text, image and podcast enclosures. Built for **scheduled monitoring**: with *Only new items* each run returns just the items you have not received yet. Feeds that did not change are skipped with HTTP 304, so a monitor of 100 feeds runs in seconds.

### Why this Actor

- 🔎 **Feed auto-discovery.** Enter `https://www.tagesschau.de` and the Actor finds `index~atom.xml` through `<link rel="alternate">`, feed links on the page, or common paths (`/feed`, `/rss.xml`, `/atom.xml`, `/index.xml`, Blogger, WordPress …).
- 📰 **All formats in one schema.** RSS 2.0, RSS 1.0/RDF, Atom and JSON Feed, with Dublin Core, `content:encoded`, Media RSS and iTunes podcast tags. Dates in RFC 822, ISO 8601 and even German weekday/month names are normalized to UTC.
- 🔔 **Only new items (monitoring mode).** Remembers what it delivered (per feed, in a named key-value store) and uses ETag / Last-Modified, so you only pay for and process what is new. Use separate *state keys* for separate monitors.
- 🎯 **Filters.** Published within the last N days or after a date, include/exclude keywords (whole words, case-insensitive) or regular expressions with the `re:` prefix.
- 🎙️ **Podcast-ready.** Audio/video enclosures with type and size, episode duration and cover image.
- 🧾 **Per-feed summary.** A `SUMMARY` record lists every input with the resolved feed URL, HTTP status, items found/saved/filtered/already seen and the error if a feed failed. One broken feed never breaks the run.
- ⚡ **Fast and cheap.** Pure HTTP, no browser, no proxy. 11 feeds with 122 items in about 5 seconds at 256 MB.

### Use cases

- **News and media monitoring:** brand, competitor or keyword alerts from news sites and blogs
- **Content aggregation:** feed a newsletter, Slack/Teams channel, Google Sheet or website
- **AI / LLM pipelines:** fresh articles with clean text for RAG, summarization or classification
- **Podcast data:** episode lists with audio URLs and durations
- **Release and changelog tracking:** GitHub releases (`/releases.atom`), product blogs, status pages
- **SEO and PR:** who published what, and when

### Input

| Field | Description |
|---|---|
| `feedUrls` | Feed URLs or website URLs (feed is auto-discovered) |
| `maxItemsPerFeed` / `maxItems` | Limits per feed (default 100) and per run |
| `onlyNew` + `stateKey` | Monitoring mode: only items not delivered in earlier runs |
| `publishedWithinDays` / `publishedAfter` | Date filter; `keepItemsWithoutDate` (default on) |
| `includeKeywords` / `excludeKeywords` | e.g. `["AI", "re:\\bKI\\b"]` |
| `includeContentHtml`, `maxTextLength` | Output options |
| `autodiscover`, `concurrency` | Advanced |

```json
{
  "feedUrls": [
    {"url": "https://www.theverge.com/rss/index.xml"},
    {"url": "https://www.tagesschau.de"},
    {"url": "https://github.com/apify/crawlee/releases.atom"}
  ],
  "onlyNew": true,
  "includeKeywords": ["AI", "Apple"],
  "maxItemsPerFeed": 50
}
```

**Tip for monitoring:** create a Task with `onlyNew: true`, add a Schedule (e.g. hourly) and connect an integration (Slack, email, webhook, Make, n8n, Zapier). The first run returns the current items; later runs return only new ones.

### Output (real example, podcast feed)

```json
{
  "title": "A Political Rebellion in the Rio Grande Valley",
  "link": "https://www.nytimes.com/the-daily",
  "guid": "3a0b9778-acb8-4a98-b24e-07fe0131dd03",
  "publishedAt": "2026-11-02T10:50:24+00:00",
  "updatedAt": null,
  "publishedRaw": "Mon, 2 Nov 2026 10:50:24 +0000",
  "author": "thedaily@nytimes.com (The New York Times), The New York Times",
  "categories": [],
  "summary": "In 2024, Hispanic voters in the region delivered a political earthquake: majority support for Republicans. Now, that support appears to be evaporating.",
  "contentText": "Warning: This episode contains strong language. In the midterm elections, one of the regions expected to swing away from President Trump and toward Democrats is the Rio Grande Valley of Texas, where life has been transformed by his administration’s crackdown on immigration. Lynsea Garrison, a …",
  "imageUrl": "https://image.simplecastcdn.com/images/34e5431c-f7f7-4edd-9b5d-0277e197a71b/7c687c39-27aa-40a4-b606-8c32fd5cbbc9/02thedaily_youtube_9.jpg",
  "enclosures": [
    {
      "url": "https://dts.podtrac.com/redirect.mp3/pdst.fm/e/pfx.vpixl.com/6qj4J/pscrb.fm/rss/p/tracking.swap.fm/track/4jdbJYYRKqK96EGqOzQb/nyt.simplecastaudio.com/03d8b493-87fc-4bd1-931f-8a8e9b945d8a/episodes/7bf4706f-de8e-4b7f-99df-a0e4d6c37736/audio/128/default.mp3?aid=rss_feed&awCollectionId=03d8b493-87fc-4bd1-931f-8a8e9b945d8a&awEpisodeId=7bf4706f-de8e-4b7f-99df-a0e4d6c37736&feed=54nAGcIl",
      "type": "audio/mpeg",
      "length": "73792530"
    }
  ],
  "duration": "01:16:52",
  "comments": null,
  "feedTitle": "The Daily",
  "feedUrl": "https://feeds.simplecast.com/54nAGcIl",
  "feedLink": "https://www.nytimes.com/the-daily",
  "feedType": "rss",
  "feedLanguage": "en",
  "itemId": "c36b95bfbe915fc8a603",
  "scrapedAt": "2026-11-02T22:56:39+00:00"
}
```

Fields: `title`, `link`, `guid`, `publishedAt`, `updatedAt`, `publishedRaw`, `author`, `categories`, `summary`, `contentText`, `contentHtml` (optional), `imageUrl`, `enclosures`, `duration`, `comments`, `feedTitle`, `feedUrl`, `feedLink`, `feedType`, `feedLanguage`, `itemId` (stable hash), `scrapedAt`.

Export as JSON, CSV, Excel, XML, RSS or via API, webhooks, Make, n8n or Zapier.

### Pricing

**The Actor is currently free** – you only pay Apify platform usage, which is very low because no browser or proxy is used. A fair pay-per-result price may be introduced later; Apify announces such changes at least 14 days in advance. Set *Max cost per run* to cap your spend.

### Notes

- Some websites don't link their feed anywhere (then enter the feed URL directly, e.g. `https://www.heise.de/rss/heise-atom.xml`).
- Feeds usually contain only the latest 10–100 items; this Actor reads what the feed publishes, it does not crawl article pages.
- In *Only new* mode with `maxItemsPerFeed`, items that did not fit are delivered in the next run.
- Respect each publisher's terms. Feeds are published for machine reading; the Actor makes one request per feed (plus a few for discovery).

***

### 🇩🇪 Deutsch: RSS- & Atom-Feed-Reader mit Monitoring

Liest **beliebige RSS-, Atom- und JSON-Feeds** und liefert saubere Daten: Titel, Link, Datum (ISO 8601), Autor, Kategorien, Zusammenfassung, Volltext, Bild und Podcast-Audio. Es reicht auch die **Website-Adresse** (z. B. `https://www.tagesschau.de`) – der Feed wird automatisch gefunden.

**Monitoring:** Mit *Nur neue Einträge* liefert jeder Lauf nur Artikel, die Sie noch nicht erhalten haben (unveränderte Feeds werden per HTTP 304 übersprungen). Ideal mit einem Zeitplan und Benachrichtigung per Slack, E-Mail oder Webhook. Dazu kommen Datums- und Stichwortfilter (auch Regex) und eine Zusammenfassung pro Feed.

**Ideal für:** Medien- und Wettbewerbsbeobachtung, Newsletter und Content-Aggregation, KI-/RAG-Pipelines, Podcast-Daten und Release-Tracking. Die Nutzung ist derzeit kostenlos (nur geringe Apify-Plattformkosten).

# Actor input Schema

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

RSS / Atom / JSON Feed URLs, or website URLs (the feed is auto-discovered from the page's <link rel="alternate"> tag or common paths like /feed).

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

Maximum number of items saved per feed (most feeds contain 10-100 items).

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

Maximum number of items saved in this run.

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

Remember delivered items between runs and only output items you have not received yet. Unchanged feeds (HTTP 304) are skipped. Ideal for schedules.

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

Name of the memory used by 'Only new items'. Use different keys for independent monitors.

## `publishedWithinDays` (type: `integer`):

Only keep items published in the last N days.

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

Only keep items published after this date, e.g. 2026-01-31.

## `keepItemsWithoutDate` (type: `boolean`):

When a date filter is used, keep items that have no publication date.

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

Keep only items whose title, text or categories contain at least one of these words (case-insensitive, whole words). Prefix with re: for a regular expression.

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

Drop items containing any of these words.

## `includeContentHtml` (type: `boolean`):

Also output the raw HTML content of each item.

## `maxTextLength` (type: `integer`):

Truncate contentText to this many characters (0 = no text).

## `autodiscover` (type: `boolean`):

If a URL is a web page, look for its feed.

## `concurrency` (type: `integer`):

Number of feeds fetched in parallel.

## Actor input object example

```json
{
  "feedUrls": [
    {
      "url": "https://www.theverge.com/rss/index.xml"
    },
    {
      "url": "https://www.tagesschau.de"
    }
  ],
  "maxItemsPerFeed": 100,
  "maxItems": 10000,
  "onlyNew": false,
  "stateKey": "default",
  "keepItemsWithoutDate": true,
  "includeContentHtml": false,
  "maxTextLength": 5000,
  "autodiscover": true,
  "concurrency": 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": [
        {
            "url": "https://www.theverge.com/rss/index.xml"
        },
        {
            "url": "https://www.tagesschau.de"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("paperlinenstudio/rss-feed-reader").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": [
        { "url": "https://www.theverge.com/rss/index.xml" },
        { "url": "https://www.tagesschau.de" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("paperlinenstudio/rss-feed-reader").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": [
    {
      "url": "https://www.theverge.com/rss/index.xml"
    },
    {
      "url": "https://www.tagesschau.de"
    }
  ]
}' |
apify call paperlinenstudio/rss-feed-reader --silent --output-dataset

```

## MCP server setup

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

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/NPYNkUTewuvNfmGYp/builds/5rnzmC9EluOHosyVf/openapi.json