# Reddit Scraper (`scrapium/reddit-scraper`) Actor

🔎 Reddit Scraper (reddit-scraper) extracts posts, comments & metadata from subreddits, users and threads — keywords, timestamps, scores & links. 📤 Export JSON/CSV. 🚀 Ideal for market research, social listening, academic studies & content discovery.

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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 Scraper

Reddit Scraper is an Apify actor that extracts Reddit posts, comment threads, subreddit listings/metadata, and user profiles using Reddit’s public JSON API — no login required. It solves the pain of manually collecting Reddit data by automating discovery and extraction at scale. As a Reddit API scraper and Reddit web scraper built in Python, it’s ideal for marketers, developers, data analysts, and researchers who need to scrape Reddit posts, scrape subreddit posts, or scrape Reddit comments for social listening, market research, and academic studies. Run it once or schedule it to power always-on Reddit data extraction pipelines. 🚀

### What data / output can you get?

Here are the key fields the actor returns in the dataset. Values below reflect real field names and structures used by the actor.

| Data type | Description | Example value |
| --- | --- | --- |
| metadata.timestamp | ISO UTC timestamp of the run summary item | 2026-04-12T13:07:24Z |
| metadata.config.maxItemsToSave | Global limit applied to certain queries | 10 |
| data.search.<query>.total | Count of posts matching a search term | 25 |
| data.search.<query>.posts[].title | Post title from search results | “Best Python tips for data viz” |
| data.subreddit.<name>.posts[].is_self | Whether a subreddit listing item is a self post | true |
| data.posts.<postId>.post.upvote_ratio | Post upvote ratio | 0.92 |
| data.posts.<postId>.comments[].replies | Nested replies array for each comment | [ { … }, … ] |
| data.users.<username>.profile.total_karma | Sum of link and comment karma | 15342 |
| data.users.<username>.submitted[].permalink | Link to a user’s submitted post | https://reddit.com/r/python/comments/abc123/... |
| data.users.<username>.comments[].body | Truncated comment body (200 chars) | “I’d recommend using aiohttp with backoff…” |
| data.users.<username>.overview.total_items | Count of items in overview (if fetched) | 40 |
| data.subreddit_info.popular[].subscribers | Subscriber count for popular subreddits | 845321 |

Notes:
- The actor pushes streaming items for each section (e.g., per search term, per subreddit, per post, per user, subreddit info batches), and finally pushes a single aggregated “summary” object with metadata and a nested data object. You can export results to JSON or CSV directly from the Apify dataset.

### Key features

- 🌐 No-login Reddit data extraction
  - Uses Reddit’s public JSON API to collect public data; perfect for a Reddit scraper Python workflow without cookies or auth.
- 🔗 Bulk Start URLs (posts, subreddits, users)
  - Paste multiple Reddit URLs to scrape Reddit posts, scrape subreddit posts by sort, and collect user profiles with submitted posts and comments.
- 🔎 Flexible search with sort & time filters
  - Run keyword searches across Reddit or within a specific community, with sort (relevance/new/hot/top/comments) and time filter (hour/day/week/month/year/all).
- 🧵 Post + full comment tree (depth control)
  - Capture a post and its nested comments, with configurable max depth to tailor “Reddit comment extractor” needs.
- 👤 User profiles, submissions, and comments
  - Fetch profile karma and history with per-user item limits; optionally add a concise overview summary.
- 🏘️ Subreddit listings & metadata
  - Collect hot/new/top/rising/controversial listings and enrich with subreddit_info: popular, new, and specific communities’ details.
- 🧰 Limits & performance controls
  - Cap items per run, per page, and comments per page; set delays between requests; constrain comment tree depth for predictable output sizes.
- 🔄 Smart proxy fallback for reliability
  - Starts direct; on blocks automatically falls back to datacenter, then residential proxies (with retries) to keep your Reddit crawler running smoothly.
- 💾 Developer friendly outputs
  - Clean JSON structures ready for pipelines, dashboards, or ML — ideal for Reddit data extraction and Reddit sentiment analysis scraper use cases.
- 📤 Easy export
  - Export datasets to JSON/CSV via the Apify platform for downstream analytics and automation.

### How to use Reddit Scraper - step by step

1. Sign in to Apify Console.
2. Open the Reddit Scraper actor (reddit-scraper) from your Actors.
3. Add input:
   - Start URLs: paste Reddit post URLs (/comments/…), subreddit URLs (/r/…), or user URLs (/user/…).
   - Or provide Search Term(s) and enable “Ignore start URLs” to run search-only jobs.
4. Configure key settings:
   - Sort and time filters for search.
   - Limits: maximum items to save, posts/comments per page, max comment depth, and request delay.
   - Toggles: Enable/disable subreddit posts, post+comments, user scraper, subreddit info.
   - Proxy settings: leave off to start direct; the actor auto-falls back to datacenter → residential if blocked.
5. Start the run.
   - Watch progress in the Log. The actor streams items to the dataset as it completes each section.
6. Review results in the Dataset.
   - You’ll see per-section items (e.g., type: “search”, “subreddit”, “post”, “user”, “subreddit_info”) and a final aggregated object with metadata and nested “data”.
7. Export your data.
   - Download JSON/CSV from the Dataset tab or use the Apify API in your Reddit API scraper pipeline.

