# Reddit User Scraper: Posts & Comment History, $2/1K Items (`actorforgehq/reddit-user-scraper`) Actor

Input: Reddit usernames. Output: each user's public posts and comments, newest first, as JSON rows with subreddit, score, body text, permalink and UTC date, up to about 1,000 items per user. $2 per 1,000 posts or comments, no start fee.

- **URL**: https://apify.com/actorforgehq/reddit-user-scraper.md
- **Developed by:** [Sluicebox](https://apify.com/actorforgehq) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 posts

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: Posts & Comment History, $2/1K Items

Get a **Reddit user's public posts and comments** as clean JSON, newest first: subreddit, score,
title or body text, permalink and UTC date for every item, plus one profile row per user with
karma, the registration date and the bio. Pick posts, comments or both, set a date, and use
only-new mode on a schedule to follow an account over time.

It reads the same public profile pages Reddit serves to a logged-out visitor's browser, over
plain HTTP with no page rendering and no scrolling, at a fixed pace that stays inside the request
quota Reddit itself announces for these pages.

This is the user member of our Reddit family. It shares its code, its field names and its output
format with the [Reddit Data Scraper](https://apify.com/actorforgehq/reddit-data-scraper), the
[Reddit Subreddit Scraper](https://apify.com/actorforgehq/reddit-subreddit-scraper), the
[Reddit Comments Scraper](https://apify.com/actorforgehq/reddit-comments-scraper) and the
[Reddit Search Scraper](https://apify.com/actorforgehq/reddit-search-scraper), so an input or a
pipeline written for one works with the others.

### What you get

One row per comment or post in the user's history, plus one profile row:

```json
{
  "type": "comment",
  "id": "p1wosm9",
  "postId": "1vgbkge",
  "subreddit": "u_spez",
  "author": "spez",
  "score": 12,
  "body": "Thanks, that is a fair point. We are looking at it.",
  "createdUtc": "2026-08-06T15:12:03.000Z",
  "permalink": "https://www.reddit.com/user/spez/comments/1vgbkge/comment/p1wosm9/",
  "depth": 0
}
```

```json
{
  "type": "user",
  "id": "1w72",
  "name": "spez",
  "permalink": "https://www.reddit.com/user/spez/",
  "karma": 941086,
  "postKarma": 184577,
  "commentKarma": 756509,
  "contributions": 4064,
  "createdUtc": "2005-06-06T00:00:00.000Z",
  "bio": "Reddit CEO"
}
```

Post rows carry the same fields as in our other Reddit Actors: `title`, `score`, `numComments`,
`url` (external link of a link post, omitted for text posts), `selfText` (body of a text post as
plain text), `flair`, `nsfw`, `spoiler` and `stickied`. A post published on the user's own
profile page shows its `subreddit` as `u_` plus the username, exactly as Reddit names it.
Comments arrive flat: a profile does not show where a comment sits in its thread, so `depth` is
0 and there is no `parentId`; `postId` tells which post it belongs to. The profile row is **free**:
it is not charged as a post or a comment and does not count toward `maxItems`.

### Input

| Field | Type | Description |
|---|---|---|
| `users` | string\[] | Usernames without `u/`, e.g. `["spez", "mvea"]`. Profile links work too. |
| `content` | string | `both` (default): posts and comments mixed, newest first; `posts`; or `comments`. |
| `maxItems` | integer | Max posts and comments per user (default 100, hard cap 1,000, about where Reddit's own feeds end). One request returns 25 items, so 1,000 items take about 40 requests. |
| `postedAfter` | string | Keep only posts submitted on or after this date (UTC). |
| `commentedAfter` | string | Keep only comments written on or after this date (UTC). |
| `includeNSFW` | boolean | Default `false`. Posts marked NSFW are skipped unless you opt in. Comments carry no NSFW flag in the history and are always included. |
| `onlyNew` | boolean | Default `false`. Skip items this Actor already gave you for the same users in earlier runs. See [Only new since last run](#only-new-since-last-run). |
| `proxyConfiguration` | object | Defaults to Apify **residential proxies** with no country pin, which is the supported configuration. |

The history is newest first, so a date lets the Actor stop early: with `content: "posts"` it
stops paging at the first item older than `postedAfter`, with `content: "comments"` at the first
item older than `commentedAfter`, and with both kinds at the first item older than the earlier of
the two dates when both are set. With both kinds and only one date set, the other kind has no
bound, so the Actor reads on to `maxItems` and filters by date after fetching.

Example:

```json
{
  "users": ["spez"],
  "content": "comments",
  "commentedAfter": "2026-06-01",
  "maxItems": 500
}
```

### How to use it

1. Click **Try for free** or **Start** on this page.
2. Enter one or more usernames.
3. Optionally choose posts or comments only, set a date and **Max items per user**.
4. Run it. Items land in the dataset as one row each, newest first, with the profile row first.
   Export them as JSON, CSV or Excel, or pull them over the API.

To follow accounts on a schedule, use Apify **Schedules** with `onlyNew: true`. Pricing has no
per-run start fee, so a scheduled check costs exactly the items it delivers. To call it from
code, use the [Apify API](https://docs.apify.com/api/v2) or an official client. AI agents can
call it through the **Apify MCP server**: the description and the input fields above are written
to be read by an agent.

### Only new since last run

Turn on **Only new since last run** (`onlyNew: true`) for monitoring. Here "new" means "not
delivered to you before for the same user", not "newer by time".

- Items you already got for a user are not written to the dataset and not charged.
- `maxItems` counts new items only. Paging stops at the first page where every item was already
  delivered to you, and never goes past 60 pages per user. A quiet account costs one request and
  no item charges. The profile row is saved on every run and is free.
- The list of delivered items lives in a named key-value store in your own Apify account, called
  `reddit-user-only-new-` plus a code made from your users (the run log shows the exact name).
  Each set of users with its content setting gets its own store, so adding a user or switching
  between posts and comments starts a fresh list for the set. Dates, NSFW and `maxItems` do not.
  The store does not expire. The latest 2,000 items per user are remembered. This Actor keeps
  its own list, separate from our other Reddit Actors.
- The list is saved once, at the end of the run. If a run is aborted or times out, the list stays
  as it was, so the next run delivers again what that run had delivered. For the same reason, do
  not let two runs with the same input overlap.
- To start over, delete that store in Apify Console under **Storage**, **Key-value stores**.

### Pricing

Pay-per-event, two events, nothing else:

| Event | Rate |
|---|---|
| `post-scraped` | **$2.00 per 1,000** ($0.002 each) |
| `comment-scraped` | **$2.00 per 1,000** ($0.002 each) |
| Profile row | **free** |
| Run start | **free, there is no start event** |

**What you get for $1:** 500 posts or comments. Platform usage (compute, proxy) is charged to
us, not to you, so the per-item price is the whole bill. A weekly check of five accounts that
finds 40 new items costs $0.08, with no per-run surcharge. Rates are as of the last README
update. The Store page stays authoritative.

### Limits (honest)

- **About 1,000 items per user is Reddit's ceiling, not ours.** Reddit serves at most about
  1,000 items for a profile feed, and no scraper can page past that. `maxItems` is capped there.
  For a longer record, run the Actor on a schedule with `onlyNew` and accumulate the history from
  now on.
- **Comments arrive flat.** A profile shows neither the thread position nor the parent of a
  comment, so comments have `depth: 0` and no `parentId`. For a whole thread use the Reddit
  Comments Scraper with the post's permalink.
- **The profile row has what the public profile shows.** Total, post and comment karma, the
  contributions counter, the registration date and the bio. Followers, trophies and anything
  behind login are not read. If Reddit serves the profile page without that card, the run goes
  on with the history alone and says so in the log.
- **Text comes as plain text.** Bodies keep their paragraphs, list items and code blocks, but not
  formatting such as bold, italics or link targets.
- **A user that does not exist, is suspended or has a private history gives an empty result.**
  Reddit serves such profiles as ordinary pages with no items, so that user ends with 0 rows and
  no charge, not with an error. Check the spelling if a user comes back empty.
- **Posts marked NSFW are skipped unless you opt in; comments are never flagged.** Reddit marks
  NSFW on posts only, so a comment under an NSFW post comes through like any other comment.
- **No login, no captcha solving.** The Actor reads only what Reddit serves to any logged-out
  visitor. It opens a session the way a browser does, completes Reddit's lightweight automated
  visitor check (a short script every visitor's browser runs), and then reads public pages with
  that session. If Reddit refuses a session, the Actor opens a new one from a fresh address. It
  fails honestly rather than fabricate data.
- If more than 5% of requests in a run fail, the run log says so loudly. A run in which every
  fetch failed is marked **failed**, not "succeeded with 0 items". A run whose filters
  legitimately match nothing (say, a strict date) still succeeds, with an empty dataset and an
  empty bill.

### Rate-limit etiquette (built in, with numbers)

- **At most 20 requests per minute**, with a hard 3-second spacing between requests. Reddit
  announces a quota of 225 requests per 10 minutes for these pages in its `x-ratelimit-*`
  headers. A 3-second spacing means at most 200 requests per 10 minutes, so the Actor stays
  inside that quota by design.
- One request carries 25 items; the profile card is one more request per user. A 100-item run is
  5 requests, about 20 seconds; 1,000 items are about 41 requests, roughly two minutes.
- On an HTTP `429` the Actor **waits 30 seconds**, opens a fresh session and retries. On any
  other transient refusal it backs off (3 s, then 6 s, then 9 s), rotates to a fresh proxy
  session and retries, at most 3 times.
- If five requests in a row fail after all retries, the run stops instead of grinding through
  the rest of the plan.

### FAQ

**Do I need a Reddit account or an API key?**
No. The Actor reads only publicly available data as a logged-out visitor, never logs in, and
does not use Reddit's developer API or anyone's credentials.

**How is this different from the Reddit Data Scraper?**
Same code, same output rows, narrower job. This Actor reads user histories only, lets you pick
posts or comments, stops early on a date, adds the free profile row, and is priced per item. The
Reddit Data Scraper also reads subreddit feeds, post pages with their first comments and search.

**Can I get a user's comments only?**
Yes: set `content: "comments"`. The Actor then reads the comments feed of the profile, so you do
not pay for posts you did not ask for.

**Does it use a browser?**
Not for the data. Pages are fetched over plain HTTP and read straight from the HTML Reddit
serves, with no rendering and no scrolling. A real Chrome is kept on standby only as a last
resort for opening a session, when no page gives one over plain HTTP.

**Can I get older items than the feed shows?**
Not from one run: Reddit's own profile feeds end at about 1,000 items. Run the Actor on a
schedule with `onlyNew` and you accumulate the history from now on.

**Where is my data stored?**
In your run's dataset on your Apify account, under your control. The Actor keeps no copy of
scraped data outside your run and sends nothing to any third party. With **Only new since last
run** on, it also keeps the ids of items it already gave you in a key-value store in your account
(see above), so you can delete them at any time.

### Legal

This is an **unofficial** scraper. It is not affiliated with, endorsed by, or connected to
Reddit, Inc. in any way, and it does not use Reddit's developer API. It reads only data that
Reddit serves publicly to any logged-out visitor: no login, no credentials, no captcha solving.
Website terms of service are a contractual matter between a website and its visitors, not
criminal law. You are responsible for ensuring that your use of the collected data complies with
the laws that apply to you and with Reddit's terms. Post and comment content belongs to its
authors.

### Personal data

This Actor collects data by username, and a username is personal data under laws such as the
GDPR even when it is a pseudonym. Reddit is a pseudonymous platform: the `author` and `name`
fields contain the public username a person chose to publish under, not their real identity.
This Actor collects no emails, no real names, no private messages, and performs no
deanonymization. It stores exactly what any visitor sees on a public page. Scraped data lives
only in your own Apify dataset and is not retained by us outside your run. You act as the
controller of the data you collect: it is your responsibility to have a legal basis for
processing and to honor data-subject requests, including deletion.

### Rate this Actor

If this Actor saved you time, a short rating or review on its Store page helps other people find
it. Missing a field, or did something break? Open the **Issues** tab on this page and tell us.

### Need a custom scraper?

We can build a custom version of this Actor, for example with extra fields, other filters or another output format, or a new Actor for a site we do not cover yet. It runs on Apify like this one. Email actorforge.hq+orders@gmail.com with the site, the data you need and how often you need it.

### Other Actors by ActorForge

- [Reddit Data Scraper](https://apify.com/actorforgehq/reddit-data-scraper): subreddit feeds,
  posts with their first comments, keyword search and user history in one Actor.
- [Reddit Subreddit Scraper](https://apify.com/actorforgehq/reddit-subreddit-scraper): the hot,
  new, top and rising posts of any subreddit, with date bounds and only-new mode.
- [Reddit Comments Scraper](https://apify.com/actorforgehq/reddit-comments-scraper): the whole
  comment thread of a post, with "more replies" branches and deep reply chains.
- [Reddit Search Scraper](https://apify.com/actorforgehq/reddit-search-scraper): posts and
  comments matching keywords, across Reddit or inside one subreddit, with only-new mode.
- [Lazada Reviews Scraper](https://apify.com/actorforgehq/lazada-reviews-scraper): product
  reviews, ratings and buyer media from all six Lazada marketplaces.
- [Wildberries Scraper](https://apify.com/actorforgehq/wildberries-scraper): products, prices
  and reviews from Wildberries as clean, schema-validated JSON.
- [Avito Real Estate Scraper](https://apify.com/actorforgehq/avito-real-estate-scraper): full
  property inventory from Avito with freshness stamps.

### Changelog

- **0.1.2** (22 October 2026): a username typed in a different letter case than Reddit shows it
  (Spez for spez) now gets its profile row too: the Actor follows Reddit's canonical profile
  address with one extra request.
- **0.1** (October 2026): first release. Posts, comments or both from a user's public history,
  newest first, date bounds with early stop, the free profile row with karma and registration
  date, only-new mode, $2 per 1,000 posts or comments, no start fee.

# Actor input Schema

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

Reddit usernames without u/, one per line, for example spez. Links to profiles like https://www.reddit.com/user/spez/ work too.

## `content` (type: `string`):

What to read from the history: posts and comments mixed, newest first (default), only posts, or only comments.

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

How many posts and comments to keep per user (default 100, hard cap 1,000, about where Reddit's own feeds end). One request returns 25 items, so 1,000 items take about 40 requests. The profile row does not count.

## `postedAfter` (type: `string`):

Keep only posts submitted on or after this date (UTC). The history is newest first, so with Posts only, or with both date fields set, the Actor stops paging at the first item older than the date.

## `commentedAfter` (type: `string`):

Keep only comments written on or after this date (UTC). The history is newest first, so with Comments only, or with both date fields set, the Actor stops paging at the first item older than the date.

## `includeNSFW` (type: `boolean`):

Off by default: posts marked NSFW are skipped unless you turn this on. Comments carry no NSFW flag in the history and are always included.

## `onlyNew` (type: `boolean`):

Skip posts and comments this Actor already gave you in earlier runs for the same users and content setting: they are not saved again and not charged. New means not delivered to you before, not newer by time. With this on, Max items counts new rows only, and paging stops at the first page where everything was already delivered. The list of delivered rows is kept in a key-value store in your own Apify account named reddit-user-only-new- plus a code made from your users (the run log shows the exact name). It does not expire. To start over, delete that store in Storage. The profile row is saved on every run.

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

Residential proxies are the default and the supported configuration. No country pin is needed. The run rotates proxy sessions and visitor cookies whenever Reddit refuses one.

## Actor input object example

```json
{
  "users": [
    "spez",
    "mvea"
  ],
  "content": "both",
  "maxItems": 100,
  "postedAfter": "2026-01-01",
  "commentedAfter": "2026-01-01",
  "includeNSFW": false,
  "onlyNew": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `history` (type: `string`):

One row per post or comment with subreddit, score, body text, permalink and UTC date; the profile row carries karma and the registration date.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("actorforgehq/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"] }

# Run the Actor and wait for it to finish
run = client.actor("actorforgehq/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"
  ]
}' |
apify call actorforgehq/reddit-user-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,actorforgehq/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/OQEoqG2aiezrQDKND/builds/lhj8kWyU78aQza4aW/openapi.json