# RSS Feed Monitor: Only New RSS, Atom & JSON Items (`ferrolark/rss-delta`) Actor

RSS feed monitor: check RSS, Atom and JSON Feed URLs and get only the items that are new since the last run, as clean JSON (RSS to JSON for new items). Handles changing GUIDs, tracking links, bad dates and cross-feed duplicates. For n8n, Make and AI agents.

- **URL**: https://apify.com/ferrolark/rss-delta.md
- **Developed by:** [Ferrolark](https://apify.com/ferrolark) (community)
- **Categories:** Automation, News, Integrations
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 new items

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 Delta: Only New Feed Items, De-duplicated

Give it a list of RSS, Atom, RSS 1.0 (RDF) or JSON Feed URLs. Each run returns **only the items that are new since the last run**, as clean JSON. The things that usually make automations post the same article three times are handled:

- **GUIDs that change** while the link stays the same
- **Tracking parameters** (`utm_*`, `fbclid`, `gclid`, `ref`…), `www.`, `http`/`https` and trailing slashes, ignored when comparing links
- **the same story in several feeds**, de-duplicated across feeds
- **invalid or future dates**, normalized to UTC ISO-8601 with a `dateValid` flag
- **items repeated inside one feed**

The state is saved in your Apify account under a name you choose. You can also pass the cursor yourself from n8n or Make. Unchanged feeds are fetched with `ETag` and `If-Modified-Since`, so they cost the publisher almost nothing.

### Real example

**Run 1**, with this input:

```json
{
  "feedUrls": [
    "https://github.blog/changelog/feed/",
    "https://www.jsonfeed.org/feed.json",
    "https://blog.python.org/feeds/posts/default",
    "https://hnrss.org/frontpage"
  ],
  "firstRunItems": 3,
  "stateName": "readme-demo"
}
```

- 4 feeds and 82 items parsed.
- 11 rows emitted: the newest 3 per feed, and the 2 items of the JSON Feed. The other 71 were marked as seen.
- Run time: 7.6 s on Apify at 256 MB, $0.0004 of platform usage.
- Your cost: 4 feeds + 11 items = **$0.0095**.

**Run 2**, same input a minute later: all 4 feeds answered `304 Not Modified`, giving 0 new items.

- Run time: 3.6 s.
- Your cost: **$0.004**.

A dataset row:

```json
{
  "feedUrl": "https://github.blog/changelog/feed/",
  "feedTitle": "Archive: 2026 - GitHub Changelog",
  "feedKind": "rss",
  "id": "rd_847630012d01c501",
  "guid": "https://github.blog/changelog/2026-11-06-copilot-code-review-api-management-and-review-overview-updates",
  "title": "Copilot code review: API management and review overview updates",
  "link": "https://github.blog/changelog/2026-11-06-copilot-code-review-api-management-and-review-overview-updates",
  "originalLink": null,
  "published": "2026-11-07T00:27:19Z",
  "updated": null,
  "dateValid": true,
  "summary": "You can now manage GitHub Copilot code review settings through the REST and GraphQL APIs, from enterprise policy down to individual repositories. …",
  "categories": ["Improvement", "copilot"],
  "enclosureUrl": null,
  "enclosureType": null,
  "firstSeenAt": "2026-11-08T23:35:09Z"
}
```

- `link` has tracking parameters and the fragment removed. When that changed the URL, `originalLink` keeps the published one.
- `id` is stable across runs, so you can use it as a primary key in Sheets, Airtable or a database.

The `OUTPUT` record reports each feed, including why items were skipped:

```json
{"feedUrl": "https://github.blog/changelog/feed/", "ok": true, "kind": "rss", "items": 10, "newItems": 0,
 "alreadySeen": 10, "guidChangedSameLink": 0, "sameTitle": 0, "repeatedInFeed": 0, "sameLinkOtherFeed": 0,
 "skippedOverLimit": 0, "firstRunSkipped": 0}
```

### Price and limits

- **$0.001 per feed checked**, including feeds with no new items, because "nothing new" is a useful answer.
- **$0.0005 per new item.**
- Feeds that fail (HTTP error, not a feed, timeout) are not charged.
- Examples:
  - 20 feeds every hour with about 10 new items per run costs about $0.025 per run.
  - Polling a quiet feed costs $0.001 per run.

Limits:

- 100 feeds per run, 10 MB per feed, 2,000 items parsed per feed.
- Up to 500 new items per feed per run (default 50).
- Each feed remembers its last 1,000 item keys.

Set **Max total charge** on the run to cap the cost. Items that do not fit are not marked as seen, so the next run delivers them.

### Input

| Field | Default | What it does |
|---|---|---|
| `feedUrls` | demo feeds | RSS, Atom, RDF or JSON Feed URLs. Empty = Hacker News front page + BBC News (demo). |
| `stateName` | `default` | Which saved state to use. Use one per workflow, so two workflows don't steal each other's items. |
| `firstRunItems` | 5 | On a feed's first run, emit the newest N items and mark the rest as seen. Use 0 for a silent start. |
| `maxNewItemsPerFeed` | 50 | Cap per feed per run. |
| `dedupeAcrossFeeds` | `true` | Skip an item whose link already came from another feed. |
| `dedupeByTitle` | `false` | Also treat the same title as a duplicate. Off by default because some feeds reuse titles. |
| `summaryMaxChars` | 300 | Plain-text summary length. 0 means no summary. |
| `includeAuthors` | `false` | Author names are left out unless you need them. |
| `cursor` / `returnCursor` | none / `false` | Manage the state yourself: read `NEXT_CURSOR` from the run's key-value store and pass it back as `cursor` next time. |
| `useStoredState` / `saveState` | `true` | Turn the stored state off, for example in tests. |

### How "new" is decided

Each item gets up to three keys:

1. its GUID or id;
2. its cleaned link;
3. optionally, its normalized title.

An item is new only if **none** of its keys was seen before in that feed, or in another feed when `dedupeAcrossFeeds` is on. After it is emitted, all of its keys are remembered. This is why a GUID change alone does not re-send an item.

Only metadata and a short plain-text summary are returned. Full article content is not copied, and links point to the publisher.

Delivery is "at least once per state", not "exactly once". If you run two workflows with the same `stateName` at the same time, they can both receive an item. Give each workflow its own state.

### Call it from code, n8n or an AI agent

**API (synchronous):**

```bash
curl -X POST "https://api.apify.com/v2/acts/ferrolark~rss-delta/run-sync-get-dataset-items?maxTotalChargeUsd=0.1" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"feedUrls": ["https://github.blog/changelog/feed/"], "stateName": "my-workflow"}'
```

**n8n:** paste this workflow on the canvas (Ctrl+V). Then add a Header Auth credential with the name `Authorization` and the value `Bearer <your Apify token>`.

- It checks the feeds every hour, and every output item is a genuinely new article.
- Connect Slack, Telegram, Notion, Sheets or an AI summary node after it, with no extra dedup step.

```json
{
  "name": "RSS Delta: new items every hour",
  "nodes": [
    {"parameters": {"rule": {"interval": [{"field": "hours"}]}}, "name": "Every hour", "type": "n8n-nodes-base.scheduleTrigger", "typeVersion": 1.2, "position": [0, 0]},
    {"parameters": {"method": "POST", "url": "https://api.apify.com/v2/acts/ferrolark~rss-delta/run-sync-get-dataset-items?maxTotalChargeUsd=0.1", "authentication": "genericCredentialType", "genericAuthType": "httpHeaderAuth", "sendBody": true, "specifyBody": "json", "jsonBody": "{\"feedUrls\": [\"https://github.blog/changelog/feed/\", \"https://hnrss.org/frontpage\"], \"stateName\": \"n8n-hourly\", \"firstRunItems\": 0}", "options": {"timeout": 120000}}, "name": "Get only new items", "type": "n8n-nodes-base.httpRequest", "typeVersion": 4.2, "position": [220, 0]}
  ],
  "connections": {
    "Every hour": {"main": [[{"node": "Get only new items", "type": "main", "index": 0}]]}
  }
}
```

**Make / Zapier:** use the Apify app's "Run Actor" action with `ferrolark/rss-delta` and a fixed `stateName`, then "Get dataset items".

**AI agents (MCP):** add `ferrolark/rss-delta` to the Apify MCP server (`https://mcp.apify.com?actors=ferrolark/rss-delta`). An agent can then ask "what's new in these feeds since yesterday?" without re-reading old items.

### Use cases

- Content and social automations that must never post the same article twice.
- Research and competitor monitoring across many blogs, changelogs and news feeds.
- Release and changelog watching: GitHub releases, product changelogs, status pages.
- Feeding only new documents into a RAG index or a newsletter digest.

### Troubleshooting

- **"Got an HTML page, not a feed"**: use the feed URL itself, often `/feed`, `/rss.xml`, `/atom.xml` or `/index.xml`. Look for `<link rel="alternate" type="application/rss+xml">` in the page source.
- **Old items appear as new**: the feed changed both the GUID and the link, for example after a domain move. Turn on `dedupeByTitle`, or start a fresh `stateName` with `firstRunItems: 0`.
- **Nothing on the first run**: `firstRunItems` is 0, or the feed is empty.
- **HTTP 403 or 429**: the publisher blocks or rate-limits automated readers. Poll less often.

### Limitations

- No full-text extraction, translation or AI summaries. Combine it with your own node for that.
- Feeds behind a login and private feeds with tokens in the URL are not supported.
- Dates are only as good as the feed. Invalid ones get `dateValid: false`.

### Changelog

- **1.0** (November 2026): first release. RSS, Atom, RDF and JSON Feed parsing; GUID, link and title de-duplication; cross-feed dedup; conditional GET; stored state or client cursor; charge-limit-safe delivery.

### More Ferrolark tools

- [Brand Name Availability Checker](https://apify.com/ferrolark/brand-name-checker): domains, GitHub, npm, PyPI and more in one report.
- [Domain Intelligence Report](https://apify.com/ferrolark/domain-intelligence-report): WHOIS, DNS, email security, SSL and hosting for any domain.
- [Launch Asset Pack](https://apify.com/ferrolark/launch-asset-pack): favicons, PWA icons, OG image and head tags from one logo.
- [Live Deploy QA](https://apify.com/ferrolark/live-deploy-qa): meta tags, canonical, robots, OG image and favicon of your deployed routes, with diffs between deploys.
- [Sitemap Delta](https://apify.com/ferrolark/sitemap-delta): new, removed and broken URLs in any sitemap since the last run.
- [PDF Merge API](https://apify.com/ferrolark/pdf-merge-api): merge PDFs from URLs or base64 with page ranges and a SHA-256 manifest.
- [PDF Split API](https://apify.com/ferrolark/pdf-split-api): split a PDF by page ranges or every N pages, or extract pages, with a ZIP and manifest.
- [Image Convert](https://apify.com/ferrolark/image-convert): PNG, JPG, WebP, AVIF and HEIC conversion (SVG input too) from URLs or base64.
- [Image Compress & Resize](https://apify.com/ferrolark/image-compress-resize): resize images and compress them to a target size in KB, WebP or AVIF.
- [PDF to Image](https://apify.com/ferrolark/pdf-to-image): PDF pages to PNG, JPG or WebP at the DPI you choose.
- [Image to PDF](https://apify.com/ferrolark/image-to-pdf): JPG, PNG, HEIC and WebP images to one PDF, JPEGs embedded without recompression.
- [PDF Compress](https://apify.com/ferrolark/pdf-compress): smaller PDFs, lossless or with image downsampling; charged only when smaller.
- [HTML to PDF & URL to PDF](https://apify.com/ferrolark/html-to-pdf): web pages or raw HTML to PDF with headless Chrome.
- [Markdown to PDF](https://apify.com/ferrolark/markdown-to-pdf): Markdown with tables, code and footnotes to a clean PDF.
- [DOCX to PDF](https://apify.com/ferrolark/docx-to-pdf): Word, Excel, PowerPoint and ODT to PDF with LibreOffice.
- [Data Convert](https://apify.com/ferrolark/data-convert): CSV, JSON, NDJSON and Excel XLSX in any direction.
- [Cinematic Shot Breakdown](https://apify.com/ferrolark/cinematic-shot-breakdown): cuts, camera moves, lighting, palette and Sora/Veo/Kling/Runway prompts per shot.
- [Criteria Checker](https://apify.com/ferrolark/criteria-checker): pass/review/fail QA gate for AI output, emails and posts (BYOK TypeSafe).
- [Support Ticket Triage](https://apify.com/ferrolark/ticket-triage): route tickets to teams with P1-P4 priority and escalation flags (BYOK TypeSafe).
- [Amazon Listing Checker](https://apify.com/ferrolark/amazon-listing-rules): title rules, restricted claims and search-term audit before upload.

***

*Built by Ferrolark.*

# Actor input Schema

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

Up to 100 RSS 2.0, Atom, RSS 1.0 (RDF) or JSON Feed URLs. If left empty, two demo feeds (Hacker News front page and BBC News) are checked.

## `stateName` (type: `string`):

Name of the saved state that remembers which items you already received. Use one name per workflow.

## `firstRunItems` (type: `integer`):

For a feed seen for the first time, emit only the newest N items and mark the rest as seen. 0 = emit nothing on the first run.

## `maxNewItemsPerFeed` (type: `integer`):

If a feed has more new items than this, the newest ones are emitted and the rest are marked as seen.

## `dedupeAcrossFeeds` (type: `boolean`):

Skip an item when the same link (ignoring tracking parameters, www and trailing slash) already came from another feed.

## `dedupeByTitle` (type: `boolean`):

Treat an item with a new GUID and link but the same title as already seen. Off by default because some feeds reuse titles such as "Release notes".

## `summaryMaxChars` (type: `integer`):

Plain-text summary length in characters (HTML removed). 0 = no summary. Full article content is never copied.

## `includeAuthors` (type: `boolean`):

Off by default, so no personal names are stored unless you need them.

## `useStoredState` (type: `boolean`):

Read the state saved by previous runs (key-value store "rss-delta-state" in your account).

## `saveState` (type: `boolean`):

Remember this run's items for the next run.

## `cursor` (type: `object`):

Advanced: pass the NEXT_CURSOR record from a previous run to manage the state yourself (for example from n8n). When set, it replaces the stored state.

## `returnCursor` (type: `boolean`):

Write the next state to the NEXT_CURSOR record of the run's key-value store.

## Actor input object example

```json
{
  "feedUrls": [
    "https://hnrss.org/frontpage",
    "https://feeds.bbci.co.uk/news/rss.xml"
  ],
  "stateName": "default",
  "firstRunItems": 5,
  "maxNewItemsPerFeed": 50,
  "dedupeAcrossFeeds": true,
  "dedupeByTitle": false,
  "summaryMaxChars": 300,
  "includeAuthors": false,
  "useStoredState": true,
  "saveState": true,
  "returnCursor": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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://feeds.bbci.co.uk/news/rss.xml"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ferrolark/rss-delta").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://feeds.bbci.co.uk/news/rss.xml",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("ferrolark/rss-delta").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://feeds.bbci.co.uk/news/rss.xml"
  ]
}' |
apify call ferrolark/rss-delta --silent --output-dataset

```

## MCP server setup

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

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/K7DKxncpNedfcJR44/builds/tG1Nr9AfDJWQQkAy2/openapi.json
