# Reddit Keyword Monitor (`coregent/reddit-keyword-monitor`) Actor

Monitor Reddit for keywords, phrases and topics across all Reddit or selected subreddits. Track posts and comments, deduplicate matches, filter noise, and return only new results on scheduled runs. Export clean JSON, CSV or Excel. No Reddit login or API key.

- **URL**: https://apify.com/coregent/reddit-keyword-monitor.md
- **Developed by:** [Delowar Munna](https://apify.com/coregent) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 keyword matches

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Reddit Keyword Monitor

![Reddit Keyword Monitor](https://raw.githubusercontent.com/coregentdevspace/reddit-keyword-monitor-assets/main/thumbnail-reddit-keyword-monitor.png "Reddit Keyword Monitor — keywords and phrases in, one row per matching post or comment out, only new matches on every scheduled run")

Monitor Reddit for keywords, phrases and topics across all of Reddit or the subreddits you choose.
Track **posts and comments**, get **one row per match with every keyword it matched**, filter out
noise and bots, and — on a schedule — receive **only the new matches** on every run. No Reddit
login, API key or AI. Export clean JSON, CSV or Excel.

**Configure keywords → schedule the Actor → receive only new matches.**

### What it does

- Searches **all of Reddit or selected subreddits** for your keywords and exact phrases, within a
  time window (past hour to all time) or since a date.
- Checks **posts and comments**, including comments that mention your keyword under any post. A
  row is delivered only when your keyword actually appears in that post or comment — Reddit's search finds candidates, the Actor confirms the match.
- Returns **one row per post or comment**, with `matchedKeywords` listing every keyword it matched.
  Found by three keywords or three searches? Still one row, one charge.
- **Noise filters**: require words (any or all), exclude words, excluded authors, bot filtering.
- **Subreddit-only monitoring**: no keywords, just the newest posts (and comments) of a community.
- **Only-new monitoring** with a monitor key, and a **baseline-only first run** for professional
  setups: the first run records what exists today, later runs deliver only what is new.
- Run summary: posts and comments scanned, unique matches, new matches delivered, already-seen
  suppressed, duplicates merged, authors filtered.

### Quick start

Monitor two keywords across Reddit:

```json
{
  "keywords": ["openai", "chatgpt"],
  "sourceTypes": "BOTH",
  "sort": "NEW",
  "timeRange": "WEEK",
  "maxResults": 100
}
```

Restrict to subreddits:

```json
{
  "keywords": ["web scraping"],
  "subreddits": ["webscraping", "dataengineering"],
  "sourceTypes": "BOTH",
  "sort": "NEW",
  "timeRange": "MONTH"
}
```

Filter the noise out of an ambiguous keyword:

```json
{
  "keywords": ["apple"],
  "subreddits": ["technology"],
  "requireWords": ["iphone", "mac", "ios"],
  "requireMode": "ANY",
  "excludeWords": ["fruit", "recipe"]
}
```

Scheduled monitoring — run it daily and get only what is new:

```json
{
  "keywords": ["Claude Code", "Cursor"],
  "subreddits": ["programming", "LocalLLaMA"],
  "sourceTypes": "BOTH",
  "sort": "NEW",
  "maxAgeHours": 24,
  "onlyNew": true,
  "monitorKey": "coding-ai-tools"
}
```

Start a monitor from a clean baseline (the first run returns nothing and is not charged):

```json
{
  "keywords": ["example topic"],
  "onlyNew": true,
  "monitorKey": "example-topic-monitor",
  "baselineMode": "BASELINE_ONLY"
}
```

### FAQ

#### What can I monitor?

Any keyword, phrase or topic: product and company names, technologies, regulations, launches,
feature requests, error messages, events. Up to 100 keywords per run, across all of Reddit or a list
of subreddits.

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

No. The Actor reads public Reddit content only. No login, no API key, no cookies.

#### Can I search all of Reddit?

Yes — leave `subreddits` empty. Each keyword is one search across Reddit.

#### Can I restrict to subreddits?

Yes. `webscraping`, `r/webscraping` and `https://www.reddit.com/r/webscraping/` all work. Each
keyword is then searched in each listed subreddit.

#### Are comments supported?

Yes. With `sourceTypes` `COMMENTS` or `BOTH`, every keyword is also searched among Reddit's
comments (across all of Reddit or in your subreddits), so a comment that mentions your keyword is
found **under any post**, not only under posts that mention it. Each comment is matched on its own
full text and carries its parent post's title and URL in `parentPost`.

In subreddit-only monitoring (no keywords) there is nothing to search comments for, so the top
comments of each new post's thread are read instead (up to `maxCommentsPerPost`, replies included).

#### Can I monitor subreddit feeds without keywords?

Yes. Leave `keywords` empty and list subreddits: every new post in the time window (and, with
`BOTH` or `COMMENTS`, its comments) is delivered. Your require/exclude words and author filters still
apply.

#### How do exact phrases work?

Put a phrase in quotes: `"customer service"` matches those words in that order. Without quotes,
`pricing issue` matches when both words appear, in any order — the way Reddit's own search reads it.
A single word matches as a whole word with an optional plural (`CRM` matches "CRMs", not "CRMify").
The keyword is reported in `matchedKeywords` exactly as you typed it, quotes included.

#### How does only-new monitoring work?

Turn on `onlyNew` and give a `monitorKey` (for example `coding-ai-tools`). The Actor remembers every
post and comment it delivers under that key — its first-seen time, last-seen time and matched
keywords — and skips them on later runs. Runs with the same key share the memory; different keys
are independent. If you leave `monitorKey` empty, one is derived from your keywords and subreddits.
A match that was cut by `maxResults` or your spending limit is not remembered, so the next run can
still deliver it. An item already delivered is not delivered again even if it later matches another
keyword.

Once a run of a monitor has read all its searches and delivered everything it found, the next run
with the same settings stops each newest-first search at the first page of matches it already
delivered, so scheduled runs only read what is new. Change the keywords, subreddits, filters or time
window, or let a run be cut by `maxResults` or your spending limit, and the next run reads its whole
window again.

#### What is baseline-only mode?

With `onlyNew` on and `baselineMode` `BASELINE_ONLY`, the **first** run of a monitor records every
current match and delivers none (and is not charged). From the second run on you receive only what
appeared after you started monitoring:

```text
Run 1: discover 800 matches, store them, deliver 0
Run 2: discover 815 matches, deliver only the 15 new ones
```

#### How are duplicate keyword matches handled?

One post or comment is one row, whatever found it. If a post matches `openai`, `chatgpt` and
`ai tools`, you get one row with `"matchedKeywords": ["openai", "chatgpt", "ai tools"]` and one
charge. The same goes for a post found by a global search, a subreddit search and a feed.

#### Can I require or exclude words?

Yes. `requireWords` keeps an item only if it also contains one of them (`requireMode` `ANY`) or all
of them (`ALL`). `excludeWords` drops any item containing one of them.

#### Can I exclude bots or specific authors?

Yes. `skipBots` (on by default) drops AutoModerator and other well-known bot accounts, and text that
says it was posted automatically. It is deliberately conservative: a username is not treated as a bot
just because it contains "bot". `excludeAuthors` drops any usernames you list.

#### Why may scores, comment counts or text be null?

Different public Reddit sources expose different fields. When a value is not available it is `null`
— never a made-up zero. A hidden score is `null`. When a post's body cannot be read, `text` is
`null`, `textAvailable` is `false`, and the match was confirmed by Reddit's search rather than in the
body (`matchBasis: "reddit-search"`); require/exclude words are then checked against the title.

#### Are search results exhaustive?

No. Reddit's search returns at most roughly 250 results per keyword, sort and time window, and only
public, non-deleted content. This Actor is built for **repeated scheduled monitoring**, not for
exhaustive historical coverage. To go deeper, narrow the time window or add subreddits.

#### How often should I schedule it?

Use an Apify schedule:

| Cadence | Good for | Suggested settings |
|---|---|---|
| Hourly | Fast-moving alerts | `maxAgeHours: 2`, `onlyNew: true` |
| Daily | Normal monitoring | `maxAgeHours: 24` or `timeRange: DAY`, `onlyNew: true` |
| Weekly | Research | `timeRange: WEEK`, `onlyNew: true` |

A small overlap between the window and the schedule is fine — only-new monitoring removes repeats.

#### How does pricing work?

Pay per result: you are charged once per **unique post or comment delivered**. Search requests,
retries, non-matches, duplicates, filtered items, items already delivered to your monitor, a
baseline-only first run, results beyond `maxResults` and failed searches are never charged. Results
are delivered newest first, so a spending limit keeps the freshest matches. See the **Pricing** tab
for the current rate — this README deliberately does not quote figures.

#### Can I use the API / MCP?

Yes. Run it like any Apify Actor through the API, the JavaScript/Python clients, integrations
(Make, Zapier, n8n, webhooks for alerts) or Apify's MCP server, and read the dataset views below.

### Input reference

| Field | Default | Description |
|---|---|---|
| `keywords` | `["web scraping"]` | Up to 100. `"quoted"` = exact phrase. Empty + subreddits = subreddit-only monitoring |
| `subreddits` | `[]` | Names, `r/name` or URLs. Empty = all of Reddit |
| `sourceTypes` | `BOTH` | `POSTS`, `COMMENTS`, `BOTH` |
| `sort` | `NEW` | `NEW`, `RELEVANCE`, `TOP`, `COMMENTS`, `HOT` |
| `timeRange` | `WEEK` | `HOUR`, `DAY`, `WEEK`, `MONTH`, `YEAR`, `ALL` |
| `postedAfter` | — | ISO date or date-time, e.g. `2026-10-14T00:00:00Z`. Wins over `maxAgeHours` and `timeRange` |
| `maxAgeHours` | — | e.g. `6`, `24`, `72`. Wins over `timeRange` |
| `maxResults` | `100` | 1–10,000 delivered unique results per run, newest first |
| `maxCommentsPerPost` | `50` | 1–100 comments read per thread in subreddit-only monitoring |
| `onlyNew` | `false` | Skip what earlier runs of the same monitor delivered |
| `monitorKey` | — | Name of the monitor's memory. Alone (without `onlyNew`) it marks rows `isNew` without skipping |
| `baselineMode` | `RETURN_CURRENT` | `BASELINE_ONLY`: first run records, delivers nothing |
| `requireWords` / `requireMode` | `[]` / `ANY` | Also require these words (`ANY` / `ALL`) |
| `excludeWords` | `[]` | Drop items containing these |
| `excludeAuthors` | `[]` | Usernames to ignore |
| `skipBots` | `true` | Drop well-known bots |
| `maxConcurrency` | `3` | 1–5 searches/threads at once |
| `proxyConfiguration` | Apify Datacenter | See the proxy policy below |

An empty run (no keywords and no subreddits), an unparseable `postedAfter`, a non-positive limit or
an unknown option value stops the run with a clear message. One invalid keyword or subreddit does not:
it is skipped and reported in `SOURCE_SUMMARY`.

### Output

Every tab below shows every row: Apify dataset views choose **columns**, not rows, so the **Post columns**
tab also lists comments (with an empty title) and the **Comment columns** tab also lists posts. Filter on
`sourceType` (`POST` / `COMMENT`) in your export or integration to split them.

![Reddit Keyword Monitor — Post columns view, table (one row per match with subreddit, body, author, score, matched keywords, match basis, found by and first seen)](https://raw.githubusercontent.com/coregentdevspace/reddit-keyword-monitor-assets/main/reddit-keyword-monitor-output-posts-table-view.png "Reddit Keyword Monitor — Post columns view, table")

#### All matches tab

Posts and comments together, newest first. A post from a one-off run (no monitor, so `isNew` and
`firstSeenAt` are `null`):

```json
{
  "sourceType": "POST",
  "subreddit": "mcp",
  "title": "I built an MCP server for stealthy browser automation. This week it ranked #1 in Glama...",
  "text": "The MCP server I created: https://glama.ai/mcp/servers/seleniumbase/SeleniumBase is #1 this week for browser automation (https://glama.ai/mcp/best/browser-automation). It lets you automate browsers and do web-scraping while bypassing bot-detection. It includes a tool for handling CAPTCHAs.\n\nThe SeleniumBase MCP server files are located at https://github.com/seleniumbase/SeleniumBase/tree/master/mcp\\_servers, with the main GitHub page at https://github.com/seleniumbase/SeleniumBase.\n\nI also created a YouTube video about it: https://www.youtube.com/watch?v=wQI3hUO9qmA",
  "author.username": "example_user",
  "publishedAt": "2026-10-16T00:02:07.959Z",
  "score": 13,
  "commentsCount": 4,
  "matchedKeywords": [
    "web scraping"
  ],
  "isNew": null,
  "url": "https://www.reddit.com/r/mcp/comments/1x71lfp/i_built_an_mcp_server_for_stealthy_browser/",
  "parentPost.title": null,
  "firstSeenAt": null
}
```

#### Post columns tab

The same post with the post columns — its body was read and the keyword confirmed in it
(`matchBasis: "text"`):

```json
{
  "id": "t3_1x71lfp",
  "subreddit": "mcp",
  "title": "I built an MCP server for stealthy browser automation. This week it ranked #1 in Glama...",
  "text": "The MCP server I created: https://glama.ai/mcp/servers/seleniumbase/SeleniumBase is #1 this week for browser automation (https://glama.ai/mcp/best/browser-automation). It lets you automate browsers and do web-scraping while bypassing bot-detection. It includes a tool for handling CAPTCHAs.\n\nThe SeleniumBase MCP server files are located at https://github.com/seleniumbase/SeleniumBase/tree/master/mcp\\_servers, with the main GitHub page at https://github.com/seleniumbase/SeleniumBase.\n\nI also created a YouTube video about it: https://www.youtube.com/watch?v=wQI3hUO9qmA",
  "textAvailable": true,
  "author.username": "example_user",
  "publishedAt": "2026-10-16T00:02:07.959Z",
  "score": 13,
  "commentsCount": 4,
  "flair": null,
  "matchedKeywords": [
    "web scraping"
  ],
  "matchBasis": "text",
  "foundBy": [
    "web scraping"
  ],
  "isNew": null,
  "firstSeenAt": null,
  "url": "https://www.reddit.com/r/mcp/comments/1x71lfp/i_built_an_mcp_server_for_stealthy_browser/"
}
```

#### Comment columns tab

A comment from a scheduled monitor run, found by comment search under a post that does not name
the keyword. Comment search does not say whether a top-level comment's parent is the post, so
`parentId` is `null` here:

```json
{
  "id": "t1_pgxb0ju",
  "subreddit": "LocalLLaMA",
  "text": "as a researcher who runs dozens of experiments a week: naming files, folders, functions, etc. I'm fairly confident Claude code does a better job organizing my files than i ever did",
  "author.username": "another_user",
  "isSubmitter": null,
  "publishedAt": "2026-10-15T16:06:00.012Z",
  "score": 5,
  "matchedKeywords": [
    "Claude Code"
  ],
  "parentPost.title": "What’s the dumbest thing you trust your LLM with, but not yourself?",
  "parentPost.url": "https://www.reddit.com/r/LocalLLaMA/comments/1x6o34h/whats_the_dumbest_thing_you_trust_your_llm_with/",
  "parentId": null,
  "isNew": true,
  "firstSeenAt": "2026-10-16T19:21:02.503Z",
  "url": "https://www.reddit.com/r/LocalLLaMA/comments/1x6o34h/whats_the_dumbest_thing_you_trust_your_llm_with/pgxb0ju/"
}
```

#### All fields

Every field of a row — here a reply (`parentId` is the comment it answers):

```json
{
  "rowType": "reddit_match",
  "sourceType": "COMMENT",
  "id": "t1_pgqn6fg",
  "postId": "1x5uwnd",
  "commentId": "pgqn6fg",
  "parentId": "t1_pgqmvdo",
  "subreddit": "LocalLLaMA",
  "title": null,
  "text": "ohh... my pc has 32gbram and 8gb vram and i want to use for agentic coding OR using as sub-agent for Claude code, i hope i can find a good model fitting my pc.",
  "textAvailable": true,
  "author": {
    "username": "third_user",
    "profileUrl": "https://www.reddit.com/user/third_user/"
  },
  "url": "https://www.reddit.com/r/LocalLLaMA/comments/1x5uwnd/a_35b_multimodal_model_running_on_a_phone_with/pgqn6fg/",
  "parentPost": {
    "id": "t3_1x5uwnd",
    "title": "A 35B multimodal model running on a phone with ~3GB memory? MiniCPM-V 4.7 demo is pretty wild",
    "url": "https://www.reddit.com/r/LocalLLaMA/comments/1x5uwnd/a_35b_multimodal_model_running_on_a_phone_with/",
    "author": null
  },
  "publishedAt": "2026-10-14T18:19:46.904Z",
  "editedAt": null,
  "score": 2,
  "commentsCount": null,
  "flair": null,
  "isNsfw": false,
  "isSubmitter": null,
  "matchedKeywords": [
    "Claude Code"
  ],
  "matchBasis": "text",
  "foundBy": [
    "comments: Claude Code in r/LocalLLaMA"
  ],
  "isNew": true,
  "firstSeenAt": "2026-10-16T19:21:02.503Z",
  "scrapedAt": "2026-10-16T19:21:02.505Z",
  "capturedSequence": 11
}
```

Usernames in these samples are anonymised.

| Field | Meaning |
|---|---|
| `sourceType` | `POST` or `COMMENT` |
| `id` | Reddit fullname (`t3_…` post, `t1_…` comment) — the dedupe key together with `sourceType` |
| `parentId` | For a comment: the comment it replies to (`t1_…`) or the post (`t3_…`); `null` when Reddit's comment search does not say |
| `text`, `textAvailable` | Body text; `textAvailable: false` when the post body could not be read |
| `matchedKeywords` | Every keyword the item matched, as you typed it |
| `matchBasis` | `text` (found in the item's text), `reddit-search` (title-only post, matched by Reddit's search), `subreddit-feed` (no keywords) |
| `foundBy` | Which searches found it (`comments: …` = comment search) |
| `isNew`, `firstSeenAt` | Monitoring state; `null` when no monitor is used |
| `parentPost` | For a comment: the post's ID, title, URL and author (`author` is `null` when the comment came from comment search alone) |

#### Dataset views and run records

| View / record | What it shows |
|---|---|
| **All matches** | Every match, newest first, with the columns common to posts and comments |
| **Post columns** | Every match, with the post columns (body, flair, comment count, match basis, found by) |
| **Comment columns** | Every match, with the comment columns (parent post, parent ID, poster flag) |
| `RUN_SUMMARY` | Keywords, subreddits, search operations, posts and comments scanned, unique matches, new matches delivered, already-seen suppressed, duplicates merged, authors and bots filtered, drops by reason |
| `SOURCE_SUMMARY` | Each search's status: `SUCCESS`, `NO_RESULTS`, `INVALID_KEYWORD`, `INVALID_SUBREDDIT`, `SUBREDDIT_NOT_FOUND`, `RATE_LIMITED`, `BLOCKED`, `PARTIAL_RESULT`, `TEMPORARY_REDDIT_ERROR`, `PROVIDER_ERROR` |

One failed keyword or subreddit search never fails the run; it is reported there.

### Limitations

- **Search depth is bounded.** Reddit's search returns roughly 250 results per query, sort and time
  window. Repeated scheduling is the intended monitoring model.
- **Comment search depth is bounded too**, like post search, and only comments Reddit's search
  indexes are found. In subreddit-only monitoring, thread reading is capped per thread (the comments
  Reddit ranks first are read). Scheduling with only-new monitoring is how a monitor stays complete
  over time.
- **Comment search does not say** whether a top-level comment's parent is the post, or whether its
  author wrote the post: `parentId` and `isSubmitter` are then `null`, and `parentPost.author`
  is `null` unless the post was also found (a reply's parent comment is given). Comments read from a
  thread in subreddit-only monitoring carry all three.
- **Matching is literal, not topical**: a post that mentions your keyword in passing matches; a post
  about your topic that never uses the keyword does not. Use several keywords and require/exclude
  words to tune it.
- **Deleted, removed and private content is unavailable**, and public content may later be edited or
  deleted.
- **Long runs stop early to deliver.** Shortly before the run's timeout, collecting stops and the
  matches found so far are delivered (the status message says so). Results are delivered at the end
  of a run, so aborting a run part-way can leave it with none.

#### 🚦 Proxy policy

Use **Apify Datacenter** proxy (the default) or **no proxy** — both work for Reddit search and
comment pages at this Actor's conservative request rate.

**Apify Residential proxy is not supported.** The Actor fails at startup if `apifyProxyGroups`
includes `RESIDENTIAL`. Reason: on pay-per-result Actors residential bandwidth is billed to the
developer, not the run, and Reddit comment pages are large, while Reddit serves the same pages to
datacenter addresses.

If you genuinely need residential routing, supply your own provider through the proxy editor's
**Custom proxy URLs** field — that traffic goes through your provider, not Apify:

```
http://user:pass@proxy.iproyal.com:12321
http://user:pass@proxy.brightdata.com:22225
http://user:pass@proxy.oxylabs.io:7777
```

### Responsible use

This is an unofficial tool and is not affiliated with Reddit. It processes **public** posts and
comments only.

- Search coverage is bounded by Reddit's own search behaviour.
- Follow each subreddit's rules and Reddit's terms. Public content may later be deleted or edited.
- You are responsible for lawful downstream processing of the data.

The Actor never reads private messages, never asks for account credentials, never votes, replies or
sends messages, and never infers sensitive attributes about people.

### Related Actors

- [Reddit Posts & Search Scraper](https://apify.com/coregent/reddit-posts-search-scraper) — every post for a search or subreddit, with full post fields
- [Reddit Comments Scraper](https://apify.com/coregent/reddit-comments-scraper) — whole comment threads with parent, depth and path

### Changelog

- **1.0** — first release: keywords and exact phrases across Reddit or subreddits, subreddit-only
  monitoring, posts and comments, local keyword validation with matched-keyword attribution,
  require/exclude words, excluded authors, bot filtering, `postedAfter` / `maxAgeHours`, only-new
  monitoring with a monitor key, baseline-only first run.

# Actor input Schema

## `keywords` (type: `array`):

Words, phrases or topics to monitor, one per line (up to 100). Put a phrase in quotes for an exact match: "customer service". Without quotes, every word must appear (in any order). Leave empty and list subreddits below to monitor their newest posts instead.

## `subreddits` (type: `array`):

Restrict the search to these communities. webscraping, r/webscraping and https://www.reddit.com/r/webscraping/ all work. Leave empty to search all of Reddit. With no keywords, the newest posts of these subreddits are monitored.

## `sourceTypes` (type: `string`):

POSTS: matching posts only. COMMENTS: matching comments, found by Reddit's comment search under any post (in subreddit-only monitoring: the comments of each new post's thread). BOTH: posts and comments.

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

Reddit's search ordering. NEW is right for monitoring; RELEVANCE and TOP find the strongest matches across the whole window. Subreddit-only monitoring always reads the newest posts.

## `timeRange` (type: `string`):

Only posts and comments from this window.

## `postedAfter` (type: `string`):

Only posts and comments published after this date or time, e.g. 2026-10-14 or 2026-10-14T00:00:00Z. Takes precedence over Posted within and Max age.

## `maxAgeHours` (type: `integer`):

Only posts and comments at most this many hours old, e.g. 6, 24 or 72. Handy for scheduled runs. Takes precedence over Posted within.

## `maxResults` (type: `integer`):

The most unique posts and comments delivered by one run (1–10,000), newest first. You are charged per delivered result.

## `maxCommentsPerPost` (type: `integer`):

Subreddit-only monitoring: how many of each new post's top comments (replies included) are read (1–100). With keywords, comments come from Reddit's comment search and this does not apply.

## `onlyNew` (type: `boolean`):

Remember what earlier runs delivered and skip it, so every scheduled run returns only new matches. Uses the monitor key below.

## `monitorKey` (type: `string`):

A name for the monitor's memory, e.g. coding-ai-tools. Runs with the same key share it. Leave empty to derive one from your keywords and subreddits. Given without Only new results, results are marked isNew but nothing is skipped.

## `baselineMode` (type: `string`):

With Only new results: RETURN_CURRENT delivers the current matches on the first run; BASELINE_ONLY records them and delivers nothing, so later runs return only what is posted after you start monitoring. A baseline run is not charged.

## `requireWords` (type: `array`):

Keep a post or comment only if it also contains these words, e.g. iphone, mac, ios for the keyword apple.

## `requireMode` (type: `string`):

ANY: at least one required word. ALL: every required word.

## `excludeWords` (type: `array`):

Drop any post or comment containing one of these, e.g. fruit, recipe.

## `excludeAuthors` (type: `array`):

Reddit usernames to ignore: your own account, brand accounts, known bots. u/name or name.

## `skipBots` (type: `boolean`):

Drop posts and comments by AutoModerator and other well-known bot accounts, and text that says it was posted automatically.

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

How many searches and threads are read at once (1–5). Reddit's own rate limits are respected per connection.

## `proxyConfiguration` (type: `object`):

Apify Datacenter proxy (the default) or no proxy both work. Apify RESIDENTIAL proxy is refused and fails the run at startup: Reddit pages are large and residential bandwidth is billed to the Actor, while Reddit serves the same data to datacenter addresses. To route through your own residential provider, use Custom proxy URLs — that traffic goes through your account and is honoured.

## Actor input object example

```json
{
  "keywords": [
    "web scraping",
    "\"data extraction\""
  ],
  "subreddits": [],
  "sourceTypes": "BOTH",
  "sort": "NEW",
  "timeRange": "WEEK",
  "maxResults": 100,
  "maxCommentsPerPost": 50,
  "onlyNew": false,
  "baselineMode": "RETURN_CURRENT",
  "requireWords": [],
  "requireMode": "ANY",
  "excludeWords": [],
  "excludeAuthors": [],
  "skipBots": true,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per unique matching post or comment, newest first.

## `posts` (type: `string`):

Matching posts only.

## `comments` (type: `string`):

Matching comments with their parent post.

## `runSummary` (type: `string`):

Posts and comments scanned, unique matches, new matches delivered, already-seen suppressed, duplicates merged, filters.

## `sourceSummary` (type: `string`):

Status of every keyword and subreddit search (SUCCESS, NO_RESULTS, BLOCKED …).

# 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 = {
    "keywords": [
        "web scraping",
        "\"data extraction\""
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("coregent/reddit-keyword-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 = {
    "keywords": [
        "web scraping",
        "\"data extraction\"",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("coregent/reddit-keyword-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 '{
  "keywords": [
    "web scraping",
    "\\"data extraction\\""
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call coregent/reddit-keyword-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,coregent/reddit-keyword-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/rCTpgejdSONzorZgY/builds/fYW3q6iN6bwz7sdTh/openapi.json