# Reddit Brand Mention Monitor & Sentiment Alerts (`apt_marble/reddit-brand-mention-monitor-sentiment-alerts`) Actor

Track every new Reddit post and comment that names your brand or your competitors. Each run returns only mentions you have not seen before — with positive, neutral or negative sentiment, the sentence around the mention and a direct link to reply. Built to run hourly or daily behind an alert.

- **URL**: https://apify.com/apt\_marble/reddit-brand-mention-monitor-sentiment-alerts.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 mentions

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 Brand Mention Monitor

Know the moment Reddit starts talking about you. This actor searches Reddit for
your brand names — and, if you want, your competitors' — and returns every post
and comment that names them, with the sentence around the mention, a positive /
neutral / negative reading and a direct link to the thread. It is built to run
on a schedule: it remembers everything it has already reported, so each run
hands you a clean "what's new since last time" list instead of the same results
over and over. Point it at all of Reddit or at a handful of communities, run it
hourly or daily, and stop finding out about the thread three weeks late.

### What you can do with it

- **Catch complaints early.** Get the negative mentions of your product within
  the hour, while the thread is still small enough to reply to.
- **Run competitive intelligence.** Track rival names alongside your own and
  compare volume, sentiment and which communities each one owns.
- **Feed a Slack or email alert.** Because every run returns only new mentions,
  you can pipe the output straight into an alert without de-duplicating it
  yourself.
- **Find support conversations you are missing.** People ask for help about your
  product in communities you have never heard of; the monitor surfaces them.
- **Measure a launch or a campaign.** Run it over the week of a launch and count
  mentions, sentiment split and the communities that picked it up.
- **Watch for name misuse.** Track a trademark, a domain or a handle and see
  where it is being resold, cloned or badmouthed.

### What you get

One record per mention. A real (abridged) result:

```json
{
  "id": "1v98gmn",
  "fullId": "t3_1v98gmn",
  "type": "post",
  "keyword": "ChatGPT",
  "keywordType": "brand",
  "matchedIn": "body",
  "snippet": "…Ranking Algorithm ↓ Same 10 blue links. # AI search is different Now imagine ChatGPT answering the same question. It isn't trying to show the \"best webpage.\" It's trying to generate the best answer at that moment…",
  "sentiment": "positive",
  "sentimentScore": 0.459,
  "sentimentSignals": ["best", "best"],
  "isNew": true,
  "title": "The old internet vs. the new internet",
  "url": "https://www.reddit.com/r/Cited/comments/1v98gmn/the_old_internet_vs_the_new_internet/",
  "subreddit": "Cited",
  "subredditUrl": "https://www.reddit.com/r/Cited/",
  "author": "bookflow",
  "authorProfileUrl": "https://www.reddit.com/user/bookflow/",
  "score": 1,
  "numComments": 0,
  "upvoteRatio": 1,
  "over18": false,
  "createdAt": "2026-07-28T19:24:15.000Z",
  "foundAt": "2026-07-28T21:00:00.000Z"
}
```

Comments come back in the same shape, with `type: "comment"`, the comment text
in `snippet` and `title` / `postUrl` pointing at the thread the comment lives in.

