Reddit Posts Scraper: Comment Thread Analysis

Reddit Scraper — Extract Posts, Comment Threads and Engagement Data

Reddit Scraper turns any subreddit, post URL, or keyword search into typed post rows plus a flattened, analyzable comment thread — every reply becomes its own row with parentId and depth, so a nested conversation tree is queryable like a table instead of a buried JSON blob. Each post also ships a computed engagement rollup: top commenters, the single most-upvoted comment, max thread depth, average comment score, and upvotes-per-hour velocity. Unlike scraping frameworks that hand you raw HTML, Reddit Scraper returns typed JSON — ready for your database, your spreadsheet, or your LLM context window without any parsing. This guide covers every input and output field, the exact engagement-rollup math, and how monitoring, research, and AI teams deploy the Actor in production.

🧭 What does Reddit Scraper do?

Reddit Scraper fetches Reddit's public old.reddit.com listing and comment pages for one or more subreddits, post-bearing URLs, or search keywords — no Reddit account, login, or API key is required anywhere in the source. For every post found, it walks the comment tree up to your configured depth and comment budget, flattens it into child rows, and (optionally) computes a per-post engagement summary. AI-based thread sentiment is available as an opt-in add-on.

• Accepts subreddit names, r/-prefixed names, full Reddit URLs, or free-text search keywords in a single input list
• Emits one row per post (type="post") and, when enabled, one row per comment (type="comment") with parentId, depth, and reply_count
• Computes topCommenters, topComment, commentDepthMax, commenterCount, and avgCommentScore per post
• Computes engagementVelocity (score ÷ post age in hours) on every post row
• Optionally sends each thread's top comments to an LLM (Anthropic, OpenAI, Google, xAI, DeepSeek, Perplexity, or Mistral) for sentiment, a controversy score, top topics, and a one-line summary
• Escalates through a no-proxy → datacenter → residential retry ladder when Reddit blocks or silently walls a request

⚡ Features & capabilities

Reddit Scraper's output splits into two row shapes that share one dataset: post rows carry the base content plus the engagement rollup, comment rows carry the flattened thread. Fetching goes through old.reddit.com HTML using Chrome-impersonated TLS (impit, with an aiohttp fallback), because Reddit's own .json API endpoints return a hard 403 across every proxy tier when called from Apify's infrastructure.

Core fields on a post row (exact names from the source): post_id, title, author, score, num_comments, subreddit, permalink, postUrl, linkFlairText, over18, engagementVelocity, plus the rollup fields topCommenters, topComment, commentDepthMax, avgCommentScore. Comment rows carry comment_id, parentId, depth, reply_count, and body so the thread tree can be rebuilt outside the Actor.

How Reddit Scraper compares to other Reddit scrapers

Feature	Reddit Scraper (this Actor)	harshmaur/reddit-scraper	blackfalcondata/reddit-scraper
Comment thread structure	Flattened child rows with parentId/depth/reply_count in the default dataset, plus a per-run child dataset mirror	Nested thread fields with parentId, depth, "full thread structure" across 45+ comment fields (as documented on their listing, July 2026)	Nested comments with parentId, depth, contentType (as documented on their listing, July 2026)
Per-post engagement rollup	topCommenters, topComment, commentDepthMax, avgCommentScore, engagementVelocity computed on every row	Derived analytics (scorePerHour, engagementTotal, commentToScoreRatio) documented per post/comment (July 2026)	Derived analytics (ageHours, scorePerHour, engagementTotal) documented per post/comment (July 2026)
Built-in AI thread analysis	Optional, 7 providers (Anthropic/OpenAI/Google/xAI/DeepSeek/Perplexity/Mistral) via aiCommentAnalysis	Not documented as a built-in Actor feature (their MCP connectors use message templates, not model calls)	Opt-in lexicon sentiment toggle only (positive/negative/neutral + confidence), not full thread analysis (as documented, July 2026)
Account/login required	No	Not documented as required — "no API keys needed" (as stated on their listing, July 2026)	Not documented as required (as stated on their listing, July 2026)
Anti-bot handling	impit Chrome-impersonated TLS + no-proxy → datacenter → residential escalation on 403/429/silent block (in source)	Not documented in detail beyond "no rate limits" (July 2026)	Not documented in detail (July 2026)
Pricing model	Pay-per-event, charged per row_result (post rows only)	$2 per 1,000 results (as listed, July 2026)	$1.25 per 1,000 results + $0.005 run start (as listed, July 2026)

