# Reddit Usernames Scraper (`truefetch/reddit-usernames-scraper`) Actor

Reddit usernames scraper that exports activity-derived subreddit contributors as 24-field profiles—identity, karma, account flags, trophies, moderated communities, and multireddits. Up to 400 profiles per run; not an official subscriber list. FREE-tier results cost $7.50 per 1,000 profiles.

- **URL**: https://apify.com/truefetch/reddit-usernames-scraper.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Social media, Developer tools, Automation
- **Stats:** 5 total users, 0 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.66 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

**Reddit Usernames Scraper is a Reddit usernames scraper that converts one subreddit's recent visible activity into structured contributor profiles with usernames, karma, account age, status flags, trophies, moderated communities, and multireddits.**

- **Two required inputs: one subreddit and a result target from 1 to 400 profiles.**
- **Discovery is based on recent post authors and visible comment authors, not Reddit's subscriber database.**
- **Each successful dataset row follows a documented 24-field top-level profile contract.**
- **FREE-tier billing is $0.01000 per run plus $0.00750 per delivered profile.**

[**Run a one-result test**](https://apify.com/truefetch/reddit-usernames-scraper/input) · [**View API**](https://apify.com/truefetch/reddit-usernames-scraper/api)

The smallest useful test requests one profile and costs at most **$0.01750 on the FREE tier** when one profile is delivered; the output is activity-derived, not an official subscriber list.

### What does Reddit Usernames Scraper do?

Reddit Usernames Scraper starts from one public subreddit and finds usernames attached to its recent posts and visible comments. It removes duplicate usernames, requests public profile information for the resulting accounts, and writes one profile per available contributor to the default Apify dataset.

The result is best understood as an **activity-derived contributor sample**. It can help identify accounts that recently participated in a community, enrich an existing list of authors, compare public karma signals, or examine publicly visible moderation relationships. It cannot establish who formally joined, currently subscribes, reads without posting, or left the community.

The Actor returns source data as observed during the run. Account flags, trophies, public descriptions, moderated communities, and multireddits can be absent or empty. Those values should not be treated as independent identity verification, endorsement, influence scoring, demographic evidence, or proof that an account still controls a particular profile.

### How do I run Reddit Usernames Scraper?

Open the [Actor input page](https://apify.com/truefetch/reddit-usernames-scraper/input), enter a subreddit, choose the maximum number of profiles, and start the run. A plain subreddit name such as `learnpython` is the clearest format. Standard `r/name` paths and Reddit community URLs are also accepted.

Use this shared example throughout the Console, API, and MCP sections:

```json
{
  "community": "learnpython",
  "max_results": 60
}
```

After the run finishes, open the default dataset and compare `username`, karma fields, account flags, nested public arrays, and `processed_at`. The requested maximum is a target for discovered usernames, not a promise that every username will yield an accessible profile. Verify important records against Reddit before using them in outreach, moderation, research, or automated decisions.

Start with 60. A small run makes source coverage, field availability, duration, and cost easy to inspect before you raise the limit for a larger community.

### What data does Reddit Usernames Scraper return?

Every returned row uses these 24 top-level fields:

- **Provenance:** `processor`, `processed_at`.
- **Profile identity:** `id`, `name`, `username`, `profile_url`, `avatar`, `banner`, `about`, `created`.
- **Source account flags:** `verified`, `verified_email`, `snoovatar`, `is_premium`, `is_employee`, `is_moderator`, `is_suspended`, `is_nsfw`, `robots_hidden`.
- **Public activity signals:** `post_karma`, `comment_karma`.
- **Nested public resources:** `trophies`, `moderated`, `multireddits`.

For the shared `learnpython` scenario, the compact illustrative example below includes every top-level key. Later source values can differ or be null:

```json
{
  "processor": "https://apify.com/truefetch/reddit-usernames-scraper",
  "processed_at": "2026-07-24T06:30:00+00:00",
  "id": "example-id",
  "name": "Example profile title",
  "username": "example_contributor",
  "profile_url": "https://www.reddit.com/user/example_contributor/",
  "avatar": "https://i.redd.it/snoovatar/avatars/example.png",
  "banner": null,
  "about": "Public profile description",
  "verified": false,
  "verified_email": true,
  "post_karma": 1250,
  "comment_karma": 4870,
  "created": "2020-05-10T12:00:00+00:00",
  "snoovatar": true,
  "is_premium": false,
  "is_employee": false,
  "is_moderator": true,
  "is_suspended": null,
  "is_nsfw": false,
  "robots_hidden": false,
  "trophies": [
    {
      "name": "Verified Email",
      "icon": "https://www.redditstatic.com/awards2/verified_email.png",
      "granted": "2020-05-10T12:00:00+00:00",
      "description": null
    }
  ],
  "moderated": [
    "r/example"
  ],
  "multireddits": [
    {
      "name": "research",
      "description": "Public collection",
      "subreddits": [
        "r/apify"
      ],
      "created": "2020-05-10T12:00:00+00:00",
      "path": "/user/example_contributor/m/research/",
      "url": "https://www.reddit.com/user/example_contributor/m/research/",
      "visibility": "public"
    }
  ]
}
```

`verified` and `verified_email` are source-reported account flags, not TrueFetch verification. Empty `trophies`, `moderated`, or `multireddits` arrays can mean that no public values were returned or that the values were unavailable to the run account.

### What inputs can I configure?

`community` is a required string. It accepts a display name such as `apify`, a path such as `r/apify` or `/r/apify`, or a standard Reddit URL containing `/r/apify`. Use one community per run so the dataset and run status retain a clear source boundary.

`max_results` is a required integer from 1 to 400. It limits the unique author names selected for profile enrichment, not the Reddit source objects examined, and it does not guarantee an equal number of dataset rows when individual profiles cannot be returned.

There are no date, keyword, geography, language, minimum-karma, verification, or moderator-only filters. Apply those conditions after export, or use a downstream workflow that reads the default dataset.

### What platforms and markets does Reddit Usernames Scraper cover?

The Actor covers contributor profiles discoverable from Reddit subreddit activity. It does not combine identities from other networks or infer cross-platform identity matches.

There is no country or market selector. A subreddit name, language, posting time, karma total, or moderation role is not reliable evidence of residence, age, profession, or demographic membership. If a community is private, banned, quarantined, unavailable, or has little visible activity, coverage can be limited or absent.

### Why use Reddit Usernames Scraper?

The main advantage is a repeatable profile dataset without asking the user to supply Reddit application credentials. Console runs are useful for one-time reviews, while API, schedules, webhooks, and MCP access make the same input contract reusable in automations.

The output separates provenance, account flags, karma, and nested public resources into predictable fields. This is easier to filter and export than manually opening many author pages. The dataset can be downloaded in JSON, JSONL, CSV, Excel, XML, or RSS-compatible forms supported by Apify.

The scope disclosure is equally important: the Actor labels the sample according to how usernames are found. That makes it possible to design analysis around active contributors without falsely presenting the result as a subscriber directory.

Use a maximum total charge for unattended workloads, inspect a small sample before scaling, and retain the processing timestamp when merging results across runs.

### Who is Reddit Usernames Scraper for?

**Community researchers** can create a reproducible sample of recent visible contributors, then compare public karma or moderation indicators. The data supports exploration; it does not establish influence, expertise, authenticity, or community membership.

**Developer and data teams** can feed structured public profile rows into enrichment, deduplication, monitoring, or review pipelines.

**Analysts and content teams** can identify accounts worth reviewing after they participate publicly. Outreach must remain relevant, proportionate, and compliant with platform rules and applicable law. Do not use the output for spam, harassment, sensitive profiling, or decisions that require verified identity.

**AI-agent builders** can request a small contributor sample through MCP and ground a workflow in current structured data. The agent should cite the observation time, distinguish public activity from subscription, and avoid turning missing fields into negative claims.

### How can I use Reddit Usernames Scraper through the API or MCP?

For an HTTP run that waits for dataset items, replace `YOUR_TOKEN` and use the same `learnpython`/60 scenario:

```bash
curl -X POST "https://api.apify.com/v2/acts/QlV6JXKESJembXKsQ/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"community":"learnpython","max_results":60}'
```

For an MCP client, configure Apify's MCP endpoint with your token according to the [Apify MCP documentation](https://docs.apify.com/integrations/mcp):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?token=YOUR_TOKEN"
    }
  }
}
```

Then call the Actor with the same input values. Tool names vary by client, but the Actor identifier and arguments remain explicit:

```json
{
  "actor": "truefetch/reddit-usernames-scraper",
  "input": {
    "community": "learnpython",
    "max_results": 60
  }
}
```

The synchronous endpoint can exceed a client timeout on a slower or larger run. For production workflows, start the run asynchronously, poll its status, and read the default dataset after success. Store tokens in secrets rather than source files, and set platform-side spending limits appropriate to the workflow.

### How much does Reddit Usernames Scraper cost?

Reddit Usernames Scraper uses pay-per-event pricing: one Actor Start event per run plus one Result event for each profile delivered to the default dataset.

| Billed event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Actor Start, per run | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 |
| Result, per delivered profile | $0.00750 | $0.00675 | $0.00600 | $0.00563 | $0.00563 | $0.00563 |

The smallest useful FREE-tier run that delivers one profile costs **$0.01000 + (1 × $0.00750) = $0.01750**. Charges follow results actually emitted, so a request can cost less when fewer profiles are available. Prices can change; review the [pricing page](https://apify.com/truefetch/reddit-usernames-scraper/pricing) before budgeting and use `maxTotalChargeUsd` for an independent spending boundary.

### How does Reddit Usernames Scraper compare with alternatives?

| Approach | Strength | Limitation |
| --- | --- | --- |
| Reddit Usernames Scraper | Structured activity-derived contributor profiles with Apify exports and integrations | Not an official member list; source availability and runtime vary |
| Manual profile review | Strong context for a very small number of known authors | Slow, inconsistent, and difficult to reproduce at larger scale |
| A custom Reddit integration | Full control over discovery, concurrency, storage, and validation choices | Requires credentials, engineering, monitoring, and ongoing maintenance |
| A post or comment dataset | Preserves content context and timestamps | Does not automatically provide the 24-field profile enrichment contract |

Choose this Actor when recent contributors and public profile attributes fit the question. Choose a post-focused Actor when text, links, scores, or comment threads are primary. No approach should be described as a complete subreddit membership export unless Reddit explicitly supplies such a dataset.

### What are the limits and troubleshooting steps?

The most important limit is conceptual: participation is not subscription. The sample depends on recent listings and visible comment trees. Sorting, deletions, moderation, privacy, source pagination, and account visibility all affect who appears.

Runtime is not proportional only to returned rows: discovering authors and enriching several profile resources makes larger limits slow. Start low, observe duration, and increase gradually. A client-side timeout does not necessarily mean the Apify run stopped; check the run status separately.

If the Actor reports a missing field, provide both `community` and `max_results`. If no active users are found, verify that the subreddit exists and has publicly visible recent activity. If fewer profiles are returned than requested, inspect the dataset and run logs for inaccessible source accounts rather than assuming missing rows are inactive or invalid.

For repeatable analysis, retain the original input, dataset ID, processing timestamps, and export date. Do not silently merge records from different observation windows.

### Frequently asked questions

#### How do I extract Reddit usernames from subreddit activity?

Enter one community name and a result target: the Actor reads recent posts and visible comments to extract Reddit usernames from subreddit activity, then resolves each unique author into a profile row.

#### Can I export Reddit users to CSV?

Yes — export Reddit users to CSV directly from the run's dataset, which also offers JSON and Excel; one row per contributor keeps karma and flags sortable.

#### Does this return every subreddit member or subscriber?

No. It discovers unique usernames from recent posts and visible comments. It cannot list silent readers, all subscribers, or Reddit's official membership state.

#### Why can the dataset contain fewer rows than max\_results?

`max_results` is the maximum number of discovered usernames selected for enrichment. Deleted, suspended, inaccessible, or transiently failing profiles can be omitted, so the emitted dataset may be smaller.

#### What does one row represent?

One row represents a public Reddit profile for an author found in the scanned community activity. It includes 24 top-level fields, with nested arrays for trophies, moderated communities, and multireddits when available.

#### Can I rank contributors by karma?

You can sort the returned `post_karma` and `comment_karma` fields, but karma is platform-wide and is not proof of contribution quality, expertise, authenticity, or influence inside the requested subreddit.

#### Do users need to provide Reddit credentials?

No user-supplied Reddit client ID, secret, login, or cookie is part of the input contract. Users still need an Apify account and token for API or MCP access.

#### Can I schedule recurring contributor snapshots?

Yes. Use Apify schedules and preserve each dataset's timestamp. Expect membership-like comparisons to reflect visible activity changes, source availability, and profile changes rather than formal joins or departures.

### Related TrueFetch Actors

- [Reddit Community Post](https://apify.com/truefetch/reddit-community-post) exports community posts when post-level signals are the target.
- [Reddit Community Profile](https://apify.com/truefetch/reddit-community-profile) returns metadata, rules, and settings for one subreddit.
- [Reddit User Profile](https://apify.com/truefetch/reddit-user-profile) looks up a known Reddit username without first discovering it from community activity.

These three Actors complement contributor sampling without implying that their outputs prove identity, formal membership, or exhaustive source coverage.

### Support

For input questions, reproducible failures, or dataset-contract issues, contact the [TrueFetch group](https://t.me/TrueFetch). Include the Actor name, run ID, sanitized input, and observed result. Never share tokens, credentials, or private datasets in a public message.

Open the [Actor page](https://apify.com/truefetch/reddit-usernames-scraper) for the live release, pricing, and Console. Review Reddit's terms and applicable privacy, data-protection, outreach, and platform rules before storing or acting on profile data.

# Actor input Schema

## `community` (type: `string`):

Subreddit name, r/name path, or reddit.com/r/name URL to scan for recent post and comment authors

## `max_results` (type: `integer`):

Members to return, minimum 1 and no upper limit. Communities expose far more people than one run can read: each profile costs about 7.6 seconds end to end, so the default one-hour run reaches roughly 400 — raise the run timeout for more. Rows are saved as they are read, so a run that hits its timeout keeps everything already returned.

## Actor input object example

```json
{
  "community": "learnpython",
  "max_results": 3
}
```

# Actor output Schema

## `results` (type: `string`):

Public Reddit profiles for unique authors discovered in the selected community's recent activity.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "community": "learnpython",
    "max_results": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/reddit-usernames-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "community": "learnpython",
    "max_results": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/reddit-usernames-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "community": "learnpython",
  "max_results": 3
}' |
apify call truefetch/reddit-usernames-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=truefetch/reddit-usernames-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/QlV6JXKESJembXKsQ/builds/HrEUmQ9XuQR0sKWpQ/openapi.json