### Input reference

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `brandKeywords` | list of text | *required* | The names you want to hear about. Multi-word terms are matched as an exact phrase. Every result contains the term verbatim. |
| `competitorKeywords` | list of text | empty | Rival names to track alongside your own. They come back tagged `competitor`. A name listed in both lists stays `brand`. |
| `subreddits` | list of text | empty | Restrict the search to specific communities. Accepts `python`, `r/python` or a full community URL. Empty means all of Reddit. |
| `excludeSubreddits` | list of text | empty | Communities to drop from the results — your own community, meme subs, known spam. |
| `searchComments` | boolean | `true` | Also open the comment threads of the matching posts and report individual comments that name your keyword, each with its own author and sentiment. Turn it off for a faster, posts-only run. |
| `lookbackWindow` | select | `day` | How far back each run looks: past hour, past 24 hours, past week or past month. |
| `maxMentionsPerKeyword` | integer | `200` | Caps how many mentions a single keyword can return in one run (max 1000), so a viral thread cannot run away with your budget. Post mentions and comment mentions are capped separately. |
| `onlyNewSinceLastRun` | boolean | `true` | Return only mentions this monitor has never reported before. Turn it off to get everything in the window every time. |
| `stateStoreName` | text | `reddit-mention-monitor-state` | The name under which the monitor keeps its memory of reported mentions. Runs sharing a name share a memory; give two schedules different names to track two brands independently. |
| `resetState` | boolean | `false` | Forget the memory for this run, so everything in the window counts as new. Useful after changing keywords or for a one-off backfill. |
| `maxConcurrency` | integer | `5` | How many searches run at the same time (1–20). |
| **Browse from** | select | United States | The country whose regional Reddit results you want to see. Most brands leave it alone. |

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `id` / `fullId` | text | Reddit's id for the post or comment. |
| `type` | text | `post` or `comment`. |
| `keyword` | text | The keyword this record matched. |
| `keywordType` | text | `brand` or `competitor`. |
| `matchedIn` | text | Where the keyword was found: `title`, `body`, `flair` or `link`. A comment always matches on its own `body`. |
| `snippet` | text | The mention in context — up to 150 characters either side of the keyword. |
| `sentiment` | text | `positive`, `neutral` or `negative`. |
| `sentimentScore` | number | −1 to +1. Anything at or beyond ±0.05 is called positive or negative. |
| `sentimentSignals` | list of text | The exact words and phrases that produced the score, so you can audit it. |
| `isNew` | boolean | `true` when this monitor had not reported this mention before. |
| `title` | text | The post title, or for a comment the title of the thread it sits in. |
| `url` | link | Direct link to the post or the individual comment. |
| `permalink` | text | The Reddit path, if you prefer to build your own links. |
| `subreddit` / `subredditUrl` | text / link | The community it was posted in. |
| `author` / `authorProfileUrl` | text / link | Who wrote it, and a link to their profile so you can reply. |
| `score` | number | Upvotes at the time of collection. |
| `numComments` | number | Comment count (posts only). |
| `upvoteRatio` | number | Share of votes that were upvotes (posts only). |
| `flair` | text | Post flair, when the community uses it. |
| `over18` | boolean | Whether the post is marked NSFW. |
| `postId` / `postUrl` | text / link | The thread a comment belongs to (for a post, the post itself). |
| `createdAt` | date | When the post or comment was written (UTC, ISO 8601). |
| `foundAt` | date | When this run collected it. |

### Pricing

Pay per event. There is exactly one billable event:

| Event | Charged when | Price |
| --- | --- | --- |
| `apify-default-dataset-item` | a mention is written to the dataset | **$0.0015** each — **$1.50 per 1,000 mentions** |

A mention is a post or a comment that names one of your keywords, already
de-duplicated, already classified and ready to act on. Runs that find nothing
cost nothing, and the same mention is never charged twice as long as "only
return mentions I have not seen" is left on — that is the whole point of the
run-to-run memory. A typical daily brand watch that surfaces 40 new mentions
costs about $0.06; a busy launch week at 2,000 mentions costs $3.00. Set a
maximum cost per run in the actor's settings and the monitor stops cleanly when
it reaches it, keeping everything it already collected.

### Limits and what this actor cannot do

Honest constraints, all of them confirmed on live Reddit data:

- **Results are a relevance-ranked sample, not an exhaustive archive.** Reddit
  itself limits any single feed to roughly 1,000 posts, and its search returns a
  relevance-ranked selection — typically a few hundred results per query — rather
  than a complete archive of everything ever written. The monitor widens coverage
  by splitting the job up: every keyword, and every community you list, is
  searched separately, so each one gets its own share of that ceiling. On an
  hourly or daily window this is rarely the binding constraint; for a month-long
  backfill of a very noisy brand name, expect a representative sample rather than
  every last mention.
- **Comments are found inside the threads your keyword was found in.** Reddit's
  own search cannot search comment text — search for a word and you get posts
  back, never individual comments, and that is true for every tool. So when
  `searchComments` is on, the monitor opens the comment threads of the posts it
  matched and reports the individual comments that name your keyword. That covers
  the discussion around every thread you are found in, but a comment that
  mentions you inside a thread whose post does not mention you will not be found.
