# Reddit Comment Scraper (`scrapeflow/reddit-comment-scraper`) Actor

💬 Reddit Comment Scraper (reddit-comment-scraper) extracts comments from posts and subreddits — with author, score, timestamp, nesting & permalinks. 📊 Export CSV/JSON. 🔍 Ideal for market research, social listening, brand monitoring & academic analysis. 🚀 Fast, scalable.

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Reddit Comment Scraper

Reddit Comment Scraper is a fast, scalable Reddit comment extractor that lets you scrape Reddit comments from public post URLs and export structured data for analysis. Built for marketers, developers, data analysts, and researchers, it solves the pain of collecting threaded discussions at scale — including authors, upvotes, nesting, and permalinks — and enables automated workflows to download Reddit comments and export Reddit comments to CSV or JSON for further processing.

### What data / output can you get?

Below are the exact fields this Reddit thread comments scraper produces in the Apify dataset (one record per comment):

| Data type | Description | Example value |
| --- | --- | --- |
| url | The original Reddit post URL the comment belongs to | https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/ |
| comment_id | Unique comment identifier | lhk1f7n |
| post_id | Post identifier (prefixed with t3_) | t3_1epeshq |
| author | Comment author username (or [deleted]) | AutoModerator |
| permalink | Direct link to the specific comment | https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/lhk1f7n/ |
| upvotes | Number of upvotes (score) | 1 |
| content_type | Content type marker | text |
| parent_id | Parent comment/post ID (normalized; null for top-level) | t3_1epeshq |
| author_avatar | Author avatar URL (empty if not available) |  |
| userUrl | Link to the author’s Reddit profile (blank if [deleted]) | https://www.reddit.com/user/AutoModerator/ |
| contentText | The comment text with newlines normalized | Comment text here... |
| created_time | Timestamp placeholder (empty if not available) |  |
| replies | Array of nested reply objects attached to this comment (size limited by replyLimit) | [ { ...nested reply object... } ] |

Notes:
- You can export results in multiple formats (CSV, JSON, Excel) directly from the Apify dataset.
- In addition to the dataset, the actor also stores a grouped object in the key‑value store under OUTPUT, mapping each post URL to an array of its comments — useful for bulk analysis and to download Reddit comments per-thread.

### Key features

- 🚀 Fast, scalable extraction
  Built with async I/O to scrape Reddit comments efficiently across multiple post URLs in parallel. Ideal when you need to scrape subreddit comments by feeding many thread URLs.

- 🧵 Threaded replies with nesting
  Captures nested replies and keeps a configurable number in each comment’s replies array, making it a reliable Reddit comment crawler for conversation structure.

- 🔁 Automatic proxy fallback
  Smart fallback from direct connection to datacenter, then residential proxies with retries — improving resilience when you scrape Reddit comments at scale.

- 📦 Structured outputs for analysis
  Clean JSON schema includes author, score, parent-child relationships, permalinks, and more, so you can export Reddit comments to CSV or JSON for dashboards and NLP.

- 💻 Developer-friendly (API-ready, Python-based)
  Implemented in Python and deployable via the Apify API — a practical choice if you’re building a Reddit comment scraper Python workflow or integrating with data pipelines.

- ⚙️ Robust comment expansion
  Uses Reddit’s JSON endpoints and the /api/morechildren flow to retrieve additional comments, functioning as a dependable Reddit API scrape comments solution without login.

- 📊 Progress logging and summaries
  Real-time logs show collected counts, plus a final per-URL summary to keep large runs transparent and manageable.

### How to use Reddit Comment Scraper - step by step

1) Sign in to Apify  
Create or log in to your Apify account at https://console.apify.com.

2) Open the actor  
Search for “reddit-comment-scraper” and open the actor page.

3) Add input data  
Paste one or more Reddit post URLs into startUrls. You can add:
- Plain strings (recommended): https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/

4) Configure limits and replies  
Set maxComments to control how many comments to collect per URL (1–10,000; default 1,000). Set replyLimit to control how many nested replies are stored in each comment’s replies array (0 = unlimited).

5) Configure proxy (optional)  
By default, no proxy is used. If Reddit blocks requests, the actor automatically falls back to datacenter and then residential proxies with retries.

6) Run the actor  
Click Run. The job will fetch the post JSON, expand missing comments via /api/morechildren, and push structured items to the dataset.

7) Monitor progress  
Follow logs to see the number of comments collected per thread and a final scraping summary.