If your use case is feeding a comment thread to an LLM, the flattened child-row structure is the decision-maker — walking a deeply nested replies array inside an agent loop to reconstruct depth and parent relationships is a reliability failure mode, not a shortcut this Actor makes you take.

When another tool might suit you better

If you need Reddit user profiles or community/subreddit metadata (subscriber counts, rules, moderation policy) in the same run, harshmaur/reddit-scraper documents fields for both (25+ profile fields, 30+ community fields, per their listing, July 2026) that this Actor does not attempt to return. If you need built-in email/social-handle extraction from post and comment text, blackfalcondata's actor documents extractedUrls/socialProfiles/emails fields this Actor does not compute. This Actor is built for one job — posts with a fully threaded, analyzable comment tree and a computed engagement score — not a full-platform data warehouse.

Reddit Scraper within the Scrapio data stack

Reddit Scraper covers posts and their comment threads. For subreddit-level trend and velocity tracking across many posts, use Reddit Trends Scraper — Trending Subreddit & Velocity Report. For auditing a specific Reddit account's post history and bot-risk score, use Reddit User Profile, Posts & Comments Scraper — Bot Detection. All three share the same old.reddit.com fetch layer and proxy-escalation pattern.

Why do developers and data teams scrape Reddit?

Reddit's threaded discussions are one of the few large, public sources of unscripted human opinion tied to a specific topic, product, or event — and its front end changes often enough that manual browsing doesn't scale past a handful of threads.

🏢 Brand and community monitoring teams

Teams pass a subreddit or keyword list as redditSources with postSort="new" and a short timeRange, then read topComment, commenterCount, and engagementVelocity off each post row to see which mentions are gaining traction fastest — without opening a single thread manually. Scheduled runs turn this into an ongoing mention feed.

📊 AI training data and RAG indexing

title, body, and each comment row's body are the high-information text fields worth indexing for retrieval — they carry unscripted, topic-tagged discussion text. For training data, score, avgCommentScore, commentDepthMax, and engagementVelocity are numeric fields with consistent structure across every row, usable as labeled features without extra normalization. When aiCommentAnalysis is on, aiThreadSummary gives a pre-compressed thread digest that's cheaper to embed than the full raw thread.

📱 Competitive and market intelligence

Track score, num_comments, and engagementVelocity for the same post_id across scheduled runs to see which product or brand discussions are accelerating, and pull topCommenters to identify the accounts driving a thread's engagement.

🔬 Research and academic use

Public subreddit and thread data supports discourse, sentiment, and community-structure research. The Actor returns only what old.reddit.com serves to a logged-out visitor — it does not access private messages, moderator-only fields, or authenticated account data.

🍚 Input parameters

All fields are read from .actor/actor.json. No parameter is flagged required at the schema level, but validate_and_parse_input raises an error at run time if redditSources (or its legacy alias startUrls) resolves to an empty list.

Parameter	Required	Type	Default	Constraints	Description
redditSources	No	array (stringList)	—	one entry per line	Subreddit names, r/-prefixed names, full Reddit URLs, or search keywords — mixed freely. Legacy field name startUrls is also accepted.
postLimit	No	integer	10	min 1, max 100	Maximum posts to scrape per source. Legacy alias maxPosts.
commentLimit	No	integer	5	min 0, max 1000	Maximum comments to walk per post, across the whole thread including nested replies. 0 skips comments entirely. Legacy alias maxComments.
maxCommentDepth	No	integer	10	min 0	How deep to follow reply chains. 0 = unlimited depth.
includeCommentRows	No	boolean	true	—	When on, every comment is also written as its own flat row in the default dataset and mirrored to a per-run child dataset. When off, comments exist only inside the post row's nested comments array.
includeEngagementRollup	No	boolean	true	—	Adds topCommenters, topComment, commentDepthMax, commenterCount, and avgCommentScore to each post row.
topCommentersCount	No	integer	5	min 0	How many top commenters (by comment count, then score) to list per post.
postSort	No	string (enum)	"top"	hot, new, top, rising	How Reddit sorts posts before scraping. Legacy alias sortOrder.
timeRange	No	string (enum)	"week"	hour, day, week, month, year, all	Time window, applied only when postSort is top or rising; ignored otherwise. Legacy alias timeFilter.
aiCommentAnalysis	No	boolean	false	—	Turns on LLM analysis of each comment thread, adding aiThreadSentiment, aiControversyScore, aiTopTopics, aiThreadSummary. Requires an API key.
aiModel	No	string (enum)	"claude-haiku-4-5"	14 models across 7 providers	Provider is auto-detected from the model name prefix (claude-→Anthropic, gpt-/o3-→OpenAI, gemini-→Google, grok-→xAI, deepseek-→DeepSeek, sonar→Perplexity, mistral-→Mistral).
aiApiKey	No	string (secret, textfield)	—	—	API key for the selected provider. Only used when aiCommentAnalysis is on. Falls back to the matching provider environment variable (ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, XAI_API_KEY, DEEPSEEK_API_KEY, PERPLEXITY_API_KEY, MISTRAL_API_KEY) when left blank. Marked isSecret in the schema, so it is masked in the Console and not stored in run logs.
proxyConfiguration	No	object (proxy editor)	{"useApifyProxy": false}	—	Proxy selection. If Reddit blocks a request, the Actor auto-escalates: no proxy → datacenter → residential. Residential is recommended for reliable access.

