Reddit Subreddit Members Scraper With User Profiles

Reddit Scraper — Extract Subreddit Members, User IDs & Profiles

Reddit Subreddit Members Scraper With User Profiles finds the accounts actively posting and commenting inside any subreddit, reads each one's genuine Reddit t2_ user ID straight off the public feed, and attaches a profile card — post karma, comment karma, account age and trophies — as typed JSON. Unlike scraping frameworks that return raw HTML for you to parse, every row here is ready for your database, spreadsheet or LLM pipeline without extra cleanup. Rows are active public participants sampled from public feeds, not a subscriber list — Reddit publishes no subreddit membership roster. This guide covers every input, every output field, and how teams deploy it for enrichment, monitoring and research.

---

🧭 What does this Reddit scraper do?

It reads a subreddit's public post listing and comment firehose on old.reddit.com (with a fallback to the third-party Arctic Shift archive), collects the distinct accounts behind that activity, and enriches each one with a live profile card. No Reddit login, OAuth app, or API key is required — the actor reads public HTML pages, the same pages any logged-out browser can reach. It returns three connected things: the participant list (who is active), each account's real Reddit user ID (its permanent t2_ fullname, not the username), and a profile card (karma, account age, trophies, admin flag).

• Sweeps one or more subreddits by new, hot, top or rising, plus the comment firehose
• Resolves free-text keywords and direct u/username entries alongside subreddit sweeps
• Reads the genuine t2_ account ID for free off every listing/search row, at zero extra cost
• Fetches a profile card (karma, creation date, account age, trophies, admin flag) per unique account
• De-duplicates every account at the run level — active in three subreddits, charged once
• Filters on karma and account age before a row is pushed, so filtered accounts cost nothing
• Falls back to the public Arctic Shift Reddit archive when Reddit's edge blocks the request

---

⚡ Features & Capabilities

This actor's capabilities split into discovery (finding participants), identity (resolving real IDs) and enrichment (the profile card) — plus the transport layer that keeps all three working against Reddit's anti-bot edge.

Core features

• Real Reddit user IDs, not usernames. Every listing and search row carries data-author-fullname; it is captured as userId and redditFullname at zero extra request cost.
• Profile enrichment fields: postKarma, commentKarma, createdISO, createdUTC, accountAgeDays, trophyCount, trophyNames, isAdmin — one request per unique account.
• Provenance per row: discoverySurface (which feeds an account was seen in), surfaceCount, timesSeenInRun, firstSeenType.
• Pre-charge filtering: minPostKarma, minCommentKarma, minAccountAgeDays, maxAccountAgeDays, excludeAuthors and requireRealUserId all run before a row is pushed and billed.
• Discovery engine choice: old.reddit.com HTML (primary) or the Arctic Shift archive (discoveryEngine), with automatic fallback between them.
• Output as a flat JSON row — no nested objects to unwrap, ready to load straight into a table or a dataframe.

How this Reddit scraper compares to typical Reddit scrapers

No independently verified competitor listings were available at the time of writing, so this table compares against the legacy approach documented in this actor's own source history rather than a named competitor.

