# Reddit Stock Sentiment Scraper (`automation-lab/reddit-stock-sentiment-buzz-tracker`) Actor

Track supplied stock and crypto tickers across public Reddit posts and comments. Export mention volume, sentiment, daily and subreddit trends, engagement, and auditable source evidence.

- **URL**: https://apify.com/automation-lab/reddit-stock-sentiment-buzz-tracker.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.87 / 1,000 item extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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 Stock Sentiment Scraper

Track **reddit stock sentiment** for supplied stock or crypto tickers.
This Actor searches public Reddit posts and comments in selected communities,
verifies each ticker mention, applies a reproducible finance-term sentiment score,
and returns one aggregate row per ticker with source evidence.

Use it for scheduled market-research snapshots, watchlist dashboards,
community comparisons, and auditable buzz analysis.
It is not a trading signal or investment-advice product.

### What does Reddit Stock Sentiment Scraper do?

For every supplied ticker, the Actor:

1. Searches each selected public subreddit for matching posts.
2. Searches the same communities for matching comments.
3. Revalidates ticker boundaries to reject partial-word matches.
4. Deduplicates stable Reddit post and comment IDs.
5. Labels each mention bullish, bearish, or neutral.
6. Calculates mention volume and sentiment percentages.
7. Groups mentions by day and subreddit.
8. Preserves Reddit permalinks, text, timestamps, authors, and engagement.
9. Exports one integration-friendly dataset row per ticker.

The default communities are `r/wallstreetbets`, `r/stocks`, and `r/investing`.
You can replace them with up to ten public subreddits.

### Who is it for?

**Market researchers** can compare attention across a watchlist.

**Fintech product teams** can feed evidence-backed social metrics into dashboards.

**Quantitative researchers** can schedule consistent snapshots for later analysis.

**Investor-relations and brand teams** can inspect the public conversations behind a volume change.

**Data engineers** can export normalized JSON, CSV, Excel, XML, or RSS through Apify datasets.

