# Reddit Comment Scraper With Author Profile (`simpleapi/reddit-comments-scraper`) Actor

Reddit Comments Scraper provides clean Reddit comment datasets for analysis. Track conversation flow, engagement signals, and user feedback across threads for research, insights, and data analytics use cases.

- **URL**: https://apify.com/simpleapi/reddit-comments-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 10 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 — Comments, Karma and Account Age

Reddit Comment Scraper With Author Profile extracts comments from any public Reddit post and enriches every unique commenter with their real Reddit profile data — total karma, post/comment karma split, account creation date, Reddit Gold status, and recent activity. No Reddit login is required. It's built for community research, brand-mention monitoring, and audience analysis that needs to know not just what was said, but who's saying it and how established they are on the platform.

### What is Reddit Comment Scraper With Author Profile?

Reddit Comment Scraper With Author Profile is an Apify Actor that scrapes comments from Reddit posts — either ones you name directly or ones discovered via subreddit/search URLs or a keyword — and optionally enriches each unique commenter with their real public profile data. Key capabilities:

- Scrape comments from direct post URLs, or discover posts via subreddit listing/search URLs and a site-wide keyword search
- Choose comment sort order (hot, new, top, controversial, old) and control nested-reply depth
- Filter comments by a date range (`sinceDate`/`untilDate`)
- Optionally enrich each unique commenter with real total/post/comment karma, account creation date, and Reddit Gold status — one lookup per author, reused across all their comments
- Optionally pull each author's recent public comment history to populate a real activity count
- Automatic proxy fallback (direct → datacenter → residential) on blocks

### What data can I extract with Reddit Comment Scraper With Author Profile?

| Field | Example Value | Use Case |
| --- | --- | --- |
| `author` / `contentText` | `"reddit_user_42"` / `"This is really insightful..."` | Identify the commenter and read their comment |
| `upvotes` / `created_time` | `142` / `"2026-07-20T10:00:00Z"` | Gauge engagement and timing |
| `comment_id` / `post_id` / `parent_id` | comment ID / post ID / parent comment ID | Reconstruct thread structure |
| `permalink` / `userUrl` | comment link / author profile link | Direct links to the comment and commenter |
| `discovered_via` / `discovered_post_title` | `"searchQuery"` / `"These are all AI generated..."` | Trace which discovery path and post surfaced this comment |
| `authorProfile.totalKarma` / `postKarma` / `commentKarma` | `48200` / `12000` / `36200` | Real, current karma split for the commenter |
| `authorProfile.accountCreatedUtc` | `"2015-03-12T00:00:00Z"` | Gauge account age/establishment |
| `authorProfile.isGold` | `false` | Identify Reddit Gold members |
| `authorProfile.recentActivityCount` | `18` | Gauge how active this commenter currently is |

#### Real author enrichment, not inferred

When `enrichAuthorProfile` is on, each unique commenter's public `about.json` is fetched exactly once (reused across every comment by that author in the run) to add `totalKarma`, `postKarma`, `commentKarma`, `accountCreatedUtc`, `isGold`, and a real profile avatar — genuine Reddit account data, not estimated. `includeRecentActivity` additionally counts each author's other comments already collected in this run (free, no extra request) and, when enabled, pulls their real recent public comment history via `/user/<name>/comments.json` to populate `recentActivityCount` with a true activity signal rather than just an in-run tally.

#### Discovery, sorting, and reply depth

`sourcePostUrls` scrapes named posts directly; `searchUrls`/`searchQuery` discover posts via subreddit listings, Reddit search URLs, or a plain site-wide keyword, up to `maxPostsToDiscover`. `sortCommentsBy` controls Reddit's own comment ordering before fetching. `maxRepliesPerComment` bounds the nested `replies` field's depth, though every reply is still collected in the flattened output regardless of this cap.

### Why not build this yourself?

Reddit's official API now requires OAuth app registration and rate-limits unauthenticated third-party access heavily, and its data endpoints have shifted enough that a naive scraper built against the old public JSON endpoints breaks. Building an equivalent tool yourself means handling that platform-level access lockout, maintaining a working comment-tree traversal and flattening approach, and adding per-author enrichment with proper request deduplication (one `about.json` call per unique author, not per comment). All of that is already implemented in this Actor's source.

### How to use data extracted from Reddit?

#### Community and audience research

