# RSS & Atom Feed Health Checker (`zaden/my-actor-9`) Actor

Checks RSS and Atom feeds for validity, staleness, and broken item links. Fast, no browser needed. Need every check? See Full Site Health Suite for all 9 checks in one job.

- **URL**: https://apify.com/zaden/my-actor-9.md
- **Developed by:** [Zaden](https://apify.com/zaden) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.60 / 1,000 feed checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## RSS & Atom Feed Health Checker

Checks RSS and Atom feeds for validity, staleness, and broken item links -- no browser needed. Point it at one or more feed URLs and get back the feed format, item count, freshness, and a list of anything that looks broken -- plus a **letter grade**, a 0-100 health score, a severity tag, and a plain-English summary.

### What you get, per feed

- A **letter grade (A+ to F)** and 0-100 health score at a glance
- A one-line **executive summary** ("Newest item is 45 day(s) old -- past the 30-day stale threshold.")
- A **severity** tag -- `critical` (feed unreachable/invalid, empty, stale, or every sampled link is broken), `warning` (other issues), or `ok` -- for instant triage
- **Format detection**: RSS 2.0 or Atom, or a clear flag if the response isn't a valid feed at all
- **Freshness**: date of the newest item and days since it was published, with a configurable staleness threshold
- **Structural checks**: missing titles, missing publish dates, duplicate item IDs/GUIDs, missing channel-level link
- **Broken link sampling**: a configurable number of item links (and podcast enclosure URLs, if present) are checked live, concurrently, for a working response
- Feeds are checked **in parallel** (configurable), so a batch of 30 feeds finishes in a fraction of the time a one-by-one check would take

### Why this instead of checking manually

| | Manual spot-checks | RSS & Atom Feed Health Checker |
|---|---|---|
| Coverage | Whatever feed you remember to open | Every feed you list, automatically |
| Speed | Open each feed, scan dates and links | Seconds, via parallel checks and sampling |
| Triage | You read the raw XML yourself | Pre-classified severity + letter grade |
| Repeatability | Forgotten until a subscriber complains | One click, or schedule it |
| Output | Notes in a doc | Structured dataset, exportable to CSV/JSON/BI tools |

### Who this is for

- Publishers and bloggers verifying their feed still works after a CMS migration
- Podcasters checking that enclosure URLs in their RSS feed are still live
- Anyone building a feed reader or aggregator who wants to pre-filter broken or stale sources
- Agencies monitoring a client's content feed for freshness

### How to use it

1. Add one or more **feed URLs** (RSS or Atom).
2. Optionally adjust the **stale threshold** (days since last item), how many item/enclosure links to spot-check, and **concurrency**.
3. Run it once, or schedule it to catch a feed going stale or breaking after a deploy.

### Example output (one item)

```json
{
  "feedUrl": "https://hnrss.org/frontpage",
  "score": 100,
  "grade": "A+",
  "severity": "ok",
  "summary": "No issues found -- feed is healthy and up to date.",
  "found": true,
  "format": "RSS",
  "title": "Hacker News: Front Page",
  "itemCount": 30,
  "latestItemDate": "2026-08-22T00:00:00.000Z",
  "daysSinceLastUpdate": 0,
  "isStale": false,
  "linksSampled": 10,
  "brokenSampledLinks": [],
  "issueCount": 0,
  "issues": [],
  "checkedAt": "2026-08-22T00:00:00.000Z"
}
```

### Pricing

This Actor uses pay-per-event pricing:

- **Feed checked** -- charged once per feed URL processed.

Parallel checking doesn't cost more -- it just finishes faster.

### FAQ

**Does this work for podcast feeds?**
Yes. Podcast RSS feeds are standard RSS 2.0 with `<enclosure>` tags for the audio file -- those enclosure URLs are included in the link-sampling check.

**What counts as "stale"?**
A feed is flagged stale if the newest item's publish/updated date is older than your configured threshold (30 days by default). This is just a signal -- some feeds are legitimately low-frequency, so treat it as a prompt to double-check rather than a hard failure.

**What makes something "critical" vs. a "warning"?**
`critical` covers the failures that mean the feed isn't doing its job right now: unreachable or invalid, empty, past the stale threshold, or every sampled link broken. `warning` covers everything else that lowers the score -- worth fixing, but not breaking the feed.

**Does it crawl the whole site linked from the feed?**
No. It only fetches the feed XML itself and, optionally, does a lightweight live check (HEAD/GET) on a sample of the item and enclosure URLs listed inside it.

**Will higher concurrency get me rate-limited?**
It can, on servers with aggressive rate limiting, though each feed is often a different host so cross-feed concurrency is usually gentle. Start at the default (5) and lower it if you see timeouts spike.

# Actor input Schema

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

One or more RSS or Atom feed URLs to check.

## `staleDaysThreshold` (type: `integer`):

A feed is flagged as stale if its newest item is older than this many days.

## `maxItemsToSample` (type: `integer`):

How many item links (and podcast enclosure URLs, if present) to check live for a working response. Set to 0 to skip spot-checking. Checked concurrently within each feed.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for each HTTP request before giving up.

## `concurrency` (type: `integer`):

How many feeds to check in parallel. Higher values finish faster at the same cost; lower values are gentler if you're checking many feeds on the same host.

## Actor input object example

```json
{
  "feedUrls": [
    "https://hnrss.org/frontpage"
  ],
  "staleDaysThreshold": 30,
  "maxItemsToSample": 10,
  "requestTimeoutSecs": 15,
  "concurrency": 5
}
```

# Actor output Schema

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

Feed health findings for each checked 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://hnrss.org/frontpage"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zaden/my-actor-9").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"] }

# Run the Actor and wait for it to finish
run = client.actor("zaden/my-actor-9").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://hnrss.org/frontpage"
  ]
}' |
apify call zaden/my-actor-9 --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zaden/my-actor-9"
        }
    }
}

```

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/8pfxpJja2X5s6TFjW/builds/9lrXrU6Z225To07Ix/openapi.json