# Reddit Opportunity Scout (`fabian_projects/reddit-opportunity-scout`) Actor

Scan one finance-heavy subreddit, detect tracked tickers/themes, and return ranked hot/watch/noise opportunities for traders, researchers, and watchlist builders.

- **URL**: https://apify.com/fabian\_projects/reddit-opportunity-scout.md
- **Developed by:** [Fabian Projects](https://apify.com/fabian_projects) (community)
- **Categories:** News, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 events

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Opportunity Scout

An Apify-ready Python Actor that scans one finance-heavy subreddit via the Arctic Shift Reddit mirror API, detects tracked assets/themes, and returns ranked narrative-aware opportunities for traders, researchers, and watchlist builders.

### Store-ready positioning

#### Who this is for
- retail traders building watchlists
- finance researchers monitoring retail sentiment
- newsletter / dashboard builders who want structured Reddit idea flow

#### Core promise
Give me one subreddit and I get back the dominant narratives, the leading names inside each one, and a ranked shortlist of what deserves attention first.

#### Why this is more sellable than a generic AI wrapper
- one narrow input domain: a single subreddit
- one narrow output shape: narrative-aware ranked opportunity rows
- dataset items map cleanly to buyer value
- pay-per-event pricing can map to **one opportunity row = one monetizable event**

### What it does

- fetches recent posts from `arctic-shift.photon-reddit.com`
- matches topics using aliases and ticker-aware token logic
- samples comments for lightweight confirmation / disagreement signals
- computes `confidence`, `opportunityScore`, and `rankLabel`
- enriches each row with `narrative`, `sentimentBias`, `momentumLabel`, `mentionShare`, and `supportingTickers`
- creates an executive narrative summary for the whole run
- pushes one dataset item per returned opportunity
- exposes a custom charge event name: `opportunity-found`

### Inputs

| Field | Purpose |
|---|---|
| `subreddit` | subreddit name without `/r/` |
| `postLimit` | number of recent posts to scan |
| `commentsPerPost` | number of comments sampled per matched post |
| `minConfidence` | drop weak opportunities below this threshold |
| `maxOpportunities` | cap dataset output size |
| `minPostScore` | ignore low-score posts |
| `watchlist` | boost assets you care about |

### Output shape

Each dataset item now includes fields like:

- `topic`
- `ticker`
- `narrative`
- `narrativeDescription`
- `signalLabel`
- `confidence`
- `opportunityScore`
- `rankLabel`
- `sentimentBias`
- `momentumLabel`
- `mentionShare`
- `posts`
- `engagementScore`
- `supportingTickers`
- `isOnWatchlist`
- `topPostTitle`
- `topPostUrl`
- `executiveSummary`

The run-level `summary` also includes:

- `dominantNarratives`
- `executiveSummary`
- `hotTopics`
- `watchTopics`
- `noiseTopics`

### Practical Store listing angle

Do **not** market it as “AI finds winning trades.”

Better positioning:
- Reddit narrative scanner for traders
- retail sentiment scout
- subreddit idea triage for traders and researchers
- narrative monitor for finance dashboards and newsletters

### Known limitations

- depends on Arctic Shift availability rather than official Reddit API access
- sentiment is lightweight keyword logic, not full semantic finance NLP
- no live price / fundamentals confirmation yet
- some subreddits are noisy enough that tuning `minConfidence` and `minPostScore` matters a lot

### Why teams use it

- surface the most discussed names inside one finance subreddit
- spot which narrative is gaining traction first
- turn noisy Reddit discussion into a small ranked watchlist
- feed dashboards, research workflows, or newsletter triage with structured rows instead of raw threads

### Pricing

This Actor is designed around **Pay Per Event** pricing so buyers pay for returned opportunities rather than vague AI output.

### What makes it useful

- one run returns a compact shortlist instead of a feed dump
- each item includes a source post and an executive summary
- works well for manual review, watchlist building, and downstream automation

# Actor input Schema

## `subreddit` (type: `string`):

Subreddit name without the /r/ prefix.
## `postLimit` (type: `integer`):

How many recent posts to fetch before topic matching.
## `commentsPerPost` (type: `integer`):

How many comments to inspect per matched post for confirmation/disagreement signals.
## `minConfidence` (type: `integer`):

Only topics at or above this confidence are returned as opportunities.
## `maxOpportunities` (type: `integer`):

Caps the number of ranked opportunity rows pushed to the dataset.
## `minPostScore` (type: `integer`):

Ignore posts below this Reddit score before analysis.
## `watchlist` (type: `array`):

Optional tickers or tracked topics you care about. Matching topics get a ranking boost.

## Actor input object example

```json
{
  "subreddit": "wallstreetbets",
  "postLimit": 25,
  "commentsPerPost": 12,
  "minConfidence": 40,
  "maxOpportunities": 10,
  "minPostScore": 0,
  "watchlist": [
    "NVDA",
    "AMD",
    "PLTR",
    "TSLA"
  ]
}
````

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

// Run the Actor and wait for it to finish
const run = await client.actor("fabian_projects/reddit-opportunity-scout").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 = { "watchlist": [
        "NVDA",
        "AMD",
        "PLTR",
        "TSLA",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fabian_projects/reddit-opportunity-scout").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 '{
  "watchlist": [
    "NVDA",
    "AMD",
    "PLTR",
    "TSLA"
  ]
}' |
apify call fabian_projects/reddit-opportunity-scout --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Opportunity Scout",
        "description": "Scan one finance-heavy subreddit, detect tracked tickers/themes, and return ranked hot/watch/noise opportunities for traders, researchers, and watchlist builders.",
        "version": "0.3",
        "x-build-id": "2kSXzoZbBdmq3a5g9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fabian_projects~reddit-opportunity-scout/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fabian_projects-reddit-opportunity-scout",
                "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/fabian_projects~reddit-opportunity-scout/runs": {
            "post": {
                "operationId": "runs-sync-fabian_projects-reddit-opportunity-scout",
                "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/fabian_projects~reddit-opportunity-scout/run-sync": {
            "post": {
                "operationId": "run-sync-fabian_projects-reddit-opportunity-scout",
                "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": [
                    "subreddit"
                ],
                "properties": {
                    "subreddit": {
                        "title": "Subreddit",
                        "type": "string",
                        "description": "Subreddit name without the /r/ prefix.",
                        "default": "stocks"
                    },
                    "postLimit": {
                        "title": "Recent posts to scan",
                        "minimum": 5,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many recent posts to fetch before topic matching.",
                        "default": 25
                    },
                    "commentsPerPost": {
                        "title": "Comments sampled per matched post",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many comments to inspect per matched post for confirmation/disagreement signals.",
                        "default": 12
                    },
                    "minConfidence": {
                        "title": "Minimum confidence",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only topics at or above this confidence are returned as opportunities.",
                        "default": 40
                    },
                    "maxOpportunities": {
                        "title": "Max opportunities returned",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Caps the number of ranked opportunity rows pushed to the dataset.",
                        "default": 10
                    },
                    "minPostScore": {
                        "title": "Minimum Reddit score per post",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Ignore posts below this Reddit score before analysis.",
                        "default": 0
                    },
                    "watchlist": {
                        "title": "Watchlist symbols",
                        "type": "array",
                        "description": "Optional tickers or tracked topics you care about. Matching topics get a ranking boost.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