Example input

{
  "redditSources": ["r/technology", "askreddit", "https://www.reddit.com/r/news/"],
  "postLimit": 25,
  "commentLimit": 100,
  "maxCommentDepth": 5,
  "includeCommentRows": true,
  "includeEngagementRollup": true,
  "topCommentersCount": 5,
  "postSort": "top",
  "timeRange": "week",
  "aiCommentAnalysis": false,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}

Supported URL types and input formats

redditSources accepts four input shapes, resolved by parse_start_urls and build_listing_url in the source:

• Subreddit name — technology or r/technology — scraped as old.reddit.com/r/technology/<sort>/.
• Full subreddit URL — https://www.reddit.com/r/news/ — the path is parsed and reduced to the subreddit name (news).
• Search keyword — any string without a / and without an r/ prefix, e.g. artificial intelligence — run through old.reddit.com/search.
• A full post/comment-thread URL — e.g. https://www.reddit.com/r/AskReddit/comments/abc123/some_title/ — is also reduced to its subreddit (AskReddit) and scraped as that subreddit's listing under your chosen postSort/timeRange. It does not scrape only that specific post; the code takes parts[1] from any /r/<name>/... path, discarding the rest.

Because old.reddit serves a fixed page of results with no pagination cursor, postLimit caps at 100 posts per source regardless of how large a subreddit is — 3 sources × 25 each is up to 75 posts, not more.

Legacy field names and precedence

Every renamed parameter in the table above (redditSources, postLimit, commentLimit, postSort, timeRange) also accepts the original base-Actor key it replaced (startUrls, maxPosts, maxComments, sortOrder, timeFilter). Because Apify injects each renamed field's schema default into every run — so it is technically always "present" — the source checks the legacy key first (it only appears in the input when you actually send it) and falls back to the renamed key's value otherwise. In practice this means: if you send sortOrder in a raw JSON input alongside the default postSort, sortOrder wins.

📦 Output format

Every run produces one dataset with three possible row shapes, distinguished by the type field. Rows can be exported as JSON, CSV, Excel, XML, RSS, or HTML from the run's Storage tab in Apify Console, or pulled programmatically via the Apify API or apify-client.

Output for a post row (type: "post")

