# RSS, Atom & JSON Feed Reader (`fleet261114/rss-feed-reader`) Actor

Read any RSS, Atom or JSON feed, or just paste a website URL and the feed is found for you. Clean items with title, link, dates, summary, full text, categories, images and podcast files. Keyword filters and new-items-only mode for monitoring.

- **URL**: https://apify.com/fleet261114/rss-feed-reader.md
- **Developed by:** [Fleet](https://apify.com/fleet261114) (community)
- **Categories:** News, 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.35 / 1,000 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 & JSON Feed Reader

Turn any news site, blog or podcast feed into clean, uniform records. Paste **feed URLs** or simply **website URLs**: if you give a website, the Actor finds the feed the site advertises (or tries the usual `/feed`, `/rss.xml`, `/atom.xml` paths).

Every item comes out in the same shape whatever the feed format (RSS 2.0, RSS 1.0/RDF, Atom, JSON Feed): title, link, publish and update dates in ISO format, a plain-text summary, the full content when the feed carries it, categories, image, and podcast/media files.

### Use it for

- **News and competitor monitoring:** schedule it hourly or daily with "Only items not returned before" and get just the new posts.
- **Content aggregation:** feed many blogs into one dataset, Google Sheet or database.
- **Keyword alerts:** keep only items mentioning your brand, product or topic; drop the noise with exclude words.
- **Podcast catalogues:** episode titles, dates and audio file URLs.
- **AI agents and RAG pipelines:** give an agent fresh, structured articles from sources you choose.

### Input

| Field | What it does |
|---|---|
| **Feed or website URLs** (required) | One per line, up to 5,000. Feed URLs are read directly; website URLs are searched for their feed. |
| Keep items containing | Keep items whose title, summary or categories contain any of these words. |
| Drop items containing | Drop items containing any of these words. |
| Published within the last N days | Date filter. Items without a date are dropped when it is set. |
| Only items not returned before | Monitoring mode: returns only items you have not received in earlier runs (per state key). State lives in your own Apify account. |
| State key | Separate watch lists, e.g. `competitors`, `press`. |
| Max items per feed | Cap per feed, in the feed's own order (usually newest first). |
| Full content format | Plain text (default), HTML, both, or none. |
| Feeds per website | How many advertised feeds to read when you give a website URL (default 1; comment feeds are skipped). |
| Parallel feeds | Default 5, at most 2 per website. |

### Output

One item per feed entry. A real example from a test run:

```json
{
  "feedUrl": "https://blog.python.org/feeds/posts/default",
  "feedTitle": "Python Insider",
  "siteUrl": "https://blog.python.org/",
  "itemId": "https://blog.python.org/2026/11/python-3160-alpha-2-is-now-available/",
  "title": "Python 3.16.0 alpha 2 is now available",
  "url": "https://blog.python.org/2026/11/python-3160-alpha-2-is-now-available/",
  "publishedAt": "2026-11-10T00:00:00.000Z",
  "updatedAt": null,
  "summary": "The second developer preview of Python 3.16 is ready for testing.",
  "categories": ["releases"],
  "imageUrl": null,
  "media": [],
  "commentsUrl": null,
  "feedFormat": "rss 2.0",
  "feedLanguage": null,
  "contentText": null,
  "inputUrl": "https://blog.python.org/feeds/posts/default",
  "scrapedAt": "2026-11-15T06:55:21.202Z"
}
```

`media` lists enclosures and Media RSS files (`url`, `type`, `length`), e.g. podcast MP3s. `contentText`/`contentHtml` are filled only when the feed itself carries full content; many feeds carry only a summary. A `RUN_SUMMARY` record in the run's key-value store lists every feed read (items in feed, matching, returned) and every input that failed, with the reason.

### Pricing

Pay per result: **$0.0005 per item returned** ($0.50 per 1,000 items), with lower prices on Apify's Bronze, Silver and Gold plans, plus Apify's small run-start fee. Inputs that fail, items removed by your filters, and items skipped in "only new" mode are not charged. You can set a maximum cost per run; the Actor stops cleanly when it is reached.

### Limits and honest notes

- The Actor reads only what the feed publishes. Most feeds list the latest 10-50 items; older items are not available through the feed.
- Author names are deliberately **not** included in the output.
- Feed discovery fetches the page you give (one request) and, if needed, a few standard feed paths. It does not crawl the site.
- Feeds behind logins, paywalls or bot challenges cannot be read; such inputs are reported as failed in `RUN_SUMMARY` and not charged.
- Use the content in line with each publisher's terms; feeds are published for reading, but republishing full articles may need permission.

### Use it from the API, a schedule or an AI agent

**API.** Start a run and get the items in one call (replace `YOUR_APIFY_TOKEN`):

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

This waits up to 5 minutes. For large lists, start a run with `POST /v2/acts/fleet261114~rss-feed-reader/runs` and read its dataset when it finishes.

**Schedules and integrations.** Save your input as a task, turn on "Only items not returned before", and attach an Apify schedule. Send new items to Slack, email, Google Sheets, Make, Zapier or n8n with Apify's integrations or a webhook.

**AI agents (MCP).** Add the Actor as a tool in any MCP client (Claude, Cursor and others) through Apify's hosted MCP server:

```
https://mcp.apify.com?tools=fleet261114/rss-feed-reader
```

The agent sees the input schema and field descriptions and can call the Actor directly. Set a maximum cost per run in the call options to cap spending.

### FAQ

**Do I need to know the feed URL?** No. Paste the website or blog address; the Actor looks for the feed. If it finds none, the run summary says so and you are not charged for that input.

**How does "only new items" work?** The Actor remembers the IDs of items it returned to you (per feed and per state key) in a key-value store in your account, and returns only items it has not returned before.

**Can I get the full article text?** When the feed includes it (many WordPress feeds do), yes, as text or HTML. If the feed has only summaries, the Actor does not fetch the article pages.

**What does a typical run cost?** At $0.0005 per item, 20 feeds × 20 items = 400 items cost about $0.20.

### Questions and problems

Open an issue on the Actor's **Issues** tab with the run link.

# Actor input Schema

## `feeds` (type: `array`):

One per line (up to 5,000). A feed URL (RSS, Atom, RDF or JSON Feed) is read directly. A website or blog URL works too: the feed it advertises in its HTML is used, or else the usual paths (/feed, /rss.xml, /atom.xml, /index.xml) are tried.

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

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

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

Drop items whose title, summary or categories contain any of these words (case-insensitive).

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

Keep only items published (or, if no publish date, updated) within this many days. Items without any date are dropped when this is set. Empty = no date filter.

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

For scheduled monitoring: return only items this Actor has not returned to you in earlier runs with the same state key. The first run returns everything that matches. State is kept in a named key-value store "rss-feed-reader-state" in your own account.

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

Use a different key for each independent watch list. Letters, digits, - and \_ only.

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

Cap on items returned per feed after filters, newest first as the feed lists them. 0 = no cap.

## `contentFormat` (type: `string`):

Whether to include the item's full content (when the feed carries it, e.g. content:encoded or Atom content) as plain text, HTML, both, or not at all. The short summary is always included.

## `maxFeedsPerSite` (type: `integer`):

When you give a website URL that advertises several feeds (e.g. posts and podcasts), read up to this many of them. Comment feeds are skipped.

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

Feeds read at the same time (at most 2 per website).

## Actor input object example

```json
{
  "feeds": [
    "https://blog.python.org/feeds/posts/default",
    "https://github.blog/"
  ],
  "keywords": [],
  "excludeKeywords": [],
  "onlyNewItems": false,
  "stateKey": "default",
  "maxItemsPerFeed": 0,
  "contentFormat": "text",
  "maxFeedsPerSite": 1,
  "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 = {
    "feeds": [
        "https://blog.python.org/feeds/posts/default",
        "https://github.blog/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fleet261114/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 = { "feeds": [
        "https://blog.python.org/feeds/posts/default",
        "https://github.blog/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fleet261114/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 '{
  "feeds": [
    "https://blog.python.org/feeds/posts/default",
    "https://github.blog/"
  ]
}' |
apify call fleet261114/rss-feed-reader --silent --output-dataset

```

## MCP server setup

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