# Reddit Intelligence (MCP) (`scrap_them_all/reddit-intelligence-mcp`) Actor

MCP-friendly Apify Actor returning a deterministic Reddit intelligence card. Four modes: keyword\_monitor, subreddit\_intel, thread\_deep\_dive, user\_intel. Sentiment, themes, pain/praise, and an LLM-ready markdown report. No LLM calls inside, fully reproducible.

- **URL**: https://apify.com/scrap\_them\_all/reddit-intelligence-mcp.md
- **Developed by:** [scrap\_them\_all](https://apify.com/scrap_them_all) (community)
- **Categories:** Social media, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 reddit intelligence cards

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 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 Intelligence (MCP)

### What does Reddit Intelligence do?

Pass a brand keyword, a subreddit, a thread URL, or a Reddit username and get back a single structured JSON object: sentiment score, top themes, pain points, praise points, trending direction, peak activity window, influential authors, top posts, and a deterministic LLM-ready markdown report. No LLM calls inside, fully reproducible. Designed to be **called from an MCP agent loop** (Claude, Cursor, GPT, Custom agents).

> Built on Reddit's public JSON endpoints. No API key, no auth, no setup. Stable, fast, and rate-limit aware.

### Why use it from an AI agent?

- **Sub-15s runs** for the typical 25-post analysis.
- **4 modes, one schema** - the agent picks the mode and the output shape stays consistent.
- **LLM-ready summary** - the `llm_ready.summary` field is a single paragraph an agent can paste into its system prompt; `llm_ready.markdown_report` is a full digest a human can read.
- **Deterministic** - same input today, same output tomorrow (no LLM jitter, no API key burn).
- **Standby-mode HTTP server** - the actor runs as a true MCP-over-HTTP endpoint when invoked via Apify Standby, with a one-shot fallback for legacy invocation.

### Modes

#### A. Keyword Monitor

What does Reddit say about my brand / competitor / product this week?

```json
{
    "mode": "keyword_monitor",
    "keywords": ["Linear app"],
    "subreddits": ["r/SaaS", "r/startups"],
    "timeRange": "week",
    "limit": 25
}
````

#### B. Subreddit Intel

What dominates this subreddit right now?

```json
{
    "mode": "subreddit_intel",
    "subreddit": "r/SaaS",
    "sort": "top",
    "timeRange": "month",
    "limit": 50
}
```

#### C. Thread Deep Dive

Analyze a single thread - arguments, sentiment, top voices.

```json
{
    "mode": "thread_deep_dive",
    "postUrl": "https://www.reddit.com/r/SaaS/comments/<id>/title/"
}
```

#### D. User Intel

Profile a user - active subs, tone, interests.

```json
{
    "mode": "user_intel",
    "username": "spez"
}
```

### Output (all modes)

```json
{
    "meta": {
        "mode": "keyword_monitor",
        "query": "Linear app",
        "timeRange": "week",
        "postsAnalyzed": 47,
        "scrapedAt": "2026-05-08T14:22:00Z"
    },
    "intelligence": {
        "sentimentScore": 0.62,
        "sentimentLabel": "mostly_positive",
        "topThemes": ["onboarding", "pricing", "support"],
        "painPoints": ["too expensive", "docs unclear"],
        "praisePoints": ["great UX", "fast API"],
        "trendingDirection": "up",
        "peakActivity": "tuesday_evening_UTC",
        "influentialAuthors": [
            { "username": "devguru", "karma": 4520, "relevance": 0.21 }
        ]
    },
    "posts": [
        {
            "id": "abc123",
            "title": "...",
            "url": "https://reddit.com/r/...",
            "subreddit": "SaaS",
            "score": 284,
            "numComments": 67,
            "sentiment": -0.42,
            "sentimentLabel": "negative",
            "summary": "User complains about pricing jump after free tier...",
            "topComment": { "body": "...", "score": 51, "author": "..." },
            "createdUtc": 1746543240
        }
    ],
    "llm_ready": {
        "summary": "47 Reddit posts analyzed for Linear app over the last week. Overall sentiment: mostly positive (81/100). ...",
        "markdown_report": "### Reddit Intelligence Report\n#### Key findings..."
    }
}
```

### No credentials needed

This Actor calls Reddit's **public JSON endpoints** (`https://www.reddit.com/r/{sub}/hot.json`, `/search.json`, `/comments/{id}.json`, `/user/{u}/about.json`). No Reddit app, no OAuth, no approval. You just call the Actor and it works.

Behind the scenes, requests are routed through Apify's residential proxy pool because Reddit blocks unauthenticated access from datacenter IP ranges. The proxy cost is negligible per call (~50KB of Reddit JSON per request).

A future v0.2 may add optional BYOK OAuth2 for higher rate limits and zero proxy dependency when callers need to run hundreds of requests per minute.

### Pricing (PPE)

| Mode | Price per call |
| --- | --- |
| All modes | $0.001 actor start + $0.003 per post analyzed |

Example: a 25-post keyword monitor = $0.001 + 25 x $0.003 = $0.076/call. A 1-post thread deep dive = $0.001 + 1 x $0.003 = $0.004/call. Free tier: 100 posts/month.

Compare: Reddit-related Apify Actors charge $0.002-0.01 per result for raw scrape; this Actor delivers sentiment + themes + LLM-ready report at the same per-post tier.

### Calling from an MCP agent

The Apify MCP server (`mcp.apify.com`) exposes this Actor as the tool `call-actor` with name `reddit-intelligence-mcp`. Typical prompt: *"Use call-actor with reddit-intelligence-mcp to monitor Reddit for 'Linear app' over the last week."*

For a true MCP-over-HTTP integration, the Actor's Standby endpoint accepts POST requests with the same JSON schema:

```bash
curl -X POST -H 'Content-Type: application/json' \
  -d '{"mode":"subreddit_intel","subreddit":"r/SaaS","limit":10}' \
  https://<actor>.apify.actor
```

### Limits

- `limit` caps at 100 (Reddit's listing API hard limit per request).
- Sentiment is AFINN-based lexical scoring, not a transformer model. Strong on direction (positive vs negative), less precise on subtle sarcasm or domain-specific jargon.
- Themes are TF-IDF-derived bigrams and unigrams. They reflect lexical patterns in titles + comments, not semantic clusters.
- `peakActivity` is computed from the time-of-creation distribution of the analyzed posts only. For a true global peak, increase `limit` and use `timeRange: "month"`.

### Sources, freshness, legality

- All data comes from Reddit's public JSON endpoints at `www.reddit.com/<path>.json`. No HTML scraping, no Pushshift.
- The Actor exposes only public Reddit content. No personal DMs, no private subreddit content.
- User-Agent identifies the actor with a descriptive string (per Reddit's documented best practice for unauthenticated access).

# Actor input Schema

## `mode` (type: `string`):

Pick one of the four intelligence modes. Each mode requires a different subset of the fields below.

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

Required for keyword\_monitor. Free-text terms to search across Reddit (e.g. 'Linear app', 'Notion'). Each keyword runs as a separate query and results are merged.

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

Optional for keyword\_monitor. Restrict the search to these subreddits. 'r/SaaS' or 'saas' both work. Empty = search all of Reddit.

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

Required for subreddit\_intel. Single subreddit to analyze (e.g. 'r/SaaS' or 'saas').

## `sort` (type: `string`):

Listing order. 'top' + a timeRange gives the strongest signal.

## `timeRange` (type: `string`):

Reddit time filter. 'week' is the sweet spot for fresh-but-stable signal.

## `limit` (type: `integer`):

Max posts to fetch and analyze. Caps at 100 (Reddit listing API hard limit per request).

## `postUrl` (type: `string`):

Required for thread\_deep\_dive. Full Reddit post URL ('https://www.reddit.com/r/SaaS/comments/abc123/...') or bare post ID ('abc123'). If bare ID, also pass 'subreddit'.

## `username` (type: `string`):

Required for user\_intel. Reddit username without 'u/' prefix (e.g. 'spez').

## Actor input object example

```json
{
  "mode": "keyword_monitor",
  "sort": "top",
  "timeRange": "week",
  "limit": 25
}
```

# Actor output Schema

## `card` (type: `string`):

No description

## `dataset` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrap_them_all/reddit-intelligence-mcp").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrap_them_all/reddit-intelligence-mcp").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 '{}' |
apify call scrap_them_all/reddit-intelligence-mcp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Intelligence (MCP)",
        "description": "MCP-friendly Apify Actor returning a deterministic Reddit intelligence card. Four modes: keyword_monitor, subreddit_intel, thread_deep_dive, user_intel. Sentiment, themes, pain/praise, and an LLM-ready markdown report. No LLM calls inside, fully reproducible.",
        "version": "0.1",
        "x-build-id": "Wru403juzw5jQYZQg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrap_them_all~reddit-intelligence-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrap_them_all-reddit-intelligence-mcp",
                "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/scrap_them_all~reddit-intelligence-mcp/runs": {
            "post": {
                "operationId": "runs-sync-scrap_them_all-reddit-intelligence-mcp",
                "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/scrap_them_all~reddit-intelligence-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-scrap_them_all-reddit-intelligence-mcp",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "keyword_monitor",
                            "subreddit_intel",
                            "thread_deep_dive",
                            "user_intel"
                        ],
                        "type": "string",
                        "description": "Pick one of the four intelligence modes. Each mode requires a different subset of the fields below.",
                        "default": "keyword_monitor"
                    },
                    "keywords": {
                        "title": "Keywords (mode A)",
                        "type": "array",
                        "description": "Required for keyword_monitor. Free-text terms to search across Reddit (e.g. 'Linear app', 'Notion'). Each keyword runs as a separate query and results are merged.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "subreddits": {
                        "title": "Subreddits filter (mode A, optional)",
                        "type": "array",
                        "description": "Optional for keyword_monitor. Restrict the search to these subreddits. 'r/SaaS' or 'saas' both work. Empty = search all of Reddit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "subreddit": {
                        "title": "Subreddit (mode B)",
                        "type": "string",
                        "description": "Required for subreddit_intel. Single subreddit to analyze (e.g. 'r/SaaS' or 'saas')."
                    },
                    "sort": {
                        "title": "Sort (modes A, B)",
                        "enum": [
                            "hot",
                            "new",
                            "top",
                            "rising",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Listing order. 'top' + a timeRange gives the strongest signal.",
                        "default": "top"
                    },
                    "timeRange": {
                        "title": "Time range (modes A, B)",
                        "enum": [
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Reddit time filter. 'week' is the sweet spot for fresh-but-stable signal.",
                        "default": "week"
                    },
                    "limit": {
                        "title": "Posts to analyze (modes A, B)",
                        "minimum": 5,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Max posts to fetch and analyze. Caps at 100 (Reddit listing API hard limit per request).",
                        "default": 25
                    },
                    "postUrl": {
                        "title": "Post URL or ID (mode C)",
                        "type": "string",
                        "description": "Required for thread_deep_dive. Full Reddit post URL ('https://www.reddit.com/r/SaaS/comments/abc123/...') or bare post ID ('abc123'). If bare ID, also pass 'subreddit'."
                    },
                    "username": {
                        "title": "Username (mode D)",
                        "type": "string",
                        "description": "Required for user_intel. Reddit username without 'u/' prefix (e.g. 'spez')."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
