# Reddit Competitor Monitor (`deepmine/reddit-competitor-monitor`) Actor

Track competitor mentions on Reddit automatically. Enter multiple competitor names, get side-by-side share-of-voice %, buzz scores, and score deltas. Spot which competitor is winning Reddit — and which discussions are gaining traction right now.

- **URL**: https://apify.com/deepmine/reddit-competitor-monitor.md
- **Developed by:** [DeepMine](https://apify.com/deepmine) (community)
- **Categories:** Social media, Automation, SEO tools
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 1 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/actors/running/actors-in-store.md#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 Competitor Monitor — Competitive Intelligence from Reddit

**Track what Reddit is saying about your competitors right now. Enter multiple competitor names and get side-by-side share-of-voice data — who's being talked about more, which subreddits are buzzing, and which discussions are gaining traction.**

Set it up once, schedule it daily or weekly, and get a continuous competitive intelligence feed with share-of-voice percentages and score tracking built in.

***

### What Is Reddit Competitor Monitor?

Reddit Competitor Monitor tracks competitor mentions across Reddit and gives you a comparative view of the competitive landscape. Enter Notion, Linear, and Coda — and every run tells you which one is getting more Reddit attention, where those conversations are happening, and which threads are actively growing.

This isn't a one-shot search tool. It's competitive intelligence infrastructure. After the first run, every mention includes a `scoreDelta` showing how many upvotes it gained since the last check — so you know which competitor discussions are spreading right now, not just which ones exist.

**Why Reddit?** Reddit is where unfiltered product opinions live. Competitor comparisons, feature debates, churn conversations, and "what should I switch to?" threads all happen on Reddit — often before they surface anywhere else. Monitoring Reddit gives you competitive signals that review sites, social media tools, and news monitoring completely miss.

***

### Key Features

- **Side-by-side competitor comparison** — track Notion, Linear, Coda in one run, get a summary row per competitor
- **Share-of-voice calculation** — see what % of total competitor mentions each brand captures (Notion: 52%, Linear: 31%, Coda: 17%)
- **Score delta tracking** — run on a schedule to see how many upvotes each mention gained since the last run
- **Buzz score ranking** — mentions ranked by engagement velocity so fast-rising threads surface above old stale ones
- **Subreddit breakdown** — see which communities are talking about each competitor most
- **Posts and comments** — catches both top-level posts and comments buried inside threads
- **Scheduled monitoring** — designed to run every 6–24 hours via Apify's scheduler

***

### Who Uses This?

#### Product Managers

Understand how your competitors are positioned on Reddit. Catch negative competitor comparisons early. Identify which competitor features Reddit users praise most — and build against them.

#### Marketing Strategists

Track share-of-voice trends over time. Is competitor buzz increasing or fading? Which subreddits mention your main rival but not you? Where should your next community strategy focus?

#### Competitive Intelligence Teams

Weekly automated report: which competitor had the most Reddit activity this week, which posts went viral, which subreddits are new signals. All in one structured dataset.

#### Startup Founders & Growth Teams

People complaining about competitors are potential customers. Monitor competitor names and catch churn conversations as they happen. High `scoreDelta` on a competitor complaint means the frustration is spreading.

#### Agencies

Run competitor monitoring for multiple clients. Each competitor gets its own summary row. Export to Slack, Google Sheets, or your reporting dashboard via Apify integrations.

***

### How Share-of-Voice Works

Share-of-voice is calculated after each run:

```
shareOfVoice = competitor mentions / total mentions across all competitors × 100
```

If you're tracking three competitors and they got 52, 31, and 17 mentions respectively, the share-of-voice is 52%, 31%, and 17%. The Summary view shows this prominently alongside total mentions and buzz scores — giving you a quick competitive landscape snapshot.

***

### How Score Delta Tracking Works

Enable **Track Score Changes Between Runs** (on by default) and schedule this actor.

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

**Every subsequent run:** Compares scores against the saved snapshot. A post with `scoreDelta: 500` gained 500 upvotes since the last run. That's the discussion actively spreading — the one to pay attention to.

**Recommended schedules:**

- Every 24 hours — good for most competitive intelligence workflows
- Every 6–12 hours — for actively monitoring a competitor launch or PR event
- Weekly — for regular share-of-voice reporting

***

### Output

Two row types per run:

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

| Field | Description |
|---|---|
| `keyword` | Competitor name |
| `shareOfVoice` | % of total mentions across all tracked competitors |
| `totalMentions` | Total posts + comments found this run |
| `mentionsDelta` | Change vs last run |
| `postCount` / `commentCount` | Breakdown by type |
| `avgBuzzScore` / `maxBuzzScore` | Engagement velocity metrics |
| `topSubreddits` | Top 5 subreddits by mention count |
| `topPostTitle` / `topPostUrl` | Highest-buzz mention this run |

#### Mentions View (all individual results)

| Field | Description |
|---|---|
| `rank` | Global rank across all competitors (1 = highest buzz) |
| `type` | `post` or `comment` |
| `matchedKeywords` | Which competitor(s) this mention matched |
| `buzzScore` | Engagement velocity score |
| `scoreDelta` | Upvotes gained since last run |
| `title` / `body` | Post title or comment text |
| `subreddit` | Where it was posted |
| `score` | Current upvote count |
| `postUrl` / `commentUrl` | Direct links |

***

### Getting Started

1. **Enter your competitors** — add 2–5 competitor names (e.g. `Notion`, `Linear`, `Coda`)
2. **Set your time window** — match it to your run schedule (daily → "Past 24 hours")
3. **Enable score tracking** — on by default; the first run builds the baseline
4. **Schedule it** — use Apify's built-in scheduler for ongoing monitoring
5. **Connect your tools** — push results to Slack, Google Sheets, or your CRM via Zapier or Make

***

### Input Parameters

| Parameter | Default | Description |
|---|---|---|
| `competitors` | — | Competitor names to track (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 competitor per run |
| `minScore` | `0` | Minimum upvote score |
| `trackChanges` | `true` | Track score delta between runs |
| `proxyConfiguration` | Residential | Proxy settings |

***

### Buzz Score Explained

`(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 at 2 hours old outscores one with 800 upvotes from 4 days ago. Combined with `scoreDelta`, buzz score tells you what's hot right now and what's accelerating between runs.

***

### Related Actors

- **[Reddit Brand Monitor](https://apify.com/your-username/reddit-brand-monitor)** — same engine, optimized for tracking your own brand on a schedule with delta alerts
- **[Reddit Mentions Scraper](https://apify.com/your-username/reddit-mentions-scraper)** — one-off deep search for any keyword across Reddit
- **[Reddit Lead Gen Scraper](https://apify.com/your-username/reddit-lead-gen-scraper)** — find people actively looking to buy what you sell

***

*Built for product managers, marketing strategists, and competitive intelligence teams who need reliable, automated Reddit competitor monitoring.*

# Actor input Schema

## `competitors` (type: `array`):

Competitor names, product names, or brand names to track across Reddit. Add one per line. Each is tracked independently — results show share-of-voice, total mentions, and which discussions are gaining traction.

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

How Reddit ranks the results returned for each competitor.

• 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 competitors.

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

Also monitor individual comments mentioning your competitors. 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 competitor per run. 100 is enough for most competitive intelligence 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`):

Each run saves a score snapshot. The next run compares against it and adds a 'scoreDelta' field — 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 competitor 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
{
  "competitors": [
    "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 = {
    "competitors": [
        "Notion",
        "Linear",
        "Figma"
    ]
};

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

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

```

## MCP server setup

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