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

Scrape public Reddit posts and comments from subreddit, search, user, and thread RSS feeds without Reddit API credentials.

- **URL**: https://apify.com/fetch\_cat/reddit-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## Reddit Scraper

Collect public Reddit posts and optional comments without Reddit API keys, OAuth, cookies, or a Reddit login.

### What does Reddit Scraper do?

Reddit Scraper turns public Reddit pages into clean dataset records that you can export, analyze, or connect to other tools.

It can collect:

- 🔎 Posts from subreddit listings
- 🆕 New, top, rising, hot, and relevance-sorted results
- 🌍 Global Reddit search results
- 🎯 Search results inside one subreddit
- 👤 Public submitted posts from user profiles
- 💬 Comments from public posts when enabled
- 🧵 Focused comment context from supported Reddit comment URLs

### Who is it for?

This Actor is useful for teams that need lightweight public Reddit monitoring.

- 🧑‍💼 Market researchers tracking conversations around products
- 🧑‍🔬 Data analysts building public discussion datasets
- 🧑‍💻 Developers prototyping Reddit-powered workflows
- 🧑‍🏫 Academic researchers collecting public post metadata
- 🧑‍🚀 Growth teams monitoring subreddit mentions
- 🧑‍⚖️ Trust and safety teams checking public discussion trends

### Why use this Actor?

Reddit pages can be inconsistent across communities, post ages, and access conditions. This Actor is designed to return useful public records while avoiding guessed or fabricated values.

If Reddit does not make a field available for a public page, the Actor leaves that field empty or `null` instead of inventing data.

### Common use cases

- Monitor a subreddit for new posts about a brand, product, or competitor
- Build keyword-based datasets from public Reddit discussions
- Collect post URLs, titles, authors, timestamps, and comment counts for analysis
- Pull a small set of comments for thread review or qualitative research
- Feed public Reddit discussions into dashboards, alerts, or LLM workflows

### Supported Reddit sources

You can start runs from several customer-friendly input types:

- Subreddit URLs such as `https://www.reddit.com/r/technology/`
- Reddit post URLs such as `https://www.reddit.com/r/technology/comments/.../`
- Reddit comment URLs when you need nearby context
- Reddit user profile URLs for public submitted posts
- A global `searchQuery`
- A `searchQuery` restricted to a `searchSubreddit`

### What data can you collect?

| Field | Description |
| --- | --- |
| `type` | `post` or `comment` |
| `id` | Reddit item id when available |
| `thingId` | Reddit thing id such as `t3_abc` or `t1_xyz` |
| `subreddit` | Subreddit name |
| `title` | Post title |
| `text` | Post text or summary when available |
| `selfText` | Post text field for compatibility with Reddit-style datasets |
| `body` | Comment body text |
| `author` | Public Reddit username |
| `url` | Post URL |
| `permalink` | Reddit permalink |
| `createdAt` | Public timestamp when available |
| `score` | Score when available; otherwise `null` |
| `commentCount` | Comment count when available |
| `parentId` | Parent post id for comments when inferable |
| `depth` | Comment nesting depth when available |
| `sourceUrl` | Input or resolved Reddit source URL |
| `scrapedAt` | Timestamp when the record was saved |

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

The Actor uses pay-per-event pricing:

- Start event: `$0.005` one-time run charge
- Item event: charged per saved post or comment record

| Plan tier | Approx. item event price | Example: 100 posts/comments |
| --- | ---: | ---: |
| Free | `$0.0001329` | `$0.0133` + start event |
| Bronze | `$0.00011557` | `$0.0116` + start event |
| Silver | `$0.000090141` | `$0.0090` + start event |
| Gold | `$0.000069339` | `$0.0069` + start event |
| Platinum | `$0.000046226` | `$0.0046` + start event |
| Diamond | `$0.000032358` | `$0.0032` + start event |

A small Free-plan test that saves 25 posts costs about `$0.0083` total (`$0.005` start event + 25 × `$0.0001329`). A 100-record Free-plan run is about `$0.0183` before any Apify platform usage charges shown to you at run time.

Actual price is shown on the Apify Store page before you start a run. Keep `maxPostsPerSource` and `maxCommentsPerPost` low for test runs.

### How to scrape a subreddit