8) Download and integrate  
Go to the Output tab to download results as JSON, CSV, or Excel. Use the Apify API to automate pipelines, or connect the dataset to BI tools and data warehouses.

Pro Tip: For large-scale Reddit comment mining, queue many post URLs from target subreddits and automate exports with the Apify API to keep your Reddit comment data scraper in sync with your analytics stack.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research + voice of customer | Aggregate discussions from target threads to quantify themes, objections, and sentiment for product teams and PMMs. |
| Social listening for brands | Monitor comment sentiment and engagement on brand- or topic-related threads to inform community and support strategies. |
| Content research + curation | Mine high-signal comments to curate insights, FAQs, and examples for blogs, newsletters, or knowledge bases. |
| Academic research + NLP datasets | Collect structured Reddit comment datasets for linguistics, topic modeling, and sentiment analysis at scale. |
| Competitive analysis in subreddits | Track competitor mentions and user feedback by downloading Reddit comments from relevant threads over time. |
| Data engineering pipeline (API) | Feed structured JSON/CSV into warehouses and ML pipelines via the Apify API for downstream analytics and dashboards. |

### Why choose Reddit Comment Scraper?

The Reddit Comment Scraper is built for precision, automation, and reliability — a production-ready Reddit comment extractor that outperforms fragile browser extensions.

- ✅ Accurate, structured outputs with IDs, permalinks, parent/child links, and scores
- 🌍 No login required — works on publicly available Reddit JSON endpoints
- 📈 Scales to thousands of comments per URL with batching and retries
- 🧰 Developer access via Apify API — ideal for Python-based data pipelines
- 🔒 Ethical-by-design: focuses on public data and avoids private/authenticated content
- 💾 Flexible exports: easily export Reddit comments to CSV, JSON, or Excel
- 🛠️ Robust infrastructure: automatic proxy fallback (direct → datacenter → residential) with retry logic

In short, it’s a Reddit thread comments scraper engineered for consistency and scale — not a one-off browser hack.

### Is it legal / ethical to use Reddit Comment Scraper?

Yes — when used responsibly. This tool accesses publicly available Reddit content only and does not log in or access private data.

Guidelines for compliant use:
- Scrape only public URLs and respect Reddit’s Terms of Service.
- Adhere to applicable regulations (e.g., GDPR, CCPA) and process personal data lawfully.
- Avoid collecting or using data in ways that could be considered abusive or spammy.
- Consult your legal team for edge cases and jurisdiction-specific requirements.

The actor is designed to collect public comment data for legitimate research and analytics purposes.

### Input parameters & output format

