# Reddit Profile Scraper (`scraptivo/reddit-profile-scraper`) Actor

Collects Reddit user profiles from profile URLs or usernames. Returns overview, posts, comments, karma, and engagement fields.

- **URL**: https://apify.com/scraptivo/reddit-profile-scraper.md
- **Developed by:** [Scraptivo](https://apify.com/scraptivo) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.70 / 1,000 overviews

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

**Reddit Profile Scraper** collects public Reddit user profiles and turns them into structured data for influencer vetting, audience research, and community monitoring. Provide profile URLs or usernames, choose overview, posts, and/or comments, and export karma, post history, comment text, scores, and subreddits to JSON, CSV, Excel, or your preferred integration. Use it to review posting behavior, enrich CRM records, and automate recurring profile collection. Pricing starts at **$3.00 per 1,000 items**, with the same rate for overview, posts, and comments.

### What can you automate with Reddit Profile Scraper?

- **Build a full profile snapshot** — Collect about text, link karma, comment karma, verification, and moderator flags.
- **Export post history** — Pull titles, bodies, scores, comment counts, flairs, and media URLs for posts a user submitted.
- **Export comment activity** — Pull comment text, parent post title, subreddit, score, and permalink.
- **Vet creators before outreach** — Review authenticity signals and engagement before you contact an account.
- **Watch key voices** — Schedule the same usernames and keep a running history of new posts and comments.
- **Split results by feed** — Overview, posts, and comments land in separate datasets so each feed stays easy to analyze.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| Influencer and partnership teams | Checking posting history and engagement before outreach. |
| Community researchers | Tracking what target accounts post and discuss over time. |
| Competitive intelligence | Following competitor employees, founders, and brand accounts. |
| Lead-generation teams | Enriching CRM records with public Reddit activity. |

### What data can you collect from Reddit?

| Data group | Example fields | How it helps |
|---|---|---|
| Profile | Username, about text, `profileKarma`, `linkKarma`, `commentKarma`, verified, mod, employee, email-verified, icon | Qualify the account before outreach. |
| Content | Title, body, URL, permalink, domain, subreddit, flair | See what the user publishes and where. |
| Engagement | Score, ups, upvote ratio, comment count, awards, gilded | Measure how the community reacted. |
| Media and flags | Thumbnail, gallery URLs, NSFW, spoiler, stickied, locked, archived, video, gallery | Filter content types and sensitive posts. |
| Thread context | `linkId`, `parentId`, `isSubmitter` | Place comments back on the original post. |

Results are stored in **three datasets**: `overview` (about data plus mixed feed), `posts`, and `comments`. A `run-stats` record in the key-value store summarizes counts per section.

### How to use Reddit Profile Scraper

1. Open the [Reddit Profile Scraper](https://apify.com/scraptivo/reddit-profile-scraper) on Apify.
2. Enter Reddit profile URLs or usernames such as `Official_EuroDNS`.
3. Choose overview, posts, and/or comments, plus sort order, time filter, and an optional `maxItems` budget.
4. Run the Actor and wait for records to appear in the three datasets.
5. Export JSON, CSV, or Excel, or connect the datasets to your workflow.

```json
{
    "usernames": ["Official_EuroDNS"],
    "scrapeOverview": true,
    "scrapePosts": true,
    "scrapeComments": true,
    "sortBy": "new",
    "maxItems": 30,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

### Example workflow

#### Vet a creator before a sponsorship

1. Run one profile with `scrapeOverview`, `scrapePosts`, and `scrapeComments` enabled and `sortBy` = `top`.
2. Review karma, verification, and the highest-scoring posts in the last year (`timeFilter` = `year`).
3. Keep only accounts that match your niche using `subreddit` after the run.
4. Deduplicate later runs against `id` within each dataset.

### Automate and integrate your results

- **Schedules** — Run **weekly** for influencer research or **daily** when you watch a small set of high-priority accounts. Create one scheduled task per username if you want separate datasets.
- **Webhooks** — Push completed overview, posts, and comments datasets into Sheets, a CRM, or Slack.
- **Exports and API** — Download from the Apify Console or start a run from the API:

```shell
curl "https://api.apify.com/v2/acts/scraptivo~reddit-profile-scraper/runs?token=YOUR-APIFY-TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "usernames": ["Official_EuroDNS"],
    "scrapeOverview": true,
    "scrapePosts": true,
    "scrapeComments": true,
    "sortBy": "new",
    "maxItems": 30,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
  }'
```

- **Deduplication** — The Actor appends results on every run. Use the record `id` as the stable key. When several sections are enabled, `maxItems` is fair-shared across overview, posts, and comments.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---|---:|---|---|
| `startUrls` | Array of URLs | No | — | Reddit profile URLs such as `https://www.reddit.com/user/spez/`. |
| `usernames` | Array of strings | No | — | Reddit usernames. Profile URLs are built automatically. |
| `scrapeOverview` | Boolean | No | `true` | Collect the overview feed plus profile about data. Charged as `overview`. |
| `scrapePosts` | Boolean | No | `true` | Collect posts submitted by the user. Charged as `posts`. |
| `scrapeComments` | Boolean | No | `true` | Collect comments written by the user. Charged as `comments`. |
| `sortBy` | String | No | `new` | `hot`, `new`, `top`, or `controversial`. |
| `timeFilter` | String | No | `all` | Time window for `top` / `controversial`: `hour`, `day`, `week`, `month`, `year`, `all`. |
| `maxItems` | Integer | No | `0` | Max records across all profiles (`0` = unlimited). Fair-shared across enabled sections. |
| `proxyConfiguration` | Proxy object | No | Apify proxy, RESIDENTIAL | Residential proxies are strongly recommended. |

Provide `startUrls` or `usernames` (or both). At least one profile source is required for a useful run.

#### How is maxItems shared?

When overview, posts, and comments are all enabled, the Actor splits the `maxItems` budget across those feeds so one section cannot consume the entire run.

### Output example

A profile record from the overview dataset looks like this:

```json
{
    "id": "fwzprbtcf",
    "fullname": "Official_EuroDNS",
    "username": "Official_EuroDNS",
    "section": "overview",
    "itemType": "profile",
    "title": "Official_EuroDNS",
    "body": "We’ve been helping people and brands manage sites and domain names since before Myspace went live.",
    "author": "Official_EuroDNS",
    "subredditNamePrefixed": "u/Official_EuroDNS",
    "createdAt": "2023-07-21T07:51:03+00:00",
    "url": "https://www.reddit.com/user/Official_EuroDNS/",
    "profileKarma": 38,
    "linkKarma": 39,
    "commentKarma": -1,
    "isMod": true,
    "verified": true,
    "hasVerifiedEmail": true
}
```

### How much does it cost to scrape Reddit profiles?

The Actor uses pay-per-event pricing plus a small Actor-start event ($0.00005 per start, scaled by memory):

- **$3.00 / 1,000 overview items** — charged for overview/about records.
- **$3.00 / 1,000 posts** — charged for each post record.
- **$3.00 / 1,000 comments** — charged for each comment record.

A run that returns 200 overview items, 200 posts, and 200 comments costs **$1.80** at the Free-plan rate. Volume discounts on Apify paid plans reduce the per-1,000 rate (for example **$2.70 per 1,000** at the Gold plan). Compute units consumed are deducted from your Apify plan. Disable sections you do not need to avoid those events.

### Reliability and responsible use

- **Proxy requirement** — Residential proxies are strongly recommended. Datacenter IPs are often blocked by Reddit. The default input uses the Apify RESIDENTIAL group.
- **Public profiles** — The Actor collects publicly visible profile, post, and comment data from the usernames or URLs you provide.
- **Conditional fields** — Karma, verification, and media fields are only present when Reddit exposes them on that profile or item.
- **Responsible use** — Only use the data in ways that comply with Reddit's terms and applicable law.

### Frequently asked questions

#### Can I scrape a Reddit profile from a username only?

Yes. Put the username in `usernames` (for example `spez`) and the Actor builds the profile URL. You can also paste full `/user/` or `/u/` URLs in `startUrls`.

#### Can I schedule Reddit Profile Scraper to run automatically?

Yes. Use the **Scheduler** tab in Apify Console. Weekly suits influencer research; daily suits a short watchlist of accounts.

#### What counts as one result?

Each overview, post, or comment record is a separate billed event at **$3.00 per 1,000**. Turning off a section means that event is not charged.

#### Why are some fields empty?

Private or restricted profiles return less data. Media and flag fields are also empty when the post or comment has no thumbnail, gallery, or special status.

#### How do I avoid duplicate records?

The Actor does not deduplicate across runs. Use `id` within each dataset. Set `maxItems` to keep scheduled runs bounded.

#### Do I need a proxy?

Residential proxies are strongly recommended. If a run returns few or no items, confirm the proxy group is RESIDENTIAL.

### Related Scraptivo automations

- [Reddit Scraper](https://apify.com/scraptivo/reddit-scraper) — posts and community data from Reddit.
- [Twitter/X Profile Scraper](https://apify.com/scraptivo/twitter-x-profile-scraper) — public profile data from X.
- [YouTube Channel Scraper](https://apify.com/scraptivo/youtube-channel-scraper) — channel and video metadata from YouTube.
- [TikTok Profile Scraper](https://apify.com/scraptivo/tiktok-profile-scraper) — profile data from TikTok accounts.

### Support and custom workflows

Need a different field, source, or delivery workflow? Contact Scraptivo at scraptivo@gmail.com. Include the Actor name, sample URL, required fields, and expected volume so we can assess the request.

# Actor input Schema

## `startUrls` (type: `array`):

Reddit profile URLs to scrape, e.g. https://www.reddit.com/user/spez/ or https://www.reddit.com/u/spez/. Leave empty if using usernames instead.

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

Reddit usernames to scrape (e.g. spez, Official\_EuroDNS). Alternative to startUrls — profile URLs are built automatically.

## `scrapeOverview` (type: `boolean`):

Scrape the profile overview feed (mixed posts and comments) plus profile about data. Charged as the overview event.

## `scrapePosts` (type: `boolean`):

Scrape posts submitted by the user. Charged as the posts event.

## `scrapeComments` (type: `boolean`):

Scrape comments written by the user. Charged as the comments event.

## `sortBy` (type: `string`):

How to sort items in each profile feed

## `timeFilter` (type: `string`):

Time filter for top/controversial sorting

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

Maximum number of records to scrape across all profiles (0 = unlimited). When multiple sections are enabled, this budget is fair-shared across overview, posts, and comments so one feed cannot starve the others.

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

Apify proxy for the browser session. Residential proxies are strongly recommended — datacenter IPs are often blocked by Reddit.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.reddit.com/user/Official_EuroDNS/"
    }
  ],
  "usernames": [
    "Official_EuroDNS"
  ],
  "scrapeOverview": true,
  "scrapePosts": true,
  "scrapeComments": true,
  "sortBy": "new",
  "timeFilter": "all",
  "maxItems": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Profile about data and overview feed items

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

Alias of the overview dataset for default export / API compatibility

## `posts` (type: `string`):

Posts submitted by scraped profiles

## `comments` (type: `string`):

Comments written by scraped profiles

## `kvsRecords` (type: `string`):

Key-value store records produced by the Actor

# 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 = {
    "startUrls": [
        {
            "url": "https://www.reddit.com/user/Official_EuroDNS/"
        }
    ],
    "usernames": [
        "Official_EuroDNS"
    ],
    "maxItems": 30,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraptivo/reddit-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 = {
    "startUrls": [{ "url": "https://www.reddit.com/user/Official_EuroDNS/" }],
    "usernames": ["Official_EuroDNS"],
    "maxItems": 30,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scraptivo/reddit-profile-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 '{
  "startUrls": [
    {
      "url": "https://www.reddit.com/user/Official_EuroDNS/"
    }
  ],
  "usernames": [
    "Official_EuroDNS"
  ],
  "maxItems": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraptivo/reddit-profile-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraptivo/reddit-profile-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/33Z0aUA2QncAIIB7n/builds/8vQqnjSige8RCeDaf/openapi.json