# Reddit Community Scraper 👾 (`shahidirfan/reddit-community-scraper`) Actor

Efficiently extract detailed data from Reddit communities and subreddits. This lightweight actor is designed for speed and simplicity. For optimal performance and to minimize the risk of rate limiting or blocking, the use of residential proxies is highly recommended.

- **URL**: https://apify.com/shahidirfan/reddit-community-scraper.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:** Developer tools, Social media, Other
- **Stats:** 31 total users, 10 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

Extract Reddit posts and comments from subreddits, user feeds, and direct thread URLs in a structured dataset. Collect titles, text, engagement metrics, community metadata, comment depth, author details, and source references for research, monitoring, and analysis.

### Features

- **Subreddit collection** — Gather recent posts from one or more Reddit communities
- **Thread comment extraction** — Collect top-level comments and nested replies from each post
- **User feed support** — Pull post activity from Reddit user profile URLs
- **Rich metadata output** — Save author, community, engagement, moderation, flair, and timestamp fields
- **Clean datasets** — Skip duplicate records and omit null or empty values from saved items
- **Flexible limits** — Control how many posts and comments to collect in each run

### Use Cases

#### Community Research
Track what specific Reddit communities are discussing right now. Use structured post and comment data to study trends, recurring questions, and audience language.

#### Competitive Monitoring
Watch how people talk about products, services, and industries inside target subreddits. Capture both original posts and comment responses for a fuller view of sentiment and objections.

#### Content Analysis
Build datasets for topic clustering, moderation research, or engagement analysis. The actor saves community and author context alongside each record for easier downstream filtering.

#### User Activity Review
Collect recent post activity from public Reddit user profiles. This is useful for creator research, outreach preparation, and niche account monitoring.

---

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrls` | Array | Yes | Community example in actor input | Reddit URLs to scrape. Supports subreddit URLs, user profile URLs, and direct post URLs. |
| `maxPostCount` | Integer | No | `4` | Maximum number of posts to save across the run. |
| `maxCommentsPerPost` | Integer | No | `2` | Maximum number of comments to save for each post. Set `0` to skip comments. |
| `skipComments` | Boolean | No | `false` | Skip comment extraction entirely. |
| `sort` | String | No | `"new"` | Sort order for subreddit listings. |
| `time` | String | No | `"all"` | Time filter used with supported sort modes. |
| `includeNSFW` | Boolean | No | `false` | Include NSFW posts in the results. |
| `maxPostAgeDays` | Integer | No | — | Only save posts newer than the specified number of days. |
| `proxy` | Object | No | Residential prefill | Proxy settings for higher-volume runs. |

---

### Output Data

Each dataset item is either a `post` record or a `comment` record.

| Field | Type | Description |
|-------|------|-------------|
| `dataType` | String | Record type: `post` or `comment` |
| `id` | String | Reddit full identifier such as `t3_...` or `t1_...` |
| `parsedId` | String | Short Reddit item ID |
| `url` | String | Absolute Reddit URL for the record |
| `permalink` | String | Relative Reddit permalink |
| `title` | String | Post title |
| `body` | String | Post or comment text content |
| `html` | String | HTML version of the text content when available |
| `username` | String | Author username |
| `userId` | String | Author full Reddit identifier |
| `communityName` | String | Community name such as `r/GrowthHacking` |
| `parsedCommunityName` | String | Community slug without the `r/` prefix |
| `subredditId` | String | Reddit community identifier |
| `postId` | String | Parent post full identifier for comment records |
| `parsedPostId` | String | Parent post short ID for comment records |
| `postTitle` | String | Parent post title for comment records |
| `postAuthor` | String | Parent post author for comment records |
| `postUrl` | String | Parent post URL for comment records |
| `parentId` | String | Parent item identifier for comment records |
| `numberOfComments` | Integer | Total comment count on a post |
| `depth` | Integer | Comment nesting depth |
| `upVotes` | Integer | Score shown for the record |
| `ups` | Integer | Upvote count when available |
| `downs` | Integer | Downvote count when available |
| `upVoteRatio` | Number | Post upvote ratio |
| `controversiality` | Integer | Comment controversiality indicator |
| `flair` | String | Post flair text |
| `authorFlairText` | String | Comment author flair text |
| `authorFlairRichtext` | String | Combined rich-text author flair content |
| `domain` | String | Post domain value |
| `link` | String | External link for link posts |
| `thumbnailUrl` | String | Thumbnail URL or Reddit thumbnail marker |
| `imageUrls` | Array | Extracted preview or gallery image URLs |
| `mediaType` | String | Derived content type such as `text`, `image`, `video`, or `link` |
| `totalAwardsReceived` | Integer | Number of awards received |
| `gilded` | Integer | Gilded count |
| `isVideo` | Boolean | Whether the post is a video |
| `isAd` | Boolean | Whether the post is promoted |
| `isSelf` | Boolean | Whether the post is a self-post |
| `isPinned` | Boolean | Whether the post is pinned |
| `isStickied` | Boolean | Whether the record is stickied |
| `isLocked` | Boolean | Whether the record is locked |
| `isSpoiler` | Boolean | Whether the post is marked as spoiler |
| `isArchived` | Boolean | Whether the record is archived |
| `isCollapsed` | Boolean | Whether the comment is collapsed |
| `isSubmitter` | Boolean | Whether the comment author is the original poster |
| `over18` | Boolean | NSFW flag |
| `authorIsBlocked` | Boolean | Author blocked flag when exposed |
| `authorPremium` | Boolean | Reddit premium flag for the author |
| `distinguished` | String | Moderator or admin distinction value |
| `discussionType` | String | Post discussion type when present |
| `category` | String | Category value when present |
| `removedByCategory` | String | Removal category when exposed |
| `createdAt` | String | Creation timestamp in ISO 8601 format |
| `editedAt` | String | Edit timestamp in ISO 8601 format |
| `scrapedAt` | String | Extraction timestamp in ISO 8601 format |
| `sourceUrl` | String | Source URL from the input run |
| `retrievalSource` | String | Extraction path used for the record |

---

### Usage Examples

#### Scrape a Subreddit

Collect recent posts and comments from one subreddit:

```json
{
    "startUrls": [
        { "url": "https://www.reddit.com/r/GrowthHacking/" }
    ],
    "maxPostCount": 20,
    "maxCommentsPerPost": 10,
    "sort": "new"
}
````

