Reddit Subreddit Members Scraper With Activity History

Reddit Scraper — Extract Participants, Posts and Comments as JSON

Reddit publishes no subscriber list for any subreddit, so this Reddit scraper samples the accounts that are visible in a community's public post feed and its recent-comment feed, de-duplicates them, then opens each account's public overview page for a last-active date, a post/comment split, other communities they post in, karma and account age. Every response is typed, normalized JSON — no HTML, no selectors, no parsing. Their recent posts and comments follow as free child rows. After reading this, you'll know exactly which fields you get, what a "participant" is (and isn't), and where the real limits sit.

What is Reddit Subreddit Members Scraper With Activity History?

It is an Apify Actor that samples the accounts who recently posted or commented in one or more subreddits, then enriches each unique account with its recent activity history: last-active date, post/comment split, the other subreddits it shows up in, post, comment and total karma, account age, and trophy/admin flags. No Reddit account or login is required — the Actor reads Reddit's public Data API (oauth.reddit.com) with an anonymous app-only token, exactly like Reddit's own logged-out web client. Optionally supply your own registered Reddit app's client ID to run on your own rate-limit budget.

• 🧑‍🤝‍🧑 Scrape subreddit participants — usernames sampled from a community's New, Hot, Top or Rising feed, plus its recent-comment feed
• 🕒 Scrape each participant's activity history — last-active date, karma, account age, other communities
• 📝 Scrape each participant's recent posts and comments as linked child rows
• 🚦 Filter participants by recency or cross-subreddit activity before any row is charged
• 📦 Export results as JSON, CSV, or Excel from the Apify dataset, or pull them via API

What data does Reddit Subreddit Members Scraper With Activity History collect?

Every run returns one of three row shapes, all built from the fields below (read straight from src/main.py).

Data Type	Key Fields	JSON Field Names
Participants	username, Reddit user ID, karma, account age, last active	username, userId, postKarma, commentKarma, accountAgeDays, lastActiveISO, recentSubredditsJoined
Recent posts	title, subreddit, score, permalink, age	itemType (post), itemTitle, itemSubreddit, itemScore, itemPermalink, itemCreatedISO
Recent comments	body, subreddit, score, permalink, age	itemType (comment), itemBody, itemSubreddit, itemScore, itemPermalink, itemCreatedISO

How does Reddit Subreddit Members Scraper With Activity History differ from the official Reddit API?

Reddit's own Data API is the sanctioned way to pull posts, comments and profile data programmatically, but it does not solve the problem this Actor solves: there is no official endpoint that lists a subreddit's subscribers, and there never has been. Both surfaces have to sample who's active instead of listing who's subscribed.

Feature	Reddit Data API	Reddit Subreddit Members Scraper With Activity History
Subscriber/member list endpoint	Not offered	Not offered — samples active participants instead (documented in every row)
Access process	OAuth app registration, Reddit review, commercial contract for higher-volume use	Runs immediately on Apify with input only, no Reddit account
Output shape	Raw JSON matching Reddit's internal schema	Normalized dataset rows — participant + post/comment child rows
Activity enrichment (karma, account age, recent items)	Requires separate calls per endpoint, assembled by the caller	Delivered by the Actor in one pass per participant
Anti-bot handling	Not applicable (first-party)	Residential proxy pinned by default, Firefox/Safari TLS impersonation
Pre-filtering before cost	Caller's responsibility	activeWithinDays, otherSubreddits, excludeAuthors run before a row is written or charged

If you already have an approved Reddit API app and only need a handful of endpoints, the official API is the right tool. If you need a de-duplicated, enriched, ready-to-export dataset of who's active in a subreddit without building and maintaining OAuth, pagination and HTML-fallback logic yourself, use this Actor.

Why do developers and teams scrape Reddit subreddit participants?

🤖 For AI engineers and agent builders

Feed a subreddit's active-participant list, complete with recentSubredditsJoined and postsInTargetSubreddit, into a RAG pipeline or agent tool to ground community-analysis prompts in real, typed data instead of scraped HTML. Because every field is a stable JSON key (lastActiveISO, recentPostCount, activitySource), an agent can reason over "who is active and where" without a parsing step, and the linked itemType/itemBody child rows give it real post and comment text to summarize or classify.

📊 For marketers and community managers

Point the Actor at a competitor's or your own subreddit to see which accounts are actually posting and commenting this week, not just subscribed-and-silent. otherSubreddits reveals whether your most active participants also post in adjacent communities, which is a direct signal for cross-community outreach or ambassador targeting.

🔬 For researchers and analysts

