# RSS Feed Extractor: RSS/Atom → Clean JSON + Markdown (`boxbox10/rss-feed-extractor`) Actor

Turn any RSS or Atom feed into clean, LLM-ready Markdown + structured JSON — one record per feed item (title, link, author, publishedAt, summary, categories, clean contentMarkdown). Optional full-text fetch. Perfect for content monitoring, news aggregation, and RAG over feeds.

- **URL**: https://apify.com/boxbox10/rss-feed-extractor.md
- **Developed by:** [Marvin Eguilos](https://apify.com/boxbox10) (community)
- **Categories:** AI, Developer tools, 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 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/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 Extractor — RSS/Atom → Clean JSON + Markdown for LLM & RAG

**Point it at any RSS or Atom feed. Get back one clean, LLM-ready record per item.** Title, link, author, publish date, summary, categories, and the full item content as clean Markdown — no HTML soup, no boilerplate. Built for content monitoring, news aggregation, and RAG pipelines that need the *content* of a feed, not raw XML.

> Turn the firehose of RSS/Atom into structured, embed-ready Markdown — one tidy JSON record per article.

---

### ✨ What it does

- **Universal feed parsing** — RSS 2.0, RSS 1.0, and Atom, including `content:encoded`, `dc:creator`, and media fields.
- **One record per item** — each article in each feed becomes its own structured result.
- **HTML → Markdown** — high-fidelity conversion (GitHub-Flavored Markdown: tables, code blocks, lists, links) via Turndown, cleaned and collapsed.
- **Structured JSON** — `feedTitle`, `feedUrl`, `title`, `link`, `author`, `publishedAt`, `summary`, `categories[]`, `contentMarkdown`.
- **Optional full-text fetch** — flip `fullTextFetch: true` to fetch each item's link and extract the full article body with Mozilla Readability (great when feeds only ship a teaser).
- **Robust by design** — one bad feed never kills the run. Feeds that fail to fetch/parse return a clean error record in a separate dataset (and are **never charged**).
- **Polite** — sends a real descriptive User-Agent and sensible timeouts.

---

### 🎯 Use cases

| You want to… | This Actor gives you… |
|---|---|
| **Monitor content / competitors** | Structured, deduped item records you can diff and alert on. |
| **Aggregate news** | Many feeds → one uniform JSON shape, ready for a dashboard or DB. |
| **Build RAG over feeds** | Clean Markdown per article, ready to chunk and embed. |
| **Give an AI agent fresh context** | Latest items as JSON your agent can reason over — no XML parsing. |
| **Archive a feed** | Portable, diff-friendly Markdown + metadata per item. |

---

### 📥 Input

| Field | Type | Default | Description |
|---|---|---|---|
| `feedUrls` | string[] | — **(required)** | One or more RSS/Atom feed URLs. Each successful item is one result. |
| `maxItems` | integer | `100` | Max items extracted per feed (as ordered by the feed). |
| `fullTextFetch` | boolean | `false` | Also fetch each item's link and extract the full article body to Markdown (higher cost). |

#### Example input

```json
{
  "feedUrls": [
    "https://hnrss.org/frontpage",
    "https://www.theverge.com/rss/index.xml"
  ],
  "maxItems": 100,
  "fullTextFetch": false
}
````

***

### 📤 Output

One dataset item per feed item. Successful example:

```json
{
  "feedTitle": "The Verge",
  "feedUrl": "https://www.theverge.com/rss/index.xml",
  "title": "Some article headline",
  "link": "https://www.theverge.com/2026/...",
  "author": "Jane Doe",
  "publishedAt": "2026-07-18T14:03:00.000Z",
  "summary": "A one-paragraph plain-text teaser of the article...",
  "contentMarkdown": "Full item content converted to clean Markdown...\n\n[Read more](https://...)",
  "categories": ["Tech", "AI"],
  "fullTextFetched": false,
  "fetchedAt": "2026-07-18T15:20:11.954Z"
}
```

Failed feed (returned in a **separate `failures` dataset**, **not charged**):

```json
{
  "feedUrl": "https://not-a-real-domain-xyz.com/feed.xml",
  "error": "getaddrinfo ENOTFOUND not-a-real-domain-xyz.com",
  "fetchedAt": "2026-07-18T15:20:10.831Z"
}
```

***

### 🔌 Call it from code (Apify API)

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~rss-feed-extractor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"feedUrls":["https://hnrss.org/frontpage"]}'
```

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const { defaultDatasetId } = await client
    .actor('YOUR_USERNAME/rss-feed-extractor')
    .call({ feedUrls: ['https://hnrss.org/frontpage'] });
const { items } = await client.dataset(defaultDatasetId).listItems();
console.log(items[0].title, items[0].contentMarkdown);
```

***

### 💸 Pricing (Pay-Per-Event)

| Event | Price |
|---|---|
| Actor start | **$0.05** per run |
| Extracted feed item | **$0.002** per successfully extracted item |

- **You only pay for items that succeed** — feeds that fail to fetch/parse are never charged.
- **🎁 Free tier:** free-plan users' platform usage is covered by Apify, so you can try it and run small jobs at **no cost** before scaling up.
- Clean structured JSON + per-item Markdown, at a low per-item price — ideal for high-volume monitoring and RAG ingestion.

***

### ⚖️ Acceptable use

This is a general-purpose feed-conversion tool: **you supply the feed URLs and are responsible for having the right to fetch and use the content you submit.** It identifies itself with a descriptive User-Agent, does not target any single platform's private API, and does not harvest personal data as a feature. Please fetch responsibly and comply with each source's terms of service and applicable law.

***

### 🧱 Under the hood

Node.js · [rss-parser](https://github.com/rbren/rss-parser) · [@mozilla/readability](https://github.com/mozilla/readability) · [Turndown](https://github.com/mixmark-io/turndown) (+ GFM) · [jsdom](https://github.com/jsdom/jsdom) · Apify SDK. Stateless — nothing is stored between runs.

# Actor input Schema

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

One or more RSS or Atom feed URLs. Each successfully parsed feed item is one billable result.

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

Safety cap on how many items are extracted from each feed (newest first, as ordered by the feed).

## `fullTextFetch` (type: `boolean`):

When on, also fetch each item's link and extract the full article body to Markdown (Readability). When off, use the content already in the feed. Higher compute + network cost.

## Actor input object example

```json
{
  "feedUrls": [
    "https://hnrss.org/frontpage"
  ],
  "maxItems": 100,
  "fullTextFetch": false
}
```

# 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://hnrss.org/frontpage",
        "https://www.theverge.com/rss/index.xml"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("boxbox10/rss-feed-extractor").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://hnrss.org/frontpage",
        "https://www.theverge.com/rss/index.xml",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("boxbox10/rss-feed-extractor").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://hnrss.org/frontpage",
    "https://www.theverge.com/rss/index.xml"
  ]
}' |
apify call boxbox10/rss-feed-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RSS Feed Extractor: RSS/Atom → Clean JSON + Markdown",
        "description": "Turn any RSS or Atom feed into clean, LLM-ready Markdown + structured JSON — one record per feed item (title, link, author, publishedAt, summary, categories, clean contentMarkdown). Optional full-text fetch. Perfect for content monitoring, news aggregation, and RAG over feeds.",
        "version": "0.1",
        "x-build-id": "kG00DRcejo2eX4epv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/boxbox10~rss-feed-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-boxbox10-rss-feed-extractor",
                "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/boxbox10~rss-feed-extractor/runs": {
            "post": {
                "operationId": "runs-sync-boxbox10-rss-feed-extractor",
                "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/boxbox10~rss-feed-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-boxbox10-rss-feed-extractor",
                "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 URLs",
                        "type": "array",
                        "description": "One or more RSS or Atom feed URLs. Each successfully parsed feed item is one billable result.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items per feed",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Safety cap on how many items are extracted from each feed (newest first, as ordered by the feed).",
                        "default": 100
                    },
                    "fullTextFetch": {
                        "title": "Fetch full article text",
                        "type": "boolean",
                        "description": "When on, also fetch each item's link and extract the full article body to Markdown (Readability). When off, use the content already in the feed. Higher compute + network cost.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```