# Reddit User Scraper — Profile, Karma, Posts & Comments (`foxlabs/reddit-user-scraper`) Actor

Reddit users by name: the profile (link and comment karma, cake day, bio, trophies and the subreddits they moderate) and the user's posts and comments, newest first, with text, score, exact time and score per hour. Only-new mode. No login.

- **URL**: https://apify.com/foxlabs/reddit-user-scraper.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Social media
- **Stats:** 6 total users, 5 monthly users, 68.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 post or comments

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Reddit User Scraper — Profile, Karma, Posts & Comments 🚀

**foXLabs Reddit series:** [Search](https://apify.com/foxlabs/reddit-search-scraper) · [Subreddit Posts](https://apify.com/foxlabs/reddit-subreddit-posts-scraper) · [Post Details](https://apify.com/foxlabs/reddit-post-details-scraper) · [Post Comments](https://apify.com/foxlabs/reddit-post-comments-scraper)

🎉 Reddit users by name, as Reddit shows them to a signed-out visitor: **the profile** — link and comment karma, the cake day, the bio, **trophies and the subreddits the user moderates** — and **the user's posts and comments**, newest first (or top/hot/controversial), with text, score, exact time and score per hour, as far back as Reddit shows a user's history. Only-new mode to watch accounts. No login, no cookies of yours, no CAPTCHA solving.

### 🔍 What is the Reddit User Scraper — and when should you use it?

Give this Actor Reddit usernames and it returns each user's profile plus their posts and comments as clean rows.

**Use it when you need:** a user's full public activity (profile + history); influencer/mod research (karma, trophies, moderated subreddits); or account monitoring on a schedule.

**Use something else when:** you're searching by keyword → [Search](https://apify.com/foxlabs/reddit-search-scraper); you want one post's thread → [Post Comments](https://apify.com/foxlabs/reddit-post-comments-scraper).

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/reddit-user-scraper`. An agent can discover it, run it and read the dataset over MCP.

**Real-time Standby API.** The same code answers HTTP requests on demand — `GET /user?name=spez&include=overview&maxItems=50`. Parameters: `name`, `include`, `sort`, `time`, `maxItems` (1–100), `profile` (0/1), `trophies` (0/1); billed with the same `profile` and `item` events.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want Reddit user profiles & activity using the Apify Actor
`foxlabs/reddit-user-scraper`.

Input: `users` is a list of usernames; `include` is overview/posts/comments; `sort`/`time` order
the history. Each user yields a profile row (karma, age, trophies, moderated subreddits) plus
post and comment rows.

Start with:
{ "users": ["spez"], "include": "overview", "maxItemsPerUser": 50 }

Ask me which users to profile, run the Actor, then summarise their activity.
```

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/reddit-user-scraper.md`.

### 📋 Overview

Everything you need to turn Reddit usernames into clean, structured data — profile, karma, trophies and full public activity — in one Actor, with no login, cookies or CAPTCHA solving.

**Why teams pick this Actor:**

- ✅ **Profile + activity** — karma, the cake day, the bio, trophies, moderated subreddits with their sizes, and the user's posts and comments.
- 📈 **Velocity on activity** — score per hour on each post/comment row.
- 🔁 **Account monitoring** — schedule with only-new to watch an account's new activity.
- 🎯 **Honest limits** — history goes as far back as Reddit lists it to a visitor; a hidden history still returns the profile.
- 💰 **Pay only for results** — `profile`/`item` events per row; status rows free.
- 🤖 **Agent-ready** — MCP + a real-time Standby API.

### ✨ Features

- 🔍 **Users by name** — `spez`, `u/spez` or a profile URL.
- 👤 **Profile** — link/comment/total karma, account age, the bio and the avatar. (Reddit's pages no longer show a signed-out visitor the premium/mod/employee/verified flags, the banner or the account's `t2_` id: those are `null`.)
- 🏆 **Trophies & moderated subreddits** — with `includeTrophies`.
- 📝 **Posts & comments** — `include` overview/posts/comments; the family's full post and comment fields.
- 🔁 **Only-new lists** for account watching.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~reddit-user-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"users": ["spez"], "include": "overview", "maxItemsPerUser": 50}'
```

### 🚀 Getting Started (3 steps)

1. **Enter your users** — one per line: `spez`, `u/spez` or a profile URL.
2. **Pick scope & order** — `include` (overview/posts/comments), `sort`/`time`.
3. **Run and export** — get a clean dataset as JSON, CSV or Excel.

### 📥 Input

| Field | Meaning |
|---|---|
| `users` | one per line: `spez`, `u/spez` or `https://www.reddit.com/user/spez/`. |
| `include` | `overview` (posts + comments, default), `posts`, `comments`. |
| `sort`, `time` | `new` (default), `hot`, `top`, `controversial`; the period for top/controversial. |
| `maxItemsPerUser` | posts+comments per user (default 100), as far back as Reddit lists the history. |
| `maxItems` | rows in the whole run (default 100,000). |
| `includeProfile` | the profile row (default on; charged as a `profile`). |
| `includeTrophies` | trophies + moderated subreddits on the profile (default on; two requests per user). |
| `onlyNewItems`, `listName` | remember delivered rows and skip them next time. |
| `proxyConfiguration` | nothing to change for normal use. |

```json
{ "users": ["spez", "u/AutoModerator"], "include": "overview", "maxItemsPerUser": 200 }
```

### 📤 Output

One profile row per user (`type: "user"`), then post rows (`type: "post"`) and comment rows (`type: "comment"`).

| Field (profile) | What it is |
|---|---|
| `username`, `userId`, `fullname`, `url` | name, id, address |
| `linkKarma`, `commentKarma`, `totalKarma`, `awarderKarma`, `awardeeKarma` | karma |
| `createdAt`, `accountAgeDays` | when the account was made, how old |
| `verifiedEmail`, `premium`, `isMod`, `isEmployee`, `acceptsFollowers` | flags |
| `description`, `avatarUrl`, `bannerUrl`, `subredditTitle`, `nsfw` | the profile page |
| `trophies`, `moderatedSubreddits` | with `includeTrophies` |

Post rows carry the [Subreddit Posts Scraper](https://apify.com/foxlabs/reddit-subreddit-posts-scraper) fields; comment rows carry text, subreddit, score, controversiality, times, flags and the post's title/address. Every row has `input` and `position`.

A line that brings nothing gets a **free status row**: not a user, no such user (deleted/shadowbanned), suspended, or named twice. A user with a profile but no listed history gets the profile row and a note.

### 💼 Use cases

**1. Influencer / mod research** — karma, trophies and which subreddits a user moderates.
*Input:* the usernames, `includeTrophies` on. *Output:* profile rows. *Use:* assess reach and authority.

**2. Activity analysis** — a user's posts and comments for behaviour analysis.
*Input:* users, `include: overview`, high `maxItemsPerUser`. *Output:* full history. *Use:* study topics and tone.

**3. Account monitoring** — watch an account's new activity.
*Input:* users, `onlyNewItems`, scheduled. *Output:* new posts/comments each run. *Use:* a watchlist feed.

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/reddit-user-scraper').call({
  users: ['spez'], include: 'overview', maxItemsPerUser: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/reddit-user-scraper').call(
    run_input={'users': ['spez'], 'include': 'overview', 'maxItemsPerUser': 50}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

Written for `apify-client` 3 for Python, where `call()` returns a run object; with version 1 or 2 it returns a dict — write `run['defaultDatasetId']` there.

**Automation (n8n / Zapier / Make):** schedule → HTTP request to the Actor API with your `users` → handle the JSON dataset → push to a sheet, CRM or dashboard.

### 📊 Pricing

Pay per event: **`profile`** per delivered profile row (trophies and moderated subreddits ride along free), **`item`** per delivered post or comment row. Status rows are free; a run Reddit doesn't answer ends FAILED and charges nothing; no start fee. [View current pricing.](https://apify.com/foxlabs/reddit-user-scraper)

### ❓ FAQ

**Do I need a Reddit account, login or API key?** No — a signed-out guest token, no account, no cookies, no CAPTCHA solving.

**How far back does history go?** As far as Reddit lists it to a visitor (measured: one account ended at 348 items, another went past 1,200). Some accounts' histories aren't listed at all; the profile row still comes.

**Why did `top` + `year` return nothing for a user?** Reddit shows top/controversial of a period only where the user was active then; use `all`.

**Can I export to CSV / Excel / JSON?** Yes — directly from the Apify dataset.

**What about suspended/deleted users?** A free status row says so.

### 🐛 Troubleshooting

- **Fewer items than asked** — Reddit's listing of that account's history ends there; it's not an error.
- **Only the profile row** — the account's history isn't shown to signed-out visitors (e.g. AutoModerator); the profile still comes.
- **A line returns a status row** — not a user, no such user, suspended, or named twice (free).
- **`subredditInfo.activeUsers` null** on post rows — Reddit doesn't give it to a signed-out visitor.

**How it reads Reddit:** opens a listing as a signed-out visitor, takes the guest token, and calls Reddit's JSON API. Residential-only token (measured 7/7 residential, 0/8 datacenter) → Apify Proxy residential by default; four addresses rotate.

### ⚠️ Trademark

Independent, third-party tool. Reddit is a trademark of Reddit, Inc.; this Actor is not affiliated with, endorsed by or connected to Reddit. The mark is used here for identification only.

### ⚖️ Is it legal to scrape this data?

It reads only what Reddit shows anyone who is not signed in. Rows carry user names (public pseudonyms) and publicly posted text; you are responsible for using them lawfully (GDPR, CCPA, Reddit's User Agreement). Nothing is stored outside your own Apify datasets. See Apify's blog post on the legality of web scraping.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🐛 **Issues:** open a ticket in the Actor's **Issues** tab — the run's `SOURCE_REPORT` record holds what was seen, read, delivered and why the run stopped.
- 🧰 **More clean data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.2.0 — 2026-10-17

Reddit closed its JSON API to signed-out visitors on 16 October 2026, so the profile and the history now come from
Reddit's own pages: the profile page carries the karma, the cake day, the bio, the trophies and the moderated
subreddits in one read, and the posts and comments feeds answer with 23–25 items a page. Field names, the dataset
shape and the prices are unchanged. `userId`, `awarderKarma`, `awardeeKarma`, `verifiedEmail`, `premium`, `isMod`,
`isEmployee`, `acceptsFollowers`, `bannerUrl`, `nsfw` and a trophy's date are `null`, a profile row is keyed by
`u_<name>`, and a comment of the history does not name its subreddit (its post and title are on the row).

#### 0.1.0 — 2026-10-10

- First release: profiles with karma, age, flags, trophies and moderated subreddits; posts and comments with the family's full fields; four orders and six periods; only-new lists; free status rows; Standby API prepared.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/reddit-user-scraper/changelog.md

# Actor input Schema

## `users` (type: `array`):

One user per line: a name (spez), u/spez, or a profile address (https://www.reddit.com/user/spez/). A user written twice is read once. Suspended, deleted and shadowbanned users get a status row.

## `include` (type: `string`):

The user's posts and comments together (overview, default), posts only, or comments only. The profile row comes in any case unless turned off below.

## `sort` (type: `string`):

new (newest first, default), hot, top (highest score in the period), controversial.

## `time` (type: `string`):

The period the top and controversial orders cover. Ignored for new and hot.

## `maxItemsPerUser` (type: `integer`):

How many of the user's posts and comments to deliver, from the top of the listing. Reddit hands them out 100 a request, as far back as it lists the user's history to a visitor who is not signed in: a larger number stops where Reddit stops.

## `maxItems` (type: `integer`):

The run stops when this many post and comment rows have been delivered. You are charged only for delivered rows.

## `includeProfile` (type: `boolean`):

On (default): one row per user (type "user") with karma, account age, flags, trophies and moderated subreddits, charged as a profile. Off: posts and comments only.

## `includeTrophies` (type: `boolean`):

Two more requests per user add the user's trophies and the subreddits the user moderates (public lists). Off: the profile row carries karma, age and flags alone.

## `onlyNewItems` (type: `boolean`):

Remember delivered posts and comments under the list name below and skip them in later runs: schedule the same users and each run brings only what is new. The profile row is delivered every run.

## `listName` (type: `string`):

Name of the memory used by "Only posts and comments not delivered before" (looked at only when that is on). Letters, digits and hyphens (a hyphen not first or last), up to 40 characters; capitals are read as lower case.

## `proxyConfiguration` (type: `object`):

Nothing to change for normal use: the Actor reads Reddit through Apify Proxy residential addresses, the only kind Reddit hands its guest token to (measured: residential 7 of 7 sessions, datacenter 0 of 8). Set a proxy here to send every request through it instead; a setting the platform refuses ends the run before anything is read.

## Actor input object example

```json
{
  "users": [
    "spez"
  ],
  "include": "overview",
  "sort": "new",
  "time": "all",
  "maxItemsPerUser": 50,
  "maxItems": 100000,
  "includeProfile": true,
  "includeTrophies": true,
  "onlyNewItems": false,
  "listName": "default",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "users": [
        "spez"
    ],
    "maxItemsPerUser": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/reddit-user-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 = {
    "users": ["spez"],
    "maxItemsPerUser": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "users": [
    "spez"
  ],
  "maxItemsPerUser": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call foxlabs/reddit-user-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foxlabs/reddit-user-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/oNiZV802OVAdASqvg/builds/9GGCcBiw7la0wDwXC/openapi.json