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

Scrape posts from any subreddit or user profile — no key, no login. Sort by top/hot/new/rising/controversial over any time window. Returns full post data plus optional clean-text/TTS-ready fields. For research, trend monitoring, video pipelines, datasets, lead gen, and more.

- **URL**: https://apify.com/dami\_studio/reddit-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** Social media, AI, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 reddit post scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

Pulls posts from any subreddit or user profile without an API key or login. Point it at a list of sources, pick a sort and time window, and you get back full post data including the body text (selftext), with optional cleaned, TTS-ready narration. Built for people batching Reddit content: short-form video scripts, research datasets, content monitoring.

### How it works

Reddit hard-blocks the anonymous `.json` API but still serves Atom RSS feeds from separate infrastructure that isn't rate-limited the same way, so the default `rss` method reads those feeds and parses them into structured records. RSS doesn't expose upvote scores or comments, so if you need those, add free Reddit "script" app credentials and the actor switches to the authenticated OAuth endpoint for that data.

### Input

Nothing is strictly required. If you pass no `sources`, the actor falls back to its prefilled examples. The fields you'll actually touch:

| Field | Required | Notes |
| --- | --- | --- |
| `sources` | no | Array of subreddits and/or user profiles. Accepts `tifu`, `r/tifu`, `u/spez`, `user/spez`, or a full reddit.com URL. Mixed lists are fine. |
| `sort` | no | One of `top`, `hot`, `new`, `rising`, `controversial`. Defaults to `top`. |
| `time` | no | Time window for `top` and `controversial`: `hour`, `day`, `week`, `month`, `year`, `all`. Ignored for the other sorts. Defaults to `day`. |
| `maxPostsPerSubreddit` | no | How many posts to return per source. Defaults to 10, max 100. |
| `method` | no | `rss` (default, no login), `oauth` (uses the creds below, adds scores/comments), or `json` (legacy anonymous API, usually blocked). |
| `cleanText` | no | Strips markdown, links, and edit stamps to produce narration sentences. On by default. Turn it off for raw text. |
| `requireStory` | no | Keep only text posts and apply the word-count fit. Off by default, which returns all post types. |
| `commentLimit` | no | Top comments to fetch per post. Needs Reddit app creds to be reliable; anonymous comment access is usually blocked. Defaults to 0. |
| `redditClientId` / `redditClientSecret` | no | Free "script" app credentials from reddit.com/prefs/apps. Only needed for comments and upvote scores. |
| `minScore`, `minWords`, `maxWords`, `minHookScore`, `includeNsfw`, `dedupeAcrossRuns` | no | Filters and run-to-run dedupe. Sensible defaults; leave them alone unless you're filtering for short-form fit. |
| `proxyConfiguration` | no | Residential proxy is recommended at volume. The RSS feeds work from most IPs, so it's not mandatory for small runs. |

### Output

Each post is one dataset item. Alongside the metadata you get `selftext` (the full post body) and, when `cleanText` is on, a `narration` field plus `ttsSegments` split into sentences ready to hand to a text-to-speech step.

Key fields: `id`, `subreddit`, `title`, `url`, `author`, `score`, `numComments`, `createdUtc`, `over18`, `selftext`, `postType`, `narration`, `ttsSegments`, `wordCount`, `readTimeSeconds`, `hookScore`, `fitsShort`. When `commentLimit` is set, a `comments` array (`author`, `body`, `score`, `depth`) and `fetchedCommentCount` are added. Set `rawMode` if you'd rather have the unshaped Reddit post object.

### Example

