Reddit Comment Scraper: 475 of 522 Runs Succeeded (2026)

Each comment record carries 42 fields, including the comment text, score, author username, and timestamps. The actor walks top-level comments and every nested reply, including replies hidden behind Reddit's load more placeholders, until the thread is exhausted. Apify's free plan includes $5.00 of monthly usage, which covers up to 1,000 results at $0.005 per result before run-start fees. Built for researchers, data scientists, and analysts who need structured discussion data without managing API credentials or login cookies, and not for anyone seeking contact details which comment records do not include.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 1,000 results at $0.005 each before platform usage. Open Reddit Comment Scraper on Apify and run the prefilled example.

How reliable is Reddit Comment Scraper in production?

Across the last 30 days of public runs on the Apify platform, Reddit Comment Scraper recorded 522 runs with the following outcomes.

Outcome	Runs	Share
Succeeded	475	91.0%
Failed	33	6.3%
Aborted by the user	14	2.7%
Timed out	0	0.0%
Total	522	100.0%

When scheduling unattended runs, expect about 6 in a hundred executions to fail or time out based on recent telemetry. Build retry routines and monitoring triggers around this baseline to handle dropped runs smoothly. Aborted runs reflect manual cancellations, so they require no automated recovery steps.

What does it cost to run Reddit Comment Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.05 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Apify plan	Per result	Per 1,000 results
FREE	$0.005	$5.00
BRONZE	$0.00367	$3.67
SILVER	$0.00233	$2.33
GOLD	$0.001	$1.00
PLATINUM	$0.001	$1.00
DIAMOND	$0.001	$1.00

Worked example: collecting 10,000 results costs $50.00 in result charges before run-start fees and platform usage. With 6.3% of runs failing or timing out in the last 30 days, budget for re-running a portion of those batches rather than assuming every run completes.

The main cost driver is the postUrls array control combined with maxComments, which directly determines how many total items are written to the dataset. Since result charges apply only to items written, limiting the maximum comment count per post keeps billing predictable. You can test the actor on Apify's free plan before committing larger budgets.

How do you run Reddit Comment Scraper from the API?

The schema marks 1 of its 25 controls as required: postUrls. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for Reddit Comment Scraper, so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~reddit-comment-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"postUrls":["https://www.reddit.com/r/programming/comments/1vqukkf/"],"maxComments":30}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "postUrls": [
    "https://www.reddit.com/r/programming/comments/1vqukkf/"
  ],
  "maxComments": 30
}