{
  "post_id": "1abcxyz",
  "title": "What's the most underrated programming language in 2026?",
  "author": "code_wanderer",
  "created_utc": 1753432800,
  "num_comments": 214,
  "score": 3287,
  "permalink": "/r/programming/comments/1abcxyz/whats_the_most_underrated_programming_language/",
  "image_url": "",
  "thumbnail_url": "https://b.thumbs.redditmedia.com/abc123.jpg",
  "body": "",
  "comments": [
    {
      "id": "kx1a2b3",
      "author": "static_typist",
      "body": "Nim, hands down. Compiles to C, no GC pauses if you want them.",
      "score": 412,
      "created_utc": 1753436400,
      "permalink": "/r/programming/comments/1abcxyz/whats_the_most_underrated_programming_language/kx1a2b3/",
      "depth": 0,
      "parentId": "t3_1abcxyz",
      "replies": []
    }
  ],
  "subreddit": "programming",
  "success": true,
  "error_message": null,
  "type": "post",
  "isChild": false,
  "publishedAt": "2026-07-25T06:00:00Z",
  "postUrl": "https://www.reddit.com/r/programming/comments/1abcxyz/whats_the_most_underrated_programming_language/",
  "authorFullname": "t2_9f8e7d",
  "over18": false,
  "spoiler": false,
  "domain": "self.programming",
  "outboundUrl": null,
  "linkFlairText": "Discussion",
  "ageHours": 19.4,
  "engagementVelocity": 169.4,
  "commentsAnalyzed": 5,
  "commenterCount": 5,
  "commentDepthMax": 3,
  "avgCommentScore": 187.6,
  "topCommenters": [
    { "author": "static_typist", "commentCount": 2, "totalScore": 540 }
  ],
  "topComment": {
    "author": "static_typist",
    "score": 412,
    "commentId": "kx1a2b3",
    "body": "Nim, hands down. Compiles to C, no GC pauses if you want them."
  },
  "aiThreadSentiment": null,
  "aiControversyScore": null,
  "aiTopTopics": null,
  "aiThreadSummary": null,
  "scrapedAt": "2026-07-25T06:19:24Z"
}

The comments, commentsAnalyzed…topComment, and aiThreadSentiment…aiThreadSummary groups only appear (with real values instead of nulls) when commentLimit > 0, includeEngagementRollup is on, and aiCommentAnalysis is on, respectively.

Output for a comment child row (type: "comment")

Written when includeCommentRows is on and the post has at least one comment — to the default dataset, and mirrored to a per-run child dataset named comments-<runId>. The runId is read from Actor.get_env(), falling back to the APIFY_ACTOR_RUN_ID or ACTOR_RUN_ID environment variable; if none of those resolve, the child dataset mirror is skipped and comment rows still land in the default dataset:

{
  "type": "comment",
  "isChild": true,
  "post_id": "1abcxyz",
  "subreddit": "programming",
  "comment_id": "kx1a2b3",
  "parentId": "t3_1abcxyz",
  "depth": 0,
  "author": "static_typist",
  "body": "Nim, hands down. Compiles to C, no GC pauses if you want them.",
  "score": 412,
  "created_utc": 1753436400,
  "publishedAt": "2026-07-25T07:00:00Z",
  "permalink": "https://www.reddit.com/r/programming/comments/1abcxyz/whats_the_most_underrated_programming_language/kx1a2b3/",
  "reply_count": 3,
  "success": true,
  "scrapedAt": "2026-07-25T06:19:31Z"
}

Schema stability and export options

A third row shape — {"type": "error", "isChild": false, "source": ..., "post_id": ..., "success": false, "error_message": ..., "scrapedAt": ...} — is pushed when a source's listing page can't be fetched after retries, or a post fails mid-scrape. Only post rows are charged (charged_event_name="row_result"); comment child rows and error rows are pushed uncharged. To keep only billed results in an export, filter the dataset on type == "post"; to also drop failed-target accounting rows from a mixed export, add type != "error".

Field names are stable across runs as long as Reddit's old.reddit.com markup doesn't change; the Actor's own row-building code adds no versioning beyond the type discriminator documented above.

💡 Reddit Scraper strategy guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run whenever your alerting system flags a new keyword or brand mention: pass the keyword as redditSources with postSort="new" and a short timeRange (day or hour). Read the returned post rows back through the Apify API and append topComment, commenterCount, and engagementVelocity to the mention record in your CRM or ticketing system — the thread's real reaction lands on the same record as the mention.

🎯 Strategy 2: Scheduled monitoring and alerting

Set up an Apify Schedule to re-run the same redditSources list on a cadence you control, with postSort="hot". Diff each run's rows against the previous run's, keyed on post_id, and alert when engagementVelocity or score crosses a threshold you set — this surfaces posts that are accelerating, not just ones that are already large.

🎯 Strategy 3: Bulk dataset build

Feed many subreddits or keywords into redditSources in one run, with postLimit and commentLimit set to their schema maximums (100 and 1000). The Actor processes sources and posts strictly sequentially — one request at a time, with roughly a 1-second delay plus jitter between each — so there is no in-run concurrency to tune; for a faster bulk build, split a long source list across several parallel Actor runs started via the API instead of one large run. Export the finished dataset to CSV for a research or training corpus.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Monitoring inbound brand/keyword mentions	On-demand run per alert, via API	JSON via API, written back to your system
Scheduled monitoring	Watching a subreddit or keyword set over time	Apify Schedule, recurring	JSON diffed run-over-run on post_id
Bulk dataset build	Research or training corpora across many sources	Several parallel runs, one source slice each	CSV/JSON export from Storage or API

