# Reddit Subreddit Posts & RSS Feed Monitor (`johnatan029/reddit-feed-monitor`) Actor

Extract recent posts from any public subreddit through Reddit RSS. Get post IDs, titles, authors, timestamps, URLs, permalinks, and thumbnails with no Reddit account, OAuth, API token, cookies, or browser. Supports new, hot, and top feeds with up to 1,000 posts per run.

- **URL**: https://apify.com/johnatan029/reddit-feed-monitor.md
- **Developed by:** [Johnn Mottin](https://apify.com/johnatan029) (community)
- **Categories:** Developer tools, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 87.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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/platform/actors/running/actors-in-store#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

## Reddit Subreddit Posts & RSS Feed Monitor

### Extract public subreddit posts through Reddit RSS

Collect structured post records from any public subreddit using Reddit's public RSS feeds.

The Actor reads feeds such as:

```text
https://www.reddit.com/r/<subreddit>/<sort>/.rss
```

and returns structured records with fields such as:

- Reddit post ID;
- fullname;
- title;
- author;
- subreddit;
- creation timestamp;
- update timestamp;
- destination URL;
- Reddit permalink;
- thumbnail when available;
- scrape timestamp.

No Reddit account. No OAuth. No API token. No authenticated cookies. No browser automation.

#### Key features

- **Public subreddit RSS feeds**
- **`new`, `hot`, and `top` sorting**
- **Up to 1,000 posts per run**
- **Post IDs and fullnames**
- **Titles and authors**
- **Creation and update timestamps**
- **Destination URLs**
- **Reddit permalinks**
- **Thumbnails when available**
- **Automatic feed pagination**
- **Datacenter or residential proxy options**
- **Run health checks**
- **Structured JSON-ready output**
- **Apify Schedules and integrations**
- **Pay per post record written**

> **Unofficial community Actor. Not affiliated with, sponsored by, or endorsed by Reddit, Inc.** Data comes from public Reddit RSS feeds and remains subject to Reddit's applicable terms and policies.

***

### What this Actor is for

This is a lightweight Reddit post-feed extractor.

Use it when you need a structured stream of recent public subreddit posts without maintaining Reddit API authentication or a browser scraper.

Typical use cases include:

- subreddit monitoring;
- community research;
- niche research;
- content discovery;
- brand-community observation;
- trend research;
- research datasets;
- Slack or webhook feeds;
- n8n, Make, and Zapier workflows;
- scheduled subreddit collection.

***

### Important: this is a feed monitor, not a keyword-search engine

The current Actor input selects:

```text
one subreddit
one sort order
one maximum post count
```

It does **not** currently provide a keyword filter or Reddit-wide search.

If you want to watch a brand, product, topic, or keyword, use one of these approaches downstream:

1. monitor a subreddit relevant to the topic;
2. send the returned posts into your workflow;
3. filter `title`, `author`, URLs, or other returned fields in n8n, Make, your database, or application.

The Actor itself does not claim to search all of Reddit for a keyword.

***

### Important: scheduled runs are snapshots of the current feed

The Actor does not maintain a persistent "already seen" state between runs.

A scheduled run reads the current RSS listing again.

That means the same post can appear in multiple scheduled datasets while it remains in the feed.

For true new-post alerting, deduplicate downstream using a stable field such as:

```text
id
fullname
permalink
```

This is especially important when scheduling the Actor every 15–60 minutes.

***

### Who it's for

#### Community and brand teams

Monitor public subreddits where your users or customers are active.

Send each run into:

- Slack;
- Google Sheets;
- a webhook;
- a CRM;
- an internal community dashboard.

For brand-name or keyword alerting, apply the text filter downstream.

#### Market and niche researchers

Collect structured post metadata from communities relevant to:

- products;
- industries;
- hobbies;
- consumer interests;
- games;
- technology;
- finance;
- local communities.

#### Automation builders

Use the clean post records as input for:

- n8n;
- Make;
- Zapier;
- webhooks;
- databases;
- internal pipelines.

#### Data teams

Use Reddit RSS as a lightweight source when you need:

- post titles;
- authors;
- timestamps;
- links;
- stable Reddit identifiers.

If you need richer Reddit engagement or comment data, this Actor is intentionally not the right tool.

***

### Input

#### Example

```json
{
  "subreddit": "worldnews",
  "sort": "new",
  "maxPosts": 25,
  "proxyMode": "datacenter"
}
```

#### Input fields

| Field | Default | Description |
|---|---|---|
| `subreddit` | required | Subreddit name without the `r/` prefix. |
| `sort` | `new` | `new`, `hot`, or `top`. |
| `maxPosts` | `100` | Maximum post records to write. Accepted range: 1–1000. |
| `proxyMode` | `datacenter` | `datacenter`, `residential`, or `none`. |
| `debug` | `false` | Enables extra logs and stores the raw first feed page. |

***

### Example: newest posts

```json
{
  "subreddit": "technology",
  "sort": "new",
  "maxPosts": 100,
  "proxyMode": "datacenter"
}
```

***

### Example: hot posts

```json
{
  "subreddit": "gaming",
  "sort": "hot",
  "maxPosts": 100,
  "proxyMode": "datacenter"
}
```

***

### Example: top feed

```json
{
  "subreddit": "worldnews",
  "sort": "top",
  "maxPosts": 100,
  "proxyMode": "datacenter"
}
```

The `top` RSS listing may expose fewer posts than `new` or `hot`.

***

### Output

The Actor writes one dataset record per post.

#### Example output

```json
{
  "recordType": "post",
  "id": "1v9mg4i",
  "fullname": "t3_1v9mg4i",
  "title": "Pakistan's situation (The rawalkot Kashmir protests)",
  "subreddit": "worldnews",
  "author": "SlayJarr",
  "createdAt": "2026-07-29T05:10:19.000Z",
  "updatedAt": "2026-07-29T05:10:19.000Z",
  "url": "https://www.arabnews.pk/node/2652489/pakistan",
  "permalink": "https://www.reddit.com/r/worldnews/comments/1v9mg4i/pakistans_situation_the_rawalkot_kashmir_protests/",
  "thumbnail": "https://external-preview.redd.it/2KRZdOWsqqGtn33zqS-MARsXy16fRaV7aWMoVQY_XhU.jpeg?width=640&crop=smart&auto=webp&s=634b613cb0cb9aa160bcf4a6f155106ec5e65972",
  "scrapedAt": "2026-07-29T05:13:41.574Z"
}
```

***

### Output fields

| Field | Description |
|---|---|
| `recordType` | Record type. Post rows use `post`. |
| `id` | Reddit post ID, for example `abc123`. |
| `fullname` | Reddit fullname, for example `t3_abc123`. |
| `title` | Post title. |
| `author` | Username without the `/u/` prefix. Can be `null` for deleted/unavailable authors. |
| `subreddit` | Subreddit name. |
| `createdAt` | ISO 8601 post creation timestamp. |
| `updatedAt` | ISO 8601 update timestamp from the feed. |
| `url` | Destination URL carried by the feed. For self-posts this can point to the Reddit post. |
| `permalink` | Reddit comments-page permalink. |
| `thumbnail` | Thumbnail URL when the feed provides one. |
| `scrapedAt` | ISO 8601 timestamp for the Actor run. |

***

### What this Actor intentionally does not return

The public RSS source used by this implementation does not provide all Reddit post fields.

The Actor intentionally does **not** invent unsupported values.

This version does not return:

```text
score
upvotes
commentsCount
raw selftext
comments
NSFW flag
domain
flair
```

#### No scores or upvotes

RSS does not provide reliable score/upvote data for this Actor's output contract.

#### No comment counts

The feed used by the Actor does not provide the comment-count field required by this implementation.

#### No raw post body

The RSS feed can carry HTML preview content, but the Actor does not expose that as raw Reddit `selftext`.

#### No comments

This Actor monitors post feeds only.

It does not crawl comment threads.

If your workflow requires engagement metrics, full post bodies, or comments, use a richer Reddit scraping tool instead.

***

### Feed limits

The Actor automatically pages through the supported feed listing.

The implementation accepts:

```text
maxPosts: 1–1000
```

Reddit's listing can stop before the requested maximum.

A run can therefore legitimately return fewer posts than `maxPosts`.

That condition is reported through:

```text
STATS
```

rather than being treated automatically as a failure.

***

### Proxy behavior

The input supports:

```text
datacenter
residential
none
```

#### Datacenter

Default:

```json
{
  "proxyMode": "datacenter"
}
```

This is the recommended starting point for the current implementation.

#### Residential

Use:

```json
{
  "proxyMode": "residential"
}
```

as an alternative when your environment requires it.

#### None

Use:

```json
{
  "proxyMode": "none"
}
```

only when you intentionally want direct requests.

The current Actor documentation notes that direct requests are commonly blocked in its operating environment.

***

### Scheduling

Reddit feeds are rolling listings, so scheduling is useful when you want recurring collection.

For active subreddits, a cadence such as:

```text
15–60 minutes
```

can be appropriate.

#### Important deduplication note

Because this Actor does not maintain persistent seen-post state, repeated scheduled runs can contain the same posts.

Your downstream workflow should deduplicate by:

```text
id
```

or:

```text
fullname
```

or:

```text
permalink
```

before generating "new post" alerts.

***

### Recommended scheduled workflow

1. Save the subreddit configuration as an Apify **Task**.
2. Go to **Console → Schedules → Create schedule**.
3. Add the Task.
4. Choose the desired cadence.
5. Route the dataset to your downstream workflow.
6. Deduplicate by post ID/permalink.
7. Apply optional keyword or brand filters.
8. Trigger the final alert or storage action.

Possible destinations:

- Slack;
- Google Sheets;
- n8n;
- Make;
- Zapier;
- databases;
- webhooks;
- internal dashboards.

***

### Example brand-monitoring workflow

Suppose you want to monitor mentions of:

```text
ExampleBrand
```

inside:

```text
r/SomeIndustry
```

Run the Actor with:

```json
{
  "subreddit": "SomeIndustry",
  "sort": "new",
  "maxPosts": 100,
  "proxyMode": "datacenter"
}
```

Then downstream:

1. deduplicate by `id`;
2. check whether `title` contains `ExampleBrand`;
3. send matching posts to Slack or another alerting destination.

The keyword filter is performed downstream, not inside the current Actor.

***

### Run health

Every run writes operational information to:

```text
STATS
```

The statistics can include:

- pages processed;
- retries;
- duplicates removed within the run;
- field completeness;
- warnings.

The Actor is designed to fail explicitly rather than silently return structurally broken feed data.

***

### Health and error codes

#### `EMPTY_RESULTS`

Raised when the run produces no post records.

#### `DEAD_FIELDS`

Raised when an important field is missing in more than half of returned posts.

Watched fields include:

```text
title
author
url
createdAt
```

The error identifies the affected field.

#### `INVALID_XML_SHAPE`

Raised when the response is not the expected Atom/RSS structure.

For example, a blocking or unexpected HTML response should not be parsed as valid feed data.

#### HTTP-level errors

The Actor can report conditions such as:

```text
HTTP_BLOCKED
HTTP_RATE_LIMITED
SUBREDDIT_NOT_FOUND
HTTP_TIMEOUT
```

`429` and applicable `5xx` responses use controlled retry/backoff before final failure.

***

### Pricing

This Actor uses **Pay Per Event** pricing.

You are billed per post record written to the dataset, plus any run-start fee shown in the Actor's Pricing tab.

Use:

```text
maxPosts
```

to control the maximum number of posts written in a run.

The **Pricing** tab on the Actor page is always the authoritative source for current rates.

***

### Cost control

The primary output-cost control is:

```text
maxPosts
```

Examples:

```json
{
  "maxPosts": 25
}
```

or:

```json
{
  "maxPosts": 100
}
```

Higher values can require additional feed pages and source requests.

***

### Honest limits

#### One subreddit per run

The current input accepts a single:

```text
subreddit
```

per run.

For multiple subreddits, create multiple Tasks/runs or orchestrate them from a parent workflow.

#### No built-in keyword filtering

The current Actor does not filter titles by keyword.

Apply topic, brand, or keyword matching downstream.

#### No persistent seen-post state

Scheduled runs can return the same post more than once.

Use stable post identifiers for downstream deduplication.

#### RSS is not the full Reddit data model

This Actor deliberately exposes only the fields supported by its RSS-based contract.

It does not provide the richer metadata available through heavier Reddit data collectors.

#### Feed history is finite

`maxPosts` can be set up to 1,000, but the public listing may end before that number is reached.

#### Sort behavior differs

`top` may expose fewer posts than `new` or `hot`.

#### Public source behavior can change

Reddit can change feed responses, blocking behavior, or listing limits.

The Actor's health checks are intended to surface those changes.

***

### FAQ

#### Do I need a Reddit account?

No.

#### Do I need a Reddit API key?

No.

#### Does the Actor use OAuth?

No.

#### Does it use authenticated cookies?

No.

#### Does it use browser automation?

No.

#### Which sort modes are supported?

```text
new
hot
top
```

#### How many posts can I request?

Between:

```text
1
```

and:

```text
1000
```

per run.

The feed can legitimately end before the requested maximum.

#### Can I monitor multiple subreddits in one run?

Not in the current input contract.

The Actor accepts one subreddit per run.

#### Can I search Reddit by keyword?

Not in the current Actor version.

You can filter the returned posts downstream.

#### Can I use it for brand monitoring?

Yes, as part of a workflow.

Monitor relevant subreddits, deduplicate posts, then apply brand or keyword filtering downstream.

#### Does it return post scores?

No.

#### Does it return comment counts?

No.

#### Does it return comments?

No.

#### Does it return the full post body?

No.

#### Does it return thumbnails?

Yes, when the RSS feed supplies one.

#### What happens if the author was deleted?

`author` can be:

```text
null
```

#### Will scheduled runs return only posts that appeared since the previous run?

No.

The Actor reads the current feed each time and does not currently store a cross-run seen-post state.

Deduplicate downstream by `id`, `fullname`, or `permalink`.

#### What proxy mode should I use?

The current implementation defaults to:

```text
datacenter
```

Residential proxy is available as a fallback option.

#### What happens if Reddit returns a blocking page instead of XML?

The Actor can fail with:

```text
INVALID_XML_SHAPE
```

or another relevant controlled HTTP error instead of parsing the response as valid posts.

#### What am I charged for?

Post records written to the dataset according to the Actor's Pay Per Event configuration, plus any run-start fee shown in Pricing.

#### Can I schedule it?

Yes.

Use Apify Tasks and Schedules, and deduplicate repeated posts downstream.

#### Is this affiliated with Reddit?

No.

This is an unofficial community Actor and is not affiliated with, sponsored by, or endorsed by Reddit, Inc.

***

### Part of the JM Forge suite

Also from the same developer:

- [Steam Game Price, Discount & Review Monitor](https://apify.com/johnatan029/steam-game-data-monitor) — Monitor Steam app IDs for price changes, discounts, release-state changes, and review movement.

- [Google, Bing & YouTube Keyword Suggest Scraper](https://apify.com/johnatan029/keyword-autocomplete-intelligence) — Expand seed keywords into structured long-tail autocomplete suggestions.

- [Shopify Price, Stock & Catalog Change Monitor](https://apify.com/johnatan029/shopify-price-catalog-monitor) — Monitor Shopify stores for price changes, restocks, sell-outs, new products, removed products, and new variants.

### Support

Report issues in the **Issues** tab of this actor — I respond within 24h. Feature requests welcome.

# Actor input Schema

## `subreddit` (type: `string`):

Subreddit name without the r/ prefix, for example "worldnews".

## `sort` (type: `string`):

How the subreddit feed is ordered.

## `maxPosts` (type: `integer`):

How many posts to collect. The feed returns 100 posts per page and Reddit stops a subreddit listing near 1000 posts, so runs may finish with fewer posts than requested.

## `proxyMode` (type: `string`):

Apify Proxy used to reach Reddit. Datacenter is the cheapest option and is enough for the RSS feed. Residential is a fallback. None sends the request directly and is normally blocked by Reddit.

## `debug` (type: `boolean`):

Log extra diagnostics and store the raw first feed page in the key-value store.

## Actor input object example

```json
{
  "subreddit": "worldnews",
  "sort": "new",
  "maxPosts": 25,
  "proxyMode": "datacenter",
  "debug": 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 = {
    "subreddit": "worldnews",
    "sort": "new",
    "maxPosts": 25,
    "proxyMode": "datacenter"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnatan029/reddit-feed-monitor").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 = {
    "subreddit": "worldnews",
    "sort": "new",
    "maxPosts": 25,
    "proxyMode": "datacenter",
}

# Run the Actor and wait for it to finish
run = client.actor("johnatan029/reddit-feed-monitor").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 '{
  "subreddit": "worldnews",
  "sort": "new",
  "maxPosts": 25,
  "proxyMode": "datacenter"
}' |
apify call johnatan029/reddit-feed-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,johnatan029/reddit-feed-monitor"
        }
    }
}

```

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/PQafuKuGeoKsdpiRa/builds/WBWEN5izohGa5stkd/openapi.json