1. Open the Actor input.
2. Add a subreddit URL such as `https://www.reddit.com/r/technology/`.
3. Choose `sort` and `timeFilter`.
4. Set `maxPostsPerSource`.
5. Run the Actor.
6. Export the dataset as JSON, CSV, Excel, or via API.

### How to scrape Reddit search

Use `searchQuery` for global search.

Example:

```json
{
  "searchQuery": "web scraping tools",
  "sort": "relevance",
  "timeFilter": "month",
  "maxPostsPerSource": 25
}
````

### How to search inside a subreddit

Set both `searchQuery` and `searchSubreddit`.

```json
{
  "searchQuery": "browser automation",
  "searchSubreddit": "webscraping",
  "sort": "new",
  "maxPostsPerSource": 20
}
```

### How to scrape comments

Enable comments only when you need thread data. Comment scraping can add more requests and may take longer than post-only runs.

```json
{
  "urls": [{ "url": "https://www.reddit.com/r/technology/" }],
  "includeComments": true,
  "maxPostsPerSource": 5,
  "maxCommentsPerPost": 10
}
```

### Input options

- `urls` - Reddit URLs to scrape.
- `searchQuery` - optional Reddit search query.
- `searchSubreddit` - optional subreddit restriction.
- `sort` - hot, new, top, rising, or relevance.
- `timeFilter` - hour, day, week, month, year, or all.
- `maxPostsPerSource` - maximum post records per source.
- `includeComments` - fetch comments for post records.
- `maxCommentsPerPost` - maximum comments for each post.
- `commentContextMode` - focused or post comment behavior.
- `commentContextDepth` - amount of surrounding context for focused comment URLs.
- `proxyConfiguration` - Apify proxy settings. Residential proxy is recommended for reliability.

### Output example

```json
{
  "type": "post",
  "id": "abc123",
  "thingId": "t3_abc123",
  "subreddit": "technology",
  "title": "Example Reddit post title",
  "text": "Example public post text or summary",
  "selfText": "Example public post text or summary",
  "body": null,
  "author": "example",
  "url": "https://www.reddit.com/r/technology/comments/abc123/example/",
  "permalink": "https://www.reddit.com/r/technology/comments/abc123/example/",
  "createdAt": "2026-06-13T12:00:00+00:00",
  "score": null,
  "commentCount": 42,
  "parentId": null,
  "depth": null,
  "sourceUrl": "https://www.reddit.com/r/technology/",
  "scrapedAt": "2026-06-13T12:01:00.000Z"
}
```

### Tips for best results

- Start with small limits while testing.
- Use subreddit URLs for predictable runs.
- Use `new` sort for monitoring recent conversations.
- Use `top` with a `timeFilter` for popular historical posts.
- Enable comments only for focused collection.
- Use the default residential proxy setting for reliable Reddit access.
- For large research jobs, split sources into smaller runs so you can inspect partial results.

### Limitations

Reddit does not make every field available on every public page.

The Actor may return `null` for:

- Score
- Exact nested comment depth
- Some deleted or removed text
- Fields that are hidden, restricted, or unavailable for a given public page

This is intentional. The Actor does not invent unavailable data.

### Availability notes

Results can vary because Reddit controls what is visible for each public URL. Some communities, posts, or comments may be removed, locked, private, quarantined, age-gated, rate-limited, or temporarily unavailable.

For production workflows, use modest limits and enable Apify Residential Proxy in the Actor input.

### Proxy and anti-blocking notes

The default input uses Apify Residential Proxy because Reddit may rate-limit shared datacenter or local traffic. Residential proxy settings are more reliable for production runs.

Use the smallest practical limits when testing proxy settings.

### Integrations

You can connect the dataset to:

- Google Sheets for subreddit monitoring
- Slack alerts for keyword mentions
- Data warehouses for trend analysis
- BI dashboards for content tracking
- LLM workflows for public discussion summaries

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/reddit-scraper').call({
  urls: [{ url: 'https://www.reddit.com/r/technology/' }],
  maxPostsPerSource: 10
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('fetch_cat/reddit-scraper').call(run_input={
    'searchQuery': 'web scraping tools',
    'maxPostsPerSource': 10,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/fetch_cat~reddit-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"urls":[{"url":"https://www.reddit.com/r/technology/"}],"maxPostsPerSource":10}'
```