#### Example input (JSON)
```json
{
  "startUrls": [
    "https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/"
  ],
  "maxComments": 1000,
  "replyLimit": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Parameters

| Parameter | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| startUrls | array | Yes | — | List one or more Reddit post URLs (e.g., https://www.reddit.com/r/subreddit/comments/post\_id/title/). |
| maxComments | integer | No | 1000 | Maximum number of comments to fetch per URL. Min 1, max 10,000. |
| replyLimit | integer | No | 0 | Maximum number of replies to store per comment in the nested replies field. Set to 0 for unlimited. (All replies are still collected in the flattened output.) |
| proxyConfiguration | object | No | { "useApifyProxy": false } | Choose which proxies to use. By default, no proxy is used. If Reddit rejects or blocks the request, it falls back to datacenter, then residential proxies with retries. |

#### Example dataset item (one comment per record)

```json
{
  "url": "https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/",
  "comment_id": "lhk1f7n",
  "post_id": "t3_1epeshq",
  "author": "AutoModerator",
  "permalink": "https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/lhk1f7n/",
  "upvotes": 1,
  "content_type": "text",
  "parent_id": "t3_1epeshq",
  "author_avatar": "",
  "userUrl": "https://www.reddit.com/user/AutoModerator/",
  "contentText": "Comment text here...",
  "created_time": "",
  "replies": []
}
```

#### Example grouped output (key‑value store: key = "OUTPUT")

```json
{
  "https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/": [
    {
      "comment_id": "lhk1f7n",
      "post_id": "t3_1epeshq",
      "author": "AutoModerator",
      "permalink": "https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/lhk1f7n/",
      "upvotes": 1,
      "content_type": "text",
      "parent_id": "t3_1epeshq",
      "author_avatar": "",
      "userUrl": "https://www.reddit.com/user/AutoModerator/",
      "contentText": "Comment text here...",
      "created_time": "",
      "replies": []
    }
  ]
}
```

Notes:

- Some fields (e.g., author\_avatar, created\_time) may be empty if Reddit does not provide them.
- The replies array is stored per comment and limited by replyLimit, while the flattened dataset includes all discovered comments.

### FAQ

#### Do I need a Reddit account or API key to use this?

✅ No. The actor uses publicly available Reddit JSON endpoints and does not require login, cookies, or API keys. It’s a straightforward Reddit comment scraping without API authentication.

#### Can it scrape nested replies from threads?

✅ Yes. Nested replies are captured, and you can control how many are stored in each comment’s replies array via replyLimit. All replies are still collected in the flattened output even when the nested array is limited.

#### How many comments can I collect per URL?

✅ You can set maxComments from 1 to 10,000 per URL. The default is 1,000. The actor trims results to this limit after expanding additional comments via /api/morechildren.

#### What happens if Reddit blocks or rate-limits requests?

✅ The actor automatically falls back: it tries a direct connection first, then datacenter proxy, and finally residential proxy with retries. This improves reliability for large runs.

#### Can I export results to CSV and JSON?

✅ Yes. All results are stored in the Apify dataset, so you can export Reddit comments to CSV, JSON, or Excel. A grouped JSON object is also saved under the OUTPUT key in the key‑value store.

#### Does this scrape entire subreddits?

ℹ️ It targets Reddit post URLs. To scrape subreddit comments broadly, supply multiple post URLs from the subreddit. This approach scales well for a Reddit comment mining workflow.

#### Is Pushshift used by this tool?

❌ No. This actor uses Reddit’s public JSON endpoints (including /api/morechildren) and does not rely on Pushshift.

#### Is there a free trial?

✅ Yes. This actor includes trial minutes on Apify (120 trial minutes are available) so you can test before subscribing.

#### Can developers integrate this with Python or the API?

✅ Yes. It’s built in Python and accessible via the Apify API, making it a great fit for Reddit comment scraper Python pipelines, ETL jobs, and automated workflows.

### Closing CTA / Final thoughts

Reddit Comment Scraper is built to extract structured, high-quality comment data from Reddit threads at scale. With nested replies, author metadata, permalinks, and robust proxy fallback, it powers market research, social listening, and data science workflows.

Marketers, developers, analysts, and researchers can quickly download Reddit comments, export to CSV/JSON, and automate pipelines via the Apify API. Start collecting richer Reddit discussion data today and turn threads into actionable insight.

# Actor input Schema

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

List one or more Reddit post URLs (e.g., https://www.reddit.com/r/subreddit/comments/post\_id/title/).

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

Maximum number of comments to fetch per URL.

## `replyLimit` (type: `integer`):

Maximum number of replies to store per comment in the nested `replies` field. Set to 0 for unlimited. (All replies are still collected in the flattened output.)

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

Choose which proxies to use. By default, no proxy is used. If Reddit rejects or blocks the request, it will fallback to datacenter proxy, then residential proxy with retries.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/"
  ],
  "maxComments": 1000,
  "replyLimit": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": ["https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/"],
    "proxyConfiguration": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapeflow/reddit-comment-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Comment Scraper",
        "description": "💬 Reddit Comment Scraper (reddit-comment-scraper) extracts comments from posts and subreddits — with author, score, timestamp, nesting & permalinks. 📊 Export CSV/JSON. 🔍 Ideal for market research, social listening, brand monitoring & academic analysis. 🚀 Fast, scalable.",
        "version": "0.1",
        "x-build-id": "tTIiNPT99k2jhxACO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeflow~reddit-comment-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeflow-reddit-comment-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapeflow~reddit-comment-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeflow-reddit-comment-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapeflow~reddit-comment-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeflow-reddit-comment-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Reddit Post URLs",
                        "type": "array",
                        "description": "List one or more Reddit post URLs (e.g., https://www.reddit.com/r/subreddit/comments/post_id/title/).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxComments": {
                        "title": "Maximum Comments per URL",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of comments to fetch per URL.",
                        "default": 1000
                    },
                    "replyLimit": {
                        "title": "Reply Limit per Comment",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of replies to store per comment in the nested `replies` field. Set to 0 for unlimited. (All replies are still collected in the flattened output.)",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Reddit rejects or blocks the request, it will fallback to datacenter proxy, then residential proxy with retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
