Reddit User Profile Posts And Comments Scraper

Reddit User Scraper — Posts, Comments and Full Selftext Data

Reddit User Scraper — Posts, Comments and Full Selftext Data extracts submitted posts from any Reddit user profile, username, or sitewide keyword search, and returns each one as a full Reddit-schema JSON row — title, subreddit, score, permalink, complete selftext, preview/media, and an optional top-level comments array. It reads Reddit's own JSON listing endpoint first and automatically falls back to old.reddit.com HTML when Reddit blocks the request, so runs keep completing under active anti-bot pressure. Built for social-listening teams, community researchers, and AI pipelines that need structured Reddit post data without a Reddit developer account.

What is Reddit User Scraper?

Reddit User Scraper — Posts, Comments and Full Selftext Data is an Apify Actor that collects a Reddit user's submitted posts, or posts matching a keyword search, and returns each one as a typed JSON row matching Reddit's own post schema. No Reddit account, login, or API credential is required — the Actor reads Reddit's public JSON listing endpoint and, when that is blocked, the public old.reddit.com HTML pages: exactly what any signed-out visitor already sees.

• 👤 Discovery by bare username, u/-prefixed username, a profile URL (old or new Reddit), or a keyword:<term> sitewide search — mixed freely across one run
• 📝 Optional per-thread enrichment (fetchSelftext) that backfills full untruncated selftext, preview images, and subreddit subscriber counts the listing endpoint omits
• 💬 Optional top-level comments (maxComments, up to 100) attached to each post in a comments array, sorted by confidence
• 🔀 Four sort orders — new, hot, top, controversial — with automatic time-window fallback when the widest window returns no results on a user listing
• 🌐 Residential-first proxy handling with silent-block detection, so a flagged IP triggers a retry instead of being read as "this user has no posts"
• 📤 Export as JSON, CSV, or Excel from the Apify Console, or read the dataset through the Apify API

What data can I extract with Reddit User Scraper?

Every pushed row carries the Actor's full canonical post schema — 108 fields covering identity, content, engagement, moderation state, flair, and media — plus a comments array that is present only when maxComments is greater than 0. The table below lists every field the Actor writes, in the order it writes them.

