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

💬 Reddit Comment Scraper (reddit-comment-scraper) captures comments from posts & subreddits—text, authors, scores, timestamps, permalinks & nesting. 🔎 Export CSV/JSON for research, social listening, sentiment & trend analysis. ⚡ Fast, reliable, API-ready.

- **URL**: https://apify.com/scraply/reddit-comment-scraper.md
- **Developed by:** [Scraply](https://apify.com/scraply) (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 production-ready Apify actor that collects structured comment data from public Reddit post URLs — a fast, reliable reddit comment extractor to scrape reddit comments at scale for research, social listening, and analytics. Built in Python, it works as a focused reddit thread comment scraper to capture text, authors, scores, permalinks, and nesting, and it’s API-ready for teams that need to export reddit comments to CSV or JSON. Perfect for marketers, developers, data analysts, and researchers, it enables large-scale monitoring and insight generation across subreddits.

### What data / output can you get?

Below are the exact fields pushed to the Apify dataset for each comment record. You can export results to JSON, CSV, or Excel directly from the Apify dataset UI or via API.

| Data field | Description | Example value |
| --- | --- | --- |
| url | The source Reddit post URL this comment belongs to | https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/ |
| comment_id | Unique Reddit comment identifier | lhk1f7n |
| post_id | Reddit post identifier (thing id format) | t3_1epeshq |
| author | Comment author username (or “[deleted]”) | AutoModerator |
| userUrl | Direct link to the author’s Reddit profile (empty for “[deleted]”) | https://www.reddit.com/user/AutoModerator/ |
| permalink | Direct link to the specific comment | https://www.reddit.com/r/ChatGPT/comments/1epeshq/these_are_all_ai/lhk1f7n/ |
| upvotes | Comment score (upvotes) | 1 |
| content_type | Content type label | text |
| parent_id | Parent thing ID (comment or post); null if none | t3_1epeshq |
| contentText | Cleaned text content of the comment | Comment text here... |
| created_time | Timestamp (if present in source; may be empty) |  |
| author_avatar | Author avatar URL if available (empty by default) |  |
| replies | Array of nested replies kept per replyLimit (each reply object has the same fields) | [] |

Notes:
- Dataset items are flattened at the comment level for easy analysis, while each item also includes a “replies” array to preserve conversation structure up to your configured reply limit.
- In addition to the dataset, the actor saves a grouped JSON to the key-value store under key “OUTPUT” in the shape: { "<post_url>": [<comment objects without the url field>] }.

### Key features

- ⚡ Automatic proxy fallback for reliability  
  Built-in smart fallback from direct connection to datacenter and then residential proxies with retries, so your reddit comment scraping bot stays resilient under blocking.

- 📦 Scalable bulk URL processing  
  Feed multiple Reddit post URLs in one run and handle large threads — ideal for a reddit post comments downloader or reddit comment scraping tool workflows.

- 🧵 Nested replies with depth control  
  Capture comment threads with a configurable replyLimit that controls how many replies are stored per comment in the nested “replies” field.

- 🚀 Async, high-throughput architecture  
  Implemented with aiohttp and async/await to collect more comments faster and reduce latency across large jobs.

- 🔌 API-ready, easy exporting  
  Access results via the Apify API and export reddit comments to CSV, JSON, or Excel — great for pipelines and dashboards.

- 🔒 No API keys or login required  
  Works on publicly available Reddit JSON responses; a practical reddit comment scraper without API credentials.

- 🧪 Flexible sort orders  
  Supports Reddit’s standard sort orders (hot, new, top, controversial, old) for more control over comment retrieval.

- 🛠️ Production-grade logging and progress tracking  
  Clear progress updates (e.g., “Collected N comments so far”) and a final scraping summary for auditability.

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

1. Create or log in to your Apify account.  
2. Open the Apify Console and navigate to Actors, then find “reddit-comment-scraper”.  
3. Add input data:  
   - Paste one or more Reddit post URLs into startUrls.  
   - Optionally set maxComments (per URL) and replyLimit.  
   - Optionally configure proxyConfiguration.  
4. Click Run to start the job. The actor will fetch the post’s JSON, follow “more” comment placeholders, and expand nested threads.  
5. Monitor logs and progress in real-time to see how many comments have been collected.  
6. When finished, open the Dataset tab to review individual comment records.  
7. Export results to CSV, JSON, or Excel, or pull data via the Apify API for downstream workflows.  

Pro Tip: Use the Apify API to integrate the dataset into analytics stacks or automations (e.g., schedule recurring runs for social listening and sentiment tracking).

### Use cases

| Use case | Description |
| --- | --- |
| Market research + topic mining | Aggregate large volumes of thread comments to quantify opinions and extract themes around products, competitors, or trends. |
| Sentiment analysis for social listening | Feed comment text and metadata into NLP models to track sentiment shifts and emerging narratives. |
| Community & subreddit monitoring | Monitor discussions across specific subreddits by scraping Reddit comments from key threads regularly. |
| Academic & policy research | Collect structured comment-level datasets for behavioral studies and qualitative analysis. |
| Developer API pipeline | Use the Apify API to automate a reddit comment scraper Python workflow and stream datasets into your systems. |
| Content aggregation & curation | Capture insightful comments and reply threads to curate quotes, FAQs, or knowledge bases. |
| Competitive/brand analysis | Track brand mentions, upvotes, and discussion depth around campaigns or launches. |

### Why choose Reddit Comment Scraper?

Built for precision, automation, and reliability, this actor outperforms manual tools and unstable extensions for scraping Reddit post comments.

- ✅ Accurate, structured outputs: Clean fields for authors, scores, permalinks, parent-child relationships, and content.  
- 🌍 Scales to long threads: Expands “more” placeholders and handles large discussions efficiently.  
- 💻 Developer-friendly & API-ready: Fetch datasets via REST API and integrate into Python pipelines.  
- 🛡️ Safe & public-only: Scrapes publicly available content; no login or API keys required.  
- 💪 Resilient infrastructure: Automatic proxy fallback keeps collection running when direct access is blocked.  
- 💰 Cost-effective & predictable: Designed for reliable, repeatable workloads without brittle browser automation.  

In short: a production-grade reddit comment scraping tool vs. extension-based alternatives.

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

Yes — when done responsibly. This actor collects publicly available data from Reddit post pages and does not access private or authenticated content.

Guidelines for compliant use:
- Scrape only public pages and respect platform terms.  
- Do not target private subreddits or password-protected content.  
- Ensure your use complies with applicable laws (e.g., GDPR, CCPA).  
- Use the data ethically — for analysis and research, not spam.  

For edge cases, confirm requirements with your legal team.

### Input parameters & output format

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

Input fields (from the actor’s input schema):

- startUrls (array, required): List one or more Reddit post URLs (e.g., https://www.reddit.com/r/subreddit/comments/post\_id/title/).\
  Default: none.
- maxComments (integer, optional): Maximum number of comments to fetch per URL. Range: 1–10,000.\
  Default: 1000.
- replyLimit (integer, optional): 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.) Range: 0–100.\
  Default: 0.
- proxyConfiguration (object, optional): 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.\
  Prefill: { "useApifyProxy": false }.

Output: dataset items (one per comment), with the following fields:

- url, comment\_id, post\_id, author, permalink, upvotes, content\_type, parent\_id, author\_avatar, userUrl, contentText, created\_time, replies

Example dataset item:

```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": []
}
```

Also saved to the key-value store as grouped output under 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:

- Fields author\_avatar and created\_time may be empty when not provided by Reddit’s response.
- The “replies” array stores nested replies per the replyLimit, while each reply is also included as its own record in the dataset.

### FAQ

#### Is there a free tier or trial to test it?

Yes. The listing includes 120 trial minutes so you can evaluate the actor. For ongoing use, there’s a flat monthly price of $19.99 shown on the Apify Store. Actual billing depends on your Apify plan and usage.

#### Do I need Reddit API keys or login?

No. It works without login or OAuth — a reddit comment scraper without API keys. The actor uses publicly available JSON responses from Reddit post pages.

#### What types of content can it scrape?

It scrapes comments from public Reddit post URLs, including nested replies. It does not access private subreddits or require authentication.

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

You can set maxComments between 1 and 10,000 per URL. The actor will traverse “more” placeholders to retrieve additional batches until your limit is reached.

#### Does it capture nested replies?

Yes. Use replyLimit to control how many replies are stored per comment in the “replies” field. Set 0 for unlimited storage of nested replies (flattened comments are still collected either way).

#### What if Reddit blocks my requests?

The actor includes smart proxy fallback: it first tries a direct connection, then falls back to datacenter proxy, and finally residential proxy with retries to maximize success.

#### Can I export results to CSV?

Yes. Open the Dataset tab after the run and use the built-in export options to download CSV, JSON, or Excel. You can also fetch data via the Apify API.

#### Can I scrape subreddit comments in bulk?

Yes, by providing multiple Reddit post URLs from your target subreddits. The tool functions as a scalable reddit thread comment scraper for bulk processing.

### Closing CTA / Final thoughts

Reddit Comment Scraper is built for accurate, scalable extraction of Reddit post comments. It delivers structured records with authors, scores, permalinks, and nested replies, ready for research, social listening, and analytics.

Whether you’re a marketer, developer, data analyst, or researcher, you can run bulk jobs, export to CSV/JSON, and integrate via the Apify API for automation. Start collecting smarter Reddit insights today — and turn conversations into measurable, repeatable intelligence.

# 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("scraply/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("scraply/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 scraply/reddit-comment-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraply/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) captures comments from posts & subreddits—text, authors, scores, timestamps, permalinks & nesting. 🔎 Export CSV/JSON for research, social listening, sentiment & trend analysis. ⚡ Fast, reliable, API-ready.",
        "version": "0.1",
        "x-build-id": "FkKjisM4mvbwSv1xE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraply~reddit-comment-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraply-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/scraply~reddit-comment-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraply-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/scraply~reddit-comment-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraply-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