Scrape comments from a subreddit's top posts and use `authorProfile.totalKarma`/`accountCreatedUtc` to distinguish established community members from new accounts, informing how representative the discussion is of the subreddit's core audience.

#### Brand-mention monitoring

Use `searchQuery` to find comments mentioning your brand across Reddit, then check `authorProfile.recentActivityCount` and karma to prioritize responding to established, active users over low-effort or new accounts.

#### Market and sentiment research

Compare comment volume and `upvotes` across multiple `sourcePostUrls` in the same topic area to see which discussion threads generated the most genuine engagement.

#### AI agents and automated pipelines

An agent can call this Actor to pull comment threads for sentiment analysis, using `authorProfile.totalKarma` as a trust/credibility signal when weighting which comments to surface in a summary.

### 🔼 Input sample

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `sourcePostUrls` | No | array | Reddit post URLs to scrape comments from | `["https://www.reddit.com/r/ChatGPT/comments/1epeshq/..."]` |
| `maxCommentsToScan` | No | integer (1-10,000) | Max comments extracted per post | `100` (default) |
| `sortCommentsBy` | No | string (enum) | `hot` (default), `new`, `top`, `controversial`, `old` | `"hot"` |
| `maxRepliesPerComment` | No | integer (0-100) | Nested-reply depth stored in `replies`; `0` = unlimited | `2` (default) |
| `searchUrls` | No | array | Subreddit listing/search URLs to discover posts from | `["https://www.reddit.com/r/ChatGPT/"]` |
| `searchQuery` | No | string | Site-wide keyword to discover matching posts | `"gpt5"` |
| `maxPostsToDiscover` | No | integer (1-500) | Max posts discovered from search URLs/query combined | `10` (default) |
| `safeSearch` | No | boolean | Skip NSFW posts found via discovery | `false` (default) |
| `sinceDate` / `untilDate` | No | string (date) | Only keep comments in this date range | `"3 days"` / `""` |
| `enrichAuthorProfile` | No | boolean | Fetch real karma/account-age per unique commenter | `false` (default) |
| `includeRecentActivity` | No | boolean | Pull real recent comment history per author | `false` (default) |
| `maxRecentActivityItems` | No | integer (1-100) | Recent comments fetched per author when enabled | `20` (default) |
| `proxyConfig` | No | object | Proxy config; auto-escalates on blocks | `{"useApifyProxy": true}` |

```json
{
  "sourcePostUrls": ["https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/"],
  "maxCommentsToScan": 200,
  "enrichAuthorProfile": true,
  "includeRecentActivity": true
}
```

**Common pitfall:** `enrichAuthorProfile` and `includeRecentActivity` add extra requests per unique author (not per comment) — a post with 200 comments from 50 unique authors costs 50 extra enrichment requests, not 200.

### 🔽 Output sample

Output is typed, normalized JSON — one row per comment, with author enrichment nested under `authorProfile` when enabled (exportable as JSON, CSV, or Excel).

```json
{
  "url": "https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/",
  "comment_id": "lg8x9k2",
  "post_id": "1epeshq",
  "author": "reddit_user_42",
  "permalink": "https://www.reddit.com/r/ChatGPT/comments/1epeshq/.../lg8x9k2/",
  "upvotes": 142,
  "content_type": "comment",
  "parent_id": null,
  "author_avatar": "https://styles.redditmedia.com/...",
  "userUrl": "https://www.reddit.com/user/reddit_user_42",
  "contentText": "This is really insightful, thanks for sharing.",
  "created_time": "2026-07-20T10:00:00Z",
  "discovered_via": "directUrl",
  "discovered_post_title": "These are all AI generated...",
  "authorProfile": {
    "totalKarma": 48200,
    "postKarma": 12000,
    "commentKarma": 36200,
    "accountCreatedUtc": "2015-03-12T00:00:00Z",
    "isGold": false,
    "recentActivityCount": 18
  }
}
```

All 20 fields shown above (with `authorProfile` flattened in the default view) are the Actor's real dataset columns.

### How do you filter and target specific comments?

`sourcePostUrls` versus `searchUrls`/`searchQuery` is the direct-vs-discovery axis — name exact posts, or let the Actor discover them by subreddit/search URL or site-wide keyword. `sinceDate`/`untilDate` is the scope-precision control for filtering comments to a date range. `sortCommentsBy` doesn't filter but changes which comments surface first within `maxCommentsToScan`. Volume is controlled by `maxCommentsToScan` per post, `maxPostsToDiscover` for discovery mode, and `maxRepliesPerComment` for nested-reply depth.