discoverySurface, discoverySurfaces and timesSeenInRun make the sampling method auditable per row, and isSubscriberList: false is written into every parent row so a dataset can never be mistaken for a membership list downstream. That auditability matters for any study of community engagement that has to survive peer review or a methods section.

🧑‍💻 For developers building data products

postKarma, commentKarma, accountAgeDays and activityItemsAnalyzed are consistent, typed fields across every run, so a product built on top (a community health dashboard, a moderator tool, a bot-detection heuristic) doesn't need bespoke parsing per subreddit.

How to scrape Reddit subreddit participants (step by step)

1. Open Reddit Subreddit Members Scraper With Activity History on the Apify Store and click Try for free (or Run, if you already have it saved).
2. Add at least one entry to communityTargets — r/python, a full subreddit URL, u/spez, or free text to search. Nothing is required by the schema, but the Actor has nothing to sample without a target.
3. Choose feedSort (New, Hot, Top or Rising) and, for Top, a topTimeWindow. Set postSampleSize / commentSampleSize for how deep to read each feed, and maxParticipants for the charged-row ceiling.
4. Click Start and watch the run log — it reports how many unique participants were found and how many were filtered before any charge.
5. Download results as JSON, CSV or Excel from the Dataset tab, or pull them with the Apify API / apify_client.

What to do when Reddit changes its structure

The Actor no longer parses HTML at all — it reads typed JSON from Reddit's own Data API, so a front-end redesign cannot break it. Where Reddit hides an individual account's profile listing from anonymous API clients, the Actor falls back to Reddit's own search endpoint and then to the public Arctic Shift Reddit archive, and records which source produced each row in activitySource. The output schema — field names and row types — is what this README documents, and it stays stable across maintenance updates so downstream integrations don't need to change their parsing.

What changed in Reddit scraping recently?

Two changes in 2026 broke essentially every HTML-based Reddit scraper, and this Actor was rebuilt around both (all figures measured live on 2026-08-23):

1. The unauthenticated .json endpoints are gone. Reddit announced their deprecation in May 2026. https://www.reddit.com/r/<sub>/new.json now answers HTTP 403 with an HTML block page — from a residential exit, from a datacenter exit and from an ordinary home connection alike, so it is a product decision, not an IP-reputation problem.
2. old.reddit.com is login-walled for logged-out clients. Every anonymous request answers HTTP 302 → /login/?reason=lor2. The www.reddit.com HTML surface serves a JavaScript challenge and, once solved, only the app shell — the feed itself is fetched client-side.

What still works, and what this Actor uses, is Reddit's public Data API at https://oauth.reddit.com with an app-only OAuth token (installed_client grant), which returns complete, typed JSON on every endpoint the Actor needs and publishes its own rate-limit budget in x-ratelimit-remaining / x-ratelimit-reset headers. Because that surface is authenticated, it does not block datacenter IPs: measured over six requests per group, Apify's datacenter proxy succeeded 5/6 and residential 3/6, so the default proxy setting is plain Apify Proxy and forceResidential now defaults to false.

⬇️ Input

Nothing is required — supply at least one target in communityTargets (or subreddits) so the Actor has something to sample.

Parameter	Required	Type	Default	Description
communityTargets	No	array	–	One entry per line: r/python, a subreddit URL, u/spez / profile URL, or free text (searched across Reddit)
subreddits	No	array	–	Extra plain subreddit names, merged with communityTargets
feedSort	No	string (enum)	"new"	Feed to sample participants from: new, hot, top, rising
topTimeWindow	No	string (enum)	"month"	Time window for the top feed: hour, day, week, month, year, all
fetchRecentActivity	No	boolean	true	Read each participant's /about, /overview and /trophies for activity, karma, account age and profile flags
activitySampleSize	No	integer (1–100)	25	Recent items (posts + comments) analysed per participant
includeActivityItems	No	boolean	true	Also emit each recent item as its own free child row
activityItemsPerUser	No	integer (0–100)	5	Cap on child rows per participant (0 = none); does not change the analysis
activeWithinDays	No	integer (0–3650)	0	Drop participants inactive longer than N days, before the row is charged (0 = disabled)
otherSubreddits	No	array	–	Keep only participants also active in one of these communities (requires the activity lookup)
excludeAuthors	No	array	–	Usernames to skip, case-insensitive
maxParticipants	No	integer (1–10000)	50	Cap on unique participants (charged parent rows) per run
postSampleSize	No	integer (1–1000)	25	Items read from the chosen feed per community
commentSampleSize	No	integer (0–1000)	25	Items read from the recent-comment feed per community (0 = skip)
redditClientId	No	string	–	Optional client ID of your own registered Reddit app, to use its rate-limit budget instead of the shared anonymous one
redditClientSecret	No	string (secret)	–	Only for a script / web app type Reddit app; leave empty for an installed app client ID
maxRunSeconds	No	integer (60–86400)	3600	Hard run-time ceiling — every loop checks it, so the Actor finishes cleanly instead of hanging
proxyConfiguration	No	object	{"useApifyProxy": true}	Apify Proxy configuration. Datacenter is both fastest and most reliable on oauth.reddit.com
forceResidential	No	boolean	false	Rewrite the proxy configuration to RESIDENTIAL. Off by default — residential exits measure less reliable here
browserFingerprint	No	string (enum)	"firefox133"	TLS fingerprint used by the HTTP client: firefox133, safari17_0
requestDelaySeconds	No	integer (0–10)	1	Jittered pause between requests, in seconds
activityConcurrency	No	integer (1–10)	3	Parallel participant-activity lookups

