Reddit Comments Scraper

Reddit Comments Scraper is an Apify Actor for collecting Reddit comment threads from a thread URL, subreddit, user profile, or keyword. It accepts one or more inputs in queries, and each input produces comment records in a flat dataset where one record means one scraped comment. The returned fields include comment text, author, score, parent and reply relationships, timestamps, post metadata, and source metadata, so the output is ready for MCP, API, analytics, and LLM workflows.

Best fit and connected workflows

This Actor fits workflows that start with Reddit sources and need comment-level JSON:

• Thread analysis from a specific Reddit post URL, where parentId, depth, threadRelation, and numReplies help reconstruct the reply tree.
• Subreddit monitoring, where r/name or a subreddit name returns recent comments in a flat feed.
• User comment review, where a user profile input returns that user's comments with the same comment-level schema.
• Keyword-led discovery, where a search term finds matching threads and returns their comments.
• MCP-based agent flows, where an AI tool can pass a Reddit reference and receive structured comments for summarization, extraction, or classification.

This Actor is designed as a focused standalone workflow.

Practical scenario

Maya, a product researcher, has a Reddit thread URL, the subreddit name, and a keyword used by customers. She sends those three values in queries and keeps mode on auto. The dataset returns comment text, author, score, created time, permalink, and the post title for each comment. Maya uses score, depth, and parentId to identify the strongest reply chain, then follows the permalink to review context before sharing a summary with her team.

Input fields

Field	Type	Purpose
queries	array	Reddit sources to scrape comments from. Supports thread URLs, subreddits, user profiles, and keywords. Required.
mode	string	Interprets each queries item as auto, thread, subreddit, user, or search.
maxComments	integer	Caps the total number of comments returned across all inputs.
sort	string	Orders comments in a thread by Reddit sort: top, suitable, new, controversial, old, or qa.
includeReplies	boolean	Expands nested replies and collapsed comment stubs for thread and keyword inputs.
maxDepth	integer	Sets the maximum reply depth to traverse.
responseFormat	string	Chooses concise or detailed record shape.
filterCommentsByKeyword	boolean	In search mode, returns only comments containing the keyword when enabled.
proxy	object	Proxy configuration, with Apify Residential proxies as the default.
redditClientId	string	Optional Reddit app client ID for owner-supplied credentials.
redditClientSecret	string	Optional Reddit app client secret for owner-supplied credentials.

Focused JSON input example