- **Each run reads the 100 newest matched threads, and the top of each one.**
  Inside a thread the monitor reads the top-voted part of the conversation —
  roughly the first 200 comments, including nested replies about eight levels
  down — rather than every last reply of a 5,000-comment mega-thread. The
  mentions worth acting on almost always sit in that part of the thread, but in
  a very large discussion a deeply buried mention can be missed.
- **Sentiment is a keyword heuristic, not AI.** Scores come from a curated
  lexicon of positive and negative words and phrases with negation ("not good"),
  intensifier ("very buggy") and idiom handling ("crash course" is not a crash).
  It is fast, free and completely transparent — `sentimentSignals` shows you
  exactly which words fired — but it is not a language model. Sarcasm, irony and
  domain jargon will fool it. Treat it as triage, not as a verdict.
- **Sentiment is scored on the mention's immediate context**, not on the whole
  post. In a 4000-word essay, only the text around your brand name is scored.
- **The sentiment lexicon is English only.** Reddit is multilingual and a global
  keyword search returns plenty of Spanish, Portuguese, Greek and Russian posts.
  Those are still reported as mentions — the keyword match is
  language-independent — but they will almost always score `neutral`, because no
  non-English word is in the lexicon. Do not read a neutral split on non-English
  results as an absence of opinion.
- **Every result contains the keyword verbatim.** Reddit's relevance search
  returns near-misses; those are discarded. Mentions that only imply your brand,
  misspell it, or refer to it by an abbreviation you did not list will not
  appear. List the variants you care about.
- **Public content only.** Private, banned and quarantined communities are not
  readable, and neither are deleted or removed posts. Moderator-only data
  (mod lists, mod logs, removal reasons) is not available.
- **No "users online now".** Reddit does not publish a live online count for a
  community, so no record contains one.
- **Search coverage is Reddit's, not ours.** Very fresh posts can take a few
  minutes to become searchable, and Reddit's own search does not guarantee that
  every matching item is returned for every term. For maximum coverage of a
  specific community, list it in `subreddits` rather than relying on a site-wide
  search.
- **The memory lives with the name you give it.** Rename `stateStoreName`, or
  tick `resetState`, and the monitor no longer knows what it reported before —
  the next run will treat everything in the window as new.
- **The memory holds the 50,000 most recent mentions.** Older entries are
  forgotten to keep it bounded. A brand generating more than 50,000 mentions
  between two runs can therefore see its oldest entries reported a second time.
  At normal volumes that is many days of history and never happens; if you
  monitor something extremely noisy, run more often and keep the lookback
  window short.
- **Volume is entirely up to your keyword.** A common word can return hundreds
  of mentions an hour and a niche brand none for days, and there is no way to
  know which you have until you run it. Treat your first run as a calibration
  run: look at how much comes back, and tune `lookbackWindow` and
  `maxMentionsPerKeyword` before you point an alert at it.

### FAQ

**Do I need a Reddit account?**
No. You do not need a Reddit account, a login, or any credentials — just enter
what you want and run it.

**Is anything about my own Reddit identity involved?**
No. Nothing personal to you is used, stored or exposed by the monitor.

**How fast is it?**
Fast. Results arrive in large batches and several keywords are handled at the
same time, so a typical daily run over a handful of brand names finishes in
seconds, and even a wide month-long backfill finishes in minutes.

**Can I run it on a schedule?**
Yes — that is what it is for. Leave "only return mentions I have not seen" on
and every scheduled run returns just the new mentions, which is exactly what you
want behind an alert. Match `lookbackWindow` to your schedule (hourly runs with
"past hour", daily runs with "past 24 hours") and overlap slightly rather than
exactly, so nothing falls between two runs.

**Why did I get zero results on the first run?**
Either nobody mentioned your keyword in the window, or the window is too narrow.
Widen `lookbackWindow` to a week, drop the community filter, and check that your
keyword really appears verbatim in Reddit threads.

**Will it report the same mention twice?**
Not while the run-to-run memory is on and `stateStoreName` stays the same. If a
post is edited later to mention you again, it still counts as already reported —
the monitor tracks each post-and-keyword pair once.

**Can I track two different brands separately?**
Yes. Run two schedules with different `stateStoreName` values and each keeps its
own independent memory.