```json
{ "searchQuery": "gpt5", "maxPostsToDiscover": 20, "sortCommentsBy": "top", "sinceDate": "1 week" }
```

```json
{ "searchUrls": ["https://www.reddit.com/r/ChatGPT/"], "safeSearch": true, "enrichAuthorProfile": true }
```

```json
{ "sourcePostUrls": ["https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/"], "maxRepliesPerComment": 0 }
```

### ▶️ Want to try other social/community scrapers?

| Scraper Name | What it extracts |
| --- | --- |
| Instagram Comments Scraper (Spam & Toxic Comment Detection) | Comparable comment-moderation flags for Instagram |
| Facebook Comments Scraper: Sentiment & Toxicity Analysis | Comparable comment engagement/moderation data for Facebook |
| LinkedIn Post Scraper & Comments Reactions | Comparable comment/reaction data for LinkedIn |
| Instagram Mentions Scraper & Sentiment Analysis | Comparable brand-mention monitoring for Instagram |
| Google Trends Scraper: Rising & Breakout Keywords | Comparable topic/keyword research |
| Instagram Related Hashtag Stats Scraper By Keyword Search | Comparable keyword-to-content discovery |

### How to extract Reddit data programmatically

Every run is a standard Apify Actor call — one API request with your token, JSON input, JSON results back. No Reddit login required.

#### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run_input = {
    "sourcePostUrls": ["https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/"],
    "enrichAuthorProfile": True,
}

