# Reddit Sentiment Tracker (`sentry/reddit-sentiment-tracker`) Actor

Reddit sentiment tracker for brands and keywords. Every mention scored positive, negative, or neutral — combining text analysis with Reddit's upvote ratio as a community signal. Get sentiment % breakdowns, overall verdict, and top posts per keyword.

- **URL**: https://apify.com/sentry/reddit-sentiment-tracker.md
- **Developed by:** [Sentry](https://apify.com/sentry) (community)
- **Categories:** Social media, SEO tools, Automation
- **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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Sentiment Tracker — Know If Reddit Likes You

**Search Reddit for any keyword and find out: is the sentiment positive, negative, or mixed? Every mention scored, every keyword summarised.**

One run. Every mention tagged. Sentiment breakdown per keyword — so you know whether Reddit's opinion is working for you or against you.

---

### What It Does

Reddit is where unfiltered opinions live. But raw mentions don't tell you much — you need to know whether those mentions are good or bad. This actor searches Reddit for your keywords, scores every post and comment using a hybrid sentiment model (AFINN keyword scoring + Reddit's own upvote ratio as a community signal), and returns a clear breakdown: what percentage of mentions are positive, negative, or neutral.

---

### How Sentiment Is Scored

Two signals combined:

**1. Text scoring (AFINN word list)**
Each post or comment is scored based on the emotional weight of its words. "Amazing", "love", "recommend" push the score positive. "Terrible", "broken", "waste" push it negative. The score is normalized by text length so short and long posts are comparable.

**2. Upvote ratio (community signal)**
Reddit's upvote ratio is the community's collective verdict. A post at 95% upvote ratio is almost certainly a positive reception. A post at 25% is controversial or disliked. This modifier adjusts the text score up or down based on how the community voted — catching cases where sarcasm or context defeats keyword matching.

**Result:** `positive` / `negative` / `neutral` label + numeric score per mention.

---

### Output

Two types of records in the dataset:

#### Sentiment Summary (one per keyword)

| Field | Description |
|---|---|
| `keyword` | The search keyword |
| `overallSentiment` | `positive`, `negative`, or `neutral` overall |
| `positiveRatio` | % of mentions scored positive |
| `negativeRatio` | % of mentions scored negative |
| `neutralRatio` | % of mentions scored neutral |
| `totalMentions` | Total mentions analysed |
| `avgSentimentScore` | Average sentiment score across all mentions |
| `topPositiveMention` | Highest-scoring positive mention (title + URL) |
| `topNegativeMention` | Most negative mention (title + URL) |

#### Mentions (one per post or comment)

| Field | Description |
|---|---|
| `sentiment` | `positive`, `negative`, or `neutral` |
| `sentimentScore` | Numeric score (positive = positive, negative = negative) |
| `contentType` | `post` or `comment` |
| `matchedKeywords` | Which of your keywords matched this mention |
| `title` | Post title |
| `body` | Comment text (for comments) |
| `subreddit` | Which subreddit |
| `score` | Reddit upvote score |
| `upvoteRatio` | Upvote ratio (posts only) |
| `buzzScore` | Engagement momentum score |
| `postUrl` | Link to the post |
| `commentUrl` | Link to the comment (for comments) |
| `author` | Reddit username |
| `createdAt` | When it was posted |

---

### Getting Started

1. Enter your keywords (brand names, product names, topics)
2. Set your time window (past week is a good default)
3. Run — get sentiment summary per keyword + every mention scored

---

### Use Cases

**Brand reputation monitoring**
Is Reddit's opinion of your brand trending positive or negative? Run weekly, check the `overallSentiment` field. If it flips from positive to negative, something changed.

**Product launch tracking**
Released something new? Search your product name after launch and see whether the Reddit reaction is positive, negative, or mixed — and which specific posts are driving the sentiment.

**Competitor analysis**
Search your competitors' names. Find out if Reddit likes them or hates them — and read the specific negative mentions to understand what they're getting wrong.

**Campaign monitoring**
Running a Reddit marketing campaign or AMA? Track your keyword during and after to see whether the campaign shifted sentiment.

---

### Input Parameters

| Parameter | Default | Description |
|---|---|---|
| `keywords` | — | Keywords to analyse (required) |
| `sortBy` | `new` | Sort order: new, relevance, top, hot, comments |
| `timeFilter` | `week` | Time window: hour, day, week, month, year, all |
| `searchPosts` | `true` | Include Reddit posts |
| `searchComments` | `false` | Include comments (slower, more coverage) |
| `subredditFilter` | `[]` | Restrict to specific subreddits (optional) |
| `maxResultsPerKeyword` | `100` | Max mentions per keyword |
| `minScore` | `0` | Minimum upvote score to include |
| `proxyConfiguration` | Residential | Proxy settings |

