# RSS Feed Reader & Scraper: RSS, Atom, JSON Feeds (`cyber1nj3ct0r/rss-feed-reader`) Actor

RSS feed scraper and reader for news sites and blogs: read any RSS, Atom or JSON feed, or give a website and it finds the feed. Every item with title, link, date, author, summary, categories and image in one table, plus the full text if you want it. Filter by date, read many feeds in one run.

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

## Pricing

from $0.40 / 1,000 items

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

### What does RSS Feed Reader do?

RSS Feed Reader turns news feeds into a clean table. Give it the addresses of RSS, Atom, RSS 1.0 or JSON feeds, or simply the websites, and you get every item with its **title, link, publication date, author, summary, categories, image and attachments**, ready to export to Excel, CSV or JSON, or to send on to another app.

- Reads RSS 2.0, Atom, RSS 1.0 (RDF) and JSON Feed, all into the same columns
- Finds a website's feed on its own: give `https://www.example.com` and it looks for the feed the site announces, then at the usual places
- Reads many feeds in one run, each item once
- Turns dates into one format (ISO 8601) and HTML descriptions into plain text
- Optional: the full text of each item, as HTML and as plain text
- Filter by date: only items from the last 24 hours, 7 days, or since any date

### What data do you get?

| Field | Example |
|---|---|
| Title | `How we cut our build time in half` |
| Link | `https://www.example.com/blog/build-time` |
| Published | `2026-10-14T08:16:08.000Z` |
| Author | `Ann Lee` |
| Summary | the item's description as plain text |
| Categories | `["Engineering", "Tutorial"]` |
| Image | the item's thumbnail or first image |
| Attachments | podcast audio and other files, with type and size |
| Feed | the feed's title and address |

### How to read RSS feeds into a spreadsheet

1. Under **Feeds or websites**, add the feeds you follow, or the websites themselves.
2. Optionally set **Maximum items per feed** or **Published since**.
3. Press **Start**.
4. Export the **Items** table as Excel or CSV, or connect it to Google Sheets, Slack, Make or Zapier.

### How much does it cost to read feeds?

You pay for results, not for time: **$0.50 per 1,000 items**. Apify subscribers on the Silver plan pay $0.45 and on the Gold plan $0.40 per 1,000 items. Each run also has a start fee of $0.00005.

| Items returned | Cost |
|---|---|
| 100 | $0.05 |
| 1,000 | $0.50 |
| 10,000 | $5.00 |
| 100,000 | $50.00 |

Apify's free plan includes $5 of credit each month, which covers about 10,000 items. Items left out by your filters are not charged. Set a maximum cost for the run in Apify Console and the tool stops there and keeps what it has read.

### Input

The only required field is **Feeds or websites**. The other options:

- **Maximum items per feed**: keeps the first items of each feed, usually the newest.
- **Published since**: a date, or a period such as `7 days` or `24 hours`.
- **Include the full text**: adds each item's full content as HTML and as plain text.
- **Find the feed of a website**: on by default; turn it off to treat every address strictly as a feed.
- **Time limit per request** and **User-Agent** under More options.

### Output example

```json
{
    "feedUrl": "https://www.example.com/feed",
    "feedTitle": "Example Blog",
    "title": "How we cut our build time in half",
    "link": "https://www.example.com/blog/build-time",
    "published": "2026-10-14T08:16:08.000Z",
    "updated": null,
    "author": "Ann Lee",
    "summary": "Three changes to our pipeline that took the build from 14 minutes to 6.",
    "categories": ["Engineering", "Tutorial"],
    "imageUrl": "https://www.example.com/images/build-time.png",
    "enclosures": [],
    "guid": "https://www.example.com/?p=4521",
    "source": "https://www.example.com",
    "error": null
}
```

When an address gives no feed, the table has one row for it with an `error`: `NO_FEED_FOUND` (a website without a feed), `NOT_A_FEED`, `HTTP_ERROR` or a network error such as `DNS_NOT_FOUND`.

### What can you use it for?

- Follow news, blogs, podcasts and release notes in one spreadsheet
- Feed new articles into Slack, e-mail, Notion or your own app on a schedule
- Collect your competitors' or your industry's publications for research and AI tools
- Track podcast episodes with their audio files
- Archive a feed's items before they drop off the end of the feed

Schedule the run in Apify Console, for example every hour with **Published since** set to `1 hour`, to get only the new items each time.

### Use it from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/cyber1nj3ct0r~rss-feed-reader/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"feedUrls": [{"url": "https://www.example.com/feed"}], "since": "7 days"}'
```

The same works from Python, JavaScript, Make, Zapier and n8n through Apify's integrations.

### FAQ

#### Why does a feed have fewer items than the website?

A feed holds only its most recent items, often the last 10 to 50, chosen by the site. The tool returns what the feed holds. Run it on a schedule to build up a longer history.

#### The tool says no feed was found. Why?

The site may not have a feed, or keeps it at an unusual address it does not announce. If you know the address, enter it directly.

#### Why is the author empty?

Many feeds do not name an author. When a feed gives only an e-mail address, it is left out: the tool returns names, not e-mail addresses.

#### A site blocks the tool. What can I do?

The tool identifies itself honestly in its User-Agent and does not try to get round blocks. If it is your own site, allow the User-Agent in your firewall, or set your own under **More options**.

#### Is it allowed to read feeds?

Feeds are published so that programs can read them. The tool reads each feed once per run. The articles belong to their publishers: you are responsible for how you use and share the content.

#### Something does not work

Open an issue on the **Issues** tab with the feed or website you tried. Every report is read and answered.

# Actor input Schema

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

Feed addresses (RSS, Atom, RSS 1.0 or JSON Feed), for example <code>https://www.example.com/feed</code>, or website addresses: the tool then finds the feed the site announces. Add them one by one, paste many with <b>Bulk edit</b>, or link a text file.

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

Keep at most this many items of each feed, in the order the feed lists them (usually newest first). You pay per item returned, so this also caps the cost.

## `since` (type: `string`):

Keep only items published (or updated) on or after this date. Pick a date or a period such as <code>7 days</code> or <code>24 hours</code>. Items without a date are left out when this filter is set.

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

Add each item's full content as the feed gives it, as HTML and as plain text. Without this, items carry a summary of up to 1,000 characters.

## `findFeeds` (type: `boolean`):

When an address is a web page, look for the feed it announces, then at the usual places (/feed, /rss.xml, /atom.xml and others).

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

How long to wait for one feed or page before giving up.

## `userAgent` (type: `string`):

The name the tool sends with each request. Leave empty to use the tool's own name, which tells site owners what is visiting. Set your own only for sites you run or have permission to use.

## Actor input object example

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

# Actor output Schema

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

One record per feed item: title, link, dates, author, summary, categories, image and attachments.

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

Each feed read: its address, title, format, language, items in the feed and items returned.

# 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": [
        {
            "url": "https://blog.apify.com/rss/"
        }
    ],
    "maxItemsPerFeed": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("cyber1nj3ct0r/rss-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": [{ "url": "https://blog.apify.com/rss/" }],
    "maxItemsPerFeed": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("cyber1nj3ct0r/rss-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": [
    {
      "url": "https://blog.apify.com/rss/"
    }
  ],
  "maxItemsPerFeed": 20
}' |
apify call cyber1nj3ct0r/rss-feed-reader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cyber1nj3ct0r/rss-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/N3OwL5p7L5WoTqcVE/builds/yaaDEXntyqzgMNZtZ/openapi.json