Reddit User Profile Posts and Comments Scraper by Subreddit

Reddit User Scraper — Posts, Comments and Subreddit Filter as JSON

Reddit User Scraper By Subreddit pulls a Reddit user's submitted posts, keeps only the ones made in the subreddits you name, and attaches the top-level comments left on each matching post — all delivered as typed, normalized JSON. Every row ships with Reddit's own canonical field names, so there's no HTML to parse and no selector to maintain. Alongside the posts, each target gets a ranked community-footprint rollup and a UTC posting-time timeline computed from what was actually collected. After reading this, you'll know exactly which subreddits a user is active in, when they post, and what got said in response — without registering a Reddit API app.

⚠️ "Comments" means replies on the post — not the user's own comment history

Read this before your first run if you came here for a target's own comment history: maxComments attaches comments left by other people on each collected post — it does not scrape comments the target user wrote elsewhere on Reddit. This variant walks a user's submitted-posts feed, filtered by subreddit; it never reads the user's own comment feed (Reddit's /user/<name>/comments.json). If what you actually need is the target's own authored comments as first-class rows, this Actor does not produce that — only the replies other people left on the target's posts.

Those replies come from each matching post's thread JSON ({permalink}.json?limit=&sort=confidence), are always sorted by Reddit's confidence algorithm regardless of the sortOrder you picked for the post feed, are capped at maxComments per post (default 0, so off), and are nested inside post["comments"] — they are not written as separate dataset rows. Because they come from Reddit's JSON API, they can come back empty when that endpoint is bot-walled on every proxy tier; the field is left an empty array rather than faked.

What is Reddit User Scraper By Subreddit?

Reddit User Scraper By Subreddit is an Apify Actor that reads a Reddit user's public submitted-posts feed (or a keyword search listing), keeps only the posts that match a subreddit allow-list you supply, and enriches what's kept with full post bodies, attached comments, a per-user community footprint, and a UTC activity timeline. No Reddit account, login, or OAuth app is required anywhere in the run — requests are made anonymously against Reddit's public JSON endpoints, with an old.reddit.com HTML fallback for when that JSON surface is blocked.

• Scrape a Reddit user's submitted posts from a username, u/name handle, full profile URL, or a keyword:term search
• Filter by subreddit — keep only posts made in the communities you list; everything else is dropped before it is enriched, counted, or charged
• Attach top-level comments made on each kept post (optional, off by default)
• Get a subreddit footprint and a UTC hour/weekday activity timeline per target, computed over the posts actually collected
• Export as JSON, CSV, Excel, XML or an HTML table — no proxy management, no parsing

What data does Reddit User Scraper By Subreddit collect?

Every run can return up to four kinds of data, one row per submitted post plus one rollup row per target.

Data Type	Key Fields	JSON Field Names
Submitted posts, filtered by subreddit	Title, subreddit, score, comment count, creation time, self-text	title, subreddit, score, num_comments, created_utc, selftext, passedSubredditFilter
Post enrichment (optional)	Full untruncated body, preview images, subreddit subscriber count, video media	selftext, preview, subreddit_subscribers, media, secure_media
Comments on those posts (optional, nested)	Commenter, comment body, comment score, reply count	comments[].author, comments[].body, comments[].score, comments[].replies_count
Per-target community footprint	Ranked subreddits the target posts in, with counts and share	subredditFootprint
Per-target activity timeline	Posting distribution by UTC hour and by weekday	activityByHourUTC, activityByWeekday

Need more Reddit data?

This Actor is scoped to one user's post history, filtered by community. If you need to scan many subreddits or keywords for buying-intent and unanswered questions instead of a single author, Reddit Posts Scraper (Buyer & Question / Lead Finder) covers that. If you need trending posts across subreddits, usernames and keyword searches in one flat schema rather than a single author's filtered footprint, Reddit Trends Scraper is the breadth tool — running it first to find active posters, then this Actor to profile one of them by subreddit, is a natural pairing.

How does Reddit User Scraper By Subreddit differ from the official Reddit Data API?

The Reddit Data API is Reddit's supported programmatic surface, and since Reddit moved it to paid access on 1 July 2023 it is gated: you register an application, every request is authenticated through OAuth 2.0, and use beyond Reddit's free non-commercial tier requires a commercial agreement with Reddit (CNBC, 1 June 2023; TechCrunch, 4 July 2023). This Actor reads the same public listings anonymously and returns a fixed, canonical post object.