Field	Example Value	Use Case
type	"post"	Row-type discriminator; always "post" in this Actor
approved_at_utc	null	Moderator approval timestamp, if approved
subreddit	"AskReddit"	Subreddit name without the r/ prefix — primary grouping field
selftext	"Full post body…"	Full self-post text; untruncated when fetchSelftext is on
author_fullname	"t2_1w72"	Reddit's internal author ID
saved	false	Whether the requesting account saved the post (always false, anonymous read)
mod_reason_title	null	Moderator removal reason title
gilded	0	Number of times the post received Reddit gold
clicked	false	Whether the viewing account clicked the post (always false)
title	"What's a small thing that made your day better?"	Post title
link_flair_richtext	[]	Rich-text segments for the post flair
subreddit_name_prefixed	"r/AskReddit"	Subreddit name with the r/ prefix
hidden	false	Whether the post is hidden from the viewing account
pwls	6	Reddit's post whitelist status score
link_flair_css_class	null	CSS class name for the post's flair
downs	0	Downvote count (Reddit always reports 0 publicly)
thumbnail_height	null	Thumbnail image height in pixels
top_awarded_type	null	Highest award tier received
hide_score	false	Whether the score is hidden until a karma threshold
name	"t3_145bram"	Reddit's fullname identifier (kind + id)
quarantine	false	Whether the subreddit is quarantined
link_flair_text_color	"dark"	Flair text color keyword
upvote_ratio	0.92	Ratio of upvotes to total votes
author_flair_background_color	null	Author's flair background color
subreddit_type	"public"	Subreddit visibility type
ups	1240	Upvote count (equal to score on an anonymous read)
total_awards_received	0	Total awards on the post
media_embed	{}	Legacy oEmbed HTML for embedded media
thumbnail_width	null	Thumbnail image width in pixels
author_flair_template_id	null	Author's flair template ID
is_original_content	false	Whether the post is flagged OC
user_reports	[]	User reports (never populated on an anonymous read)
secure_media	null	HTTPS media metadata
is_reddit_media_domain	false	Whether media is hosted on Reddit's own CDN
is_meta	false	Whether the post is a meta discussion post
category	null	Reddit's internal category label
secure_media_embed	{}	HTTPS oEmbed HTML for embedded media
link_flair_text	"Discussion"	Flair label text
can_mod_post	false	Whether the viewing account can moderate the post
score	1240	Net score (upvotes minus downvotes)
approved_by	null	Moderator who approved the post
is_created_from_ads_ui	false	Whether the post originated from Reddit's ad tools
author_premium	true	Whether the author has Reddit Premium
thumbnail	"self"	Thumbnail image URL, or "self"/"default"
edited	false	false, or the Unix timestamp of the last edit
author_flair_css_class	null	CSS class for the author's flair
author_flair_richtext	[]	Rich-text segments for the author's flair
gildings	{}	Gilding counts by award type
post_hint	"self"	Reddit's content-type hint (self, image, link, hosted:video)
content_categories	null	Reddit's content classification tags
is_self	true	Whether the post is a text (self) post
mod_note	null	Moderator note
created	1686332653	Unix creation timestamp (local; same value as created_utc here)
link_flair_type	"text"	Flair rendering type
wls	6	Reddit's whitelist status score
removed_by_category	null	Category the post was removed under
banned_by	null	Moderator who removed the post
author_flair_type	"text"	Author flair rendering type
domain	"self.AskReddit"	Link domain, or self.<subreddit> for text posts
allow_live_comments	false	Whether live comment mode is enabled
selftext_html	"<div class=\"md\">…</div>"	Rendered HTML of the post body
likes	null	Viewing account's vote direction (always null, anonymous)
suggested_sort	null	Post author's suggested comment sort
banned_at_utc	null	Timestamp the post was banned
view_count	null	View count (Reddit no longer exposes this publicly)
archived	false	Whether the post is archived (locked from new comments)
no_follow	true	Whether links on the post carry rel=nofollow
is_crosspostable	true	Whether the post can be crossposted
pinned	false	Whether the post is pinned to the author's profile
over_18	false	NSFW flag
preview	{"images": [], "enabled": false}	Preview image object; populated when fetchSelftext is on
all_awardings	[]	Full award objects on the post
awarders	[]	User IDs who gave awards
media_only	false	Whether the post is media-only
can_gild	false	Whether the post can still receive awards
spoiler	false	Spoiler flag
locked	false	Whether comments are locked
author_flair_text	null	Author flair label text
treatment_tags	[]	Reddit's internal experiment tags
visited	false	Whether the viewing account visited the post
removed_by	null	Username of the removing moderator
num_reports	null	Report count (moderator-only field, always null)
distinguished	null	"moderator", "admin", or null
subreddit_id	"t5_2qh1i"	Subreddit's fullname identifier
author_is_blocked	false	Whether the author is blocked by the viewing account
mod_reason_by	null	Moderator who added the removal reason
removal_reason	null	Removal reason text
link_flair_background_color	""	Flair background color hex
id	"145bram"	Reddit's post ID (without the t3_ prefix)
is_robot_indexable	true	Whether search engines may index the post
report_reasons	null	Report reason labels
author	"spez"	Post author's username — primary identity field
discussion_type	null	Discussion-post type marker
num_comments	33886	Total comment count on the post
send_replies	true	Whether the author receives reply notifications
contest_mode	false	Whether contest mode (hidden scores) is on
mod_reports	[]	Moderator reports
author_patreon_flair	false	Whether the author has Patreon flair
author_flair_text_color	null	Author flair text color keyword
permalink	"/r/AskReddit/comments/145bram/…/"	Relative permalink to the post — join key for comments
stickied	false	Whether the post is stickied
url	"https://www.reddit.com/r/…"	Full URL — post link, or the external link for link posts
subreddit_subscribers	229811	Subreddit member count; populated when fetchSelftext is on
created_utc	1686332653	Unix creation timestamp, UTC
publishedAt	"2023-06-09T21:44:13.000Z"	ISO-8601 timestamp derived from created_utc; null if no usable epoch exists
num_crossposts	3	Number of times the post was crossposted
media	null	Native video/media metadata object
is_video	false	Whether the post is a Reddit-hosted video
comments	[{ "id": "jnkd694", "author": "spez", "body": "…", "score": -1756, "created_utc": 1686337071, "permalink": "/r/AskReddit/comments/145bram/…/jnkd694/", "replies_count": 2 }]	Top-level comments; present only when maxComments is greater than 0

Engagement and moderation fields