Pro tip: Schedule recurring runs for ongoing monitoring, or connect the Apify Dataset API to your Reddit scraper Python workflows and data warehouses.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research & trend tracking | Analyze topics, upvotes, and comment volume to quantify interest and sentiment in your niche. |
| Social listening for brands | Monitor subreddit posts and comment threads to surface complaints, ideas, and feature requests. |
| Academic & policy research | Collect reproducible datasets of posts and comments for studies, leveraging a structured Reddit data extractor. |
| Competitive intelligence | Track competitor communities and product feedback across relevant subreddits. |
| Content strategy & SEO | Discover high-performing threads and questions to inform content calendars and keyword targeting. |
| Customer support insights | Harvest user pain points from comments for faster triage and product improvements. |
| Data engineering pipelines | Build automated Reddit crawler pipelines using Apify’s API and export JSON/CSV into your analytics stack. |

### Why choose Reddit Scraper?

This production-ready Reddit scraping tool emphasizes precision, automation, and reliability.

- ✅ Accurate JSON from public endpoints: Clean, structured fields straight from Reddit’s public JSON API.
- 🌍 Scalable and flexible: Bulk Start URLs and keyword searches with configurable limits and depths.
- 🧑‍💻 Developer-ready: Structured outputs fit data pipelines; perfect for Reddit scraper Python integration and API-driven workflows.
- 🔐 Safe by design: No login required; collects public data only.
- 🔄 Resilient infrastructure: Automatic proxy fallback (direct → datacenter → residential) keeps runs stable under rate limiting.
- 💸 Cost-effective alternative: Avoid brittle browser extensions and manual copy-paste with a robust, server-side Reddit web scraper.

Bottom line: It’s a reliable Reddit post scraper and Reddit data extraction tool that balances control, scale, and clean outputs.

### Is it legal / ethical to use Reddit Scraper?

Yes — when used responsibly. This actor accesses publicly available Reddit data without authentication and does not target private content. You should:
- Scrape only public data.
- Respect Reddit’s terms and rate limits.
- Observe applicable data protection laws (e.g., GDPR, CCPA) and internal policies.
- Avoid misuse (e.g., unsolicited outreach/spam).
Always verify compliance with your legal team for your specific use case.

### Input parameters & output format

