# 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
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# 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("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapemint/rss-feed-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RSS Feed Scraper",
        "description": "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.",
        "version": "0.1",
        "x-build-id": "q9JF9wv5p0jBnaOJt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~rss-feed-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-rss-feed-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapemint~rss-feed-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-rss-feed-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapemint~rss-feed-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-rss-feed-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "feedUrls"
                ],
                "properties": {
                    "feedUrls": {
                        "title": "Feed or site URLs",
                        "type": "array",
                        "description": "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).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPerFeed": {
                        "title": "Items per feed",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How many items to return per feed, in feed order (feeds put newest first).",
                        "default": 50
                    },
                    "sinceDays": {
                        "title": "Published within (days)",
                        "minimum": 0,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Only items published in the last N days. 0 = everything the feed carries. Items without a parseable date are kept.",
                        "default": 0
                    },
                    "includeFullContent": {
                        "title": "Include full content HTML",
                        "type": "boolean",
                        "description": "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.",
                        "default": false
                    },
                    "newOnly": {
                        "title": "Monitor mode: new items only",
                        "type": "boolean",
                        "description": "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.",
                        "default": false
                    },
                    "maxRows": {
                        "title": "Max rows",
                        "minimum": 1,
                        "maximum": 25000,
                        "type": "integer",
                        "description": "Stop after this many rows in total across all feeds.",
                        "default": 500
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
