# Reddit Scraper (`datasteady/reddit-scraper`) Actor

Pay Per Result, unlimited Reddit scraper — crawl posts, comments, upvote ratios, communities, and users without login or API key. $3/1,000 results. Drop-in Reddit Scraper Lite alternative: same input, same output fields, lower price.

- **URL**: https://apify.com/datasteady/reddit-scraper.md
- **Developed by:** [Sait](https://apify.com/datasteady) (community)
- **Categories:** Social media, News, AI
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 result storeds

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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, unlimited Reddit scraper to crawl posts, comments, communities, and users — without login. And the price you see is your entire bill.** Point it at any subreddit, user, post, or search, cap it by number of items, and get all the data in one dataset in multiple formats. No API key, no authentication, no rate-limit headaches. **Platform usage included, retries and IP rotation on us, empty runs cost nothing** — and the Actor is monitored around the clock, so breakage never reaches you silently.

### What does Reddit Scraper do?

Our unofficial Reddit extractor pulls data straight from Reddit with no authentication and no login. It gets posts and comments together with community and user info in a single run. Reddit Scraper lets you:

- **scrape subreddits** (communities) with top, hot, new, or rising posts
- **scrape Reddit posts** — title, body text, username, number of comments, votes, upvote ratio, and media
- **scrape Reddit comments** — text, timestamps, points, usernames, post and comment URLs
- **scrape user details** — karma, account age, and their most recent posts and comments
- **scrape community info** — subreddit member counts, descriptions, and creation dates
- **monitor brands and keywords** — combine `searchTerms` with `postDateLimit` on a schedule and each run returns only the fresh mentions (see below)
- **search communities** — find every subreddit around a topic, with member counts
- **sort scraped data** by Relevance, Hot, Top, New, or Rising
- **scrape by URL or by keyword** — mix subreddit, user, and post URLs freely in one run

### Monitor Reddit mentions of your brand — on autopilot

Reddit threads increasingly feed AI answers and Google results: what people say about your product on Reddit is what ChatGPT and Google tell your customers. This scraper is built for exactly that monitoring loop:

1. Set `searchTerms` to your brand/product keywords.
2. Set `postDateLimit` to today's date and put the Actor on an Apify **schedule** (e.g. daily).
3. Every run delivers **only the new posts** since your cutoff — no duplicates, no noise — straight to your dataset, webhook, or Slack.

You pay only for the fresh mentions found. A quiet day costs nearly nothing; a viral day is exactly the day you want the data.

### What data can I extract from Reddit?

| Type | Fields |
|---|---|
| 📝 **Post** | id, url, title, body, username, communityName, numberOfComments, upVotes, upVoteRatio, imageUrls, videoUrls, createdAt, flair, domain, isNSFW, isVideo, isStickied |
| 💬 **Comment** | id, url, body, username, upVotes, createdAt, post & comment permalinks |
| 👥 **Community** | name, url, subscribers, description |
| 👤 **User** | username, linkKarma, commentKarma, createdAt + their recent posts and comments |

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

**Pay per result — all-inclusive.** You're billed only for the items delivered to your dataset, never for our retries, blocked requests, or infrastructure. No platform usage charges, no start fees, no monthly minimums. Predictable to the cent: 1,000 results costs a fixed, transparent price (see the **Pricing** tab), and a run that finds nothing costs nothing. That's the whole bill.

We take reliability personally: the Actor runs scheduled health checks around the clock, and Reddit-side changes are typically fixed before you notice them. If something ever looks off, open an issue — real maintainers respond.

### How to scrape Reddit

1. Click **Try for free**.
2. Add one or more full Reddit URLs (subreddits, users, or posts) to **Start URLs**, or type a keyword into **Search Terms**.
3. Set your limits (`maxPostCount`, `maxComments`, `maxUserCount`).
4. Run it, then download the dataset as JSON, CSV, Excel, XML, or JSONL — or pull it via API.

#### How to use scraped Reddit data
Market research, brand and sentiment monitoring, lead generation, trend tracking, training data, competitive analysis — clean structured Reddit data, ready for your pipeline.

### Input parameters

| Field | Type | Description |
|---|---|---|
| `startUrls` | array | Reddit URLs: subreddits `/r/x/`, users `/user/x/`, posts `/comments/id/`. Mix freely. |
| `searchTerms` | array | Keywords to search Reddit for. |
| `sort` | string | `hot` · `new` · `top` · `rising` · `relevance` |
| `maxPostCount` | integer | Max posts per source. |
| `maxComments` | integer | Comments per post. `0` = posts only; `>0` fetches full post pages (body + upvote ratio + comments). |
| `maxUserCount` | integer | Max user profiles to scrape. |
| `maxCommunitiesCount` | integer | Max community (subreddit) info items. `0` = one per subreddit URL. |
| `skipCommunity` | boolean | Don't emit community info items. |
| `postDateLimit` | string | Only posts at/after this ISO date (`2026-07-01`) or datetime. The backbone of scheduled monitoring: each run returns only fresh posts. |
| `searchPosts` | boolean | Search posts for the given terms (default `true`). |
| `searchCommunities` | boolean | Also search communities (subreddits) — returns community items with member counts. |
| `searchComments` | boolean | Accepted for compatibility; comment search isn't available without login, so posts are searched instead. |
| `includeMediaLinks` | boolean | Accepted for compatibility; media links (`imageUrls`/`videoUrls`) are always included. |

#### Input example
```json
{
  "startUrls": ["https://www.reddit.com/r/programming/", "https://www.reddit.com/user/spez/"],
  "searchTerms": ["cloudflare workers"],
  "sort": "top",
  "maxPostCount": 50,
  "maxComments": 20
}
````

### Results

#### 📝 Example Reddit post

```json
{ "dataType": "post", "id": "t3_abc123", "title": "An Update from the Team",
  "body": "Full post text…", "username": "spez", "communityName": "r/programming",
  "numberOfComments": 214, "upVotes": 941, "upVoteRatio": 0.96,
  "imageUrls": ["https://i.redd.it/…"], "url": "https://www.reddit.com/r/programming/comments/abc123/…",
  "createdAt": "2026-05-23T13:54:37Z", "flair": "Discussion", "isNSFW": false }
```

#### 💬 Example Reddit comment

```json
{ "dataType": "comment", "id": "t1_def456", "body": "Great write-up.",
  "username": "user123", "upVotes": 42, "createdAt": "2026-05-23T14:10:00Z" }
```

#### 👤 Example Reddit user

```json
{ "dataType": "user", "username": "spez", "linkKarma": 184005,
  "commentKarma": 756202, "createdAt": "2005-06-06T04:00:00Z" }
```

### Only need a few Reddit results?

Set a small `maxPostCount` — pay per result means a 20-post run costs a fraction of a cent. Test cheaply, scale when ready.

### Notes for developers

#### Reddit's 1,000 items limit

Reddit itself caps any single subreddit or search at ~1,000 items. To go beyond, split by time range, sort, or narrower queries.

#### Reliability, monitored

Unlike scrapers that quietly return empty datasets when Reddit changes, every run here is **quality-gated** (no CAPTCHA pages, no empty-but-"successful" results) and a live health-check watches every field — so drift is caught before it reaches your data.

### FAQ

**Is Reddit scraping legal?** Scraping publicly available data is generally legal. You are responsible for how you use the data (respect privacy laws and Reddit's terms).

**Do I need cookies or login?** No. This scraper reads public Reddit data with no authentication and no login.

**How do I scrape Reddit comments?** Set `maxComments` above `0` — the scraper fetches each post's full page and returns its comments.

**Do I need proxies?** Proxies are handled for you (residential). No setup required.

**Can I export/import via API?** Yes — every dataset is available via the Apify API in JSON, CSV, Excel, XML, or JSONL.

**Why can't I get more than 1,000 posts from a subreddit?** That's Reddit's own limit, not ours. Split by sort/time/query to collect more.

**Why choose this over other Reddit scrapers?** Same input and output fields as the scraper you're likely already using — switch by changing one actor ID, your integration keeps working — plus transparent pay-per-result pricing and monitored reliability so you're never the last to know when something breaks.

# Actor input Schema

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

Reddit URLs to scrape — subreddits (/r/x/), user profiles (/user/x/), or posts (/comments/id/). Mix freely.

## `searches` (type: `array`):

Keywords to search Reddit for. Ignored when Start URLs are provided.

## `searchTerms` (type: `array`):

Alias for 'searches'.

## `postDateLimit` (type: `string`):

Only posts at/after this date (ISO, e.g. 2026-07-01 or full datetime). Ideal for scheduled brand/keyword monitoring — each run returns only the fresh posts.

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

Search posts for the given terms.

## `searchComments` (type: `boolean`):

Accepted for compatibility. Comment search is not available token-free; posts are searched instead.

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

Also search communities (subreddits) for the given terms — returns community items with member counts.

## `includeMediaLinks` (type: `boolean`):

Accepted for compatibility. Media links (imageUrls/videoUrls) are always included.

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

Sort order for results.

## `maxPostCount` (type: `integer`):

Maximum posts to return per source.

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

Comments per post. 0 = posts only; > 0 fetches each post's full page for body, upvote ratio, and comments.

## `maxUserCount` (type: `integer`):

Maximum user profiles to scrape (when user URLs are provided).

## `maxCommunitiesCount` (type: `integer`):

Maximum community (subreddit) info items to emit. 0 = one per subreddit URL.

## `skipCommunity` (type: `boolean`):

Don't emit community (subreddit) info items.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/programming/"
    }
  ],
  "searchPosts": true,
  "searchComments": false,
  "searchCommunities": false,
  "includeMediaLinks": true,
  "sort": "hot",
  "maxPostCount": 25,
  "maxComments": 0,
  "maxUserCount": 10,
  "maxCommunitiesCount": 0,
  "skipCommunity": false
}
```

# Actor output Schema

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

Mixed items discriminated by dataType: post, comment, community, user.

# 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": [
        {
            "url": "https://www.reddit.com/r/programming/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datasteady/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 = { "startUrls": [{ "url": "https://www.reddit.com/r/programming/" }] }

# Run the Actor and wait for it to finish
run = client.actor("datasteady/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 '{
  "startUrls": [
    {
      "url": "https://www.reddit.com/r/programming/"
    }
  ]
}' |
apify call datasteady/reddit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Scraper",
        "description": "Pay Per Result, unlimited Reddit scraper — crawl posts, comments, upvote ratios, communities, and users without login or API key. $3/1,000 results. Drop-in Reddit Scraper Lite alternative: same input, same output fields, lower price.",
        "version": "0.1",
        "x-build-id": "Mb99SiiOlVK7cx0kz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datasteady~reddit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datasteady-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/datasteady~reddit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datasteady-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/datasteady~reddit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datasteady-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",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Reddit URLs to scrape — subreddits (/r/x/), user profiles (/user/x/), or posts (/comments/id/). Mix freely.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searches": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Keywords to search Reddit for. Ignored when Start URLs are provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search Terms (alias)",
                        "type": "array",
                        "description": "Alias for 'searches'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postDateLimit": {
                        "title": "Post Date Limit",
                        "type": "string",
                        "description": "Only posts at/after this date (ISO, e.g. 2026-07-01 or full datetime). Ideal for scheduled brand/keyword monitoring — each run returns only the fresh posts."
                    },
                    "searchPosts": {
                        "title": "Search Posts",
                        "type": "boolean",
                        "description": "Search posts for the given terms.",
                        "default": true
                    },
                    "searchComments": {
                        "title": "Search Comments",
                        "type": "boolean",
                        "description": "Accepted for compatibility. Comment search is not available token-free; posts are searched instead.",
                        "default": false
                    },
                    "searchCommunities": {
                        "title": "Search Communities",
                        "type": "boolean",
                        "description": "Also search communities (subreddits) for the given terms — returns community items with member counts.",
                        "default": false
                    },
                    "includeMediaLinks": {
                        "title": "Include Media Links",
                        "type": "boolean",
                        "description": "Accepted for compatibility. Media links (imageUrls/videoUrls) are always included.",
                        "default": true
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "hot",
                            "new",
                            "top",
                            "rising",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort order for results.",
                        "default": "hot"
                    },
                    "maxPostCount": {
                        "title": "Max Post Count",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum posts to return per source.",
                        "default": 25
                    },
                    "maxComments": {
                        "title": "Max Comments",
                        "type": "integer",
                        "description": "Comments per post. 0 = posts only; > 0 fetches each post's full page for body, upvote ratio, and comments.",
                        "default": 0
                    },
                    "maxUserCount": {
                        "title": "Max User Count",
                        "type": "integer",
                        "description": "Maximum user profiles to scrape (when user URLs are provided).",
                        "default": 10
                    },
                    "maxCommunitiesCount": {
                        "title": "Max Communities Count",
                        "type": "integer",
                        "description": "Maximum community (subreddit) info items to emit. 0 = one per subreddit URL.",
                        "default": 0
                    },
                    "skipCommunity": {
                        "title": "Skip Community Info",
                        "type": "boolean",
                        "description": "Don't emit community (subreddit) info items.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
