# Reddit Scraper - Posts, Comments, Search, Users (no login) (`constructive_calm/reddit-scraper-pro`) Actor

Scrape Reddit subreddit posts, search results, full comment trees, and user history. Cookie-free, reliable (>95% success), and cheaper than incumbents. Built-in monitor mode for new-post alerts.

- **URL**: https://apify.com/constructive\_calm/reddit-scraper-pro.md
- **Developed by:** [Omar Eldeeb](https://apify.com/constructive_calm) (community)
- **Categories:** Social media, AI, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.50 / 1,000 post fetcheds

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 — Posts, Comments, Search & Users (no login)

Reliable, low-cost Reddit data extraction. Pull a **subreddit's posts**, run a **keyword search**, grab a post's **full comment tree**, scrape a **user's history**, or **monitor** a subreddit for new posts — all without a Reddit login, app registration, or API key. Built on the public `old.reddit.com` HTML, it returns clean structured rows you can export to JSON, CSV, or Excel and feed straight into AI/RAG pipelines, dashboards, or research notebooks.

### What does Reddit Scraper do?

Reddit's official API went paid and rate-limited in 2023, so getting bulk Reddit data is harder than it should be. This Actor turns any subreddit, search query, post, or user into structured data — posts (title, score, comment count, author, flair, links, timestamps) and comments (body, score, depth, parent, author, OP flag) — on the [Apify platform](https://apify.com), with scheduling, exports, integrations, and an API out of the box.

It is engineered for **reliability and price**: it scrapes the lightweight `old.reddit.com` HTML cookie-free, rotates IPs automatically, and escalates from cheap datacenter to residential proxies only when needed — so runs finish at high success rates without you paying for residential traffic you didn't need.

### Why use Reddit Scraper?

- **AI / RAG builders** — bulk subreddit posts + comment trees as a clean training/retrieval corpus, with stable IDs and parent linkage.
- **Market & brand researchers** — search any keyword across Reddit or inside a subreddit and track sentiment, complaints, and competitor mentions.
- **Social-listening & trend analysts** — monitor mode returns only *new* posts since the last run, perfect for scheduled alerts.
- **Academics & data scientists** — reproducible discussion-tree extraction with depth and parent IDs (Pushshift is dead; this fills the gap).
- **Reliability-first teams** — automatic IP rotation + datacenter→residential fallback keeps success high where cheaper scrapers time out.

### How to use Reddit Scraper

1. Click **Try for free**.
2. Pick a **mode** (subreddit posts, search, comments thread, user profile, or monitor).
3. Fill the relevant fields (e.g. subreddit names, a search query, or post URLs).
4. Set **Max items** and **Max pages per target** to control run size and cost.
5. Click **Start**, then **export** the dataset as JSON, CSV, or Excel — or pull it via the Apify API.

### Input

**Subreddit posts**
```json
{ "mode": "subreddit_posts", "subreddits": ["programming", "rust"], "sort": "top", "timeFilter": "week", "maxItems": 200 }
````

**Search (sitewide or inside a subreddit)**

```json
{ "mode": "search", "searchQuery": "vector database", "sort": "top", "timeFilter": "year", "maxItems": 100 }
```

**Comments thread (full tree)**

```json
{ "mode": "comments_thread", "postUrls": ["https://www.reddit.com/r/programming/comments/abc123/some_title/"], "maxCommentDepth": 10 }
```

**User profile (posts + comments)**

```json
{ "mode": "user_profile", "usernames": ["spez"], "maxItems": 100 }
```

**Monitor (only new posts since last run)**

```json
{ "mode": "monitor", "subreddits": ["programming"], "maxItems": 100 }
```

### Output

Each row is a `post` or `comment`. Example post row:

```json
{
  "recordType": "post",
  "id": "1seu7p2",
  "fullId": "t3_1seu7p2",
  "subreddit": "rust",
  "author": "lekkerwafel",
  "title": "Unpopular opinion: Rust should have a larger standard library",
  "score": 923,
  "numComments": 383,
  "createdAt": "2026-04-07T12:13:45.000Z",
  "url": "https://www.reddit.com/r/rust/comments/1seu7p2/unpopular_opinion_rust_should_have_a_larger/",
  "externalUrl": null,
  "domain": "self.rust",
  "isSelf": true,
  "isNsfw": false,
  "isStickied": false,
  "flair": "💡 ideas & proposals",
  "fetchedAt": "2026-05-29T09:50:00.000Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | `post` or `comment` |
| `id` / `fullId` | string | base36 id / `t3_`/`t1_` prefixed fullname |
| `subreddit` | string | Subreddit name |
| `author` | string | Username (`[deleted]` if removed) |
| `title` | string | Post title (posts only) |
| `selfText` | string | Self-post body (comments\_thread mode) |
| `body` | string | Comment text (comments only) |
| `score` | number|null | Net upvotes (null when Reddit hides it) |
| `numComments` | number | Comment count (posts) |
| `createdAt` | string | ISO 8601 timestamp |
| `depth` / `parentId` | number / string | Comment nesting depth + parent fullname |
| `isSubmitter` | boolean | Comment authored by the OP |
| `url` | string | Canonical permalink |
| `externalUrl` / `domain` | string | Outbound link + domain (link posts) |
| `flair`, `isNsfw`, `isStickied` | — | Post metadata |

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

Pay only for what you extract (pay-per-event), with the **first 10 events free every run** to try it out:

| Event | Price |
|-------|-------|
| Post fetched | $0.0025 |
| Comment fetched | $0.0008 |
| Search result fetched | $0.003 |
| User history item fetched | $0.004 |
| Monitor delta detected | $0.0025 |

Typical runs:

- 1,000 subreddit posts → **~$2.50** (vs ~$4 on common incumbents).
- A 500-comment thread → **~$0.40**.
- Daily monitor of 5 subreddits (~50 new posts/day) → **~$0.13/day**.

Datacenter proxy (cheapest) is the default; the Actor only escalates to residential when a page is blocked, so you don't overpay.

### Tips & advanced options

- **Sort & time window**: `top`/`controversial` honor the `timeFilter` (hour→all). `hot`/`new`/`rising` ignore it.
- **Scope a search**: turn on *Restrict search to first subreddit* to search inside one subreddit.
- **Comment depth**: lower `maxCommentDepth` for cheaper, shallower trees; raise it for deep discussions.
- **Schedule monitor mode**: pair it with Apify Schedules to get only-new-posts alerts; state persists across runs.
- **Big runs**: switch the proxy to Residential up front for very large or heavily rate-limited scrapes.
- **Cost control**: `maxItems` is a hard cap across all targets; `maxPagesPerTarget` bounds pagination.

### Legal & responsible use

This Actor collects **publicly available** content from Reddit. You are responsible for complying with [Reddit's User Agreement](https://www.redditinc.com/policies/user-agreement) and applicable laws (including GDPR/CCPA) when collecting and processing data, and for respecting the rights and privacy of the people whose content you scrape. Do not use it to collect personal data unlawfully, to harass, or to redistribute content in violation of Reddit's terms. This tool is provided for lawful research, analytics, and archival use.

### FAQ & support

- **Do I need a Reddit account or API key?** No — it uses the public `old.reddit.com` HTML, cookie-free.
- **Why did a run escalate to residential?** Reddit blocks some datacenter IPs on `/search` and `/comments`; the Actor falls back automatically to keep success high. Disable via *Auto residential fallback* if you prefer datacenter-only.
- **Can it expand "load more comments" links?** v1 extracts the full server-rendered tree up to your depth cap; deeply collapsed `more comments` stubs are not expanded yet.
- **Are scores always present?** Reddit hides scores on very new posts/comments; those return `null`.
- **It returned 0 rows for a subreddit/user.** Likely banned, private, suspended, or misspelled — check the run log.
- **Issues / requests?** Open an issue from the Actor's Issues tab.

# Actor input Schema

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

Pick the scrape mode. 'Subreddit posts' is the most common starting point.

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

Subreddit names without the r/ prefix (e.g. 'programming'). Used by subreddit\_posts and monitor modes.

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

Sort order. For SEARCH, choose 'Relevance' or 'Top' for the most precise results — 'Hot' is recency-weighted and matches loosely. (In subreddit feeds, which have no relevance sort, 'Relevance' falls back to 'Hot'.)

## `timeFilter` (type: `string`):

Only applies when sort is 'top' or 'controversial'.

## `searchQuery` (type: `string`):

Keyword to search (search mode). TIP: wrap a multi-word query in double quotes for exact-phrase matching — e.g. "offshore recruiting" — otherwise Reddit matches the words loosely and returns tangential posts. Pair with sort=Relevance or Top for best precision. Combine with 'Restrict search to subreddit' to scope it.

## `restrictToSubreddit` (type: `boolean`):

When on, search mode searches only within the first subreddit listed above (restrict\_sr). Off = sitewide search.

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

Full Reddit post URLs or permalinks. Used by comments\_thread mode. Example: https://www.reddit.com/r/programming/comments/abc123/title/

## `usernames` (type: `array`):

Reddit usernames without the u/ prefix. Used by user\_profile mode.

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

comments\_thread mode ONLY. When on, emits the full comment tree; when off, only the post. IGNORED by search / subreddit\_posts / user\_profile / monitor (those return posts only). To get comments for search results, run comments\_thread on the result URLs.

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

comments\_thread mode ONLY. How deep to follow nested comment chains. 0 = post only. Ignored by other modes.

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

Hard cap on dataset rows for this run (across all targets).

## `maxPagesPerTarget` (type: `integer`):

Pagination cap per subreddit/search/user (each page = ~25 items). Guards runaway runs.

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

Datacenter (default) is cheapest and works for most runs. For very large or heavily rate-limited runs, switch to Residential. Reddit rate-limits by IP, so the scraper rotates IPs + retries automatically regardless of choice.

## `residentialFallback` (type: `boolean`):

When a datacenter request keeps getting blocked/rate-limited after retries, automatically retry that page once through a residential IP. Keeps success rate high while staying cheap by default. (No effect if you already selected residential.)

## Actor input object example

```json
{
  "mode": "subreddit_posts",
  "subreddits": [
    "programming"
  ],
  "sort": "hot",
  "timeFilter": "all",
  "restrictToSubreddit": false,
  "includeComments": true,
  "maxCommentDepth": 10,
  "maxItems": 200,
  "maxPagesPerTarget": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "residentialFallback": true
}
```

# Actor output Schema

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

All extracted posts and comments in one dataset.

# 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": [
        "programming"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("constructive_calm/reddit-scraper-pro").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": ["programming"] }

# Run the Actor and wait for it to finish
run = client.actor("constructive_calm/reddit-scraper-pro").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": [
    "programming"
  ]
}' |
apify call constructive_calm/reddit-scraper-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Scraper - Posts, Comments, Search, Users (no login)",
        "description": "Scrape Reddit subreddit posts, search results, full comment trees, and user history. Cookie-free, reliable (>95% success), and cheaper than incumbents. Built-in monitor mode for new-post alerts.",
        "version": "0.1",
        "x-build-id": "HAmqS70XPPfrwMNht"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/constructive_calm~reddit-scraper-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-constructive_calm-reddit-scraper-pro",
                "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/constructive_calm~reddit-scraper-pro/runs": {
            "post": {
                "operationId": "runs-sync-constructive_calm-reddit-scraper-pro",
                "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/constructive_calm~reddit-scraper-pro/run-sync": {
            "post": {
                "operationId": "run-sync-constructive_calm-reddit-scraper-pro",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "subreddit_posts",
                            "search",
                            "comments_thread",
                            "user_profile",
                            "monitor"
                        ],
                        "type": "string",
                        "description": "Pick the scrape mode. 'Subreddit posts' is the most common starting point.",
                        "default": "subreddit_posts"
                    },
                    "subreddits": {
                        "title": "Subreddits",
                        "type": "array",
                        "description": "Subreddit names without the r/ prefix (e.g. 'programming'). Used by subreddit_posts and monitor modes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "hot",
                            "new",
                            "top",
                            "rising",
                            "controversial",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort order. For SEARCH, choose 'Relevance' or 'Top' for the most precise results — 'Hot' is recency-weighted and matches loosely. (In subreddit feeds, which have no relevance sort, 'Relevance' falls back to 'Hot'.)",
                        "default": "hot"
                    },
                    "timeFilter": {
                        "title": "Time window (for Top / Controversial)",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Only applies when sort is 'top' or 'controversial'.",
                        "default": "all"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword to search (search mode). TIP: wrap a multi-word query in double quotes for exact-phrase matching — e.g. \"offshore recruiting\" — otherwise Reddit matches the words loosely and returns tangential posts. Pair with sort=Relevance or Top for best precision. Combine with 'Restrict search to subreddit' to scope it."
                    },
                    "restrictToSubreddit": {
                        "title": "Restrict search to first subreddit",
                        "type": "boolean",
                        "description": "When on, search mode searches only within the first subreddit listed above (restrict_sr). Off = sitewide search.",
                        "default": false
                    },
                    "postUrls": {
                        "title": "Post URLs or permalinks",
                        "type": "array",
                        "description": "Full Reddit post URLs or permalinks. Used by comments_thread mode. Example: https://www.reddit.com/r/programming/comments/abc123/title/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "Reddit usernames without the u/ prefix. Used by user_profile mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeComments": {
                        "title": "Include comments (comments_thread mode only)",
                        "type": "boolean",
                        "description": "comments_thread mode ONLY. When on, emits the full comment tree; when off, only the post. IGNORED by search / subreddit_posts / user_profile / monitor (those return posts only). To get comments for search results, run comments_thread on the result URLs.",
                        "default": true
                    },
                    "maxCommentDepth": {
                        "title": "Max comment depth (comments_thread mode only)",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "comments_thread mode ONLY. How deep to follow nested comment chains. 0 = post only. Ignored by other modes.",
                        "default": 10
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Hard cap on dataset rows for this run (across all targets).",
                        "default": 200
                    },
                    "maxPagesPerTarget": {
                        "title": "Max pages per target",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Pagination cap per subreddit/search/user (each page = ~25 items). Guards runaway runs.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Datacenter (default) is cheapest and works for most runs. For very large or heavily rate-limited runs, switch to Residential. Reddit rate-limits by IP, so the scraper rotates IPs + retries automatically regardless of choice.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "residentialFallback": {
                        "title": "Auto residential fallback",
                        "type": "boolean",
                        "description": "When a datacenter request keeps getting blocked/rate-limited after retries, automatically retry that page once through a residential IP. Keeps success rate high while staying cheap by default. (No effect if you already selected residential.)",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```