### MCP usage

Use the Apify MCP server with tools scoped to this Actor:

```text
https://mcp.apify.com/?tools=fetch_cat/reddit-scraper
```

Claude Code setup:

```bash
claude mcp add apify-reddit --transport http --url "https://mcp.apify.com/?tools=fetch_cat/reddit-scraper"
```

JSON configuration example:

```json
{
  "mcpServers": {
    "apify-reddit": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/reddit-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the top posts from r/technology this week."
- "Find recent Reddit discussions about web scraping tools."
- "Collect five posts and comments from this Reddit thread."

### Data quality guidance

Review saved text before using it for downstream modeling. Public Reddit pages can contain boilerplate, deleted-content markers, link summaries, or moderator notices.

For analytics, filter by `type`, `subreddit`, `author`, and `createdAt`.

### Legality and ethics

This Actor collects public Reddit pages available without login. You are responsible for using the data lawfully, respecting privacy, following applicable terms, and avoiding spam or harassment.

Do not use scraped public data to identify, target, or harm individuals.

### FAQ

#### Does this Actor need Reddit API credentials?

No. It collects public Reddit pages and does not require OAuth, cookies, or a Reddit login.

#### Can it scrape private or quarantined communities?

No. It only collects public content that is available without login.

#### Can it collect every comment in a large thread?

Not always. Very large, removed, locked, or restricted threads may return fewer comments than requested.

### Troubleshooting

#### Why is `score` null?

Reddit does not consistently make score values available for every public source. The Actor leaves `score` null rather than guessing.

#### Why did I get fewer posts than requested?

The source may contain fewer visible entries for that source, sort, search query, or time filter. Reddit may also remove, hide, or temporarily limit posts.

#### Why are comments missing?

Set `includeComments` to true and use a post URL or a low number of posts. Some threads have deleted, locked, or unavailable comments.

### Related scrapers

Other Apify actors from this account may help with social media or monitoring workflows:

- Website Change Monitor: `https://apify.com/fetch_cat/website-change-monitor`
- TikTok Comments Scraper: `https://apify.com/fetch_cat/tiktok-comments-scraper`

### Changelog

#### 0.1

- Initial Reddit post and comment collection.

### Support

If a Reddit URL does not work, include the input, run ID, and expected public page. Availability can vary by subreddit, post age, access conditions, and Reddit-side restrictions.

# Actor input Schema

## `urls` (type: `array`):

Subreddit, post, comment, user profile, or Reddit search URLs to scrape.

## `searchQuery` (type: `string`):

Optional Reddit search query. Used with global Reddit search unless Search subreddit is filled.

## `searchSubreddit` (type: `string`):

Optional subreddit name for restricting searchQuery, for example technology or webscraping.

## `sort` (type: `string`):

Sort mode for subreddit listings and search feeds.

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

Time window for top/search RSS feeds.

## `maxPostsPerSource` (type: `integer`):

Maximum number of post records to save from each URL or query source.

## `includeComments` (type: `boolean`):

Fetch comments for discovered post URLs using Reddit comments RSS. Best-effort and limited by maxCommentsPerPost.

## `maxCommentsPerPost` (type: `integer`):

Maximum number of comment records to save per post when comments are enabled.

## `commentContextMode` (type: `string`):

For comment URLs, fetch the focused context when Reddit RSS supports it, otherwise fetch the post comment feed.

## `commentContextDepth` (type: `integer`):

Context depth parameter for focused comment RSS URLs.

## `retryCount` (type: `integer`):

Maximum retry attempts for Reddit RSS requests after rate limits, proxy resets, or temporary server errors.

## `initialRetryDelayMillis` (type: `integer`):

Base delay for exponential backoff after Reddit rate limits or proxy errors. Retry-After headers are respected when Reddit sends them.

## `requestPacingMillis` (type: `integer`):

Minimum delay between Reddit RSS requests. Increase this for large comment-heavy runs if Reddit returns 429 or proxy errors.

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

Proxy settings. Residential Apify Proxy is recommended because Reddit often rate-limits shared datacenter traffic.

## Actor input object example

