# Reddit Brand Monitor (`sentry/reddit-brand-monitor`) Actor

Monitor Reddit for brand mentions, competitor names, and product keywords on a schedule. Tracks score changes between runs so you always know which mentions are gaining momentum — not just what exists. Set it, schedule it, stay ahead.

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

## Pricing

$25.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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 Monitor — Automated Reddit Brand Monitoring & Mention Tracker

**Monitor your brand, competitors, and keywords on Reddit automatically. Every run shows you what's new, what's growing, and which mentions are gaining upvotes — so you always know what Reddit is saying about you right now.**

Set it up once, schedule it to run every few hours, and get a continuous feed of ranked Reddit mentions with score growth tracking built in.

***

### What Is Reddit Brand Monitor?

Reddit Brand Monitor is an Apify Actor designed specifically for ongoing brand monitoring on Reddit. It searches Reddit for your brand name, competitor names, and keywords on a schedule — and after the first run, every mention includes a `scoreDelta` field showing exactly how many upvotes it gained since the last check.

This isn't a one-shot search tool. It's a monitoring pipeline. The difference: instead of just telling you what mentions exist, it tells you which ones are **actively gaining traction right now** — the discussions blowing up, the complaints spreading, the competitor comparisons going viral.

**Why Reddit?** Reddit is where unfiltered consumer opinion lives. Product complaints, competitor comparisons, brand recommendations, and community sentiment all happen on Reddit — often before they surface anywhere else. Monitoring Reddit gives you an early warning system that review sites, social media, and news monitoring tools miss entirely.

***

### Key Features

- **Scheduled monitoring** — designed to run every 6–24 hours via Apify's scheduler, building a continuous picture of brand mentions over time
- **Score delta tracking** — every mention shows how many upvotes it gained since the last run, surfacing what's actively growing vs what's already peaked
- **Multi-brand monitoring** — track your brand, multiple competitors, and category keywords in a single run, each tracked separately
- **Buzz score ranking** — mentions ranked by engagement velocity, not raw upvotes, so fast-rising new discussions rank above old stale ones
- **Per-brand summaries** — automatic summary per keyword: total mentions, top subreddits, average buzz, peak buzz, top post
- **Posts and comments** — monitor posts only or include comment-level mentions for deeper coverage
- **Subreddit targeting** — restrict monitoring to specific communities or watch all of Reddit
- **Time window control** — match the time window to your run schedule for fresh, non-overlapping results
- **Cross-brand deduplication** — posts mentioning multiple brands appear once, tagged with all matched brands

***

### Who Uses This?

#### Brand Managers & PR Teams

Know the moment a Reddit thread about your brand starts gaining traction. The `scoreDelta` field flags which mentions grew the most since your last run — those are the discussions that need attention. Catch reputation issues in hours, not days. Schedule hourly or every 6 hours for real-time awareness.

#### Marketing Agencies

Monitor brand health for multiple clients in a single scheduled actor. Each keyword gets its own summary row with total mention volume, top subreddits, and top post. Export to Slack, Google Sheets, or your reporting dashboard via Apify integrations.

#### Competitive Intelligence Teams

Add competitor names alongside your own brand. Every run tells you how many new mentions each competitor received and which posts are growing fastest. The `scoreDelta` field turns raw mentions into a signal — high delta on a competitor thread means their community is actively engaged right now.

#### Product Managers

Reddit is unfiltered product feedback at scale. Monitor your product name, common pain points, and feature requests on a weekly schedule. The highest-scoring and fastest-growing threads surface the issues your users actually care about — not the ones they submit in support tickets.

#### Startup Founders & Growth Teams

Track brand awareness growth over time. Monitor competitor names to catch churn opportunities — people complaining about competitors are potential customers. Watch for category keywords to catch buying intent discussions as they happen.

#### Investor Relations & Analysts

Monitor company names, ticker symbols, and sector terms across Reddit's financial communities. Score delta tracking on r/wallstreetbets, r/stocks, and r/investing threads shows which mentions are gaining momentum between your monitoring windows.

***

### How Monitoring Mode Works

Enable **Track Score Changes Between Runs** (on by default) and schedule this actor to run on a regular interval.

**First run:** Fetches all mentions and saves a score snapshot to memory. The `scoreDelta` field will be `null` — this run establishes the baseline.

**Every subsequent run:** Fetches mentions, compares scores against the saved snapshot, and populates `scoreDelta` for every result. A post with `scoreDelta: 847` gained 847 upvotes since the last run. That's the one to pay attention to.

**Recommended schedules:**

- Every 6 hours — good balance of freshness and cost for most brand monitoring
- Every hour — for active brand incidents or high-profile product launches
- Every 24 hours — for low-volume brands or weekly reporting workflows