#### Scrape Multiple Communities

Collect posts from several subreddits in one run:

```json
{
    "startUrls": [
        { "url": "https://www.reddit.com/r/technology/" },
        { "url": "https://www.reddit.com/r/startups/" }
    ],
    "maxPostCount": 30,
    "maxCommentsPerPost": 5,
    "sort": "top",
    "time": "week"
}
```

#### Scrape a Direct Post Thread

Collect a single thread and its comments:

```json
{
    "startUrls": [
        {
            "url": "https://www.reddit.com/r/GrowthHacking/comments/1tuorhf/best_inbound_ai_sdr_tools_in_2026_or_are_we_all/"
        }
    ],
    "maxPostCount": 1,
    "maxCommentsPerPost": 50
}
```

#### Scrape a User Feed

Collect recent posts from a Reddit user profile:

```json
{
    "startUrls": [
        { "url": "https://www.reddit.com/user/example_user/" }
    ],
    "maxPostCount": 15,
    "skipComments": true
}
```

***

### Sample Output

```json
{
    "dataType": "comment",
    "id": "t1_opaxdor",
    "parsedId": "opaxdor",
    "url": "https://www.reddit.com/r/GrowthHacking/comments/1tuorhf/best_inbound_ai_sdr_tools_in_2026_or_are_we_all/opaxdor/",
    "permalink": "/r/GrowthHacking/comments/1tuorhf/best_inbound_ai_sdr_tools_in_2026_or_are_we_all/opaxdor/",
    "parentId": "t3_1tuorhf",
    "postId": "t3_1tuorhf",
    "parsedPostId": "1tuorhf",
    "postTitle": "Best inbound ai sdr tools in 2026 or are we all just paying for better dashboards?",
    "postAuthor": "GoldTap9957",
    "postUrl": "https://www.reddit.com/r/GrowthHacking/comments/1tuorhf/best_inbound_ai_sdr_tools_in_2026_or_are_we_all/",
    "username": "LeaderAtLeading",
    "userId": "t2_2c0mv5otpl",
    "communityName": "r/GrowthHacking",
    "parsedCommunityName": "GrowthHacking",
    "subredditId": "t5_2vpgj",
    "body": "Most are dashboards with LLMs glued on. Real signal is still manual to verify.",
    "html": "<div class=\"md\"><p>Most are dashboards with LLMs glued on. Real signal is still manual to verify.</p></div>",
    "depth": 0,
    "upVotes": 1,
    "ups": 1,
    "downs": 0,
    "controversiality": 0,
    "totalAwardsReceived": 0,
    "isSubmitter": false,
    "isStickied": false,
    "isLocked": false,
    "isArchived": false,
    "isCollapsed": false,
    "authorIsBlocked": false,
    "authorPremium": true,
    "createdAt": "2026-06-02T12:06:29.000Z",
    "scrapedAt": "2026-06-02T13:43:02.535Z",
    "sourceUrl": "https://www.reddit.com/r/GrowthHacking",
    "retrievalSource": "comment_thread"
}
```

