RSS/Atom Feed-to-Digest for AI Agents

Fetch RSS and Atom feeds and get back clean, structured digest records: one row per item, HTML stripped to plain text by default, dates normalized. Built so an AI agent (or a scheduled pipeline) can monitor a feed the way a digest actually works, not the way a re-fetch works.

What it does

• Give it feed URLs, RSS or Atom, mixed freely. Format is auto-detected per feed; the same parser handles RSS 2.0, RSS 1.0/RDF, and Atom.
• Get back one record per item: title, link, publish date, summary, author, categories, and the feed's own title.
• Strip HTML out of summaries into plain text (on by default), or keep the raw markup if you want it.
• Optionally pull the full item body when the feed provides one beyond its summary (content:encoded in RSS, <content> in Atom).
• Filter to items published on or after a given date.

The actual differentiator: new-items-only mode

Turn on isNewOnly and the Actor remembers, per feed, every item id it has already returned, in a named key-value store keyed to that feed's URL. That store is not run-scoped, so it survives between separate runs. The first run of a feed returns everything found. Every run after that returns only items it has never returned before. Run it twice in a row with nothing new published in between and the second run returns nothing, correctly, because there is nothing new to report.

That is what makes this Actor a digest tool instead of a fetch tool: a store sweep of this category found real evidence of heavy scheduled use (one listing at over 5,000 runs in 30 days from under 40 users) with the field mostly unrated, which reads as an agent calling a feed on a schedule and wanting only what changed. Most feed actors return everything, every time, and leave dedup to you. This one does the dedup.

Ethics note

RSS and Atom are formats publishers create and expose specifically so software can consume them automatically. There is no scraping, no login bypass, and no anti-bot evasion here; fetching a feed is exactly what the format is for.

Output example

{
  "feedUrl": "https://hnrss.org/frontpage",
  "feedTitle": "Hacker News: Front Page",
  "itemId": "https://news.ycombinator.com/item?id=49428318",
  "title": "Thomson Reuters Launches Its Own Frontier Model",
  "link": "https://www.thomsonreuters.com/en/press-releases/2026/august/thomson-reuters-leverages-its-world-class-data-assets-to-launch-its-own-frontier-model",
  "publishedDate": "2026-08-25T02:11:39+00:00",
  "summary": "Article URL: https://www.thomsonreuters.com/...\nComments URL: https://news.ycombinator.com/item?id=49428318\nPoints: 31\n# Comments: 8",
  "fullContent": null,
  "author": "giuliomagnifico",
  "categories": null,
  "fetchedAt": "2026-08-25T03:28:30+00:00",
  "isNew": true
}

Input

Field	Meaning
feedUrls	RSS or Atom feed URLs. Required, mixed freely.
maxItemsPerFeed	Newest-first per feed, default 20, max 200.
sinceDate	YYYY-MM-DD. Only items published on/after this date. Items with no parseable date are kept.
isNewOnly	Cross-run dedup by item id, per feed, via a named key-value store. See above. Default off, so a one-off run always sees the full feed.
stripHtml	Clean HTML tags out of summaries (and full content) into plain text. Default on.
includeFullContent	Also return the feed's full-content field when it provides one beyond the summary. Default off. null when the feed has nothing beyond its summary.

Recipe: monitor a feed on a schedule, get only what's new

This is the intended usage pattern, the same recipe already shipped on this account's SEC EDGAR Filings Fetcher listing, adapted for feeds:

1. Create a Task for this Actor with your feed list and isNewOnly: true, for example feedUrls: ["https://your-target-feed.example/rss"].
2. Attach an Apify Schedule to the Task (hourly, daily, whatever matches how often the feed actually publishes).
3. Every scheduled run returns only items this Task has never returned before for that feed. No downstream dedup step needed.
4. Pair the schedule with an Apify integration (webhook, Slack, email) and each run's output is, by construction, the digest: what's new since last time.

Three notes on how the store keys work: the seen-items store is keyed by a hash of the feed URL, so it is shared by any run of any Task in your account that queries the same feed URL, and it is capped at the 3,000 most recently seen ids per feed (FIFO eviction) so it never grows unbounded — if a feed resurfaces an item older than the last 3,000 seen, it can appear "new" again. Two overlapping runs against the exact same feed URL at the same time (for example, a schedule interval shorter than a run's own duration) can race: whichever run finishes writing last wins, and the other run's newly-seen ids can be lost, occasionally causing an item to look "new" again on a later run. This is rare in the recommended single-Task, single-Schedule pattern above, and never causes a missed item, only an occasional repeat. Change isNewOnly back to off any time you want a full, ordinary fetch of the current feed instead.

Fair pricing

Pay per item returned once pay-per-event pricing is enabled, plus a small per-feed charge for each feed successfully fetched. A feed that fails to fetch or fails to parse costs nothing. No subscription.