# Reddit Scraper - Monitoring, Signals & Attention Queue (`ryanclinton/reddit-scraper`) Actor

Scrapes Reddit and returns a ranked attention queue: brand monitoring, mention tracking, sentiment analysis, and breakout detection in one run. Drop-in compatible with existing Reddit scraper workflows. $0.002 per record.

- **URL**: https://apify.com/ryanclinton/reddit-scraper.md
- **Developed by:** [Ryan Clinton](https://apify.com/ryanclinton) (community)
- **Categories:** Social media, News, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Scraper - Monitoring, Signals & Attention Queue

![Reddit Scraper - stop reading Reddit rows, start tracking what changed](https://apifyforge.com/readme-assets/ryanclinton-reddit-scraper/hero.png)

### In one sentence

Reddit Scraper is a Reddit monitoring and attention-routing engine that searches public Reddit posts, comments, communities, and users and returns a ranked attention queue of what changed, what matters, and what needs a look right now.

**Category:** Reddit monitoring tool. Reddit mention tracker. Reddit sentiment analysis actor.
**Primary use case:** Track a brand or keyword across Reddit and get back the few threads that need attention now, ranked, with a reason and a recommended action on each. Can also be used for trend discovery, community research, search reranking, and drop-in row scraping.

**Also known as:** Reddit scraper, Reddit brand monitoring, Reddit mention tracking, Reddit sentiment signals, Reddit attention queue, subreddit monitor.

#### What you want to know → what Reddit Scraper tells you

| You want to know | Reddit Scraper tells you | Field |
|---|---|---|
| Is Reddit talking about us more? | Mention spike vs baseline | `signalEvents` → `mention_spike` |
| Is sentiment changing? | Sentiment shift, with evidence | `signalEvents` → `sentiment_shift` |
| Which threads matter most? | Ranked attention queue | `attentionIndex`, `watchStatus` |
| Is this getting worse or better? | Direction + volatility | `signalTrajectory` |
| Is this recurring or structural? | Recurrence class + history | `persistentSignal`, `narrativeMemory` |
| What changed since last run? | Delta since last comparison | `stateTransition`, delta arrays |
| What did you ignore, and why? | Suppressed-noise audit | `suppressedSignals`, `trustDiagnostics` |

### What this actor does

- **What it is:** the first operational Reddit intelligence layer of its kind on the Store. It scrapes public Reddit and adds a decision layer on top of the rows.
- **What it checks:** breakout posts, mention spikes, sentiment shifts, topic surges, community acceleration, and author momentum, each as a typed, evidenced signal.
- **What it returns:** a sortable `attentionIndex` (0-100), a `watchStatus`, plain-English `whyNow` reasons, a `recommendedAction`, and the full substrate fields a standard Reddit scraper emits.
- **What it does NOT do:** it never logs in, never reads private content, and performs no in-Reddit actions (no posting, replying, voting, or DMing). It is not a brand-safety or controversy scorer.
- **Who it's for:** brand and social teams, PR and comms, market researchers, trend and VC scouts, AI/RAG teams, competitor analysts.

Reddit Scraper functions as a Reddit signals API rather than a row dumper. Where a plain Reddit scraper hands back thousands of flat post, comment, community, and user records and leaves you to read every one, Reddit Scraper detects breakout posts, mention spikes, and sentiment shifts, deduplicates threads, and ranks the output so the first rows are the ones worth opening. Its moat is persistent operational memory: when you name a watchlist and run on a schedule, state compounds across runs and surfaces what changed since last time, the kind of longitudinal context that cannot be backfilled from a single scrape.

**What it does** — searches public Reddit and returns a ranked attention queue with reasons and a recommended action per record.
**Best for** — brand monitoring, mention tracking, sentiment shift detection, trend discovery, search reranking.
**Speed** — first results in about 60 seconds for a single-brand monitor run.
**Pricing** — $0.002 per record ($2 / 1,000), roughly half the incumbent row scraper's per-result cost; $0.20 per monitor or search query; the signal layer is included.
**Output** — JSON with `attentionIndex`, `watchStatus`, `whyNow`, `recommendedAction` plus full substrate fields.

**Key limitation:** delta, trajectory, and topic-memory fields are maturity-gated. Run 1 shows `first-run` / `building` status and empty delta arrays; they sharpen after several scheduled runs on the same watchlist.
**What it is not:** Not a logged-in scraper, not a brand-safety scorer, and not a replacement for Reddit's official API for write actions.
**Does not include:** in-Reddit actions, private or authenticated content, cross-community propagation mapping (a future capability), and LLM-generated narratives.
**Results may be incomplete when:** subreddits are private or unavailable, Reddit's ~1,000-item list cap is hit, or requests are rate-limited. The `coverage` block reports exactly what was and was not scanned.

**Workflow roles:** brand-monitoring feed, PR early-warning, trend-discovery scout.
Use Reddit Scraper whenever an AI agent or a human needs to evaluate Reddit activity, not just retrieve Reddit rows.

### What you get from one call

**Input:** `{ "mode": "monitor", "track": ["Notion"] }`
**Returns:**
- A ranked attention queue: the top threads about Notion, ordered by `attentionIndex`.
- A `watchStatus` and `whyNow` on each record (for example, on a "Notion just changed its pricing again" thread: "Upvote velocity 9x community baseline within 12h" + "Sentiment on Notion shifted negative over the last 7 days").
- A `recommendedAction` per record (for example, "Review this thread within 3 days").
- Deterministic comment sentiment and theme synthesis when comment sampling is on.
- A run summary with a `dailyBriefing`, `portfolioState`, `coverage`, and a `publicDataCompliance` block.

**Typical time to first result:** about 60 seconds for a single-brand monitor run.
**Typical time to integrate:** under 30 minutes for an existing Reddit-scraper workflow, since the input shape is drop-in compatible.

![The Reddit Scraper intelligence stack: from a brand or keyword to a ranked attention queue](https://apifyforge.com/readme-assets/ryanclinton-reddit-scraper/intelligence-layers.png)

### What makes this different

- **Attention queue, not a row dump** — every run starts ordered by what to look at first, with a reason and a recommended action on each record, instead of thousands of flat rows you read by hand.
- **Persistent operational memory** — name a watchlist and state compounds across runs, surfacing what changed since the last run. This is the part a competitor cannot backfill from a single scrape.
- **Deterministic, no-LLM synthesis** — sentiment and theme clustering use a fixed lexicon and TF-IDF (`lexicon-tfidf-v1`), so every result re-runs byte-identical and is fully auditable, with no probabilistic drift and no external model dependency.

If you were building this yourself, you would need to scrape Reddit, compute community baselines, detect breakouts and mention spikes, run deterministic sentiment, persist per-term state across runs, and rerank, then keep all of it versioned and reproducible.

It functions as a Reddit signals API, producing scored, decision-ready records, useful for brand monitoring, PR early-warning, and trend discovery.

### Reddit Scraper models state evolution, not snapshots

A traditional Reddit scraper answers one question: what exists right now. Reddit Scraper answers what changed, what accelerated, what stabilised, what is recurring, and what needs attention now. Signals are the ingredients; the run-over-run state evolution is the product. That is why a single scrape cannot reproduce its output and why the value compounds the longer you run it on a watchlist.

### Before vs after

**Before:** Scrape 2,000 Reddit posts mentioning your brand, dump them to a spreadsheet, read every row, eyeball sentiment by hand. Hours per week, every week.
**After:** Run `monitor` mode once, read the top five rows of the attention queue, act on the ones flagged `urgent` or `critical`. Minutes per day.

### What Reddit Scraper replaces

Instead of:
- scraping Reddit into spreadsheets and reading rows by hand
- eyeballing sentiment thread by thread
- comparing this week's export against last week's by hand
- writing and maintaining custom Reddit monitoring scripts
- paying for a general social-listening suite to cover Reddit

Reddit Scraper automatically:
- detects mention spikes and sentiment shifts, with evidence
- ranks attention-worthy threads into one queue
- tracks what changed between runs
- suppresses duplicate-crosspost noise and shows you what it ignored
- builds persistent monitoring memory that compounds over time

**In short:** it replaces the manual Reddit-triage workflow, not just the scraper that feeds it.

### Quick answers

**What is it?** Reddit Scraper is a Reddit monitoring and attention-routing engine. It scrapes public Reddit and returns a ranked attention queue with a reason and a recommended action per record.

**How do I monitor a brand on Reddit?** Run `monitor` mode with your brand or keyword in `track`. You get back the threads that need attention now, ranked by a sortable `attentionIndex`, each with `whyNow` and a `recommendedAction`.

**What makes it different?** It ships decisions, not just rows, and its persistent operational memory compounds across scheduled runs to show what changed, which a single scrape cannot reconstruct.

**What data sources does it use?** Public Reddit posts, comments, communities, and users only. No login, no private content, no Reddit write actions.

**What does it return?** A sortable `attentionIndex` (0-100), a `watchStatus`, `whyNow` reasons, a `recommendedAction`, and the full substrate fields a standard Reddit scraper emits.

**How much does it cost?** $0.002 per record ($2 per 1,000) plus $0.20 per monitor or search query. The signal layer is included; monitoring adds no extra per-record cost.

**Is it deterministic?** Yes. Sentiment and themes use a fixed lexicon and TF-IDF, so every run reproduces byte-identical results.

### Reddit Scraper at a Glance

**Quick facts:**
- **Input:** a brand or keyword (`track`), subreddits (`communities`), post URLs, usernames, or a search query.
- **Output:** `attentionIndex`, `watchStatus`, `whyNow`, `recommendedAction`, plus full substrate fields (`title`, `url`, `upVotes`, `numberOfComments`, `communityName`, `body`).
- **Pricing:** $0.002 per record; $0.20 per monitor/search query.
- **Batch size:** up to 1,000 records per run (Reddit's platform-wide list cap; use scheduled monitor runs to capture beyond it incrementally).
- **Modes:** monitor, communities, posts, users, search.
- **Output profiles:** signals (default), compat (drop-in substrate), agent (compact decisions), minimal (IDs only).
- **Determinism:** every result re-runs byte-identical (no external LLM).
- **Compliance:** public-content-only, no login, no in-Reddit actions.

**Input -> Output:**
- Input: a brand, keyword, subreddit, post URL, username, or search query.
- Process: scrape public Reddit, detect typed signals, score, rank, and (in monitor mode) diff against persisted state.
- Output: a ranked attention queue of decision-ready records plus a run summary.

**Best fit:** brand and product mention tracking, PR issue detection, trend and topic discovery, community momentum research, search reranking, drop-in migration from a row scraper.
**Not ideal for:** logged-in or private content, real-time webhook alerting (use scheduling), brand-safety or toxicity scoring, write actions on Reddit.
**Does not include:** in-Reddit actions, private content, cross-community propagation mapping, LLM-generated prose.

**Problems this solves:**
- How to track brand mentions across Reddit without reading every row.
- How to catch a brewing PR issue on Reddit before it blows up.
- How to find emerging Reddit topics and shifting opinion.
- How to know what changed on Reddit since your last check.

**Data trust:** all data is scraped from public Reddit. Delta, trajectory, and memory fields are maturity-gated and stay `null` or `building` until enough scheduled runs accumulate. The actor never fabricates history; the `coverage` and `historicalProfile` blocks state exactly how much it knows.

### Best fit / Less suitable

**Best fit:**
- Brand and social teams running a daily mention-tracking feed across several subreddits.
- PR and comms teams that need a sentiment shift or mention spike surfaced early, with evidence.
- Researchers and trend scouts watching topic surges and community acceleration over weeks.

**Less suitable:**
- Reading private, deleted, or quarantined content. Reddit Scraper reads public content only.
- Real-time second-by-second alerting. Schedule monitor runs instead (daily or hourly).
- Judging whether a post is "problematic." `contested_thread` is a descriptive engagement-divergence signal, not a controversy or safety call.

**Scope disclaimer:** Reddit Scraper is a read-only public-monitoring actor. It does not perform any in-Reddit action, and it does not score brand safety or toxicity. (Field-by-field definitions are in the Definitions section below.)

### What is a Reddit monitoring tool?

A Reddit monitoring tool watches Reddit over time for changes that matter to you (mentions, sentiment, emerging topics) and tells you what needs attention, rather than just exporting rows. Most Reddit actors on the Store stop at extraction; Reddit Scraper adds the interpretation, ranking, and run-over-run state that turns a scrape into a monitoring feed.

### Why Reddit monitoring is hard

Reddit monitoring is harder than it looks, which is why most tools stop at extraction:

- Reddit lists cap at roughly 1,000 items, so a single scrape can silently miss the rest.
- Communities behave differently. A spike that matters in a 20k-member subreddit is noise in a 2M-member one.
- Viral spikes create noisy false positives. One crosspost duplicated across communities looks like a trend.
- Sentiment shifts are usually gradual, not a single dramatic post, so they hide in the row dump.
- Most tools forget every prior run completely, so they can never tell you whether something is recurring or structural.

Reddit Scraper solves these with community-relative baselines, deterministic scoring, duplicate-crosspost suppression with a trust audit, and persistent operational memory that accumulates state across scheduled runs. That last piece is why a competitor cannot replicate the output by scraping the same data tomorrow.

### Common Reddit monitoring problems

#### Reddit exports too many rows
Traditional Reddit scrapers export thousands of rows with no prioritisation. Reddit Scraper returns a ranked attention queue instead, so the first rows are the ones worth opening.

#### Reddit sentiment changes slowly
Most Reddit issues emerge gradually across comments and communities, not in one dramatic post. Reddit Scraper tracks sentiment shifts across runs and surfaces the trend before it is obvious.

#### Reddit spikes create false positives
Crossposts and viral reposts duplicate the same content across communities and look like a trend. Reddit Scraper suppresses duplicate-crosspost artifacts and exposes exactly what it ignored in `trustDiagnostics`.

#### Most monitoring tools forget prior runs
A one-shot scrape cannot tell you whether an issue is new or recurring. Reddit Scraper persists operational memory per watchlist, so recurring narratives and structural issues are detected over time via `persistentSignal` and `narrativeMemory`.

### What data can you extract?

| Data Point | Source | Availability | Example |
|---|---|---|---|
| **Post title** | Public post | Always | "Notion just changed its pricing again" |
| **Up votes** | Public post | Always | 1,842 |
| **Number of comments** | Public post | Always | 326 |
| **Community name** | Post / community | Always | r/Notion |
| **Comment body** | Public comment | When comments sampled | "The new plan is way too expensive" |
| **User karma** | Public profile | Users mode | postKarma 4, commentKarma 10 |
| **Attention index** | Computed | signals profile | 78 |
| **Watch status** | Computed | signals profile | attention-required |
| **Why now** | Computed | signals profile | "Upvote velocity 9x baseline within 12h" |
| **Comment sentiment** | Computed (deterministic) | When comments sampled | positive 0.41, negative 0.33 |
| **Comment themes** | Computed (deterministic) | When comments sampled | Pricing complaints (weight 0.34) |
| **Signal profile** | Computed | Community records | emerging |

![Four features: ranked not dumped, tracks recurrence, quiet when it's quiet, shows what it ignored](https://apifyforge.com/readme-assets/ryanclinton-reddit-scraper/feature-callouts.png)

### Why use Reddit Scraper?

**Before:** scraping Reddit for brand mentions ends the same way for every team: a spreadsheet, read row by row, sentiment eyeballed by hand, every day. The bottleneck in 2026 is not getting Reddit data, it is operationalising it fast enough.

Reddit Scraper closes that gap in one run. Instead of 2,000 rows you triage by hand, you get the threads that need attention now, ranked, with a reason and a recommended action on each. The real competitor here is not another scraper; it is the spreadsheet workflow that sits downstream of one.

**Key difference:** a plain Reddit scraper hands you rows and stops. Reddit Scraper hands you decisions and remembers what it told you last run.

**The monitoring workflow, step by step.** A row scraper does step one and leaves the rest to you:

| Workflow step | Standard Reddit scraper | Reddit Scraper |
|---|---|---|
| Scrape posts and comments | Yes | Yes |
| Detect breakout threads | Manual | Automatic |
| Detect sentiment shifts | Manual | Automatic |
| Rank what matters | Manual | Automatic |
| Compare against prior runs | Manual | Automatic |
| Suppress duplicate-crosspost noise | Manual | Automatic |
| Build persistent memory of recurring issues | Impossible | Built in |
| Read thousands of rows by hand | Required | Replaced |

The grounded feature comparison against the incumbent:

| Feature | Reddit Scraper | trudax/reddit-scraper-lite |
|---|---|---|
| Public Reddit substrate (posts, comments, communities, users) | Yes | Yes |
| Ranked attention queue (`attentionIndex`) | Yes | Not a feature |
| Mention spike + sentiment shift detection | Yes | Not a feature |
| Deterministic comment sentiment + theme synthesis | Yes (no LLM) | Not a feature |
| Breakout + topic-surge detection | Yes | Not a feature |
| Persistent monitoring state across runs | Yes | Not a feature |
| Search reranking (`breakoutPotential`, `momentum`) | Yes | Native sort only |
| Drop-in compatible input + substrate fields | Yes (`compat` profile) | n/a |
| Per-result price | $0.002 / record ($2 / 1k) | ~$0.004 / result (~$4 / 1k) |
| Free-tier headroom ($5 credits) | ~2,500 records | ~1,250 results |

*Pricing and features based on publicly available information as of May 2026 and may change. Re-verify the incumbent's live price before relying on the comparison.*

Unlike a row scraper, which is built to export everything and let you sort it out, Reddit Scraper is built for automation-first monitoring workflows where the first rows are the ones that matter.

### Platform capabilities

- **Scheduling** — run monitor mode daily or hourly with the same `watchlistName` to build a persistent Reddit feed.
- **API access** — trigger from Python, JavaScript, or any HTTP client via the Apify API.
- **Proxy rotation** — Apify residential proxies by default, with conservative rate limits and a circuit breaker on consecutive blocks.
- **Monitoring** — Slack or email alerts when runs fail, via Apify integrations.
- **Integrations** — Zapier, Make, Google Sheets, webhooks, and MCP/agent consumers via the `agent` output profile.

### The five modes

Each mode produces one buyer-facing outcome.

| Mode | One-line outcome |
|---|---|
| **monitor** (hero) | "These Reddit threads about your brand need attention right now." Track a brand or keyword over time; name a watchlist to build a feed of only what changed. |
| **communities** | "These subreddits, ranked by what's heating up." Scan communities, each tagged with a signal profile. |
| **posts** | "Here's what's notable about each thread." Analyse post URLs; each carries `whyThisMatters` plus comment-theme synthesis. |
| **users** | "This author is gaining momentum." Surface posting and karma velocity per user. |
| **search** | "Of 500 posts matching this query, these 4 are popping." Rerank search results by breakout potential, momentum, or attention. |

### Reddit Monitoring Features

Reddit Scraper layers a deterministic signal engine and a persistent state engine on top of a drop-in Reddit substrate. Signals are typed and evidenced, scoring is bounded so no single component dominates, and every version constant is pinned so a run is reproducible and auditable.

**Signal detection**
- **Eight typed signal events** — `breakout_post`, `community_acceleration`, `community_deceleration`, `topic_surge`, `sentiment_shift`, `mention_spike`, `author_emergence`, `contested_thread`. Each carries `signalStrength` (heuristic 0-1), `evidenceGrade` (weak/moderate/strong), a `decayStatus` (fresh/active/fading/expired), and an `evidence` object with the underlying z-scores and windows.
- **Eight community signal profiles** — `emerging`, `breakout`, `stable-authority`, `viral-fragile`, `high-engagement-niche`, `decelerating`, `dormant`, `unclassified`, with strength and plain-English evidence.
- **Suppressed signals** — signals that fired but were judged noise are surfaced with a reason and a `noiseRisk`, never silently dropped, so you can see what the actor ignored across communities.

**Decision and routing**
- **attentionIndex (0-100)** — the single sortable composite, with a `breakdown` audit trail and top-3 paste-ready `drivers`.
- **watchStatus** — the routing primitive to branch on (`no-action`, `monitor`, `attention-required`, `urgent`, `critical`).
- **whyNow + recommendedAction** — plain-English reasons plus a prioritisation instruction (Review, Read, Monitor, Track, Re-check, Compare, Investigate), never an in-Reddit engagement instruction.
- **agentContract + agentDecision** — a compact decision surface (`review_now` / `monitor` / `ignore`) for MCP, AI-agent, and RAG consumers.

**Comment intelligence (deterministic, no LLM)**
- **Sentiment** — positive/negative/neutral with a `confidenceBand` that scales with sample size, via a fixed lexicon.
- **Themes** — TF-IDF clustering mapped to a fixed theme dictionary (stable `themeCode` enum), with keywords and example comment IDs.

**Persistent state (monitor mode)**
- **signalTrajectory** — direction, velocity, stability, phase, and `trajectoryClass` in one block. Maturity-gated to `unknown` until 3+ runs.
- **persistentSignal** — recurrence classification (`transient`, `recurring`, `persistent`, `cyclical`, `dormant`) from accumulated state.
- **narrativeMemory** — cross-run topic memory with historical peaks and cycle length; advanced fields stay `null` until enough cycles exist.
- **stateTransition + changeFlags** — what changed since the last run (`NEW_BREAKOUT`, `MENTION_SPIKE`, `SENTIMENT_DOWN`, `SIGNAL_EXPIRED`).

**Run summary and trust**
- **dailyBriefing + portfolioState** — a morning brand-monitoring surface and a CIO-glance over the run.
- **runOutcome** — a quiet-mode status (`quiet` / `active` / `high-activity`) so a monitor that says "nothing fired" is trusted when it does fire.
- **coverage** — requested vs scanned communities, typed skip reasons, and a `coverageStatus`.
- **publicDataCompliance** — a machine-readable read-only posture with `inRedditActionsPerformed` hard-wired to `false`.
- **trustDiagnostics + runManifest** — suppression counts, dedup counts, coverage confidence, and every pinned version constant for audit.

### Use cases for Reddit monitoring

#### Reddit monitoring for product marketing
Use when you need to know how Reddit is talking about your product this week. Set `mode: monitor`, put your brand in `track`, name a `watchlistName`, and schedule daily. PMM teams use Reddit Scraper to surface mention spikes and recurring complaint narratives without reading every thread. Key outputs: `attentionIndex`, `whyNow`, `signalEvents`, `commentIntelligence`.

#### Reddit monitoring for PR teams
Use when a brewing issue needs to be caught before it blows up. Set `persona: pr-comms` so sentiment shifts and mention spikes escalate immediately, with evidence on each. Key outputs: `watchStatus`, `attentionWindow`, `signalTrajectory`, `changeFlags`.

#### Reddit monitoring for researchers and trend scouts
Use when you are scouting which topics or communities are accelerating before they are obvious. Set `persona: trend-research` and `rankBy: breakoutPotential`. Key outputs: `signalProfile`, `topic_surge` events, `communityHealth`, `narrativeConcentration`.

#### Reddit monitoring for competitor analysis
Use when you track how a community discusses rivals over time. Schedule monitor runs and read the run-over-run delta to see what shifted. Key outputs: `signalTrajectory`, `persistentSignal`, `stateTransition`, `portfolioState`.

#### Reddit monitoring for investors and scouts
Use when you want to spot a community or product narrative accelerating early. Schedule weekly monitor runs on a watchlist; `signalTrajectory` and `persistentSignal` tell you whether momentum is building or fading and whether an issue is recurring. Key outputs: `signalTrajectory`, `persistentSignal`, `narrativeMemory`, `communityHealth`.

#### Reddit monitoring for AI agents and RAG pipelines
Use when an agent or pipeline needs Reddit content with quality and sentiment signals attached. Set `outputProfile: agent` for a compact, deterministic decision surface, or `signals` for the full envelope. Key outputs: `agentContract`, `commentIntelligence`, `attentionIndex`, `materiality`.

### When to use Reddit Scraper

**Best for:**
- Daily brand monitoring across 5-10 subreddits with a named watchlist.
- Weekly trend and competitor research that compares against the prior run.
- Search reranking across hundreds of results to surface what is popping.
- Migrating an existing Reddit-scraper workflow to a cheaper, signal-rich substrate.

**Not ideal for:**
- Logged-in or private content. Reddit Scraper reads public content only.
- Real-time alerting. Schedule monitor runs (hourly or daily) instead.
- Brand-safety or toxicity scoring. Use a dedicated content-moderation tool.

### How to monitor a brand on Reddit

1. **Enter your brand or keyword** — set `mode` to `monitor` and add your term to `track`, for example `["Notion"]`. Add subreddits in `communities` to focus the scan.
2. **Configure options** — name a `watchlistName` to persist state across runs (leave empty for a one-shot run). Defaults cover most cases: `rankBy: attention`, `persona: brand-monitoring`.
3. **Run the actor** — click Start. A single-brand monitor run returns first results in about 60 seconds.
4. **Download results** — open the Attention Queue view, or export JSON, CSV, or Excel from the Dataset tab.

### First run tips

- **Start with the monitor demo** — leave the fields at their defaults to run the built-in `track: ["Notion"]` example and see the attention queue before pointing it at your own brand.
- **Run 1 will not show deltas** — `historicalProfile` reports `first-run` and delta arrays are empty by design. Schedule a second run with the same `watchlistName` to start the memory clock; it cannot be backfilled.
- **Turn on comment sampling for sentiment** — set `includeCommentsSample: true` to unlock `commentIntelligence` (sentiment shift detection needs sampled comments).
- **Name your watchlist** — without `watchlistName`, the run is one-shot with no persistence and no delta intelligence.
- **Test small** — keep `maxResults` low (for example 50) for your first run before scaling up.

### Typical performance

Observed in internal testing (May 2026, small sample). Reddit is rate-limited and client-rendered, so figures vary by mode, depth, and proxy conditions.

| Metric | Typical value |
|---|---|
| Records per run | up to 1,000 (Reddit list cap) |
| Run time (single-brand monitor) | ~60-120 seconds |
| Run time (multi-community deep scan) | several minutes |
| First result latency | ~60 seconds |
| Cost per 1,000 records | $2.00 + $0.20 per query |

### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `mode` | string | No | `monitor` | Entry point: `monitor`, `communities`, `posts`, `users`, `search`. |
| `track` | array | No | `["Notion"]` | Monitor mode: brand names or keywords to track across Reddit. |
| `communities` | array | No | `[]` | Subreddits to scan or monitor (`r/Notion`, `Notion`, or a URL). |
| `posts` | array | No | `[]` | Posts mode: Reddit post permalinks to analyse. |
| `users` | array | No | `[]` | Users mode: usernames or profile URLs. |
| `searchQuery` | string | No | `""` | Search mode: keyword or phrase to search and rerank. |
| `searchType` | string | No | `posts` | Search mode target: `posts`, `communities`, `users`. |
| `rankBy` | string | No | `attention` | Ordering axis: `attention`, `breakoutPotential`, `momentum`, `engagement`, `recency`, `relevance`. |
| `watchlistName` | string | No | `""` | Name a watchlist to persist state across runs and unlock delta intelligence. |
| `deltaWindowDays` | integer | No | `7` | Window for run-over-run change detection. |
| `persona` | string | No | `brand-monitoring` | Reshapes materiality weights: `brand-monitoring`, `trend-research`, `community-discovery`, `pr-comms`, `generic`. |
| `includeCommentsSample` | boolean | No | `false` | Sample comments and run deterministic theme + sentiment synthesis. |
| `commentsSamplePerPost` | integer | No | `100` | Comments sampled per post (raises sentiment confidence band). |
| `outputProfile` | string | No | `signals` | `signals` (full), `compat` (drop-in substrate), `agent` (compact decisions), `minimal` (IDs only). |
| `analysisDepth` | string | No | `standard` | Coverage/runtime tradeoff: `fast`, `standard`, `deep`. |
| `explainability` | string | No | `standard` | Verbosity: `standard` (decision surface) or `full` (all evidence blocks). |
| `maxResults` | integer | No | `100` | Hard cap on records emitted (max 1,000). |
| `maxPostsPerCommunity` | integer | No | `100` | Per-community post cap. |
| `maxRecentItems` | integer | No | `50` | Users mode: recent posts/comments per user. |
| `sort` | string | No | `hot` | Reddit listing/search sort. |
| `time` | string | No | `month` | Time window for top/search sorts. |
| `includeNSFW` | boolean | No | `false` | Include over-18 communities/posts. |
| `maxRuntimeSeconds` | integer | No | `3600` | Runtime budget; emits partial results plus a summary before timeout. |
| `startUrls` | array | No | `[]` | Compatibility alias: paste post/user/community URLs from an existing workflow. |
| `searches` | array | No | `[]` | Compatibility alias for keyword search. |
| `searchCommunityName` | string | No | `""` | Compatibility alias: restrict search to one community. |
| `proxyConfiguration` | object | No | residential | Proxy settings; residential recommended for Reddit. |

#### Input examples

- **Monitor a brand (hero):** `{ "mode": "monitor", "track": ["Notion"], "rankBy": "attention" }`
- **Daily brand feed with persistence:** `{ "mode": "monitor", "track": ["Notion", "Obsidian"], "communities": ["r/productivity", "r/Notion"], "watchlistName": "notion-brand", "deltaWindowDays": 7, "persona": "pr-comms", "includeCommentsSample": true }`
- **Drop-in migration (compat):** `{ "startUrls": [{ "url": "https://www.reddit.com/r/Notion/" }], "outputProfile": "compat", "maxResults": 200 }`

#### Input tips

- **Start with defaults** — the default monitor mode covers most first runs.
- **Name a watchlist for monitoring** — `watchlistName` is what unlocks delta intelligence; without it the run is one-shot.
- **Use the compat profile to verify migration** — `outputProfile: compat` returns the exact substrate field set with no signal fields.
- **Sample comments for sentiment** — `includeCommentsSample: true` is required for sentiment shift detection.

### Output example

```json
{
  "schemaVersion": "1.0",
  "recordType": "post",
  "eventId": "t3_144w7sn",
  "attentionIndex": {
    "value": 78,
    "breakdown": { "activeSignals": 22, "mentionSpike": 18, "sentimentShift": 14, "breakoutStrength": 16, "communityMomentum": 8 },
    "drivers": [
      "Breakout post: upvote velocity 9x community baseline within 12h.",
      "Mention volume up 3x vs 30-day baseline.",
      "Sentiment shifted negative (-0.22) over 7 days."
    ]
  },
  "watchStatus": "attention-required",
  "whyNow": [
    "Breakout post detected 12h ago, upvote velocity 9x community baseline.",
    "Sentiment on 'Notion' shifted negative over the last 7 days."
  ],
  "agentDecision": "review_now",
  "recommendedAction": "Review this thread within 3 days.",
  "attentionWindow": { "urgency": "high", "recommendedReviewWithinHours": 24 },
  "attentionPriority": "high",
  "communityName": "r/Notion",
  "signalEvents": [
    {
      "type": "breakout_post",
      "signalStrength": 0.91,
      "active": true,
      "firstDetectedAt": "2026-05-21T09:00:00Z",
      "peakAt": "2026-05-20T15:00:00Z",
      "daysSincePeak": 1,
      "decayStatus": "fresh",
      "evidenceGrade": "strong",
      "reason": "Upvote velocity 9.2x subreddit p90 within 12h of posting.",
      "evidence": { "postId": "t3_144w7sn", "upvoteZScore": 4.1, "ageHours": 12, "communityP90": 4200 }
    }
  ],
  "commentIntelligence": {
    "status": "full",
    "method": "lexicon-tfidf-v1",
    "sampleSize": 100,
    "sentiment": { "positive": 0.41, "negative": 0.33, "neutral": 0.26, "confidenceBand": "medium" },
    "themes": [
      { "themeCode": "pricing_complaints", "label": "Pricing complaints", "weight": 0.34, "keywords": ["price", "expensive", "plan"], "exampleCommentIds": ["t1_x", "t1_y"] }
    ],
    "audienceSignals": ["Comments referencing professional/team use."],
    "limitations": ["Theme labels are deterministic keyword labels, not generated summaries."]
  },
  "signalTrajectory": {
    "direction": "accelerating",
    "velocity": 0.81,
    "stability": 0.22,
    "phase": "expansion",
    "trendDurationDays": 12,
    "trajectoryClass": "emerging-risk"
  },
  "title": "Notion just changed its pricing again",
  "url": "https://www.reddit.com/r/Notion/comments/144w7sn/",
  "upVotes": 1842,
  "numberOfComments": 326,
  "dataType": "post"
}
````

![Sample Reddit Scraper output: a ranked attention queue with watch status and recommended action per row](https://apifyforge.com/readme-assets/ryanclinton-reddit-scraper/output-table.png)

### Definitions

- **Attention queue** — a ranked list of Reddit threads ordered by operational importance, not by date or raw upvotes.
- **Attention index** — a bounded 0-100 composite score for how worth reviewing a Reddit thread is right now.
- **Watch status** — the routing state for a record: `no-action`, `monitor`, `attention-required`, `urgent`, or `critical`.
- **Persistent operational memory** — cross-run Reddit monitoring state that accumulates over time and cannot be reconstructed from a single scrape.
- **Signal trajectory** — whether a narrative is accelerating, rising, stable, fading, or volatile.
- **Persistent signal** — a recurring signal classified as transient, recurring, persistent, cyclical, or dormant from accumulated history.
- **Suppressed signal** — a signal that fired but was filtered as noise, surfaced with its reason rather than silently dropped.

### Output fields

| Field | Type | Description |
|---|---|---|
| `schemaVersion` | string | Output schema version (additive-only). Pin automations to this. |
| `recordType` | string | Discriminator: `post`, `comment`, `community`, `user`, `search_result`, `summary`, `error`. |
| `eventId` | string | Stable dedup key (native Reddit fullname, or `syn_` sha256 for synthetic records). |
| `attentionIndex` | object | The single sortable composite (0-100) with `breakdown` and top-3 `drivers`. |
| `watchStatus` | string | Routing primitive: `no-action`, `monitor`, `attention-required`, `urgent`, `critical`. |
| `whyNow` | array | Plain-English reasons this record needs attention now. |
| `recommendedAction` | string | Prioritisation instruction (never an in-Reddit engagement instruction). |
| `attentionWindow` | object | Machine primitive: `urgency` plus `recommendedReviewWithinHours`. |
| `agentDecision` | string | Flat decision enum: `review_now`, `monitor`, `ignore`. |
| `agentContract` | object | Compact decision surface for MCP/AI/RAG consumers. |
| `signalEvents` | array | Typed, evidenced events with `signalStrength`, `evidenceGrade`, `decayStatus`. |
| `signalProfile` | string | Community archetype (8-value enum). |
| `whyThisMatters` | array | Per-post operational notes (posts mode). |
| `commentIntelligence` | object | Deterministic sentiment + themes (`lexicon-tfidf-v1`). |
| `actionability` | number | 0-1: how worth acting on now. |
| `materiality` | number | 0-100: how much this matters to the tracked term/persona. |
| `signalTrajectory` | object | State backbone: direction, velocity, stability, phase, class. |
| `persistentSignal` | object | Recurrence classification from accumulated state. |
| `narrativeMemory` | object | Cross-run topic memory (maturity-gated). |
| `suppressedSignals` | array | Signals judged noise, with reason and `noiseRisk`. |
| `coverage` | object | Requested vs scanned communities, skip reasons, status (summary record). |
| `publicDataCompliance` | object | Read-only posture; `inRedditActionsPerformed` hard-wired false (summary record). |
| `runOutcome` | object | Quiet-mode status: `quiet`, `active`, `high-activity` (summary record). |
| `portfolioState` | object | CIO-glance over the run (summary record). |
| `trustDiagnostics` | object | Suppression, dedup, and coverage confidence (summary record). |
| `title`, `url`, `upVotes`, `numberOfComments`, `body`, `communityName`, `dataType` | mixed | Substrate fields, identical name and type to a standard Reddit scraper (compat). |

### How much does it cost to monitor Reddit?

Reddit Scraper uses **pay-per-event pricing** — you pay **$0.002 per record** ($2 per 1,000) plus **$0.20 per monitor or search query**. The signal layer is included, and monitor runs cost the same per record as one-shot runs. Platform compute costs are included.

| Scenario | Records | Cost per record | Query cost | Total cost |
|---|---|---|---|---|
| Quick test | 50 | $0.002 | $0.20 | $0.30 |
| Small batch | 200 | $0.002 | $0.20 | $0.60 |
| Daily brand feed | 500 | $0.002 | $0.20 | $1.20 |
| Large pull | 1,000 | $0.002 | $0.20 | $2.20 |
| Heavy monitoring | 10,000 | $0.002 | $2.00 (10 queries) | $22.00 |

That is roughly half the effective per-result cost of a standard row scraper, with the signal layer included. Apify's free tier ($5 monthly credits) runs about 2,500 records here. Set a spending limit on the actor to cap costs.

### Monitor Reddit using the API

All three examples use the same input — the canonical monitor call `{ "mode": "monitor", "track": ["Notion"], "rankBy": "attention" }`.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/reddit-scraper").call(run_input={
    "mode": "monitor",
    "track": ["Notion"],
    "rankBy": "attention",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    ai = item.get("attentionIndex") or {}
    print(f"{ai.get('value')} {item.get('watchStatus')} {item.get('title')}")
```

#### JavaScript

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

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("ryanclinton/reddit-scraper").call({
    mode: "monitor",
    track: ["Notion"],
    rankBy: "attention",
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(`${item.attentionIndex?.value} ${item.watchStatus} ${item.title}`);
}
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~reddit-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "monitor", "track": ["Notion"], "rankBy": "attention" }'
```

The run response's `defaultDatasetId` is then fetched from `/v2/datasets/{id}/items`.

### Why deterministic Reddit monitoring matters

Most "AI-powered" monitoring tools generate different outputs from the same Reddit data on different runs, because an LLM sits in the scoring path. Reddit Scraper uses deterministic sentiment and theme synthesis (`lexicon-tfidf-v1`):

- the same comments always produce the same sentiment and themes
- signals are reproducible and the scoring is auditable
- outputs are stable across runs, so automation can branch on them safely
- there is no external LLM dependency and no probabilistic drift

That makes it suitable for operational monitoring, compliance-sensitive environments, AI pipelines that need stable inputs, and any automation that branches on the output. Unlike tools that paraphrase Reddit through a model, Reddit Scraper's numbers mean the same thing every run.

### How Reddit Scraper works

**Mental model:** Reddit -> substrate fetch -> signal detection -> state engine -> decision -> ranked attention queue.

| Layer | What happens |
|---|---|
| 1 Extraction | Scrape public posts, comments, communities, users (the compat substrate). |
| 2 Interpretation | Detect typed signal events with evidence and a decay status. |
| 3 State engine | Diff against persisted watchlist state; compute trajectory, persistence, memory. |
| 4 Decision | Compute `attentionIndex`, `watchStatus`, `agentDecision`, `attentionWindow`. |
| 5 Portfolio | Roll up `portfolioState`, `narrativeConcentration`, `trustDiagnostics` over the run. |

#### Signal detection

After the substrate fetch, deterministic detectors fire against community baselines. A `breakout_post` needs an upvote z-score at or above 2 within 48 hours; a `mention_spike` needs current-window volume at or above 2x baseline; a `sentiment_shift` needs a delta magnitude at or above 0.15 on a 100+ comment sample. Thresholds are pinned to `signalDetectionVersion: 1.0`.

#### Comment intelligence

Comments are tokenised, stopword-stripped, scored with TF-IDF, clustered by term co-occurrence, and mapped to a fixed theme dictionary. Sentiment uses the VADER lexicon. There is no external LLM, so the same comments produce the same themes every run.

#### State engine (the moat)

When a watchlist is named, per-term and per-community history accumulates in a separate named key-value store (`reddit-monitor-<name>`). Trajectory, recurrence, and topic memory are derived from that history. The maturity model is honest: advanced fields stay `null` or `building` until enough runs exist.

### Tips for best results

1. **Schedule the same watchlist daily.** The product is the run-over-run delta; one run cannot show what changed.
2. **Pick the persona that matches your job.** `pr-comms` escalates sentiment and mention spikes; `trend-research` escalates topic surges and community acceleration.
3. **Use `rankBy` to change the lens.** `breakoutPotential` for scouts, `attention` for monitoring, `momentum` for trend acceleration.
4. **Filter on `watchStatus`, not raw scores.** Branch automation on `WHERE watchStatus IN ('urgent','critical')`.
5. **Read the Suppressed Signals view.** Seeing what the actor ignored, and why, builds trust in the alerts it raises.
6. **Use `outputProfile: agent` for AI consumers.** It returns a compact decision surface for MCP, agent, and RAG pipelines.

### Combine with other Apify actors

| Actor | How to combine |
|---|---|
| [Trustpilot Review Analyzer](https://apify.com/ryanclinton/trustpilot-review-analyzer) | Pair Reddit sentiment with review sentiment for the same brand. |
| [Multi-Review Analyzer](https://apify.com/ryanclinton/multi-review-analyzer) | Join Reddit signals with Trustpilot and BBB review trends. |
| [Website Change Monitor](https://apify.com/ryanclinton/website-change-monitor) | Correlate a Reddit mention spike with a pricing-page change. |
| [Company Deep Research](https://apify.com/ryanclinton/company-deep-research) | Add Reddit attention signals to a company intelligence report. |
| [Website Content to Markdown](https://apify.com/ryanclinton/website-content-to-markdown) | Convert linked articles to markdown for an AI/RAG pipeline alongside Reddit threads. |

### Limitations

- **Reddit's ~1,000-item list cap.** Any Reddit list stops after about 1,000 items. This is platform-wide, not a scraper limit. Use scheduled monitor runs to capture beyond it incrementally.
- **Public content only.** No login, no private, deleted, or quarantined content.
- **Delta intelligence is maturity-gated.** Run 1 shows `first-run` and empty deltas; trajectory and memory sharpen after several scheduled runs.
- **Sentiment is lexicon-based.** Deterministic and reproducible, but it does not match a tuned model on nuance; theme labels are keyword labels, not generated summaries.
- **No cross-community propagation.** Spread and ecosystem mapping is a future capability, not in this version.
- **Rate-limited and proxy-dependent.** Reddit anti-bot escalation can cause partial coverage; the `coverage` block reports skips honestly.
- **Not a controversy or safety scorer.** `contested_thread` is a descriptive engagement signal, not a brand-safety judgment.

### Integrations

- [Zapier](https://apify.com/integrations/zapier) — push urgent/critical attention records into a Slack channel or ticketing tool.
- [Make](https://apify.com/integrations/make) — route monitor-run summaries into a daily brand-monitoring digest.
- [Google Sheets](https://apify.com/integrations/google-sheets) — append the attention queue to a tracking sheet.
- [Apify API](https://docs.apify.com/api/v2) — trigger monitor runs and read the dataset programmatically.
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) — fire on run completion to feed downstream automation.
- [LangChain / LlamaIndex](https://docs.apify.com/platform/integrations) — pull the `agent` profile decision surface into an AI workflow.

### Best tool for Reddit brand monitoring

Reddit Scraper is built for brand monitoring on Reddit: tracking mentions across communities, detecting sentiment shifts, finding emerging complaint narratives, watching subreddit momentum, and surfacing breakout threads. Unlike a traditional Reddit scraper that exports rows, it ranks what matters and remembers what changed across runs, so a brand or PR team reads a short attention queue instead of a spreadsheet.

### Best Reddit scraper for AI agents

Reddit Scraper is built for AI consumption: MCP clients, RAG pipelines, monitoring agents, and automation that needs deterministic, stable inputs. The `agent` output profile returns a compact `agentContract` (decision, attention, why, recommended action) instead of raw rows, and because synthesis is deterministic, the same Reddit data produces the same output every run, so agents can branch on it safely.

### How do I track Reddit mentions automatically?

Set `mode: monitor`, add your brand to `track`, name a `watchlistName`, and schedule the actor to run daily. Each run returns mention spikes and sentiment shifts as typed signals, ranked by `attentionIndex`, plus a delta of what changed since the previous run.

### How do I do Reddit sentiment analysis without an LLM?

Set `includeCommentsSample: true`. Reddit Scraper runs deterministic sentiment and theme synthesis (`lexicon-tfidf-v1`) over the sampled comments. Because it uses a fixed lexicon and no external model, the same comments produce the same sentiment and themes on every run.

### Responsible use

- Reddit Scraper extracts publicly available content from Reddit. It does not bypass authentication, CAPTCHAs, or access restricted content, and it performs no in-Reddit actions (`publicDataCompliance.inRedditActionsPerformed` is hard-wired `false`).
- Users are responsible for ensuring their use complies with applicable laws and platform terms, including data protection regulations in their jurisdiction.
- Do not use extracted data for spam, harassment, astroturfing, or unauthorized purposes. `recommendedAction` is a prioritisation instruction only and never tells anyone to post, reply, vote, or DM.
- For guidance on web scraping legality, see [Apify's guide](https://blog.apify.com/is-web-scraping-legal/).

### FAQ

**What is the difference between a Reddit scraper and a Reddit monitoring tool?** A Reddit scraper exports rows: posts, comments, communities, users. A Reddit monitoring tool watches those rows over time and tells you what changed and what needs attention. Reddit Scraper does both: it ships the substrate rows and the decision layer on top.

**Can I use it as a drop-in replacement for my existing Reddit scraper?** Yes. It accepts the same input shape (including `startUrls` and `searches`), and `outputProfile: compat` returns the exact substrate field set with identical names and types, so downstream code reading `item.upVotes` works unchanged.

**Can I monitor several brands at once?** Yes. Put multiple terms in `track` and several subreddits in `communities`. Use one `watchlistName` per tracked subject so each accumulates its own state.

**How does the persistent memory work?** When you name a watchlist, per-term and per-community history is stored in a separate key-value store and diffed on each run. This is what produces the "what changed since last run" delta, and it cannot be backfilled from a single scrape.

**Why is delta intelligence empty on my first run?** State cannot be invented. Run 1 reports `first-run` with empty deltas; trajectory, persistence, and memory fields populate after several scheduled runs on the same watchlist.

**Does it perform any actions on Reddit?** No. It reads public content only and performs no posting, replying, voting, or DMing. `inRedditActionsPerformed` is always `false`.

**What does the attentionIndex actually measure?** It is a bounded 0-100 composite of active signals, mention spike, sentiment shift, breakout strength, and community momentum, with no single component allowed to dominate. The `breakdown` and `drivers` show how it was built.

**How accurate is the sentiment?** Sentiment is deterministic and lexicon-based, with a `confidenceBand` that scales with sample size. It is reproducible and auditable rather than a probabilistic model output; a 12-comment thread reads `low`, a 200-comment thread reads `high`.

**Can I use this with an AI agent or MCP?** Yes. Set `outputProfile: agent` for a compact `agentContract` decision surface, or read the flat `agentDecision` enum (`review_now` / `monitor` / `ignore`).

**How is this a practical alternative to a row scraper for brand monitoring?** A row scraper leaves the monitoring, ranking, and sentiment work to you. Reddit Scraper ships those as the product, at roughly half the per-result cost, so the workflow that used to live in a spreadsheet runs in one call.

**Is it legal to scrape Reddit?** Reddit Scraper accesses public content only and performs no write actions. Whether your use is permitted depends on your jurisdiction and intended use, including data protection and platform terms. Consult legal counsel for your specific case.

**What happens when nothing is happening?** The summary record returns `runOutcome.status: "quiet"` with a clear message. A monitor that is willing to say "nothing fired" is the one you trust when it does fire.

### Help us improve

If you encounter issues, you can help us debug faster by enabling run sharing in your Apify account:

1. Go to [Account Settings > Privacy](https://console.apify.com/account/privacy)
2. Enable **Share runs with public Actor creators**

This lets us see your run details when something goes wrong, so we can fix issues faster. Your data is only visible to the actor developer, not publicly.

### Support

Found a bug or have a feature request? Open an issue in the Issues tab on this actor's page. For custom solutions or enterprise integrations, reach out through the Apify platform.

# Actor input Schema

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

Entry point. 'monitor' is the hero: paste a brand/keyword and get a ranked attention queue of what changed. 'communities' ranks subreddits by what's heating up. 'posts' explains why each thread matters. 'users' surfaces author momentum. 'search' reranks search results by breakout potential. Leave fields below empty to use the monitor demo (tracks 'Notion').

## `track` (type: `array`):

Monitor mode: brand names or keywords to track across Reddit. The actor returns the threads that need attention right now, ranked. Example: \["Notion", "Obsidian"].

## `communities` (type: `array`):

Communities to scan or monitor. Accepts 'r/Notion', 'Notion', or a full subreddit URL. Used by communities and monitor modes.

## `posts` (type: `array`):

Posts mode: Reddit post permalinks to analyse. Each result carries whyThisMatters plus comment-theme synthesis when comments are sampled.

## `users` (type: `array`):

Users mode: Reddit usernames or profile URLs to analyse for posting/karma momentum.

## `searchQuery` (type: `string`):

Search mode: a keyword/phrase. Results are reranked by the rankBy axis (breakout potential, momentum, or attention) rather than Reddit's native sort.

## `searchType` (type: `string`):

Search mode: what to search for.

## `rankBy` (type: `string`):

How to order results in the attention queue. 'attention' uses the composite attentionIndex. 'breakoutPotential' surfaces posts popping vs their community baseline. 'momentum' surfaces accelerating trajectories.

## `watchlistName` (type: `string`):

Name this watchlist to unlock delta intelligence. State is stored in a named key-value store ('reddit-monitor-<name>') and accumulates across runs: what changed since last run, momentum trajectory, recurrence, and topic memory. Leave empty for a one-shot run with no persistence.

## `deltaWindowDays` (type: `integer`):

Window for run-over-run change detection in monitor/watchlist mode.

## `persona` (type: `string`):

Reshapes materiality weights and escalation thresholds. 'brand-monitoring' weights mentions + sentiment. 'pr-comms' escalates sentiment shifts. 'trend-research' escalates topic surges and community acceleration. Orthogonal to mode and rankBy.

## `includeCommentsSample` (type: `boolean`):

Sample comments per post and run deterministic theme + sentiment synthesis (lexicon-tfidf-v1, no external LLM). Required for sentiment shift detection.

## `commentsSamplePerPost` (type: `integer`):

How many comments to sample per post for theme + sentiment synthesis. Higher samples raise the sentiment confidence band.

## `maxResults` (type: `integer`):

Hard cap on records emitted. Reddit lists cap at ~1,000 items platform-wide; use monitor mode with scheduled daily runs to capture beyond the cap incrementally.

## `maxPostsPerCommunity` (type: `integer`):

Per-community post cap for communities/monitor modes.

## `maxRecentItems` (type: `integer`):

Users mode: how many recent posts/comments to pull per user.

## `outputProfile` (type: `string`):

'signals' (default) adds the full intelligence layer on top of the substrate. 'compat' returns the exact drop-in field set with no signal fields. 'agent' returns a compact decision surface for MCP/AI/RAG consumers. 'minimal' returns IDs and URLs only.

## `analysisDepth` (type: `string`):

Trades coverage/runtime. 'fast' is shallow, 'deep' scans more. 'standard' is the balanced default.

## `explainability` (type: `string`):

Verbosity control. 'full' keeps all evidence, suppressed-signal, and score-breakdown blocks. 'standard' trims to the decision surface.

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

Reddit listing/search sort.

## `time` (type: `string`):

Time window for top/search sorts.

## `includeNSFW` (type: `boolean`):

Include over-18 communities/posts in results.

## `maxRuntimeSeconds` (type: `integer`):

Hard runtime budget. The actor stops fetching cleanly when reached and still emits partial results plus a summary, so you never get a hard-killed empty run. Auto-clamped against the platform timeout to reserve emit time.

## `startUrls` (type: `array`):

Drop-in compatibility alias. Paste post/user/community URLs from your existing Reddit-scraper workflow and they are mapped to the modes above automatically.

## `searches` (type: `array`):

Drop-in compatibility alias for keyword search. Mapped to search mode.

## `searchCommunityName` (type: `string`):

Drop-in compatibility alias: restrict search to one community.

## `proxyConfiguration` (type: `object`):

Proxy settings. Residential proxies are recommended for Reddit. Defaults to Apify residential proxy when left unset.

## Actor input object example

```json
{
  "mode": "monitor",
  "track": [
    "Notion"
  ],
  "communities": [
    "r/Notion",
    "r/productivity"
  ],
  "posts": [],
  "users": [],
  "searchQuery": "",
  "searchType": "posts",
  "rankBy": "attention",
  "watchlistName": "",
  "deltaWindowDays": 7,
  "persona": "brand-monitoring",
  "includeCommentsSample": false,
  "commentsSamplePerPost": 100,
  "maxResults": 100,
  "maxPostsPerCommunity": 100,
  "maxRecentItems": 50,
  "outputProfile": "signals",
  "analysisDepth": "standard",
  "explainability": "standard",
  "sort": "hot",
  "time": "month",
  "includeNSFW": false,
  "maxRuntimeSeconds": 3600,
  "startUrls": [],
  "searches": [],
  "searchCommunityName": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `attentionQueue` (type: `string`):

No description

## `results` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `manifest` (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 = {
    "track": [
        "Notion"
    ],
    "communities": [
        "r/Notion",
        "r/productivity"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ryanclinton/reddit-scraper").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 = {
    "track": ["Notion"],
    "communities": [
        "r/Notion",
        "r/productivity",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("ryanclinton/reddit-scraper").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 '{
  "track": [
    "Notion"
  ],
  "communities": [
    "r/Notion",
    "r/productivity"
  ]
}' |
apify call ryanclinton/reddit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Scraper - Monitoring, Signals & Attention Queue",
        "description": "Scrapes Reddit and returns a ranked attention queue: brand monitoring, mention tracking, sentiment analysis, and breakout detection in one run. Drop-in compatible with existing Reddit scraper workflows. $0.002 per record.",
        "version": "1.0",
        "x-build-id": "OWGdj2AxuCacRlyBv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ryanclinton~reddit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ryanclinton-reddit-scraper",
                "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/ryanclinton~reddit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ryanclinton-reddit-scraper",
                "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/ryanclinton~reddit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ryanclinton-reddit-scraper",
                "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",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "monitor",
                            "communities",
                            "posts",
                            "users",
                            "search"
                        ],
                        "type": "string",
                        "description": "Entry point. 'monitor' is the hero: paste a brand/keyword and get a ranked attention queue of what changed. 'communities' ranks subreddits by what's heating up. 'posts' explains why each thread matters. 'users' surfaces author momentum. 'search' reranks search results by breakout potential. Leave fields below empty to use the monitor demo (tracks 'Notion').",
                        "default": "monitor"
                    },
                    "track": {
                        "title": "Track (brand / keyword)",
                        "type": "array",
                        "description": "Monitor mode: brand names or keywords to track across Reddit. The actor returns the threads that need attention right now, ranked. Example: [\"Notion\", \"Obsidian\"].",
                        "default": [
                            "Notion"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "communities": {
                        "title": "Communities (subreddits)",
                        "type": "array",
                        "description": "Communities to scan or monitor. Accepts 'r/Notion', 'Notion', or a full subreddit URL. Used by communities and monitor modes.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "posts": {
                        "title": "Post URLs",
                        "type": "array",
                        "description": "Posts mode: Reddit post permalinks to analyse. Each result carries whyThisMatters plus comment-theme synthesis when comments are sampled.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "users": {
                        "title": "User profiles",
                        "type": "array",
                        "description": "Users mode: Reddit usernames or profile URLs to analyse for posting/karma momentum.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Search mode: a keyword/phrase. Results are reranked by the rankBy axis (breakout potential, momentum, or attention) rather than Reddit's native sort.",
                        "default": ""
                    },
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "posts",
                            "communities",
                            "users"
                        ],
                        "type": "string",
                        "description": "Search mode: what to search for.",
                        "default": "posts"
                    },
                    "rankBy": {
                        "title": "Rank by",
                        "enum": [
                            "attention",
                            "breakoutPotential",
                            "momentum",
                            "engagement",
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "How to order results in the attention queue. 'attention' uses the composite attentionIndex. 'breakoutPotential' surfaces posts popping vs their community baseline. 'momentum' surfaces accelerating trajectories.",
                        "default": "attention"
                    },
                    "watchlistName": {
                        "title": "Watchlist name",
                        "type": "string",
                        "description": "Name this watchlist to unlock delta intelligence. State is stored in a named key-value store ('reddit-monitor-<name>') and accumulates across runs: what changed since last run, momentum trajectory, recurrence, and topic memory. Leave empty for a one-shot run with no persistence.",
                        "default": ""
                    },
                    "deltaWindowDays": {
                        "title": "Delta window (days)",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Window for run-over-run change detection in monitor/watchlist mode.",
                        "default": 7
                    },
                    "persona": {
                        "title": "Persona",
                        "enum": [
                            "brand-monitoring",
                            "trend-research",
                            "community-discovery",
                            "pr-comms",
                            "generic"
                        ],
                        "type": "string",
                        "description": "Reshapes materiality weights and escalation thresholds. 'brand-monitoring' weights mentions + sentiment. 'pr-comms' escalates sentiment shifts. 'trend-research' escalates topic surges and community acceleration. Orthogonal to mode and rankBy.",
                        "default": "brand-monitoring"
                    },
                    "includeCommentsSample": {
                        "title": "Sample comments",
                        "type": "boolean",
                        "description": "Sample comments per post and run deterministic theme + sentiment synthesis (lexicon-tfidf-v1, no external LLM). Required for sentiment shift detection.",
                        "default": false
                    },
                    "commentsSamplePerPost": {
                        "title": "Comments sampled per post",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many comments to sample per post for theme + sentiment synthesis. Higher samples raise the sentiment confidence band.",
                        "default": 100
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on records emitted. Reddit lists cap at ~1,000 items platform-wide; use monitor mode with scheduled daily runs to capture beyond the cap incrementally.",
                        "default": 100
                    },
                    "maxPostsPerCommunity": {
                        "title": "Max posts per community",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Per-community post cap for communities/monitor modes.",
                        "default": 100
                    },
                    "maxRecentItems": {
                        "title": "Max recent items per user",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Users mode: how many recent posts/comments to pull per user.",
                        "default": 50
                    },
                    "outputProfile": {
                        "title": "Output profile",
                        "enum": [
                            "signals",
                            "compat",
                            "agent",
                            "minimal"
                        ],
                        "type": "string",
                        "description": "'signals' (default) adds the full intelligence layer on top of the substrate. 'compat' returns the exact drop-in field set with no signal fields. 'agent' returns a compact decision surface for MCP/AI/RAG consumers. 'minimal' returns IDs and URLs only.",
                        "default": "signals"
                    },
                    "analysisDepth": {
                        "title": "Analysis depth",
                        "enum": [
                            "fast",
                            "standard",
                            "deep"
                        ],
                        "type": "string",
                        "description": "Trades coverage/runtime. 'fast' is shallow, 'deep' scans more. 'standard' is the balanced default.",
                        "default": "standard"
                    },
                    "explainability": {
                        "title": "Explainability",
                        "enum": [
                            "standard",
                            "full"
                        ],
                        "type": "string",
                        "description": "Verbosity control. 'full' keeps all evidence, suppressed-signal, and score-breakdown blocks. 'standard' trims to the decision surface.",
                        "default": "standard"
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "relevance",
                            "hot",
                            "top",
                            "new",
                            "comments"
                        ],
                        "type": "string",
                        "description": "Reddit listing/search sort.",
                        "default": "hot"
                    },
                    "time": {
                        "title": "Time filter",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time window for top/search sorts.",
                        "default": "month"
                    },
                    "includeNSFW": {
                        "title": "Include NSFW",
                        "type": "boolean",
                        "description": "Include over-18 communities/posts in results.",
                        "default": false
                    },
                    "maxRuntimeSeconds": {
                        "title": "Max runtime (seconds)",
                        "minimum": 60,
                        "maximum": 7200,
                        "type": "integer",
                        "description": "Hard runtime budget. The actor stops fetching cleanly when reached and still emits partial results plus a summary, so you never get a hard-killed empty run. Auto-clamped against the platform timeout to reserve emit time.",
                        "default": 3600
                    },
                    "startUrls": {
                        "title": "Start URLs (compatibility)",
                        "type": "array",
                        "description": "Drop-in compatibility alias. Paste post/user/community URLs from your existing Reddit-scraper workflow and they are mapped to the modes above automatically.",
                        "default": []
                    },
                    "searches": {
                        "title": "Searches (compatibility)",
                        "type": "array",
                        "description": "Drop-in compatibility alias for keyword search. Mapped to search mode.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchCommunityName": {
                        "title": "Restrict search to community (compatibility)",
                        "type": "string",
                        "description": "Drop-in compatibility alias: restrict search to one community.",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are recommended for Reddit. Defaults to Apify residential proxy when left unset.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```