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

Extract Reddit user profiles by username: post and comment karma, cake day, trophies and recent posts and comments.

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

## Pricing

from $10.00 / 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

<!-- actor-banner -->
[![Reddit User Profile, Posts & Comments Scraper](https://scrapers.lat/banners/reddit-user-scraper.png)](https://console.apify.com/actors/8CuawWPx3lV2qrXB2/input)
<!-- /actor-banner -->

## Reddit User Profile, Posts & Comments Scraper

> Look up any Reddit user by username and get their full profile plus their recent posts and comments: karma, cake day, trophies and activity.

![Apify](https://img.shields.io/badge/Platform-Apify-1CE1CE?logo=apify&logoColor=white)
![Coverage](https://img.shields.io/badge/Coverage-All%20Reddit-blue)
![Maintained](https://img.shields.io/badge/Maintained-Yes-brightgreen)
![Output](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-orange)

<table><tr>
<td align="center"><strong>17 fields</strong><br>per user</td>
<td align="center"><strong>Profile + activity</strong><br>posts & comments</td>
<td align="center"><strong>JSON / CSV / Excel</strong><br>output formats</td>
<td align="center"><strong>Updated</strong><br>2026-06-28</td>
</tr></table>

<br>

### What you get

One record per username, with the public profile and, when enabled, the user's recent posts and comments. Use it to research authors, vet influencers, study moderators, or build account-level datasets.

- **username**: the user's handle
- **profileUrl**: the canonical reddit.com link to the profile
- **postKarma**: karma earned from posts
- **commentKarma**: karma earned from comments
- **totalKarma**: post plus comment karma
- **accountCreated**: account creation timestamp
- **cakeDay**: the account's cake day (month and day)
- **isGold**: whether the account has Reddit Premium
- **isMod**: whether the account is a moderator
- **isVerified**: verified-email flag, when exposed
- **trophies**: array of trophy/award names on the profile
- **numPostsFetched**, **numCommentsFetched**: how many of each were collected
- **recentPosts\***: array of the user's recent posts (title, subreddit, score, numComments, permalink, createdAt)
- **recentComments\***: array of the user's recent comments (body, subreddit, score, permalink, createdAt, link title)
- **observedAt**: when this user was last seen by the scraper

*\*The activity arrays appear when Fetch Posts & Comments is enabled.*

### How it works

| Input | What it does |
|---|---|
| `usernames` | One or more Reddit usernames (with or without the u/ prefix). |
| `withDetails` | Fetch the user's recent posts and comments, not just the profile. |
| `maxPostsPerUser` | Cap how many recent posts to collect per user. |
| `maxCommentsPerUser` | Cap how many recent comments to collect per user. |
| `sort` | Order the activity feeds by new, hot, top or controversial. |

### Use cases

| Use case | Who it is for |
|---|---|
| Author and influencer research | Marketing and PR teams |
| Moderation and trust & safety review | Community managers |
| Account-level datasets | ML and NLP engineers |
| Lead and expert discovery | Founders and recruiters |
| Engagement and reputation analysis | Analysts |

### Frequently Asked Questions

**Which users can it scrape?**
Any public Reddit profile. Enter usernames with or without the `u/` prefix. Suspended, deleted or private profiles are returned as a record with an `error` field instead of being silently dropped.

**Does it return the user's posts and comments?**
Yes. With Fetch Posts & Comments enabled, each record includes `recentPosts` and `recentComments` arrays, capped by `maxPostsPerUser` and `maxCommentsPerUser`.

**Can I process many users in one run?**
Yes. Add every username to `usernames` and the actor returns one record per user.

**What ordering does the activity use?**
Choose `sort` (new, hot, top, controversial) to control how the recent posts and comments are ordered.

<!-- example-tasks -->
### Example use cases

Ready-to-run example tasks, each preconfigured for a common scenario. Open one and press run, or use it as a template:

- [Reddit User Activity History](https://apify.com/scrapers_lat/reddit-user-scraper/examples/reddit-user-activity-history): Pull a Reddit user complete recent activity with posts and comments, subreddits, scores and timestamps.
- [Reddit Bulk User Profiles](https://apify.com/scrapers_lat/reddit-user-scraper/examples/reddit-user-bulk-profiles): Collect multiple Reddit user profiles at once with karma, cake day, trophies and recent activity.
- [Reddit User Profile Lookup](https://apify.com/scrapers_lat/reddit-user-scraper/examples/reddit-user-profile-lookup): Look up Reddit user profiles by username with karma, cake day, trophies and recent posts and comments.

<!-- /example-tasks -->

<!-- related-actors -->
### Related scrapers

Need data from the same space? Here are other scrapers we build and maintain:

- [Reddit Posts Scraper](https://apify.com/scrapers_lat/reddit-posts-scraper): Extract Reddit posts with full text, scores, awards and gallery images from any subreddit, search query or post URL.
- [Reddit Comments Scraper](https://apify.com/scrapers_lat/reddit-comments-scraper): Extract Reddit comment threads with full text, scores, author and nesting depth from any post.
- [Reddit Posts & Comments Scraper](https://apify.com/scrapers_lat/reddit-scraper): Extract Reddit posts and comments from subreddits and search results using the public Reddit feeds.
- [X (Twitter) Profiles & Tweets Scraper](https://apify.com/scrapers_lat/x-twitter-scraper): Extract public X (Twitter) tweets by tweet ID: text, author, likes, replies, media and timestamps.
- [Instagram Profile & Posts Scraper](https://apify.com/scrapers_lat/instagram-scraper): Extract public Instagram profiles and recent posts by username without login.
- [YouTube Scraper](https://apify.com/scrapers_lat/youtube-scraper): Scrape YouTube videos and channels by search query, video URL or channel URL.

<!-- /related-actors -->

<!-- scrapers-lat-cta -->
### More scrapers at scrapers.lat

This actor is built and maintained by [scrapers.lat](https://scrapers.lat), where we publish scrapers for Latin American and US public platforms: real estate, jobs, e-commerce, company registries and government data. Browse the full catalog, see live sample output for each one, or ask us for a custom scraper at [scrapers.lat](https://scrapers.lat).

---

> This actor is an independent tool and has no affiliation with Reddit, Inc. It only accesses data that is publicly available on Reddit. Use it in accordance with Reddit's terms of service.
<!-- /scrapers-lat-cta -->

# Actor input Schema

## `usernames` (type: `array`):

Reddit usernames to research. Enter them with or without the u/ prefix, for example: spez, GovSchwarzenegger.
## `withDetails` (type: `boolean`):

When enabled, each profile is enriched with the user's recent posts and comments. Disable for a faster, profile-only run.
## `maxPostsPerUser` (type: `integer`):

Maximum number of recent posts to fetch per user. Used when Fetch Recent Posts and Comments is enabled.
## `maxCommentsPerUser` (type: `integer`):

Maximum number of recent comments to fetch per user. Used when Fetch Recent Posts and Comments is enabled.
## `sort` (type: `string`):

Sort order for the recent posts and comments feeds.
## `proxyConfiguration` (type: `object`):

Proxy settings. Reddit blocks datacenter ranges, so the Apify Residential proxy is required and set as the default.

## Actor input object example

```json
{
  "usernames": [
    "spez"
  ],
  "withDetails": true,
  "maxPostsPerUser": 25,
  "maxCommentsPerUser": 25,
  "sort": "new",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
````

# Actor output Schema

## `results` (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 = {
    "usernames": [
        "spez"
    ],
    "maxPostsPerUser": 25,
    "maxCommentsPerUser": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers_lat/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 = {
    "usernames": ["spez"],
    "maxPostsPerUser": 25,
    "maxCommentsPerUser": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers_lat/reddit-user-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 '{
  "usernames": [
    "spez"
  ],
  "maxPostsPerUser": 25,
  "maxCommentsPerUser": 25
}' |
apify call scrapers_lat/reddit-user-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit User Profile, Posts & Comments Scraper",
        "description": "Extract Reddit user profiles by username: post and comment karma, cake day, trophies and recent posts and comments.",
        "version": "0.1",
        "x-build-id": "suBi6ft4jDarNPsIO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers_lat~reddit-user-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers_lat-reddit-user-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapers_lat~reddit-user-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapers_lat-reddit-user-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapers_lat~reddit-user-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers_lat-reddit-user-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "proxyConfiguration"
                ],
                "properties": {
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "Reddit usernames to research. Enter them with or without the u/ prefix, for example: spez, GovSchwarzenegger.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "withDetails": {
                        "title": "Fetch Recent Posts and Comments",
                        "type": "boolean",
                        "description": "When enabled, each profile is enriched with the user's recent posts and comments. Disable for a faster, profile-only run.",
                        "default": true
                    },
                    "maxPostsPerUser": {
                        "title": "Max Posts Per User",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of recent posts to fetch per user. Used when Fetch Recent Posts and Comments is enabled."
                    },
                    "maxCommentsPerUser": {
                        "title": "Max Comments Per User",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of recent comments to fetch per user. Used when Fetch Recent Posts and Comments is enabled."
                    },
                    "sort": {
                        "title": "Activity Sort",
                        "enum": [
                            "new",
                            "hot",
                            "top",
                            "controversial"
                        ],
                        "type": "string",
                        "description": "Sort order for the recent posts and comments feeds.",
                        "default": "new"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Reddit blocks datacenter ranges, so the Apify Residential proxy is required and set as the default.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