Combine with the time window setting: if you run every 24 hours, set time window to "Past 24 hours" so each run only surfaces new mentions from the current window.

***

### Output — What You Get

Each run outputs two types of records: **summary rows** (one per brand/keyword) followed by **mention rows** ranked by buzz score.

#### Summary View (one row per brand)

| Field | Description |
|---|---|
| `keyword` | The brand or keyword monitored |
| `totalMentions` | Total mentions found this run |
| `postCount` | Number of matching posts |
| `commentCount` | Number of matching comments |
| `avgBuzzScore` | Average buzz score across all mentions |
| `maxBuzzScore` | Highest buzz score (hottest single mention) |
| `avgScore` | Average upvote score |
| `topSubreddits` | Top 5 subreddits by mention count, e.g. `r/technology (8)` |
| `topPostTitle` | Title of the highest-buzz mention |
| `topPostUrl` | Link to the highest-buzz mention |
| `topPostSubreddit` | Subreddit of the top mention |
| `topPostScore` | Upvote count of the top mention |
| `topPostBuzzScore` | Buzz score of the top mention |

#### Mentions View (all individual results)

| Field | Description |
|---|---|
| `rank` | Global rank across all brands (1 = highest buzz) |
| `type` | `post` or `comment` |
| `matchedKeywords` | Which brand(s) this mention matched |
| `buzzScore` | Engagement velocity score |
| `scoreDelta` | Upvotes gained since last run (null on first run) |
| `title` | Post title (posts) |
| `body` | Comment text (comments) |
| `subreddit` | Subreddit name |
| `author` | Reddit username |
| `score` | Current upvote count |
| `numComments` | Comment count (posts) |
| `postAgeHours` | Age of the post |
| `createdAt` | ISO 8601 timestamp |
| `postUrl` | Reddit post link |
| `commentUrl` | Direct comment link (comments) |

***

### Getting Started

1. **Add your brands** — Enter your brand name, product names, and up to 5 competitor names. Each is monitored independently.

2. **Set your time window** — Match it to how often you plan to run. Daily runs → "Past 24 hours". Every 6 hours → "Past hour" or "Past 24 hours" depending on volume.

3. **Enable score tracking** — On by default. The first run builds the baseline; every run after shows you what grew.

4. **Schedule it** — Use Apify's built-in scheduler. Set the interval, save, and you're done. Results appear in the dataset after every run with delta tracking populated from the second run onward.

5. **Connect your tools** — Use Apify's Zapier or Make integration to push results to Slack, Google Sheets, or your CRM automatically after each run.

***

### Input Parameters

| Parameter | Default | Description |
|---|---|---|
| `keywords` | — | Brand names and keywords to monitor (required) |
| `sortBy` | `new` | Sort order: `new`, `relevance`, `top`, `hot`, `comments` |
| `timeFilter` | `day` | Time window: `hour`, `day`, `week`, `month`, `year`, `all` |
| `searchPosts` | `true` | Monitor posts |
| `searchComments` | `false` | Also monitor comments |
| `subredditFilter` | `[]` | Restrict to specific subreddits (empty = all Reddit) |
| `maxResultsPerKeyword` | `100` | Max mentions per brand per run |
| `minScore` | `0` | Minimum upvote score (0 = include everything) |
| `trackChanges` | `true` | Track score delta between runs |
| `proxyConfiguration` | Residential | Proxy settings |

***

### Buzz Score Explained

Every mention is scored by **buzz score** — an engagement velocity metric:

`(upvotes + comments × 2) ÷ age^0.8`

Comments count double because they signal active discussion. The age exponent rewards momentum over age — a post with 200 upvotes and 50 comments at 2 hours old outscores a post with 800 upvotes from 4 days ago. Combined with `scoreDelta`, buzz score tells you both what's hot right now and what's accelerating between runs.

***

### Frequently Asked Questions

**How is this different from Reddit Mentions Scraper?**
Reddit Mentions Scraper is built for on-demand searching — you run it when you want results. Reddit Brand Monitor is built for scheduled, ongoing monitoring. Score tracking is on by default, time window defaults to "Past 24 hours" for fresh results, and the minimum score is 0 so you catch brand-new posts immediately. The whole setup is optimized for recurring runs, not one-off searches.

**How often should I schedule it?**
Every 6–24 hours for most use cases. During a product launch or PR incident, switch to every hour. Match the time window to the interval so you don't get overlap or gaps.

**What is scoreDelta?**
The number of upvotes a mention gained since your last run. A post with `scoreDelta: 500` went from 100 to 600 upvotes between your last two runs — that's a signal it's spreading. Posts with high scoreDelta are the ones to prioritize.

