# Reddit Keyword Monitor with Score & Karma Filters (`xyrelith-data/reddit-keyword-monitor-with-score-and-karma`) Actor

Search Reddit by keyword for matching posts, comments, communities and accounts, with score, karma, flair, date and subreddit filters, Reddit's own boolean search syntax, and 5 sort orders. No API key, no login.

- **URL**: https://apify.com/xyrelith-data/reddit-keyword-monitor-with-score-and-karma.md
- **Developed by:** [Xyrelith Data](https://apify.com/xyrelith-data) (community)
- **Categories:** Social media, Automation, Lead generation
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 with Score & Karma Filters

Reddit's own search box only gets you so far before you need to sift the results by hand. This actor runs a keyword search across Reddit and hands back posts, comments, subreddits and accounts as filtered, structured records — score thresholds, karma minimums, flair text, date windows and more applied before the data ever reaches you. No Reddit account or API key needed on your side.

### What this actor does

- Searches Reddit by keyword and returns **posts, comments, communities and users** — pick any combination via `searchPosts` / `searchComments` / `searchCommunities` / `searchUsers`
- Supports Reddit's full search syntax inside each keyword: exact phrases, `AND` / `OR` / `NOT`, `-exclusions`, and field operators (`author:`, `subreddit:`, `flair:`, `selftext:`, `site:`)
- 5 sort orders (Relevance, Hot, Top, New, Comment count), 6 time filters, and 30+ optional filters — score, karma, flair, author, domain, awards, NSFW, subreddit access type, and creation-date windows
- Scope a search to one or more subreddits at once (`withinCommunity`), or leave it unset to search all of Reddit
- Empty fields are omitted from every record — the output never contains null or blank values

### Output: per-post

Each post record starts with `dataType: "post"` and includes:

`subreddit`, `subreddit_prefixed`, `subreddit_id`, `subreddit_subscribers`, `subreddit_type`, `post_id`, `post_name`, `title`, `author`, `author_id`, `author_flair`, `author_flair_background_color`, `author_flair_text_color`, `author_flair_type`, `author_flair_css_class`, `author_flair_richtext`, `author_flair_template_id`, `author_premium`, `author_is_blocked`, `author_patreon_flair`, `content`, `content_html`, `content_url`, `content_categories`, `url` (reddit permalink), `permalink`, `url_overridden_by_dest`, `domain`, `post_hint`, `is_self`, `post_type` (self/link/image/video/gallery/poll), `score`, `ups`, `downs`, `upvote_ratio`, `num_comments`, `link_flair`, `link_flair_background_color`, `link_flair_text_color`, `link_flair_type`, `link_flair_css_class`, `link_flair_richtext`, `link_flair_template_id`, `thumbnail_url`, `thumbnail_width`, `thumbnail_height`, `created_utc`, `created_at`, `edited`, `edited_at`, `is_stickied`, `is_locked`, `is_archived`, `is_pinned`, `is_nsfw`, `is_spoiler`, `is_original_content`, `is_crosspost`, `is_crosspostable`, `is_meta`, `is_robot_indexable`, `is_reddit_media_domain`, `media_only`, `no_follow`, `send_replies`, `allow_live_comments`, `contest_mode`, `hide_score`, `suggested_sort`, `quarantine`, `num_crossposts`, `num_duplicates` (link posts only), `gilded`, `total_awards_received`, `awards` (award-type breakdown — name, count, coin price, icon URL — for every award given), `removed_by_category`, `distinguished`, `hidden`, `media_type`, `has_media`, `images[]`, `gallery_images[]`, `gallery_count`, `video_url`, `poll_data`, `crosspost_parent_id`, `search_term`, `crawled_at`, `source`

### Output: per-comment

Each comment record starts with `dataType: "comment"` and includes:

`post_id`, `post_url`, `post_title`, `comment_id`, `comment_name`, `author`, `author_id`, `author_flair`, `author_flair_css_class`, `author_flair_template_id`, `author_flair_type`, `author_flair_text_color`, `author_flair_background_color`, `author_flair_richtext`, `author_premium`, `author_is_blocked`, `author_patreon_flair`, `body`, `body_html`, `score`, `ups`, `downs`, `score_hidden`, `subreddit`, `subreddit_prefixed`, `subreddit_id`, `subreddit_type`, `link_id`, `created_utc`, `created_at`, `edited`, `edited_at`, `archived`, `can_gild`, `depth`, `parent_id`, `parent_kind`, `is_op`, `is_stickied`, `is_locked`, `distinguished`, `controversiality`, `collapsed`, `collapsed_reason`, `collapsed_because_crowd_control`, `collapsed_reason_code`, `comment_type`, `unrepliable_reason`, `no_follow`, `send_replies`, `gilded`, `total_awards_received`, `awards`, `removed_by_category`, `permalink`, `search_term`, `crawled_at`, `source`

### Output: per-community

Each community record starts with `dataType: "community"` and includes:

`subreddit`, `subreddit_prefixed`, `subreddit_id`, `url`, `title`, `description`, `description_html`, `public_description`, `public_description_html`, `submit_text`, `submit_text_html`, `submit_text_label`, `submit_link_label`, `subscribers`, `active_user_count`, `weekly_visitors`, `weekly_contributions`, `created_utc`, `created_at`, `subreddit_type`, `submission_type`, `restrict_posting`, `restrict_commenting`, `over18`, `quarantine`, `wiki_enabled`, `lang`, `advertiser_category`, `community_icon`, `icon_img`, `banner_img`, `banner_background_image`, `banner_background_color`, `mobile_banner_image`, `header_img`, `header_title`, `banner_width`, `banner_height`, `header_width`, `header_height`, `icon_width`, `icon_height`, `primary_color`, `key_color`, `allow_images`, `allow_videos`, `allow_videogifs`, `allow_galleries`, `allow_polls`, `allow_predictions`, `allow_predictions_tournament`, `allow_prediction_contributors`, `allow_talks`, `allow_discovery`, `allowed_media_in_comments`, `spoilers_enabled`, `original_content_tag_enabled`, `all_original_content`, `is_crosspostable_subreddit`, `link_flair_enabled`, `link_flair_position`, `user_flair_enabled_in_sr`, `user_flair_position`, `user_flair_type`, `user_flair_text`, `user_flair_richtext`, `user_flair_template_id`, `user_flair_background_color`, `user_flair_text_color`, `can_assign_link_flair`, `can_assign_user_flair`, `suggested_comment_sort`, `accept_followers`, `emojis_enabled`, `comment_score_hide_mins`, `collapse_deleted_comments`, `free_form_reports`, `hide_ads`, `public_traffic`, `community_reviewed`, `has_menu_widget`, `disable_contributor_requests`, `should_archive_posts`, `show_media`, `show_media_preview`, `should_show_media_in_comments_setting`, `user_sr_theme_enabled`, `search_term`, `crawled_at`, `source`

### Output: per-user

Each user record starts with `dataType: "user"` and includes:

`username`, `user_id`, `profile_url`, `post_karma`, `comment_karma`, `total_karma`, `awardee_karma`, `awarder_karma`, `is_gold`, `is_mod`, `is_employee`, `has_verified_email`, `verified`, `has_subscribed`, `is_blocked`, `is_friend`, `pref_show_snoovatar`, `icon_img`, `snoovatar_img`, `snoovatar_size`, `accept_followers`, `hide_from_robots`, `user_subreddit` (the account's profile subreddit: display name, title, subscribers, icon, banner, bio, NSFW flag, type, URL), `created_utc`, `created_at`, `search_term`, `crawled_at`, `source`

Fields that don't apply to a given record (no media, no flair, no poll, no gallery, etc.) are **omitted entirely** — the output never contains null or empty values.

### Data source

Reddit protects its public JSON endpoints with a browser challenge on many networks, so this actor reads the **server-rendered Reddit search pages** in a real browser session (cookieless — no Reddit account, login or API key) and extracts the result cards from the page. Posts, comments and communities are then enriched with their full field sets from the public, keyless **Arctic Shift** Reddit archive API (looked up by the IDs found on Reddit), which also supplies the awards, flair, media and karma breakdowns that the search cards don't show. If the archive is temporarily unavailable, the actor still returns the fields visible on the search page.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | string\[] | – | Search terms. Each keyword is searched separately and results are tagged with `search_term`. Supports Reddit's search syntax: exact phrases (`"machine learning"`), boolean (`python AND rust`, `python OR django`, `python NOT snake`, `(python OR django) AND framework`), exclusion (`-javascript`), and field operators (`author:name`, `subreddit:name`, `flair:tag`, `selftext:"phrase"`, `site:domain`) |
| `searchPosts` | boolean | `true` | Include posts in the results |
| `searchComments` | boolean | `false` | Include comments in the results |
| `searchCommunities` | boolean | `false` | Include subreddits in the results (community discovery) |
| `searchUsers` | boolean | `false` | Include Reddit accounts whose username matches the keyword (user discovery) |
| `withinCommunity` | string | – | Restrict the search to one or more subs — bare name (`technology`), `r/technology`, a full URL, or a comma-separated list (`technology,programming`) to search several subreddits at once. Applies to posts and comments; community and account search are always global |
| `sort` | enum | `relevance` | `relevance`, `hot`, `top`, `new`, `comments` |
| `timeFilter` | enum | `all` | `hour`, `day`, `week`, `month`, `year`, `all` (applies to the Top sort, as in Reddit's own search UI) |
| `resultLimit` | integer | `100` | Maximum posts per keyword (1–1,000) |
| `maxComments` | integer | `100` | Maximum comments per keyword, when `searchComments` is on (0–100,000) |
| `maxCommunities` | integer | `10` | Maximum subreddits per keyword, when `searchCommunities` is on (0–1,000) |
| `maxUsers` | integer | `25` | Maximum accounts per keyword, when `searchUsers` is on (0–100 — Reddit serves a single results page for account search, so 100 is the reliable ceiling) |
| `maxItems` | integer | `100000` | Hard cap on the **total** number of records for the whole run (all keywords, all types combined); the run stops as soon as this budget is spent (1–1,000,000) |
| `includeNSFW` | boolean | `false` | Include 18+ posts |
| `onlyWithFlair` | boolean | `false` | Keep only posts that have a link flair set; drop unflaired posts |
| `postType` | enum | – | Keep only posts of one content type: `self`, `link`, `image`, `video`, `gallery`, `poll`. Leave unset to keep all types |
| `minScore` | integer | – | Keep only posts with a score (upvotes minus downvotes) at or above this value |
| `maxScore` | integer | – | Keep only posts with a score at or below this value — useful for finding overlooked/low-visibility posts |
| `minComments` | integer | – | Keep only posts with at least this many comments |
| `minAwards` | integer | – | Keep only posts (and comments, when `searchComments` is on) with at least this many total awards |
| `titleContains` | string | – | Keep only posts whose title contains this text (case-insensitive substring match) |
| `contentContains` | string | – | Keep only self (text) posts whose body contains this text (case-insensitive substring match) |
| `flairContains` | string | – | Keep only posts whose link flair text contains this text (case-insensitive substring match) |
| `authorFlairContains` | string | – | Keep only posts (and comments, when `searchComments` is on) whose author flair text contains this text (case-insensitive substring match) |
| `authors` | string\[] | – | Keep only results submitted by one of these usernames (bare name or `u/`-prefixed); applies to posts and, when `searchComments` is on, comments |
| `domain` | string | – | Keep only posts whose link domain contains this text (e.g. `youtube.com`, `self.python`) |
| `distinguished` | enum | – | Keep only `moderator`, `admin`, or `special` (Reddit-team) results, or `none` to keep only regular results. Applies to posts and, when `searchComments` is on, comments |
| `subredditType` | enum | – | Keep only results whose community has this access type: `public`, `restricted`, `private`, `gold_only`, `archived`, `user`. Applies to posts, comments and communities alike |
| `minUpvoteRatio` | number | – | Keep only posts with an upvote ratio (0–1) at or above this value |
| `excludeStickied` | boolean | `false` | Drop posts pinned by moderators (and comments stickied by a moderator, when `searchComments` is on) |
| `excludeCrossposts` | boolean | `false` | Drop posts that are crossposted from another subreddit |
| `excludeArchived` | boolean | `false` | Drop content Reddit has archived (locked from voting/commenting), for posts and, when `searchComments` is on, comments |
| `excludeLocked` | boolean | `false` | Drop content a moderator has locked from further comments/replies, for posts and, when `searchComments` is on, comments |
| `excludeDeleted` | boolean | `false` | Drop posts and comments whose author was deleted or whose content was removed by a moderator/admin |
| `excludeSpoilers` | boolean | `false` | Drop posts marked as a spoiler by their author |
| `onlyOriginalContent` | boolean | `false` | Keep only posts the author tagged as original content (OC) |
| `minCommentScore` | integer | – | Keep only comments with a score at or above this value, when `searchComments` is on |
| `commentContains` | string | – | Keep only comments whose body contains this text, when `searchComments` is on |
| `onlyOPComments` | boolean | `false` | Keep only comments written by the post's original poster, when `searchComments` is on |
| `minCommunitySubscribers` | integer | – | Keep only communities with at least this many subscribers, when `searchCommunities` is on |
| `minUserKarma` | integer | – | Keep only accounts with at least this much total karma, when `searchUsers` is on |
| `minPostKarma` | integer | – | Keep only accounts with at least this much post (link) karma, when `searchUsers` is on |
| `minCommentKarma` | integer | – | Keep only accounts with at least this much comment karma, when `searchUsers` is on |
| `postedAfter` | date | – | Keep only results created on or after this date (UTC, `YYYY-MM-DD`). Applies to posts, comments and communities (subreddit creation date). Reddit's cookieless account search exposes no account creation date, so account records are not date-filtered |
| `postedBefore` | date | – | Keep only results created on or before this date (UTC, inclusive of the whole day). Applies to posts, comments and communities; account records are not date-filtered |

#### Example: basic keyword search

```json
{
  "keywords": ["notion alternative", "best productivity app"],
  "searchPosts": true,
  "sort": "top",
  "timeFilter": "month",
  "resultLimit": 50
}
```

#### Example: advanced search syntax with quality filters

```json
{
  "keywords": ["\"machine learning\" AND python -tutorial"],
  "searchPosts": true,
  "postType": "self",
  "minScore": 50,
  "minComments": 10,
  "excludeStickied": true,
  "resultLimit": 100
}
```

#### Example: scoped subreddit search

```json
{
  "keywords": ["AI agents"],
  "searchPosts": true,
  "withinCommunity": "r/MachineLearning,r/artificial",
  "sort": "new",
  "resultLimit": 30
}
```

#### Example: multi-type search (posts, comments, communities and users)

```json
{
  "keywords": ["notion"],
  "searchPosts": true,
  "searchComments": true,
  "searchCommunities": true,
  "searchUsers": true,
  "resultLimit": 30,
  "maxComments": 30,
  "maxCommunities": 10,
  "maxUsers": 10,
  "postedAfter": "2026-01-01",
  "maxItems": 200
}
```

### Use cases

- **Brand monitoring** — track mentions of your product or competitors across Reddit, scheduled to run daily
- **Lead generation** — find posts with purchase intent or "recommend me a tool" requests in your niche
- **Market research** — mine opinions and sentiment across relevant communities
- **Content ideation** — discover trending questions and discussion topics before you write
- **Community discovery** — find every subreddit that matters for a given topic, with subscriber counts and rules-relevant metadata
- **Influencer/account discovery** — find Reddit accounts whose username matches a brand or topic keyword

### FAQ

**Do I need a Reddit API key or login?** No — the actor searches Reddit's public data on your behalf; you don't need your own Reddit account or credentials.

**Does this actor need a proxy configured?** No — there is no proxy field to set. Nothing on your end is required beyond the keywords and filters above.

**Why did I get fewer results than my `resultLimit` / `maxItems`?** Reddit's own search index caps each query at roughly 1,000 results, and in practice it often serves noticeably fewer than that — commonly around 200–300 — for broad or generic keywords. This is a limitation of Reddit's search index itself, not a bug in the actor: the actor paginates through everything Reddit's search exposes and returns every result it can reach. Narrower, more specific keywords (or scoping with `withinCommunity`) typically surface a higher share of the available results.

**Why do I get at most about 100 comments per keyword?** Reddit's Comments tab renders a single page of comment matches (roughly 100) and exposes no further cursor for that query, so each keyword/community returns at most about 100 comments before your score/date filters are applied. Narrow the keyword or scope it to a subreddit to surface different matches.

**Why do scores differ slightly from what I see on Reddit?** Live scores and comment counts are read from Reddit's search page at run time; the archive enrichment can lag by up to ~36 hours, so the actor always prefers the live values for those two fields.

**Which sort orders and time filters are available?** Relevance, Hot, Top, New and Comment count, matching Reddit's own search UI. The time filter (past hour/day/week/month/year/all time) applies to the Top sort, exactly as it does on reddit.com.

**Can I search inside one or more specific subreddits?** Yes — set `withinCommunity` to a bare name, `r/name`, a full URL, or a comma-separated list to search several subreddits in one query. This applies to posts and comments; community and account search are always global.

**Can I find Reddit users by keyword?** Yes — enable `searchUsers` to get accounts whose username matches the keyword, along with karma breakdown, verification/moderator/gold status and their profile subreddit. Account search always searches globally and returns up to 100 accounts per keyword.

**How fresh is the data?** Every run scrapes Reddit live at the time it executes — there is no cached or delayed data. Each record includes a `crawled_at` timestamp.

**Why are `gilded`/`awards`/`total_awards_received` usually empty or zero?** Reddit retired most of its public award program, so award data is now rare on individual posts and comments. The actor still returns these fields whenever Reddit's data does include them.

**Is this actor affiliated with Reddit?** No — this is an independent, third-party actor that reads Reddit's publicly accessible search results. It is not endorsed by or affiliated with Reddit, Inc.

# Actor input Schema

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

List of keywords to search for on Reddit. Each keyword is searched separately. Advanced search syntax is supported: exact phrases ("machine learning"), boolean (python AND rust, python OR django, python NOT snake, (python OR django) AND framework), exclusion (-javascript), and field operators (author:name, subreddit:name, flair:tag, selftext:"phrase", site:domain).

## `searchPosts` (type: `boolean`):

Include posts in the keyword search results.

## `searchComments` (type: `boolean`):

Include comments in the keyword search results.

## `searchCommunities` (type: `boolean`):

Include subreddits in the keyword search results (full community data: subscribers, description, rules-friendly fields).

## `searchUsers` (type: `boolean`):

Include Reddit accounts (usernames) that match the keyword in the results (e.g. finding accounts named after a brand or topic).

## `withinCommunity` (type: `string`):

Restrict the keyword search to specific subreddits. Accepts a bare name (developers), r/developers, a full subreddit URL, or a comma-separated list to search several subreddits at once (developers,programming). Leave empty to search all of Reddit. Applies to posts and comments; community and account search are always global (Reddit does not scope those to a subreddit).

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

How the keyword search results are ranked.

## `timeFilter` (type: `string`):

Limit results to posts from a specific time window. Applies to the Top sort (as in Reddit's search UI); other sorts ignore it.

## `resultLimit` (type: `integer`):

Maximum number of posts to scrape for each keyword (1-1000).

## `maxComments` (type: `integer`):

Maximum number of comments to scrape per keyword (when 'Search for comments' is enabled).

## `maxCommunities` (type: `integer`):

Maximum number of subreddits to return per keyword (when 'Search for communities' is enabled).

## `maxUsers` (type: `integer`):

Maximum number of Reddit accounts to return per keyword (when 'Search for users' is enabled). Reddit serves a single results page for account search (no further pagination), so the reliable ceiling is 100.

## `maxItems` (type: `integer`):

Hard cap on the total number of records returned for the whole run (all keywords, all result types combined). The run stops as soon as this budget is spent.

## `includeNSFW` (type: `boolean`):

Include NSFW posts in the results.

## `onlyWithFlair` (type: `boolean`):

Keep only posts that have a link flair set (e.g. 'Discussion', 'News'). Posts without any flair are dropped.

## `postType` (type: `string`):

Keep only posts of the selected content type. Leave unset to keep all types.

## `minScore` (type: `integer`):

Only keep posts with a score at or above this value. Leave unset to keep all scores.

## `minComments` (type: `integer`):

Only keep posts with at least this many comments. Leave unset to keep all posts.

## `maxScore` (type: `integer`):

Only keep posts with a score at or below this value. Useful for finding overlooked/low-visibility posts. Leave unset to keep all scores.

## `minAwards` (type: `integer`):

Only keep posts (and comments, when 'Search for comments' is enabled) with at least this many total awards. Leave unset to keep all.

## `titleContains` (type: `string`):

Only keep posts whose title contains this text (case-insensitive substring match). Applies on top of the keyword search. Leave empty to keep all titles.

## `contentContains` (type: `string`):

Only keep self (text) posts whose body contains this text (case-insensitive substring match). Link/image/video posts have no body text and are excluded when this is set. Leave empty to keep all posts.

## `flairContains` (type: `string`):

Only keep posts whose flair text contains this text (case-insensitive substring match). Leave empty to keep all flairs.

## `authorFlairContains` (type: `string`):

Only keep posts (and comments, when 'Search for comments' is enabled) whose author flair text contains this text (case-insensitive substring match). Leave empty to keep all.

## `authors` (type: `array`):

Only keep posts (and comments, when 'Search for comments' is enabled) submitted by one of these usernames (bare name or u/-prefixed, case-insensitive). Leave empty to keep results from all authors.

## `domain` (type: `string`):

Only keep posts whose link domain contains this text (case-insensitive, e.g. 'youtube.com' or 'self.python'). Leave empty to keep all domains.

## `distinguished` (type: `string`):

Only keep posts (and comments, when 'Search for comments' is enabled) distinguished by Reddit as moderator, admin or special (e.g. Reddit-team), or only regular (non-distinguished) results. Leave unset to keep all.

## `excludeSpoilers` (type: `boolean`):

When enabled, posts marked as a spoiler by their author are dropped from the results.

## `onlyOriginalContent` (type: `boolean`):

When enabled, only posts the author tagged as original content are kept.

## `excludeStickied` (type: `boolean`):

When enabled, posts pinned/stickied by moderators (and, when 'Search for comments' is enabled, comments stickied by a moderator) are dropped from the results.

## `excludeCrossposts` (type: `boolean`):

When enabled, posts that are crossposted from another subreddit are dropped from the results.

## `excludeArchived` (type: `boolean`):

When enabled, posts (and, when 'Search for comments' is enabled, comments) that Reddit has archived (locked from further voting/commenting after 6 months) are dropped from the results.

## `excludeLocked` (type: `boolean`):

When enabled, posts that a moderator has locked from further comments (and, when 'Search for comments' is enabled, comments a moderator has locked from further replies) are dropped from the results.

## `excludeDeleted` (type: `boolean`):

Drop posts and comments whose author account was deleted or whose content was removed by a moderator/admin (Reddit marks these with the literal '\[deleted]' or '\[removed]' placeholders).

## `minUpvoteRatio` (type: `number`):

Only keep posts whose upvote ratio (fraction of upvotes among all votes) is at or above this value. Leave unset to keep all ratios.

## `minCommentScore` (type: `integer`):

Only keep comments with a score at or above this value. Applies when 'Search for comments' is enabled; ignored otherwise. Leave unset to keep all scores.

## `commentContains` (type: `string`):

Only keep comments whose body contains this text (case-insensitive substring match). Applies when 'Search for comments' is enabled; ignored otherwise. Leave empty to keep all comments.

## `onlyOPComments` (type: `boolean`):

When enabled, keep only comments written by the post's original poster (self-replies). Applies when 'Search for comments' is enabled; ignored otherwise.

## `minCommunitySubscribers` (type: `integer`):

Only keep communities (subreddits) with at least this many subscribers. Applies when 'Search for communities' is enabled; ignored otherwise. Leave unset to keep all sizes.

## `subredditType` (type: `string`):

Only keep results whose community has this access type (e.g. 'public' to exclude results from private/restricted/gold-only/archived subs you can't freely join, post or comment in). Applies to posts, comments and communities alike. Leave unset to keep all types.

## `minUserKarma` (type: `integer`):

Only keep Reddit accounts with at least this much total karma. Applies when 'Search for users' is enabled; ignored otherwise. Leave unset to keep all accounts.

## `minPostKarma` (type: `integer`):

Only keep Reddit accounts with at least this much post (link) karma. Applies when 'Search for users' is enabled; ignored otherwise. Leave unset to keep all accounts.

## `minCommentKarma` (type: `integer`):

Only keep Reddit accounts with at least this much comment karma. Applies when 'Search for users' is enabled; ignored otherwise. Leave unset to keep all accounts.

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

Only keep results created on or after this date (UTC). Applies to posts, comments and communities (subreddit creation date). Reddit's cookieless account search exposes no account creation date, so account records are not date-filtered. Reddit caps each search at roughly 1,000 results and the live index often serves far fewer (~225-250), so a distant date window on a very broad query may not be fully reachable.

## `postedBefore` (type: `string`):

Only keep results created on or before this date (interpreted as the end of that day, UTC). Applies to posts, comments and communities; account records are not date-filtered.

## Actor input object example

```json
{
  "keywords": [
    "python programming",
    "machine learning",
    "best laptops 2025"
  ],
  "searchPosts": true,
  "searchComments": false,
  "searchCommunities": false,
  "searchUsers": false,
  "withinCommunity": "r/technology,r/programming",
  "sort": "relevance",
  "timeFilter": "all",
  "resultLimit": 100,
  "maxComments": 100,
  "maxCommunities": 10,
  "maxUsers": 25,
  "maxItems": 100000,
  "includeNSFW": false,
  "onlyWithFlair": false,
  "minScore": 10,
  "minComments": 5,
  "maxScore": 1000,
  "minAwards": 1,
  "titleContains": "launch",
  "contentContains": "tutorial",
  "flairContains": "Discussion",
  "authorFlairContains": "Moderator",
  "authors": [
    "spez"
  ],
  "domain": "youtube.com",
  "excludeSpoilers": false,
  "onlyOriginalContent": false,
  "excludeStickied": false,
  "excludeCrossposts": false,
  "excludeArchived": false,
  "excludeLocked": false,
  "excludeDeleted": false,
  "minUpvoteRatio": 0.8,
  "minCommentScore": 5,
  "commentContains": "agree",
  "onlyOPComments": false,
  "minCommunitySubscribers": 1000,
  "minUserKarma": 1000,
  "minPostKarma": 100,
  "minCommentKarma": 100,
  "postedAfter": "2025-01-01",
  "postedBefore": "2025-12-31"
}
```

# Actor output Schema

## `searchResultRecords` (type: `string`):

Dataset containing the matching posts, comments, communities and/or users for the searched keywords. Records are distinguished by the `dataType` field.

# 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": [
        "machine learning"
    ],
    "searchPosts": true,
    "searchComments": false,
    "searchCommunities": false,
    "searchUsers": false,
    "sort": "relevance",
    "timeFilter": "all",
    "resultLimit": 3,
    "maxComments": 100,
    "maxCommunities": 10,
    "maxUsers": 25,
    "maxItems": 3,
    "includeNSFW": false,
    "onlyWithFlair": false,
    "excludeSpoilers": false,
    "onlyOriginalContent": false,
    "excludeStickied": false,
    "excludeCrossposts": false,
    "excludeArchived": false,
    "excludeLocked": false,
    "excludeDeleted": false,
    "onlyOPComments": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("xyrelith-data/reddit-keyword-monitor-with-score-and-karma").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": ["machine learning"],
    "searchPosts": True,
    "searchComments": False,
    "searchCommunities": False,
    "searchUsers": False,
    "sort": "relevance",
    "timeFilter": "all",
    "resultLimit": 3,
    "maxComments": 100,
    "maxCommunities": 10,
    "maxUsers": 25,
    "maxItems": 3,
    "includeNSFW": False,
    "onlyWithFlair": False,
    "excludeSpoilers": False,
    "onlyOriginalContent": False,
    "excludeStickied": False,
    "excludeCrossposts": False,
    "excludeArchived": False,
    "excludeLocked": False,
    "excludeDeleted": False,
    "onlyOPComments": False,
}

# Run the Actor and wait for it to finish
run = client.actor("xyrelith-data/reddit-keyword-monitor-with-score-and-karma").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": [
    "machine learning"
  ],
  "searchPosts": true,
  "searchComments": false,
  "searchCommunities": false,
  "searchUsers": false,
  "sort": "relevance",
  "timeFilter": "all",
  "resultLimit": 3,
  "maxComments": 100,
  "maxCommunities": 10,
  "maxUsers": 25,
  "maxItems": 3,
  "includeNSFW": false,
  "onlyWithFlair": false,
  "excludeSpoilers": false,
  "onlyOriginalContent": false,
  "excludeStickied": false,
  "excludeCrossposts": false,
  "excludeArchived": false,
  "excludeLocked": false,
  "excludeDeleted": false,
  "onlyOPComments": false
}' |
apify call xyrelith-data/reddit-keyword-monitor-with-score-and-karma --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xyrelith-data/reddit-keyword-monitor-with-score-and-karma"
        }
    }
}
```

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/LxcZex2BAoPonkyrQ/builds/fnN0CgcvwNm5wV0EC/openapi.json