Reddit User Profile Posts and Comments Scraper User Comments

Reddit User Scraper — Posts, Authored Comments and Block Status

Scrape a Reddit user's submitted posts and their own authored comment history in one run, plus a per-user diagnostic row that tells you whether a zero-result run means "no activity" or "blocked." Every response is structured JSON — ready to pass directly to an LLM, index into a vector store, or feed a monitoring pipeline. Give it a username, a u/ handle, a profile URL, or a keyword:term search, and get back typed rows for posts, comments, and run status, streamed to the dataset as soon as each is parsed.

What is the Reddit User Scraper?

This is an Apify Actor that queries Reddit's public listing feeds for a given user (or a keyword search) and returns two kinds of activity — the posts they submitted and the comments they personally wrote — as separate, typed dataset rows. It does not require a Reddit account, login, or API key; it reads the same public feeds any visitor's browser can load. What sets it apart from a plain "posts" scraper is the user_summary row it emits per target: an uncharged accounting row carrying a blocked flag and the set of subreddits touched, so a run that returns zero rows is never silently indistinguishable from a user who has posted nothing.

Key capabilities:

• 📝 Submitted posts — full canonical Reddit post object (title, selftext, subreddit, score, flair, media, timestamps)
• 💬 Authored comments — the user's own comment history, parsed from old.reddit.com/user/<name>/comments, as separate rows
• 🗨️ Reply comments per post — optionally attach top-level comments made on each post as a nested array
• 🔍 Keyword search — keyword:term targets return matching posts instead of a user's feed
• 🗂️ Independent sort control — posts and authored comments each have their own sort order (new, hot, top, controversial)
• 📄 Optional full-text enrichment — per-post JSON lookup for untruncated selftext, preview images, and subreddit subscriber counts

What data can you get with the Reddit User Scraper?

The Actor returns four row types in one dataset, distinguished by a type field: post, comment, user_summary, and (as a nested array on post rows) reply comments.

Result Type	Extracted Fields (highlights)	Primary Use Case
Submitted posts	title, selftext, subreddit, author, score, num_comments, permalink, created_utc, preview, media, plus the full canonical Reddit post schema	Content research, engagement analysis, dataset building
Authored comments	body, subreddit, score, created_utc, link_title, is_submitter, distinguished	Sentiment mining, persona/community analysis
Reply comments (nested on a post)	id, author, body, score, created_utc, permalink, replies_count	Thread-level engagement on a user's own posts
Per-user summary (diagnostic)	postsCollected, commentsCollected, uniqueSubreddits, uniqueSubredditCount, blocked, scrapedAt	Run-health monitoring, distinguishing "no activity" from "blocked"

Block Status: the user_summary diagnostic row

None of the three competing Reddit user scrapers checked for this comparison (louisdeconinck/reddit-user-profile-posts-scraper, simpleapi/reddit-user-profile-posts-and-comments-scraper, signalengine/reddit-user-scraper — Apify Store, checked 2026-07-26) document a row that tells you why a target returned nothing. This Actor pushes one user_summary row per target — uncharged, so it costs nothing extra — with an explicit blocked boolean and a uniqueSubreddits list built from both the post and comment feeds combined:

{
  "type": "user_summary",
  "isChild": false,
  "target": "cyPersimmon9",
  "targetKind": "user",
  "postsCollected": 8,
  "commentsCollected": 50,
  "uniqueSubreddits": ["python", "learnprogramming", "AskReddit"],
  "uniqueSubredditCount": 3,
  "blocked": false,
  "scrapedAt": "2026-07-25T09:14:02Z"
}

When every proxy tier returns zero results on the first page, blocked flips to true — so a monitoring pipeline can alert on "this account went dark" instead of misreading it as "this account posted nothing this week."

Authored comments: the headline capability of this variant

Authored comments are parsed from old.reddit.com/user/<name>/comments — a feed the JSON .json endpoint does not reliably serve inside Apify's container, so this path always goes straight to the HTML fallback rather than trying JSON first. Each comment is pushed as its own row (type: "comment", isChild: true) and mirrored, uncharged, to a per-run child dataset named user-comments-<runId>. A profile with 8 posts and maxUserComments=50 yields up to 8 post rows + 50 comment rows + 1 summary row in a single run.

Why not build this yourself?