Feature	Reddit Data API	Reddit User Scraper By Subreddit
Reddit account and registered app	Required	Not used
Authentication	OAuth 2.0 on every request	None — anonymous requests
Commercial use above the free tier	Requires an agreement with Reddit	Governed by Apify's terms and your own legal review
Per-user subreddit filtering	Not built in — the caller filters the raw listing client-side	Built in via filterSubreddits, applied server-side before enrichment or charging
Data scope	Full documented endpoint surface, including comments, moderation and private mod actions	One user's public submitted-post feed, filtered to chosen subreddits, plus top-level comments on those posts
Output shape	Reddit's listing envelope, nested under data.children[].data	Canonical flat post object using Reddit's own field names, plus derived rollups
Setup time	Application registration and OAuth approval before the first call	Provide a username and press Start

Use the Reddit Data API when you need comments moderation, write access, the user's own comment history, or a contractual basis for large-scale commercial use — none of that is what this Actor does. Use this Actor when you need one user's post history narrowed to specific communities, with a footprint and timeline computed for you, without registering an application.

Why do developers and teams scrape Reddit user activity?

Filtering one account's history by community is a narrow, specific job. Four groups get the most out of it.

For AI engineers and agent builders

subredditFootprint and activityByHourUTC turn a raw post list into a structured persona signal: which communities an account actually participates in, and when. A typical pipeline pulls a target's posts filtered to a handful of relevant subreddits, feeds title + selftext into an embedding index keyed on permalink, and uses the footprint's share values as a feature for "is this account a genuine community member or a drive-by poster." Because every field is typed JSON with fixed names, an agent tool can call the Actor and consume the response with no parsing step.

For marketers and brand teams

Influencer and creator vetting usually starts with "does this person actually post in our niche, or just once." Run a candidate's username with filterSubreddits set to the two or three communities your audience lives in, and subredditFootprint tells you their real share of activity there instead of a self-reported bio claim. activityByHourUTC further shows whether their posting pattern lines up with when your audience is actually online.

For researchers and analysts

Everything returned is what an anonymous visitor already sees — no login, no private subreddits, no DMs. That scope matters for research approvals studying cross-community posting behavior: a discourse study can track how a set of public accounts distributes activity across a fixed subreddit list over time, using subredditFootprint and passedSubredditFilter as the sampling record for exactly which posts were counted and which were excluded.

For developers building data products

startUrls accepts usernames, profile URLs and keyword:term searches interchangeably, and filterSubreddits and the two rollup toggles (includeSubredditFootprint, includeActivityTimeline) are per-run switches, not separate endpoints — one Actor covers "give me this user's activity in these communities" as a single integration. Schedule it in Apify, attach a webhook, and pull the dataset through the Apify API into your own store. permalink is stable and canonical, which makes it a reliable deduplication key across repeated runs.

How to scrape a Reddit user's posts by subreddit (step by step)

Reddit User Scraper By Subreddit runs on Apify. Start it from the Apify Console or call it through the Apify API.

1. Open Reddit User Scraper By Subreddit on Apify and click Try for free
2. Add your targets to startUrls — the only required input. A bare username, a u/name handle, a full profile URL, or keyword:term all work, and you can add as many as you like
3. Set filterSubreddits to the communities you want to keep (leave empty to keep everything), and pick sortOrder for how the feed is read before filtering
4. Set maxPosts, fetchSelftext, maxComments and the two rollup toggles, then click Start
5. Download the dataset as JSON, CSV, Excel, XML or an HTML table, or read it through the Apify API

What to do when Reddit changes its structure

The Actor reads Reddit's public JSON endpoints first and falls back to parsing old.reddit.com's HTML when the JSON surface is blocked, so it has two independent paths to the same canonical field set. It is maintained, and the output contract — the same field names and types — is what stays stable on your end, so scheduled runs and downstream mappings keep working across Reddit-side changes.

What changed in Reddit scraping recently?