#### Example JSON input
```json
{
  "startUrls": [
    "https://www.reddit.com/r/python/",
    "https://www.reddit.com/r/dataisbeautiful/",
    "https://www.reddit.com/r/Python/comments/abc123/example_post_title/",
    "https://www.reddit.com/user/spez/"
  ],
  "searchTerms": ["data visualization", "asyncio"],
  "searchCommunity": "python",
  "ignoreStartUrls": false,
  "sortSearch": "new",
  "timeFilter": "all",
  "enableSearch": true,
  "enableSubreddit": true,
  "sortSubreddit": "hot",
  "enablePost": true,
  "enableUser": true,
  "enableSubredditInfo": true,
  "skipComments": false,
  "skipUserPosts": false,
  "skipCommunity": false,
  "maxItemsToSave": 10,
  "limitPostsPerPage": 10,
  "limitCommentsPerPage": 10,
  "limitCommunityPages": 2,
  "limitUserPages": 2,
  "pageScrollTimeout": 40,
  "maxCommentDepth": 5,
  "maxItemsPerUser": 20,
  "fetchUserProfile": true,
  "fetchUserSubmitted": true,
  "fetchUserComments": true,
  "fetchUserOverview": false,
  "fetchPopularSubreddits": false,
  "fetchNewSubreddits": false,
  "maxSubredditsInfo": 25,
  "requestDelaySeconds": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### All input fields

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| startUrls | array | Yes | — | One or more Reddit URLs to scrape. Supports bulk. Accepts post (/comments/…), subreddit (/r/…), and user (/user/…) URLs. |
| skipComments | boolean | No | false | Do not fetch comments for any post URLs; only post-level data is collected. |
| skipUserPosts | boolean | No | false | Ignore user profile URLs; no user data is scraped. |
| skipCommunity | boolean | No | false | Do not fetch subreddit/community metadata. |
| searchTerms | array | No | — | One or more search phrases. Used in search mode (no Start URLs or Ignore start URLs on). |
| searchCommunity | string | No | — | Optional subreddit name (without r/). Restricts search to a specific community. |
| ignoreStartUrls | boolean | No | false | Skip all Start URLs and run search-only mode (requires at least one Search Term). |
| searchForPosts | boolean | No | true | Include posts in search results. |
| searchForComments | boolean | No | false | Reserved for future use: include comments in the search scope. |
| searchForCommunities | boolean | No | false | Reserved for future use: include communities in the search scope. |
| searchForUsers | boolean | No | false | Reserved for future use: include users in the search scope. |
| sortSearch | string | No | new | Order search results: relevance, new, hot, top, comments. |
| timeFilter | string | No | all | Search time window: hour, day, week, month, year, all. |
| filterByDate | string | No | — | Optional absolute or relative filter for posts (e.g., 2024-01-15 or “2 weeks”). |
| enableSearch | boolean | No | true | Run Reddit search when in search mode and terms are provided. |
| enableSubreddit | boolean | No | true | Process subreddit URLs to fetch listings by sort. |
| sortSubreddit | string | No | hot | Subreddit listing sort: hot, new, top, rising, controversial. |
| enablePost | boolean | No | true | Process post URLs to fetch full post and comment tree (unless Skip comments is on). |
| enableUser | boolean | No | true | Process user URLs to fetch profile, submitted posts, and comments. |
| enableSubredditInfo | boolean | No | true | Fetch subreddit metadata for popular/new/specific communities. |
| maxItemsToSave | integer | No | 10 | Global maximum number of items to collect across sources. |
| limitPostsPerPage | integer | No | 10 | Maximum posts to fetch from a single subreddit listing page. |
| postDateLimit | string | No | — | Only include posts created on or after this date (YYYY-MM-DD). |
| limitCommentsPerPage | integer | No | 10 | Maximum number of comments retrieved per post. |
| limitCommunityPages | integer | No | 2 | Maximum listing pages to paginate for each subreddit URL. |
| limitUserPages | integer | No | 2 | Maximum pages to fetch for user submissions and comments. |
| pageScrollTimeout | integer | No | 40 | Timeout in seconds for page/scroll operations. |
| maxCommentDepth | integer | No | 5 | Maximum nested comment depth to parse (1–20). |
| maxItemsPerUser | integer | No | 20 | Max submitted posts and comments per user profile. |
| fetchUserProfile | boolean | No | true | Fetch user profile details (name, karma, created). |
| fetchUserSubmitted | boolean | No | true | Fetch posts submitted by each user. |
| fetchUserComments | boolean | No | true | Fetch comments made by each user. |
| fetchUserOverview | boolean | No | false | Fetch combined user overview and add summary counts. |
| fetchPopularSubreddits | boolean | No | false | Fetch Reddit’s popular subreddit list. |
| fetchNewSubreddits | boolean | No | false | Fetch recently created subreddits list. |
| maxSubredditsInfo | integer | No | 25 | Maximum number of subreddits for popular/new lists. |
| requestDelaySeconds | integer | No | 1 | Delay between HTTP requests to Reddit in seconds. |
| proxyConfiguration | object | No | { "useApifyProxy": false } | Configure Apify Proxy. Actor auto-falls back to datacenter → residential on blocks if not set. |

#### Output format

During the run, the actor streams items to the dataset by section and then pushes a final aggregated object. Examples:

- Search item

```json
{
  "type": "search",
  "query": "data visualization",
  "community": "python",
  "total": 3,
  "posts": [
    {
      "title": "Matplotlib vs Plotly for dashboards",
      "subreddit": "Python",
      "author": "chart_ninja",
      "score": 128,
      "num_comments": 42,
      "url": "https://example.com/post-url",
      "permalink": "https://reddit.com/r/Python/comments/abc123/...",
      "created_utc": 1712875200
    }
  ]
}
```

- Subreddit listing item

```json
{
  "type": "subreddit",
  "source": "python",
  "total": 2,
  "posts": [
    {
      "title": "Asyncio tips for web scraping",
      "author": "py_async",
      "score": 210,
      "num_comments": 33,
      "url": "https://example.com/post-url",
      "permalink": "https://reddit.com/r/Python/comments/def456/...",
      "created_utc": 1712878800,
      "is_self": true,
      "selftext": "Here are some tips..."
    }
  ]
}
```

- Post with comments item

```json
{
  "type": "post",
  "postId": "abc123",
  "post": {
    "id": "abc123",
    "title": "Show HN: My Python scraper",
    "author": "dev_user",
    "subreddit": "Python",
    "score": 512,
    "upvote_ratio": 0.95,
    "num_comments": 87,
    "created_utc": 1712871000,
    "url": "https://example.com/post-url",
    "permalink": "https://reddit.com/r/Python/comments/abc123/...",
    "is_self": true,
    "selftext": "I built a scraper...",
    "link_flair_text": "Project",
    "over_18": false
  },
  "comments": [
    {
      "id": "c1",
      "author": "commenter1",
      "body": "Nice work!",
      "score": 15,
      "created_utc": 1712874600,
      "depth": 0,
      "replies": []
    }
  ],
  "total_comments_parsed": 1
}
```

- User item

```json
{
  "type": "user",
  "username": "spez",
  "profile": {
    "name": "spez",
    "link_karma": 1000,
    "comment_karma": 500,
    "total_karma": 1500,
    "created_utc": 1133212800
  },
  "submitted": [
    {
      "title": "Announcement",
      "subreddit": "announcements",
      "score": 999,
      "created_utc": 1712870000,
      "permalink": "https://reddit.com/r/announcements/comments/ghi789/..."
    }
  ],
  "comments": [
    {
      "body": "Thanks for the feedback.",
      "subreddit": "redditdev",
      "score": 42,
      "created_utc": 1712873600,
      "permalink": "https://reddit.com/r/redditdev/comments/jkl012/..."
    }
  ],
  "overview": null
}
```

- Subreddit info items

```json
{
  "type": "subreddit_info",
  "kind": "popular",
  "count": 2,
  "subreddits": [
    {
      "name": "python",
      "title": "Python",
      "description": "News about the programming language Python",
      "subscribers": 1000000,
      "active_users": 8500,
      "created_utc": 1200000000,
      "over_18": false,
      "subreddit_type": "public",
      "url": "https://reddit.com/r/python/",
      "icon_img": "",
      "banner_img": "",
      "community_icon": ""
    }
  ]
}
```

- Final aggregated object (summary)

```json
{
  "metadata": {
    "timestamp": "2026-04-12T13:07:24Z",
    "config": {
      "maxItemsToSave": 10,
      "limitPostsPerPage": 10,
      "maxCommentDepth": 5
    }
  },
  "data": {
    "search": {
      "data visualization": {
        "total": 3,
        "posts": [
          {
            "title": "Matplotlib vs Plotly for dashboards",
            "subreddit": "Python",
            "author": "chart_ninja",
            "score": 128,
            "num_comments": 42,
            "url": "https://example.com/post-url",
            "permalink": "https://reddit.com/r/Python/comments/abc123/...",
            "created_utc": 1712875200
          }
        ]
      }
    },
    "subreddit": {
      "python": {
        "total": 2,
        "posts": [
          {
            "title": "Asyncio tips for web scraping",
            "author": "py_async",
            "score": 210,
            "num_comments": 33,
            "url": "https://example.com/post-url",
            "permalink": "https://reddit.com/r/Python/comments/def456/...",
            "created_utc": 1712878800,
            "is_self": true,
            "selftext": "Here are some tips..."
          }
        ]
      }
    },
    "posts": {
      "abc123": {
        "post": { "id": "abc123", "title": "Show HN: My Python scraper", "author": "dev_user", "subreddit": "Python", "score": 512, "upvote_ratio": 0.95, "num_comments": 87, "created_utc": 1712871000, "url": "https://example.com/post-url", "permalink": "https://reddit.com/r/Python/comments/abc123/...", "is_self": true, "selftext": "I built a scraper...", "link_flair_text": "Project", "over_18": false },
        "comments": [ { "id": "c1", "author": "commenter1", "body": "Nice work!", "score": 15, "created_utc": 1712874600, "depth": 0, "replies": [] } ],
        "total_comments_parsed": 1
      }
    },
    "users": {
      "spez": {
        "profile": { "name": "spez", "link_karma": 1000, "comment_karma": 500, "total_karma": 1500, "created_utc": 1133212800 },
        "submitted": [ { "title": "Announcement", "subreddit": "announcements", "score": 999, "created_utc": 1712870000, "permalink": "https://reddit.com/r/announcements/comments/ghi789/..." } ],
        "comments": [ { "body": "Thanks for the feedback.", "subreddit": "redditdev", "score": 42, "created_utc": 1712873600, "permalink": "https://reddit.com/r/redditdev/comments/jkl012/..." } ],
        "overview": { "total_items": 0, "posts_count": 0, "comments_count": 0 }
      }
    },
    "subreddit_info": {
      "popular": [
        { "name": "python", "title": "Python", "description": "News about the programming language Python", "subscribers": 1000000, "active_users": 8500, "created_utc": 1200000000, "over_18": false, "subreddit_type": "public", "url": "https://reddit.com/r/python/", "icon_img": "", "banner_img": "", "community_icon": "" }
      ],
      "new": [],
      "specific": {
        "python": { "name": "python", "title": "Python", "description": "News about the programming language Python", "subscribers": 1000000, "active_users": 8500, "created_utc": 1200000000, "over_18": false, "subreddit_type": "public", "url": "https://reddit.com/r/python/", "icon_img": "", "banner_img": "", "community_icon": "" }
      }
    }
  }
}
```

Notes:

- Depending on your toggles, some optional objects may be missing or null (e.g., user.profile when disabled; overview when off).
- Export JSON or CSV from the Dataset UI or via the Apify API.

### FAQ

#### Do I need to log in or use API keys to run this Reddit Scraper?

No. The actor uses Reddit’s public JSON API and does not require login or API keys. It’s a Reddit scraper Python solution that works on publicly available data only.

#### Can it scrape Reddit comments as well as posts?

Yes. When “Enable post + comments” is on and “Skip comments” is off, it fetches full posts and parses comment trees up to the “Max comment tree depth” you set.

#### How do I restrict search to a specific subreddit?

Provide your Search Term(s) and set “Community (optional)” to the subreddit name (without r/). Enable “Ignore start URLs” if you want search-only mode.

#### What limits control the volume of data?

Use “Maximum number of items to be saved,” “Limit of posts scraped inside a single page,” “Limit of comments scraped inside a single page,” “Max items per user,” and “Max comment tree depth.” You can also adjust “Delay between requests (seconds)” to manage pacing and reduce rate limiting.

#### How reliable is it when Reddit rate-limits or blocks requests?

The actor starts with direct connections and automatically falls back to Apify datacenter proxy, then residential proxy (with retries) if blocked. Once a working proxy is found, it’s used for all remaining requests.

#### What output formats are supported?

Data is stored in the Apify Dataset. You can export to JSON or CSV and consume via the Apify API for integration into your Reddit API scraper pipelines.

#### Can I integrate this with my own Python scripts or data pipelines?

Yes. Access the Dataset via the Apify API and process outputs in your scripts. The structured JSON is designed for easy ingestion in automation, analytics, or ML workflows.

#### Is it safe and compliant to use?

Yes — when used responsibly on public content. The actor does not access private or authenticated data. Always respect Reddit’s terms and applicable data protection laws.

### Final thoughts

Reddit Scraper is built for scalable, structured Reddit data extraction without login. With bulk URL support, flexible search, full comment parsing, user activity capture, and resilient proxy fallback, it’s ideal for marketers, developers, data analysts, and researchers. Export clean JSON/CSV, connect via the Apify API, and automate your Reddit web scraper workflows with confidence. Start extracting smarter insights from Reddit today.

# Actor input Schema

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

One or more Reddit URLs to scrape. This field supports bulk input: use "+ Add" to add more URLs, "Bulk edit" to paste many at once, or "Text file" to upload a file with one URL per line. Accepted URL types: (1) Post URLs — any link containing /comments/ and a post ID (e.g. https://www.reddit.com/r/subreddit/comments/ABC123/title/); (2) Subreddit URLs — links to a community (e.g. https://www.reddit.com/r/python/); (3) User profile URLs — links to a user (e.g. https://www.reddit.com/user/username/). The actor detects the type of each URL and runs the appropriate scraper (post+comments, subreddit listing, or user profile). At least one Start URL is required unless you run in search-only mode with "Ignore start URLs" enabled.

## `skipComments` (type: `boolean`):

If enabled, the actor will not fetch comments for any post URLs. Only the post title, body, score, and other post-level data will be collected. Use this to speed up runs or reduce output size when you only need post content.

## `skipUserPosts` (type: `boolean`):

If enabled, any user profile URLs in Start URLs are ignored and no user data (profile, submitted posts, comments) is scraped. Subreddit and post URLs are still processed as usual.

## `skipCommunity` (type: `boolean`):

If enabled, the actor will not fetch subreddit/community metadata (e.g. description, subscriber count, creation date) for subreddits that appear in your Start URLs or in the subreddit info options. Post listings from those subreddits are still scraped when "Enable subreddit posts" is on.

## `searchTerms` (type: `array`):

One or more search phrases to run against Reddit. Use "+ Add" to add another term or "Bulk edit" to paste multiple lines. Each term is queried separately and results appear under the "search" key in the output, with the query as the key (e.g. "python programming"). Search is executed only when this array is non-empty and either you have no Start URLs or "Ignore start URLs" is enabled.

## `searchCommunity` (type: `string`):

Optional subreddit name without the "r/" prefix (e.g. python, learnprogramming). When set, search is restricted to this community only (Reddit's "search within subreddit" behaviour). Leave empty to search all of Reddit. Only has an effect when you have at least one Search Term.

## `ignoreStartUrls` (type: `boolean`):

When enabled, the actor does not scrape any Start URLs. Only search runs, using the Search Term(s) you provided. Useful when you want to run a search-only job (e.g. multiple keywords) without scraping specific posts or subreddits. You must provide at least one search term for the run to do anything.

## `searchForPosts` (type: `boolean`):

Include posts in search results. When on (default), search returns post listings matching your query. This is the primary search mode for this actor.

## `searchForComments` (type: `boolean`):

Reserved for future use: include comments in the search scope. Currently the actor focuses on post search.

## `searchForCommunities` (type: `boolean`):

Reserved for future use: include communities/subreddits in the search scope.

## `searchForUsers` (type: `boolean`):

Reserved for future use: include user profiles in the search scope.

## `sortSearch` (type: `string`):

Controls how Reddit search results are ordered. Options: relevance (best match to query), new (newest first), hot (trending), top (highest score), comments (most comments). Applies to all search terms in this run.

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

Restricts search results to a relative time window: hour (last 24h), day, week, month, year, or all (no time limit). This is Reddit's "t" parameter and affects which posts are included in search. Use "Filter by date" below for an absolute or custom relative date.

## `filterByDate` (type: `string`):

Optional filter to only include posts from a certain date onward. You can choose an absolute date (e.g. 2024-01-15) or a relative range (e.g. "3 days", "2 weeks", "1 month"). Leave empty to not filter by date. Applies to search and listing results where applicable.

## `enableSearch` (type: `boolean`):

When on, the actor will run Reddit search if you have provided Search Terms and are in search mode (no Start URLs or Ignore start URLs). When off, search is skipped even if search terms are present.

## `enableSubreddit` (type: `boolean`):

When on, any subreddit URLs in Start URLs (e.g. reddit.com/r/python) are scraped for their post listing (hot, new, etc.) up to the limits you set. When off, subreddit URLs are ignored.

## `sortSubreddit` (type: `string`):

How to order posts when fetching from each subreddit: hot (trending), new (newest first), top (highest score), rising (gaining traction), controversial.

## `enablePost` (type: `boolean`):

When on, any post URLs in Start URLs are scraped for the full post and its comment tree (unless "Skip comments" is enabled). When off, post URLs are ignored.

## `enableUser` (type: `boolean`):

When on, any user profile URLs in Start URLs are scraped for profile info, submitted posts, and comments (subject to "Skip user posts" and limit settings). When off, user URLs are ignored.

## `enableSubredditInfo` (type: `boolean`):

When on, the actor fetches metadata for subreddits: for subreddits from Start URLs and, if enabled below, popular/new subreddit lists. Metadata includes title, description, subscribers, creation date, etc. When off, no subreddit info is collected.

## `maxItemsToSave` (type: `integer`):

Global maximum number of items (e.g. posts, search results) the actor will collect across all sources. Helps control run duration and dataset size. Each scraper type respects this cap where applicable.

## `limitPostsPerPage` (type: `integer`):

Maximum number of posts to fetch from a single subreddit listing (e.g. one "hot" or "new" listing). Reddit returns up to 100 per request; lowering this reduces data per subreddit.

## `postDateLimit` (type: `string`):

If set, only posts created on or after this date (YYYY-MM-DD) are included. Use the date picker or enter a date. Leave empty to include all posts regardless of date.

## `limitCommentsPerPage` (type: `integer`):

Maximum number of comments to retrieve per post. Reddit returns comments in a tree; this limits how many are fetched per post to avoid very large responses.

## `limitCommunityPages` (type: `integer`):

For each subreddit/community URL, the maximum number of listing pages to paginate through (each page can contain up to the "Limit of posts" value). Use a low number (e.g. 2) for quick runs or higher for more coverage.

## `limitUserPages` (type: `integer`):

For each user profile URL, the maximum number of pages to fetch for submitted posts and comments. Each page contains multiple items; this cap controls how deep the actor goes into a user's history.

## `pageScrollTimeout` (type: `integer`):

Timeout in seconds for any page or scroll-related operations during scraping. If a request or scroll step takes longer than this, it may be aborted. Increase for slow networks.

## `maxCommentDepth` (type: `integer`):

Maximum depth of nested comment replies to parse. Depth 1 means only top-level comments; higher values include more nested threads. Reddit threads can be very deep; limiting depth keeps output manageable (1–20).

## `maxItemsPerUser` (type: `integer`):

Per user, the maximum number of submitted posts and the maximum number of comments to fetch. For example, 20 means up to 20 submitted posts and up to 20 comments per user profile.

## `fetchUserProfile` (type: `boolean`):

When on, fetch each user's profile (name, karma, created date). When off, only submitted posts and/or comments are fetched according to the toggles below.

## `fetchUserSubmitted` (type: `boolean`):

When on, fetch posts submitted by each user. When off, only profile and/or comments are fetched according to the other toggles.

## `fetchUserComments` (type: `boolean`):

When on, fetch comments made by each user. When off, only profile and/or submitted posts are fetched according to the other toggles.

## `fetchUserOverview` (type: `boolean`):

When on, in addition to profile, submitted posts, and comments, the actor fetches the user's combined overview and adds a summary (total items, posts count, comments count) to the user output. Slightly increases requests per user.

## `fetchPopularSubreddits` (type: `boolean`):

When on, the actor fetches Reddit's list of popular subreddits and adds them to the "subreddit\_info.popular" array in the output. The number of subreddits is capped by "Max subreddits (popular/new lists)" below.

## `fetchNewSubreddits` (type: `boolean`):

When on, the actor fetches recently created subreddits and adds them to "subreddit\_info.new" in the output. The number is capped by "Max subreddits (popular/new lists)" below.

## `maxSubredditsInfo` (type: `integer`):

When "Fetch popular subreddits" or "Fetch new subreddits" is enabled, this is the maximum number of subreddits to fetch for each of those lists. Does not affect metadata for subreddits from your Start URLs.

## `requestDelaySeconds` (type: `integer`):

Number of seconds to wait between consecutive HTTP requests to Reddit. A value of 1 or 2 can help avoid rate limiting (429). Set to 0 for no delay (faster but higher risk of blocks).

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

Configure Apify Proxy for this run. By default the actor uses no proxy (direct connection to Reddit). If Reddit blocks or rate-limits the run, the actor will automatically try datacenter proxy, then residential proxy (up to 3 retries), and keep using the first one that works. Here you can optionally enable Apify proxy from the start (e.g. use Apify Proxy with a specific group) so all requests go through proxy immediately.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.reddit.com/r/pasta/comments/vwi6jx/pasta_peperoni_and_ricotta_cheese_"
  ],
  "skipComments": false,
  "skipUserPosts": false,
  "skipCommunity": false,
  "ignoreStartUrls": false,
  "searchForPosts": true,
  "searchForComments": false,
  "searchForCommunities": false,
  "searchForUsers": false,
  "sortSearch": "new",
  "timeFilter": "all",
  "enableSearch": true,
  "enableSubreddit": true,
  "sortSubreddit": "hot",
  "enablePost": true,
  "enableUser": true,
  "enableSubredditInfo": true,
  "maxItemsToSave": 10,
  "limitPostsPerPage": 10,
  "limitCommentsPerPage": 10,
  "limitCommunityPages": 2,
  "limitUserPages": 2,
  "pageScrollTimeout": 40,
  "maxCommentDepth": 5,
  "maxItemsPerUser": 20,
  "fetchUserProfile": true,
  "fetchUserSubmitted": true,
  "fetchUserComments": true,
  "fetchUserOverview": false,
  "fetchPopularSubreddits": false,
  "fetchNewSubreddits": false,
  "maxSubredditsInfo": 25,
  "requestDelaySeconds": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "https://www.reddit.com/r/pasta/comments/vwi6jx/pasta_peperoni_and_ricotta_cheese_"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapium/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 = {
    "startUrls": ["https://www.reddit.com/r/pasta/comments/vwi6jx/pasta_peperoni_and_ricotta_cheese_"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapium/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 '{
  "startUrls": [
    "https://www.reddit.com/r/pasta/comments/vwi6jx/pasta_peperoni_and_ricotta_cheese_"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapium/reddit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Scraper",
        "description": "🔎 Reddit Scraper (reddit-scraper) extracts posts, comments & metadata from subreddits, users and threads — keywords, timestamps, scores & links. 📤 Export JSON/CSV. 🚀 Ideal for market research, social listening, academic studies & content discovery.",
        "version": "0.1",
        "x-build-id": "QifPxkBu5T2MrTOmV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapium~reddit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapium-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/scrapium~reddit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapium-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/scrapium~reddit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapium-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗 Start URLs",
                        "type": "array",
                        "description": "One or more Reddit URLs to scrape. This field supports bulk input: use \"+ Add\" to add more URLs, \"Bulk edit\" to paste many at once, or \"Text file\" to upload a file with one URL per line. Accepted URL types: (1) Post URLs — any link containing /comments/ and a post ID (e.g. https://www.reddit.com/r/subreddit/comments/ABC123/title/); (2) Subreddit URLs — links to a community (e.g. https://www.reddit.com/r/python/); (3) User profile URLs — links to a user (e.g. https://www.reddit.com/user/username/). The actor detects the type of each URL and runs the appropriate scraper (post+comments, subreddit listing, or user profile). At least one Start URL is required unless you run in search-only mode with \"Ignore start URLs\" enabled.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "skipComments": {
                        "title": "💬 Skip comments",
                        "type": "boolean",
                        "description": "If enabled, the actor will not fetch comments for any post URLs. Only the post title, body, score, and other post-level data will be collected. Use this to speed up runs or reduce output size when you only need post content.",
                        "default": false
                    },
                    "skipUserPosts": {
                        "title": "👤 Skip user posts",
                        "type": "boolean",
                        "description": "If enabled, any user profile URLs in Start URLs are ignored and no user data (profile, submitted posts, comments) is scraped. Subreddit and post URLs are still processed as usual.",
                        "default": false
                    },
                    "skipCommunity": {
                        "title": "🏘️ Skip community",
                        "type": "boolean",
                        "description": "If enabled, the actor will not fetch subreddit/community metadata (e.g. description, subscriber count, creation date) for subreddits that appear in your Start URLs or in the subreddit info options. Post listings from those subreddits are still scraped when \"Enable subreddit posts\" is on.",
                        "default": false
                    },
                    "searchTerms": {
                        "title": "🔎 Search Term",
                        "type": "array",
                        "description": "One or more search phrases to run against Reddit. Use \"+ Add\" to add another term or \"Bulk edit\" to paste multiple lines. Each term is queried separately and results appear under the \"search\" key in the output, with the query as the key (e.g. \"python programming\"). Search is executed only when this array is non-empty and either you have no Start URLs or \"Ignore start URLs\" is enabled.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchCommunity": {
                        "title": "🏘️ Community (optional)",
                        "type": "string",
                        "description": "Optional subreddit name without the \"r/\" prefix (e.g. python, learnprogramming). When set, search is restricted to this community only (Reddit's \"search within subreddit\" behaviour). Leave empty to search all of Reddit. Only has an effect when you have at least one Search Term."
                    },
                    "ignoreStartUrls": {
                        "title": "⏭️ Ignore start URLs",
                        "type": "boolean",
                        "description": "When enabled, the actor does not scrape any Start URLs. Only search runs, using the Search Term(s) you provided. Useful when you want to run a search-only job (e.g. multiple keywords) without scraping specific posts or subreddits. You must provide at least one search term for the run to do anything.",
                        "default": false
                    },
                    "searchForPosts": {
                        "title": "📝 Search for posts",
                        "type": "boolean",
                        "description": "Include posts in search results. When on (default), search returns post listings matching your query. This is the primary search mode for this actor.",
                        "default": true
                    },
                    "searchForComments": {
                        "title": "💬 Search for comments",
                        "type": "boolean",
                        "description": "Reserved for future use: include comments in the search scope. Currently the actor focuses on post search.",
                        "default": false
                    },
                    "searchForCommunities": {
                        "title": "🏘️ Search for communities",
                        "type": "boolean",
                        "description": "Reserved for future use: include communities/subreddits in the search scope.",
                        "default": false
                    },
                    "searchForUsers": {
                        "title": "👤 Search for users",
                        "type": "boolean",
                        "description": "Reserved for future use: include user profiles in the search scope.",
                        "default": false
                    },
                    "sortSearch": {
                        "title": "📊 Sort search",
                        "enum": [
                            "relevance",
                            "new",
                            "hot",
                            "top",
                            "comments"
                        ],
                        "type": "string",
                        "description": "Controls how Reddit search results are ordered. Options: relevance (best match to query), new (newest first), hot (trending), top (highest score), comments (most comments). Applies to all search terms in this run.",
                        "default": "new"
                    },
                    "timeFilter": {
                        "title": "⏱️ Time filter",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Restricts search results to a relative time window: hour (last 24h), day, week, month, year, or all (no time limit). This is Reddit's \"t\" parameter and affects which posts are included in search. Use \"Filter by date\" below for an absolute or custom relative date.",
                        "default": "all"
                    },
                    "filterByDate": {
                        "title": "📅 Filter by date (Posts only)",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$|^$",
                        "type": "string",
                        "description": "Optional filter to only include posts from a certain date onward. You can choose an absolute date (e.g. 2024-01-15) or a relative range (e.g. \"3 days\", \"2 weeks\", \"1 month\"). Leave empty to not filter by date. Applies to search and listing results where applicable."
                    },
                    "enableSearch": {
                        "title": "🔍 Enable search",
                        "type": "boolean",
                        "description": "When on, the actor will run Reddit search if you have provided Search Terms and are in search mode (no Start URLs or Ignore start URLs). When off, search is skipped even if search terms are present.",
                        "default": true
                    },
                    "enableSubreddit": {
                        "title": "📰 Enable subreddit posts",
                        "type": "boolean",
                        "description": "When on, any subreddit URLs in Start URLs (e.g. reddit.com/r/python) are scraped for their post listing (hot, new, etc.) up to the limits you set. When off, subreddit URLs are ignored.",
                        "default": true
                    },
                    "sortSubreddit": {
                        "title": "📊 Subreddit listing sort",
                        "enum": [
                            "hot",
                            "new",
                            "top",
                            "rising",
                            "controversial"
                        ],
                        "type": "string",
                        "description": "How to order posts when fetching from each subreddit: hot (trending), new (newest first), top (highest score), rising (gaining traction), controversial.",
                        "default": "hot"
                    },
                    "enablePost": {
                        "title": "📝 Enable post + comments",
                        "type": "boolean",
                        "description": "When on, any post URLs in Start URLs are scraped for the full post and its comment tree (unless \"Skip comments\" is enabled). When off, post URLs are ignored.",
                        "default": true
                    },
                    "enableUser": {
                        "title": "👤 Enable user scraper",
                        "type": "boolean",
                        "description": "When on, any user profile URLs in Start URLs are scraped for profile info, submitted posts, and comments (subject to \"Skip user posts\" and limit settings). When off, user URLs are ignored.",
                        "default": true
                    },
                    "enableSubredditInfo": {
                        "title": "🏘️ Enable subreddit info",
                        "type": "boolean",
                        "description": "When on, the actor fetches metadata for subreddits: for subreddits from Start URLs and, if enabled below, popular/new subreddit lists. Metadata includes title, description, subscribers, creation date, etc. When off, no subreddit info is collected.",
                        "default": true
                    },
                    "maxItemsToSave": {
                        "title": "📦 Maximum number of items to be saved",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Global maximum number of items (e.g. posts, search results) the actor will collect across all sources. Helps control run duration and dataset size. Each scraper type respects this cap where applicable.",
                        "default": 10
                    },
                    "limitPostsPerPage": {
                        "title": "📄 Limit of posts scraped inside a single page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of posts to fetch from a single subreddit listing (e.g. one \"hot\" or \"new\" listing). Reddit returns up to 100 per request; lowering this reduces data per subreddit.",
                        "default": 10
                    },
                    "postDateLimit": {
                        "title": "📅 Post date limit",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^$",
                        "type": "string",
                        "description": "If set, only posts created on or after this date (YYYY-MM-DD) are included. Use the date picker or enter a date. Leave empty to include all posts regardless of date."
                    },
                    "limitCommentsPerPage": {
                        "title": "💬 Limit of comments scraped inside a single page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of comments to retrieve per post. Reddit returns comments in a tree; this limits how many are fetched per post to avoid very large responses.",
                        "default": 10
                    },
                    "limitCommunityPages": {
                        "title": "🏘️ Limit of Communities' pages scraped",
                        "minimum": 1,
                        "type": "integer",
                        "description": "For each subreddit/community URL, the maximum number of listing pages to paginate through (each page can contain up to the \"Limit of posts\" value). Use a low number (e.g. 2) for quick runs or higher for more coverage.",
                        "default": 2
                    },
                    "limitUserPages": {
                        "title": "👤 Limit of Users' pages scraped",
                        "minimum": 1,
                        "type": "integer",
                        "description": "For each user profile URL, the maximum number of pages to fetch for submitted posts and comments. Each page contains multiple items; this cap controls how deep the actor goes into a user's history.",
                        "default": 2
                    },
                    "pageScrollTimeout": {
                        "title": "⏳ Page scroll timeout (seconds)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Timeout in seconds for any page or scroll-related operations during scraping. If a request or scroll step takes longer than this, it may be aborted. Increase for slow networks.",
                        "default": 40
                    },
                    "maxCommentDepth": {
                        "title": "🌳 Max comment tree depth",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum depth of nested comment replies to parse. Depth 1 means only top-level comments; higher values include more nested threads. Reddit threads can be very deep; limiting depth keeps output manageable (1–20).",
                        "default": 5
                    },
                    "maxItemsPerUser": {
                        "title": "👤 Max items per user (posts/comments)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Per user, the maximum number of submitted posts and the maximum number of comments to fetch. For example, 20 means up to 20 submitted posts and up to 20 comments per user profile.",
                        "default": 20
                    },
                    "fetchUserProfile": {
                        "title": "👤 Fetch user profile",
                        "type": "boolean",
                        "description": "When on, fetch each user's profile (name, karma, created date). When off, only submitted posts and/or comments are fetched according to the toggles below.",
                        "default": true
                    },
                    "fetchUserSubmitted": {
                        "title": "📝 Fetch user submitted posts",
                        "type": "boolean",
                        "description": "When on, fetch posts submitted by each user. When off, only profile and/or comments are fetched according to the other toggles.",
                        "default": true
                    },
                    "fetchUserComments": {
                        "title": "💬 Fetch user comments",
                        "type": "boolean",
                        "description": "When on, fetch comments made by each user. When off, only profile and/or submitted posts are fetched according to the other toggles.",
                        "default": true
                    },
                    "fetchUserOverview": {
                        "title": "📋 Fetch user overview",
                        "type": "boolean",
                        "description": "When on, in addition to profile, submitted posts, and comments, the actor fetches the user's combined overview and adds a summary (total items, posts count, comments count) to the user output. Slightly increases requests per user.",
                        "default": false
                    },
                    "fetchPopularSubreddits": {
                        "title": "🔥 Fetch popular subreddits list",
                        "type": "boolean",
                        "description": "When on, the actor fetches Reddit's list of popular subreddits and adds them to the \"subreddit_info.popular\" array in the output. The number of subreddits is capped by \"Max subreddits (popular/new lists)\" below.",
                        "default": false
                    },
                    "fetchNewSubreddits": {
                        "title": "🆕 Fetch new subreddits list",
                        "type": "boolean",
                        "description": "When on, the actor fetches recently created subreddits and adds them to \"subreddit_info.new\" in the output. The number is capped by \"Max subreddits (popular/new lists)\" below.",
                        "default": false
                    },
                    "maxSubredditsInfo": {
                        "title": "🔢 Max subreddits (popular/new lists)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "When \"Fetch popular subreddits\" or \"Fetch new subreddits\" is enabled, this is the maximum number of subreddits to fetch for each of those lists. Does not affect metadata for subreddits from your Start URLs.",
                        "default": 25
                    },
                    "requestDelaySeconds": {
                        "title": "⏳ Delay between requests (seconds)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of seconds to wait between consecutive HTTP requests to Reddit. A value of 1 or 2 can help avoid rate limiting (429). Set to 0 for no delay (faster but higher risk of blocks).",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy Configuration",
                        "type": "object",
                        "description": "Configure Apify Proxy for this run. By default the actor uses no proxy (direct connection to Reddit). If Reddit blocks or rate-limits the run, the actor will automatically try datacenter proxy, then residential proxy (up to 3 retries), and keep using the first one that works. Here you can optionally enable Apify proxy from the start (e.g. use Apify Proxy with a specific group) so all requests go through proxy immediately."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