```json
{
  "sources": ["r/tifu", "r/AskReddit", "u/GallowBoob"],
  "sort": "top",
  "time": "week",
  "maxPostsPerSubreddit": 25,
  "cleanText": true
}
````

### Pricing

$0.50 per 1000 posts, pay per result, no subscription. Steps that use an AI model expect your own OpenAI key.

### Notes

Scores and comments are not in the RSS feed. If you need them, create a free script app at reddit.com/prefs/apps and pass `redditClientId` and `redditClientSecret`. Anonymous comment fetching is mostly blocked by Reddit and will usually come back empty.

# Actor input Schema

## `sources` (type: `array`):

Any mix of subreddits and Reddit user profiles. Accepts: 'askreddit', 'r/tifu', 'u/GallowBoob', 'user/spez', or a full reddit.com URL. Works for ANY subreddit or profile — not limited to AITA.

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

Optional alternative to 'sources' — plain subreddit names. Merged with 'sources'.

## `users` (type: `array`):

Optional — Reddit usernames to scrape submissions from (without u/). Merged with 'sources'.

## `method` (type: `string`):

rss = no key/login needed (recommended, default). oauth = use Reddit app creds below (adds score/comments). json = legacy anonymous API (often blocked).

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

top, hot (trending), new (latest), rising, or controversial.

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

Time window for 'top' and 'controversial' sorts (ignored for hot/new/rising). E.g. top of all time, top this year, top this week.

## `maxPostsPerSubreddit` (type: `integer`):

How many qualifying stories to return per subreddit.

## `minScore` (type: `integer`):

Skip posts below this upvote count.

## `minWords` (type: `integer`):

Skip stories shorter than this (too thin for a short).

## `maxWords` (type: `integer`):

Skip stories longer than this (won't fit a 30–90s short).

## `minHookScore` (type: `integer`):

Filter out weak openers. 0 = keep all.

## `requireStory` (type: `boolean`):

Keep only self/text-post stories (skip link/image posts) and apply the word-count fit. Off by default = return ALL posts. Turn on for faceless story videos.

## `includeNsfw` (type: `boolean`):

Include posts marked over-18. Off by default.

## `cleanText` (type: `boolean`):

Strip markdown/links/edit-stamps and produce TTS-ready sentences. Turn off for raw text.

## `rawMode` (type: `boolean`):

Output the complete raw Reddit post object instead of the shaped record.

## `dedupeAcrossRuns` (type: `boolean`):

Remember post IDs between runs so you never get the same story twice.

## `commentLimit` (type: `integer`):

Fetch up to this many top comments per post (0 = none). Reliable when you add Reddit app credentials below; anonymous Reddit usually blocks comment access.

## `redditClientId` (type: `string`):

Optional. The default RSS method needs no login. Add a free 'script' app's client ID (reddit.com/prefs/apps) only if you want upvote score + comment counts (not exposed via RSS).

## `redditClientSecret` (type: `string`):

The secret for your Reddit app (reddit.com/prefs/apps).

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

RESIDENTIAL recommended for best reliability at volume. The RSS feeds work from most IPs.

## Actor input object example

```json
{
  "sources": [
    "r/tifu",
    "r/AskReddit",
    "u/GallowBoob"
  ],
  "method": "rss",
  "sort": "top",
  "time": "day",
  "maxPostsPerSubreddit": 10,
  "minScore": 0,
  "minWords": 30,
  "maxWords": 800,
  "minHookScore": 0,
  "requireStory": false,
  "includeNsfw": false,
  "cleanText": true,
  "rawMode": false,
  "dedupeAcrossRuns": true,
  "commentLimit": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Result rows / metadata are stored in the default dataset (one row per item).

## `files` (type: `string`):

Generated media/files (video, audio, images, captions) are stored in the default key-value store.

# 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 = {
    "sources": [
        "r/tifu",
        "r/AskReddit",
        "u/GallowBoob"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/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 = {
    "sources": [
        "r/tifu",
        "r/AskReddit",
        "u/GallowBoob",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/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 '{
  "sources": [
    "r/tifu",
    "r/AskReddit",
    "u/GallowBoob"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call dami_studio/reddit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Scraper",
        "description": "Scrape posts from any subreddit or user profile — no key, no login. Sort by top/hot/new/rising/controversial over any time window. Returns full post data plus optional clean-text/TTS-ready fields. For research, trend monitoring, video pipelines, datasets, lead gen, and more.",
        "version": "0.1",
        "x-build-id": "91NVb9vSzmWVo4sgr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dami_studio~reddit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dami_studio-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/dami_studio~reddit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dami_studio-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/dami_studio~reddit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dami_studio-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": {
                    "sources": {
                        "title": "Sources (subreddits or user profiles)",
                        "type": "array",
                        "description": "Any mix of subreddits and Reddit user profiles. Accepts: 'askreddit', 'r/tifu', 'u/GallowBoob', 'user/spez', or a full reddit.com URL. Works for ANY subreddit or profile — not limited to AITA.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "subreddits": {
                        "title": "Subreddits (legacy alias)",
                        "type": "array",
                        "description": "Optional alternative to 'sources' — plain subreddit names. Merged with 'sources'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "users": {
                        "title": "User profiles (alias)",
                        "type": "array",
                        "description": "Optional — Reddit usernames to scrape submissions from (without u/). Merged with 'sources'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "method": {
                        "title": "Fetch method",
                        "enum": [
                            "rss",
                            "oauth",
                            "json"
                        ],
                        "type": "string",
                        "description": "rss = no key/login needed (recommended, default). oauth = use Reddit app creds below (adds score/comments). json = legacy anonymous API (often blocked).",
                        "default": "rss"
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "top",
                            "hot",
                            "new",
                            "rising",
                            "controversial"
                        ],
                        "type": "string",
                        "description": "top, hot (trending), new (latest), rising, or controversial.",
                        "default": "top"
                    },
                    "time": {
                        "title": "Time range",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time window for 'top' and 'controversial' sorts (ignored for hot/new/rising). E.g. top of all time, top this year, top this week.",
                        "default": "day"
                    },
                    "maxPostsPerSubreddit": {
                        "title": "Max stories per subreddit",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many qualifying stories to return per subreddit.",
                        "default": 10
                    },
                    "minScore": {
                        "title": "Minimum upvotes",
                        "type": "integer",
                        "description": "Skip posts below this upvote count.",
                        "default": 0
                    },
                    "minWords": {
                        "title": "Min words (short-form fit)",
                        "type": "integer",
                        "description": "Skip stories shorter than this (too thin for a short).",
                        "default": 30
                    },
                    "maxWords": {
                        "title": "Max words (short-form fit)",
                        "type": "integer",
                        "description": "Skip stories longer than this (won't fit a 30–90s short).",
                        "default": 800
                    },
                    "minHookScore": {
                        "title": "Minimum hook score (0–100)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Filter out weak openers. 0 = keep all.",
                        "default": 0
                    },
                    "requireStory": {
                        "title": "Text stories only",
                        "type": "boolean",
                        "description": "Keep only self/text-post stories (skip link/image posts) and apply the word-count fit. Off by default = return ALL posts. Turn on for faceless story videos.",
                        "default": false
                    },
                    "includeNsfw": {
                        "title": "Include NSFW (over-18)",
                        "type": "boolean",
                        "description": "Include posts marked over-18. Off by default.",
                        "default": false
                    },
                    "cleanText": {
                        "title": "Clean narration text",
                        "type": "boolean",
                        "description": "Strip markdown/links/edit-stamps and produce TTS-ready sentences. Turn off for raw text.",
                        "default": true
                    },
                    "rawMode": {
                        "title": "Raw mode (full Reddit JSON)",
                        "type": "boolean",
                        "description": "Output the complete raw Reddit post object instead of the shaped record.",
                        "default": false
                    },
                    "dedupeAcrossRuns": {
                        "title": "Dedupe across runs",
                        "type": "boolean",
                        "description": "Remember post IDs between runs so you never get the same story twice.",
                        "default": true
                    },
                    "commentLimit": {
                        "title": "Comments per post",
                        "type": "integer",
                        "description": "Fetch up to this many top comments per post (0 = none). Reliable when you add Reddit app credentials below; anonymous Reddit usually blocks comment access.",
                        "default": 0
                    },
                    "redditClientId": {
                        "title": "Reddit app client ID (optional)",
                        "type": "string",
                        "description": "Optional. The default RSS method needs no login. Add a free 'script' app's client ID (reddit.com/prefs/apps) only if you want upvote score + comment counts (not exposed via RSS)."
                    },
                    "redditClientSecret": {
                        "title": "Reddit app client secret (recommended)",
                        "type": "string",
                        "description": "The secret for your Reddit app (reddit.com/prefs/apps)."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "RESIDENTIAL recommended for best reliability at volume. The RSS feeds work from most IPs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
