# Reddit Comment Scraper - Export Comments & Replies ($1.5/1k) (`harshmaur/reddit-comments-scraper`) Actor

Scrape Reddit comments without the API — every comment and nested reply from any post URL, 'load more comments' expanded automatically. Export to CSV, Excel, or JSON for sentiment analysis, AI training data, or research. No login, no rate limits. From $1.50 per 1,000 comments.

- **URL**: https://apify.com/harshmaur/reddit-comments-scraper.md
- **Developed by:** [Harsh Maur](https://apify.com/harshmaur) (community)
- **Categories:** AI, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 83.3% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.50 / 1,000 result saveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Comments Scraper — Download Every Comment From Any Reddit Post (No API)

<p align="center">
  <strong>Paste a Reddit post URL, get the post plus its entire comment tree — nested replies included, "load more comments" expanded automatically. No API key, no login. From $1.50 per 1,000 results.</strong>
</p>

<p align="center">
  <a href="https://apify.com/harshmaur/reddit-comments-scraper">
    <img src="https://img.shields.io/badge/Apify-Try%20Now-00C7B7?style=for-the-badge&logo=apify" alt="Try on Apify">
  </a>
  <a href="https://apify.com/harshmaur/reddit-comments-scraper/input-schema">
    <img src="https://img.shields.io/badge/Input-Schema-blue?style=for-the-badge" alt="Input Schema">
  </a>
  <a href="https://apify.com/harshmaur/reddit-comments-scraper/api">
    <img src="https://img.shields.io/badge/API-Docs-orange?style=for-the-badge" alt="API Docs">
  </a>
</p>

<p align="center">
  <a href="#what-does-reddit-comments-scraper-do">What it does</a> •
  <a href="#how-to-scrape-reddit-comments">How to use</a> •
  <a href="#input-example">Input</a> •
  <a href="#output-example">Output</a> •
  <a href="#use-cases">Use cases</a> •
  <a href="#pricing">Pricing</a> •
  <a href="#faq">FAQ</a>
</p>

---

### What does Reddit Comments Scraper do? {#what-does-reddit-comments-scraper-do}

**Reddit Comments Scraper** is a purpose-built **reddit comment scraper**: give it one or more post URLs (comment permalinks work too) and it returns the parent post record plus **every comment in the thread, including nested replies**. Where Reddit's website stops at roughly 500 comments per page, this actor keeps going — it expands every "load more comments" placeholder through Reddit's `morechildren` API, routinely pulling **5,000–6,000 comments from a single post** (configurable up to 10,000 via `maxCommentsPerPost`).

There is nothing to configure beyond the URLs. No OAuth app, no Reddit account, no cookies — and none of the official API's 600-requests-per-10-minutes ceiling.

**Why this actor instead of a general Reddit scraper:**

- 💬 **Deep threads, fully expanded** — nested replies and "load more" branches that page-level scrapers miss
- 🧵 **Thread structure preserved** — every comment carries `parentId`, `depth`, and `isSubmitter`, so you can rebuild the reply tree
- 🔓 **Zero authentication** — scrape reddit comments without API keys, logins, or rate limits
- 📤 **Export anywhere** — JSON, CSV, Excel, XML, HTML · n8n, Zapier, Make, REST API, MCP
- 💰 **Pay per result** — from $1.50 per 1,000 comments, no monthly fees

---

### How to scrape Reddit comments {#how-to-scrape-reddit-comments}

Downloading Reddit comments from a post takes about a minute of setup:

1. [Sign up for a free Apify account](https://apify.com/) (or log in)
2. Open [Reddit Comments Scraper](https://apify.com/harshmaur/reddit-comments-scraper)
3. Paste one or more Reddit post URLs into the **Reddit post URLs** field
4. Optionally adjust **Max comments per post** (default 100, up to 10,000)
5. Click **Start** and watch comments stream into the dataset
6. Download the results as JSON, CSV, Excel, XML, or HTML

> 💡 **Tip:** A comment permalink (a link to a single comment inside a thread) is also accepted — the scraper resolves it to the parent post and collects the thread from there.

#### Inputs at a glance

| Field | What it does |
| --- | --- |
| `postUrls` | One or more Reddit post URLs (or comment permalinks) to collect comments from. **Required.** |
| `maxCommentsPerPost` | Cap per post, nested replies included. Default `100`, maximum `10000`. |
| `includeNSFW` | Set `true` to include posts and comments flagged 18+. Default `false`. |
| `proxy` | Proxy settings. Apify residential proxy is preconfigured and recommended. |

That's the entire schema — see the [Input Schema tab](https://apify.com/harshmaur/reddit-comments-scraper/input-schema) for full details.

---

### Input example {#input-example}

This configuration pulls up to 2,000 comments from each of two posts, skipping NSFW content:

```json
{
  "postUrls": [
    {
      "url": "https://www.reddit.com/r/generativeAI/comments/1l64st7/have_we_reached_a_point_where_aigenerated_video/"
    },
    {
      "url": "https://www.reddit.com/r/technology/comments/1example/another_post_to_analyze/"
    }
  ],
  "maxCommentsPerPost": 2000,
  "includeNSFW": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

***

### Output example {#output-example}

Each run produces one `post` item (the parent post) followed by one item per comment. Comment items carry the full thread structure — `parentId` points to the parent comment or post, `depth` tells you how deep in the reply tree the comment sits, and `isSubmitter` flags replies written by the original poster.

Here's a realistic nested-reply comment item (note `depth: 1` and a `parentId` referencing another comment, `t1_...`):

```json
{
  "dataType": "comment",
  "id": "t1_kx9d2fe",
  "parsedId": "kx9d2fe",
  "body": "Disagree — the uncanny valley is still obvious in any clip longer than ten seconds.",
  "bodyHtml": "<p>Disagree — the uncanny valley is still obvious in any clip longer than ten seconds.</p>",
  "authorId": "t2_8fk3la",
  "parsedAuthorId": "8fk3la",
  "authorName": "vfx_skeptic",
  "authorFullname": "t2_8fk3la",
  "authorFlairText": null,
  "authorPremium": false,
  "communityName": "r/generativeAI",
  "parsedCommunityName": "generativeAI",
  "subredditName": "generativeAI",
  "postId": "t3_1l64st7",
  "parsedPostId": "1l64st7",
  "postTitle": "Have we reached a point where AI-generated video is indistinguishable?",
  "postUrl": "https://www.reddit.com/r/generativeAI/comments/1l64st7/",
  "postUpVotes": 873,
  "postCommentsCount": 412,
  "parentId": "t1_kx9bq1a",
  "parsedParentId": "kx9bq1a",
  "parentKind": "comment",
  "depth": 1,
  "isSubmitter": false,
  "url": "https://www.reddit.com/r/generativeAI/comments/1l64st7/comment/kx9d2fe/",
  "score": 156,
  "commentUpVotes": 156,
  "controversiality": 0,
  "totalAwardsReceived": 0,
  "gilded": 0,
  "distinguished": null,
  "stickied": false,
  "scoreHidden": false,
  "collapsed": false,
  "collapsedReason": null,
  "edited": false,
  "editedAt": null,
  "ageHours": 18.4,
  "scorePerHour": 8.48,
  "bodyLength": 84,
  "wordCount": 16,
  "commentCreatedAt": "2025-06-08T11:24:00.000Z",
  "postCreatedAt": "2025-06-08T07:02:00.000Z",
  "crawledAt": "2025-06-09T05:48:00.000Z"
}
```

Top-level comments have `depth: 0` and a `parentId` equal to the post's `t3_` ID with `parentKind: "post"`. The parent `post` item itself ships with the full post field set — `title`, `body`, `score`, `upvoteRatio`, `commentsCount`, flair, flags, media fields, and derived analytics like `engagementTotal` and `commentsPerHour`.

***

### What can you do with scraped Reddit comments? {#use-cases}

- **🎯 Sentiment analysis** — turn a product launch thread or an AMA into thousands of labeled-ready opinions. Reply depth lets you separate hot takes from the debates underneath them.
- **🤖 AI training data** — comment trees are natural conversation data. The `parentId`/`depth` structure makes it trivial to reconstruct dialogue pairs for fine-tuning or RAG corpora.
- **📢 Brand monitoring** — when your company gets mentioned in a viral thread, pull the entire discussion (not just the visible page) and quantify what people actually said.
- **🎓 Academic research** — collect complete, reproducible discussion datasets with timestamps, scores, controversiality, and structural metadata intact for citation and replication.

***

### How much does it cost to scrape Reddit comments? {#pricing}

Reddit Comments Scraper is **pay-per-result**: you're billed per comment stored, starting at **$1.50 per 1,000 results**, with **no monthly subscription and no platform fees**. A 5,000-comment megathread costs about $7.50; a quick 200-comment pull costs pennies.

This model fits comment scraping well because thread sizes vary wildly — you pay for the 6,000-comment AMA when you scrape it, and nothing the rest of the month.

> **💼 Scraping comments continuously at scale?** [**Reddit Scraper Pro**](https://apify.com/harshmaur/reddit-scraper-pro) offers unlimited results on a flat monthly subscription using the same engine.

***

### Export Reddit comments to CSV, Excel, or JSON

Once a run finishes, download the dataset in **JSON, CSV, Excel (XLSX), XML, or HTML** straight from the Apify Console — Reddit comments to CSV is one click. For automated pipelines:

- **REST API** — `POST https://api.apify.com/v2/acts/harshmaur~reddit-comments-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN` with the input JSON as the body
- **n8n / Zapier / Make** — trigger runs and route comment data into sheets, databases, or Slack
- **MCP** — expose the actor as a tool via the [Apify MCP server](https://mcp.apify.com/), so Claude, ChatGPT, Cursor, or any MCP client can fetch a thread's comments mid-conversation

See the [API tab](https://apify.com/harshmaur/reddit-comments-scraper/api) for ready-made code snippets in Node.js, Python, and curl.

***

### FAQ {#faq}

#### Is it legal to scrape Reddit comments?

Comments on public Reddit threads are publicly accessible data, and scraping public data is generally permitted — but you're responsible for using it lawfully. Keep request volumes reasonable, respect Reddit's terms where applicable, handle personal data in line with GDPR/CCPA, and only collect public content. Apify's guide on the [enforceability of website terms](https://blog.apify.com/enforceability-of-terms-of-use/) is a good primer.

#### Can I scrape Reddit comments without the API?

Yes — that's the whole point of this actor. It reads publicly available thread data directly, so there's no OAuth application, no API key, and no 600-requests-per-10-minutes quota. You don't even need a Reddit account.

#### How many comments can I scrape from one post?

Up to **10,000 per post** (`maxCommentsPerPost`). Reddit's own interface serves only ~500 comments per page; this actor automatically expands the "load more comments" placeholders via Reddit's `morechildren` endpoint, so very large threads typically yield 5,000–6,000 comments without you doing anything.

#### Does it capture nested replies, or just top-level comments?

The full tree. Every reply at every level is collected, and each item records its `parentId`, `parentKind`, and `depth` so you can reconstruct the exact thread hierarchy in your own analysis.

#### Can I scrape multiple posts in one run?

Yes. Add as many URLs to `postUrls` as you like — each post is processed with its own `maxCommentsPerPost` budget, and every output item carries `postId` and `postTitle` so mixed datasets stay easy to split.

#### Do I need a proxy?

Yes — proxies keep large comment pulls reliable and prevent IP blocks. The actor comes preconfigured with Apify's residential proxy group, which is the recommended setting; you can also plug in your own proxies via the `proxy` input.

#### What input does it accept — post URLs only?

Standard post URLs (`https://www.reddit.com/r/subreddit/comments/abc123/title/`) and comment permalinks. A permalink is resolved to its parent post and the thread is scraped from there. Subreddit pages, user profiles, and search URLs are not accepted — for those, use one of the [other Reddit scrapers below](#more-reddit-scrapers).

#### Can I export the comments to a spreadsheet?

Yes. Every dataset can be downloaded as CSV or Excel (plus JSON, XML, and HTML) directly from the platform, or fetched in any of those formats through the API for automated exports.

***

### More Reddit scrapers {#more-reddit-scrapers}

This actor does one thing deeply. If your job is broader, pick the right tool:

| Actor | Use it when |
| --- | --- |
| [Reddit Scraper](https://apify.com/harshmaur/reddit-scraper) | You want the all-in-one: posts, comments, subreddits, search, and user profiles in a single configurable actor. |
| [Reddit Search Scraper](https://apify.com/harshmaur/reddit-search-scraper) | You're starting from keywords, not URLs — find posts and discussions across all of Reddit by search term. |
| [Reddit User Scraper](https://apify.com/harshmaur/reddit-user-scraper) | You need a specific user's profile, post history, and comment history rather than a thread. |
| [Subreddit Scraper](https://apify.com/harshmaur/reddit-subreddit-scraper) | You want to pull an entire community's posts in bulk instead of drilling into individual threads. |

***

<p align="center">
  <a href="https://apify.com/harshmaur/reddit-comments-scraper">
    <img src="https://img.shields.io/badge/🚀_Try_Reddit_Comments_Scraper-00C7B7?style=for-the-badge" alt="Try Reddit Comments Scraper">
  </a>
</p>

<p align="center">
  <sub>Built by <a href="https://github.com/harshmaur">Harsh Maur</a> • Questions? <a href="mailto:harshmaur@gmail.com">Contact support</a></sub>
</p>

# Actor input Schema

## `postUrls` (type: `array`):

Add one or more Reddit post URLs to scrape comments from. Post URLs look like https://www.reddit.com/r/subreddit/comments/abc123/title/. Comment permalinks also work.

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

Maximum number of comments to collect per post, including nested replies. Reddit returns ~500 comments per page; everything beyond that is expanded automatically via the 'load more comments' API.

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

Include posts and comments marked as Not Safe For Work.

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

Either use Apify proxy, or provide your own proxy servers.

## Actor input object example

```json
{
  "postUrls": [
    {
      "url": "https://www.reddit.com/r/generativeAI/comments/1l64st7/have_we_reached_a_point_where_aigenerated_video/"
    }
  ],
  "maxCommentsPerPost": 100,
  "includeNSFW": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped Reddit data including posts, comments, communities, and user profiles. Use 'dataType' field to filter by type.

# 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 = {
    "postUrls": [
        {
            "url": "https://www.reddit.com/r/generativeAI/comments/1l64st7/have_we_reached_a_point_where_aigenerated_video/"
        }
    ],
    "maxCommentsPerPost": 100,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("harshmaur/reddit-comments-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 = {
    "postUrls": [{ "url": "https://www.reddit.com/r/generativeAI/comments/1l64st7/have_we_reached_a_point_where_aigenerated_video/" }],
    "maxCommentsPerPost": 100,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("harshmaur/reddit-comments-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 '{
  "postUrls": [
    {
      "url": "https://www.reddit.com/r/generativeAI/comments/1l64st7/have_we_reached_a_point_where_aigenerated_video/"
    }
  ],
  "maxCommentsPerPost": 100,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call harshmaur/reddit-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Comment Scraper - Export Comments & Replies ($1.5/1k)",
        "description": "Scrape Reddit comments without the API — every comment and nested reply from any post URL, 'load more comments' expanded automatically. Export to CSV, Excel, or JSON for sentiment analysis, AI training data, or research. No login, no rate limits. From $1.50 per 1,000 comments.",
        "version": "0.0",
        "x-build-id": "Jnrk2gHyLx8sJNGPx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/harshmaur~reddit-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-harshmaur-reddit-comments-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/harshmaur~reddit-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-harshmaur-reddit-comments-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/harshmaur~reddit-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-harshmaur-reddit-comments-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": [
                    "postUrls"
                ],
                "properties": {
                    "postUrls": {
                        "title": "Reddit post URLs",
                        "type": "array",
                        "description": "Add one or more Reddit post URLs to scrape comments from. Post URLs look like https://www.reddit.com/r/subreddit/comments/abc123/title/. Comment permalinks also work.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxCommentsPerPost": {
                        "title": "Max comments per post",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of comments to collect per post, including nested replies. Reddit returns ~500 comments per page; everything beyond that is expanded automatically via the 'load more comments' API.",
                        "default": 100
                    },
                    "includeNSFW": {
                        "title": "Include NSFW (18+) content",
                        "type": "boolean",
                        "description": "Include posts and comments marked as Not Safe For Work.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Either use Apify proxy, or provide your own proxy servers.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