The defining change was Reddit moving its Data API to paid access on 1 July 2023, which required OAuth-authenticated registered applications and priced large-scale third-party use out of the free tier; several major third-party Reddit apps shut down rather than pay (CNBC, 1 June 2023; TechCrunch, 4 July 2023).

A follow-up tightened the non-API side: on 25 June 2024 Reddit announced an updated robots.txt and said it would continue rate-limiting or blocking bots and crawlers operating outside its Public Content Policy without a licensing agreement (TechCrunch, 25 June 2024).

For DIY scrapers this raised the floor: default HTTP clients are TLS-fingerprint-filtered, datacenter IPs get rate-limited, and Reddit intermittently returns HTTP 200 with an empty payload to flagged IPs instead of an honest error. For this Actor's users, that is the reason it impersonates Chrome's TLS fingerprint, escalates through a residential proxy tier on a suspected silent block, and falls back to old.reddit.com HTML when the JSON endpoint won't serve. A user's public submitted-post feed remains publicly accessible; that is all this Actor reads, and it is maintained against changes on that surface.

⬇️ Input

Nine parameters. Only startUrls is required.

Parameter	Required	Type	Description	Example Value
startUrls	Yes	array	Targets to scrape. Each item can be a bare username, a u/name handle, a full profile URL, or a keyword search prefixed with keyword:. Add as many targets as you like.	["spez", "u/spez", "https://www.reddit.com/user/spez", "keyword:python"]
filterSubreddits	No	array	Restrict output to posts made in these subreddits (case-insensitive; r/ prefix optional). Posts in any other subreddit are dropped before enrichment and never charged. Default [] — leave empty to keep every subreddit.	["AskReddit", "r/python"]
sortOrder	No	string	Order the user's submitted feed is read in before filtering. Enum: new (🆕 New — most recent, default), hot (🔥 Hot — trending), top (⬆️ Top — highest score), controversial (💥 Controversial).	"new"
maxPosts	No	integer	Maximum posts to keep per target, after the subreddit filter. Minimum 1, maximum 10000, default 25. Reddit caps a profile feed at roughly the 1,000 most-recent submissions, so older history is unreachable regardless of this value.	25
fetchSelftext	No	boolean	Default true. When on, each kept post is enriched with full untruncated selftext, preview images, subreddit subscriber count and video media — one extra request per post. This enrichment reads Reddit's JSON API, which is frequently bot-walled inside cloud IPs; when blocked, listing-level fields are still returned and the enrichment-only fields stay null (never faked).	true
maxComments	No	integer	Top-level comments made on each kept post to attach in a comments array. Minimum 0, maximum 100, default 0 (skip — fastest). These are replies from other Redditors, not the target's own authored comments; sorted by Reddit's confidence order regardless of sortOrder.	10
includeSubredditFootprint	No	boolean	Default true. Emits subredditFootprint — a ranked list of the subreddits the target posts in most, with post counts and share — on a per-target summary row.	true
includeActivityTimeline	No	boolean	Default true. Emits activityByHourUTC (24 buckets) and activityByWeekday (7 buckets, Monday = 0) computed from each kept post's timestamp, on the per-target summary row.	true
proxyConfiguration	No	object	Proxy settings, editor: proxy, prefilled {"useApifyProxy": false}. In practice, Apify residential proxy is always attempted as the base tier regardless of this setting — supplying a custom proxy here adds it as a first tier that is tried before the residential fallback, it does not replace it. There is no way to force the run to skip proxying entirely.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

Common pitfall: maxPosts is a post-filter keep count, not a pre-filter scan limit — the Actor pages through the target's entire available feed (up to Reddit's ~1,000-item cap) looking for subreddit matches, not just the first maxPosts items. So a low maxPosts with a narrow filterSubreddits list won't under-scan; but if none of the target's recent ~1,000 submissions fall in your chosen subreddits, you will legitimately get zero rows even though the account has older history there that Reddit no longer exposes.

Example input