```json
{
  "urls": [
    {
      "url": "https://www.reddit.com/r/technology/"
    },
    {
      "url": "https://www.reddit.com/r/webscraping/"
    }
  ],
  "searchQuery": "web scraping tools",
  "searchSubreddit": "technology",
  "sort": "hot",
  "timeFilter": "week",
  "maxPostsPerSource": 20,
  "includeComments": false,
  "maxCommentsPerPost": 10,
  "commentContextMode": "focused",
  "commentContextDepth": 3,
  "retryCount": 2,
  "initialRetryDelayMillis": 750,
  "requestPacingMillis": 750,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        {
            "url": "https://www.reddit.com/r/technology/"
        },
        {
            "url": "https://www.reddit.com/r/webscraping/"
        }
    ],
    "searchQuery": "web scraping tools",
    "searchSubreddit": "technology"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = {
    "urls": [
        { "url": "https://www.reddit.com/r/technology/" },
        { "url": "https://www.reddit.com/r/webscraping/" },
    ],
    "searchQuery": "web scraping tools",
    "searchSubreddit": "technology",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/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 '{
  "urls": [
    {
      "url": "https://www.reddit.com/r/technology/"
    },
    {
      "url": "https://www.reddit.com/r/webscraping/"
    }
  ],
  "searchQuery": "web scraping tools",
  "searchSubreddit": "technology"
}' |
apify call fetch_cat/reddit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Scraper",
        "description": "Scrape public Reddit posts and comments from subreddit, search, user, and thread RSS feeds without Reddit API credentials.",
        "version": "0.1",
        "x-build-id": "9KPn23rv62eFAKYF9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~reddit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-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/fetch_cat~reddit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-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/fetch_cat~reddit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-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",
                "properties": {
                    "urls": {
                        "title": "Reddit URLs",
                        "type": "array",
                        "description": "Subreddit, post, comment, user profile, or Reddit search URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Optional Reddit search query. Used with global Reddit search unless Search subreddit is filled."
                    },
                    "searchSubreddit": {
                        "title": "Search subreddit",
                        "type": "string",
                        "description": "Optional subreddit name for restricting searchQuery, for example technology or webscraping."
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "hot",
                            "new",
                            "top",
                            "rising",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort mode for subreddit listings and search feeds.",
                        "default": "hot"
                    },
                    "timeFilter": {
                        "title": "Time filter",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time window for top/search RSS feeds.",
                        "default": "week"
                    },
                    "maxPostsPerSource": {
                        "title": "Maximum posts per source",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of post records to save from each URL or query source.",
                        "default": 20
                    },
                    "includeComments": {
                        "title": "Include comments",
                        "type": "boolean",
                        "description": "Fetch comments for discovered post URLs using Reddit comments RSS. Best-effort and limited by maxCommentsPerPost.",
                        "default": false
                    },
                    "maxCommentsPerPost": {
                        "title": "Maximum comments per post",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of comment records to save per post when comments are enabled.",
                        "default": 10
                    },
                    "commentContextMode": {
                        "title": "Comment URL mode",
                        "enum": [
                            "focused",
                            "post"
                        ],
                        "type": "string",
                        "description": "For comment URLs, fetch the focused context when Reddit RSS supports it, otherwise fetch the post comment feed.",
                        "default": "focused"
                    },
                    "commentContextDepth": {
                        "title": "Comment context depth",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Context depth parameter for focused comment RSS URLs.",
                        "default": 3
                    },
                    "retryCount": {
                        "title": "Retry attempts per Reddit request",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum retry attempts for Reddit RSS requests after rate limits, proxy resets, or temporary server errors.",
                        "default": 2
                    },
                    "initialRetryDelayMillis": {
                        "title": "Initial retry delay (ms)",
                        "minimum": 250,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Base delay for exponential backoff after Reddit rate limits or proxy errors. Retry-After headers are respected when Reddit sends them.",
                        "default": 750
                    },
                    "requestPacingMillis": {
                        "title": "Request pacing delay (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Minimum delay between Reddit RSS requests. Increase this for large comment-heavy runs if Reddit returns 429 or proxy errors.",
                        "default": 750
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential Apify Proxy is recommended because Reddit often rate-limits shared datacenter traffic.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```