# RSS & Atom Feed Monitor - New Items Only + AI Digest (`koban-tools/rss-feed-monitor`) Actor

Monitor any number of RSS 2.0, Atom and RSS 1.0 (RDF) feeds and get only the items you have not seen yet. Keyword filters, conditional GET, Shift_JIS/EUC-JP safe, optional Claude summaries and digest with your own Anthropic API key.

- **URL**: https://apify.com/koban-tools/rss-feed-monitor.md
- **Developed by:** [Koban Tools](https://apify.com/koban-tools) (community)
- **Categories:** Developer tools, News, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 feed item delivereds

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?

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 Feed Monitor - New Items Only + AI Digest

Monitor any number of **RSS 2.0, Atom and RSS 1.0 (RDF)** feeds and get **only the items you have not seen before**. Put it on an Apify Schedule (hourly, daily...) and every run delivers just the fresh entries - ready for Slack, email, Google Sheets, Make, n8n, Zapier or your AI agent via MCP.

Optional: let **Claude** write a 1-2 sentence summary per item and/or one Markdown digest per run, using **your own Anthropic API key**.

### Why this feed monitor

- **New items only, across runs.** Seen item IDs are remembered per feed in a key-value store in your account. No duplicates in your downstream tools.
- **Polite and cheap.** Uses HTTP conditional requests (`ETag` / `If-Modified-Since`). Unchanged feeds return `304 Not Modified` and cost almost nothing.
- **Handles real-world feeds.** RSS 2.0, Atom, RSS 1.0/RDF, `content:encoded`, Dublin Core dates, enclosures (podcasts), HTML stripped to clean text. Correctly decodes **Shift_JIS and EUC-JP** feeds that break many parsers (common on Japanese sites), and timezone-less Japanese dates.
- **Keyword filters** (include / exclude, case-insensitive, works with Japanese and Chinese text) and an age filter.
- **Budget-safe.** Respects your "Maximum cost per run". If the limit is hit, undelivered items stay pending and arrive on the next run - nothing is silently lost.
- **AI optional, bring your own key.** Model usage is billed by Anthropic directly to you. Default model `claude-haiku-4-5` (cheapest); you can choose any Claude model.

### Use cases

- Competitor blogs, changelogs and release notes -> Slack channel
- Security advisories (vendor and government feeds) -> ticket queue
- News monitoring for a brand or topic with keyword filters -> daily AI digest by email
- Podcast feed watcher (enclosure URLs) -> transcription pipeline
- Japanese government / corporate press-release feeds -> English digest (set *Summary language* to English)

### Input

| Field | Description |
|---|---|
| `feedUrls` | List of feed URLs (required). |
| `onlyNewItems` | Remember delivered items and output only unseen ones (default `true`). |
| `firstRunBehavior` | `emit-all` (default) outputs current items on the first run; `baseline-only` just remembers them. |
| `stateStoreName` | Key-value store that holds the memory. Use different names for independent monitors. |
| `maxItemsPerFeed` | Max items per feed per run (default 50). Older items beyond this limit in the same feed snapshot are marked as seen. |
| `publishedWithinDays` | Skip items older than N days. |
| `includeKeywords` / `excludeKeywords` | Keyword filters on title, summary and categories. |
| `includeContentHtml` | Also output full HTML content when available. |
| `aiMode` | `none`, `per-item`, `digest`, or `both`. |
| `anthropicApiKey` | Your Anthropic API key (secret input, needed only for AI). |
| `aiModel`, `aiLanguage`, `aiInstructions` | Model ID, output language, extra instructions. |

Example:

```json
{
  "feedUrls": ["https://hnrss.org/frontpage", "https://github.blog/feed/"],
  "onlyNewItems": true,
  "includeKeywords": ["security", "pricing"],
  "aiMode": "digest",
  "anthropicApiKey": "sk-ant-...",
  "aiLanguage": "English"
}
```

### Output

One dataset item per delivered feed entry:

```json
{
  "feedUrl": "https://github.blog/feed/",
  "feedTitle": "The GitHub Blog",
  "feedFormat": "rss2",
  "itemId": "https://github.blog/?p=99381",
  "title": "Hack the World: Why hackathons are still the best place to learn to build",
  "link": "https://github.blog/developer-skills/career-growth/hack-the-world-...",
  "publishedAt": "2026-10-09T16:00:00.000Z",
  "author": "Ed Summers",
  "categories": ["Career growth", "Developer skills"],
  "summary": "The barriers to building software have collapsed. ...",
  "aiSummary": null,
  "enclosures": [],
  "isNew": true,
  "detectedAt": "2026-10-12T12:58:11.580Z"
}
```

The run's key-value store also contains:

- `RUN_REPORT` - per-feed status (`ok`, `not-modified`, `error`), item counts and detected encoding.
- `DIGEST.md` - the AI digest (when `aiMode` is `digest` or `both`).

### Pricing (pay per event)

You pay only for results:

| Event | Price |
|---|---|
| Feed item delivered | $0.0008 per item ($0.80 per 1,000) |
| AI item summary | $0.002 per item (+ your own Anthropic usage) |
| AI digest | $0.01 per digest (+ your own Anthropic usage) |

A run where nothing changed (all feeds `304 Not Modified`) delivers no items, so you pay only the small Apify start fee.

### Scheduling

Create an Apify Schedule (e.g. every hour) with the same input. Because the memory is stored in your account, each run only returns what is new since the previous run. Connect an integration (Slack, email, webhook, Google Sheets) to the "run succeeded" event to push new items automatically.

### Responsible use

This Actor only reads feeds you list. Feeds are published for automated reading, but some publishers limit how their content may be reused - make sure your use of the content complies with each publisher's terms. The Actor sends a descriptive User-Agent, uses conditional requests, and fetches each feed once per run with low concurrency. It does not bypass logins, paywalls or bot protection.

### FAQ

**Does it scrape article pages?** No. It reads only the feed itself. If the feed contains full content, enable `includeContentHtml`.

**Where is my Anthropic key stored?** It is a secret input: Apify stores it encrypted and it is only used to call the Anthropic API during your run.

**A feed returns an error.** Check `RUN_REPORT` for the HTTP status. Other feeds in the same run are still processed.

**Japanese feed shows garbled text in other tools.** This Actor detects the charset from the HTTP header and the XML declaration (Shift_JIS, EUC-JP, UTF-8 and others) and always outputs UTF-8.

### About

Developed and maintained by koban-tools, with AI-assisted development (Claude). The code is tested against real RSS, Atom and RDF feeds before each release. Questions and bug reports are welcome via the Issues tab (English or Japanese).

# Actor input Schema

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

RSS 2.0, Atom or RSS 1.0 (RDF) feed URLs to monitor. Only add feeds you are allowed to read (published feeds are meant for machine reading).

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

Remember which items were already delivered (per feed) and output only unseen items on later runs. Ideal with Apify Schedules.

## `firstRunBehavior` (type: `string`):

What to do the first time a feed is seen: output its current items, or just remember them (baseline) and output only items published afterwards.

## `stateStoreName` (type: `string`):

Name of the key-value store in your account that remembers seen items. Use different names to keep independent monitors.

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

Upper limit of items output per feed in one run.

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

Skip items older than this many days (items without a date are kept). Leave empty for no limit.

## `includeKeywords` (type: `array`):

Keep only items whose title, summary or categories contain at least one of these (case-insensitive). Works with Japanese/Chinese text too.

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

Drop items that contain any of these (case-insensitive).

## `includeContentHtml` (type: `boolean`):

Also output the item's full HTML content when the feed provides it (content:encoded / Atom content).

## `aiMode` (type: `string`):

Optional Claude processing using YOUR Anthropic API key: a 1-2 sentence summary per item, a Markdown digest of all new items (saved as DIGEST.md in the run's key-value store), or both.

## `anthropicApiKey` (type: `string`):

Required only when AI is on. Stored encrypted by Apify; Anthropic bills your account for model usage.

## `aiModel` (type: `string`):

Anthropic model ID, e.g. claude-haiku-4-5 (cheapest), claude-sonnet-5-5 or claude-opus-5-5.

## `aiLanguage` (type: `string`):

Language for AI summaries, e.g. English, Japanese, German.

## `aiInstructions` (type: `string`):

Optional, e.g. 'Focus on pricing changes' or 'Flag anything about security'.

## `maxConcurrency` (type: `integer`):

How many feeds are fetched in parallel (1-10).

## Actor input object example

```json
{
  "feedUrls": [
    "https://hnrss.org/frontpage",
    "https://github.blog/feed/"
  ],
  "onlyNewItems": true,
  "firstRunBehavior": "emit-all",
  "stateStoreName": "rss-feed-monitor-state",
  "maxItemsPerFeed": 50,
  "includeContentHtml": false,
  "aiMode": "none",
  "aiModel": "claude-haiku-4-5",
  "aiLanguage": "English",
  "maxConcurrency": 5
}
```

# Actor output Schema

## `items` (type: `string`):

No description

## `digest` (type: `string`):

No description

## `runReport` (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.blog/feed/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("koban-tools/rss-feed-monitor").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.blog/feed/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("koban-tools/rss-feed-monitor").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.blog/feed/"
  ]
}' |
apify call koban-tools/rss-feed-monitor --silent --output-dataset

```

## MCP server setup

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

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/LD9zz8uiIfRrW6vGK/builds/nN3W4H8oxziREv12u/openapi.json