run = client.actor("<YOUR_USERNAME>/reddit-comment-scraper-with-author-profile").call(run_input=run_input)

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["author"], row["authorProfile"]["totalKarma"], row["contentText"][:60])
```

#### Export to spreadsheets or CRM

Export the dataset directly as CSV or Excel, then map `author`/`userUrl` to your CRM's contact fields and `authorProfile.totalKarma`/`recentActivityCount` to a credibility-scoring column.

### Is it legal to scrape Reddit comments?

Usernames, karma, account age, and comment text are personal data tied to individual Reddit accounts, so GDPR and CCPA obligations apply to storing and using this data. Public Reddit posts and profiles are visible to any logged-out visitor, but downstream storage of individual users' comments and profile data should follow applicable data-protection rules. Consult legal counsel for commercial applications involving bulk storage of personal data.

### ❓ FAQ

#### How accurate is the karma data?

It's fetched directly from each commenter's real, current public Reddit profile (`about.json`) — not estimated or cached from an old snapshot.

#### Does enrichment cost extra per comment or per author?

Per unique author — each commenter's profile is fetched once regardless of how many comments they made in the scraped result, and that data is reused across all their comments.

#### How many comments can I get per post?

`maxCommentsToScan` (1-10,000, default 100) caps this per post.

#### Do I need a Reddit account to use this?

No — the Actor reads Reddit's public post and profile pages, requiring no login.

#### Does Reddit Comment Scraper With Author Profile work with Claude, ChatGPT, and AI agent frameworks?

It has no dedicated MCP server registration in this Actor's current setup, but it is callable as a standard Apify API endpoint by any agent framework that can make an authenticated HTTP request and parse JSON.

#### How does this compare to other Reddit comment scrapers?

No independently verifiable competitor listing could be confirmed at the time of writing, so no specific comparison is made here. This Actor's distinguishing feature is genuine per-author karma/account-age/activity enrichment, deduplicated per unique commenter rather than refetched per comment.

#### Can I discover posts without knowing exact URLs?

Yes — use `searchUrls` (subreddit listings or Reddit search URLs) or `searchQuery` (a site-wide keyword) instead of `sourcePostUrls`, up to `maxPostsToDiscover`.

### Conclusion

Reddit Comment Scraper With Author Profile turns a post or subreddit into structured comments plus real commenter profile data — genuine karma, account age, and activity signals, deduplicated per author, not per comment. It's built for community research, brand monitoring, and audience analysis that needs to know who's talking, not just what they said. Start a run with your post URLs or a search query to get comments and author profiles back in one pass.

# Actor input Schema

## `sourcePostUrls` (type: `array`):

📋 One or more Reddit post URLs to scrape comments from. Example: https://www.reddit.com/r/subreddit/comments/post\_id/title/. (Also accepts the base `startUrls` key.)

## `maxCommentsToScan` (type: `integer`):

⚙️ Maximum number of comments to extract from each Reddit post. Range 1-10,000. Default is 100. (Also accepts the base `maxComments` key.)

## `sortCommentsBy` (type: `string`):

📶 How Reddit should sort comments before they are fetched. Default is 'hot'. (Also accepts the base `sortOrder` key.)

## `maxRepliesPerComment` (type: `integer`):

🌳 Depth of nested replies stored in the `replies` field. 0 = unlimited depth. All replies are still collected in the flattened output regardless. Default is 2. (Also accepts the base `replyLimit` key.)

## `searchUrls` (type: `array`):

🕵️ Paste subreddit listing URLs (e.g. https://www.reddit.com/r/ChatGPT/) or Reddit search URLs (e.g. https://www.reddit.com/r/ChatGPT/search/?q=gpt5) to discover posts to scrape, instead of pasting individual post URLs.

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

💡 A plain keyword/phrase to search Reddit site-wide for matching posts (used together with or instead of 🌐 Subreddit / Search URLs).

## `maxPostsToDiscover` (type: `integer`):

📈 Maximum number of posts to discover in total from 🌐 Subreddit / Search URLs and 🔑 Keyword Search Query combined. Ignored when only direct 🔗 Reddit Post URLs are used.

## `safeSearch` (type: `boolean`):

🔞 When enabled, skip over\_18/NSFW posts found via discovery. Has no effect on directly-provided 🔗 Reddit Post URLs.

## `sinceDate` (type: `string`):

⏱️ Only keep comments created on/after this date. Accepts an absolute date or a relative value like `3 days`/`1 week`.

## `untilDate` (type: `string`):

⏱️ Only keep comments created on/before this date. Accepts an absolute date or a relative value like `3 days`/`1 week`.

## `enrichAuthorProfile` (type: `boolean`):

🔎 When enabled, fetches each unique commenter's public `about.json` once and adds real totalKarma, postKarma, commentKarma, accountCreatedUtc, isGold, and a real profile avatar (`author_avatar`) to every one of their comments. Unchecked = base behavior (no enrichment call, avatar left blank).

## `includeRecentActivity` (type: `boolean`):

🗂️ When enabled, counts each unique author's other comments already collected in this run (dedup pass) AND pulls their recent public /comments.json history to populate `authorProfile.recentActivityCount`. Unchecked = skip the extra activity lookup (still counts in-run comments for free).

## `maxRecentActivityItems` (type: `integer`):

⚙️ Maximum number of recent comments to fetch from an author's public profile (`/user/<name>/comments.json`) when 'Include Author Recent Activity' is enabled. Range 1-100. Default is 20.

## `proxyConfig` (type: `object`):

🛡️ Proxy settings for reliable scraping. By default no proxy is used; on a block the actor automatically falls back to datacenter, then residential proxy with retries, and also uses this proxy for the author-enrichment/activity requests. (Also accepts the base `proxyConfiguration` key.)

## Actor input object example

```json
{
  "sourcePostUrls": [
    "https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/"
  ],
  "maxCommentsToScan": 100,
  "sortCommentsBy": "hot",
  "maxRepliesPerComment": 2,
  "searchUrls": [],
  "maxPostsToDiscover": 10,
  "safeSearch": false,
  "enrichAuthorProfile": false,
  "includeRecentActivity": false,
  "maxRecentActivityItems": 20,
  "proxyConfig": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "sourcePostUrls": [
        "https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/"
    ],
    "maxCommentsToScan": 100,
    "sortCommentsBy": "hot",
    "maxRepliesPerComment": 2,
    "searchUrls": [],
    "searchQuery": "",
    "maxRecentActivityItems": 20,
    "proxyConfig": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/reddit-comments-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 = {
    "sourcePostUrls": ["https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/"],
    "maxCommentsToScan": 100,
    "sortCommentsBy": "hot",
    "maxRepliesPerComment": 2,
    "searchUrls": [],
    "searchQuery": "",
    "maxRecentActivityItems": 20,
    "proxyConfig": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/reddit-comments-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 '{
  "sourcePostUrls": [
    "https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/"
  ],
  "maxCommentsToScan": 100,
  "sortCommentsBy": "hot",
  "maxRepliesPerComment": 2,
  "searchUrls": [],
  "searchQuery": "",
  "maxRecentActivityItems": 20,
  "proxyConfig": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/reddit-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/FPy4fkrO4xshmN0Za/builds/TARMoJBUzWkUX61EJ/openapi.json