# RSS Feed Scraper (`scrapemint/rss-feed-scraper`) Actor

Scrape any RSS or Atom feeds into clean structured rows: title, link, date, author, summary, categories and image. Accepts plain site URLs too (finds the feed automatically). Monitor mode turns any site into a new-post alert feed. No API key.

- **URL**: https://apify.com/scrapemint/rss-feed-scraper.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** News, Automation
- **Features:** Limited permissions
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 feed item rows

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 Feed Scraper

Turn any RSS or Atom feeds into clean structured data. Paste feed URLs - or just website URLs, and the actor finds the feed for you - and get one row per item with title, link, date, author, plain-text summary, categories and image. No API key, no login, no browser.

### What you get

One row per feed item:

- title, link, published date (ISO), author
- a **plain-text summary** with HTML stripped and entities decoded
- categories/tags and the item image (enclosure or media tag)
- feed title and URL, plus the input URL it came from
- optionally the full HTML content when the feed carries it

### Feed autodiscovery

You do not need to know a site's feed URL. Give it `https://techcrunch.com` and the actor reads the page's feed link tag (falling back to common paths like `/feed` and `/atom.xml`) and scrapes what it finds. RSS 2.0, RSS 1.0 and Atom all work, including the malformed feeds real sites publish.

```json
{
    "feedUrls": [
        "https://feeds.bbci.co.uk/news/technology/rss.xml",
        "https://techcrunch.com"
    ],
    "maxPerFeed": 50
}
```

### Monitor mode

Turn on **newOnly**, put the actor on a schedule, and each run emits only items it has not returned before. That turns any list of sites into a new-post alert feed - competitor blogs, industry news, product changelogs, security advisories - ready to pipe into Sheets, Slack or anything else. Runs where nothing new arrived cost nothing.

### Who uses this

- **Marketing and PR teams**: watch competitor blogs and industry news in one place, structured.
- **Founders and analysts**: aggregate niche sources into one dataset instead of an unread feed reader.
- **Developers**: a feed-to-JSON bridge for dashboards and automations - no parsing, no cron server.
- **Researchers and journalists**: collect articles across many outlets with consistent fields.

Pairs with our Google News Scraper for keyword-driven discovery and our Website Change Monitor for pages that have no feed at all.

### Pricing

A small fee per item row. Dead URLs, sites with no discoverable feed, and runs where nothing new arrived are free note rows, and the first 2 rows of every run are free.

### Notes

- Feeds are fetched directly with plain HTTP - your sources see a normal feed-reader request.
- Items are returned in feed order (feeds put newest first). Use **sinceDays** to drop old items on first runs.
- Very large feeds are truncated at the last complete item; per-feed and total row caps keep runs bounded.

# Actor input Schema

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

RSS/Atom feed URLs, one per line. Plain website URLs work too - the actor finds the site's feed automatically (link tag, then common paths like /feed).

## `maxPerFeed` (type: `integer`):

How many items to return per feed, in feed order (feeds put newest first).

## `sinceDays` (type: `integer`):

Only items published in the last N days. 0 = everything the feed carries. Items without a parseable date are kept.

## `includeFullContent` (type: `boolean`):

Include the item's full HTML content when the feed carries it (content:encoded / Atom content). Rows get much bigger; the plain-text summary is always included.

## `newOnly` (type: `boolean`):

Remember items already returned and emit only ones not seen before. Run on a schedule to turn any site's feed into a new-post alert feed - quiet runs cost nothing.

## `maxRows` (type: `integer`):

Stop after this many rows in total across all feeds.

## Actor input object example

```json
{
  "feedUrls": [
    "https://feeds.bbci.co.uk/news/technology/rss.xml",
    "https://techcrunch.com/feed/"
  ],
  "maxPerFeed": 50,
  "sinceDays": 0,
  "includeFullContent": false,
  "newOnly": false,
  "maxRows": 500
}
```

# 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://feeds.bbci.co.uk/news/technology/rss.xml",
        "https://techcrunch.com/feed/"
    ]
};

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

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

```

## MCP server setup

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

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/ioC8sKMN3F2DBX57P/builds/q9JF9wv5p0jBnaOJt/openapi.json