Reddit's listing and per-thread JSON endpoints are undocumented for this use case, change shape without notice, and are aggressively bot-walled inside datacenter and container environments — flagged IPs get a silent HTTP 200 with an empty children array instead of an error, which looks identical to "this user has no posts" unless you specifically detect it. Building a reliable version yourself means maintaining Chrome-grade TLS/HTTP2 fingerprinting, a residential proxy rotation ladder, retry logic for 403/429/503 responses, an old.reddit.com HTML parser as a fallback when JSON is walled, and ongoing maintenance as Reddit's markup shifts. This Actor packages all of that — impersonated Chrome requests via impit, a residential-first proxy ladder with automatic escalation, silent-block detection, and an HTML fallback parser — so you send a username and get structured JSON back.

What is the difference between a post scraper and a comment history scraper?

A Reddit post scraper returns only what a user submitted — link posts and self-posts, found under /user/<name>/submitted. A Reddit comment history scraper returns what a user personally wrote in reply to other people's threads, found under a separate feed at /user/<name>/comments. The two are not interchangeable: a highly active commenter can have zero submitted posts, and a prolific poster can rarely comment. Community researchers who query only the submitted-posts feed (as several competing "Reddit user" scrapers do) miss the comment half of a user's public footprint entirely. This Actor returns both, as distinct row types in the same dataset — posts arrive with type: "post", authored comments with type: "comment" and isChild: true — so a reader can filter for either signal, or both, from a single run.

How to scrape Reddit user activity with this Actor?

1. Open the Actor on its Apify Store listing and click Try for free (or Run if you already have it in your account).
2. Enter one or more targets in startUrls — a bare username, a u/ handle, a full profile URL, or keyword:term for a search.
3. Set the query controls that matter for your job: sortOrder for post ordering, userCommentSort for comment ordering, maxPosts and maxUserComments for caps.
4. Click Start to launch the run.
5. Open the Dataset tab when the run finishes and export as JSON, CSV, or Excel — or pull it programmatically via the Apify API.

How to scrape multiple Reddit users in one job

startUrls accepts an array, so you can mix usernames, profile URLs, and keyword: searches in a single run — each is processed as an independent target with its own summary row. There is no documented concurrency setting for this Actor; targets are processed sequentially within one run, and each is charged per row returned, not per target.

⬇️ Input

Every field below is read directly from the Actor's input schema. startUrls is the only required field.

