# Reddit Scraper | 6 Modes + Comments | $1/1K Results (`smrtai-ops/reddit-scraper`) Actor

Scrape posts, full comment threads, and keyword searches from any subreddit, user profile, or community. 6 modes: Hot, New, Top, Rising, Search & Archive. Stealth anti-detection browsing. No API key or login needed. Ideal for market research, AI training, and competitor analysis.

- **URL**: https://apify.com/smrtai-ops/reddit-scraper.md
- **Developed by:** [Smrt AI](https://apify.com/smrtai-ops) (community)
- **Categories:** AI, Developer tools, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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 Scraper — Posts, Comments & Keyword Search | $1/1K Results

Scrape Reddit posts, comments, and user profiles from any public subreddit, user, or community. This Reddit data extraction tool supports 5 scraping modes — Hot, New, Top, Rising, and Search — with full comment threads, engagement metrics, and stealth anti-detection browsing. No Reddit API key or login required.

### What does Reddit Scraper do?

Our Reddit Scraper extracts structured data from any public subreddit, user profile, or community with human-like browsing behavior that avoids detection. It is **4x cheaper** than leading alternatives and delivers clean, structured JSON output ready for analysis, AI training, or business intelligence.

Reddit Scraper allows you to:

- Scrape any **subreddit** (community) with posts sorted by Hot, New, Top, Rising, or keyword Search
- Extract **full comment threads** with author info, timestamps, and vote counts
- Scrape **user profiles** — their posts, comments, and activity
- **Search by keywords** within specific subreddits to find exactly what you need
- Deep **archive scraping** for historical data collection with cursor-based pagination
- Run with **stealth anti-detection** — human-like scrolling, viewport randomization, and natural delays

### What data can I extract from Reddit?

| 📌 Post Data | 💬 Comment Data | 📊 Engagement Metrics |
|---|---|---|
| `id` — Reddit post ID | `comments_text` — Full thread text | `score` — Upvotes minus downvotes |
| `title` — Post title | `comments_count_fetched` — ## extracted | `num_comments` — Total comment count |
| `content` — Full post body | Author and timestamps | `upvote_ratio` — % upvoted |
| `author` — Username | Thread URLs | `controversy_score` — Controversy metric |
| `author_url` — Profile link | — | `awards` — Award count |
| `url` — Full post URL | — | — |
| `permalink` — Short path | — | — |
| `flair` — Post category tag | — | — |
| `created_at` — ISO timestamp | — | — |
| `created_utc` — Unix timestamp | — | — |
| `external_url` — Linked URL | — | — |
| `is_self` — Text post flag | — | — |
| `is_stickied` — Pinned flag | — | — |

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

| Plan | Price | What you get |
|---|---|---|
| **Free** | $0 | Use your Apify free credits (~5,000 results/month) |
| **Basic** | **$1 per 1,000 results** | All 5 modes + full comments + user profiles |
| **Enterprise** | Contact us | Archive mode, monitoring mode, bulk scraping, dedicated support |

> 💡 **4x cheaper than alternatives.** Most Reddit scrapers charge $4/1K results. Ours delivers the same data for $1/1K — with stealth anti-detection included.

### Scraping Modes

| Mode | Description | Best For |
|---|---|---|
| 🔥 **Hot** | Currently trending posts | Real-time brand monitoring |
| 🆕 **New** | Most recently published posts | Catching fresh discussions |
| ⬆️ **Top** | Highest voted posts (with time filter) | Finding best content |
| 📈 **Rising** | Posts rapidly gaining traction | Early trend detection |
| 🔍 **Search** | Keyword search within subreddits | Targeted market research |
| 🗄️ **Archive** ⭐ | Deep historical scraping with pagination | Enterprise only — coming soon |
| 🔄 **Monitoring** ⭐ | Real-time alerts on new posts | Enterprise only — coming soon |

### How to scrape Reddit

No coding skills required:

1. **Create** a free Apify account
2. **Open** the Reddit Scraper
3. **Add** one or more subreddits, usernames, or keywords
4. **Select** your scraping mode (Hot, New, Top, Rising, or Search)
5. **Click "Start"** and wait for results
6. **Download** your data in JSON, CSV, XML, Excel, or HTML format

### Use Cases

- 🔍 **Market Research** — Monitor subreddits for product feedback, feature requests, and user sentiment
- 🎯 **Pain Point Detection** — Find complaints and frustrations in niche communities to validate startup ideas
- 📊 **Competitor Analysis** — Track mentions of competitor brands and products across Reddit
- 💡 **Content Research** — Find trending topics, viral content patterns, and engagement drivers
- 🔬 **Academic Research** — Collect structured data from specific communities for studies
- 🤖 **AI & LLM Training** — Gather real-world conversational data for model fine-tuning
- 📣 **PR & Reputation** — Automatically track mentions of your brand or product

### Input Examples

#### Scrape multiple subreddits (Hot posts)

```json
{
    "subreddits": ["SaaS", "startups", "programming"],
    "mode": "hot",
    "limit": 20,
    "fetch_comments": true,
    "humanizer_preset": "normal"
}
````

#### Search by keywords within a subreddit

```json
{
    "subreddits": ["marketing"],
    "mode": "search",
    "keywords": ["growth hacking", "SEO tools"],
    "limit": 50,
    "fetch_comments": false
}
```

#### Scrape user profiles

```json
{
    "users": ["spez", "GovSchwarzenegger"],
    "mode": "posts",
    "limit": 30,
    "fetch_comments": true
}
```

#### Top posts of the month

```json
{
    "subreddits": ["technology", "science"],
    "mode": "top",
    "time_filter": "month",
    "limit": 100,
    "fetch_comments": false
}
```

### Output Examples

#### 📝 Reddit Post (without comments)

```json
{
    "id": "t3_1tdrx3c",
    "title": "Am I crazy or is this workload impossible in 25 hours a month?",
    "content": "I freelance for a startup doing social media + some community work...",
    "author": "Ok_Eye_8974",
    "author_url": "https://www.reddit.com/user/Ok_Eye_8974",
    "subreddit": "marketing",
    "url": "https://www.reddit.com/r/marketing/comments/1tdrx3c/am_i_crazy_or_is_this_workload_impossible_in_25/",
    "permalink": "/r/marketing/comments/1tdrx3c/am_i_crazy_or_is_this_workload_impossible_in_25/",
    "created_at": "2026-05-15T10:11:32+00:00",
    "created_utc": 1778839892.0,
    "score": 15,
    "num_comments": 18,
    "upvote_ratio": 0.95,
    "flair": "Question",
    "awards": 0,
    "external_url": null,
    "scrape_mode": "hot",
    "source_platform": "reddit",
    "scraped_at": "2026-05-15T19:03:36.850288+00:00"
}
```

#### 💬 Reddit Post (with comments)

```json
{
    "id": "t3_1tdrx3c",
    "title": "Am I crazy or is this workload impossible in 25 hours a month?",
    "content": "I freelance for a startup doing social media...",
    "author": "Ok_Eye_8974",
    "subreddit": "marketing",
    "score": 15,
    "num_comments": 18,
    "scrape_mode": "hot",
    "comments_count_fetched": 13,
    "comments": [
        {
            "author": "SoftResetMode15",
            "score": 16,
            "body": "25 hours disappears really fast once calls, revisions, comments, research, and random coordination get layered in.",
            "depth": 0
        },
        {
            "author": "janenotdaria",
            "score": 5,
            "body": "They know it's a full time job, they want you to work the remaining 15 hours for free.",
            "depth": 0
        },
        {
            "author": "ColdIsMyMaster",
            "score": 4,
            "body": "Imo it seems like they have reasonable expectations for a part time employee at a startup.",
            "depth": 0
        }
    ],
    "source_platform": "reddit",
    "scraped_at": "2026-05-15T19:03:36.850288+00:00"
}
```

#### 👤 User Profile Post

```json
{
    "id": "t3_1t4nr7v",
    "title": "Reddit looked old the day it was born...",
    "content": "Watch the full episode here: https://youtu.be/eAu9gTilxA0",
    "author": "spez",
    "author_url": "https://www.reddit.com/user/spez",
    "subreddit": "u_spez",
    "score": 47,
    "num_comments": 33,
    "upvote_ratio": 0.62,
    "item_type": "post",
    "scrape_mode": "user_profile",
    "source_platform": "reddit",
    "target_user": "spez",
    "scraped_at": "2026-05-15T19:04:08.187193+00:00"
}
```

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `subreddits` | Array | — | Subreddit names to scrape (without `r/` prefix) |
| `users` | Array | `[]` | Reddit usernames to scrape (without `u/` prefix) |
| `mode` | String | `hot` | Scraping mode: `hot`, `new`, `top`, `rising`, `search`, `archive` |
| `limit` | Integer | `20` | Max posts per target (1–500) |
| `time_filter` | String | `week` | Time filter for `top` mode: `hour`, `day`, `week`, `month`, `year`, `all` |
| `keywords` | Array | `[]` | Search keywords (required for `search` mode) |
| `fetch_comments` | Boolean | `true` | Extract full comment threads for each post |
| `humanizer_preset` | String | `normal` | Browsing speed: `fast`, `normal`, `careful`, `stealth` |
| `use_proxy` | Boolean | `true` | Use Apify Proxy for browser requests |

### Anti-Detection & Stealth

Reddit Scraper uses a Playwright-based browser engine with built-in human-like behavior:

| Feature | Description |
|---|---|
| **Viewport Randomization** | Random screen sizes to avoid fingerprinting |
| **Natural Scrolling** | Smooth, variable-speed scrolling patterns |
| **Configurable Speed** | 4 presets: `fast`, `normal`, `careful`, `stealth` |
| **Request Delays** | Natural pauses between page loads |
| **User Agent Rotation** | Realistic browser identification strings |

> 🛡️ **Recommended:** Use `normal` or `careful` preset for production workloads. Use `stealth` for sensitive subreddits.

### Performance

| Metric | Value |
|---|---|
| **Speed** | ~3 seconds per 10 posts (after initialization) |
| **Initialization** | ~5 seconds (browser startup, runs once) |
| **Memory** | 1024–4096 MB recommended |
| **Rate Limiting** | Built-in delays to avoid Reddit bans |

### FAQ

#### Is Reddit scraping legal?

Scraping publicly available data from Reddit is generally permitted. Reddit's Terms of Service govern API usage, but web scraping of public content falls under fair use in most jurisdictions. Always use the scraper responsibly and comply with applicable laws.

#### Do I need a Reddit API key?

No. This scraper works without any Reddit API key, authentication, or login. It accesses only publicly available content through browser automation.

#### Do I need proxies for scraping Reddit?

Recommended but not strictly required. Apify Proxy is included and enabled by default. For large-scale scraping, residential proxies provide better reliability.

#### Can I export the data via API?

Yes. The Apify API gives you programmatic access to all scraped datasets. Export to JSON, CSV, XML, or integrate directly with your application using the Apify API client for Node.js or Python.

#### What is the 1,000 items limit?

Reddit limits most feed listings to ~1,000 items. This is a Reddit platform restriction, not a scraper limitation. To collect more data, use our `search` mode with different keywords or `archive` mode for deep historical scraping.

#### What's the difference between Hot, New, and Top?

- **Hot**: Reddit's algorithm-ranked trending posts (mix of recency and engagement)
- **New**: Chronologically newest posts first
- **Top**: Highest voted posts within a time period (hour/day/week/month/year/all)

### Enterprise & Integration

Need high-volume scraping, custom integrations, or dedicated support? Our Enterprise tier includes:

- 🗄️ **Archive mode** for deep historical data
- 🔄 **Monitoring mode** for real-time alerts
- 🔗 **API integration** with your data pipeline
- 📞 **Priority support**

Contact us for enterprise pricing and custom solutions.

# Actor input Schema

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

Subreddit names to scrape (without the r/ prefix). Example: marketing, SaaS, startups

## `users` (type: `array`):

Reddit usernames to scrape (without the u/ prefix). Extracts their recent posts.

## `mode` (type: `string`):

How to sort and discover posts in each target

## `limit` (type: `integer`):

Maximum number of posts to extract from each subreddit or user profile

## `time_filter` (type: `string`):

Time range — only applies when mode is set to Top

## `fetch_comments` (type: `boolean`):

Extract full comment threads for each post. Returns structured array with author, score, and body. Adds ~2 seconds per post.

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

Keywords to search for inside the target subreddits. Only used when mode is 'Search'.

## `humanizer_preset` (type: `string`):

Controls how human-like the browsing behavior is. Slower = safer against detection, but takes longer.

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

Select the proxy to use for scraping. Residential proxies are recommended for best results.

## Actor input object example

```json
{
  "subreddits": [
    "marketing"
  ],
  "mode": "hot",
  "limit": 20,
  "time_filter": "week",
  "fetch_comments": true,
  "humanizer_preset": "normal",
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "subreddits": [
        "marketing"
    ],
    "mode": "hot",
    "limit": 20,
    "time_filter": "week",
    "fetch_comments": true,
    "humanizer_preset": "normal",
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "subreddits": ["marketing"],
    "mode": "hot",
    "limit": 20,
    "time_filter": "week",
    "fetch_comments": True,
    "humanizer_preset": "normal",
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("smrtai-ops/reddit-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "subreddits": [
    "marketing"
  ],
  "mode": "hot",
  "limit": 20,
  "time_filter": "week",
  "fetch_comments": true,
  "humanizer_preset": "normal",
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call smrtai-ops/reddit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Scraper | 6 Modes + Comments | $1/1K Results",
        "description": "Scrape posts, full comment threads, and keyword searches from any subreddit, user profile, or community. 6 modes: Hot, New, Top, Rising, Search & Archive. Stealth anti-detection browsing. No API key or login needed. Ideal for market research, AI training, and competitor analysis.",
        "version": "1.0",
        "x-build-id": "I0h16b7eb9EEyV7QH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/smrtai-ops~reddit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-smrtai-ops-reddit-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/smrtai-ops~reddit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-smrtai-ops-reddit-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/smrtai-ops~reddit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-smrtai-ops-reddit-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "subreddits": {
                        "title": "Subreddits",
                        "type": "array",
                        "description": "Subreddit names to scrape (without the r/ prefix). Example: marketing, SaaS, startups",
                        "items": {
                            "type": "string"
                        }
                    },
                    "users": {
                        "title": "User Profiles",
                        "type": "array",
                        "description": "Reddit usernames to scrape (without the u/ prefix). Extracts their recent posts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "Scraping Mode",
                        "enum": [
                            "hot",
                            "new",
                            "top",
                            "rising",
                            "search"
                        ],
                        "type": "string",
                        "description": "How to sort and discover posts in each target",
                        "default": "hot"
                    },
                    "limit": {
                        "title": "Posts per Target",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of posts to extract from each subreddit or user profile",
                        "default": 20
                    },
                    "time_filter": {
                        "title": "Time Filter",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time range — only applies when mode is set to Top",
                        "default": "week"
                    },
                    "fetch_comments": {
                        "title": "Include Comments",
                        "type": "boolean",
                        "description": "Extract full comment threads for each post. Returns structured array with author, score, and body. Adds ~2 seconds per post.",
                        "default": true
                    },
                    "keywords": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search for inside the target subreddits. Only used when mode is 'Search'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "humanizer_preset": {
                        "title": "Browsing Speed",
                        "enum": [
                            "fast",
                            "normal",
                            "careful",
                            "stealth"
                        ],
                        "type": "string",
                        "description": "Controls how human-like the browsing behavior is. Slower = safer against detection, but takes longer.",
                        "default": "normal"
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select the proxy to use for scraping. Residential proxies are recommended for best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
