# RSS and Atom Feed Reader (`daddyd-prints/rss-atom-feed-reader`) Actor

Reads RSS, Atom and JSON feeds, or finds the feed of a website, and returns each item: title, link, dates, author, categories, summary and attachments. Date filter and full text optional. Pay per item.

- **URL**: https://apify.com/daddyd-prints/rss-atom-feed-reader.md
- **Developed by:** [Derek Derringer](https://apify.com/daddyd-prints) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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 and Atom Feed Reader

### What it does

This Actor reads news and blog feeds and returns every item as a clean row: title, link, publish and update dates in UTC, author, categories, a plain-text summary and any attached files (such as podcast audio). Give it one feed or a list of them.

It reads RSS (0.9x, 1.0 and 2.0), Atom and JSON Feed. If you give it a website instead of a feed, for example a blog's home page, it finds the feed the page announces and reads that.

You can keep only items published after a date, and you can ask for the full text and HTML of each item when the feed carries it.

It reads each site's robots.txt before anything else and obeys it. It never logs in, never sends a cookie and never tries to get past a CAPTCHA. Attached files are listed, not downloaded. Email addresses are removed from item titles, summaries, content, authors, categories, ids, links and attachments before anything is saved; text that only looks like an address, such as `react@18` or `logo@2x.png`, is kept.

### How to use it

1. Open the Actor in Apify Console.
2. Put one feed or website address per line in **Feed or website URLs**.
3. Set **Maximum items per feed**, and **Published on or after** if you only want recent items.
4. Click **Start**.
5. When the run ends, open the **Output** tab. The **Items** view shows each item with its feed, date, title, link and summary. Export as CSV, JSON or Excel.

### Input

| Field | What it does | Default | Limits |
| --- | --- | --- | --- |
| Feed or website URLs (`feedUrls`) | The feeds to read, one address per line. A web page works too, if it announces a feed. | None. Prefilled with one public feed | http and https only. Up to 500 lines. Duplicates are removed |
| Maximum items per feed (`maxItemsPerFeed`) | The most items saved from each feed, in the order the feed lists them (usually newest first). | 50 | 1 to 1,000 |
| Published on or after (`publishedAfter`) | Only items dated on or after this day, in UTC: `2026`, `2026-06`, `2026-06-30` or a full time. Items with no date are left out when this is set. | None | |
| Include full content (`includeContent`) | Also return the full HTML and text of each item, when the feed carries it. | false | Each is cut at 200,000 characters |
| Download timeout (`requestTimeoutSecs`) | How long a site may take to start answering. Reading the answer may then take up to four times this, so one download can take up to five times this, for each redirect. | 30 seconds | 5 to 120 seconds |

A date that cannot be read (including a day that does not exist, or a time that is not in UTC) stops the run before anything is requested, so nothing is charged for items you did not ask for. `2026-1-1` is read as 1 January.

**The same feed twice.** A feed reached a second time, through another address, a redirect or a page that announces it, is read once; the other lines are listed in SKIPPED as `duplicate_feed`. Two feeds count as the same when they have the same address, or the same format, title and item titles and dates. Different feeds that share items (a site's main feed and one of its category feeds, say) are separate, so a shared item can appear once for each feed, and each is charged.

### Output

One dataset item per feed item:

| Field | What it holds |
| --- | --- |
| `sourceUrl`, `feedUrl`, `discoveredFrom` | The address you gave, the feed that was read (after redirects), and the page the feed was found on when you gave a page |
| `feedTitle`, `feedLink`, `feedFormat` | The feed's title, its website, and its format: `rss20`, `rss10`, `rss090` to `rss094`, `atom10`, `atom01` to `atom03`, `json1` or `json1.1` |
| `position` | Where the item sits in the feed, from 1 |
| `itemId`, `title`, `link` | The item's id (RSS guid, Atom id or JSON Feed id; an RSS guid that is a relative address is made absolute, like a link; an id that holds an email address is replaced by a stable `sha256:` code), its title as plain text, and its web address |
| `published`, `updated` | Dates in ISO 8601, UTC. Empty when the feed does not say. In RSS feeds that date items with dc:date, that date is the published date |
| `author` | The author name the feed gives, without email addresses |
| `categories` | The item's categories or tags |
| `summary`, `summaryTruncated` | The summary as plain text, at most 2,000 characters, and whether it was cut |
| `contentHtml`, `contentText`, `contentTruncated` | The full content, when **Include full content** is on and the feed carries it. In the HTML, scripts, styles, frames, embedded objects, event handlers, `javascript:` and `data:` links and `mailto:` links are removed by feedparser's sanitizer and the Actor; images and other markup are kept as the feed has them. Relative links are made absolute. If an email address could still show in the HTML (for example one split across tags), `contentHtml` is left empty and only `contentText` is given |
| `enclosures` | Attached files: `url`, `type` and `lengthBytes` as the feed declares them |
| `readAt` | When the feed was read |

Example row from a test run of the prefilled feed (some fields left out):

```json
{"feedTitle": "Apify Blog", "feedFormat": "rss20", "position": 1, "title": "Get more people to use your Actor with task examples", "link": "https://blog.apify.com/actor-task-examples/", "published": "2026-10-22T08:00:00Z", "author": "Fabian Maume", "categories": ["Developer community", "Use cases"], "summaryTruncated": false, "enclosures": []}
```

### Pricing

This Actor is priced per event, with two charges:

- **Actor start:** Apify's automatic start event, $0.0001 per start (one event per GB of run memory, minimum one; this Actor runs at 256 MB, so one per run).
- **Item:** one charge for each feed item written to the dataset.

**Price per item: $1.00 per 1,000 items, which is $0.001 each.**

These are never charged: addresses that could not be read (robots.txt blocks, timeouts, errors, 401, 403, 429, login and CAPTCHA pages), pages that announce no feed, answers that are not a feed, feeds that cannot be read, feeds with no items, items outside the date filter, repeated items within a feed, the same feed reached a second time (see above), and the REPORT and SKIPPED records.

If you set a maximum cost for the run and it is reached, the Actor saves no more items, lists the rest in SKIPPED as `spending_limit_reached`, and ends the run without an error.

### Records

| Record | What it holds |
| --- | --- |
| REPORT | Why the run stopped, the settings used, feeds read and their formats, items saved per feed, items left out by date, repeated items dropped, robots.txt results and requests per site |
| SKIPPED | Every line that gave no items, could not be read, or was cut short, with the reason: `robots_disallowed`, `http_error`, `no_feed_found`, `not_a_feed`, `unreadable_feed`, `no_items`, `duplicate_feed`, `too_large`, `timeout`, `spending_limit_reached` and others. Only the items in the dataset are charged |

### Rules it follows

- robots.txt is read first on every site, including every site a redirect or a feed link leads to, and obeyed.
- One request at a time to any one site, with the site's Crawl-delay. A Crawl-delay over 30 seconds skips the site.
- Answers of 401, 403 and 429 are listed and not retried. Redirects to login or CAPTCHA pages are not followed.
- On Apify, private and local network addresses are refused.
- Feeds larger than 10 MB are skipped, compressed or not.
- A feed may not declare XML entities: the answer is decoded first (UTF-8, UTF-16 or UTF-32), every DOCTYPE and stray text before its first element is removed, an answer that still declares entities there is refused as not a feed, and no outside DTD or entity is ever fetched.
- One feed that cannot be read is listed as `unreadable_feed` and never stops the run.
- There is no cookie, header, login, proxy or user agent input. The user agent starts with `rss-atom-feed-reader/0.1`.

### Your responsibility

Feeds are published to be read, but their items belong to their publishers. You are responsible for following each site's terms of use and copyright in how you use and republish what this Actor returns.

### Limits

| Limit | Value |
| --- | --- |
| Feeds per run | 1 to 500 |
| Items per feed | 1 to 1,000 |
| Feed size | Up to 10 MB |
| Summary | 2,000 characters |
| Full content | 200,000 characters each for HTML and text |
| Memory | 256 MB |

# Actor input Schema

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

One address per line: a feed (RSS, RDF, Atom or JSON Feed), or a web page that announces its feed, such as a blog's home page. Before anything is requested from a site, the Actor reads that site's robots.txt, and any address it disallows is skipped, listed in SKIPPED and not charged. Up to 500 lines.

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

The most items saved from each feed, in the order the feed lists them (usually newest first). Each saved item is one charged result.

## `publishedAfter` (type: `string`):

Only items published (or, when a feed gives no publish date, updated) on or after this date, in UTC: a year (2026), a month (2026-06), a day (2026-06-30) or a full time (2026-06-30T12:30). 2026-1-1 is read as 1 January. Items with no date at all are left out when this is set. Leave empty to keep every item.

## `includeContent` (type: `boolean`):

Also return the full text and HTML of each item when the feed carries it. Off by default: many feeds carry whole articles, which makes the output much larger.

## `requestTimeoutSecs` (type: `integer`):

How long a site may take to start answering. Reading the answer may then take up to four times this, so one download can take up to five times this, for each redirect. A feed that does not arrive in time is listed in SKIPPED and not charged.

## Actor input object example

```json
{
  "feedUrls": [
    "https://blog.apify.com/rss/"
  ],
  "maxItemsPerFeed": 50,
  "includeContent": false,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

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

No description

## `report` (type: `string`):

No description

## `skipped` (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://blog.apify.com/rss/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("daddyd-prints/rss-atom-feed-reader").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://blog.apify.com/rss/"] }

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

```

## MCP server setup

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

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/twqyUdXtRAP5Muv0C/builds/9or8f9h9Qfz6Ughf2/openapi.json