# RSS Feed Scraper - RSS & Atom Data (`benthepythondev/rss-feed-scraper`) Actor

Scrape RSS and Atom feeds into structured records with title, URL, author, publish date, categories, image and summary.

- **URL**: https://apify.com/benthepythondev/rss-feed-scraper.md
- **Developed by:** [ben](https://apify.com/benthepythondev) (community)
- **Categories:** Automation, SEO tools, Business
- **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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 - RSS & Atom Data

Scrape RSS and Atom feeds into clean, structured records that are ready for spreadsheets, dashboards, automations, monitoring tools and content pipelines. Paste one or more feed URLs and the actor returns every item with the title, URL, publish date, author, categories, image and cleaned summary.

### What is the RSS Feed Scraper?

RSS and Atom are still one of the most reliable ways to monitor websites. Newsrooms, blogs, ecommerce stores, podcasts, documentation portals, changelogs and company announcement pages often expose feeds even when the normal website is noisy or difficult to scrape. This actor turns those feeds into a normalized dataset that can be exported as JSON, CSV, Excel or consumed through the Apify API.

The scraper supports both classic RSS feeds and Atom feeds. It reads standard item fields, handles common namespace extensions such as Dublin Core, Media RSS and content:encoded, and strips HTML from summaries so the output is easier to work with. It is designed for reliability: no browser, no login, no proxy and no heavy compute. That makes it a strong fit for scheduled monitoring jobs.

### Common use cases

Use this actor to monitor competitor blogs, track company press releases, collect article URLs for SEO research, feed a newsletter curation workflow, build a news alert pipeline, ingest podcast episode metadata, watch software changelogs, or archive posts from multiple content sources.

Because the output is normalized, you can send the dataset directly into Make, Zapier, n8n, Airtable, Google Sheets, a database, a vector pipeline, or a custom alerting system. For example, run it every hour against a list of industry feeds, filter new items by keyword, and notify your sales or research team when a relevant article appears.

### Input

Provide one or more RSS or Atom feed URLs.

```json
{
  "feedUrls": [
    "https://blog.apify.com/rss/"
  ],
  "maxItems": 10
}
````

### Output

Each dataset item represents one feed entry.

```json
{
  "feed_url": "https://blog.apify.com/rss/",
  "final_feed_url": "https://blog.apify.com/rss/",
  "feed_title": "Apify Blog",
  "title": "Example article title",
  "url": "https://blog.apify.com/example/",
  "guid": "https://blog.apify.com/example/",
  "published_at": "2026-07-07T09:00:00+00:00",
  "author": "Apify",
  "summary": "Clean text summary without HTML tags.",
  "categories": ["Web scraping"],
  "image": "https://example.com/image.jpg",
  "source_type": "rss"
}
```

### Output fields

- `feed_url` - the original feed URL you provided.
- `final_feed_url` - the final URL after redirects.
- `feed_title` - the title of the RSS channel or Atom feed.
- `title` - item or entry title.
- `url` - canonical article, episode or entry URL when available.
- `guid` - RSS guid or Atom id.
- `published_at` - parsed publish date in ISO format when possible.
- `author` - author or creator field when present.
- `summary` - cleaned text summary.
- `categories` - categories or tags from the feed.
- `image` - Media RSS thumbnail/content image when present.
- `source_type` - `rss` or `atom`.

### Why use this actor?

Feeds are usually more stable than HTML pages. They are lightweight, fast, structured and intended for machine consumption. This actor keeps that advantage while giving you Apify scheduling, storage, exports, API access, webhooks and integrations. You can scrape many feeds without a browser and without paying proxy costs.

### Example workflows

For content monitoring, add your competitors' blog feeds, schedule the actor every morning, and send new titles into a spreadsheet or Slack channel. For newsletter research, collect posts from trade publications and filter by category or keyword before handing the list to an editor. For product and developer monitoring, watch changelog feeds, release feeds and documentation feeds so your team sees important updates quickly.

For SEO teams, RSS feeds are useful because they provide fresh URLs without crawling a whole website. You can collect the newest posts, enrich the domains, check whether pages are indexed, or send the URLs into a backlink prospecting workflow. For data teams, feeds are a dependable ingestion layer because the schema is simpler and more stable than public HTML.

### Integration ideas

Use Apify webhooks to trigger a downstream workflow when a run finishes. Send the dataset to Make or Zapier, deduplicate by `guid` or `url`, and notify only when a new item appears. Export to CSV for manual review, or call the dataset API from a backend service to keep an internal content database current.

You can also pair this actor with a full-page scraper. First collect URLs from RSS feeds, then pass only those URLs into a website content actor. That two-step approach is cheaper and more reliable than crawling an entire site when all you need is the latest content.

### Notes and limits

Some websites publish partial summaries instead of full article text. This actor returns what the feed provides; it does not crawl each linked article. If you need full article pages, combine this actor with a website content scraper after collecting the URLs. Feeds that require authentication or block non-browser clients may fail, but public feeds generally work well.

### Best practices

Use stable feed URLs instead of homepage URLs. Keep `maxItems` modest for frequent monitoring runs and raise it only for backfills. Store the previous run's `guid` values if you want to detect new items. When a feed provides both `published_at` and `guid`, use the `guid` as the primary deduplication key because publishers sometimes edit titles and dates.

### FAQ

Can it scrape Atom feeds?

Yes. It supports RSS and Atom and normalizes both into the same output structure.

Does it download full web pages?

No. It reads the feed document only. That keeps runs fast, cheap and reliable.

Can I run it on a schedule?

Yes. Schedule it in Apify and compare each run against previous results to detect new posts.

Can I use it for SEO monitoring?

Yes. RSS feeds are useful for competitor content tracking, news monitoring, backlink prospecting and content ideation.

### You might also like

- Website Contact Extractor - find contact details from websites.
- Sitemap URL Extractor - extract URLs from XML sitemaps.
- Google News Scraper - collect news search results.

### Keywords

RSS scraper, Atom scraper, feed scraper, RSS feed API, content monitoring, blog monitoring, news monitoring, feed extractor, SEO monitoring, Apify RSS scraper.

# Actor input Schema

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

RSS or Atom feed URLs to scrape.

## `maxItems` (type: `integer`):

Maximum number of feed items to return from each feed URL.

## Actor input object example

```json
{
  "feedUrls": [
    "https://blog.apify.com/rss/"
  ],
  "maxItems": 10
}
```

# 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/"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/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://blog.apify.com/rss/"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/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://blog.apify.com/rss/"
  ],
  "maxItems": 10
}' |
apify call benthepythondev/rss-feed-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=benthepythondev/rss-feed-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RSS Feed Scraper - RSS & Atom Data",
        "description": "Scrape RSS and Atom feeds into structured records with title, URL, author, publish date, categories, image and summary.",
        "version": "1.0",
        "x-build-id": "3DosSsiNKdu2YTFbH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~rss-feed-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-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/benthepythondev~rss-feed-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-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/benthepythondev~rss-feed-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-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",
                "properties": {
                    "feedUrls": {
                        "title": "Feed URLs",
                        "type": "array",
                        "description": "RSS or Atom feed URLs to scrape.",
                        "default": [
                            "https://blog.apify.com/rss/"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items per feed",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of feed items to return from each feed URL.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```