---

### Related Actors

- **[Reddit Brand Monitor](https://apify.com/your-username/reddit-brand-monitor)** — track mentions and score changes between scheduled runs
- **[Reddit Competitor Monitor](https://apify.com/your-username/reddit-competitor-monitor)** — side-by-side share-of-voice tracking for competitor names
- **[Reddit Mentions Scraper](https://apify.com/your-username/reddit-mentions-scraper)** — raw mention data without sentiment scoring

---

*Built for brand managers, PR teams, and marketing teams who need to know whether Reddit's opinion is helping or hurting them.*

# Actor input Schema

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

Brand names, product names, or topics to analyse on Reddit. Each keyword is searched independently — results show sentiment breakdown per keyword.
## `sortBy` (type: `string`):

How Reddit ranks the results returned for each keyword.

• New — most recent mentions first. Best for catching fresh opinions.
• Relevance — Reddit's own relevance ranking.
• Top — highest-scored posts. Good for seeing what resonated most.
• Hot — currently active discussions.
• Most Comments — most-discussed threads.
## `timeFilter` (type: `string`):

Only return mentions posted within this time window.
## `searchPosts` (type: `boolean`):

Analyse Reddit posts (links, articles, discussions) that mention your keyword.
## `searchComments` (type: `boolean`):

Also analyse individual comments mentioning your keywords. Catches opinions buried inside threads. Increases run time.
## `subredditFilter` (type: `array`):

Optionally restrict analysis to specific subreddits. Leave empty to search all of Reddit. Accepts any format: gaming, r/gaming, or full URL.
## `maxResultsPerKeyword` (type: `integer`):

Maximum number of mentions to collect per keyword. More results = more accurate sentiment breakdown but longer run time.
## `minScore` (type: `integer`):

Ignore mentions with fewer upvotes than this. Set to 0 to include brand-new posts with no votes yet.
## `proxyConfiguration` (type: `object`):

Proxy settings for routing requests. Residential proxies are strongly recommended for reliable results.

## Actor input object example

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

# Actor output Schema

## `results` (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-sentiment-tracker").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-sentiment-tracker").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-sentiment-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Sentiment Tracker",
        "description": "Reddit sentiment tracker for brands and keywords. Every mention scored positive, negative, or neutral — combining text analysis with Reddit's upvote ratio as a community signal. Get sentiment % breakdowns, overall verdict, and top posts per keyword.",
        "version": "1.0",
        "x-build-id": "DgoAW1c18wWkpIVpe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sentry~reddit-sentiment-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sentry-reddit-sentiment-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/sentry~reddit-sentiment-tracker/runs": {
            "post": {
                "operationId": "runs-sync-sentry-reddit-sentiment-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/sentry~reddit-sentiment-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-sentry-reddit-sentiment-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords to Analyse",
                        "type": "array",
                        "description": "Brand names, product names, or topics to analyse on Reddit. Each keyword is searched independently — results show sentiment breakdown per keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "new",
                            "relevance",
                            "top",
                            "hot",
                            "comments"
                        ],
                        "type": "string",
                        "description": "How Reddit ranks the results returned for each keyword.\n\n• New — most recent mentions first. Best for catching fresh opinions.\n• Relevance — Reddit's own relevance ranking.\n• Top — highest-scored posts. Good for seeing what resonated most.\n• Hot — currently active discussions.\n• Most Comments — most-discussed threads.",
                        "default": "new"
                    },
                    "timeFilter": {
                        "title": "Time Window",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Only return mentions posted within this time window.",
                        "default": "week"
                    },
                    "searchPosts": {
                        "title": "Analyse Posts",
                        "type": "boolean",
                        "description": "Analyse Reddit posts (links, articles, discussions) that mention your keyword.",
                        "default": true
                    },
                    "searchComments": {
                        "title": "Analyse Comments",
                        "type": "boolean",
                        "description": "Also analyse individual comments mentioning your keywords. Catches opinions buried inside threads. Increases run time.",
                        "default": false
                    },
                    "subredditFilter": {
                        "title": "Restrict to Subreddits (optional)",
                        "type": "array",
                        "description": "Optionally restrict analysis to specific subreddits. Leave empty to search all of Reddit. Accepts any format: gaming, r/gaming, or full URL.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerKeyword": {
                        "title": "Max Results Per Keyword",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of mentions to collect per keyword. More results = more accurate sentiment breakdown but longer run time.",
                        "default": 100
                    },
                    "minScore": {
                        "title": "Minimum Upvote Score",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Ignore mentions with fewer upvotes than this. Set to 0 to include brand-new posts with no votes yet.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for routing requests. Residential proxies are strongly recommended for reliable results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
