# Reddit Scraper — Posts, Comments & Subreddits ✅ No Login (`themineworks/reddit-scraper`) Actor

Cheapest Reddit scraper: posts, comments, scores & subreddits. 100% free, no subscription, no API key. Works in Claude, ChatGPT & any MCP-compatible AI agent. MCP server: the-mine-works-mcp.hatchable.site

- **URL**: https://apify.com/themineworks/reddit-scraper.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Social media, Developer tools, MCP servers
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 — Pay Per Result, Deep History, Full Comment Trees

Scrape Reddit posts, comments, subreddits, search results, and user histories — without a monthly rental fee. This actor charges only for posts actually scraped, handles deep historical backfill through Reddit's full pagination API, and delivers nested comment trees that most alternatives silently truncate.

**Keywords:** reddit scraper, reddit api, scrape reddit posts, reddit comments scraper, subreddit scraper, reddit data, reddit post scraper

---

### Why This Beats the Alternatives

The most-used Reddit scrapers on the Apify Store have a consistent set of problems:

| Problem with incumbents | This actor |
|---|---|
| Monthly rental ($45+/mo) regardless of usage | **Pay only for what you scrape — $2.50 per 1,000 posts** |
| Comment trees silently truncated or broken | Full recursive comment trees up to configurable depth |
| Hard ceiling of ~1,000 posts per run | Paginate as deep as Reddit allows via `after` cursor |
| Charged even when a run returns zero results | **Zero charge on empty runs — actor fails with explanation** |
| No way to resume or do historical backfill | Expose the `after` cursor so you can resume exactly where you left off |
| Opaque errors | Every error pushed as a typed item in the dataset; summary always present |

The two-year track record of 2.7-star reviews on competing actors comes down to these four issues. This actor was built specifically to fix all of them.

---

### Features

- **4 scraping modes:** subreddit listings, Reddit-wide search, user post history, and specific post URLs
- **Deep historical backfill:** paginate through Reddit's full history using the `after` cursor — not capped at 100 or 1,000 posts
- **Cursor resume:** the summary item always contains `last_after_cursor` so you can continue a run exactly where it left off by passing it as input
- **Full nested comment trees:** recursive extraction up to configurable depth (default 3), with `more` stubs preserved so you know where truncation occurred
- **Honest billing:** PPE (pay-per-event) — charged exactly once per successfully scraped post, never on fetch errors or empty runs
- **Zero charge on empty runs:** if no posts are scraped the actor calls `Actor.fail()` with a plain-English reason — your balance is untouched
- **Graceful error handling:** HTTP 429 with exponential backoff (5s / 10s / 20s), 404 and 403 handled per-resource, never crashes the whole run on a single bad post
- **Responsible rate limiting:** 1-second delay between page requests, proper `User-Agent` header on every request per Reddit's API requirements

---

### Output Schema

Each post is one dataset item:

