# RSS & Atom Feed New-Item Monitor (`delta_tools/rss-atom-feed-new-item-monitor`) Actor

Watch any RSS, Atom, RDF, or JSON feed for genuinely new entries. Built-in cross-run dedup means scheduled re-runs push nothing and cost ~nothing when nothing new appears. Pay only per new item detected.

- **URL**: https://apify.com/delta_tools/rss-atom-feed-new-item-monitor.md
- **Developed by:** [Delta Tools](https://apify.com/delta_tools) (community)
- **Categories:** Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 new item detecteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 New-Item Monitor

Watch any **RSS, Atom, RDF, or JSON feed** for genuinely **new entries** — with
built-in cross-run deduplication. Schedule it hourly or daily and get alerted
only when a feed publishes something new. Quiet runs push nothing and cost
\~nothing.

### Why this instead of a feed reader

One-shot feed readers re-bill you for every entry on every scheduled run, and
leave the "what's actually new?" diffing to you. This Actor keeps a snapshot
of every entry it has already seen (per `stateKey`), so:

- **Only genuinely new entries are ever output** — repeat runs with nothing
  new return an empty dataset.
- **You pay per new item, not per entry scanned.** A quiet hourly run costs
  only the Actor start ($0.001).
- **No API key, no login, no proxy.** Plain HTTP fetches of public feeds.

### Inputs

| Field | Description |
|---|---|
| `feeds` | One entry per feed URL (max 50). Each has `url` (required — RSS 2.0, Atom, RDF, or JSON Feed), optional `name` (friendly label; defaults to the feed's own title), and `maxItems` (5–500, default 50) for how many of the newest entries to compare. |
| `stateKey` | Namespace for the saved snapshot. Use a different key per schedule so monitors never share baselines. The prefilled `default` key rotates daily so the free trial always shows recent entries. |
| `reportInitialAsNew` | On the very first run there is no baseline, so every entry is reported as new. Turn off to silently build the baseline instead. |
| `httpTimeoutSeconds` | Per-request timeout (default 45). |

Feeds publish newest-first, and entries are diffed by identity: `guid`/`id`
first, then the entry link, then a title+date hash. An edit to an already-seen
entry does not re-report it.

### Outputs

One dataset row per new entry: `feedUrl`, `feedName`, `entryId`, `title`,
`link`, `published`, `updated`, `author`, `summary` (first 500 chars),
`categories`, `detectedAt`.

### Pricing

Pay-per-event. You are billed **per genuinely new entry** (`new-item`
event). Entries that were already seen are never billed. A run where nothing
is new bills only the Actor start.

### Honest limitations

- Only public feeds reachable over plain HTTP(S) — no authenticated or
  paywalled feeds.
- Identity falls back to title+date hash when a feed provides neither guid
  nor link; two entries with identical titles and dates on such a feed would
  dedup together.
- Feeds larger than 5 MB are truncated before parsing.
- A feed that renumbers its guids (rare, usually after a CMS migration) will
  look like all-new entries on the next run — change `stateKey` or accept one
  noisy run after such a migration.
- Very high-frequency feeds (hundreds of entries/hour) can outrun an hourly
  schedule: raise `maxItems` or schedule more often.

# Actor input Schema

## `feeds` (type: `array`):

RSS/Atom/RDF/JSON feeds to watch. Leave empty to run a quick demo with a sample feed.

## `httpTimeoutSeconds` (type: `integer`):

Per-request timeout for feed fetches.

## `reportInitialAsNew` (type: `boolean`):

On the very first run there is no baseline, so every entry is reported as new. Turn off to silently build the baseline instead.

## `stateKey` (type: `string`):

Namespace for the saved snapshot, so separate monitors never share baselines. Change it to start fresh.

## Actor input object example

```json
{
  "feeds": [
    {
      "maxItems": 25,
      "name": "Hacker News newest",
      "url": "https://hnrss.org/newest"
    }
  ],
  "httpTimeoutSeconds": 45,
  "reportInitialAsNew": true,
  "stateKey": "default"
}
```

# Actor output Schema

## `author` (type: `string`):

Entry author, when the feed provides one.

## `categories` (type: `string`):

Comma-separated feed categories/tags on the entry.

## `detectedAt` (type: `string`):

ISO timestamp when this run first saw the entry.

## `entryId` (type: `string`):

Entry identity used for dedup (guid/id, link, or title+date hash).

## `feedName` (type: `string`):

Friendly feed label (input name or the feed's own title).

## `feedUrl` (type: `string`):

The feed URL this entry came from.

## `link` (type: `string`):

Direct link to the entry.

## `published` (type: `string`):

Publication date as given by the feed.

## `summary` (type: `string`):

First 500 characters of the entry description/summary.

## `title` (type: `string`):

Entry title.

## `updated` (type: `string`):

Last-updated date as given by the feed, when present.

# 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 = {
    "feeds": [
        {
            "maxItems": 25,
            "name": "Hacker News newest",
            "url": "https://hnrss.org/newest"
        }
    ],
    "httpTimeoutSeconds": 45,
    "reportInitialAsNew": true,
    "stateKey": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("delta_tools/rss-atom-feed-new-item-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 = {
    "feeds": [{
            "maxItems": 25,
            "name": "Hacker News newest",
            "url": "https://hnrss.org/newest",
        }],
    "httpTimeoutSeconds": 45,
    "reportInitialAsNew": True,
    "stateKey": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("delta_tools/rss-atom-feed-new-item-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 '{
  "feeds": [
    {
      "maxItems": 25,
      "name": "Hacker News newest",
      "url": "https://hnrss.org/newest"
    }
  ],
  "httpTimeoutSeconds": 45,
  "reportInitialAsNew": true,
  "stateKey": "default"
}' |
apify call delta_tools/rss-atom-feed-new-item-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,delta_tools/rss-atom-feed-new-item-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/uJNRSK00v9GKD2k41/builds/VSeQqzWV8cwPzTIK8/openapi.json