score, ups, upvote_ratio and num_comments are the engagement signals most filtering and ranking runs on. distinguished, stickied, locked, archived, over_18 and spoiler describe the post's moderation and display state — useful for excluding pinned announcements or NSFW content from a dataset before analysis. removed_by_category, banned_by and removal_reason surface moderator actions when Reddit exposes them; most stay null on an anonymous read, since Reddit reserves them for moderators viewing their own subreddit. num_crossposts and total_awards_received round out how far a post spread and how it was received.

Filtering and targeting fields

author, subreddit, subreddit_name_prefixed and domain are what you filter and group by downstream. created_utc and the derived publishedAt (ISO-8601, or null when no usable epoch exists) support date-range narrowing after the run. is_self separates text posts from link posts, and permalink/url are the two addressable identifiers for deduplication or for joining post rows against a separate comments pull.

⚠️ Why not build this yourself?

Reddit does not publish a key-free endpoint for pulling one user's submission history mixed freely with a free-text keyword search — its OAuth Data API requires a registered app, and the official listing endpoints do not combine the two input types in a single call. Building this from scratch means solving three problems this Actor already handles.

First, Reddit's own .json listing endpoint is reachable from a browser but returns HTTP 403 to most datacenter, and even some residential, proxy IP ranges when called with a plain HTTP client. The Actor's proxy ladder — Chrome TLS/HTTP-2 impersonation via impit, residential-first with an optional user-proxy tier, up to 3 retries per tier — exists because requests get filtered at the edge before they ever reach Reddit's application layer.

Second, Reddit silently returns HTTP 200 with an empty post list to a flagged IP, rather than an error — indistinguishable from "this user has no posts" unless you check for it explicitly. The Actor treats an empty first page as a signal to escalate proxy tiers, not to stop.

Third, the per-thread .json endpoint used to backfill full selftext and comments is blocked on every Apify proxy tier the Actor has tried, so it falls back to parsing old.reddit.com's comment-page HTML for the same data — one more parser to write and maintain that most one-off scripts skip entirely.

This is undifferentiated infrastructure, not your product. Reddit User Scraper exists so you get post rows, not proxy-ladder code.

How to use data extracted from Reddit?

Social listening and community research teams

A social-listening analyst sets startUrls to a keyword: search term — for example keyword:project management software — with sortOrder at "new" and maxPosts at 200, then reads title, selftext, subreddit and score to track how a topic is discussed across Reddit as it happens. Turning fetchSelftext on backfills the full post body rather than the listing's truncated preview, which matters when the analysis is qualitative — sentiment, phrasing, objections — rather than a simple volume count. Filtering the resulting rows by subreddit_name_prefixed splits one keyword pull into per-community views without a second run.

Agencies monitoring client and competitor mentions

An agency tracking a client's Reddit presence runs one startUrls entry per relevant username or keyword on a recurring Apify schedule, and diffs score, num_comments and upvote_ratio run over run to flag posts gaining traction. Because every parsed post is pushed to the dataset immediately rather than batched at the end of a run, a scheduled run that gets interrupted mid-way still leaves the client with partial results instead of nothing.

Community and content research

A researcher scraping a specific user's history sets maxPosts to the target count and sortOrder to "top", then groups the returned rows by subreddit and averages score to find which communities that account performs best in. Turning on maxComments attaches the top confidence-sorted comments to each post, which is the fastest way to see how a community actually reacted, not just how many people upvoted.

AI agents and automated pipelines

An AI agent researching a topic calls this Actor with a keyword: target, reads title and selftext from the returned rows, and uses them as grounding context for a summarization or sentiment tool — no HTML parsing step, since every field arrives as typed JSON. Because the output schema is identical whether the target was a keyword search or a specific username, the same downstream extraction code handles both.

⬇️ Input

Read directly from the Actor's input schema — six parameters, one of them required.

Parameter	Required	Type	Description	Example Value
startUrls	✅ Yes	array	Reddit usernames, profile URLs, or keyword searches. Accepts a bare username (cyPersimmon9), a u/-prefixed username, a full profile URL, or keyword:<term> for a sitewide search. Multiple entries run in the same call.	["cyPersimmon9", "keyword:python"]
sortOrder	No	string	Sort order for the returned posts. One of "new", "hot", "top", "controversial". Default "new".	"top"
maxPosts	No	integer	Maximum posts to collect per profile or keyword. Minimum 1, maximum 1000, default 10.	50
fetchSelftext	No	boolean	Fetch each post's per-thread page and merge in fields the listing omits — full untruncated selftext, preview images, subreddit subscriber count, full media embed for videos. Default true.	true
maxComments	No	integer	Top-level comments to attach to each post in a comments array. Minimum 0, maximum 100, default 0 (skip comments — fastest).	10
proxyConfiguration	No	object	Apify Proxy settings. Residential is used automatically by default; see the proxy strategy above.	{"useApifyProxy": false}

