RSS Feed Reader (with MCP)

Read public RSS, Atom, and RDF feed URLs and export normalized feed item rows for monitoring, alerts, AI/RAG ingestion, spreadsheets, and MCP/no-code workflows.

What it does

• Fetches one or more feed URLs.
• Normalizes entries into dataset rows with title, link, dates, author, categories, media URLs, and feed metadata.
• Deduplicates items by GUID, link, or title/date.
• Keeps partial runs useful by saving an error row for a failed feed when enabled.

Examples

Example input recipes below show common RSS feed reader runs. Use these examples before creating saved public tasks.

Input recipes

{
  "feedUrls": [
    "https://feeds.bbci.co.uk/news/rss.xml",
    "https://www.nasa.gov/news-release/feed/"
  ],
  "maxItemsPerFeed": 20,
  "includeContent": true,
  "includeFeedMetadata": true,
  "dedupeBy": "guid"
}

Output

Each dataset item represents one feed entry or one feed-level error row. Common fields include feedUrl, feedTitle, title, description, content, link, guid, pubDate, isoDate, author, categories, imageUrl, mediaUrls, fetchedAt, dedupeKey, and error.

API usage

Call the actor with the Apify API or CLI by passing a JSON input containing feedUrls and optional limits. After the run succeeds, read the default dataset to receive normalized feed item rows.

$apify call fetch_cat/rss-feed-reader --input-file input.json

Cost expectations

The actor uses lightweight HTTP requests and does not require a browser or proxy for normal public feeds. Limit maxItemsPerFeed to control output volume.

FAQ

Can one bad feed fail the whole run? No. Failed feeds are logged and can be emitted as dataset rows with the error field.

Does it support Atom as well as RSS? Yes. It handles common RSS, Atom, and RDF feed structures.

Related actors

Use this actor when your starting point is a feed URL. For full website crawling or page extraction, use a dedicated website scraper instead.

Who is it for

RSS Feed Reader is for teams that already know the feed URLs they want to monitor and need structured data without building a feed parser. Common users include editorial teams, market researchers, newsletter operators, automation builders, developers, and AI teams collecting fresh source material for retrieval workflows.

Pricing

Pricing is based on platform pay-per-event settings. You can control spend by limiting feedUrls and maxItemsPerFeed. Small monitoring jobs with a few feeds are inexpensive because the actor uses direct feed requests rather than a browser.

Legality

Only use this actor with public RSS, Atom, or RDF feeds that you are allowed to access. Respect each publisher's terms, copyright rules, and rate limits. The actor reads feed documents supplied in your input; it does not bypass logins or access private content.

Node.js API usage

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/rss-feed-reader').call({
  feedUrls: ['https://feeds.bbci.co.uk/news/rss.xml'],
  maxItemsPerFeed: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python API usage

from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/rss-feed-reader').call(run_input={
    'feedUrls': ['https://feeds.bbci.co.uk/news/rss.xml'],
    'maxItemsPerFeed': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

cURL API usage

curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~rss-feed-reader/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"feedUrls":["https://feeds.bbci.co.uk/news/rss.xml"],"maxItemsPerFeed":10}'

Reliability tips

Use stable publisher feed URLs, keep per-feed limits bounded, and leave emitErrorItems enabled when you need auditability for partial failures. If a publisher changes or removes a feed, the error row helps identify the specific feed that needs attention.

Troubleshooting

If a run produces no rows, check that the feed URL returns XML in a browser or with curl. If dates are empty, the publisher may omit date fields. If duplicate rows are removed unexpectedly, switch dedupeBy from guid to link or titleAndDate.

Support

If a public feed URL fails even though it returns a valid RSS, Atom, or RDF document, open an actor issue with the feed URL and run ID so the case can be reproduced.

Limits

The actor is designed for feed documents, not arbitrary website pages. For HTML pages, sitemaps, or JavaScript-rendered sites, use a crawler actor instead.

Feed selection checklist

Start with canonical feed URLs from the publisher, prefer HTTPS URLs, and avoid search-result pages or HTML article pages. If you are monitoring several publishers, add each feed as a separate feedUrls entry so failures remain isolated.

Dataset workflow

After a run finishes, open the default dataset, export JSON/CSV/Excel, or connect the dataset to another Apify integration. The dedupeKey field is intended for downstream merge logic in databases, spreadsheets, and automation tools.

Automation ideas

Schedule the actor to run every hour for newsroom monitoring, every day for competitor content tracking, or before an AI indexing job that refreshes a knowledge base from feed items.

Data quality notes

RSS publishers vary in which fields they expose. Some feeds provide rich content and images, while others provide only titles and links. Empty optional fields usually mean the feed did not publish that metadata.

Error handling details

With emitErrorItems enabled, a failed feed still creates a row with feedUrl and error. This makes scheduled monitoring easier because you can alert on error rows without losing successful rows from other feeds.

Performance notes

Keep maxItemsPerFeed close to the number of new items you expect per run. Smaller limits finish faster and make exports easier to review.

Change monitoring pattern

For recurring checks, compare each new dataset export against the previous run. Use dedupeKey as the stable comparison key. Alert only on entries that were not present before. Store the feed URL with each alert so reviewers can trace the source quickly.