# Reddit Scraper All-in-One - Posts, Comments,& Email Finder (`pro100chok/reddit-scraper-all-in-one`) Actor

Scrape Reddit posts, comments, communities, users & search — no login, no API key. The only Reddit scraper that also
pulls emails, phone numbers & social links from users' profile websites. Fast & async. Export JSON, CSV or Excel for
lead gen, research & monitoring.

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

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## 🟠 Reddit Scraper All-in-One — Posts, Comments, Users, Communities & Email Finder

**Scrape Reddit at scale — no login, no API key, no code.** Extract Reddit
**posts, comments, subreddits (communities), user profiles and search results**
into clean JSON, CSV or Excel. Plus a feature no other Reddit scraper has:
it **finds emails, phone numbers and social media links** from the websites
people share in their Reddit profiles — turning Reddit into a lead-generation
goldmine. 🚀

> Works as an all-in-one replacement for Reddit Scraper, Reddit Scraper Lite,
> Reddit Scraper Pro and Reddit Search — one actor for everything.

---

### ✨ What you can scrape

| Source | Data you get |
|--------|--------------|
| **📝 Posts** | title, body text, author, score, upvotes, upvote ratio, number of comments, flair, media (images/video/galleries), awards, NSFW/spoiler/pinned flags, timestamps |
| **💬 Comments** | full nested comment threads, author, score, depth, reply counts, timestamps |
| **👥 Communities (subreddits)** | members, active users, description, creation date, icons & banners, NSFW flag, type |
| **🧑 Users** | post & comment karma, total karma, account age, verified status, avatar & banner, recent posts and comments |
| **🔍 Search** | posts, communities and users by any keyword, with sort & time filters |
| **📧 Contacts** | emails, phone numbers & social links pulled from profile websites |

Pick a **Scrape type**, then drop your inputs into the **Items** field — that's
it. One mode for each job:

| 🎯 Scrape type | What to put in **Items** |
|----------------|--------------------------|
| 🔍 **Search by keyword** | search terms (e.g. `nike running shoes`) |
| 📋 **Posts from a community** | subreddit names or URLs (`Entrepreneur`, `r/python`) |
| 💬 **Post / thread + comments** | post URLs or IDs |
| 🧑 **User profiles** | usernames or profile URLs (`spez`, `u/spez`) |
| 🔗 **Any Reddit URL** | a mix of Reddit links — type auto-detected per item |

---

### 🎯 Popular use cases

- **Lead generation** — collect emails, phone numbers and social links from
  active users in your niche.
- **Market & audience research** — track what your target communities talk
  about, complain about and recommend.
- **Brand & reputation monitoring** — find every mention of your product,
  competitor or keyword across Reddit.
- **Content & trend discovery** — pull top/hot/rising posts to find viral ideas.
- **Sentiment analysis & AI training** — export large, clean comment datasets.
- **Influencer & community discovery** — find the most active users and
  fastest-growing subreddits in any topic.

---

### 💎 The killer feature: contact & email extraction

For every Reddit user profile, this scraper automatically:

1. Reads the bio and finds linked **websites** and **social handles**.
2. Visits each website (home page + `contact` / `about` / `impressum` pages).
3. Harvests **email addresses**, **phone numbers** and **social media links**
   — Twitter/X, Instagram, Telegram, LinkedIn, Facebook, YouTube, TikTok,
   GitHub, Discord and more — including hidden `name [at] domain [dot] com`
   formats.

**Other Reddit scrapers don't do this.** It's what makes this the best Reddit
scraper for sales, recruiting and outreach.

---

### ⚙️ Easy to configure

Set it up in seconds — every option has a friendly toggle in the input form:

- **Scrape type** — pick one mode: keyword search, posts from a community,
  a single post/thread with comments, user profiles, or any Reddit URL.
- **Search types** — posts, communities, users (any combination).
- **Filters** — sort (relevance / hot / top / new / rising / most comments),
  time range (hour → all time), include or skip NSFW.
- **Limits** — max items, max posts per source, max comments per post, max
  activity per user — so you stay in full control of cost.
- **Contact extraction** — turn email/phone/social harvesting on or off.
- **Proxy** — built-in, fully automatic. The actor uses the right residential
  proxies for Reddit so you never have to configure anything.

---

### 📤 Output

Every result is a flat, ready-to-use record. Export to **JSON, CSV, Excel,
HTML or XML**, or pull it straight from the Apify API into your app, Google
Sheets, Make/Zapier or your database.