{
  "queries": [
    "https://www.reddit.com/r/technology/comments/1abcd2e/some_thread/",
    "r/MachineLearning",
    "u/spez",
    "ChatGPT alternatives"
  ],
  "mode": "auto",
  "maxComments": 50,
  "sort": "top",
  "includeReplies": true,
  "maxDepth": 5,
  "responseFormat": "concise",
  "filterCommentsByKeyword": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

Output fields

The default dataset stores one item per comment. In concise mode, the core fields are compact and agent-friendly. In detailed mode, additional metadata is included.

Field	Type	Purpose
commentId	string	Comment identifier.
fullId	string	Full comment identifier.
parentId	string	Parent comment or post relationship.
postId	string	Reddit post identifier.
subreddit	string	Subreddit name.
postTitle	string	Post title.
postUrl	string	Reddit post URL.
author	string	Comment author.
body	string	Comment text.
score	integer	Comment score.
depth	integer	Reply depth.
isSubmitter	boolean	Indicates whether the commenter is the post author.
isEdited	boolean	Indicates whether the comment was edited.
createdAt	string	Comment creation time.
editedAt	string	Edit time, when present.
permalink	string	Direct comment link.
awardsCount	integer	Award count.
numReplies	integer	Number of replies.
inputMode	string	Routed input mode used for the record.
sourceInput	string	Original query value.
source	string	Data source used to serve the record.
bodyHtml	string	HTML body in detailed mode.
authorFlair	string	Author flair in detailed mode.
controversiality	integer	Reddit controversiality value in detailed mode.
stickied	boolean	Stickied flag in detailed mode.
distinguished	string	Distinguished value.
gilded	integer	Gilded count in detailed mode.
threadRelation	string	Thread relationship label.
_partial	boolean	Partial record flag.

Illustrative output record

{
  "commentId": "abc123",
  "fullId": "t1_abc123",
  "parentId": "t3_1abcd2e",
  "postId": "1abcd2e",
  "subreddit": "technology",
  "postTitle": "Some interesting thread",
  "postUrl": "https://www.reddit.com/r/technology/comments/1abcd2e/some_thread/",
  "author": "example_user",
  "body": "This is the comment text.",
  "score": 142,
  "depth": 0,
  "isSubmitter": false,
  "isEdited": false,
  "createdAt": "2026-06-02T14:30:00.000Z",
  "permalink": "https://www.reddit.com/r/technology/comments/1abcd2e/some_thread/abc123/",
  "awardsCount": 0,
  "numReplies": 3,
  "inputMode": "subreddit",
  "sourceInput": "r/technology",
  "source": "reddit-oauth"
}

How it works

The Actor uses a managed data-source chain described by the live contract:

1. Reddit OAuth is used when owner-managed Reddit credentials are configured.
2. ScrapeCreators is used as a managed fallback source.
3. SociaVault is used as an additional managed fallback source.

The live manifest also shows source telemetry in the dataset, so each record can indicate which source served it. The input schema routes each query item by shape when mode is set to auto, and includeReplies and maxDepth shape how deeply thread replies are traversed. The dataset schema exposes the comment table view with author, body, score, subreddit, postTitle, createdAt, and permalink.

Pricing

This Actor uses Pay per event pricing plus Apify platform usage. The primary event is Comment scraped, and the live Pricing tab shows the current per-event and platform usage details.

For example, a run that returns one hundred comments is billed as one hundred comment events, plus the Apify platform usage tied to the run. The final cost depends on the live Pricing tab and the amount of output produced by the Actor.

Use with AI agents (MCP)

This Actor is available as an Apify Actor usable through Apify MCP. It accepts a Reddit reference and returns structured comment JSON that can be fed into downstream agent steps such as summarization, topic extraction, moderation review, or field-level filtering.

Actor identity: khadinakbar/reddit-comments-scraper

Tool description: use this Actor when an agent needs comment-level Reddit data from a thread URL, subreddit, user profile, or keyword, with one dataset item per comment and source metadata included in each record.

Scrape the comments from this Reddit thread and return concise JSON for downstream analysis. Use the thread URL, keep nested replies enabled, and cap the result to 30 comments.

Output interpretation: the dataset contains one record per comment. body is the comment text, author is the account name, score shows the Reddit score, depth shows reply nesting, parentId connects reply chains, and permalink points to the source comment.

Provenance: each record includes sourceInput, inputMode, and source so an agent can track which input produced the item and which managed source served it.

Scope and pagination: maxComments is the hard cap for the run, and the Actor stops once that cap is reached. For thread inputs, includeReplies and maxDepth shape how far reply trees are expanded. For subreddit and user inputs, the returned feed is flat by nature.

Cost guidance: because billing is tied to returned comments, keeping maxComments aligned with the agent task size helps keep the payload and billed events aligned.

Apify API example

JavaScript:

const { ApifyClient } = require("apify-client");

(async () => {
  const client = new ApifyClient({
    token: process.env.APIFY_TOKEN,
  });

  const run = await client.actor("khadinakbar/reddit-comments-scraper").call({
    queries: ["r/technology"],
    mode: "auto",
    maxComments: 10,
    responseFormat: "concise",
  });

  const { items } = await client.dataset(run.defaultDatasetId).listItems({
    clean: true,
  });

  console.log(items);
})();

Set APIFY_TOKEN in your environment before running the example.

Best results and outcome guidance

• Use a thread URL when you need full reply context around a specific discussion.
• Use auto mode for mixed input lists, since the Actor detects thread, subreddit, user, and keyword patterns per item.
• Use concise when the next step is an AI model or a lightweight pipeline.
• Use detailed when you need comment metadata such as HTML body, flair, controversiality, or stickied status.
• Keep maxComments aligned with the amount of comment coverage you need.
• Use includeReplies and maxDepth to shape how deep the thread traversal should go.

Focused standalone workflow

This Actor is designed as a focused standalone workflow.

Design note

I found that the dataset contract is centered on a single comment record schema, with author, body, score, subreddit, postTitle, createdAt, and permalink highlighted in the overview table view.

FAQ

Can I mix thread URLs, subreddits, users, and keywords in one run?

Yes. The queries array accepts mixed input types, and auto mode routes each item by shape.

What does one output record represent?

One output record represents one scraped Reddit comment.

When should I use thread instead of auto?

Use thread when you want every input item treated as a post URL, especially in workflows where the source format is already known.

When should I use search?

Use search when a keyword input should be routed as search text rather than interpreted as a subreddit or another source shape.

What fields help me rebuild comment context?

commentId, parentId, postId, depth, threadRelation, and permalink are the main fields for reconstructing context.

Responsible use

This Actor collects public Reddit comments for analysis, research, and workflow automation. Use the data in ways that respect Reddit source availability, applicable law, and the rights and expectations of the people who wrote the comments. For workflows that involve personal data handling, keep your use aligned with your own compliance requirements and data-governance practices.