RSS Feed Reader (with MCP)

Read RSS and Atom feeds, normalize feed items, and export clean dataset rows for monitoring, alerts, AI, MCP, and integrations.

Data fields

FieldTypeDescription
feedUrlstringValidated public feed URL.
feedTypestring | nullRSS, Atom, or RDF.
feedTitlestring | nullFeed title when provided.
titlestring | nullFeed entry title.
descriptionstring | nullEntry summary or description.
contentstring | nullOptional entry content, bounded in size.
linkstring | nullCanonical item link when provided.
guidstring | nullEntry GUID or source ID.

Input preview

feedUrlsFeed URLs *
maxItemsPerFeedMax items per feed
includeContentInclude content
includeFeedMetadataInclude feed metadata
dedupeByDeduplicate by
requestTimeoutSecsRequest timeout seconds

API and agents

This actor can be run through Apify API, datasets, webhooks, schedules, and the official Apify MCP server.

How this actor works

See example inputs, outputs, API usage, and practical limits before running this actor on Apify.

Open Apify page

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.

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.

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.

Common questions

Questions and answers reused from the canonical actor README.

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.