Use [Reddit Posts Search Scraper](https://apify.com/automation-lab/reddit-posts-search-scraper)
when you need general Reddit post discovery rather than ticker-level aggregation.

### Why use this Actor?

A generic Reddit scraper returns source records and leaves aggregation to you.
This Actor adds a ticker-specific workflow:

- separate post and comment counts;
- bullish, bearish, and neutral counts;
- percentages and an average score;
- daily mention trends;
- subreddit-level comparisons;
- unique-author and combined-score context;
- recent evidence embedded with every aggregate;
- explicit time-window and source provenance.

Sentiment is deterministic and inspectable.
It does not make opaque AI claims and does not require an external AI key.

### Input parameters

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `tickers` | string array | required | 1–20 symbols such as `NVDA`, `$TSLA`, or `BTC`. |
| `subreddits` | string array | WSB, stocks, investing | 1–10 public subreddit names. `r/` is accepted. |
| `lookbackDays` | integer | `7` | Time window from 1 to 365 days. |
| `includePosts` | boolean | `true` | Include public Reddit submissions. |
| `includeComments` | boolean | `true` | Include public Reddit comments. |
| `maxMentionsPerTicker` | integer | `100` | Maximum source records used per ticker, 1–500. |
| `maxEvidencePerTicker` | integer | `50` | Maximum evidence objects returned per ticker, 1–100. |

At least one of `includePosts` and `includeComments` must be enabled.
Ticker symbols are normalized to uppercase and deduplicated.

### Getting started

1. Open the Actor input page.
2. Enter one or more ticker symbols.
3. Keep the default communities or supply focused subreddits.
4. Choose a lookback period.
5. Keep limits small for a first run.
6. Click **Start**.
7. Open the **Ticker sentiment and buzz** dataset view.
8. Expand `evidence`, `dailyTrend`, or `subredditBreakdown` for detail.
9. Export the dataset or connect it to your workflow.

A useful first input is:

```json
{
  "tickers": ["NVDA", "TSLA"],
  "subreddits": ["wallstreetbets", "stocks", "investing"],
  "lookbackDays": 7,
  "maxMentionsPerTicker": 40,
  "maxEvidencePerTicker": 20
}
```

### What data is extracted?

| Output field | Meaning |
| --- | --- |
| `ticker` | Normalized requested symbol. |
| `mentionVolume` | Posts plus comments included in the aggregate. |
| `postMentions` | Matching post count. |
| `commentMentions` | Matching comment count. |
| `bullishMentions` | Mentions with a positive lexicon score. |
| `bearishMentions` | Mentions with a negative lexicon score. |
| `neutralMentions` | Mentions with a zero net score. |
| `bullishPercent` | Bullish mentions as a percentage of volume. |
| `bearishPercent` | Bearish mentions as a percentage of volume. |
| `averageSentiment` | Mean normalized score from `-1` to `1`. |
| `totalScore` | Sum of Reddit scores across evidence. |
| `uniqueAuthors` | Distinct non-deleted public authors. |
| `subredditBreakdown` | Counts and labels grouped by community. |
| `dailyTrend` | Daily volume, labels, and average score. |
| `evidence` | Recent matched source records. |
| `evidenceTruncated` | Whether more mentions contributed than are embedded. |
| `partialCoverage` | Whether one or more requested source slices failed after bounded retries. |
| `sourceFailures` | Explicit failed record-type and subreddit slices for auditable partial output. |
| `fromDate`, `toDate` | Exact UTC aggregation window. |
| `collectedAt` | Snapshot creation time. |
| `methodology` | Sentiment qualification attached to every result. |

### Output example

A result from the current implementation has this shape:

```json
{
  "ticker": "NVDA",
  "mentionVolume": 10,
  "postMentions": 5,
  "commentMentions": 5,
  "bullishMentions": 4,
  "bearishMentions": 1,
  "neutralMentions": 5,
  "bullishPercent": 40,
  "bearishPercent": 10,
  "averageSentiment": 0.2,
  "uniqueAuthors": 9,
  "subredditBreakdown": [
    { "subreddit": "wallstreetbets", "mentions": 10, "bullish": 4, "bearish": 1, "neutral": 5 }
  ],
  "dailyTrend": [
    { "date": "2026-08-31", "mentions": 3, "bullish": 1, "bearish": 0, "neutral": 2, "averageSentiment": 0.3333 }
  ],
  "evidence": [
    {
      "id": "sample1",
      "type": "post",
      "ticker": "NVDA",
      "title": "Sample public market discussion",
      "author": "exampleuser",
      "subreddit": "wallstreetbets",
      "score": 12,
      "createdAt": "2026-08-31T12:00:00.000Z",
      "permalink": "https://www.reddit.com/r/wallstreetbets/comments/sample1/sample/",
      "sentiment": "bullish",
      "sentimentScore": 1,
      "matchedTerms": ["buy"]
    }
  ],
  "source": "reddit"
}
```

The example identity and text are anonymized.
Actual rows preserve the public Reddit evidence returned for your query.

### How sentiment is calculated

The Actor tokenizes each matching title and body.
It counts a documented set of finance terms such as `bullish`, `buy`, `calls`,
`breakout`, and `upside` as positive, and terms such as `bearish`, `sell`,
`puts`, `crash`, and `downside` as negative.

The normalized evidence score is bounded from `-1` to `1`.
Positive scores are `bullish`, negative scores are `bearish`, and zero is `neutral`.
Ticker-level averages use every accepted source record, including records omitted
from the evidence array because of `maxEvidencePerTicker`.

This method is transparent and repeatable, but it does not reliably detect
sarcasm, negation, irony, price targets, or the author's real position.
Treat it as a research feature, not a prediction.

### Source evidence and auditability

Each evidence object retains:

- the stable Reddit ID;
- record type (`post` or `comment`);
- title and available public text;
- public author name or `[deleted]`;
- subreddit;
- Reddit score and post comment count;
- creation timestamp;
- canonical Reddit permalink;
- sentiment label, score, and matched terms.

Set `maxEvidencePerTicker` lower than `maxMentionsPerTicker` to keep result rows compact.
The aggregate still uses the larger accepted sample.
Check `evidenceTruncated` before assuming the array is complete.

### How much does it cost to track Reddit stock sentiment?

The Actor uses pay-per-event pricing.
A run has a small start event and one primary `item` event for every ticker aggregate saved.
The start price is $0.000045 on every plan.
Ticker aggregates cost $0.0016615 on FREE, $0.0014448 on BRONZE, $0.0011269 on SILVER, $0.00086686 on GOLD, $0.00057791 on PLATINUM, and $0.00040453 on DIAMOND.

At BRONZE pricing:

- 1 ticker costs about **$0.001490**;
- 5 tickers cost about **$0.007269**;
- 10 tickers cost about **$0.014493**;
- 20 tickers cost about **$0.028941**.

These are Actor event charges, excluding any account-specific platform usage rules.
A zero-mention ticker is still a useful, explicit aggregate and is charged once.
Source evidence inside an aggregate has no separate event charge.

### Recurring market-monitoring workflow

Create an Apify Schedule with a fixed watchlist input.
Run it hourly, daily, or weekly according to your research cadence.
Keep each run's dataset ID and compare:

1. `mentionVolume` against the previous snapshot;
2. `bullishPercent` and `bearishPercent` changes;
3. community concentration in `subredditBreakdown`;
4. daily acceleration in `dailyTrend`;
5. source evidence behind unusual spikes.

You can send completed-run webhooks to Make, Zapier, Slack, a database,
or your own service.
The Actor itself produces snapshots; it does not send investment alerts.

### API usage with cURL

Start a synchronous run and receive dataset items:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~reddit-stock-sentiment-buzz-tracker/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "tickers": ["NVDA", "TSLA"],
    "subreddits": ["wallstreetbets", "stocks"],
    "lookbackDays": 7,
    "maxMentionsPerTicker": 50
  }'
