# Reddit User & Profile Scraper (`scrapesmith/reddit-user-profile-scraper`) Actor

Scrape Reddit user profiles with karma, badges, bio, account age, and their full post or comment history. Bulk usernames supported — scrape hundreds of profiles in one run. Get post karma, comment karma, verification status, and mod badges. No login or cookies needed. Export JSON, CSV, Excel.

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

## Pricing

from $0.80 / 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.

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

## Reddit User Scraper — Profiles, Karma & Full Post History in Bulk

Want the most comprehensive **Reddit user scraper** on the market? This tool pulls complete public profile data — karma, bio, account age, verification status — together with a user's **full post and comment history**, for as many usernames as you want, in a single run. It's the fastest way to research any Reddit account without manually clicking through pages of history.

Built for researchers, OSINT investigators, brand teams, recruiters, and community managers who need structured **Reddit data** on specific users at scale.

### What It Does

Reddit User Scraper takes a list of Reddit usernames and returns a rich, structured dataset combining profile metadata with post or comment history. You choose whether to pull a user's submitted posts or their comments, and whether to include the profile summary as its own item. Every result — profile or post/comment — comes back as clean JSON ready to filter, analyze, or export.

This is the tool people use when they need to understand a Reddit account at a glance: who they are, how active they are, what communities they participate in, and what they've actually said.

### Features

- **Bulk username scraping** — analyze dozens of Reddit accounts in a single run
- **Full karma breakdown** — post karma, comment karma, and total karma
- **Complete profile metadata** — bio, account age, avatar, banner, verification, moderator, and Reddit Gold status
- **Choose posts or comments** — pull a user's submitted posts or their comment history
- **Rich post/comment data** — titles, body text, images, links, flair, scores, timestamps, and subreddit context for everything returned
- **Optional profile inclusion** — add or skip the profile summary item as needed
- **Resumable, checkpointed runs** — large multi-user jobs pick up exactly where they left off if interrupted
- **No Reddit login or API key required** — completely anonymous
- **Export instantly** — download as JSON, CSV, or Excel

### Input Parameters

| Field | Type | Description |
|---|---|---|
| `usernames` | Array | List of Reddit usernames to scrape (no `u/` prefix needed) |
| `section` | Select | Which history to collect: `submitted` (posts) or `comments` |
| `maxPosts` | Number | Maximum posts/comments to collect per username |
| `includeProfile` | Boolean | Include the user's profile metadata as an extra item |
| `maxItems` | Number | Hard cap on total items saved across all usernames |

### Output Fields

| Field | Description |
|---|---|
| `dataType` | `user`, `post`, or `comment` |
| `username` | The Reddit account being scraped |
| `url` | Profile URL or permalink to the post/comment |
| `userIcon` / `bannerUrl` | Profile avatar and banner image URLs (profile items) |
| `bio` | User's public bio/description (profile items) |
| `postKarma` / `commentKarma` / `totalKarma` | Karma breakdown (profile items) |
| `isGold` / `isMod` / `isVerified` / `isEmployee` | Account status flags (profile items) |
| `title` | Post title (post items) |
| `body` | Post or comment text |
| `communityName` | Subreddit the post/comment belongs to |
| `upVotes` | Score of the post or comment |
| `numberOfComments` | Comment count (post items) |
| `flair` | Post flair (post items) |
| `depth` | Comment nesting depth (comment items) |
| `over18` | NSFW flag (profile/post items) |
| `createdAt` | Creation timestamp (ISO format) |
| `scrapedAt` | Time the data was scraped |

### Sample Output