```json
{
  "type": "post",
  "title": "How I got my first 100 customers",
  "author": "startup_founder",
  "community": "r/Entrepreneur",
  "score": 1543,
  "upvoteRatio": 0.97,
  "numberOfComments": 218,
  "url": "https://www.reddit.com/r/Entrepreneur/comments/...",
  "createdAt": "2026-05-20T14:08:11+00:00"
}
````

***

### ❓ FAQ

**Do I need a Reddit account or API key?**
No. It works anonymously out of the box — just provide URLs or keywords.

**Is it fast?**
Yes — it's fully asynchronous and scrapes many sources in parallel.

**Can I scrape comments from a specific post?**
Yes. Paste the post URL and enable comments; you'll get the full thread.

**Can I scrape all posts from a subreddit?**
Yes — paste `r/yoursubreddit` and set how many posts you want; pagination is
handled automatically.

**Is scraping Reddit legal?**
This actor collects only publicly available data. You are responsible for using
the data in line with Reddit's terms and applicable laws (e.g. GDPR).

***

### 🏷️ Keywords

reddit scraper, reddit api, scrape reddit, reddit data extractor, reddit posts
scraper, reddit comments scraper, reddit user scraper, subreddit scraper, reddit
search scraper, reddit email scraper, reddit lead generation, reddit email
finder, social media scraper, reddit crawler, reddit export csv.

# Actor input Schema

## `scrapeType` (type: `string`):

Pick what to scrape, then open the matching section below to fine-tune it. The **Items** field is interpreted according to this choice.

## `items` (type: `array`):

One value per line, interpreted by the **Scrape type** above:

- **Search by keyword** → search terms (e.g. `nike running shoes`)
- **Posts from a community** → subreddit names or URLs (e.g. `Entrepreneur`, `r/python`)
- **Post / thread + comments** → post URLs or IDs (e.g. `https://www.reddit.com/r/python/comments/abc123/...`)
- **User profiles** → usernames or profile URLs (e.g. `spez`, `u/spez`)
- **Any Reddit URL** → mixed Reddit URLs; the type is auto-detected per item

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

Sort order for listings and search.

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

Time window for Top/search results.

## `searchWithinCommunity` (type: `string`):

Optional subreddit name (without r/) to limit keyword searches to.

## `searchPosts` (type: `boolean`):

Return posts matching the search terms.

## `searchCommunities` (type: `boolean`):

Return subreddits matching the search terms.

## `searchUsers` (type: `boolean`):

Return user profiles matching the search terms.

## `scrapeComments` (type: `boolean`):

Fetch comments for posts (post/thread URLs and subreddit listings).

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

Max comments fetched for each post.

## `includeCommunityDetails` (type: `boolean`):

For each subreddit (r/…) source, also output a community record (members, description, icons, etc.) before its posts.

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

Include adult / over-18 content.

## `includeUserPosts` (type: `boolean`):

Include each user's recent submitted posts.

## `includeUserComments` (type: `boolean`):

Include each user's recent comments.

## `maxUserPosts` (type: `integer`):

Max recent posts AND comments to fetch per user profile.

## `extractContacts` (type: `boolean`):

For user profiles: find websites linked in the bio, crawl them DIRECTLY (without proxy) and harvest e-mail addresses, phone numbers and social links. This is the killer feature competitors don't have. 🚀

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

Hard cap on the total number of records saved to the dataset.

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

Max posts to pull from each subreddit / search.

## `maxConcurrency` (type: `integer`):

How many sources to process in parallel.

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

Retries per request on connection / rate-limit errors.

## Actor input object example

