# RSS/Atom Feed-to-Digest for AI Agents (`inn_corp/feed-digest`) Actor

Fetch RSS and Atom feeds and return clean digest records. Optional cross-run new-items-only mode for scheduled AI-agent monitoring.

- **URL**: https://apify.com/inn\_corp/feed-digest.md
- **Developed by:** [Inn Corp](https://apify.com/inn_corp) (community)
- **Categories:** AI, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 feed item retrieveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 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

```json
{
  "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.

# Actor input Schema

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

RSS or Atom feed URLs. Mix freely; the format is auto-detected per feed.

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

Newest-first, as ordered by the feed itself.

## `sinceDate` (type: `string`):

YYYY-MM-DD. Items with no parseable publish date are kept (there is no date to filter on). Leave empty for no filter.

## `isNewOnly` (type: `boolean`):

When on, the Actor remembers every item id/link it has already returned for each feed (in a named key-value store keyed by the feed URL) and only returns items it has never returned before. The first run of a feed returns everything found (and records it as seen); every run after that returns only what is genuinely new. This is what makes a Scheduled run behave like a digest instead of a re-fetch. Off by default so a one-off run always sees the full feed.

## `stripHtml` (type: `boolean`):

Clean HTML tags out of item summaries (and full content, if included) into plain text. Off returns the feed's raw HTML.

## `includeFullContent` (type: `boolean`):

Include the feed's full-content field (content:encoded or Atom <content>) when the feed provides one beyond its summary. null when the feed does not provide it.

## Actor input object example

```json
{
  "feedUrls": [
    "https://hnrss.org/frontpage"
  ],
  "maxItemsPerFeed": 20,
  "sinceDate": "2026-08-01",
  "isNewOnly": false,
  "stripHtml": true,
  "includeFullContent": false
}
```

# Actor output Schema

## `items` (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": [
        "https://hnrss.org/frontpage",
        "https://github.com/microsoft/vscode/releases.atom"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("inn_corp/feed-digest").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": [
        "https://hnrss.org/frontpage",
        "https://github.com/microsoft/vscode/releases.atom",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("inn_corp/feed-digest").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": [
    "https://hnrss.org/frontpage",
    "https://github.com/microsoft/vscode/releases.atom"
  ]
}' |
apify call inn_corp/feed-digest --silent --output-dataset

```

## MCP server setup

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

```

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/V8xPfaWnfurDJ0pu2/builds/ekL2jyHwxzEi0hGHF/openapi.json