Common pitfall: paste the profile's root URL (https://www.reddit.com/user/<name>), not a sub-page like /submitted/ or /comments/. The Actor's URL parser takes the last path segment as the username, so a trailing sub-page segment gets read as the username instead of the account name.

Example input

{
  "startUrls": ["cyPersimmon9", "keyword:python"],
  "sortOrder": "new",
  "maxPosts": 25,
  "fetchSelftext": true,
  "maxComments": 5,
  "proxyConfiguration": { "useApifyProxy": false }
}

⬆️ Output

Typed, normalized JSON matching Reddit's own post schema — 108 fields in a fixed order on every row, plus a conditional comments array. Missing values come back as honest typed defaults (null, false, [], {}), never fabricated. Every dataset row is billed under the row_result charged event; no uncharged accounting rows are pushed. Export as JSON, CSV, or Excel from the Apify Console, or read the dataset through the Apify API.

Example output

{
  "type": "post",
  "approved_at_utc": null,
  "subreddit": "AskReddit",
  "selftext": "",
  "author_fullname": "t2_1w72",
  "saved": false,
  "mod_reason_title": null,
  "gilded": 0,
  "clicked": false,
  "title": "What's a small thing that made your day better?",
  "link_flair_richtext": [],
  "subreddit_name_prefixed": "r/AskReddit",
  "hidden": false,
  "pwls": 6,
  "link_flair_css_class": null,
  "downs": 0,
  "thumbnail_height": null,
  "top_awarded_type": null,
  "hide_score": false,
  "name": "t3_145bram",
  "quarantine": false,
  "link_flair_text_color": "dark",
  "upvote_ratio": 0.92,
  "author_flair_background_color": null,
  "subreddit_type": "public",
  "ups": 1240,
  "total_awards_received": 0,
  "media_embed": {},
  "thumbnail_width": null,
  "author_flair_template_id": null,
  "is_original_content": false,
  "user_reports": [],
  "secure_media": null,
  "is_reddit_media_domain": false,
  "is_meta": false,
  "category": null,
  "secure_media_embed": {},
  "link_flair_text": "Discussion",
  "can_mod_post": false,
  "score": 1240,
  "approved_by": null,
  "is_created_from_ads_ui": false,
  "author_premium": true,
  "thumbnail": "self",
  "edited": false,
  "author_flair_css_class": null,
  "author_flair_richtext": [],
  "gildings": {},
  "post_hint": "self",
  "content_categories": null,
  "is_self": true,
  "mod_note": null,
  "created": 1686332653,
  "link_flair_type": "text",
  "wls": 6,
  "removed_by_category": null,
  "banned_by": null,
  "author_flair_type": "text",
  "domain": "self.AskReddit",
  "allow_live_comments": false,
  "selftext_html": null,
  "likes": null,
  "suggested_sort": null,
  "banned_at_utc": null,
  "view_count": null,
  "archived": false,
  "no_follow": true,
  "is_crosspostable": true,
  "pinned": false,
  "over_18": false,
  "preview": { "images": [], "enabled": false },
  "all_awardings": [],
  "awarders": [],
  "media_only": false,
  "can_gild": false,
  "spoiler": false,
  "locked": false,
  "author_flair_text": null,
  "treatment_tags": [],
  "visited": false,
  "removed_by": null,
  "num_reports": null,
  "distinguished": null,
  "subreddit_id": "t5_2qh1i",
  "author_is_blocked": false,
  "mod_reason_by": null,
  "removal_reason": null,
  "link_flair_background_color": "",
  "id": "145bram",
  "is_robot_indexable": true,
  "report_reasons": null,
  "author": "spez",
  "discussion_type": null,
  "num_comments": 33886,
  "send_replies": true,
  "contest_mode": false,
  "mod_reports": [],
  "author_patreon_flair": false,
  "author_flair_text_color": null,
  "permalink": "/r/AskReddit/comments/145bram/whats_a_small_thing_that_made_your_day_better/",
  "stickied": false,
  "url": "https://www.reddit.com/r/AskReddit/comments/145bram/whats_a_small_thing_that_made_your_day_better/",
  "subreddit_subscribers": 229811,
  "created_utc": 1686332653,
  "publishedAt": "2023-06-09T21:44:13.000Z",
  "num_crossposts": 3,
  "media": null,
  "is_video": false,
  "comments": [
    {
      "id": "jnkd694",
      "author": "spez",
      "body": "Apologies for the delay. We are responding now.",
      "score": -1756,
      "created_utc": 1686337071,
      "permalink": "/r/AskReddit/comments/145bram/whats_a_small_thing_that_made_your_day_better/jnkd694/",
      "replies_count": 2
    }
  ]
}