```

Keep the token in an environment variable or secret manager.
Do not commit it to source control.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/reddit-stock-sentiment-buzz-tracker').call({
  tickers: ['AAPL', 'MSFT'],
  subreddits: ['stocks', 'investing'],
  lookbackDays: 14,
  maxMentionsPerTicker: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/reddit-stock-sentiment-buzz-tracker').call(
    run_input={
        'tickers': ['GME'],
        'subreddits': ['wallstreetbets'],
        'lookbackDays': 30,
        'maxEvidencePerTicker': 50,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add this Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/reddit-stock-sentiment-buzz-tracker"
```

#### Claude Desktop

Add this server object to the Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/reddit-stock-sentiment-buzz-tracker"
    }
  }
}
```

#### Cursor

Open **Settings → MCP**, add an HTTP server named `apify`, and use the same Actor-specific URL shown above.

#### VS Code

Add an HTTP MCP server named `apify` to your VS Code MCP configuration with the same Actor-specific URL.

Example prompts:

- “Compare seven-day NVDA and TSLA Reddit buzz in WallStreetBets and stocks.”
- “Create a Reddit sentiment snapshot for AAPL, MSFT, AMZN, and META.”
- “Show the source evidence behind the most bearish ticker in this dataset.”

Always inspect source evidence before using a generated interpretation.

### Tips for useful results

Use symbols that Reddit users actually write.
For ambiguous short tickers, prefer focused finance communities.

Search several relevant communities rather than one very broad subreddit.

Increase `lookbackDays` before increasing limits when a ticker has sparse discussion.

Use both posts and comments for a balanced sample.
Use posts-only mode when you need headline-level buzz.
Use comments-only mode when you need conversational reactions.

For recurring comparisons, keep inputs and limits stable across runs.

### Limits and failure behavior

The Actor searches public archive records, not private, quarantined, or deleted content.
Coverage depends on upstream archive availability and indexing.
Very recent Reddit activity may arrive with a delay.

Each ticker uses at most 500 accepted mentions.
Each run supports at most 20 tickers and 10 subreddits.
Requests have a three-second client timeout.
An indexed-search timeout triggers a bounded recent-record scan with local ticker filtering instead of blind retries. Recent scans are cached by subreddit and record type within the run, so multiple tickers reuse the same source response.

If one subreddit or record-type slice remains unavailable after that fallback, the Actor continues with other requested slices and sets `partialCoverage=true` with explicit `sourceFailures`.
If every requested slice for a ticker fails, the run fails clearly instead of fabricating an empty result.
A valid ticker with no matches and no source failures produces a zero-volume aggregate.

The Actor does not use a residential proxy or browser.
It does not bypass login, private-community, or access controls.

### Troubleshooting

**The Actor returned zero mentions.**

Confirm the symbol is used in the selected communities.
Try a longer lookback, include both posts and comments, or add another finance subreddit.
Remember that some symbols are mostly discussed by company name rather than ticker.

**A common word looks like a ticker match.**

Ticker matching uses word boundaries, but symbols such as `AI`, `ON`, or `IT`
can still be ordinary words.
Use focused communities and inspect evidence before accepting the count.

**The run failed on an archive request.**

Check the log for the endpoint type and retry count.
The public archive may be temporarily unavailable.
Retry later rather than increasing retries indefinitely.

**The evidence array is shorter than mentionVolume.**

This is expected when `maxEvidencePerTicker` is lower than `maxMentionsPerTicker`.
Check `evidenceTruncated` and increase the evidence limit up to 100 if needed.

### Responsible use and legality

Use only public Reddit data for legitimate research.
Respect Reddit's terms, applicable laws, platform policies, and user privacy.
Do not use this Actor to profile sensitive traits, harass users, manipulate markets,
or make automated high-impact decisions about individuals.

Public availability does not remove your responsibility to minimize retained data.
Store only the evidence your workflow needs and apply an appropriate retention policy.
Do not present rule-based sentiment as verified intent or financial advice.

### Related Automation Lab Actors

- [Reddit Posts Search Scraper](https://apify.com/automation-lab/reddit-posts-search-scraper) — normalized Reddit post discovery by query, community, author, or URL.
- [Reddit Scraper](https://apify.com/automation-lab/reddit-scraper) — broader post and comment collection workflows.
- [Stocktwits Scraper](https://apify.com/automation-lab/stocktwits-scraper) — ticker messages and author-declared sentiment from Stocktwits.
- [Reddit Historical Archive Scraper](https://apify.com/automation-lab/reddit-historical-archive-scraper) — general historical Reddit archive workflows.

Choose this Actor when ticker-level aggregation plus direct source evidence is the desired output.

### FAQ

**Does it predict stock prices?**

No. It measures public mention volume and a simple textual sentiment feature.
It does not predict price direction or returns.

**Is sentiment generated by an LLM?**

No. The Actor uses a deterministic English finance-term lexicon.
This keeps runs reproducible and removes external AI cost, but has known language limitations.

**Are comments included?**

Yes by default. Disable `includeComments` for submissions only.

**Can I search crypto symbols?**

Yes, if the symbol format is valid and people use it in the selected subreddits.
Interpret ambiguous symbols carefully.

**Can I schedule it?**

Yes. Save the input in an Apify Task and attach an Apify Schedule.
Each run produces a timestamped snapshot suitable for comparison.

**Does it require a Reddit account or API key?**

No. It uses public source data and needs no Reddit credentials.

**Can I export CSV or Excel?**

Yes. Use the dataset export controls or Apify dataset API.
Nested evidence and trend arrays are most naturally consumed as JSON.

**Why is each ticker one dataset item?**

Ticker-level rows are convenient for watchlists, dashboards, schedules, and joins.
The source evidence remains nested with the aggregate that it supports.

# Actor input Schema

## `tickers` (type: `array`):

One to 20 ticker symbols without or with a leading $, for example NVDA, TSLA, or BTC.

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

Two to 10 public subreddit names to search. Names may include r/. Defaults to WallStreetBets, stocks, and investing.

## `lookbackDays` (type: `integer`):

Search the public archive from this many days before the run time, from 1 to 365 days.

## `includePosts` (type: `boolean`):

Count public Reddit submissions that mention each ticker.

## `includeComments` (type: `boolean`):

Count public Reddit comments that mention each ticker.

## `maxMentionsPerTicker` (type: `integer`):

Maximum matching source records used to calculate each ticker aggregate, from 1 to 500.

## `maxEvidencePerTicker` (type: `integer`):

Maximum recent source records embedded in each ticker result, from 1 to 100. Aggregates still use up to maxMentionsPerTicker records.

## Actor input object example

```json
{
  "tickers": [
    "NVDA",
    "TSLA"
  ],
  "subreddits": [
    "wallstreetbets",
    "stocks",
    "investing"
  ],
  "lookbackDays": 7,
  "includePosts": true,
  "includeComments": true,
  "maxMentionsPerTicker": 100,
  "maxEvidencePerTicker": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

Ticker-level aggregates with daily trends, subreddit breakdowns, and source evidence.

# 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 = {
    "tickers": [
        "NVDA",
        "TSLA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/reddit-stock-sentiment-buzz-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 = { "tickers": [
        "NVDA",
        "TSLA",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/reddit-stock-sentiment-buzz-tracker").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 '{
  "tickers": [
    "NVDA",
    "TSLA"
  ]
}' |
apify call automation-lab/reddit-stock-sentiment-buzz-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/reddit-stock-sentiment-buzz-tracker"
        }
    }
}

```

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/UYbxGPKsQk7xbqzQ4/builds/v5z6S76fwUtP71yhb/openapi.json