Example input:

{
  "communityTargets": ["r/python", "https://www.reddit.com/r/webscraping/", "u/spez"],
  "subreddits": ["learnpython"],
  "feedSort": "top",
  "topTimeWindow": "month",
  "fetchRecentActivity": true,
  "activitySampleSize": 25,
  "includeActivityItems": true,
  "activityItemsPerUser": 5,
  "activeWithinDays": 30,
  "otherSubreddits": ["datascience"],
  "excludeAuthors": ["AutoModerator"],
  "maxParticipants": 50,
  "postSampleSize": 25,
  "commentSampleSize": 25,
  "proxyConfiguration": { "useApifyProxy": true },
  "forceResidential": false,
  "browserFingerprint": "firefox133",
  "requestDelaySeconds": 1,
  "activityConcurrency": 3,
  "maxRunSeconds": 3600
}

Common pitfall: setting otherSubreddits or a tight activeWithinDays without leaving fetchRecentActivity on true — both filters read the activity lookup, so they silently keep everyone if the lookup that feeds them is disabled.

⬆️ Output

Results are written to the Apify dataset as typed JSON rows, exportable as JSON, CSV or Excel. Three row shapes appear, distinguished by rowType: participant (charged), activityItem (free child row), and — only on a run that writes nothing — a single uncharged runNote accounting row.

Scraped participant

{
  "username": "spez",
  "userId": "t2_1w72",
  "profileUrl": "https://www.reddit.com/user/spez/",
  "totalKarma": 940933,
  "postKarma": 184453,
  "commentKarma": 756480,
  "createdUTC": 1118030400.0,
  "isGold": true,
  "iconImg": "https://styles.redditmedia.com/t5_3k30p/styles/profileIcon_uj015iwx9s7g1.png",
  "rowType": "participant",
  "rowId": "u_spez",
  "parentId": null,
  "createdISO": "2005-06-06T04:00:00Z",
  "accountAgeDays": 7748.13,
  "awardeeKarma": 0,
  "awarderKarma": 0,
  "trophyCount": 8,
  "trophyNames": "15-Year Club, Verified Email",
  "isRedditAdmin": true,
  "isModerator": true,
  "isVerified": true,
  "hasVerifiedEmail": true,
  "isNsfwProfile": false,
  "profileTitle": "spez",
  "profileDescription": "reddit ceo",
  "discoverySurface": "oauth.reddit:/r/python/top?t=month",
  "discoverySurfaces": ["oauth.reddit:/r/python/top?t=month", "oauth.reddit:/r/python/comments"],
  "discoveredInSubreddit": "python",
  "firstSeenItemId": "t3_1abcxyz",
  "timesSeenInRun": 2,
  "profileFetched": true,
  "activityFetched": true,
  "activitySource": "oauth.reddit.com/user/<name>/overview",
  "activityError": null,
  "lastActiveUTC": 1785954710.0,
  "lastActiveISO": "2026-08-22T12:31:50Z",
  "lastActiveType": "comment",
  "lastActiveSubreddit": "announcements",
  "daysSinceLastActive": 0.42,
  "oldestActivityISO": "2026-06-01T09:14:00Z",
  "activitySpanDays": 63.11,
  "activityItemsAnalyzed": 25,
  "recentPostCount": 4,
  "recentCommentCount": 21,
  "recentSubreddits": ["announcements", "python", "modnews"],
  "recentSubredditCount": 3,
  "recentSubredditsJoined": "announcements, python, modnews",
  "recentScoreTotal": 412,
  "recentScoreMedian": 6,
  "postsInTargetSubreddit": 3,
  "activityChildRows": 5,
  "isSubscriberList": false,
  "sampleScope": "accounts that recently posted or commented in the sampled feeds; lurkers excluded",
  "scrapedAtISO": "2026-08-23T10:00:00Z",
  "runId": "abCDefGhij0123"
}