**Can I monitor competitors alongside my own brand?**
Yes. Add as many brand or keyword names as you want. Each gets its own summary row. Results are tagged with which keyword they matched, so you can filter per brand in any downstream tool.

**Can I connect results to Slack or Google Sheets?**
Yes — all Apify actors work natively with Zapier, Make (formerly Integromat), and Google Sheets. Set up a webhook to push new results to Slack after every run, or sync to a Google Sheet for a live monitoring dashboard.

**Does it catch brand mentions in comments?**
Optionally. Enable "Monitor Comments" to include comment-level mentions. This catches your brand name mentioned inside discussion threads, not just post titles. It increases run time but significantly increases coverage.

**What happens on the first run?**
The first run fetches all matching mentions and saves a score baseline. `scoreDelta` will be null for every result. From the second run onward, deltas are calculated and populated automatically.

**Can I restrict monitoring to specific subreddits?**
Yes. Add subreddit names to the filter field. Accepts any format: `technology`, `r/technology`, or a full Reddit URL. Leave empty to monitor all of Reddit.

***

### Use Case Examples

**Reputation monitoring:**
Add your brand name and 2–3 common variations. Schedule every 6 hours, time window "Past 24 hours". After each run, the mentions with the highest `scoreDelta` are the ones gaining the most attention — prioritize those for response or escalation.

**Competitive intelligence:**
Add 4–5 competitor brand names. Schedule daily. The Summary view shows which competitor got the most mentions and what subreddits they appeared in. The Mentions view ranked by buzz shows which competitor discussions went viral this week.

**Product launch monitoring:**
Add your product name and launch keywords. Schedule hourly during launch week. Watch `scoreDelta` spike on positive reviews and catch negative threads before they gain traction.

**Community sentiment tracking:**
Add your product name plus 3–5 pain point keywords ("X is broken", "alternative to X", "X vs"). Weekly schedule. High-delta results on complaint keywords tell you which issues are resonating most with your user base.

***

*Built for brand managers, PR teams, marketing agencies, and product teams who need a reliable, automated Reddit monitoring pipeline.*

# Actor input Schema

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

Brand names, product names, competitor names, or keywords to monitor across Reddit. Add one per line. Each is tracked independently — results show which keyword matched and how scores have changed since the last run.

## `sortBy` (type: `string`):

How Reddit ranks the results returned for each keyword.

• New — most recent mentions first. Best for catching new discussions as they appear.
• Relevance — Reddit's own relevance ranking. Good for on-topic results.
• Top — highest-scored posts. Good for seeing what resonated most.
• Hot — currently active discussions with momentum.
• Most Comments — most-discussed threads.

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

Only return mentions posted within this time window. Match this to your run schedule — if you run every 24 hours, 'Past 24 hours' keeps results fresh. Use 'Past week' for broader coverage.

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

Monitor Reddit posts (links, articles, discussions) that mention your brand or keywords.

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

Also monitor individual comments mentioning your keywords. Catches brand mentions buried inside discussion threads. Increases run time.

## `subredditFilter` (type: `array`):

Optionally restrict monitoring to specific subreddits. Leave empty to monitor all of Reddit. Accepts any format: gaming, r/gaming, or full URL.

## `maxResultsPerKeyword` (type: `integer`):

Maximum number of mentions to collect per keyword per run. 100 is enough for most brand monitoring use cases.

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

Ignore mentions with fewer upvotes than this. Set to 0 to capture everything including brand-new posts with no votes yet.

## `trackChanges` (type: `boolean`):

The core monitoring feature. Each run saves a score snapshot. The next run compares against it and adds a 'scoreDelta' field to every result — showing exactly how many upvotes each mention gained since last time.

Run on a schedule (every 6–24 hours) to build a continuous picture of which brand mentions are growing. The first run establishes the baseline — scoreDelta will be null. From the second run onward, deltas show you what's gaining traction.

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

Proxy settings for routing requests. Residential proxies are strongly recommended for reliable results. Defaults to Apify's residential proxy pool.

## Actor input object example

```json
{
  "keywords": [
    "Notion",
    "Linear",
    "Figma"
  ],
  "sortBy": "new",
  "timeFilter": "day",
  "searchPosts": true,
  "searchComments": false,
  "subredditFilter": [],
  "maxResultsPerKeyword": 100,
  "minScore": 0,
  "trackChanges": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `trendingPosts` (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 = {
    "keywords": [
        "Notion",
        "Linear",
        "Figma"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sentry/reddit-brand-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": [
        "Notion",
        "Linear",
        "Figma",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sentry/reddit-brand-monitor").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 '{
  "keywords": [
    "Notion",
    "Linear",
    "Figma"
  ]
}' |
apify call sentry/reddit-brand-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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