# Feed Delta — RSS, Atom and JSON Feed Updates (`intuitional_lilypad/feed-delta-rss-atom-json`) Actor

Extract RSS, Atom and JSON Feed into JSON, CSV or Excel. Compare snapshots to deliver new entries and detect edits, without repeating unchanged content.

- **URL**: https://apify.com/intuitional_lilypad/feed-delta-rss-atom-json.md
- **Developed by:** [hhpost](https://apify.com/intuitional_lilypad) (community)
- **Categories:** Automation, Developer tools, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 new or updated feed entries

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

## Feed Delta — RSS, Atom and JSON Feed Updates

Get new and updated feed entries as clean JSON, CSV or Excel data. Feed Delta compares each entry with a previous snapshot, so a workflow can skip unchanged articles and still detect edits to older entries.

Use it for newsletter research, feed-to-database imports, release-note monitoring and collecting updates for an AI workflow. It reads feed content; it does not crawl the full article pages or generate summaries.

### Try it

1. Keep the prefilled GitHub blog example, or enter 1–5 public HTTPS feed URLs.
2. Click **Start**. Open **Output** to view or download the entries.

No proxy, browser or additional API key is needed. The GitHub blog is an example source, with no affiliation.

### Get only changes on later runs

The first run treats all valid entries as new. For incremental processing:

1. Open the run's key-value store and copy **NEXT_STATE**.
2. On the next run, expand **Incremental processing** and use that object as **Previous state**.

In an automated workflow, retrieve `NEXT_STATE` from the run's default key-value store, save it after your downstream delivery succeeds, and pass it as `previousState` on the next run. Each workflow owns its snapshot, so separate workflows do not overwrite one another's progress. Running on a schedule alone does not transfer this state.

```json
{
  "feedUrls": ["https://github.blog/feed/"],
  "maxResults": 100,
  "previousState": {"version": 1, "seen": {}}
}
```

An empty `previousState` starts a new baseline. The full snapshot contains fingerprints, not article text.

### What you receive

The default dataset contains only new or changed entries:

| Field | Meaning |
| --- | --- |
| `change` | `new` or `updated` |
| `id`, `key` | Feed identity and a stable key scoped to the feed URL |
| `title`, `url`, `content` | Content supplied by the feed |
| `source` | Original feed URL |
| `published`, `updated` | Feed-provided timestamps, when available |
| `content_hash` | Fingerprint for downstream deduplication |

Download the dataset as JSON, CSV or Excel using Apify's export controls. The key-value store also contains:

- **OUTPUT**: counts, source formats, errors and any results not emitted because a limit was reached.
- **NEXT_STATE**: the snapshot to use on the next run.

A successful run with zero dataset rows means there were no changes, provided `OUTPUT.status` is `completed`.

### Pricing

- **$1 per 1,000 new or updated entries** delivered ($0.001 each).
- **$0.00005 per start** at the default 256 MB memory. Apify charges one start event per GB, with a minimum of one.
- Unchanged entries have no result charge. A no-change run still has its start charge.

For example, 100 delivered entries at the default memory cost $0.10005. The platform's current pricing panel is authoritative. Set a maximum cost per run to control spending; the minimum allowed limit is $0.002. The configured event prices include ordinary platform usage.

When a result or spending limit stops delivery, `NEXT_STATE` includes only delivered changes. Pass that state to retrieve the remaining changes later. A platform interruption can happen before the final summary is written; inspect the run status and available records before advancing your downstream checkpoint.

### Limits and behavior

- RSS 2.0, Atom, RDF/RSS and JSON Feed; UTF-8; up to 5 MB per feed.
- 1–5 public HTTPS feeds on port 443, up to 1,000 changed entries per run and 50,000 remembered identities.
- Entries need a stable ID or link. Identity is scoped to the exact feed URL, including its query string.
- Missing entries are not deletions: feeds typically retain only recent content.
- Source failures appear in `OUTPUT`. Good sources can still produce results, while total source failure fails the run. Failed sources do not remove previously saved fingerprints.
- No login, browser rendering, proxies or XML DTD processing.
- A crash between delivery and checkpointing can replay an entry. Downstream consumers should deduplicate using `key` plus `content_hash`; exactly-once delivery and charging are not guaranteed.

For a problem, open the Actor's Issues tab with the run ID, feed format and a short description. Do not include credentials or private feed content.

# Actor input Schema

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

1–5 public HTTPS RSS, Atom, RDF or JSON Feed URLs. Each feed is limited to 5 MB.

## `maxResults` (type: `integer`):

Up to 1,000 changed entries. Undelivered entries are not added to NEXT_STATE and can be retried.

## `previousState` (type: `object`):

Paste NEXT_STATE from the last successful run of this workflow. Without it, all entries are new. Keep independent workflows separate.

## Actor input object example

```json
{
  "feedUrls": [
    "https://github.blog/feed/"
  ],
  "maxResults": 100,
  "previousState": {
    "version": 1,
    "seen": {}
  }
}
```

# Actor output Schema

## `entries` (type: `string`):

No description

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

No description

## `nextState` (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://github.blog/feed/"
    ],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("intuitional_lilypad/feed-delta-rss-atom-json").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://github.blog/feed/"],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("intuitional_lilypad/feed-delta-rss-atom-json").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://github.blog/feed/"
  ],
  "maxResults": 100
}' |
apify call intuitional_lilypad/feed-delta-rss-atom-json --silent --output-dataset

```

## MCP server setup

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

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/M7stmJMLduhKVEFjG/builds/6VL8vIshkXve2z8Hd/openapi.json