How does it work?

Each startUrls entry is normalized into a user or keyword target, then scraped through Reddit's own .json listing endpoint first. Every fetch runs through a residential-first proxy ladder built on impit's Chrome TLS and HTTP/2 impersonation, so requests carry a real browser fingerprint rather than a default HTTP client signature — the layer that gets filtered at the edge before ever reaching Reddit's application servers.

If the JSON endpoint is blocked on every proxy tier tried, the Actor switches to parsing old.reddit.com's rendered HTML for the same listing. The HTML parser reads post identity, score, flair, thumbnail, and preview/media data straight out of the page's data-* attributes and cached expando HTML — ported from a proven standalone parser rather than written fresh against live markup, so a layout tweak degrades one field rather than the whole row.

A silent block — Reddit answering with HTTP 200 and an empty post list — is treated as a signal to escalate to the next proxy tier or rotate to a fresh residential IP, not as "this user has no posts." When fetchSelftext or maxComments is on, the Actor tries the per-thread .json endpoint once per post; if that is blocked too, it falls back to the same thread's old.reddit.com comment page for the full selftext, subreddit subscriber count, and top-level comments in a single extra fetch. Every parsed post is pushed to the dataset the moment it is finalized, so an interrupted run still keeps whatever it had already found.

How do you filter and target specific posts?

Reddit User Scraper exposes two real narrowing axes, not a full faceted-search system, so precision here comes from choosing the right input shape rather than stacking filter parameters.

Username vs keyword search. A bare username or profile URL in startUrls guarantees every returned post belongs to that one author — the most complete option when the target is a known account. A keyword:<term> entry instead queries Reddit's sitewide search index, which is not exhaustive and can lag freshly posted content; use it when you need topic coverage across authors, not a single account's history.

Volume and depth controls. maxPosts (1–1000) is the sole volume ceiling per target — the Actor pages internally in blocks of up to 100 until it is reached or the target's feed runs out. Depth is a separate decision: fetchSelftext trades one extra request per post for the full body and preview data, and maxComments (0–100) trades further requests for a top-level comments array. Leave both at their defaults for the fastest, metadata-only pull.

There is no server-side quality threshold — no minimum-score or minimum-comment-count filter exists in the schema — so score, upvote_ratio and num_comments are returned on every row for filtering downstream instead.

{ "startUrls": ["keyword:local seo tools"], "sortOrder": "top", "maxPosts": 300 }

{ "startUrls": ["u/cyPersimmon9"], "maxPosts": 200, "fetchSelftext": true, "maxComments": 20 }

{ "startUrls": ["spez", "kn0thing"], "maxPosts": 1000, "fetchSelftext": false, "maxComments": 0 }

🔗 Related Reddit scrapers

Scraper Name	What it extracts
Reddit Posts Scraper — Author & Media Details	Reddit posts enriched with author profile and media details
Reddit Trends Scraper With Author Contact Leads	Trending Reddit posts paired with author contact-lead signals
LinkedIn Comments & Reactions Scraper	Comments and reactions from LinkedIn posts
Instagram Comment Engagement Scraper	Comment-level engagement data from Instagram posts

How to extract Reddit data programmatically

Reddit User Scraper is an Apify Actor: one authenticated call to the Apify API starts a run, and typed JSON rows land in a dataset you read back the same way.

Python example

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/reddit-user-profile-posts-and-comments-scraper-pay-per-events").call(run_input={
    "startUrls": ["keyword:python", "cyPersimmon9"],
    "sortOrder": "new",
    "maxPosts": 50,
    "maxComments": 5,
})

for post in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(post["author"], post["subreddit"], post["title"], post["score"])

Works the same way in Go, Ruby, Node.js, or cURL — any language that can make an HTTP request against the Apify API.

