# Reddit Scraper - Fast, Comments,Data,Subreddits (`myagizm/reddit-scraper`) Actor

Scrape public Reddit posts, comments, users, communities, and search results as structured JSON. No login, no API key.

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

## Pricing

$1.40 / 1,000 reddit item scrapeds

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 Scraper 🚀

Extract public Reddit data at scale — **no login, no API keys, no rate-limit headaches.**
Point it at subreddits, users, search queries, or plain Reddit URLs and get clean,
structured JSON back.

Great for market research, lead generation, trend monitoring, sentiment analysis,
training datasets, and competitive intel.

---

### ✨ What you can scrape

- **Subreddit listings** — New, Hot, Top, Rising, or Controversial, with pagination.
- **Keyword search** — across posts, communities, and users.
- **User submissions** — everything a given user has posted.
- **Community metadata** — subscribers, description, creation date, NSFW flag.
- **Any Reddit URL** — paste a post, subreddit, or profile link; it's auto-detected.
- **Nested comments** — full comment trees, depth- and count-bounded.
- **Media URLs** — images and videos (i.redd.it, v.redd.it, imgur, galleries).

Built-in filters: date ranges, keyword filter, NSFW toggle, and per-source caps.

---

### 🔧 Example input

```json
{
  "subreddits": ["forhire", "jobbit"],
  "sort": "new",
  "maxItems": 100,
  "includeSelftext": true,
  "includeComments": false
}
````

Search example:

```json
{
  "searchQueries": ["python developer"],
  "searchFor": ["posts", "communities", "users"],
  "sort": "relevance",
  "time": "month",
  "maxItems": 50
}
```

You don't have to write JSON — every field is available as a form in the Actor's
**Input** tab, so you can configure and test a run with a few clicks.

***

### 📦 Output

Each result is one record in the dataset. The `type` field is one of
`post`, `comment`, `community`, or `user`.

**Post example:**

```json
{
  "type": "post",
  "id": "t3_1abcde",
  "subreddit": "forhire",
  "title": "[For Hire] Full-stack developer",
  "author": "some_user",
  "url": "https://www.reddit.com/r/forhire/comments/1abcde/...",
  "score": 42,
  "numComments": 7,
  "createdUtc": "2026-07-14T19:02:17+00:00",
  "selftext": "…",
  "flair": "For Hire",
  "nsfw": false
}
```

Community records include `subscribers`, users include `linkKarma` / `commentKarma`,
and comments include `body`, `score`, and `depth`. Per-run statistics are written
to the key-value store under `STATS`.

Export the dataset as **JSON, CSV, Excel, or via the API** — like any Apify Actor.

***

### 💵 Pricing

**$1.40 per 1,000 results.** Pay only for the data you keep — no monthly fee, no
start fee. That's well below the market average (~$3.50 / 1,000) and undercuts the
most popular Reddit scrapers on the Store.

### ⏱️ Usage limits

To keep the service fast and fair for everyone:

- A single run lasts at most **~10 minutes**.
- Only **one long-running job** is processed at a time — if a run is already in
  progress, start the next one a moment later.
- Keep `maxItems` / `maxPages` reasonable for the fastest results.

***

### ❓ Notes

- This scraper reads only **public** Reddit data.
- `activeUsers` may be `null` — Reddit does not expose live active-user counts publicly.
- Reddit no longer supports true comment *search*; searching for comments returns
  matching posts. Reading a post's own comments works fully.
- Please scrape responsibly and respect Reddit's terms and the subreddits you target.

***

### 🔎 Keywords

reddit scraper, reddit api, reddit data extraction, scrape reddit posts, reddit comments scraper,
subreddit scraper, reddit search scraper, reddit user scraper, reddit community scraper,
reddit keyword monitor, reddit crawler, reddit json, reddit without api key, no login reddit scraper,
reddit sentiment analysis, reddit market research, reddit lead generation, social media scraping,
reddit trends, reddit posts export, reddit dataset, reddit media downloader, old.reddit scraper,
reddit monitoring, brand monitoring, reddit content extraction, reddit analytics

# Actor input Schema

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

Subreddit names to scrape, e.g. "AskReddit", "forhire". The r/ prefix is optional.

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

Paste any Reddit URLs (post, subreddit, or user). Each is auto-detected and scraped accordingly.

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

Usernames whose submitted posts to scrape, e.g. "spez". The u/ prefix is optional.

## `communities` (type: `array`):

Subreddit names to fetch metadata for (subscribers, description, creation date) without listing posts.

## `searchQueries` (type: `array`):

Keywords to search across Reddit. Each query is run for every type selected in "Search for".

## `searchFor` (type: `array`):

Which entity types each search query should return.

## `searchInSubreddits` (type: `array`):

If set, each search query is restricted to these subreddits only.

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

Sort order for listings and search results.

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

Time window used by Top / Controversial / search.

## `postDateLimit` (type: `string`):

Keep only posts created on or after this date. Leave empty for no limit.

## `commentDateLimit` (type: `string`):

Keep only comments created on or after this date. Leave empty for no limit.

## `searchTerms` (type: `array`):

Keep only posts whose title or body contains at least one of these words (case-insensitive).

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

Include posts flagged as over-18 / NSFW.

## `includeSelftext` (type: `boolean`):

Fetch each post's self/body text.

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

Scrape nested comments for each post (slower).

## `maxComments` (type: `integer`):

Upper bound on comments scraped per post when "Include comments" is on.

## `maxCommentDepth` (type: `integer`):

Maximum nesting depth of the comment tree to traverse.

## `includeMedia` (type: `boolean`):

Extract image/video media URLs (i.redd.it, v.redd.it, imgur, galleries).

## `maxItems` (type: `integer`):

Hard cap on the total number of items saved in one run. Keep this reasonable — a single run is limited to ~10 minutes.

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

Cap on posts kept from each individual subreddit, user, or search.

## `maxPages` (type: `integer`):

How many pages of a listing to paginate through (25 posts per page).

## `ignoreStartUrls` (type: `boolean`):

Skip the Start URLs input even if provided.

## `maxRetries` (type: `integer`):

Retry attempts (with backoff) per failed request.

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

Politeness delay between consecutive requests.

## `debug` (type: `boolean`):

Emit verbose per-source logs (useful while testing your input).

## Actor input object example

```json
{
  "subreddits": [
    "AskReddit",
    "programming"
  ],
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/pics/"
    }
  ],
  "users": [
    "spez",
    "kn0thing"
  ],
  "communities": [
    "technology",
    "science"
  ],
  "searchQueries": [
    "python developer"
  ],
  "searchFor": [
    "posts"
  ],
  "searchInSubreddits": [
    "forhire"
  ],
  "sort": "hot",
  "time": "week",
  "postDateLimit": "2026-01-01",
  "commentDateLimit": "2026-01-01",
  "searchTerms": [
    "hiring",
    "developer"
  ],
  "includeNSFW": false,
  "includeSelftext": true,
  "includeComments": false,
  "maxComments": 20,
  "maxCommentDepth": 4,
  "includeMedia": false,
  "maxItems": 50,
  "maxPostsPerSource": 25,
  "maxPages": 1,
  "ignoreStartUrls": false,
  "maxRetries": 3,
  "requestDelayMs": 300,
  "debug": false
}
```

# Actor output Schema

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

All scraped items as structured JSON.

# 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": [
        "forhire"
    ],
    "startUrls": [
        {
            "url": "https://www.reddit.com/r/webdev/"
        }
    ],
    "users": [
        "spez"
    ],
    "communities": [
        "technology"
    ],
    "searchQueries": [
        "remote developer"
    ],
    "searchFor": [
        "posts"
    ],
    "sort": "hot",
    "time": "week",
    "includeNSFW": false,
    "includeSelftext": true,
    "includeComments": false,
    "maxComments": 20,
    "maxCommentDepth": 4,
    "includeMedia": false,
    "maxItems": 50,
    "maxPostsPerSource": 25,
    "maxPages": 1,
    "ignoreStartUrls": false,
    "maxRetries": 3,
    "requestDelayMs": 300,
    "debug": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("myagizm/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": ["forhire"],
    "startUrls": [{ "url": "https://www.reddit.com/r/webdev/" }],
    "users": ["spez"],
    "communities": ["technology"],
    "searchQueries": ["remote developer"],
    "searchFor": ["posts"],
    "sort": "hot",
    "time": "week",
    "includeNSFW": False,
    "includeSelftext": True,
    "includeComments": False,
    "maxComments": 20,
    "maxCommentDepth": 4,
    "includeMedia": False,
    "maxItems": 50,
    "maxPostsPerSource": 25,
    "maxPages": 1,
    "ignoreStartUrls": False,
    "maxRetries": 3,
    "requestDelayMs": 300,
    "debug": False,
}

# Run the Actor and wait for it to finish
run = client.actor("myagizm/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": [
    "forhire"
  ],
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/webdev/"
    }
  ],
  "users": [
    "spez"
  ],
  "communities": [
    "technology"
  ],
  "searchQueries": [
    "remote developer"
  ],
  "searchFor": [
    "posts"
  ],
  "sort": "hot",
  "time": "week",
  "includeNSFW": false,
  "includeSelftext": true,
  "includeComments": false,
  "maxComments": 20,
  "maxCommentDepth": 4,
  "includeMedia": false,
  "maxItems": 50,
  "maxPostsPerSource": 25,
  "maxPages": 1,
  "ignoreStartUrls": false,
  "maxRetries": 3,
  "requestDelayMs": 300,
  "debug": false
}' |
apify call myagizm/reddit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Scraper - Fast, Comments,Data,Subreddits",
        "description": "Scrape public Reddit posts, comments, users, communities, and search results as structured JSON. No login, no API key.",
        "version": "0.1",
        "x-build-id": "lgJb6clGHldMUe5Dy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/myagizm~reddit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-myagizm-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/myagizm~reddit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-myagizm-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/myagizm~reddit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-myagizm-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, e.g. \"AskReddit\", \"forhire\". The r/ prefix is optional.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste any Reddit URLs (post, subreddit, or user). Each is auto-detected and scraped accordingly.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "users": {
                        "title": "Users",
                        "type": "array",
                        "description": "Usernames whose submitted posts to scrape, e.g. \"spez\". The u/ prefix is optional.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "communities": {
                        "title": "Communities (metadata only)",
                        "type": "array",
                        "description": "Subreddit names to fetch metadata for (subscribers, description, creation date) without listing posts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search across Reddit. Each query is run for every type selected in \"Search for\".",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchFor": {
                        "title": "Search for",
                        "type": "array",
                        "description": "Which entity types each search query should return.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "posts",
                                "comments",
                                "communities",
                                "users",
                                "media"
                            ],
                            "enumTitles": [
                                "Posts",
                                "Comments (Reddit returns posts)",
                                "Communities",
                                "Users",
                                "Media posts only"
                            ]
                        },
                        "default": [
                            "posts"
                        ]
                    },
                    "searchInSubreddits": {
                        "title": "Restrict search to subreddits",
                        "type": "array",
                        "description": "If set, each search query is restricted to these subreddits only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "new",
                            "hot",
                            "top",
                            "rising",
                            "controversial",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort order for listings and search results.",
                        "default": "new"
                    },
                    "time": {
                        "title": "Time range",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time window used by Top / Controversial / search.",
                        "default": "all"
                    },
                    "postDateLimit": {
                        "title": "Only posts on/after (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Keep only posts created on or after this date. Leave empty for no limit."
                    },
                    "commentDateLimit": {
                        "title": "Only comments on/after (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Keep only comments created on or after this date. Leave empty for no limit."
                    },
                    "searchTerms": {
                        "title": "Keyword filter",
                        "type": "array",
                        "description": "Keep only posts whose title or body contains at least one of these words (case-insensitive).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeNSFW": {
                        "title": "Include NSFW",
                        "type": "boolean",
                        "description": "Include posts flagged as over-18 / NSFW.",
                        "default": false
                    },
                    "includeSelftext": {
                        "title": "Include post text",
                        "type": "boolean",
                        "description": "Fetch each post's self/body text.",
                        "default": true
                    },
                    "includeComments": {
                        "title": "Include comments",
                        "type": "boolean",
                        "description": "Scrape nested comments for each post (slower).",
                        "default": false
                    },
                    "maxComments": {
                        "title": "Max comments per post",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Upper bound on comments scraped per post when \"Include comments\" is on.",
                        "default": 20
                    },
                    "maxCommentDepth": {
                        "title": "Max comment depth",
                        "minimum": 0,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Maximum nesting depth of the comment tree to traverse.",
                        "default": 4
                    },
                    "includeMedia": {
                        "title": "Include media URLs",
                        "type": "boolean",
                        "description": "Extract image/video media URLs (i.redd.it, v.redd.it, imgur, galleries).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Hard cap on the total number of items saved in one run. Keep this reasonable — a single run is limited to ~10 minutes.",
                        "default": 50
                    },
                    "maxPostsPerSource": {
                        "title": "Max posts per source",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Cap on posts kept from each individual subreddit, user, or search.",
                        "default": 25
                    },
                    "maxPages": {
                        "title": "Max listing pages",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many pages of a listing to paginate through (25 posts per page).",
                        "default": 1
                    },
                    "ignoreStartUrls": {
                        "title": "Ignore start URLs",
                        "type": "boolean",
                        "description": "Skip the Start URLs input even if provided.",
                        "default": false
                    },
                    "maxRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 6,
                        "type": "integer",
                        "description": "Retry attempts (with backoff) per failed request.",
                        "default": 3
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Politeness delay between consecutive requests.",
                        "default": 300
                    },
                    "debug": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Emit verbose per-source logs (useful while testing your input).",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