***

### Tips for Best Results

#### Choose Strong Source URLs

- Use direct subreddit, user, or post URLs from `www.reddit.com`
- Start with a small `maxPostCount` when validating a new target
- Use direct post URLs when you care most about one specific thread

#### Control Dataset Size

- Keep `maxCommentsPerPost` low for fast monitoring runs
- Increase comment limits only when thread depth matters to your analysis
- Use `skipComments: true` when you only need post-level data

#### Improve Signal Quality

- Use `sort: "top"` with a `time` filter for high-engagement posts
- Use `maxPostAgeDays` to focus on fresh discussions
- Leave `includeNSFW` disabled unless that content is required

#### Proxy Configuration

For larger or more sensitive runs, configure Apify Proxy in the actor input:

```json
{
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

***

### Integrations

Connect your Reddit dataset with:

- **Google Sheets** — Review community activity in a familiar spreadsheet workflow
- **Airtable** — Build searchable records of posts and comments
- **Slack** — Share noteworthy thread activity with your team
- **Webhooks** — Send new records into your own systems
- **Make** — Automate monitoring and reporting flows
- **Zapier** — Trigger downstream actions from dataset exports

#### Export Formats

- **JSON** — For structured application workflows
- **CSV** — For spreadsheets and bulk analysis
- **Excel** — For reporting and review
- **XML** — For system integrations that require XML

***

### Frequently Asked Questions

#### What kinds of Reddit URLs can I use?

You can provide subreddit URLs, user profile URLs, or direct thread URLs. Mixed inputs are supported in the same run.

#### Does the actor collect comments?

Yes. Comments are collected for saved posts unless you set `skipComments` to `true` or set `maxCommentsPerPost` to `0`.

#### How are duplicate records handled?

The actor tracks seen post and comment IDs during the run and skips repeat records before saving them.

#### Why do some fields appear only on certain items?

Reddit does not expose every field on every post or comment. Empty values are omitted from saved records to keep the dataset cleaner.

#### Can I focus on only recent posts?

Yes. Use `maxPostAgeDays` to restrict the run to newer posts.

#### What happens when a thread has more hidden comments?

The actor continues expanding thread comments until it reaches your per-post comment limit or the thread has no more retrievable comments.

#### Do I need a proxy for every run?

Not always. Smaller local runs can work without a proxy, while larger or repeated collection is more reliable with Apify Proxy enabled.

***

### Support

For issues or feature requests, contact support through the Apify Console.

#### Resources

- [Apify Documentation](https://docs.apify.com/)
- [API Reference](https://docs.apify.com/api/v2)
- [Scheduling Runs](https://docs.apify.com/schedules)

***

### Legal Notice

This actor is designed for legitimate data collection purposes. Users are responsible for ensuring compliance with Reddit's terms of service and applicable laws. Use data responsibly and respect platform limits.

# Actor input Schema

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

List of Reddit URLs to scrape. Supports subreddits (r/example), user profiles (u/username), or specific posts.

## `maxPostCount` (type: `integer`):

Maximum number of posts to scrape across all sources (0-10000).

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

Maximum number of comments to scrape per post (0-1000). Set to 0 to skip comments entirely.

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

Skip scraping comments from posts to speed up the process.

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

How to sort posts and search results.

## `time` (type: `string`):

Time range for sorting (only applies to 'top' and 'comments' sort).

## `includeNSFW` (type: `boolean`):

Include NSFW (Not Safe For Work) posts in results.

## `maxPostAgeDays` (type: `integer`):

Only scrape posts created within the last N days. Leave empty for no age limit.

## `proxy` (type: `object`):

Proxy settings for the scraper. Recommended for high-volume scraping to avoid rate limits.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/programming/"
    },
    {
      "url": "https://www.reddit.com/r/funny/"
    },
    {
      "url": "https://www.reddit.com/u/someuser/"
    }
  ],
  "maxPostCount": 4,
  "maxCommentsPerPost": 2,
  "skipComments": false,
  "sort": "new",
  "time": "all",
  "includeNSFW": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.reddit.com/r/GrowthHacking/"
        }
    ],
    "maxPostCount": 4,
    "maxCommentsPerPost": 2,
    "skipComments": false,
    "sort": "new",
    "time": "all",
    "includeNSFW": false,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahidirfan/reddit-community-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.reddit.com/r/GrowthHacking/" }],
    "maxPostCount": 4,
    "maxCommentsPerPost": 2,
    "skipComments": False,
    "sort": "new",
    "time": "all",
    "includeNSFW": False,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("shahidirfan/reddit-community-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": [
    {
      "url": "https://www.reddit.com/r/GrowthHacking/"
    }
  ],
  "maxPostCount": 4,
  "maxCommentsPerPost": 2,
  "skipComments": false,
  "sort": "new",
  "time": "all",
  "includeNSFW": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call shahidirfan/reddit-community-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Community Scraper 👾",
        "description": "Efficiently extract detailed data from Reddit communities and subreddits. This lightweight actor is designed for speed and simplicity. For optimal performance and to minimize the risk of rate limiting or blocking, the use of residential proxies is highly recommended.",
        "version": "0.0",
        "x-build-id": "8mentglurTCqudbL0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shahidirfan~reddit-community-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shahidirfan-reddit-community-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/shahidirfan~reddit-community-scraper/runs": {
            "post": {
                "operationId": "runs-sync-shahidirfan-reddit-community-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/shahidirfan~reddit-community-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-shahidirfan-reddit-community-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": "List of Reddit URLs to scrape. Supports subreddits (r/example), user profiles (u/username), or specific posts.",
                        "default": [
                            {
                                "url": "https://www.reddit.com/r/GrowthHacking/"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxPostCount": {
                        "title": "📊 Maximum Posts",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of posts to scrape across all sources (0-10000).",
                        "default": 4
                    },
                    "maxCommentsPerPost": {
                        "title": "💬 Comments Per Post",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of comments to scrape per post (0-1000). Set to 0 to skip comments entirely.",
                        "default": 2
                    },
                    "skipComments": {
                        "title": "🚫 Skip Comments",
                        "type": "boolean",
                        "description": "Skip scraping comments from posts to speed up the process.",
                        "default": false
                    },
                    "sort": {
                        "title": "📈 Sort Order",
                        "enum": [
                            "hot",
                            "new",
                            "top",
                            "rising",
                            "relevance",
                            "best",
                            "comments"
                        ],
                        "type": "string",
                        "description": "How to sort posts and search results.",
                        "default": "new"
                    },
                    "time": {
                        "title": "⏰ Time Filter",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time range for sorting (only applies to 'top' and 'comments' sort).",
                        "default": "all"
                    },
                    "includeNSFW": {
                        "title": "🔞 Include NSFW Content",
                        "type": "boolean",
                        "description": "Include NSFW (Not Safe For Work) posts in results.",
                        "default": false
                    },
                    "maxPostAgeDays": {
                        "title": "📅 Maximum Post Age",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only scrape posts created within the last N days. Leave empty for no age limit."
                    },
                    "proxy": {
                        "title": "🌐 Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper. Recommended for high-volume scraping to avoid rate limits."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