Export to spreadsheets or CRM

Every export carries the full 108-field row. For a CRM or spreadsheet import, map author, title, subreddit, score, num_comments, permalink and created_utc to columns — these seven cover what most downstream tools actually use. Export directly from the Apify Console as CSV or Excel, or pull the same fields through the API and write them with any spreadsheet library.

Is it legal to scrape Reddit?

Scraping publicly visible Reddit posts is broadly treated as permissible where no login or paywall is bypassed, and everything this Actor returns is already visible to any signed-out visitor on reddit.com or old.reddit.com. Because each row is tied to a Reddit username and carries that person's own words, the output is personal data under GDPR and CCPA-style regimes even though it was collected without authentication — a lawful basis (typically legitimate interest for research or monitoring) and a defined retention period apply once you store it. Consult legal counsel for commercial applications involving bulk storage of personal data, particularly before combining usernames with any other identifying signal.

❓ Frequently asked questions

What happens if a Reddit account is suspended or has been deleted?

The run returns zero posts for that target rather than an error — Reddit's listing endpoint responds the same way to a suspended, deleted, or genuinely empty account, so the Actor cannot distinguish the three. A 0 result for a username you know is active is worth a manual check on the account's live profile page.

Can I get comments along with the posts?

Yes. Set maxComments to a value from 1 to 100 and each post's row gains a comments array holding that many top-level, confidence-sorted comments with id, author, body, score, created_utc, permalink and replies_count. Only top-level comments are captured — nested reply threads are not expanded, though replies_count tells you how many exist.

What happens if Reddit blocks the run partway through?

The run does not simply fail. The Actor escalates through its proxy tiers — residential by default, plus your own proxy first if you supplied one — with up to three attempts each, and on the old.reddit.com HTML fallback it retries on a fresh residential IP several times before giving up on a single target. Posts already pushed to the dataset before a block are never lost; a target that cannot be recovered at all simply finishes with a lower count than requested and a warning in the run log, rather than stopping the whole run.

How accurate is the post data?

The Actor returns each field exactly as Reddit's own listing or thread page reports it at request time. Accuracy of score, num_comments and similar counters depends on Reddit's own count at that moment, not on the Actor — scores in particular continue to change after a run finishes.

How many posts can I get per run?

Up to 1000 per startUrls entry — maxPosts is a per-target ceiling, not a run-wide one, so five usernames each capped at 1000 can return up to 5000 rows in a single run.

Can I mix usernames and keyword searches in one run?

Yes. startUrls accepts both simultaneously — each entry is normalized independently into a username or keyword target, so one call can pull a specific account's history alongside a topic-wide search.

Does Reddit User Scraper work with Claude, ChatGPT, and AI agent frameworks?

Yes. It is callable as a standard HTTP endpoint through the Apify API, so LangChain, CrewAI, n8n, or a hand-written tool definition can invoke it and receive typed JSON with no parsing step.

How does Reddit User Scraper compare to other Reddit user scrapers?

Checked on the Apify Store on 26 July 2026: louisdeconinck/reddit-user-profile-posts-scraper documents the same 108-field-plus-comments schema and is the most-used Reddit user Actor by run count. signalengine/reddit-user-scraper takes a narrower approach — RSS-based, capped at roughly 25 recent items per user, with no comments array but an inferred company-website field. The simpleapi flat-price listing of this same Reddit user/keyword concept documents a direct→datacenter→residential proxy ladder rather than the residential-first design used here. This Actor's difference is the dual JSON-then-HTML fallback per post thread, so full selftext and comments still populate when Reddit's per-thread JSON endpoint is blocked outright.

Can I use Reddit User Scraper without a Reddit account or API key?

Yes. No Reddit account, login, OAuth client, or API key is required — the Actor reads public listing and thread pages anonymously. The only credential you need is your Apify token.

💬 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 — reports that include the target username or keyword and the run's log output are the fastest to reproduce and fix.

Conclusion

Reddit User Scraper — Posts, Comments and Full Selftext Data turns a username, profile URL, or keyword search into a stable, typed dataset of Reddit posts — full selftext, engagement counts, and optional comments included — without a Reddit developer account or proxy infrastructure to maintain. It is built for social-listening teams, agencies, researchers, and AI pipelines that need Reddit post data as clean JSON, not raw HTML. Start a run from the Apify Console or call it through the Apify API to get your first dataset.