Scraped activity item (child row)

{
  "rowType": "activityItem",
  "rowId": "u_spez#1",
  "parentId": "u_spez",
  "parentUsername": "spez",
  "username": "spez",
  "userId": "t2_1w72",
  "profileUrl": "https://www.reddit.com/user/spez/",
  "itemIndex": 1,
  "activitySource": "oauth.reddit.com/user/<name>/overview",
  "itemIsInTargetSubreddit": true,
  "scrapedAtISO": "2026-08-23T10:00:00Z",
  "runId": "abCDefGhij0123",
  "itemType": "comment",
  "itemId": "t1_kxyz123",
  "itemSubreddit": "python",
  "itemSubredditId": "t5_2qh0y",
  "itemTitle": "What is your favourite stdlib module?",
  "itemParentPostId": "t3_1abcxyz",
  "itemBody": "Have you tried the walrus operator here?",
  "itemUrl": "https://www.reddit.com/r/python/comments/1abcxyz/what_is_your_favourite_stdlib_module/",
  "itemPermalink": "https://www.reddit.com/r/python/comments/1abcxyz/what_is_your_favourite_stdlib_module/kxyz123/",
  "itemScore": 14,
  "itemNumComments": null,
  "itemCreatedUTC": 1785954710.0,
  "itemCreatedISO": "2026-08-22T12:31:50Z",
  "itemAgeDays": 1.75
}

For a post row, itemTitle is the post's own title, itemBody is its self-text (null for a link post), itemUrl is what the post links to and itemNumComments is its reply count. For a comment row, itemTitle is the title of the post the comment sits under, itemBody is the comment text, and itemParentPostId is that post's fullname.

How does Reddit Subreddit Members Scraper With Activity History compare to a generic Reddit scraper?

Feature	This Actor	Generic alternative
Membership labelling	Every row carries isSubscriberList: false and sampleScope — never claims to be a member list	Often markets a participant sample as "members" or "subscribers" without saying so
Entity coverage in one run	Participants + their recent posts + comments, linked by parentId	Typically one entity type per scraper; activity requires a second tool
Transport	Reddit's own Data API over an app-only OAuth token, with rate-limit headers honoured and two real fallbacks when Reddit hides a profile listing	Usually the .json endpoints or old.reddit.com HTML — both retired for anonymous clients in 2026
Cost control	activeWithinDays, otherSubreddits, excludeAuthors filter before a row is written or charged	Typically filters after fetching, or not at all
Output format	Typed, normalized JSON with stable field names	Often raw HTML or inconsistent field names across pages

If you're building an AI agent or RAG pipeline, the output-format row is the decision-maker — parsing HTML inside an agent loop is a reliability failure mode, not a feature.

How many participants can you scrape with this Actor?

maxParticipants caps charged parent rows at up to 10,000 per run (default 50); there is no separate cap on free activityItem child rows beyond activityItemsPerUser (0–100, default 5) each. Feed depth is capped by postSampleSize and commentSampleSize (1–1000 and 0–1000 respectively); each request reads up to 100 items and sweep_listing() follows Reddit's after cursor automatically, up to 12 pages per feed — Reddit itself stops paginating any single listing at roughly 1,000 items, which is the real ceiling. Every unique participant costs exactly one row_result charge regardless of how many child rows or feeds it was found in; activity lookups add three API calls per participant (/about, /overview, /trophies) when fetchRecentActivity is on. Reddit's app-only token allows about 100 requests per minute; the Actor reads x-ratelimit-remaining / x-ratelimit-reset from every response and pauses until the window resets instead of hammering. maxRunSeconds bounds the whole run, and every individual request has a hard 25-second timeout, so a run always terminates.

Integrate Reddit Subreddit Members Scraper With Activity History and automate your workflow

Reddit Subreddit Members Scraper With Activity History works with any language or tool that can send an HTTP request — it runs like any other Apify Actor.

REST API integration

