# Reddit Profile Scraper | $4/1K | No Login (Real-Time) (`apivault_labs/reddit-scraper`) Actor

Real-time Reddit user profile scraper. Live data, not stale database. Get username, bio, followers, karma, website, trophies, active subreddits. Choose fields to extract. Batch up to 20 concurrent. No login, no API key. JSON output for community research.

- **URL**: https://apify.com/apivault\_labs/reddit-scraper.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** Social media, Lead generation, Jobs
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Profile Scraper | $4/1K | No Login (Real-Time)

Real-time Reddit user profile scraper. Live data from Reddit — not a stale database. No login, no API key, no browser.

### Why This Actor?

| | This Actor | Reddit API | Database Scrapers |
|---|---|---|---|
| Data freshness | Real-time | Real-time | Cached, old |
| Auth required | No | Yes (OAuth) | No |
| Rate limit | High | 60 req/min | N/A |
| Karma breakdown | Yes | Yes | Rarely |
| Trophies & badges | Yes | Limited | No |
| Active subreddits | Yes | No | No |
| Field selection | You choose | Fixed | Fixed |
| Price per 1K | $4 | Free (limited) | $5-15 |

### Key Feature: Rich Metadata

Reddit profiles contain unique data: karma breakdown, cake day, trophies, active subreddits, moderator status. This Actor extracts it all in the "Other Metadata" field.

### Configurable Fields

| Field | Default | Description |
|-------|---------|-------------|
| Username | ✅ | Reddit username (u/name) |
| Display Name | ✅ | Display name (if set) |
| Bio | ✅ | Profile bio |
| Followers | ✅ | Follower count |
| Following | ✅ | Following count |
| Post Count | ✅ | Number of posts / karma |
| Profile URL | ✅ | Reddit URL |
| Website | ✅ | External website |
| Category | ✅ | User category |
| Other Metadata | ✅ | Karma, cake day, trophies, subreddits |

### Input