Related Reddit scrapers & tools

Scraper	What it extracts
Reddit Trends Scraper — Trending Subreddit & Velocity Report	Per-post upvote velocity plus a subreddit-level rollup (avg/median velocity, top post, live subscriber counts)
Reddit User Profile, Posts & Comments Scraper — Bot Detection	A Reddit account's post history plus a 0–100 authenticity/bot-risk score
Quora Search Scraper — Answer Text & Upvote Ranking	Quora answers by keyword, ranked by upvotes — same Q&A-community entity type on a different platform
Twitter Trends Scraper — Watch Your Brand Keywords	Cross-platform keyword monitoring for teams already tracking Reddit mentions

None of these compute the same per-post comment-thread rollup this Actor does; they are adjacent entity types (velocity-only, user history, or a different platform) rather than direct substitutes.

How to integrate Reddit Scraper with your stack

Reddit Scraper works with any language or tool that can call the Apify API — there is no separate REST API of its own to learn, and no MCP server is documented for this Actor. It runs on the apify Python SDK (apify>=2.0.0) with impit for the Chrome-impersonated fetch layer and lxml for HTML parsing, packaged in the standard apify/actor-python Docker base image.

Python

from apify_client import ApifyClient
import csv

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "redditSources": ["r/technology", "artificial intelligence"],
    "postLimit": 25,
    "commentLimit": 50,
    "postSort": "top",
    "timeRange": "week",
}

run = client.actor("<YOUR_USERNAME>/reddit-posts-scraper-comment-thread-analysis").call(
    run_input=run_input
)

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
posts = [r for r in rows if r.get("type") == "post"]

with open("reddit_posts.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=[
        "subreddit", "title", "score", "num_comments", "engagementVelocity", "postUrl"
    ])
    writer.writeheader()
    for row in posts:
        writer.writerow({k: row.get(k) for k in writer.fieldnames})

print(f"Saved {len(posts)} post rows to reddit_posts.csv")

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const run = await client.actor('<YOUR_USERNAME>/reddit-posts-scraper-comment-thread-analysis').call({
    redditSources: ['r/technology', 'artificial intelligence'],
    postLimit: 25,
    commentLimit: 50,
    postSort: 'top',
    timeRange: 'week',
});

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

for (const row of items.filter((r) => r.type === 'post')) {
    console.log(row.title, row.score, row.engagementVelocity);
}

Async and scheduled pipelines

For large source lists, start the Actor with client.actor(...).start() instead of .call() so your caller doesn't block, then poll run status or subscribe to an Apify webhook on ACTOR.RUN.SUCCEEDED to pull the dataset once the run finishes. For recurring monitoring, configure an Apify Schedule on the Actor in Apify Console rather than triggering runs from your own cron job.

🎯 Who Needs Reddit Scraper? (Use Cases & Industries)

🏢 Brand and community monitoring teams

Watch topComment and engagementVelocity on posts matching a brand or product keyword to catch a mention that's gaining traction before it trends, without opening threads manually.

📊 AI/ML and data engineering teams

Feed title, body, and comment body text into a RAG index, or use score, avgCommentScore, and commentDepthMax as pre-computed numeric features for a downstream ranking or classification model.

📱 Competitive and market intelligence teams

Compare score, num_comments, and topCommenters for the same post_id across scheduled runs to see which competitor mentions or product launches are gaining real discussion volume.

🔬 Researchers

Public thread data supports discourse and community-structure research — pricing distributions, sentiment spread, or reply-depth patterns by subreddit — using only what old.reddit.com serves to a logged-out visitor.

Is it legal to scrape Reddit?

Scraping publicly accessible web pages is generally lawful; U.S. courts have held that scraping data a website makes available to the public does not, by itself, violate the Computer Fraud and Abuse Act (hiQ Labs, Inc. v. LinkedIn Corp., 9th Cir. 2019). Running this Actor against Reddit may still violate Reddit's own Terms of Service, which is a contractual and civil matter between you and Reddit, not a criminal one — review Reddit's terms before using scraped data commercially. Reddit post and comment rows include an author username and free-text body content, which can constitute personal data under GDPR/CCPA where a pseudonymous username is linkable to an individual; usernames returned here are exactly what Reddit itself displays publicly, and no private-message, email, or authenticated-account data is ever collected. Reddit Scraper returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