from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("<actor-id>").call(run_input={
    "communityTargets": ["r/python"],
    "feedSort": "top",
    "topTimeWindow": "month",
    "maxParticipants": 50,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["rowType"], item.get("username"), item.get("lastActiveISO"))

Works in Python, Node.js, Go, Ruby, cURL — any client that can call the Apify API with your API token.

Automation platforms (n8n, Make, LangChain)

In n8n, the built-in Apify node runs this Actor and streams its dataset into the rest of your workflow — no custom HTTP request node needed. In Make, the Apify app's "Run Actor" and "Get Dataset Items" modules do the same. In LangChain, langchain_community.document_loaders.ApifyDatasetLoader (or the ApifyWrapper helper) can start this Actor and load its dataset rows directly as Document objects for an agent or retrieval chain.

Is it legal to scrape Reddit subreddit participants?

Scraping publicly accessible Reddit pages is generally lawful, and this Actor returns only data that is visible without logging in — usernames, public posts and comments, and karma/account-age figures shown on public profile pages. That data is nonetheless personal data about real, identifiable people: it links a stable username to their posting behaviour, community memberships and account history. If you are in the EU/UK or processing data about EU/UK residents, GDPR governs your storage, use and retention of it; CCPA may apply if you are handling data about California residents at scale. Reddit's own Terms of Service and User Agreement also govern automated access regardless of your intent. Consult legal counsel for commercial use cases involving bulk personal data.

Frequently asked questions

Does this Actor work without a Reddit account?

Yes. It never logs in as a Reddit user. It authenticates as an application using Reddit's anonymous installed_client grant — the same app-only token Reddit's own logged-out web client uses — and reads only data that is public to any logged-out visitor. Supplying redditClientId (and redditClientSecret for a script/web app) is optional and only changes whose rate-limit budget is spent.

How often is the scraped data updated?

Every run fetches live pages at the time it runs; nothing is cached or replayed from a previous run. scrapedAtISO on every row records exactly when that row was read.

What happens if a participant's account is deleted, suspended, or has no public activity?

If /user/<name>/about returns 404 the row is kept with activityFetched: false and activityError: "profile-not-found-deleted-or-suspended"; a 403 gives "profile-forbidden-suspended-or-private". Reddit also serves an empty profile listing for a sizeable minority of perfectly live accounts when the caller is an anonymous app-only client — measured on 2026-08-23, 6 of 14 r/python authors returned children: [] deterministically across fresh tokens, fresh device IDs and three different exit IPs, while Reddit's own search still returned the same accounts' posts. For those accounts the Actor falls back to Reddit's search endpoint and then to the public Arctic Shift Reddit archive, notes it in activityError and names every source it used in activitySource. If nothing at all is visible, activityError is "no-public-items-visible" and the activity fields are left null — nothing is ever invented. Participants with unreadable activity are kept and flagged, never silently dropped, unless activeWithinDays explicitly filters them out.

Can I scrape private subreddits or suspended accounts' content?

No. Only communities and profiles that Reddit exposes to a logged-out visitor are read. Private and quarantined subreddits, and suspended or shadowbanned accounts, are not accessible to this Actor. There is also no endpoint, official or otherwise, that lists a subreddit's subscribers — that roster is private, which is exactly why this Actor samples visible participants instead and stamps isSubscriberList: false on every parent row.

How is this Actor priced?

Pay per event. One row_result charge is made per unique participant (parent row). Activity activityItem child rows, and the single runNote row written when a run finds zero participants, are pushed without a charged event and cost nothing.

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

Yes — it is callable as a standard HTTP endpoint by any agent framework via the Apify API, and every dataset row is typed JSON with stable field names, so no parsing step is needed before passing it into an LLM context window or a retrieval pipeline.

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

It avoids it rather than fighting it: Reddit's Data API is an authenticated surface with a published rate-limit budget, so the Actor reads x-ratelimit-remaining / x-ratelimit-reset from every response and backs off before it is throttled. On top of that it mints a fresh proxy exit per request, rotates TLS fingerprints and retries with exponential backoff on transport errors, honours Retry-After on HTTP 429, re-mints the OAuth token on HTTP 401, and treats an HTTP 200 whose body is not JSON as a block rather than as data.

How does this Actor compare to other Reddit scrapers?

See the comparison table above. The concrete, checkable differences are: participant rows are explicitly labelled as a sample (never a subscriber list), posts and comments are returned as linked child rows in the same run, and cost-relevant filters run before a row is charged.

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

Yes. Every row is typed, normalized JSON with stable field names and no HTML or CSS selectors to strip. Pass it 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 Proxy is configured by default and you don't need your own pool. Reddit's Data API does not block datacenter exits, so the plain default is the fastest and most reliable choice; set forceResidential to true only if your own network needs a residential exit.

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

The Actor is maintained, and its output schema — field names and row types — stays stable across maintenance updates, so integrations built on it keep working on the user's end without changes.

Your feedback

Found a bug, or a field that doesn't match what's documented here? We want to know — open an issue via the Actor's page on the Apify Store or contact API-Empire through your Apify Console. Reports like these keep this Actor's fields and limits accurate.