# RSS, Atom & JSON Feed Reader (`amcbstudio/rss-atom-json-feed-reader`) Actor

Parse public RSS, Atom, RDF/RSS, and JSON Feed URLs into a bounded, stable JSON contract for apps and AI agents.

- **URL**: https://apify.com/amcbstudio/rss-atom-json-feed-reader.md
- **Developed by:** [AMCB Studio](https://apify.com/amcbstudio) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 feed parseds

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?

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Parse public RSS, Atom, RDF/RSS, and JSON Feed URLs into a predictable, bounded dataset for apps, automations, and AI agents.

### What this Actor does

- Accepts 1–100 public feed URLs in one run.
- Detects RSS 2.0, RSS 1.0/RDF, Atom 1.0, and JSON Feed 1.0/1.1.
- Normalizes common item fields without inventing missing values.
- Preserves input order while fetching feeds concurrently.
- Writes one success or error summary for every requested feed.
- Isolates feed-level errors so one bad source does not discard the rest of the batch.

Common uses include scheduled news, blog, podcast, and release monitoring; RSS-to-JSON normalization for n8n, Make, or Zapier; bounded source ingestion for AI/RAG workflows; and diagnosing malformed feeds.

### Input

```json
{
  "feedUrls": [
    "https://www.w3.org/blog/news/feed/",
    "https://hnrss.org/frontpage"
  ],
  "maxItemsPerFeed": 50,
  "includeContent": true,
  "minimumPublishedAt": "2026-01-01T00:00:00Z"
}
```

| Field | Type | Default | Purpose |
| --- | --- | --- | --- |
| `feedUrls` | string array | required | 1–100 public HTTP/HTTPS feed URLs |
| `maxItemsPerFeed` | integer | `100` | Maximum items returned after filtering |
| `includeContent` | boolean | `true` | Include full content supplied inside the feed |
| `minimumPublishedAt` | ISO 8601 string | none | Keep items on or after this date; undated items remain with a warning |
| `timeoutSeconds` | integer | `20` | Per-request timeout, from 1 to 30 seconds |
| `maxRedirects` | integer | `5` | Maximum redirects, from 0 to 10 |
| `maxResponseBytes` | integer | `2000000` | Maximum response body per feed |
| `maxConcurrency` | integer | `4` | Concurrent requests, from 1 to 10 |

### Output

Each normalized item is followed by one summary for its feed. Missing source fields are `null`; the Actor does not fabricate titles, authors, dates, or content.

Item example:

```json
{
  "recordType": "feed_item",
  "schemaVersion": "1.0",
  "status": "ok",
  "feedIndex": 0,
  "itemIndex": 0,
  "feedFormat": "rss2",
  "feedTitle": "Example updates",
  "id": "release-42",
  "url": "https://example.com/releases/42",
  "title": "Release 42",
  "publishedAt": "2026-08-25T12:30:00Z"
}
```

Summary example:

```json
{
  "recordType": "feed_summary",
  "schemaVersion": "1.0",
  "status": "ok",
  "feedIndex": 0,
  "requestedUrl": "https://example.com/feed.xml",
  "feedFormat": "rss2",
  "itemsSeen": 20,
  "itemsEmitted": 20,
  "itemsFiltered": 0,
  "warnings": []
}
```

### Pricing

- Actor start: **US$0.00005** once per run.
- Feed parsed: **US$0.002** for each successfully parsed feed, including all emitted item and summary records.
- A failed feed has no `feed-parsed` charge.
- Platform usage is included in the event price.
- There is no per-dataset-row charge.

The Actor checks the run spending limit before making network requests and reduces the batch when the remaining limit cannot cover every requested feed.

### API and agent use

Run the Actor from Apify Console, REST API, schedules, tasks, or webhooks. After publication under eligible pay-per-event settings, Apify can also expose it to MCP clients. For larger batches, prefer an asynchronous run plus webhook or dataset retrieval instead of keeping a synchronous request open.

### Safety and privacy

- Public HTTP and HTTPS feeds on standard ports only.
- No credentials, authentication, cookies, browser, proxy, or JavaScript execution.
- Localhost, private, link-local, reserved, and cloud-metadata destinations are blocked.
- DNS is pinned for each connection; every redirect destination is resolved and checked again.
- Response size, redirects, timeout, concurrency, feed count, and item count are bounded.
- DTD and XML entity declarations are rejected.

Use only feeds you own or are authorized to access.

### Limitations

This Actor does not crawl linked articles, render JavaScript, bypass access controls, discover feed URLs from websites, persist cross-run deduplication state, or read authenticated feeds and custom ports.

### Troubleshooting

- `UNSAFE_URL`: the destination, redirect, port, credentials, or a DNS answer violates the public-network boundary.
- `HTTP_STATUS`: the source returned a non-success HTTP status.
- `RESPONSE_TOO_LARGE`: lower the source payload or keep the 2 MB safety ceiling.
- `INVALID_FEED`: the response is not a supported, parseable feed.
- Missing content: some feeds publish only a title, summary, or link. The Actor returns `null` rather than crawling the article.

Failed feeds still produce a visible error summary and are not charged as `feed-parsed` events.

# Actor input Schema

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

RSS 2.0, RSS 1.0/RDF, Atom 1.0, or JSON Feed 1.x URLs.

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

Return at most this many items after date filtering.

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

Include content:encoded, Atom content, or JSON Feed content fields when supplied by the feed.

## `minimumPublishedAt` (type: `string`):

Optional ISO 8601 cutoff. Items without a valid date are retained and reported in warnings.

## `timeoutSeconds` (type: `integer`):

Network timeout for each feed request.

## `maxRedirects` (type: `integer`):

Each redirect destination is resolved and safety-checked again.

## `maxResponseBytes` (type: `integer`):

Maximum response body size for one feed.

## `maxConcurrency` (type: `integer`):

Maximum simultaneous public feed requests.

## Actor input object example

```json
{
  "feedUrls": [
    "https://www.w3.org/blog/news/feed/",
    "https://hnrss.org/frontpage"
  ],
  "maxItemsPerFeed": 100,
  "includeContent": true,
  "minimumPublishedAt": "2026-01-01T00:00:00Z",
  "timeoutSeconds": 20,
  "maxRedirects": 5,
  "maxResponseBytes": 2000000,
  "maxConcurrency": 4
}
```

# Actor output Schema

## `results` (type: `string`):

Normalized feed items and feed-level summaries in the default dataset.

# 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://www.w3.org/blog/news/feed/",
        "https://hnrss.org/frontpage"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("amcbstudio/rss-atom-json-feed-reader").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://www.w3.org/blog/news/feed/",
        "https://hnrss.org/frontpage",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("amcbstudio/rss-atom-json-feed-reader").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://www.w3.org/blog/news/feed/",
    "https://hnrss.org/frontpage"
  ]
}' |
apify call amcbstudio/rss-atom-json-feed-reader --silent --output-dataset

```

## MCP server setup

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

```

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/u84PXvZcHPma4R9iH/builds/yWJHecdMwYy1saeos/openapi.json