{
  "startUrls": ["spez", "keyword:python"],
  "filterSubreddits": ["announcements", "r/redditsecurity"],
  "sortOrder": "new",
  "maxPosts": 25,
  "fetchSelftext": true,
  "maxComments": 10,
  "includeSubredditFootprint": true,
  "includeActivityTimeline": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

⬆️ Output

The dataset holds two structurally different row shapes: one post row per kept submission (type: "post"), and one per-target summary row (type: "profile_summary", isSummary: true) with the community footprint and activity timeline. Comments, when requested, are nested inside each post row rather than written as their own rows. Export as JSON, CSV, Excel, XML or an HTML table, or read the dataset through the Apify API.

Filtered-out posts — anything not matching filterSubreddits — are never pushed to the dataset at all, not even as an uncharged accounting row: the filter check runs before enrichment, comment-fetching, or Actor.push_data, so a filtered post costs nothing and leaves no trace beyond the summary row's counts.

Scraped post — every field the Actor writes

Every post row carries the same 107-key canonical Reddit post object (Reddit's own field names, in a fixed order) plus three derived columns, for a total of 110 keys — comments adds an 111th when maxComments > 0. Grouped below; every key is present on every row (never dropped), filled with Reddit's default when a source doesn't provide it.

• Identity & links (14): type, id, name, author, author_fullname, title, permalink, url, domain, subreddit, subreddit_id, subreddit_name_prefixed, subreddit_type, subreddit_subscribers
• Content (4): selftext, selftext_html, is_self, post_hint
• Scoring & engagement (13): score, ups, downs, upvote_ratio, num_comments, num_crossposts, total_awards_received, all_awardings, awarders, gilded, gildings, top_awarded_type, hide_score
• Post flair (6): link_flair_text, link_flair_richtext, link_flair_css_class, link_flair_text_color, link_flair_background_color, link_flair_type
• Author flair & badges (10): author_flair_text, author_flair_richtext, author_flair_css_class, author_flair_type, author_flair_template_id, author_flair_background_color, author_flair_text_color, author_premium, author_patreon_flair, author_is_blocked
• Media & preview (12): thumbnail, thumbnail_height, thumbnail_width, preview, media, media_embed, secure_media, secure_media_embed, is_video, is_reddit_media_domain, media_only, is_original_content
• Moderation, status & timestamps (48): approved_at_utc, approved_by, banned_by, banned_at_utc, mod_note, mod_reason_by, mod_reason_title, mod_reports, user_reports, num_reports, report_reasons, removal_reason, removed_by, removed_by_category, distinguished, can_mod_post, discussion_type, contest_mode, quarantine, stickied, locked, archived, hidden, visited, saved, clicked, spoiler, over_18, pinned, is_crosspostable, is_created_from_ads_ui, is_robot_indexable, is_meta, no_follow, send_replies, allow_live_comments, suggested_sort, content_categories, category, treatment_tags, wls, pwls, likes, edited, created, created_utc, view_count, can_gild
• Derived by this variant (3): publishedAt — ISO-8601 UTC string built from created_utc; passedSubredditFilter — boolean, whether the row matched filterSubreddits (always true when the filter is empty); scrapedAt — ISO-8601 UTC timestamp for the run
• Optional (1): comments — array, present only when maxComments > 0

One accuracy fix over a naive port: upvote_ratio is only available from Reddit's JSON API and cannot be read off old.reddit.com HTML. When a post is served through the HTML fallback, upvote_ratio is shipped as null rather than a fabricated 0.0.

{
  "type": "post",
  "id": "145bram",
  "name": "t3_145bram",
  "author": "spez",
  "author_fullname": "t2_1w72",
  "title": "Addressing the community about changes to our API",
  "selftext": "Dear redditors, ...",
  "is_self": true,
  "subreddit": "reddit",
  "subreddit_name_prefixed": "r/reddit",
  "subreddit_type": "restricted",
  "subreddit_subscribers": 229811,
  "score": 0,
  "ups": 0,
  "downs": 0,
  "upvote_ratio": 0.17,
  "num_comments": 33886,
  "num_crossposts": 52,
  "gilded": 11,
  "total_awards_received": 0,
  "link_flair_text": null,
  "over_18": false,
  "spoiler": false,
  "locked": false,
  "stickied": false,
  "archived": true,
  "domain": "self.reddit",
  "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,
  "thumbnail": "self",
  "is_video": false,
  "media": null,
  "publishedAt": "2023-06-09T21:24:13Z",
  "passedSubredditFilter": true,
  "scrapedAt": "2026-07-25T10:00:00Z",
  "comments": [
    {
      "id": "jnkd694",
      "author": "spez",
      "body": "Apologies for the delay. We are responding now. ...",
      "score": -1756,
      "created_utc": 1686337071,
      "permalink": "/r/reddit/comments/145bram/addressing_the_community_about_changes_to_our_api/jnkd694/",
      "replies_count": 4
    }
  ]
}

(Trimmed for readability — every field listed in the groups above is present on the real row. The full canonical set matches Reddit's own field names one for one.)

Attached comment — nested inside post["comments"]

Seven fields per comment, not written as a standalone dataset row.

Field	Description
id	Comment ID
author	Commenter's username
body	Comment text
score	Comment score
created_utc	Epoch seconds
permalink	Relative URL to the comment
replies_count	Number of direct replies (nested reply bodies are not fetched)

Per-target summary row — one per target, uncharged

Pushed once per target in startUrls, whether or not any posts matched — so a genuine "no matching posts" result is visible in the dataset instead of just being absent.

Field	Description
type	Always "profile_summary"
isSummary	Always true
isChild	Always false — reserved, not currently used to distinguish anything in this variant
target	The normalized target value (username or search term)
targetKind	"user" or "keyword"
sampleSize	Count of posts collected for this target — identical to matchedPostCount
matchedPostCount	Count of posts collected for this target — identical to sampleSize
filterSubreddits	The normalized, lowercased, sorted list of subreddits the filter was applied with
status	"ok" if at least one post was collected, else "blocked_or_no_matches"
scrapedAt	ISO-8601 UTC timestamp for the run
subredditFootprint	[{ subreddit, posts, total, share }], ranked by post count; null when includeSubredditFootprint is false
activityByHourUTC	24 integers, one per UTC hour; null when includeActivityTimeline is false
activityByWeekday	7 integers, Monday = index 0; null when includeActivityTimeline is false

{
  "type": "profile_summary",
  "isSummary": true,
  "isChild": false,
  "target": "spez",
  "targetKind": "user",
  "sampleSize": 3,
  "matchedPostCount": 3,
  "filterSubreddits": ["announcements", "redditsecurity"],
  "status": "ok",
  "scrapedAt": "2026-07-25T10:00:00Z",
  "subredditFootprint": [
    { "subreddit": "announcements", "posts": 2, "total": 3, "share": 0.6667 },
    { "subreddit": "redditsecurity", "posts": 1, "total": 3, "share": 0.3333 }
  ],
  "activityByHourUTC": [0,0,1,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0],
  "activityByWeekday": [1,0,0,2,0,0,0]
}

status: "blocked_or_no_matches" covers two different real situations that look identical in the row: Reddit genuinely blocked every proxy tier, or the target genuinely has no posts matching filterSubreddits. The dataset can't tell them apart on its own — check the run log, which distinguishes a silent-block escalation from a clean "no matching posts" stop.

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

Requests are sent through impit, a Rust HTTP client that reproduces Chrome's TLS and HTTP/2 fingerprint, rather than a default Python HTTP client signature that Reddit filters at the edge. Proxying is residential-first and user-locked: by default only Apify's residential proxy pool is used, with up to three retries and a fresh IP per retry; if you supply a custom proxy, that proxy is tried first (three retries), then residential is tried as a fallback (three more) — residential is never fully opted out of.

Reddit sometimes returns HTTP 200 with an empty post list to a flagged IP instead of an honest error. The Actor treats an empty first page as a suspected silent block and force-escalates to the next proxy tier rather than accepting it as "this user has no posts." If every proxy tier still comes back empty or blocked on the JSON endpoint, the Actor falls back to parsing old.reddit.com HTML directly, which is the more resilient logged-out surface. 429 responses back off 12–18 seconds and rotate the connection; 403/503 back off briefly and rotate; other non-2xx statuses are treated as non-retryable and the request is abandoned for that page.

How does Reddit User Scraper By Subreddit compare to other Reddit scrapers?

Claims below are as observed on each Actor's live Apify Store listing on 25 July 2026.

Feature	Reddit User Scraper By Subreddit	Generic Reddit user scraper
Subreddit filter on a user's own feed	✅ filterSubreddits, applied server-side before charging	louisdeconinck/reddit-user-profile-posts-scraper's listing documents post and comment scraping from a profile with no subreddit-filter input
Target's own comment history	❌ Not scraped — only replies made on the target's posts are attached	louisdeconinck/reddit-user-profile-posts-scraper's listing returns the user's own posts and own comments as two separate row types (type: "post" / type: "comment") — broader personal-comment coverage than this Actor
Per-user rollups (community footprint, activity timeline)	✅ subredditFootprint, activityByHourUTC, activityByWeekday	Not documented on louisdeconinck/reddit-user-profile-posts-scraper or makework36/reddit-scraper's listings
Reliability claims	Not published — retry tiers, silent-block detection and the HTML fallback are documented above instead of a headline number	makework36/reddit-scraper's listing advertises a "99%+ success rate" and "no rate limit" (checked on the Apify Store, 2026-07-25) — not measured here
Schema stability across the JSON/HTML fallback	✅ Same 107-key canonical field set whether served from Reddit's JSON API or the old.reddit.com HTML fallback	convertfleetdotonline/reddit-scraper's listing documents four search modes (posts/comments/communities/URLs) but does not document field-level schema stability across them

If you need the target's own comment history as first-class rows rather than replies on their posts, louisdeconinck/reddit-user-profile-posts-scraper is the better fit for that specific need — that is the honest recommendation. If you need one user's activity narrowed to specific subreddits with a computed footprint, this Actor is built for exactly that.

How many results can you scrape with Reddit User Scraper By Subreddit?

maxPosts caps how many posts are kept per target, from 1 to 10000, default 25. That is a schema ceiling, not a realistic one: Reddit itself exposes only the roughly 1,000 most-recent submissions on a user's profile feed, so requesting maxPosts: 10000 on a target with a thinner or older history simply returns everything the feed holds.

Pagination follows Reddit's own after cursor: the Actor requests up to 100 items per page and keeps paging — filtering each page by filterSubreddits as it goes — until maxPosts matching posts have been kept, Reddit stops returning a next page (after is empty, the feed is exhausted), or every proxy tier fails on a page. A narrow filterSubreddits list does not stop the scan early; the Actor keeps paging the full available feed looking for matches, up to Reddit's own depth limit.

maxComments (0–100, default 0) is a separate per-post cap, applied independently to each kept post's comment thread — it does not affect how many posts are scraped.

Integrate Reddit User Scraper By Subreddit and automate your workflow

This Actor is an Apify Actor, so it works with any language or tool that can send an HTTP request or read an Apify dataset.

Calling it from Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/reddit-user-profile-posts-and-comments-scraper-by-subreddit").call(run_input={
    "startUrls": ["spez"],
    "filterSubreddits": ["announcements"],
    "maxPosts": 25,
    "maxComments": 10,
    "includeSubredditFootprint": True,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("type") == "post":
        print(row["subreddit"], row["score"], row["title"])

Works in Python, Node.js, Go, Ruby, cURL — any language that can make an HTTP request. Filter on row["type"] == "post" if you want to skip the per-target summary row while iterating.

Automation platforms (n8n, Make, LangChain)

In n8n, the Apify node (or an HTTP Request node against the Apify run endpoint with your token) takes the same JSON input shown above; a downstream Filter node on passedSubredditFilter or type routes post rows separately from the summary row. In Make, the Apify module's run-and-wait action can feed a scheduled subreddit-footprint check straight into Google Sheets or Airtable. For LangChain, wrap the Apify API call as a tool that accepts startUrls and filterSubreddits as arguments — the typed JSON response needs no output parser before it reaches the model. Apify's own schedules and webhooks cover recurring runs without any of these.

Is it legal to scrape Reddit user activity?

Scraping publicly visible Reddit posts is broadly treated as permissible where no authentication is bypassed, and this Actor collects only what an anonymous visitor already sees — no account, no cookie, no session, no private or restricted community content.

That said, this output is personal data. Post rows carry usernames, author-linked content, and the community footprint and activity timeline are themselves inferences about a specific pseudonymous individual. GDPR, CCPA and equivalent regimes attach to this kind of record — a pseudonymous Reddit username is still personal data under GDPR, and pseudonymisation reduces risk without removing the obligation. You need a lawful basis to store and use it, and the data-subject rights that come with it apply.

Reddit's own terms of service and its published Public Content Policy are contractual considerations separate from the data-protection question, and both are worth reading before a sustained collection programme.

Consult legal counsel for commercial use cases involving bulk personal data.

❓ Frequently asked questions

Does this Actor work without a Reddit account?

Yes. No Reddit account, login, cookie, OAuth application or API key is used anywhere in the Actor. Requests are anonymous, against Reddit's public JSON endpoints with an old.reddit.com HTML fallback. The only credential involved is your Apify token, and only if you're calling the Actor through the Apify API rather than the Console.

How often is the scraped data updated?

Every run fetches live. Nothing is cached between runs — each run reads the target's feed and each post's thread fresh, so a run started now reflects Reddit as of now. For repeated tracking, use Apify schedules and diff on permalink, which is stable across runs.

What happens when a target has no posts matching the subreddit filter?

You get zero post rows for that target, plus one summary row with status: "blocked_or_no_matches" and sampleSize: 0, so a real "no matching posts" result is visible in the dataset rather than silently absent. The honest caveat: this status also fires when Reddit blocked every proxy tier before any post could be read — the dataset can't distinguish the two on its own, so check the run log, which logs a silent-block escalation separately from a clean "feed exhausted, no matches" stop.

Can I scrape a suspended or deleted Reddit account?

No usable data. A suspended or deleted account's submitted-post feed returns no items on both the JSON and HTML surfaces, which the Actor treats the same as "no matching posts" — you'll get the uncharged summary row with sampleSize: 0 and no post rows.

Can I scrape private or restricted Reddit content?

No. Only publicly accessible posts are returned. Private subreddits, quarantine-gated communities, and anything behind a Reddit login are not reachable, because the Actor never authenticates.

How am I charged for using this Actor?

On the row_result event, once per post row actually written to the dataset. Posts dropped by filterSubreddits are never pushed and never charged. The per-target summary row (type: "profile_summary") is pushed without a charged event — it's a rollup, not a product row, so it costs nothing regardless of how many targets you run.

Does this Actor work for AI agent workflows and LLM pipelines?

Yes. It's callable as a standard HTTP-triggered Apify Actor run, so LangChain, CrewAI, n8n, or a hand-written tool definition can invoke it and receive typed JSON with no parsing step. Every post row uses the same fixed field set whether served from Reddit's JSON API or the HTML fallback, so downstream code doesn't need to branch on source.

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

Chrome TLS/HTTP2 impersonation via impit, a residential-first proxy ladder with per-retry IP rotation, silent-block detection that force-escalates on an empty first page instead of accepting it as "no posts," and an old.reddit.com HTML fallback when the JSON endpoint won't serve on any tier. Full detail is in the anti-bot section above.

Does this Actor return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with stable field names matching Reddit's own schema. No HTML, no selectors, no parsing. Pass a row directly into an LLM context window, index it into a vector store, or route it through an agent tool.

Can I use this Actor without managing proxies?

Yes. Apify residential proxy is used automatically as the base tier regardless of your proxyConfiguration setting — you never create a proxy account or rotate an IP yourself. Supplying your own proxy adds it as an additional first tier ahead of the residential fallback; it doesn't replace it.

What happens when Reddit changes its structure or blocks the scraper?

The Actor is maintained, and it has two independent read paths — Reddit's JSON API and old.reddit.com HTML — so a change to one surface doesn't necessarily break both at once. Your field names and types don't change on your end; the canonical post schema is what stays stable across updates.

🔗 Related scrapers

Scraper Name	What it extracts
Reddit Trends Scraper	Trending posts across subreddits, usernames and keyword searches, one flat schema
Reddit Posts Scraper (Buyer & Question / Lead Finder)	Posts scored for buying intent and unanswered questions, across subreddits or keywords
Twitter Trends Scraper	Trending topics, with where each trend is also trending
TikTok Trending Hashtags Scraper	New and rising hashtags for trend discovery
Quora Search Scraper	Question-intent results with author enrichment
Google News Scraper	News results with real source URLs and metadata

💬 Your feedback

Found a bug, or need a field that Reddit exposes but this Actor doesn't return? Open an issue on the Actor's Issues tab and it will be looked at. Reports that include your exact input JSON and the target username that misbehaved are the fastest to reproduce and fix.