Feature	This actor	Legacy www.reddit.com/*.json scrapers
Real t2_ user ID	✅ read from data-author-fullname, free	Varies — many synthesize a fake ID when the JSON endpoint is blocked
Legacy JSON endpoint dependency	❌ not used — reads old.reddit.com HTML	✅ typically depends on it
Works when www.reddit.com/*.json returns HTTP 403	✅ (observed on every client, fingerprint and proxy tier as of 2026-08-01)	❌ by definition, if that is the only data path
Pre-charge filtering	✅ karma/age/exclude filters run before the row is pushed	Not documented
Archive fallback when blocked	✅ Arctic Shift	Not documented

If your use case is feeding structured data to an LLM, the output-format row is the decision-maker — a flat, typed JSON row with a stable key set is a reliability win over parsing HTML inside an agent loop, where a single markup change breaks the extraction silently.

When another tool might suit you better

This actor optimizes for who is active and who they are — it deliberately discards post and comment text, titles and scores. If your goal is the actual content of posts and comments (body text, scores, thread structure) rather than the author list, a Reddit content/post scraper is the better fit; running this actor for that purpose means paying for identity resolution you won't use. Likewise, if you need Reddit's true subscriber count for a subreddit, no scraper can currently provide it — /about.json has returned HTTP 403 since 2026-08, and this actor does not guess at a number it cannot verify.

Reddit Scraper With User Profiles within the Scrapio data stack

This is Scrapio's Reddit participant-and-profile actor — it covers subreddit participants, their real user IDs, and profile cards. For the same "discover an active user, then enrich their profile" pattern on other platforms, see Scrapio's X (Twitter) User Profile and Tweets Scraper With Follower Lists and Pinterest Profile Scraper and Pinner Profiles in the same account.

---

Why do developers and data teams scrape Reddit?

🏢 Community and audience research

Teams evaluating a niche subreddit before sponsoring, moderating, or launching a product there use redditTargets to sweep the community's new, hot and comment feeds, then read postKarma, commentKarma and accountAgeDays to judge whether the active base is established contributors or a wave of new accounts. discoverySurface shows exactly which feed each account came from, so the sample is auditable rather than a black box.

📊 AI training data and RAG indexing

trophyNames and discoverySurface are the fields with the most consistent structure across records — both are arrays that describe an account's history without needing text parsing. For RAG enrichment, join a username mentioned in a support ticket or forum thread against this actor's output to pull karma and account age into the retrieved context. For training data, postKarma, commentKarma, accountAgeDays and trophyCount are consistent numeric fields across every row, useful as features for a account-trust or spam-likelihood model. Every field returns as a typed primitive — no HTML entities, no nested markup to strip.

📱 Competitive and market intelligence

Track which accounts are driving conversation in a competitor's or your own brand's subreddit over time. Run the same redditTargets sweep on a schedule and watch timesSeenInRun and surfaceCount — a sudden jump in a small set of authors posting or commenting repeatedly is a concentrated-activity signal worth investigating.

🔬 Research and academic use

Social and market researchers studying participation patterns in online communities can use this actor to build a de-duplicated, timestamped sample of active accounts per subreddit, with firstSeenType distinguishing posters from commenters. Scope is limited to public feed data only — no private messages, no deleted content, and no subscriber roster, since Reddit does not publish one.

🎥 Product and SaaS development

Directory and monitoring products built on Reddit activity — a "who's active in r/X this week" dashboard, a lead-enrichment API for community managers — can call this actor per subreddit or per username list and store the flat JSON rows directly, keyed on the permanent userId rather than the mutable username.

---

🍚 Input Parameters

Every parameter below comes directly from .actor/actor.json, in schema order. None are required — an empty run simply returns nothing.

Parameter	Required	Type	Description	Example Value
redditTargets	No	array (stringList)	One entry per line: r/python, a full subreddit URL, u/spez, a full profile URL, or a plain keyword. Anything not a subreddit or profile is treated as a search query.	["r/python", "r/learnpython", "u/spez"]
targets	No	array (stringList)	Same meaning as redditTargets, kept under the original key for backwards compatibility. Wins over redditTargets when both are supplied.	["r/python"]
startUrls	No	array (stringList)	Alternative alias for the target list. Used only when neither field above is supplied.	["https://www.reddit.com/r/python/"]
subredditNames	No	array (stringList)	Plain subreddit names without the r/ prefix, appended to the sweep and de-duplicated.	["webscraping"]
subreddits	No	array (stringList)	Original key for the extra subreddit list. Wins over subredditNames when both are supplied.	["webscraping"]
sort_order	No	string (enum)	Listing to read for each subreddit: new, hot, top, rising. Default "new".	"top"
topTimeWindow	No	string (enum)	Time window used only when sort_order is top: hour, day, week, month, year, all. Default "month".	"year"
maxPosts	No	integer	Submissions to read per subreddit or per keyword search. Minimum 1, maximum 1000. Default 25.	50
maxComments	No	integer	Comment-firehose entries to read per subreddit. 0 skips comments. Minimum 0, maximum 1000. Default 25.	50
discoveryEngine	No	string (enum)	auto (old.reddit first, archive fallback), oldreddit (old.reddit only), arcticshift (archive only). Default "auto".	"auto"
keywordSearchScope	No	string (enum)	global (search all of Reddit) or targetSubreddits (search only inside the listed subreddits). Default "global".	"targetSubreddits"
fetchDetails	No	boolean	Read each account's profile page for karma, creation date, age, trophies and the admin flag. One request per unique account. Default true.	true
requireRealUserId	No	boolean	Drop discovered accounts whose genuine t2_ ID could not be read. Applied before any profile request and before billing. Default false.	false
minPostKarma	No	integer	Drop accounts below this post karma. Minimum 0. 0 disables the filter. Default 0.	100
minCommentKarma	No	integer	Drop accounts below this comment karma. Minimum 0. 0 disables the filter. Default 0.	100
minAccountAgeDays	No	integer	Drop accounts younger than this, in days. Minimum 0. 0 disables the filter. Default 0.	90
maxAccountAgeDays	No	integer	Drop accounts older than this, in days. Minimum 0. 0 disables the filter. Default 0.	30
excludeAuthors	No	array (stringList)	Case-insensitive usernames to skip entirely. These cost neither a profile request nor a charged row.	["AutoModerator"]
dropWhenProfileUnavailable	No	boolean	Off by default: unreadable profiles are returned, flagged, and exempted from the karma/age filters. Default false.	false
maxConcurrentUsers	No	integer	Profile cards fetched concurrently. Minimum 1, maximum 8. Default 3.	3
requestDelay	No	integer	Extra pause added after each request, in seconds. Minimum 0, maximum 30. Default 1.	1
proxyConfiguration	No	object (proxy editor)	Proxy configuration. Defaults to Apify Proxy with the RESIDENTIAL group. A non-residential configuration is automatically escalated to residential.	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

{
  "redditTargets": ["r/python", "r/learnpython"],
  "sort_order": "new",
  "maxPosts": 50,
  "maxComments": 50,
  "fetchDetails": true,
  "minCommentKarma": 100,
  "minAccountAgeDays": 90,
  "excludeAuthors": ["AutoModerator"],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

Supported URL types and input formats

• Subreddit sweep: r/python or https://www.reddit.com/r/python/ — reads the post listing and comment firehose for that subreddit.
• Direct profile lookup: u/spez or https://www.reddit.com/user/spez/ — adds the account directly, no feed sweep needed.
• Keyword search: any entry that is not a subreddit or profile, e.g. web scraping — searched globally by default, or restricted to the listed subreddits via keywordSearchScope: "targetSubreddits".

Leading emoji and decoration on pasted list entries are stripped before parsing, so a list copied from a formatted document still resolves correctly.

---

📦 Output Format

Output is one flat JSON row per unique account for the entire run — no nested objects. Export directly from the Apify Console to JSON, CSV, Excel, HTML, XML or RSS, or pull it programmatically via the Apify API or apify_client.

Output for a participant row

{
  "username": "spez",
  "userId": "t2_1w72",
  "redditFullname": "t2_1w72",
  "userIdSource": "oldreddit_listing",
  "profileUrl": "https://reddit.com/user/spez",
  "postKarma": 158452,
  "commentKarma": 892310,
  "createdUTC": 1119651600,
  "createdISO": "2005-06-24T21:00:00Z",
  "accountAgeDays": 7710,
  "trophyCount": 12,
  "trophyNames": ["Reddit Premium", "Verified Email", "10-Year Club"],
  "isAdmin": true,
  "profileFetched": true,
  "profileFetchError": null,
  "discoverySurface": ["r/python:new"],
  "surfaceCount": 1,
  "timesSeenInRun": 3,
  "firstSeenType": "post",
  "totalKarma": null,
  "isGold": null,
  "iconImg": null,
  "rowType": "participant",
  "runId": "abcd1234efgh5678",
  "scrapedAt": "2026-08-04T12:00:00Z"
}

totalKarma, isGold and iconImg are kept for backwards compatibility with the original actor and are always null — the only Reddit surface that ever carried them (/user/<name>/about.json) has returned HTTP 403 since 2026-08. totalKarma is deliberately not computed as postKarma + commentKarma, because Reddit's real total also folds in award karma that this actor cannot read; a wrong derived number would be worse than null.

Output for an accounting note row

Note rows record targets that returned nothing, or a run that stopped early. They are never charged — only rows with charged_event_name="row_result" (every rowType: "participant" row) are billed.

{
  "rowType": "note",
  "runId": "abcd1234efgh5678",
  "note": "no data for r/somedeadsubreddit",
  "target": "r/somedeadsubreddit",
  "scrapedAt": "2026-08-04T12:00:00Z"
}

The target key is present only on per-target notes; the "stopped early: pay-per-event charge limit reached" and "run produced no qualifying participants" notes omit it. To keep only billable data rows when processing the dataset, filter on rowType == "participant".

Schema stability and export options

The 24-key field order is fixed in the actor's own output-building code, and fields that lose their data source (like totalKarma) are kept as null rather than removed, so a pipeline built against this schema does not break when a Reddit surface goes away. Delivery is via the standard Apify dataset: download as JSON, CSV, Excel, HTML, XML or RSS from the Console, or read it programmatically through the Apify API or the apify_client / apify-client SDKs.

---

💡 Reddit Scraper With User Profiles Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

When a username shows up in a support ticket, a lead form, or a mention alert, enrich it in real time: trigger a run with that u/username in redditTargets and fetchDetails: true, then read back userId (the permanent join key), postKarma, commentKarma and accountAgeDays from the pushed row. Write those fields into your CRM or database alongside the original record — userId never changes, so it is safe to re-key on if the person changes their display name later.

🎯 Strategy 2: Scheduled monitoring and alerting

To track a community over time, run the same redditTargets sweep on a recurring Apify Schedule. Compare each run's set of userId values against the previous run's: new IDs appearing with low accountAgeDays flag fresh accounts joining the conversation, while a spike in timesSeenInRun for existing accounts flags concentrated activity. Alert on whichever delta matters to you — the actor itself does not diff runs, so this comparison happens in your own pipeline against the dataset it produces.

🎯 Strategy 3: Bulk dataset build

For a research or training dataset spanning many subreddits, list them all in redditTargets in a single run, or fire one run per subreddit in parallel through the Apify API and aggregate the resulting datasets afterward. maxConcurrentUsers (1–8) is the one documented concurrency control the actor exposes, and it governs profile-card fetches within a single run, not how many runs you can start in parallel on your account. Export each run's dataset to CSV or JSON and merge on userId.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Enriching one inbound username at a time	Single triggered run per event	JSON row via API
Scheduled monitoring	Tracking a community's active accounts over time	Recurring run via Apify Schedules, diffed externally	JSON dataset per run
Bulk dataset build	Research or training datasets across many subreddits	One large run, or parallel runs via the API	CSV/JSON dataset export

---

🌴 Related Reddit Scrapers & Tools

Scraper	What it extracts
X (Twitter) User Profile and Tweets Scraper With Follower Lists (Scrapio)	Twitter/X profiles, tweets and follower lists — same discover-then-enrich pattern on a different platform
Pinterest Profile Scraper and Pinner Profiles (Scrapio)	Pinterest profile and pinner data
TikTok Data Scraper — Comments, Replies and AI Sentiment (Scrapio)	TikTok comment authors and sentiment, a comment-side counterpart to this actor's post/comment author discovery

This is Scrapio's only Reddit actor; for Reddit post or comment content itself rather than the author list, look for a dedicated Reddit content scraper outside this account.

---

How to integrate Reddit Scraper With User Profiles with your stack

Reddit Scraper With User Profiles works with any language or tool that can make an HTTP request to the Apify API.

Python

from apify_client import ApifyClient
import csv

client = ApifyClient("<APIFY_API_TOKEN>")

run_input = {
    "redditTargets": ["r/python", "r/learnpython", "r/webscraping"],
    "sort_order": "new",
    "maxPosts": 50,
    "maxComments": 50,
    "fetchDetails": True,
    "minCommentKarma": 100,
    "excludeAuthors": ["AutoModerator"],
}

run = client.actor("<YOUR_USERNAME>/reddit-subreddit-members-scraper-with-user-profiles").call(
    run_input=run_input
)

items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
participants = [row for row in items if row.get("rowType") == "participant"]

with open("reddit_participants.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=list(participants[0].keys()))
    writer.writeheader()
    writer.writerows(participants)

print(f"Wrote {len(participants)} participant rows")

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<APIFY_API_TOKEN>' });

const run = await client
  .actor('<YOUR_USERNAME>/reddit-subreddit-members-scraper-with-user-profiles')
  .call({
    redditTargets: ['r/python', 'r/learnpython'],
    sort_order: 'top',
    topTimeWindow: 'month',
    maxPosts: 50,
    minAccountAgeDays: 90,
  });

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const participants = items.filter((row) => row.rowType === 'participant');

console.log(`Fetched ${participants.length} participant rows`);

Async and scheduled pipelines

For large sweeps, start the run and poll client.run(runId).get() for status instead of waiting synchronously, or trigger runs on a recurring cadence with an Apify Schedule and read the resulting dataset afterward. Apify also supports run-finished webhooks at the platform level if you want your own endpoint notified when a run completes, instead of polling.

---

🎯 Who needs Reddit Scraper With User Profiles? (Use cases & industries)

🏢 Community and brand managers

Sweep a brand's or a client's subreddit on hot and the comment firehose, then read postKarma, commentKarma and discoverySurface to identify the handful of accounts actually driving the conversation, rather than guessing from vote counts alone.

📊 Growth and lead-enrichment teams

Feed a list of u/username entries collected from support threads or DMs into redditTargets with fetchDetails: true, and get back userId, accountAgeDays and karma as trust signals to prioritize outreach or flag likely throwaway accounts with maxAccountAgeDays.

📱 Competitive and market intelligence analysts

Run the same subreddit sweep on a schedule for your own community and a competitor's, and compare active-participant counts and timesSeenInRun concentration between the two over successive runs.

🔬 Researchers

Build a de-duplicated, timestamped sample of a subreddit's active posters and commenters for social or market research, scoped to public feed data only — no subscriber roster exists to sample from instead.

---

Is it legal to scrape Reddit?

Scraping publicly accessible Reddit pages is generally lawful; the more relevant risks are contractual and data-protection, not criminal. Three separate questions apply here:

• Scraping public data. The pages this actor reads — subreddit listings, the comment firehose, and user profile pages — are served to any logged-out visitor without authentication.
• Reddit's Terms of Service. Reddit's terms and API policy restrict automated access. Violating them is a civil contract matter between you and Reddit, not a criminal one, but it can result in IP or account restrictions.
• Data protection. This actor's output identifies real people — usernames, account creation dates, karma history and trophies are personal data under GDPR and CCPA in relevant jurisdictions, even though Reddit displays them publicly. Public availability does not remove data-protection obligations for how you store, combine or act on that data.

Reddit Scraper With User Profiles returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

---

❓ Frequently asked questions

Does this scraper work without a Reddit account?

Yes. It reads public HTML pages on old.reddit.com (and optionally the third-party Arctic Shift archive) the same way a logged-out browser would — no Reddit login, OAuth app, or API key is used anywhere in the code.

Is the output a subreddit's member or subscriber list?

No. Reddit does not publish a subscriber roster, and this actor never claims to produce one. Every row is an account that recently posted or commented in the subreddit's public feeds, bounded by maxPosts and maxComments — active participants, not the full subscriber base, and lurkers are excluded by definition.

How does it handle Reddit's anti-scraping measures?

It uses a residential-first proxy ladder (escalating from direct or user-supplied proxies to Apify's RESIDENTIAL group), TLS fingerprint impersonation (Firefox, then Safari — Chrome and Edge fingerprints are blocked outright), and content-based validation rather than trusting HTTP status codes, since Reddit answers several challenge and interstitial pages with HTTP 200. Failed requests retry with exponential backoff and escalate proxy tier or fingerprint between attempts.

Can I run it at scale without getting blocked?

⚠️ old.reddit.com serves this data only to residential exits with a non-Chrome TLS fingerprint — datacenter proxy groups are hard-blocked, so the actor automatically escalates any non-residential proxy configuration to residential. maxConcurrentUsers (1–8) and requestDelay (0–30 seconds) are the pacing controls available if you see blocked responses in the run log. No uptime or block-rate figure is published for this or any Reddit scraper.

How fresh is the data?

Live per run. old.reddit.com is fetched fresh on every run with no caching. If the run falls back to the Arctic Shift archive (or you set discoveryEngine: "arcticshift" directly), that data source lags real-time Reddit by roughly an hour and has no hot or rising ranking.

Does it return post or comment content, or just the author list?

Just the author list and their profile card. The actor reads post and comment listings to find who is active, but it does not extract post titles, comment bodies, or scores — only the account identity (username, userId) and where it was found (discoverySurface, firstSeenType).

Which fields work best for AI training and RAG indexing?

For RAG enrichment, join on username or userId to pull postKarma, commentKarma, accountAgeDays and trophyNames into context when an LLM needs to reason about an account's standing. For training data, postKarma, commentKarma, accountAgeDays and trophyCount are numeric fields with consistent structure across every row. All fields return as typed primitives — strings, numbers, booleans and string arrays — requiring no HTML parsing or normalization before use.

What happens to the personal data this actor returns?

The actor returns publicly available Reddit profile data — it does not authenticate as the account holder or access anything not visible to a logged-out visitor. Lawful basis for storing, combining and using that data (including under GDPR or CCPA where applicable) sits with you as the operator of the run.

Does it work with Claude, ChatGPT and other AI agent tools?

There is no dedicated MCP server documented for this actor. It is callable as an HTTP endpoint through the Apify API by any agent framework that can issue requests — every response is typed JSON, so an agent can consume it directly without an HTML-parsing step.

---

ℹ️ Disclaimer

Reddit Scraper With User Profiles extracts only publicly available data from Reddit. This tool is intended for lawful use cases only. Users are responsible for complying with Reddit's terms of service and applicable data protection laws in their jurisdiction.