Parameter	Required	Type	Constraints	Description
startUrls	Yes	array (stringList)	—	One or more Reddit targets. Each entry can be a bare username (cyPersimmon9), a u/ handle (u/cyPersimmon9), a full profile URL (https://www.reddit.com/user/cyPersimmon9), or a keyword search (keyword:python). Authored-comment collection applies to user targets only; keyword targets return posts.
includeUserComments	No	boolean	default true	When on, fetch the user's own written comments in addition to their posts. Example: a profile with 8 posts and maxUserComments=50 yields up to 8 post rows + 50 comment rows + 1 summary row. Keyword targets are unaffected.
maxUserComments	No	integer	default 50, min 0, max 1000	Cap on authored comments collected per user (0 = skip). A user's comment feed serves at most ~1000 most-recent comments.
userCommentSort	No	string enum	default "new"; one of "new", "top", "controversial", "hot"	Ordering applied to the user's authored-comment feed.
sortOrder	No	string enum	default "new"; one of "new", "hot", "top", "controversial"	How submitted posts are ordered: new (recent), hot (trending), top (highest scored), controversial (most debated).
maxPosts	No	integer	default 50, min 1, max 1000	Maximum submitted posts collected per profile or keyword. A user's post feed serves at most ~1000 most-recent posts.
fetchSelftext	No	boolean	default true	Attempt per-post enrichment via Reddit's per-thread JSON (full untruncated selftext, preview, subreddit_subscribers, video media). This endpoint is frequently bot-walled in-container, so listing-level fidelity is what is reliably returned.
maxComments	No	integer	default 0, min 0, max 100	Attach up to this many top-level comments made on each post as a comments array on the post row. Distinct from the user's own authored comments. Sourced from per-thread JSON — may be empty when Reddit walls it.
proxyConfiguration	No	object (proxy editor)	default: Apify residential	Proxy settings. Default routes through Apify residential proxy with retries. If you supply a custom proxy (proxyUrls or a non-residential Apify proxy group), it is tried first, then residential is used as a fallback.

Example input

{
  "startUrls": ["spez", "u/kn0thing", "keyword:python"],
  "includeUserComments": true,
  "maxUserComments": 50,
  "userCommentSort": "new",
  "sortOrder": "new",
  "maxPosts": 25,
  "fetchSelftext": true,
  "maxComments": 0,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}

Common pitfall: keyword: targets never return authored comments, regardless of includeUserComments — comment history collection requires a resolvable username. If a keyword target isn't returning comment rows, that's expected behavior, not a bug.

⬆️ Output

Every row is typed, normalized JSON pushed to the Actor's default dataset the moment it is parsed, so partial runs are preserved if a run stops early. Export as JSON, CSV, or Excel from the Dataset tab, or pull it via the Apify API. Authored-comment rows are additionally mirrored, uncharged, to a per-run dataset named user-comments-<runId>.

⚠️ fetchSelftext enrichment and the maxComments reply array both depend on Reddit's per-thread JSON endpoint, which is frequently bot-walled inside Apify's container. When that happens, posts fall back to listing-level fields (still a complete row — every one of the 109 canonical keys is present) and the comments array may come back empty rather than populated.

The default dataset view surfaces 19 columns: type, isChild, author, subreddit, title, body, score, num_comments, permalink, link_title, created_utc, publishedAt, is_self, selftext, url, link_permalink, preview, media, comments. This is a display subset — every row carries substantially more keys than the table shows, documented in full below.

Post row fields (109 keys, type: "post")

Canonical Reddit post schema, in push order. Two fields are added by this Actor on top of Reddit's own schema: isChild (always false on a post row) and publishedAt (ISO-8601 UTC, derived from created_utc). upvote_ratio is deliberately returned as null rather than a fabricated value — Reddit's HTML listing does not expose it, so this Actor reports the gap honestly instead of shipping a fake 0.0.

Field	Description	Field	Description
type	Always "post" on this row type	approved_at_utc	Timestamp a moderator approved the post, if any
subreddit	Subreddit name, no prefix	selftext	Full self-post text
author_fullname	Author's Reddit fullname (t2_...)	saved	Whether the post is saved (always false for a fresh scrape)
mod_reason_title	Moderation reason title, if any	gilded	Number of times the post received Reddit gold
clicked	Whether the post has been clicked	title	Post title
link_flair_richtext	Rich-text formatting for the post's flair	subreddit_name_prefixed	Subreddit with r/ prefix, as Reddit renders it
hidden	Whether the post is hidden	pwls	Whitelist status code
link_flair_css_class	CSS class for the post's flair	downs	Downvote count (Reddit no longer exposes this separately; typically 0)
thumbnail_height	Thumbnail image height in px	top_awarded_type	Type of the top award received
hide_score	Whether the score is hidden	name	Fullname (t3_<id>)
quarantine	Whether the post is from a quarantined subreddit	link_flair_text_color	Flair text color
upvote_ratio	Always null — not fabricated; the HTML source has no equivalent field	author_flair_background_color	Author flair background color
subreddit_type	e.g. public, restricted	ups	Upvote count
total_awards_received	Total awards on the post	media_embed	Embedded media details, when present
thumbnail_width	Thumbnail image width in px	author_flair_template_id	Author's flair template ID
is_original_content	Whether marked as OC	user_reports	User-submitted reports (visible only to mods; empty for a public scrape)
secure_media	Secure media details, when present	is_reddit_media_domain	Whether media is hosted on Reddit
is_meta	Whether the post is flagged meta	category	Post category, when set
secure_media_embed	Secure embedded media details	link_flair_text	Post flair text
can_mod_post	Whether the viewer can moderate the post	score	Overall score (upvotes minus downvotes)
approved_by	Approving moderator's username, if any	is_created_from_ads_ui	Whether created via the ads UI
author_premium	Whether the author has Reddit Premium	thumbnail	Thumbnail image URL, or "self" for text posts
edited	Edit timestamp, or false if never edited	author_flair_css_class	CSS class for the author's flair
author_flair_richtext	Rich-text formatting for the author's flair	gildings	Gilding counts by award type
post_hint	e.g. "self", "link", "image"	content_categories	Content categories, when set
is_self	Whether it's a text (self) post	mod_note	Moderator note, if any
created	Unix timestamp of creation (local)	link_flair_type	Flair rendering type, e.g. "text"
wls	Whitelist status	removed_by_category	Category the post was removed under, if applicable
banned_by	Banning moderator's username, if any	author_flair_type	Author flair rendering type
domain	Domain of the linked content	allow_live_comments	Whether live comments are allowed
selftext_html	HTML-rendered self-post text	likes	Viewer's own vote on the post (always null for an unauthenticated scrape)
suggested_sort	Suggested comment sort for the thread	banned_at_utc	Ban timestamp, if applicable
view_count	View count, when exposed	archived	Whether the post is archived
no_follow	Whether outbound links are nofollow	is_crosspostable	Whether the post can be crossposted
pinned	Whether the post is pinned	over_18	NSFW flag
preview	Preview image object (images, enabled)	all_awardings	All awards received
awarders	Users who gave awards	media_only	Whether the post is media-only
can_gild	Whether the post can receive gold	spoiler	Spoiler flag
locked	Whether comments are locked	author_flair_text	Author flair text
treatment_tags	Internal Reddit treatment tags	visited	Whether the viewer has visited the post
removed_by	Removing moderator's username, if any	num_reports	Report count (mod-only; empty for a public scrape)
distinguished	"admin" / "moderator", when applicable	subreddit_id	Subreddit fullname
author_is_blocked	Whether the author is blocked by the viewer	mod_reason_by	Moderator who added a mod reason
removal_reason	Removal reason text, if removed	link_flair_background_color	Flair background color
id	Post ID	is_robot_indexable	Whether search engines may index the post
report_reasons	Report reason list (mod-only)	author	Author's username
discussion_type	Discussion type, when set	num_comments	Total comment count on the post
send_replies	Whether the author receives reply notifications	contest_mode	Whether contest mode is enabled
mod_reports	Moderator reports (mod-only)	author_patreon_flair	Whether the author has a Patreon flair
author_flair_text_color	Author flair text color	permalink	Relative URL to the post
stickied	Whether the post is stickied	url	Full URL of the post (or linked content)
subreddit_subscribers	Subreddit subscriber count	created_utc	Unix epoch (UTC) of creation
num_crossposts	Number of crossposts	media	Media object, when present
is_video	Whether the post contains video	isChild	Added by this Actor — always false on a post row
publishedAt	Added by this Actor — ISO-8601 UTC, derived from created_utc	comments	Present only when maxComments > 0 — nested reply array, see below

When maxComments > 0, each post row also carries a comments array. Each entry has: id, author, body, score, created_utc, permalink, replies_count (count of direct replies to that comment).

Comment row fields (21 keys, type: "comment", isChild: true)

Field	Description
type	Always "comment"
isChild	Always true
id	Comment ID
name	Fullname (t1_<id>)
author	Comment author (the target user)
author_fullname	Author's Reddit fullname, when present in the HTML
parentAuthor	The username this comment feed belongs to
subreddit	Subreddit the comment was posted in
subreddit_name_prefixed	Subreddit with r/ prefix, as Reddit renders it
subreddit_id	Subreddit fullname
body	Comment text
score	Comment score; null when Reddit hides it on very new comments
created_utc	Unix epoch timestamp
publishedAt	ISO-8601 UTC timestamp
permalink	Relative URL to the comment
link_title	Title of the parent post the comment replied to
link_permalink	URL of the parent post
is_submitter	Whether the commenter was the original poster of that thread
distinguished	"admin" / "moderator" when applicable, else null
controversiality	Always null — this is a .json-only field with no HTML equivalent
commentSource	Provenance marker, always "old_reddit_html"

Per-user summary row fields (10 keys, type: "user_summary", uncharged)

Field	Description
type	Always "user_summary"
isChild	Always false
target	The username or keyword scraped
targetKind	"user" or "keyword"
postsCollected	Post rows pushed for this target
commentsCollected	Comment rows pushed for this target
uniqueSubreddits	Sorted list of distinct subreddits seen across posts and comments
uniqueSubredditCount	Length of uniqueSubreddits
blocked	true when both post and comment counts are zero (silent-block or genuinely no activity)
scrapedAt	ISO-8601 UTC timestamp of when this target finished

Scraped results

[
  {
    "type": "post",
    "id": "145bram",
    "name": "t3_145bram",
    "author": "spez",
    "title": "Addressing the community about changes to our API",
    "selftext": "Dear redditors, ...",
    "subreddit": "reddit",
    "subreddit_name_prefixed": "r/reddit",
    "score": 0,
    "ups": 0,
    "upvote_ratio": null,
    "num_comments": 33886,
    "permalink": "/r/reddit/comments/145bram/addressing_the_community_about_changes_to_our_api/",
    "url": "https://www.reddit.com/r/reddit/comments/145bram/addressing_the_community_about_changes_to_our_api/",
    "created_utc": 1686332653,
    "publishedAt": "2023-06-09T21:24:13Z",
    "is_self": true,
    "over_18": false,
    "spoiler": false,
    "distinguished": "admin",
    "preview": { "images": [], "enabled": false },
    "media": null,
    "isChild": false
  },
  {
    "type": "comment",
    "isChild": true,
    "id": "jnkd694",
    "name": "t1_jnkd694",
    "author": "spez",
    "parentAuthor": "spez",
    "subreddit": "reddit",
    "subreddit_name_prefixed": "r/reddit",
    "body": "Apologies for the delay. We are responding now.",
    "score": -1756,
    "created_utc": 1686337071,
    "publishedAt": "2023-06-09T22:44:31Z",
    "permalink": "/r/reddit/comments/145bram/addressing_the_community_about_changes_to_our_api/jnkd694/",
    "link_title": "Addressing the community about changes to our API",
    "link_permalink": "/r/reddit/comments/145bram/addressing_the_community_about_changes_to_our_api/",
    "is_submitter": true,
    "distinguished": "admin",
    "controversiality": null,
    "commentSource": "old_reddit_html"
  },
  {
    "type": "user_summary",
    "isChild": false,
    "target": "spez",
    "targetKind": "user",
    "postsCollected": 1,
    "commentsCollected": 1,
    "uniqueSubreddits": ["reddit"],
    "uniqueSubredditCount": 1,
    "blocked": false,
    "scrapedAt": "2026-07-25T09:14:02Z"
  }
]

How can I use the data extracted with this Actor?

• 🔬 Community & audience researchers: build a full picture of a Redditor's public footprint — what they post and what they say in replies — using title/selftext alongside body, cross-referenced by uniqueSubreddits from the summary row.
• 🤖 AI engineers and LLM developers: issue a query with a username, receive structured JSON back, and pass the title, selftext, and body fields directly to a model as grounding context for a Reddit-aware agent.
• 📊 Market researchers: track which subreddits a set of users are active in over repeated runs, using uniqueSubreddits and uniqueSubredditCount to measure community coverage and shifts.
• 🛡️ Moderation & trust teams: spot distinguished admin/moderator activity and is_submitter self-replies, and use the blocked flag to tell a deactivated or banned account apart from one that's simply quiet.

📈 How do you monitor a Reddit user's activity over time?

Monitoring a Redditor's public footprint means running the same target repeatedly and diffing what changed between runs, rather than relying on a single snapshot. Each run's user_summary row gives you a compact baseline: postsCollected, commentsCollected, uniqueSubredditCount, and blocked for that target. Comparing consecutive runs tells you whether activity increased, whether the user started posting in a new subreddit (a change in uniqueSubreddits), or whether they went from active to blocked: true — which, combined with a zero row count, is a stronger signal than a simple "0 results" would be on its own.

A practical workflow: run the Actor across a watchlist of usernames on an Apify Schedule, store each run's user_summary rows, and diff uniqueSubreddits and blocked against the previous run. Alert when blocked flips from false to true (possible ban or shadowban), or when a new subreddit appears in uniqueSubreddits (a shift in community focus). Schedule recurring runs from the Schedules tab in the Apify Console — this Actor has no built-in webhook delivery, so scheduled runs plus dataset export (or the Apify API) is the supported delivery path.

Integrate this Actor and automate your workflow

This Actor works with any language or tool that can send an HTTP request to the Apify API.

REST API with Python

from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("<YOUR_USERNAME>/reddit-user-profile-posts-and-comments-scraper-user-comments").call(
    run_input={
        "startUrls": ["spez"],
        "includeUserComments": True,
        "maxUserComments": 50,
        "maxPosts": 25,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["type"], item.get("title") or item.get("body"))

Scheduled monitoring and delivery

Recurring runs are set up from the Schedules tab in the Apify Console — pick a cron interval and this Actor's saved input, and it runs unattended. There is no built-in webhook delivery; retrieve results after each scheduled run via the Dataset export (JSON/CSV/Excel) or by polling the Apify API with apify_client.

Is it legal to scrape Reddit user data?

Scraping public Reddit profiles and comment feeds for information any visitor can already see is generally lawful; this Actor returns only what is publicly viewable on reddit.com and old.reddit.com, without logging in or bypassing any access control. Because usernames, comments, and post content can constitute personal data about identifiable individuals, GDPR and CCPA considerations apply if you collect, store, or process data about EU or California residents — you are responsible for having a lawful basis and for honoring deletion or access requests where applicable. Scraping for passive research or monitoring carries a different risk profile than scraping to power AI training datasets or bulk resale, and Reddit's own Terms of Service impose separate contractual restrictions on automated access regardless of data-protection law. Consult your legal team for commercial use cases involving bulk data storage.

❓ Frequently asked questions

What formats does startUrls accept?

A bare username, a u/ handle, a full profile URL (reddit.com/user/<name> or reddit.com/u/<name>), or keyword:term for a search. All are normalized internally to either a user or keyword target before scraping starts.

What's the difference between sortOrder and userCommentSort?

sortOrder controls the ordering of the user's submitted posts; userCommentSort controls the ordering of their authored comments. They're independent — you can pull posts sorted by top while pulling comments sorted by new in the same run, since each maps to a separate Reddit feed.

How does this Actor handle Reddit's anti-bot measures?

It impersonates real Chrome TLS/HTTP2 fingerprints via impit rather than a plain HTTP client, routes through a residential-first Apify proxy ladder (falling back from any user-supplied proxy to residential), retries 403/429/503 responses with a fresh proxy session each time, detects the "HTTP 200 with an empty payload" silent-block pattern Reddit uses against flagged IPs and force-escalates the proxy tier when it happens, and falls back to parsing old.reddit.com HTML when the JSON endpoint is unreachable on every tier.

Does this Actor detect blocked or inactive users?

Yes — every target gets one uncharged user_summary row with a blocked boolean, set to true when both the post scrape and the comment scrape return zero rows after all proxy tiers and retries are exhausted. This distinguishes "this user has posted nothing" from "we couldn't reach this user's feed."

How many posts and comments does this Actor return per user?

Up to maxPosts (default 50, max 1000) submitted posts and up to maxUserComments (default 50, max 1000) authored comments per target. Reddit's own user feeds serve at most roughly 1000 most-recent items of each type — older history isn't reachable through these feeds regardless of the limit you set.

How do I monitor a Reddit user's activity over time?

Run the same username(s) on a recurring Apify Schedule, store each run's user_summary and post/comment rows, and diff uniqueSubreddits, postsCollected, commentsCollected, and blocked against the previous run to catch new communities, activity spikes, or a sudden block.

Does this Actor work with Claude, ChatGPT, and AI agent frameworks?

It has no dedicated MCP server, but it is callable as a standard HTTP endpoint via the Apify API — any agent framework that can call apify_client or make an HTTP request can trigger a run, poll for completion, and pull the resulting JSON as grounding context before answering a question about a Reddit user.

How does this Actor compare to other Reddit user scrapers?

As observed on the Apify Store on 2026-07-26: louisdeconinck/reddit-user-profile-posts-scraper returns posts and comments from a user's profile with a rich native Reddit field set, but its README does not document any block-detection or run-diagnostic row. simpleapi/reddit-user-profile-posts-and-comments-scraper collects posts and optional comments-on-posts with a documented proxy fallback chain, but does not document authored-comment collection as a distinct feed. signalengine/reddit-user-scraper returns a lightweight per-user profile (recent activity plus an inferred company website) from public RSS feeds, capped at roughly 25 items per user, with no proxy required but also no configurable post/comment limits beyond that cap. This Actor is the only one of the four whose documented output includes an explicit blocked diagnostic and a separate, uncharged authored-comment mirror dataset.

Can I use this Actor without managing proxies or Reddit credentials?

Yes. No Reddit login, account, or API key is required — the Actor reads public feeds only. Proxy handling is automatic: leave proxyConfiguration at its default and Apify residential proxy is used with built-in retries and rotation; you only need an Apify account to run the Actor and access its proxy pool.

💬 Your feedback

Found a bug, or a field that doesn't match what Reddit's own feeds return? Let us know through the Actor's Issues tab on Apify or via Apify Console support — reports like these keep this scraper accurate as Reddit's markup changes.