❓ Frequently asked questions

Does Reddit Scraper work without a Reddit account?

Yes. It fetches old.reddit.com listing and comment pages with a Chrome-impersonated HTTP client (impit, falling back to aiohttp) — no Reddit login, session cookie, or API key is used anywhere in the source.

How does Reddit Scraper handle Reddit's anti-scraping measures?

It escalates through a proxy ladder — no proxy → datacenter → residential (with up to 3 residential retries) — whenever a request returns HTTP 403/429, a transport error, or a "silent block" (HTTP 200/3xx with the expected page marker missing, e.g. a redirect to a login page). Each retry backs off 1.5 seconds plus the attempt number, plus jitter.

Can I run Reddit Scraper at scale without getting blocked?

postLimit accepts up to 100 posts per source — old.reddit's listing page has no pagination cursor, so 100 is the real ceiling per source regardless of subreddit size. commentLimit accepts up to 1000, but the comment page itself is only ever requested with limit=min(commentLimit × 3, 500), so a commentLimit set above roughly 165 will not pull materially more comments than the 500-item page allows. No uptime or block-rate guarantee is published; enabling residential proxy is the documented recommendation for reliability.

How fresh is the data Reddit Scraper returns?

Every run fetches live from old.reddit.com at request time — there is no caching or reuse of HTML between runs.

What happens if I paste a direct post URL instead of a subreddit?

It is reduced to that post's subreddit and scraped as a listing under your chosen postSort/timeRange — not scraped as that single post. parse_start_urls takes only the subreddit segment (parts[1]) from any /r/<name>/... path, so a post-permalink URL and a bare subreddit URL behave identically as input.

Which fields work best for AI training and RAG indexing?

For RAG, index title, body, and comment-row body text — they carry unscripted, topic-tagged discussion language. For training features, score, avgCommentScore, commentDepthMax, and engagementVelocity are numeric and structurally consistent across every row, returned as typed primitives that need no normalization before use.

Does using Reddit Scraper involve personal data?

Yes, in a limited sense: author (a public Reddit username) and comment body text are returned, since that is what Reddit displays publicly on the post and thread. No email, real name, or authenticated-account data is collected. Lawful basis for storing and using any personal data you retain from the output sits with you, the user, not with the Actor.

Does Reddit Scraper work with Claude, ChatGPT, and other AI agent tools?

No MCP server is documented for this Actor. It is callable as a standard Apify Actor run by any agent framework that can call the Apify API — every response is typed JSON, so no HTML-parsing step sits between the output and your agent's context window. The optional aiCommentAnalysis toggle can also call Claude, GPT, Gemini, Grok, DeepSeek, Perplexity, or Mistral directly inside the run itself.

What happens if the AI provider call fails or the key is missing?

aiThreadSentiment, aiControversyScore, aiTopTopics, and aiThreadSummary all come back null — the Actor never fabricates an AI result. If aiCommentAnalysis is on but no API key is found (neither in aiApiKey nor the matching provider environment variable), a warning is logged once and every post's AI fields stay null for the whole run; the post row itself, its comments, and the engagement rollup are unaffected.

What happens if a subreddit, URL, or keyword returns no posts?

The run doesn't fail — the Actor logs a warning ("No posts parsed for source") and moves on to the next source. If the listing page itself can't be fetched after retries across all proxy tiers, an uncharged type: "error" row is pushed for that source instead, and the run still completes successfully with whatever other sources returned data.

How does Reddit Scraper compare to other Reddit scrapers?

harshmaur/reddit-scraper documents a broader schema — user profiles, community metadata, and 140+ fields across four data types (as listed on their listing, July 2026) — that this Actor doesn't attempt to replicate. blackfalcondata/reddit-scraper documents a built-in lexicon sentiment toggle and link/email extraction (July 2026). This Actor's differentiator is the flattened comment-thread rows with explicit parentId/depth/reply_count, paired with a computed engagement rollup, in a single pay-per-post-result run.

Disclaimer

Reddit Scraper extracts only publicly available data from Reddit. This tool is intended for lawful use cases only. Users are responsible for complying with Reddit's terms of service and applicable data protection laws in their jurisdiction.