# RSS Feed Scraper - RSS & Atom to JSON (`technicaldost/rss-feed-scraper`) Actor

Convert public RSS and Atom feeds to JSON or CSV, or paste any website and the Actor finds its feed. Titles, links, dates, authors, summaries and full content, with keyword and date filters. Failed-feed diagnostics are free by default; optional error dataset rows are billable.

- **URL**: https://apify.com/technicaldost/rss-feed-scraper.md
- **Developed by:** [Technical Dost Solutions](https://apify.com/technicaldost) (community)
- **Categories:** News, Automation, AI
- **Features:** Limited permissions
- **Stats:** 102 total users, 15 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$8.00 / 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.

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

Turn one or hundreds of public RSS and Atom feeds into clean, structured dataset items. Use it for one-off scrapes, bulk exports, content aggregation, podcast and YouTube feed ingestion, research, or an AI/RAG pipeline without proxies or cookies.

**First run:** use the prefilled Hacker News feed with five items. A successful run produces at most six dataset rows, or $0.048 at the current $0.008 per row. Check the live Pricing tab before starting, then inspect the `feed_item` rows in the default dataset.

Need an hourly or daily schedule that returns only new items? [RSS Feed Monitor](https://apify.com/technicaldost/rss-feed-monitor) handles deduplication across runs. Its [HN and BBC example](https://apify.com/technicaldost/rss-feed-monitor/examples/watch-hn-and-bbc-new-items) shows the separate workflow.

### Import a ready-to-run workflow

Use the tested starter inputs in [n8n JSON](https://api.apify.com/v2/key-value-stores/IQa7iF8xgAsSffUKz/records/rss-ingestion.n8n.json?attachment=true) or the [Make blueprint](https://api.apify.com/v2/key-value-stores/IQa7iF8xgAsSffUKz/records/rss-ingestion.make.json?attachment=true). [Setup instructions](https://api.apify.com/v2/key-value-stores/IQa7iF8xgAsSffUKz/records/README.md?attachment=true) explain import, credentials, output fields and recovery. [Download both platforms as a ZIP](https://api.apify.com/v2/key-value-stores/IQa7iF8xgAsSffUKz/records/integration-workflows.zip?attachment=true).

Select your own Apify credential after importing and run manually first. The templates set a $1 maximum run budget, check run success and preserve useful output. The $1 setting is a ceiling, not a fixed charge. Source availability and provider execution limits still apply. No recurring schedule or external destination is enabled by these files.

### What you get

- Parse multiple RSS or Atom feed URLs in one run, five at a time.
- Paste an ordinary website URL (for example `https://techcrunch.com`) and the Actor finds the feed the site publishes.
- Keep only entries that mention your `keywords`, or that were published after a date (`publishedAfter`, e.g. `2026-10-01` or `7 days`).
- Extract titles, links, authors, publication dates, categories, summaries, full content when supplied by the feed, and media/enclosure metadata.
- Control volume independently for every feed, from 1 to 500 items.
- Continue processing other feeds if an individual feed is temporarily unavailable or malformed. By default, failed-feed diagnostics are listed in the run status and the `ERRORS` record of the key-value store, outside the billable dataset. If you enable `saveErrorRows`, any error rows written to the dataset are billed at the standard per-row rate.
- Export results as JSON, CSV, Excel, XML, or HTML through Apify datasets.
- Run manually, on a schedule, by API, or from Make, Zapier, n8n, webhooks, and other Apify integrations.

### Quick start

```json
{
  "feedUrls": [
    "https://news.ycombinator.com/rss"
  ],
  "maxItemsPerFeed": 5,
  "includeContent": true
}
```

The prefilled first run uses this one-feed, five-entry example. It produces at most six billed dataset rows, or $0.048 at the current $0.008 per row, when the feed succeeds. The output includes one metadata row plus up to five entry rows. Check the live Pricing tab before running. Results appear in the default dataset. The API default remains 50 entries per feed when `maxItemsPerFeed` is omitted, so set a limit explicitly when cost matters.

Try the ready-to-run examples: [HN and BBC news feeds](https://apify.com/technicaldost/rss-feed-scraper/examples/hacker-news-and-bbc-rss) or [Google Developers YouTube feed](https://apify.com/technicaldost/rss-feed-scraper/examples/youtube-dev-channel-feed-monitor).

### Input

| Field | Type | Required | Default | Description |
|---|---|---:|---:|---|
| `feedUrls` | string\[] | Yes | None | Public RSS or Atom feed URLs to parse. |
| `maxItemsPerFeed` | integer | No | `50` for omitted API input; `5` prefilled in the form | Maximum items extracted from each feed. Allowed range: 1–500. |
| `includeContent` | boolean | No | `true` | Include full article content when the feed provides it. |

### Output

The Actor writes `feed_metadata` and `feed_item` records to the default dataset. For articles or videos, filter rows to `type === "feed_item"`. A failed feed does not prevent other feeds from completing: it is listed, free of charge, in the run status message and in the `ERRORS` record of the run's key-value store. Set `saveErrorRows` to `true` to also get `error` rows in the dataset (billed like other rows).

After exporting the dataset as JSON, the free [local dataset receipt example](https://github.com/Technical-Dost/apify-rss-feed-to-json-example/blob/main/examples/summarize-dataset.mjs) counts all three row types and exits nonzero for a failed or empty feed. It does not start another Actor run. The [five-item walkthrough](https://technical-dost.github.io/apify-rss-feed-to-json-example/) shows the same bounded input and illustrative output.

Use `guid` with `feedUrl` as a downstream identity where available, and fall back to the entry `link`. A repeat run returns the feed again; this scraper does not maintain a cross-run seen-item history.

The Actor writes feed metadata and normalized feed entries to the default Apify dataset. Available fields depend on what each publisher includes in its feed and can include:

- feed and item titles
- canonical links
- author or creator
- publication date
- description or content snippet
- full encoded content
- categories
- enclosures and media metadata

Because publishers expose different RSS extensions, fields that are absent in the source feed may be empty.

### Common use cases

#### News and competitor monitoring

Collect recent posts from company blogs, publications, press rooms, or industry sources on a schedule and send new items to Slack, email, a database, or a spreadsheet.

#### AI and RAG ingestion

Convert feeds into predictable JSON before embedding, summarizing, classifying, or routing content through an agent workflow.

#### Podcast and YouTube monitoring

Ingest podcast RSS feeds and public YouTube channel feeds, including available dates, links, descriptions, and enclosure/media data.

#### Content aggregation

Combine multiple public feeds in one run and export the output to JSON, CSV, or Excel for a dashboard, newsletter, or research pipeline.

### API example

Run this request from a terminal after setting `APIFY_TOKEN`. Keep your token private; the Authorization header avoids putting it into the URL.

```bash
curl --request POST \
  'https://api.apify.com/v2/actors/technicaldost~rss-feed-scraper/run-sync-get-dataset-items?timeout=120' \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{"feedUrls":["https://feeds.bbci.co.uk/news/rss.xml"],"maxItemsPerFeed":5,"includeContent":true}'
```

In n8n, Make or another HTTP workflow, use the same POST URL, headers and JSON body. Split the returned array into rows, keep `type=feed_item`, and map `title`, `link`, `pubDate`, `summary` and `guid` to your next step. Large batches should use the asynchronous Actor runs endpoint and fetch the resulting dataset after completion.

### Pricing

This Actor costs $8.00 per 1,000 dataset items. Always check the live Pricing tab before a large run. You pay for results, not a subscription. Use maxItemsPerFeed to control entry volume. Metadata rows are also dataset items under the current pricing model. Failed feeds are not billed unless you turn on `saveErrorRows`. The run-budget minimum shown by Apify is not a minimum actual bill.

### Limits and responsible use

- The feed URL must be publicly reachable by Apify.
- The Actor does not sign in to private feeds or bypass access controls.
- Output completeness depends on the fields supplied by the publisher.
- Respect publisher terms, copyright, privacy, and applicable laws when storing or republishing feed content.

### Support

If a valid public feed fails or a field is parsed incorrectly, open an issue with the feed URL, expected behavior, and a sample of the missing data. Do not include credentials or private feed tokens.

### Use RSS Feed Scraper with AI agents (MCP)

Give Claude, ChatGPT, Cursor, VS Code or any MCP client this Actor as a tool through the hosted [Apify MCP server](https://mcp.apify.com). The agent sees the input fields with descriptions and example values, runs the Actor, and reads the results.

**MCP server URL (this Actor only):**

```
https://mcp.apify.com/?tools=technicaldost/rss-feed-scraper
```

**Claude Code:**

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=technicaldost/rss-feed-scraper" --header "Authorization: Bearer YOUR_APIFY_TOKEN"
```

**Cursor, VS Code, Claude Desktop and other clients** (`mcp.json` or the client's MCP settings):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=technicaldost/rss-feed-scraper",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

Clients that support sign-in (such as Claude.ai connectors) can use the URL without a token and log in to Apify instead. Get your token in [Apify Console → Settings → API & Integrations](https://console.apify.com/settings/integrations), or generate a ready config for your client at [mcp.apify.com](https://mcp.apify.com). In the agent the tool is named `technicaldost--rss-feed-scraper`; ask it, for example, to *"run RSS Feed Scraper with {"feedUrls": \["https://news.ycombinator.com/rss", "https://feeds.bbci.co.uk/news/rss.xml"], "maxItemsPerFeed": 10, "includeContent": true}"*.

AI agents without an Apify account can also run and pay for this Actor per request with [x402 agentic payments](https://docs.apify.com/platform/integrations/x402).

### Run RSS Feed Scraper via API

Run the Actor and get its results in one call (replace `YOUR_APIFY_TOKEN`):

```bash
curl -X POST "https://api.apify.com/v2/acts/technicaldost~rss-feed-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"feedUrls": ["https://news.ycombinator.com/rss", "https://feeds.bbci.co.uk/news/rss.xml"], "maxItemsPerFeed": 10, "includeContent": true}'
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("technicaldost/rss-feed-scraper").call(run_input={"feedUrls": ["https://news.ycombinator.com/rss", "https://feeds.bbci.co.uk/news/rss.xml"], "maxItemsPerFeed": 10, "includeContent": true})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**JavaScript / TypeScript** (`npm install apify-client`):

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('technicaldost/rss-feed-scraper').call({"feedUrls": ["https://news.ycombinator.com/rss", "https://feeds.bbci.co.uk/news/rss.xml"], "maxItemsPerFeed": 10, "includeContent": true});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Long runs: start them with `POST /v2/acts/technicaldost~rss-feed-scraper/runs` and fetch the dataset when the run finishes, or receive a webhook.

### FAQ

#### Can I use RSS Feed Scraper with AI agents like Claude or ChatGPT?

Yes. Connect the Apify MCP server with `?tools=technicaldost/rss-feed-scraper` (see above) and the agent can run the Actor and read its results on its own.

#### Can I call RSS Feed Scraper from my own code?

Yes. Use the REST API, or the official Python and JavaScript clients shown above. Results are available as JSON, CSV, Excel, XML or HTML.

#### How do I run it on a schedule?

Save your input as a task in Apify Console and add a schedule (for example, daily). Use webhooks or integrations to send each run's results onward.

#### Is it legal to use this Actor?

It works with publicly available data. Make sure your use complies with the source website's terms and with data protection laws such as GDPR, especially for personal data.

#### Something doesn't work or I need a feature. What should I do?

Open an issue in the **Issues** tab on this Actor's page with an example input, and we'll look into it.

# Actor input Schema

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

Public RSS or Atom feed URLs, or ordinary website URLs (e.g. https://techcrunch.com): for a website, the Actor finds and uses the feed it publishes. Start with one feed, then add more after checking the output and pricing.

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

Maximum entry rows per feed. Each successful feed also adds one billable metadata row; check the Pricing tab.

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

Whether to include full article content (if available)

## `keywords` (type: `array`):

Keep only entries whose title, summary or categories contain at least one of these words (case-insensitive). Leave empty to keep all entries.

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

Keep only entries published after this date, e.g. 2026-10-01, or within a period such as "24 hours" or "7 days". Entries without a date are kept.

## `saveErrorRows` (type: `boolean`):

Failed feeds are always listed in the ERRORS record of the key-value store and the run status, free of charge. Turn this on to also save them as type "error" rows in the dataset; those rows are billed like any dataset item.

## Actor input object example

```json
{
  "feedUrls": [
    "https://news.ycombinator.com/rss"
  ],
  "maxItemsPerFeed": 5,
  "includeContent": true,
  "saveErrorRows": false
}
```

# Actor output Schema

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

Parsed feed items with title, link, published date, and feed URL

# 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://news.ycombinator.com/rss"
    ],
    "maxItemsPerFeed": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("technicaldost/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://news.ycombinator.com/rss"],
    "maxItemsPerFeed": 5,
}

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

```

## MCP server setup

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