run = client.actor("crawlerbros~reddit-comment-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

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

const input = {
  "postUrls": [
    "https://www.reddit.com/r/programming/comments/1vqukkf/"
  ],
  "maxComments": 30
}

const run = await client.actor('crawlerbros~reddit-comment-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which Reddit Comment Scraper inputs matter, and which can you skip?

The schema provides 25 controls, of which postUrls is the single required parameter. Most users should start by providing one or more post URLs and leaving optional filters like date windows and score thresholds at their defaults until a baseline run succeeds.

postUrls (array): Post URLs, comment URLs, share links or bare post IDs. Accepted forms: full post URL (https://www.reddit.com/r/x/comments/1abc/title/), short URL (https://www.reddit.com/comments/1abc or with ?sort=top), comment URL (.../comments/1abc/title/comment/xyz/), mobile share link (https://www.reddit.com/r/x/s/token), bare post id (1abc123) or t3_1abc123.
maxComments (integer): Maximum number of comments to scrape from each post (including nested replies). Default: 100.
commentSort (string): How to sort the comment threads. Default: "confidence".
includePost (boolean): When enabled, the parent post is emitted as the first record of each thread (full post data included). Default: false.
postedAfter (string): Only keep comments created on or after this date (UTC).
postedBefore (string): Only keep comments created on or before this date (interpreted as the end of that day, UTC).
minDepth (integer): Only keep comments nested at or deeper than this depth (0 = keep everything, 1 = drop top-level comments and keep only replies, 2 = keep only replies-to-replies and deeper, etc.). Leave empty for no limit.
maxDepth (integer): Only keep comments nested at or above this depth (0 = top-level comments only, 1 = top-level + first-level replies, etc.). Leave empty for no limit.
minCommentScore (integer): Only keep comments with a score (upvotes minus downvotes) at or above this value. Leave empty for no limit.
maxCommentScore (integer): Only keep comments with a score (upvotes minus downvotes) at or below this value. Leave empty for no limit.
onlyOP (boolean): When enabled, only comments written by the post's original author are kept. Default: false.
excludeDeletedRemoved (boolean): When enabled, comments whose body or author show as [deleted] or [removed] are dropped (no real content left to scrape). Default: false.

The other 13 controls, with their defaults, are listed in the input schema on Reddit Comment Scraper on Apify.

Fixed-choice controls: commentSort accepts confidence (Best (Confidence)), top, new, controversial, old, qa (Q&A).

What does Reddit Comment Scraper return?

Returned records provide structured comment fields including markdown bodies, vote scores, author names, and nesting depths. The output conspicuously lacks verified email addresses or off-platform user identities.

Output per comment

dataType - always "comment" for these records
comment_id - comment identifier without the t1_ prefix
comment_name - full comment name in Reddit's format (t1_...)
post_id, post_url, post_title - identifiers and title of the parent post this comment belongs to
link_id - fullname of the parent post (t3_...)
permalink - direct link to the comment on reddit.com
author - commenter's username ([deleted] if the account was deleted)
author_id - commenter's fullname (t2_...); absent when the author is deleted
author_is_blocked - whether the author has blocked the scraper's account
author_flair, author_flair_css_class, author_flair_template_id, author_flair_type, author_flair_text_color, author_flair_background_color, author_flair_richtext - the author's community flair, when they have one
author_premium, author_patreon_flair - whether the author has Reddit Premium / a Patreon badge in this community
body - comment text as markdown
body_html - comment text rendered as Reddit HTML
score - net score (upvotes minus downvotes)
ups, downs - raw upvote / downvote counts
score_hidden - whether the score is currently hidden by the community
controversiality - 1 when the up/down split is near-even, else 0
subreddit, subreddit_prefixed, subreddit_id, subreddit_type - the community the comment belongs to
created_utc, created_at - when the comment was posted (Unix epoch and ISO-8601)
edited, edited_at - whether and when the comment was last edited
depth - nesting level, 0 = top-level comment
parent_id - fullname of the direct parent (t3_... for a post, t1_... for another comment)
parent_kind - post if it's a top-level reply to the post, comment if it's a reply to another comment
is_op - whether the commenter is also the post's original author
is_stickied - whether the comment is pinned by moderators
is_locked - whether the comment thread is locked
archived - whether the comment is archived (voting/commenting closed)
distinguished - moderator or admin when the author posted in an official capacity
collapsed - whether Reddit collapses the comment by default
collapsed_reason, collapsed_reason_code - human-readable and machine-readable reason for the collapse
collapsed_because_crowd_control - whether the collapse was caused by crowd control
can_gild - whether the comment could receive legacy awards
comment_type - optional type marker (e.g. live); absent on regular comments
unrepliable_reason - why the comment can't be replied to, when that's the case
no_follow - whether the comment is tagged nofollow for search engines
send_replies - whether the author receives reply notifications for this comment
gilded - number of legacy (gold-style) awards received
total_awards_received - total award count
awards - award breakdown (name, count, coin price, icon URL); omitted when there are no awards
removed_by_category - who removed the comment, when removed: moderator, automod_filtered, reddit, author/deleted
crawled_at - when the actor fetched this record (ISO-8601)
source - json (primary Reddit JSON endpoint) or dom (browser fallback)

Output per post

dataType - always "post" for these records
post_id, post_name - bare id and full Reddit name (t3_...) of the post
title - post title
content, content_html - self-post body as markdown / Reddit HTML (text posts only)
content_url - external destination URL for link posts
url, permalink - canonical reddit.com link to the post
url_overridden_by_dest - Reddit's resolved destination URL, when it differs from content_url
domain - self.<subreddit> for text posts, otherwise the linked domain
post_hint - Reddit's own content hint (self, link, image, hosted:video, …)
is_self - whether the post is a text post
post_type - self, link, image, video, gallery, or poll
media_type - text, link, image, video, gallery, or embed
has_media - whether the post carries image/video/gallery/poll/embed media
author, author_id - the poster's username and fullname
author_flair, author_flair_css_class, author_flair_template_id, author_flair_type, author_flair_text_color, author_flair_background_color, author_flair_richtext - the poster's community flair, when they have one
author_premium, author_is_blocked, author_patreon_flair - poster's premium status, block status, and Patreon badge
subreddit, subreddit_prefixed, subreddit_id, subreddit_subscribers, subreddit_type - the community the post belongs to
score, ups, downs, upvote_ratio - vote totals and the up/down ratio
num_comments - total comment count on the post at crawl time
num_crossposts, num_duplicates - how often the post was crossposted, and how many other posts link the same destination (link posts only)
link_flair, link_flair_css_class, link_flair_richtext, link_flair_background_color, link_flair_text_color, link_flair_type - the post's own flair, when set
thumbnail_url, thumbnail_width, thumbnail_height - thumbnail image and dimensions, when a real thumbnail exists
created_utc, created_at - when the post was submitted (Unix epoch and ISO-8601)
edited, edited_at - whether and when the post was last edited
is_stickied, is_pinned - whether the post is pinned by moderators / on the subreddit
is_locked, is_archived - whether commenting/voting is closed
is_nsfw, is_spoiler - content warnings
is_original_content - whether the post is flagged OC
is_crosspost, crosspost_parent_id - whether this is a crosspost, and the original post's id
is_crosspostable, is_meta, is_robot_indexable, is_reddit_media_domain, media_only, quarantine - additional Reddit-assigned post attributes
no_follow, send_replies, allow_live_comments, contest_mode, hide_score, suggested_sort, content_categories - post configuration flags Reddit reports
hidden - whether the post is hidden
images - image URLs from the post preview
gallery_images, gallery_count - full-resolution gallery image URLs and item count (gallery posts)
video_url - direct video file URL (video posts)
poll_data - poll options and vote totals (poll posts)
embed_type, embed_provider, embed_title, embed_author_name, embed_author_url, embed_thumbnail_url, embed_html - auto-embed data for link posts Reddit embeds from YouTube, Imgur, Gfycat, Twitch, etc.; omitted when the post has no external embed
gilded, total_awards_received, awards - legacy and modern award counts, plus the award breakdown
removed_by_category - who removed the post, when removed
distinguished - moderator or admin when the poster acted in an official capacity
crawled_at - when the actor fetched this record (ISO-8601)
source - json (primary Reddit JSON endpoint) or dom (browser fallback)

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Reddit Comment Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

Provide one or more target Reddit URLs in the postUrls array control before running the actor.
Set maxComments to cap how many comments are pulled per post during extraction.
Choose a sort order using the commentSort control to arrange threads by confidence, top, new, controversial, old, or q a.
Toggle includePost to true if the parent post record should appear as the first dataset item.
Apply filters such as minCommentScore, postedAfter, or excludeDeletedRemoved to narrow down the comment set.
Run the actor once with a small input and check that the returned records contain valid comment_id and body fields before scaling up.

How do you apply it? Three worked playbooks

These are Reddit Comment Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Sentiment & NLP datasets

Outcome: Build large, labeled corpora from real Reddit discussions

Configure: Set postUrls to a list of target thread links and set excludeDeletedRemoved to true.

Working method: Run on a batch of discussion threads, filter out short comments with minCommentLength, and export the resulting dataset for text analysis.

Deliverable: A structured dataset containing clean comment text bodies ready for natural language processing models.

Stop condition: Zero records returned due to invalid URLs or restricted subreddits.

Use case 2: Market & product research

Outcome: See what customers actually say about a product or brand in the replies

Configure: Populate postUrls with product discussion threads and apply keywords to isolate brand mentions.

Working method: Target relevant review discussions, filter by score or keywords, and analyze comment sentiment across the thread.

Deliverable: A filtered set of customer commentary and feedback extracted from community discussions.

Stop condition: Keyword filters returning no matching results across large threads.

Use case 3: Community & moderation analysis

Outcome: Study conversation structure, controversy, and OP engagement in a subreddit

Configure: Set commentSort to controversial or enable onlyOP to isolate specific participant interactions.

Working method: Extract comments with depth and controversy markers enabled, then analyze reply trees for moderation patterns.

Deliverable: A structured breakdown of thread hierarchy, user engagement, and moderation actions.

Stop condition: Missing nested replies caused by incorrect depth settings.

What breaks, and how do you design around it?

Over the last 30 days, 6.3% of public runs failed and 0.0% timed out. Build retries and alerting around those rates rather than assuming every run completes.

Large threads exceeding maxComments will truncate deeper replies, so increase the cap or narrow your URL list when complete coverage is required. If a subreddit restricts access or a post is removed, the actor returns 0 records for that URL along with a status message rather than failing the run.

When should you not use Reddit Comment Scraper?

Do not use this actor if you need to search Reddit posts by keywords rather than scraping known URLs, in which case Reddit Keywords is the correct tool. Avoid this scraper if your workflow requires downloading media files directly from video posts, where Reddit Video Downloader provides specialized extraction. Finally, skip this tool if you only need high-level post metrics without comment trees, as Reddit Scraper handles subreddit listings more efficiently.

What should you check before trusting the output?

Verify that comment records include a non-null body field containing markdown text.
Check that created_utc and created_at timestamps are populated for every comment.
Ensure score and upvote metrics are present and formatted as integers.
Check for missing author usernames which indicate deleted or removed accounts.
Stop scheduled runs if failure rates exceed the historical baseline of about 6 in a hundred.

None of this proves a record is correct. It gives a scheduled Reddit Comment Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

Do I need a Reddit account or API key to run this actor?

No. The actor reads Reddit's public web data directly, so no login credentials, cookies, or official developer keys are required to execute a run.

How much does it cost to scrape 1,000 comments?

Results are billed at $0.005 per item, making 1,000 results cost $5.00 in result charges. Apify's free plan provides $5.00 of monthly usage which covers this exact volume without requiring a credit card.

Why do my scraped comment counts occasionally fall short of Reddit's displayed total?

Reddit's public comment counters often include items that were subsequently deleted or removed by moderators. The actor extracts every comment currently served by the public endpoints, but it cannot recover items that have already been purged.

Can I extract comments from a specific user profile instead of a post?

This actor focuses specifically on post comment threads and permalinks. If you need user profile histories, karma breakdowns, or submitted comments across a user account, use Reddit Profile Crawler Pro instead.

How does the actor handle rate limits or proxy blocks from Reddit?

Reddit blocks requests from datacenter IPs with HTTP 403, so the actor always routes requests through an Apify Residential proxy pinned to the US. This ensures high reliability without requiring any manual proxy configuration from the user.

Where to go next

When you are ready to run it, open Reddit Comment Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the Reddit Comment Scraper Actor page for the current input schema, pricing tier, and run history.

It is part of the Reddit Scraping Suite, which puts every related Actor on one page with its price and run history.

If you are comparing approaches rather than committing to one Actor, these category pages list every option we publish:

Comment scrapers covers 37 Actors in this family.

Readers running Reddit Comment Scraper commonly pair it with:

Reddit Profile Crawler Pro: Scrape Reddit user profiles with split karma (post/comment/awarder/awardee), account age, admin/employee/moderator badges, trophies, moderated subreddits, and recent comments.
Reddit MCP Scraper: Unified Reddit scraper supporting 3 modes: (1) Subreddit posts with content extraction, (2) Post comments with threading, (3) User profiles with metadata.
Reddit Keywords: Welcome to Reddit Keywords Scraper.
Reddit Scraper: Scrape entire subreddits with this crawler.
Reddit Video Downloader: Download videos from Reddit posts, subreddits, or user profiles.
Reddit Scraper Pro: Scrape Reddit subreddit posts with advanced filters (keywordFilter, minScore, maxAgeDays, excludeStickied, excludeNsfw, authorBlocklist, domainAllowlist/Blocklist).
Reddit Profile Crawler: Scrape reddit's profiles with posts and profile information.
Reddit Keywords Pro: Search Reddit by keywords with advanced filters like subredditFilter, subredditBlocklist, dateFrom/dateTo, minScore, maxAgeDays, excludeNsfw, authorBlocklist, keywordRequireAll.

Related guides:

Resources

Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-23.
Actor last updated by its maintainers on 2026-08-27.
Run outcome figures cover the 30 day public window ending 2026-09-23.
Reddit Comment Scraper on Apify