```json
{
  "scrapeType": "search",
  "items": [
    "nike"
  ],
  "sort": "new",
  "time": "all",
  "searchPosts": true,
  "searchCommunities": false,
  "searchUsers": false,
  "scrapeComments": true,
  "maxCommentsPerPost": 50,
  "includeCommunityDetails": true,
  "includeNSFW": true,
  "includeUserPosts": true,
  "includeUserComments": true,
  "maxUserPosts": 25,
  "extractContacts": true,
  "maxItems": 50,
  "maxPostsPerSource": 50,
  "maxConcurrency": 10,
  "maxRetries": 5
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `contacts` (type: `string`):

No description

# 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 = {
    "items": [
        "nike"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("pro100chok/reddit-scraper-all-in-one").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 = { "items": ["nike"] }

# Run the Actor and wait for it to finish
run = client.actor("pro100chok/reddit-scraper-all-in-one").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 '{
  "items": [
    "nike"
  ]
}' |
apify call pro100chok/reddit-scraper-all-in-one --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Scraper All-in-One - Posts, Comments,& Email Finder",
        "description": "Scrape Reddit posts, comments, communities, users & search — no login, no API key. The only Reddit scraper that also\n  pulls emails, phone numbers & social links from users' profile websites. Fast & async. Export JSON, CSV or Excel for\n  lead gen, research & monitoring.",
        "version": "1.0",
        "x-build-id": "yAERr7MsC0ruzc1W8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/pro100chok~reddit-scraper-all-in-one/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-pro100chok-reddit-scraper-all-in-one",
                "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/pro100chok~reddit-scraper-all-in-one/runs": {
            "post": {
                "operationId": "runs-sync-pro100chok-reddit-scraper-all-in-one",
                "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/pro100chok~reddit-scraper-all-in-one/run-sync": {
            "post": {
                "operationId": "run-sync-pro100chok-reddit-scraper-all-in-one",
                "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": [
                    "items"
                ],
                "properties": {
                    "scrapeType": {
                        "title": "🎯 Scrape type",
                        "enum": [
                            "search",
                            "subreddit",
                            "post",
                            "user",
                            "url"
                        ],
                        "type": "string",
                        "description": "Pick what to scrape, then open the matching section below to fine-tune it. The **Items** field is interpreted according to this choice.",
                        "default": "search"
                    },
                    "items": {
                        "title": "📝 Items",
                        "type": "array",
                        "description": "One value per line, interpreted by the **Scrape type** above:\n\n- **Search by keyword** → search terms (e.g. `nike running shoes`)\n- **Posts from a community** → subreddit names or URLs (e.g. `Entrepreneur`, `r/python`)\n- **Post / thread + comments** → post URLs or IDs (e.g. `https://www.reddit.com/r/python/comments/abc123/...`)\n- **User profiles** → usernames or profile URLs (e.g. `spez`, `u/spez`)\n- **Any Reddit URL** → mixed Reddit URLs; the type is auto-detected per item",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "↕️ Sort",
                        "enum": [
                            "relevance",
                            "hot",
                            "top",
                            "new",
                            "rising",
                            "comments"
                        ],
                        "type": "string",
                        "description": "Sort order for listings and search.",
                        "default": "new"
                    },
                    "time": {
                        "title": "🕒 Time range",
                        "enum": [
                            "all",
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year"
                        ],
                        "type": "string",
                        "description": "Time window for Top/search results.",
                        "default": "all"
                    },
                    "searchWithinCommunity": {
                        "title": "📍 Restrict search to community",
                        "type": "string",
                        "description": "Optional subreddit name (without r/) to limit keyword searches to."
                    },
                    "searchPosts": {
                        "title": "📝 Search posts",
                        "type": "boolean",
                        "description": "Return posts matching the search terms.",
                        "default": true
                    },
                    "searchCommunities": {
                        "title": "👥 Search communities",
                        "type": "boolean",
                        "description": "Return subreddits matching the search terms.",
                        "default": false
                    },
                    "searchUsers": {
                        "title": "🧑 Search users",
                        "type": "boolean",
                        "description": "Return user profiles matching the search terms.",
                        "default": false
                    },
                    "scrapeComments": {
                        "title": "💭 Scrape comments",
                        "type": "boolean",
                        "description": "Fetch comments for posts (post/thread URLs and subreddit listings).",
                        "default": true
                    },
                    "maxCommentsPerPost": {
                        "title": "💬 Max comments per post",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Max comments fetched for each post.",
                        "default": 50
                    },
                    "includeCommunityDetails": {
                        "title": "🏷️ Include community details",
                        "type": "boolean",
                        "description": "For each subreddit (r/…) source, also output a community record (members, description, icons, etc.) before its posts.",
                        "default": true
                    },
                    "includeNSFW": {
                        "title": "🔞 Include NSFW",
                        "type": "boolean",
                        "description": "Include adult / over-18 content.",
                        "default": true
                    },
                    "includeUserPosts": {
                        "title": "📤 Include user posts",
                        "type": "boolean",
                        "description": "Include each user's recent submitted posts.",
                        "default": true
                    },
                    "includeUserComments": {
                        "title": "🗨️ Include user comments",
                        "type": "boolean",
                        "description": "Include each user's recent comments.",
                        "default": true
                    },
                    "maxUserPosts": {
                        "title": "🗂️ Max activity per user",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Max recent posts AND comments to fetch per user profile.",
                        "default": 25
                    },
                    "extractContacts": {
                        "title": "📧 Extract contacts (emails, phones, socials)",
                        "type": "boolean",
                        "description": "For user profiles: find websites linked in the bio, crawl them DIRECTLY (without proxy) and harvest e-mail addresses, phone numbers and social links. This is the killer feature competitors don't have. 🚀",
                        "default": true
                    },
                    "maxItems": {
                        "title": "🔢 Max items (total)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the total number of records saved to the dataset.",
                        "default": 50
                    },
                    "maxPostsPerSource": {
                        "title": "📚 Max posts per source",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Max posts to pull from each subreddit / search.",
                        "default": 50
                    },
                    "maxConcurrency": {
                        "title": "⚡ Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many sources to process in parallel.",
                        "default": 10
                    },
                    "maxRetries": {
                        "title": "🔁 Max retries",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Retries per request on connection / rate-limit errors.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