**Does it pick up comments too?**
Yes, by default. For every post it matches, it opens the thread and reports the
individual comments that name your keyword, each as its own record with its own
author, link and sentiment. That is where most of the actual conversation is. It
covers the 100 newest matched threads per run and the top-voted part of each
one. The one thing it cannot do is find a comment about you in a thread whose
post never mentions you — Reddit's own search cannot search comment text, for
any tool.

# Actor input Schema

## `brandKeywords` (type: `array`):

The names you want to hear about — your product, your company, a handle, a domain. Multi-word terms are matched as an exact phrase. Every result is guaranteed to contain the term verbatim.

## `competitorKeywords` (type: `array`):

Optional. Rival names to track alongside your own. They appear in the results tagged as 'competitor' so you can compare share of voice and sentiment side by side.

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

Optional. Restrict the search to specific communities. Accepts 'python', 'r/python' or a full community URL. Leave empty to search all of Reddit.

## `excludeSubreddits` (type: `array`):

Optional. Communities to drop from the results — useful for muting your own community, meme subs or known spam hangouts.

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

Also open the comment threads of the matching posts and report individual comments that name your keyword, each with its own author and sentiment. This adds a little time per thread. Turn it off if you only want whole posts and want the run to finish faster.

## `lookbackWindow` (type: `string`):

How far back each run looks. Match this to how often you schedule the monitor — hourly runs work well with 'Past hour', daily runs with 'Past 24 hours'.

## `maxMentionsPerKeyword` (type: `integer`):

Caps how many mentions each keyword can return in one run, so a keyword that suddenly goes viral cannot run away with your budget. Post mentions and comment mentions are capped separately, so one busy thread cannot crowd out everything else.

## `onlyNewSinceLastRun` (type: `boolean`):

On by default. The monitor remembers every mention it has already reported and skips it next time, so a scheduled run gives you a clean 'what's new' list instead of the same items again. Turn it off to get every mention in the window on every run.

## `stateStoreName` (type: `string`):

The name under which the monitor keeps its record of already-reported mentions. Runs that share a name share a memory — give two schedules different names to track two brands independently.

## `resetState` (type: `boolean`):

Wipes the memory for this run, so every mention in the window counts as new. Handy after changing keywords or when you want a full backfill.

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

How many searches run at the same time. Higher finishes sooner; lower is gentler and more predictable.

## `country` (type: `string`):

Which country's view of Reddit to use. Reddit content is the same almost everywhere, so the default suits nearly every run.

## Actor input object example

```json
{
  "brandKeywords": [
    "ChatGPT"
  ],
  "competitorKeywords": [
    "Claude",
    "Gemini"
  ],
  "subreddits": [],
  "excludeSubreddits": [],
  "searchComments": true,
  "lookbackWindow": "day",
  "maxMentionsPerKeyword": 200,
  "onlyNewSinceLastRun": true,
  "stateStoreName": "reddit-mention-monitor-state",
  "resetState": false,
  "maxConcurrency": 5,
  "country": "us"
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "brandKeywords": [
        "ChatGPT"
    ],
    "competitorKeywords": [
        "Claude",
        "Gemini"
    ],
    "lookbackWindow": "day",
    "maxMentionsPerKeyword": 200,
    "stateStoreName": "reddit-mention-monitor-state",
    "maxConcurrency": 5,
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/reddit-brand-mention-monitor-sentiment-alerts").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 = {
    "brandKeywords": ["ChatGPT"],
    "competitorKeywords": [
        "Claude",
        "Gemini",
    ],
    "lookbackWindow": "day",
    "maxMentionsPerKeyword": 200,
    "stateStoreName": "reddit-mention-monitor-state",
    "maxConcurrency": 5,
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/reddit-brand-mention-monitor-sentiment-alerts").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "brandKeywords": [
    "ChatGPT"
  ],
  "competitorKeywords": [
    "Claude",
    "Gemini"
  ],
  "lookbackWindow": "day",
  "maxMentionsPerKeyword": 200,
  "stateStoreName": "reddit-mention-monitor-state",
  "maxConcurrency": 5,
  "country": "us"
}' |
apify call apt_marble/reddit-brand-mention-monitor-sentiment-alerts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=apt_marble/reddit-brand-mention-monitor-sentiment-alerts",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/RY68V6BKfrhhfbZJ1/builds/Ib3jgq5aW0RKxROej/openapi.json