# Reddit Comment Scraper — Posts, Subreddits & Keywords (`brilliant_gum/reddit-comment-scraper`) Actor

Scrape Reddit comments from any post URL, subreddit feed, or keyword search. Full nested threads, 24 metadata fields per comment, built-in analytics report. No API key, no browser, 512 MB RAM.

- **URL**: https://apify.com/brilliant\_gum/reddit-comment-scraper.md
- **Developed by:** [Yuliia Kulakova](https://apify.com/brilliant_gum) (community)
- **Categories:** Social media, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 comment scrapeds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Reddit Comment Scraper — Posts, Subreddits & Keywords

> **Extract Reddit comments at scale.** Full nested threads, rich metadata, analytics report. No API key, no browser, fits in 512 MB RAM.

![Reddit Comment Scraper](https://i.imgur.com/DtdTSyl.png)

---

### 🚀 What this scraper does

Reddit's comments are gold — for market research, brand sentiment, content ideas, AI training data, social listening. But Reddit's official API is rate-limited, requires authentication, and skips half the metadata you actually want.

This actor gives you **everything Reddit shows on the page** — in clean structured JSON — without an API key, without spinning up a browser, and at a price that scales.

✅ **Three ways to find comments** — by post URL, subreddit feed, or keyword search across all of Reddit
✅ **Full nested threads** — every reply, every depth level, parent-child relationships preserved
✅ **Rich metadata** — 24 fields per comment including score, controversiality, awards, edits, deletion status, and more
✅ **Built-in analytics report** — community insights computed automatically and saved alongside the data
✅ **Fast and lean** — runs in 512 MB RAM, no headless browser, no slow Selenium-style waits

---

### 💡 Use cases

| Who | How they use it |
|---|---|
| **Market researchers** | Track what real users say about products, competitors, pricing |
| **Brand managers** | Monitor mentions of your brand across thousands of subreddits |
| **Content creators** | Find trending discussions, popular questions, hot takes |
| **AI / ML teams** | Build training datasets of authentic human conversations |
| **SEO specialists** | Discover what your audience actually asks and cares about |
| **Investors** | Track retail sentiment on stocks, crypto, IPOs in real time |
| **Academics** | Sociology, linguistics, political science research |

---

### 📥 Three ways to give it a target

You can mix-and-match any of these in a single run.

#### Mode 1 — Direct URLs

Paste any Reddit URL. The scraper figures out whether it's a post, a subreddit feed, or a search page.

```json
{
  "startUrls": [
    { "url": "https://www.reddit.com/r/AskReddit/comments/1u003hr/" },
    { "url": "https://www.reddit.com/r/programming/" }
  ]
}
````

#### Mode 2 — Subreddit feeds

Just list the subreddit names. The actor pulls the latest posts and scrapes all their comments.

```json
{
  "subreddits": ["AskReddit", "MachineLearning", "investing"],
  "postSort": "hot",
  "postTime": "week",
  "maxPostsPerSource": 25
}
```

#### Mode 3 — Keyword search

Search across all of Reddit, or within specific subreddits.

```json
{
  "keywords": ["chatgpt", "claude code", "anthropic"],
  "subreddits": ["LocalLLaMA", "OpenAI"],
  "maxPostsPerSource": 10
}
```

If you only provide keywords without subreddits, the actor searches globally across Reddit.

***

### 🎛️ Filters that actually work

Every filter has been tested end-to-end.

| Filter | What it does |
|---|---|
| `minScore` | Skip low-quality comments below this upvote count |
| `maxDepth` | Limit nesting (1 = top-level only, 2 = top + one reply level, 0 = unlimited) |
| `maxCommentsPerPost` | Cap comments per post so a megathread doesn't blow your budget |
| `excludeDeleted` | Drop `[deleted]` and `[removed]` comments |
| `includeNSFW` | Opt in to NSFW subreddits (default: skipped) |
| `commentSort` | top / new / controversial / old / qa / confidence |
| `postSort` | hot / top / new / relevance / comments / controversial |
| `postTime` | hour / day / week / month / year / all |

***

### 📤 What you get back

One dataset item per comment with **24 fields**:

| Field | Type | Description |
|---|---|---|
| `id` | string | Reddit comment ID |
| `postId` | string | ID of the parent post |
| `postTitle` | string | Title of the parent post |
| `postUrl` | string | Full URL of the parent post |
| `postScore` | number | Score of the parent post |
| `subreddit` | string | e.g. `AskReddit` |
| `subredditPrefixed` | string | e.g. `r/AskReddit` |
| `author` | string | Reddit username |
| `body` | string | Comment text (markdown) |
| `score` | number | Net upvotes (upvotes minus downvotes) |
| `controversiality` | number | `1` if Reddit flagged the comment as controversial |
| `totalAwards` | number | Awards received |
| `depth` | number | Nesting depth (0 = top-level reply to the post) |
| `parentId` | string | ID of the parent comment or post |
| `isTopLevel` | boolean | True if this is a direct reply to the post |
| `isSubmitter` | boolean | True if the author is the post's OP |
| `isStickied` | boolean | True for moderator-pinned comments |
| `distinguished` | string | null | `"moderator"`, `"admin"`, or null |
| `isDeleted` | boolean | True if the comment was deleted by the user or removed by moderators |
| `postedAt` | ISO date | When the comment was posted |
| `editedAt` | ISO date | null | When the comment was last edited (null if never) |
| `scrapedAt` | ISO date | When the scraper saw it |
| `permalink` | string | Direct link to the comment on Reddit |
| `matchedKeyword` | string | null | Which of your keywords matched (for keyword-search mode) |

#### Example output

```json
{
  "id": "oqen70z",
  "postId": "1u003hr",
  "postTitle": "What movie plot hole is so massive that it completely ruins the story?",
  "postUrl": "https://www.reddit.com/r/AskReddit/comments/1u003hr/...",
  "postScore": 1300,
  "subreddit": "AskReddit",
  "subredditPrefixed": "r/AskReddit",
  "author": "TheAmazingSealo",
  "body": "The Butterfly Effect breaks its own rules and logic...",
  "score": 3003,
  "controversiality": 0,
  "totalAwards": 0,
  "depth": 0,
  "parentId": "1u003hr",
  "isTopLevel": true,
  "isSubmitter": false,
  "isStickied": false,
  "distinguished": null,
  "isDeleted": false,
  "postedAt": "2026-06-08T07:02:55.000Z",
  "editedAt": "2026-06-08T08:10:16.000Z",
  "scrapedAt": "2026-06-08T13:21:29.916Z",
  "permalink": "https://www.reddit.com/r/AskReddit/comments/1u003hr/.../oqen70z/",
  "matchedKeyword": null
}
```

***

### 📊 Bonus: analytics report

Set `includeAnalytics: true` (it's on by default) and the actor computes a community insights report alongside the raw data. Saved as `ANALYTICS` in the run's Key-Value store.

What's inside:

- 📈 Total posts and comments processed
- ⭐ Average comment score
- 🏆 Top commenters by volume and by score
- 🔥 Hottest threads (highest engagement)
- 😡 Most controversial threads
- 📊 Distribution of comments by depth, score buckets, time-of-day

Perfect for one-glance overviews and dashboards. No extra setup — just one toggle.

***

### ⚙️ Quick start

1. **Pick a target.** A subreddit name, a post URL, a keyword — anything that interests you.
2. **Set limits.** `maxPostsPerSource: 5` and `maxCommentsPerPost: 100` are reasonable starting values.
3. **Click Run.** Results stream into the dataset as they're scraped.

That's it. No tokens to fetch, no proxies to configure (the default works), no schema to learn.

***

### 💰 Pricing

Pay only for what you use:

| Event | Price |
|---|---|
| Actor start | $0.01 per run |
| Comment scraped | $2.00 per 1,000 comments ($0.002 each) |

**Example runs:**

- 100 comments → $0.21
- 500 comments → $1.01
- 5,000 comments → $10.01
- 100,000 comments → $200.01

Apify platform usage (compute, proxy, storage) is billed separately by Apify at standard platform rates. The actor runs in 512 MB RAM with no headless browser, so platform costs stay low.

***

### ❓ FAQ

**Do I need a Reddit account or API key?**
No. The scraper works on Reddit's public data — anything visible without logging in.

**Will it get my IP banned?**
The actor ships configured to use Apify Residential proxies, which rotate IPs automatically. You can override with your own proxy in the input.

**How fresh is the data?**
Real-time. The scraper reads Reddit's live data — comments posted minutes ago are already in the results.

**Does it handle deleted comments?**
Yes. Deleted comments are flagged with `isDeleted: true` so you keep the tree structure intact. Opt out with `excludeDeleted: true`.

**Can I scrape NSFW subreddits?**
Yes, but you have to opt in with `includeNSFW: true`. By default they're skipped.

**What about Reddit's "load more comments" buttons?**
Top comments are always returned. Very deep tail threads (beyond what Reddit returns in one shot) are noted in the log but not auto-expanded by default — increase `maxCommentsPerPost` to pull more.

**Can I run scheduled scrapes?**
Yes. Use Apify's built-in Schedules. Great for daily brand-mention digests or weekly sentiment snapshots.

**Will old.reddit.com / new.reddit.com URLs both work?**
Both. Also `redd.it` short links and mobile `.compact` URLs.

**Does the actor work for private subreddits?**
No — private subreddits require authenticated access. Public and quarantined-but-visible subs work fine.

***

### 🛠️ Author

Maintained by **brilliant\_gum**.

Bug reports, feature requests, custom-scrape needs → open an issue on this actor.

If this saved you time, leave a ⭐ — it helps other Reddit researchers find the tool.

# Actor input Schema

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

Direct Reddit post URLs (to scrape their comments) or subreddit URLs (to scrape the feed then comments). Example: https://www.reddit.com/r/Python/comments/abc123/...

## `subreddits` (type: `array`):

Subreddit names to scrape (e.g. "python" or "r/MachineLearning"). Fetches recent posts then collects their comments.

## `keywords` (type: `array`):

Search keywords. Finds posts matching these terms across Reddit (or within specified subreddits) and collects their comments.

## `postSort` (type: `string`):

Sort order for posts when using subreddit or keyword mode. Note: 'controversial' applies only to subreddit feeds (Reddit's search API ignores it).

## `postTime` (type: `string`):

Time period for posts (applies to top/relevance sort).

## `commentSort` (type: `string`):

How comments are sorted within each post.

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

Maximum number of posts to process per subreddit or keyword. Higher values = more comments but longer runtime.

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

Maximum number of comments to collect per post (0 = no limit, collect all available).

## `maxDepth` (type: `integer`):

Maximum nesting depth. 0 = all levels. 1 = top-level comments only. 2 = top-level + one reply level.

## `minScore` (type: `integer`):

Skip comments with fewer upvotes than this value. Useful for filtering low-quality comments.

## `excludeDeleted` (type: `boolean`):

Skip comments where the content or author has been deleted or removed by moderators.

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

Include comments from posts marked as Not Safe For Work.

## `includeAnalytics` (type: `boolean`):

Generate a community insights report and save it to the Key-Value store under the key ANALYTICS.

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

Reddit blocks datacenter IPs. Apify Residential proxy is strongly recommended for reliable results.

## `requestDelayMs` (type: `integer`):

Milliseconds to wait between requests. Increase to 1000+ for large runs to avoid rate limiting.

## Actor input object example

```json
{
  "startUrls": [],
  "subreddits": [
    "AskReddit"
  ],
  "keywords": [],
  "postSort": "hot",
  "postTime": "week",
  "commentSort": "top",
  "maxPostsPerSource": 5,
  "maxCommentsPerPost": 100,
  "maxDepth": 0,
  "minScore": 0,
  "excludeDeleted": false,
  "includeNSFW": false,
  "includeAnalytics": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "requestDelayMs": 500
}
```

# Actor output Schema

## `results` (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": [],
    "subreddits": [
        "AskReddit"
    ],
    "keywords": [],
    "maxPostsPerSource": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("brilliant_gum/reddit-comment-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": [],
    "subreddits": ["AskReddit"],
    "keywords": [],
    "maxPostsPerSource": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("brilliant_gum/reddit-comment-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": [],
  "subreddits": [
    "AskReddit"
  ],
  "keywords": [],
  "maxPostsPerSource": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call brilliant_gum/reddit-comment-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Comment Scraper — Posts, Subreddits & Keywords",
        "description": "Scrape Reddit comments from any post URL, subreddit feed, or keyword search. Full nested threads, 24 metadata fields per comment, built-in analytics report. No API key, no browser, 512 MB RAM.",
        "version": "1.0",
        "x-build-id": "GXpIMOVC92NXTZCAd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/brilliant_gum~reddit-comment-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-brilliant_gum-reddit-comment-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/brilliant_gum~reddit-comment-scraper/runs": {
            "post": {
                "operationId": "runs-sync-brilliant_gum-reddit-comment-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/brilliant_gum~reddit-comment-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-brilliant_gum-reddit-comment-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": {
                    "startUrls": {
                        "title": "Post / Subreddit URLs",
                        "type": "array",
                        "description": "Direct Reddit post URLs (to scrape their comments) or subreddit URLs (to scrape the feed then comments). Example: https://www.reddit.com/r/Python/comments/abc123/...",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "subreddits": {
                        "title": "Subreddits",
                        "type": "array",
                        "description": "Subreddit names to scrape (e.g. \"python\" or \"r/MachineLearning\"). Fetches recent posts then collects their comments.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Search keywords. Finds posts matching these terms across Reddit (or within specified subreddits) and collects their comments.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postSort": {
                        "title": "Post sort",
                        "enum": [
                            "relevance",
                            "new",
                            "hot",
                            "top",
                            "comments",
                            "controversial"
                        ],
                        "type": "string",
                        "description": "Sort order for posts when using subreddit or keyword mode. Note: 'controversial' applies only to subreddit feeds (Reddit's search API ignores it).",
                        "default": "hot"
                    },
                    "postTime": {
                        "title": "Post time filter",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time period for posts (applies to top/relevance sort).",
                        "default": "week"
                    },
                    "commentSort": {
                        "title": "Comment sort",
                        "enum": [
                            "top",
                            "new",
                            "controversial",
                            "old",
                            "qa",
                            "confidence"
                        ],
                        "type": "string",
                        "description": "How comments are sorted within each post.",
                        "default": "top"
                    },
                    "maxPostsPerSource": {
                        "title": "Max posts per source",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of posts to process per subreddit or keyword. Higher values = more comments but longer runtime.",
                        "default": 25
                    },
                    "maxCommentsPerPost": {
                        "title": "Max comments per post",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of comments to collect per post (0 = no limit, collect all available).",
                        "default": 100
                    },
                    "maxDepth": {
                        "title": "Max comment depth",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum nesting depth. 0 = all levels. 1 = top-level comments only. 2 = top-level + one reply level.",
                        "default": 0
                    },
                    "minScore": {
                        "title": "Min comment score",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip comments with fewer upvotes than this value. Useful for filtering low-quality comments.",
                        "default": 0
                    },
                    "excludeDeleted": {
                        "title": "Exclude deleted / removed",
                        "type": "boolean",
                        "description": "Skip comments where the content or author has been deleted or removed by moderators.",
                        "default": false
                    },
                    "includeNSFW": {
                        "title": "Include NSFW posts",
                        "type": "boolean",
                        "description": "Include comments from posts marked as Not Safe For Work.",
                        "default": false
                    },
                    "includeAnalytics": {
                        "title": "Include analytics report",
                        "type": "boolean",
                        "description": "Generate a community insights report and save it to the Key-Value store under the key ANALYTICS.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Reddit blocks datacenter IPs. Apify Residential proxy is strongly recommended for reliable results."
                    },
                    "requestDelayMs": {
                        "title": "Request delay (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Milliseconds to wait between requests. Increase to 1000+ for large runs to avoid rate limiting.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
