<!-- BusyBot node reference — https://busybot.net/tools/rss-feed-read/ -->

> Node: RSS Feed Read (`rss_feed_read`) · Action · v1
> Category: Core Nodes · Credentials: none
> Updated: 2026-08-16

# RSS Feed Read

> Reads and parses RSS/Atom feeds from a URL.

## Overview

The RSS Feed Read tool fetches an RSS or Atom feed from a given URL and parses it into structured JSON items. Each feed item (article, post, episode, etc.) becomes a separate output item with fields like title, link, pubDate, content, contentSnippet, creator, guid, and isoDate. Supports custom field extraction from non-standard feed elements. No authentication is required for public feeds. Uses the rss-parser npm package internally.

**Category:** Core Nodes  
**Tool Name:** `rss_feed_read`  
**Version:** 1

**Appearance:** Icon: `lucide-Rss` | Color: `#ff6600`

## Node Type

**Action** — processes input items and produces output

## Input / Output

| Direction | Port(s) |
|-----------|--------|
| Input | `Input` |
| Output | `Output`, `Error` |

## Credentials

This tool does not require any credentials.

### Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| URL | `string` | Yes | — | URL of the RSS or Atom feed to read. Supports expressions like {{ $json.feedUrl }}. |
| Options | `collection` | No | `{}` | Extra parsing settings. |
| — Custom Fields | `string` | No | — | A comma-separated list of custom XML element names to extract from each feed item. For example, "author, contentSnippet, myCustomTag". |
| — Ignore SSL Issues (Insecure) | `boolean` | No | `false` | Whether to ignore SSL/TLS certificate validation errors. Useful for self-signed certificates. |
| Max Concurrency | `number` | No | `10` | Maximum number of input items to process concurrently. |

## Output Data

This node fans out: **one output item per feed entry**. A single input item pointing at a feed with 40 articles produces 40 output items. A feed with no entries produces none, and that is not an error. Binary data from the input item is forwarded onto every output item.

Each output item's JSON is the parsed feed entry itself — the input item's own JSON is not merged in. The exact fields depend on what the feed publishes; common ones are:

```json
{
  "title": "Release 4.2 is out",
  "link": "https://blog.example.com/release-4-2",
  "pubDate": "Mon, 04 Aug 2026 09:15:00 GMT",
  "isoDate": "2026-08-04T09:15:00.000Z",
  "creator": "Dana Whitfield",
  "guid": "https://blog.example.com/release-4-2",
  "content": "<p>Full HTML body of the entry…</p>",
  "contentSnippet": "Full plain-text body of the entry…"
}
```

- `content` holds the entry's HTML; `contentSnippet` holds the same text with the markup stripped.
- `isoDate` is the normalized timestamp — prefer it over `pubDate` for sorting and comparisons, since `pubDate` is whatever string the publisher wrote.
- Any element named in **Custom Fields** is added as a field of the same name, which is how you reach elements the RSS and Atom specs do not define.

Reference an entry downstream by expression, e.g. `{{ $json.title }}`.

## Usage Examples

- Read the latest posts from a blog RSS feed
- Parse an Atom feed to extract article titles and links
- Monitor a news feed for new items
- Extract custom fields from a podcast RSS feed

## Example Configuration

Read a public feed:

```json
{
  "type": "rss_feed_read",
  "parameters": {
    "url": "https://feeds.bbci.co.uk/news/rss.xml"
  }
}
```

Pull extra elements out of each entry:

```json
{
  "type": "rss_feed_read",
  "parameters": {
    "url": "https://example.com/blog/feed.xml",
    "options": {
      "customFields": "author, contentSnippet, category",
      "ignoreSSL": false
    }
  }
}
```

Read an internal feed served with a self-signed certificate:

```json
{
  "type": "rss_feed_read",
  "parameters": {
    "url": "https://internal.company.example/news/feed.rss",
    "maxConcurrency": 5,
    "options": {
      "ignoreSSL": true,
      "customFields": "department, priority"
    }
  }
}
```

Read a feed whose URL comes from an upstream item:

```json
{
  "type": "rss_feed_read",
  "parameters": {
    "url": "{{ $json.feedUrl }}",
    "maxConcurrency": 15,
    "options": {
      "customFields": "category, pubDate, guid"
    }
  }
}
```

Read a podcast feed:

```json
{
  "type": "rss_feed_read",
  "parameters": {
    "url": "https://podcast.example.com/feed/",
    "options": {
      "customFields": "author, contentSnippet, enclosure"
    }
  }
}
```

### Error Handling

| Mode | Behavior |
|------|----------|
| **stop** | Halts workflow on first error |
| **continue** | Skips failed items, passes successful ones through |
| **errorPort** | Routes failed items to Error output port |

## Tips

Fetches and parses an RSS or Atom feed URL into structured JSON items; use when you need to read blog posts, news articles, or podcast episodes from a feed.

### Key Usage Notes

1. **URL Format**: The `url` parameter must be a complete URL starting with `http://` or `https://`
2. **Custom Fields**: Use `customFields` to extract additional XML elements that aren't part of standard RSS/Atom specification
3. **SSL Certificates**: Set `ignoreSSL` to `true` only when dealing with self-signed or invalid certificates in trusted environments
4. **Concurrency**: Adjust `maxConcurrency` based on the feed server's capacity and your processing requirements
5. **Feed Types**: Supports RSS 2.0, RSS 1.0 (RDF), and Atom feeds automatically