```json
{
  "dataType": "user",
  "username": "example_redditor",
  "url": "https://www.reddit.com/user/example_redditor",
  "bio": "Software engineer, cat person, occasional gardener.",
  "postKarma": 15230,
  "commentKarma": 48210,
  "totalKarma": 63440,
  "isGold": false,
  "isMod": true,
  "isVerified": false,
  "over18": false,
  "createdAt": "2018-03-14T09:00:00.000Z",
  "scrapedAt": "2026-07-06T09:18:00.000Z"
}
````

```json
{
  "dataType": "post",
  "username": "example_redditor",
  "title": "How I automated my entire home garden setup",
  "communityName": "r/gardening",
  "upVotes": 1284,
  "numberOfComments": 97,
  "flair": "DIY",
  "createdAt": "2026-06-20T18:30:00.000Z",
  "scrapedAt": "2026-07-06T09:18:00.000Z"
}
```

### Use Cases

1. **Influencer & power-user research** — evaluate karma, activity level, and posting history of key community voices
2. **OSINT & background research** — build a public activity profile for a specific Reddit account
3. **Competitor & community intelligence** — see what competitor employees or brand accounts post and where
4. **Recruiting & vetting** — review a candidate's public Reddit activity and community reputation
5. **Moderator activity tracking** — monitor how active and engaged subreddit moderators are
6. **Brand ambassador discovery** — identify high-karma users who already talk positively about your space
7. **Journalism & investigative reporting** — trace an account's full public post and comment history for a story
8. **Sentiment & behavior research** — build datasets of a user's language and engagement patterns over time
9. **Fraud & bot detection research** — analyze account age, karma, and posting patterns for suspicious behavior

### Pricing

Simple pay-per-result pricing: **$0.80 per 1,000 results**. No subscriptions or setup fees — you only pay for the profile, post, and comment items actually returned.

### Tips for Best Results

- Set `includeProfile` to true when you need karma and account-age context alongside activity history
- Use `section: comments` instead of `submitted` when you care more about a user's opinions than their original posts
- Keep `maxPosts` reasonable for very active accounts to control run size and cost
- Batch as many usernames as you need into a single run rather than running them one at a time
- Pair with the Reddit Search Scraper to first discover usernames worth investigating, then run them through this tool

### FAQ

**Do I need a Reddit account or API key to use this scraper?**
No. This Reddit user scraper is completely anonymous — no login, cookies, or API key required.

**Can I scrape both posts and comments for the same user?**
Each run collects one section (`submitted` or `comments`) per username. Run it twice with different `section` values if you need both.

**What if a username doesn't exist or has been deleted?**
The scraper skips invalid or deleted accounts gracefully and continues processing the rest of your list.

**Can I scrape many usernames in one run?**
Yes — add as many usernames as you like to the input list and they'll all be processed in the same job.

**What export formats are supported?**
JSON, CSV, and Excel — all downloadable instantly once your run finishes.

**Does this include suspended or private accounts?**
Only public, active Reddit accounts can be scraped, consistent with what's publicly visible on Reddit itself.

**How current is the karma and profile data?**
Every profile is scraped fresh at run time, so karma and account details reflect the latest publicly available data.

**Can I track the same users over time to watch how their activity changes?**
Yes, schedule recurring runs against the same username list to build a timeline of karma growth and posting activity.

### Why Teams Choose This Scraper

Manually reviewing a Reddit profile means endless scrolling and no way to export what you find. Reddit User Scraper turns that into a single structured dataset — karma, bio, and full activity history for as many accounts as you need, all in one run. It's the fastest way to go from "who is this account?" to a clean, exportable answer.

### Getting Started

Add the Reddit usernames you want to research, choose whether to pull posts or comments, decide if you want the profile summary included, and run. Your dataset populates as each account is processed.

### Support

Questions, feature requests, or issues? Reach out through the contact/support options on this actor's Apify page — we're continually improving this tool to remain the most comprehensive Reddit user scraper available.

# Actor input Schema

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

List of Reddit usernames to scrape (without the u/ prefix).

## `section` (type: `string`):

Which part of the user's history to collect.

## `maxPosts` (type: `integer`):

Maximum number of posts or comments to collect per username.

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

Include the user's profile info (karma, bio, account age, badges) as an extra item.

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

Hard cap on the total number of items saved to the dataset across all usernames.

## Actor input object example

```json
{
  "usernames": [
    "spez"
  ],
  "section": "submitted",
  "maxPosts": 10,
  "includeProfile": true
}
```

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit User & Profile Scraper",
        "description": "Scrape Reddit user profiles with karma, badges, bio, account age, and their full post or comment history. Bulk usernames supported — scrape hundreds of profiles in one run. Get post karma, comment karma, verification status, and mod badges. No login or cookies needed. Export JSON, CSV, Excel.",
        "version": "0.0",
        "x-build-id": "tjuSHbfIXV3Jkg6RF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~reddit-user-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-reddit-user-profile-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/scrapesmith~reddit-user-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-reddit-user-profile-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/scrapesmith~reddit-user-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-reddit-user-profile-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": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Reddit usernames",
                        "type": "array",
                        "description": "List of Reddit usernames to scrape (without the u/ prefix).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "section": {
                        "title": "Section to scrape",
                        "enum": [
                            "submitted",
                            "comments"
                        ],
                        "type": "string",
                        "description": "Which part of the user's history to collect.",
                        "default": "submitted"
                    },
                    "maxPosts": {
                        "title": "Max posts/comments per user",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of posts or comments to collect per username.",
                        "default": 10
                    },
                    "includeProfile": {
                        "title": "Include profile metadata",
                        "type": "boolean",
                        "description": "Include the user's profile info (karma, bio, account age, badges) as an extra item.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max total items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the total number of items saved to the dataset across all usernames."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