```json
{
  "id": "abc123",
  "name": "t3_abc123",
  "subreddit": "MachineLearning",
  "subreddit_id": "t5_2fwo",
  "title": "GPT-4 vs Claude 3 — which wins on reasoning?",
  "author": "username123",
  "score": 1842,
  "upvote_ratio": 0.97,
  "url": "https://i.imgur.com/example.jpg",
  "permalink": "https://www.reddit.com/r/MachineLearning/comments/abc123/...",
  "selftext": "I ran 200 reasoning tasks on both...",
  "is_self": true,
  "domain": "self.MachineLearning",
  "flair": "Discussion",
  "num_comments": 247,
  "created_utc": 1717200000,
  "is_pinned": false,
  "is_locked": false,
  "awards_count": 5,
  "scraped_at": "2026-06-05T10:00:00.000Z",
  "comments": [
    {
      "id": "xyz789",
      "author": "commenter_a",
      "body": "Claude wins on multi-step reasoning, GPT-4 on coding.",
      "score": 312,
      "created_utc": 1717201000,
      "is_submitter": false,
      "depth": 0,
      "replies": [
        {
          "id": "pqr456",
          "author": "commenter_b",
          "body": "Agree, tested this last week.",
          "score": 88,
          "created_utc": 1717201500,
          "is_submitter": false,
          "depth": 1,
          "replies": []
        }
      ]
    }
  ]
}
````

`comments` is only present when `includeComments=true`. Deleted posts have `author: "[deleted]"` and `selftext: "[removed]"` — exactly as Reddit returns them.

At the end of every run, a summary item is pushed:

```json
{
  "_type": "summary",
  "posts_requested": 200,
  "posts_scraped": 197,
  "posts_failed": 3,
  "subreddits_processed": 2,
  "charged_for": 197,
  "last_after_cursor": "t3_xyz999",
  "scraped_at": "2026-06-05T10:04:22.000Z"
}
```

Pass `last_after_cursor` back in as the `after` input field on your next run to continue from exactly that point — this is the deep historical backfill feature.

***

### Pricing

**$2.50 per 1,000 posts scraped.**

- No monthly fee, no minimum, no rental
- Charged per-event (PPE) — only on successful scrapes
- Zero charge if the run returns no results
- A run scraping 250 posts costs $0.625

This is the standard Apify pay-per-result model. You pay for outcomes, not for time on the platform.

***

### Use Cases

- **Market research** — scrape subreddit discussions to understand what customers say about your product or competitors, unsolicited and unfiltered
- **Sentiment analysis** — collect scored posts and comments to build training datasets or feed NLP pipelines
- **AI training data** — gather large volumes of human-written text across diverse topics for fine-tuning or RLHF
- **Brand monitoring** — track mentions of your brand or keywords across all of Reddit with scheduled runs
- **Academic research** — download historical threads with full comment trees for discourse analysis, misinformation studies, community dynamics
- **Competitive intelligence** — monitor competitor subreddits, feature request threads, and complaint patterns

***

### Rate Limits & Responsible Use

Reddit's public JSON API does not require OAuth for read-only access but does require:

1. A descriptive `User-Agent` header (included in every request)
2. No more than ~1 request per second (enforced by the 1s inter-page delay)

This actor targets Reddit's public JSON endpoints (`*.reddit.com/*.json`) rather than scraping rendered HTML. This is the same approach used by countless Reddit apps and is stable. If Reddit returns HTTP 429, the actor backs off automatically (5s → 10s → 20s) before retrying.

**Do not** use this actor to:

- Harvest personal data for advertising or resale
- Bypass Reddit's rate limits by running many parallel actors simultaneously
- Violate Reddit's [User Agreement](https://www.reddit.com/help/useragreement) or [Privacy Policy](https://www.reddit.com/help/privacypolicy)

Private subreddits, banned subreddits, and suspended users will return 403/404 — those runs still push error items explaining why, and you are not charged for them.

***

### Input Reference

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | enum | — | `subreddit`, `search`, `user`, or `post` |
| `subreddits` | string\[] | `[]` | Subreddit names (mode=subreddit) |
| `searchQuery` | string | — | Search query (mode=search) |
| `username` | string | — | Reddit username (mode=user) |
| `postUrls` | string\[] | `[]` | Full post URLs (mode=post) |
| `sortBy` | enum | `hot` | `hot`, `new`, `top`, `rising` |
| `timeframe` | enum | `all` | `hour`, `day`, `week`, `month`, `year`, `all` |
| `maxPosts` | integer | 25 | Max posts to scrape (1–1000) |
| `includeComments` | boolean | `false` | Fetch comment trees |
| `maxCommentsPerPost` | integer | 100 | Max comments per post (1–500) |
| `maxDepth` | integer | 3 | Max comment reply depth |
| `after` | string | — | Pagination cursor for historical backfill resume |
| `skipPinnedPosts` | boolean | `false` | Skip stickied/pinned posts |

### Related Actors

| Actor | Use case |
|-------|----------|
| [Threads Scraper](https://apify.com/themineworks/threads-scraper) | Same topics on Meta's Threads platform |
| [Instagram Profile Scraper](https://apify.com/themineworks/instagram-profile-scraper) | Brand/creator profiles linked from Reddit posts |
| [Google Trends Pro](https://apify.com/themineworks/google-trends-pro) | Validate Reddit topic spikes against search interest data |

# Actor input Schema

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

What to scrape. Choose subreddit, search, user, or specific post URLs.

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

List of subreddit names to scrape (without r/ prefix). Used when mode=subreddit.

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

Search query string. Used when mode=search. Supports Reddit's full search syntax.

## `username` (type: `string`):

Reddit username (without u/ prefix). Used when mode=user.

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

Full Reddit post URLs to scrape with comments. Used when mode=post.

## `sortBy` (type: `string`):

How to sort posts. 'top' can be combined with a timeframe.

## `timeframe` (type: `string`):

Time window when using sort=top. Ignored for other sort types.

## `maxPosts` (type: `integer`):

Maximum number of posts to scrape. You are charged only for posts actually scraped.

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

Fetch and include the comment tree for each post. Increases run time and cost.

## `maxCommentsPerPost` (type: `integer`):

Maximum number of top-level comments to fetch per post. Only used when includeComments=true.

## `maxDepth` (type: `integer`):

How deep to recurse into comment reply threads. 1 = top-level only, 3 = three levels deep.

## `after` (type: `string`):

Reddit 'after' cursor for resuming or deep historical backfill. Paste the cursor from a previous run's summary item to continue where it left off.

## `skipPinnedPosts` (type: `boolean`):

Skip mod-pinned/stickied posts at the top of subreddit listings.

## `clientId` (type: `string`):

Optional. Your own Reddit OAuth client ID for higher rate limits. Get one at https://www.reddit.com/prefs/apps (choose 'installed app' type). Leave blank to use the actor's shared credentials (subject to lower shared rate limit).

## Actor input object example

```json
{
  "mode": "subreddit",
  "subreddits": [
    "MachineLearning",
    "Python",
    "startups"
  ],
  "searchQuery": "lab grown diamonds engagement ring",
  "username": "spez",
  "postUrls": [
    "https://www.reddit.com/r/MachineLearning/comments/abc123/some_post_title/"
  ],
  "sortBy": "hot",
  "timeframe": "all",
  "maxPosts": 5,
  "includeComments": false,
  "maxCommentsPerPost": 100,
  "maxDepth": 3,
  "skipPinnedPosts": 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 = {
    "mode": "subreddit",
    "subreddits": [
        "python"
    ],
    "maxPosts": 5
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "mode": "subreddit",
    "subreddits": ["python"],
    "maxPosts": 5,
}

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

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

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

```

## CLI example

```bash
echo '{
  "mode": "subreddit",
  "subreddits": [
    "python"
  ],
  "maxPosts": 5
}' |
apify call themineworks/reddit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Scraper — Posts, Comments & Subreddits ✅ No Login",
        "description": "Cheapest Reddit scraper: posts, comments, scores & subreddits. 100% free, no subscription, no API key. Works in Claude, ChatGPT & any MCP-compatible AI agent. MCP server: the-mine-works-mcp.hatchable.site",
        "version": "0.1",
        "x-build-id": "5IzdG41w5sAJ9IMFK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/themineworks~reddit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-themineworks-reddit-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/themineworks~reddit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-themineworks-reddit-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/themineworks~reddit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-themineworks-reddit-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "subreddit",
                            "search",
                            "user",
                            "post"
                        ],
                        "type": "string",
                        "description": "What to scrape. Choose subreddit, search, user, or specific post URLs.",
                        "default": "subreddit"
                    },
                    "subreddits": {
                        "title": "Subreddits",
                        "type": "array",
                        "description": "List of subreddit names to scrape (without r/ prefix). Used when mode=subreddit.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search query string. Used when mode=search. Supports Reddit's full search syntax."
                    },
                    "username": {
                        "title": "Reddit Username",
                        "type": "string",
                        "description": "Reddit username (without u/ prefix). Used when mode=user."
                    },
                    "postUrls": {
                        "title": "Post URLs",
                        "type": "array",
                        "description": "Full Reddit post URLs to scrape with comments. Used when mode=post.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "hot",
                            "new",
                            "top",
                            "rising"
                        ],
                        "type": "string",
                        "description": "How to sort posts. 'top' can be combined with a timeframe.",
                        "default": "hot"
                    },
                    "timeframe": {
                        "title": "Timeframe (for Top sort)",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time window when using sort=top. Ignored for other sort types.",
                        "default": "all"
                    },
                    "maxPosts": {
                        "title": "Max Posts",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of posts to scrape. You are charged only for posts actually scraped.",
                        "default": 25
                    },
                    "includeComments": {
                        "title": "Include Comments",
                        "type": "boolean",
                        "description": "Fetch and include the comment tree for each post. Increases run time and cost.",
                        "default": false
                    },
                    "maxCommentsPerPost": {
                        "title": "Max Comments Per Post",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of top-level comments to fetch per post. Only used when includeComments=true.",
                        "default": 100
                    },
                    "maxDepth": {
                        "title": "Max Comment Depth",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How deep to recurse into comment reply threads. 1 = top-level only, 3 = three levels deep.",
                        "default": 3
                    },
                    "after": {
                        "title": "Pagination Cursor (after)",
                        "type": "string",
                        "description": "Reddit 'after' cursor for resuming or deep historical backfill. Paste the cursor from a previous run's summary item to continue where it left off."
                    },
                    "skipPinnedPosts": {
                        "title": "Skip Pinned Posts",
                        "type": "boolean",
                        "description": "Skip mod-pinned/stickied posts at the top of subreddit listings.",
                        "default": false
                    },
                    "clientId": {
                        "title": "Reddit Client ID (optional)",
                        "type": "string",
                        "description": "Optional. Your own Reddit OAuth client ID for higher rate limits. Get one at https://www.reddit.com/prefs/apps (choose 'installed app' type). Leave blank to use the actor's shared credentials (subject to lower shared rate limit)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