```json
{
  "profileUrls": [
    "https://www.reddit.com/user/GovSchwarzenegger/",
    "https://www.reddit.com/user/thisisbillgates/"
  ],
  "extractMetadata": true,
  "maxConcurrency": 5
}
````

### Output

```json
{
  "success": true,
  "inputUrl": "https://www.reddit.com/user/GovSchwarzenegger/",
  "username": "GovSchwarzenegger",
  "displayName": "Arnold Schwarzenegger",
  "bio": "My new daily health and fitness newsletter...",
  "followerCount": 1701748,
  "postCount": 669083,
  "profileUrl": "https://www.reddit.com/user/GovSchwarzenegger/",
  "website": "https://schwarzenegger.ck.page/31e92076eb",
  "category": "Public Figure / Fitness",
  "otherMetadata": "Reddit Premium; 13 years on Reddit; 1032665 comment karma; Active in r/bodybuilding"
}
```

Output contains only the fields you enabled.

### Pricing

- **$0.004 per profile** ($4 per 1,000 profiles)
- Pay only for results — no subscriptions
- Free Apify credits cover ~1,250 profiles/month

### Performance

- 14-25 seconds per profile (real-time scraping)
- Up to 20 concurrent requests
- Works on all public Reddit user profiles

### Use Cases

- Community research — find active users in specific subreddits
- Influencer discovery — identify high-karma users
- Brand monitoring — track brand mentions by user activity
- Competitor analysis — analyze Reddit presence
- Academic research — study user behavior patterns

### Notes

- Only public profile data is extracted
- Suspended or deleted accounts return no data
- "Post Count" may reflect total karma rather than exact post count
- "Other Metadata" includes karma breakdown, cake day, trophies, and active subreddits

### Disclaimer

This Actor extracts only publicly available data. Ensure your use complies with applicable laws and Reddit's terms of service.

# Actor input Schema

## `profileUrls` (type: `array`):

List of Reddit user profile URLs to scrape

## `extractUsername` (type: `boolean`):

Extract Reddit username

## `extractFullName` (type: `boolean`):

Extract display name (if set)

## `extractBio` (type: `boolean`):

Extract bio text

## `extractFollowers` (type: `boolean`):

Extract follower count

## `extractFollowing` (type: `boolean`):

Extract following count

## `extractPosts` (type: `boolean`):

Extract post count or karma

## `extractProfileUrl` (type: `boolean`):

Include profile URL in output

## `extractWebsite` (type: `boolean`):

Extract website URL

## `extractCategory` (type: `boolean`):

Extract user category

## `extractMetadata` (type: `boolean`):

Extract karma breakdown, cake day, trophies, active subreddits

## `maxConcurrency` (type: `integer`):

Number of parallel requests (recommended: 5-10)

## `timeout` (type: `integer`):

Max wait time per profile

## Actor input object example

```json
{
  "profileUrls": [
    "https://www.reddit.com/user/GovSchwarzenegger/"
  ],
  "extractUsername": true,
  "extractFullName": true,
  "extractBio": true,
  "extractFollowers": true,
  "extractFollowing": true,
  "extractPosts": true,
  "extractProfileUrl": true,
  "extractWebsite": true,
  "extractCategory": true,
  "extractMetadata": true,
  "maxConcurrency": 5,
  "timeout": 90
}
```

# 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 = {
    "profileUrls": [
        "https://www.reddit.com/user/GovSchwarzenegger/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/reddit-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 = { "profileUrls": ["https://www.reddit.com/user/GovSchwarzenegger/"] }

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/reddit-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 '{
  "profileUrls": [
    "https://www.reddit.com/user/GovSchwarzenegger/"
  ]
}' |
apify call apivault_labs/reddit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Profile Scraper | $4/1K | No Login (Real-Time)",
        "description": "Real-time Reddit user profile scraper. Live data, not stale database. Get username, bio, followers, karma, website, trophies, active subreddits. Choose fields to extract. Batch up to 20 concurrent. No login, no API key. JSON output for community research.",
        "version": "0.0",
        "x-build-id": "UsG3FuO8B1o8x43VP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apivault_labs~reddit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apivault_labs-reddit-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/apivault_labs~reddit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-apivault_labs-reddit-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/apivault_labs~reddit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-apivault_labs-reddit-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": [
                    "profileUrls"
                ],
                "properties": {
                    "profileUrls": {
                        "title": "Reddit User Profile URLs",
                        "type": "array",
                        "description": "List of Reddit user profile URLs to scrape",
                        "items": {
                            "type": "string"
                        }
                    },
                    "extractUsername": {
                        "title": "Username",
                        "type": "boolean",
                        "description": "Extract Reddit username",
                        "default": true
                    },
                    "extractFullName": {
                        "title": "Display Name",
                        "type": "boolean",
                        "description": "Extract display name (if set)",
                        "default": true
                    },
                    "extractBio": {
                        "title": "Bio / Description",
                        "type": "boolean",
                        "description": "Extract bio text",
                        "default": true
                    },
                    "extractFollowers": {
                        "title": "Follower Count",
                        "type": "boolean",
                        "description": "Extract follower count",
                        "default": true
                    },
                    "extractFollowing": {
                        "title": "Following Count",
                        "type": "boolean",
                        "description": "Extract following count",
                        "default": true
                    },
                    "extractPosts": {
                        "title": "Post / Karma Count",
                        "type": "boolean",
                        "description": "Extract post count or karma",
                        "default": true
                    },
                    "extractProfileUrl": {
                        "title": "Profile URL",
                        "type": "boolean",
                        "description": "Include profile URL in output",
                        "default": true
                    },
                    "extractWebsite": {
                        "title": "Website",
                        "type": "boolean",
                        "description": "Extract website URL",
                        "default": true
                    },
                    "extractCategory": {
                        "title": "Category",
                        "type": "boolean",
                        "description": "Extract user category",
                        "default": true
                    },
                    "extractMetadata": {
                        "title": "Other Metadata (karma, cake day, trophies)",
                        "type": "boolean",
                        "description": "Extract karma breakdown, cake day, trophies, active subreddits",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of parallel requests (recommended: 5-10)",
                        "default": 5
                    },
                    "timeout": {
                        "title": "Timeout per profile (seconds)",
                        "minimum": 30,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Max wait time per profile",
                        "default": 90
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
