# Reddit Posts Scraper (`scrapesmith/reddit-posts-scraper`) Actor

Scrape posts from any subreddit on Reddit. Get titles, body text, images, videos, upvotes, comment counts, flair, author info, crossposts, and thumbnails. Sort by hot, new, top, rising, or controversial. Filter by date and NSFW. Deep scrape all sorts at once. No login or cookies needed.

- **URL**: https://apify.com/scrapesmith/reddit-posts-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 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.

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 Posts Scraper — The Fastest Way to Extract Subreddit Data at Scale

Looking for the most comprehensive **Reddit scraper** for pulling posts out of any subreddit? This is it. Reddit Posts Scraper is a blazing-fast, no-login **subreddit scraper** built for marketers, researchers, data analysts, and developers who need clean, structured **Reddit data** without touching a browser or writing a single line of scraping code.

Whether you're tracking trends on r/technology, monitoring brand sentiment on r/business, building a content calendar from r/marketing, or running large-scale **social media data** research, this tool turns any subreddit into a ready-to-use dataset in seconds. It's the most complete subreddit post scraper on the market — covering every sort mode, every time filter, and every post type Reddit has to offer.

### What It Does

Reddit Posts Scraper connects to any public subreddit and extracts every post along with its full metadata — title, body text, media, upvotes, comment counts, flair, author details, and more. You can scrape a single subreddit or a huge list of them in one run, choose exactly which sort order you want (Hot, New, Top, Rising, Controversial), or let the scraper sweep through **every sort combination automatically** so you never miss a trending post again.

This is the tool people reach for when they need **reddit data** that's actually usable — not a pile of raw HTML, but clean structured JSON ready to drop into a spreadsheet, database, or BI dashboard.

### Features

- **Multi-subreddit scraping** — feed in dozens of subreddits and scrape them all in a single run
- **All sort modes supported** — Hot, New, Top, Rising, Controversial, plus every Top/Controversial time window (hour, day, week, month, year, all-time)
- **"Scrape All Sorts" mode** — automatically cycles through every sort combination per subreddit for maximum, most comprehensive coverage
- **Date filtering** — only pull posts newer than a specific date, perfect for daily/weekly monitoring jobs
- **NSFW toggle** — include or exclude adult content with a single switch
- **Subreddit community metadata** — get subscriber counts, descriptions, banners, and icons for the communities you scrape
- **Rich media extraction** — image galleries, video URLs, thumbnails, and dimensions pulled automatically
- **Full author & engagement data** — upvotes, upvote ratio, comment counts, crosspost counts, author flair, and more
- **Resumable runs** — large jobs checkpoint automatically so nothing is lost on restarts
- **No login, no cookies, no API key** — completely anonymous and hassle-free
- **Export anywhere** — download your results instantly as JSON, CSV, or Excel

### Input Parameters

| Field | Type | Description |
|---|---|---|
| `subreddits` | Array | List of subreddit names to scrape (no `r/` prefix needed), e.g. `python`, `technology` |
| `sort` | Select | Sort order: Hot, New, Top, Rising, or Controversial |
| `time` | Select | Time window for Top/Controversial sorts: hour, day, week, month, year, all-time |
| `maxPostCount` | Number | Maximum posts to collect per subreddit (per sort if "Scrape all sorts" is on) |
| `postDateLimit` | Date (YYYY-MM-DD) | Only collect posts newer than this date; auto-switches sort to New |
| `scrapeAllSorts` | Boolean | Scrape every sort combination for each subreddit instead of just one |
| `includeNSFW` | Boolean | Include NSFW/over-18 posts |
| `includeCommunityInfo` | Boolean | Add one extra item per subreddit with community stats (subscribers, description, icons) |
| `maxItems` | Number | Hard cap on total items returned across the whole run |

### Output Fields

| Field | Description |
|---|---|
| `id` / `parsedId` | Reddit's internal post ID |
| `url` | Direct link to the post |
| `username` | Post author |
| `title` | Post title |
| `communityName` | Subreddit name (e.g. `r/python`) |
| `subredditSubscribers` | Subscriber count of the subreddit |
| `body` | Post text content (self-posts) |
| `html` | Rendered HTML of the post body |
| `link` | External link (for link posts) |
| `domain` | Source domain of the linked content |
| `numberOfComments` | Total comment count |
| `numberOfCrossposts` | Number of times the post was crossposted |
| `flair` | Post flair tag |
| `authorFlair` | Author's flair in the subreddit |
| `upVotes` / `upVoteRatio` | Post score and like ratio |
| `isSelf` / `isVideo` / `isStickied` / `isLocked` / `isSpoiler` / `isOriginalContent` | Post type flags |
| `over18` | NSFW flag |
| `videoUrl`, `videoDuration`, `videoWidth`, `videoHeight` | Video metadata (if applicable) |
| `thumbnailUrl`, `thumbnailWidth`, `thumbnailHeight` | Thumbnail metadata |
| `imageUrls` | Array of image URLs (galleries and previews) |
| `createdAt` | Post creation timestamp (ISO format) |
| `scrapedAt` | Time the data was scraped |
| `dataType` | `post` or `community` |

### Sample Output

```json
{
  "id": "t3_1abcxyz",
  "parsedId": "1abcxyz",
  "url": "https://www.reddit.com/r/technology/comments/1abcxyz/example_post/",
  "username": "example_user",
  "title": "New breakthrough in battery technology announced",
  "communityName": "r/technology",
  "subredditSubscribers": 15200000,
  "body": "Researchers have unveiled a new battery design...",
  "numberOfComments": 342,
  "flair": "Energy",
  "upVotes": 5821,
  "upVoteRatio": 0.96,
  "isSelf": true,
  "isVideo": false,
  "over18": false,
  "imageUrls": [],
  "createdAt": "2026-07-01T14:22:00.000Z",
  "scrapedAt": "2026-07-06T09:10:00.000Z",
  "dataType": "post"
}
````

### Use Cases

1. **Trend & content research** — spot rising topics across niche and mainstream subreddits before they go viral
2. **Brand & product monitoring** — track what Reddit is saying about your brand, product, or competitors
3. **Market & sentiment research** — pull large volumes of Reddit discussions for NLP and sentiment analysis
4. **Academic research** — collect structured social data for studies on online communities and discourse
5. **Content curation** — automatically surface top posts from your favorite subreddits for newsletters or social media
6. **Lead generation** — find people discussing problems your product solves in relevant subreddits
7. **Journalism & reporting** — quickly gather primary-source Reddit posts for stories and investigations
8. **SEO & keyword research** — discover what real people are asking and discussing around your target keywords
9. **Competitive intelligence** — monitor competitor mentions and community sentiment in real time

### Pricing

This Reddit scraper runs on simple, transparent pay-per-result pricing: **$0.80 per 1,000 results**. No subscriptions, no hidden fees — you only pay for the posts you actually collect. Start with the free tier to test it out, then scale up to as many subreddits and posts as you need.

### Tips for Best Results

- Use `scrapeAllSorts` when you want the absolute maximum, most comprehensive coverage of a subreddit's activity
- Set a `postDateLimit` for recurring daily/weekly monitoring runs so you never collect duplicate data
- Turn on `includeCommunityInfo` if you also want subscriber growth tracking over time
- Keep `maxItems` set to something reasonable when scraping many subreddits at once to control run size
- Combine this scraper with the Reddit Comments Scraper to get full post + discussion coverage

### FAQ

**Do I need a Reddit account or API key to use this scraper?**
No. This Reddit scraper works completely anonymously — no login, no Reddit API credentials, no cookies required.

**Can I scrape multiple subreddits in one run?**
Yes. Just add as many subreddit names as you want to the input list and they'll all be scraped in the same run.

**What's the difference between `sort` and `scrapeAllSorts`?**
`sort` picks one sort mode (like Hot or New). `scrapeAllSorts` ignores that setting and automatically scrapes every sort and time-window combination for the most comprehensive dataset possible.

**Can I export the data to Excel or CSV?**
Yes. All results can be downloaded directly as JSON, CSV, or Excel files with one click after your run finishes.

**Does this scraper support NSFW subreddits?**
Yes, just enable the "Include NSFW posts" toggle in the input settings.

**How fast is this compared to other Reddit scrapers?**
This is one of the fastest subreddit scrapers available — it processes large post lists in seconds thanks to an optimized, lightweight scraping engine.

**What happens if my run gets interrupted?**
Runs checkpoint automatically, so large jobs can resume from where they left off instead of starting over.

**Is this suitable for large-scale, recurring scraping jobs?**
Absolutely. Between resumable checkpointing, the `maxItems` safety cap, and support for scheduling repeated runs, this scraper is built for both one-off pulls and ongoing subreddit monitoring pipelines.

### Why Teams Choose This Scraper

There are plenty of Reddit scrapers out there, but most only cover a single sort mode or leave out community metadata entirely. Reddit Posts Scraper was built to be the single tool you need for any subreddit data project — from a quick one-off pull of the day's top posts to an ongoing pipeline monitoring dozens of communities around the clock. Fast setup, clean output, and pricing that scales with you.

### Support

Have questions, feature requests, or run into an issue? Reach out through the Apify platform's contact/support options on this actor's page — feedback is always welcome and helps make this the most comprehensive Reddit scraper available.

# Actor input Schema

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

Subreddit names to scrape (without the r/ prefix, e.g. 'python').

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

Sort order for posts. Ignored if 'Scrape all sorts' is enabled.

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

Time period for 'top' and 'controversial' sorts.

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

Maximum number of posts to collect per subreddit (per sort, if 'Scrape all sorts' is enabled).

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

Only collect posts newer than this date (format YYYY-MM-DD). Leave empty to disable. Forces sort to 'new'.

## `scrapeAllSorts` (type: `boolean`):

Scrape every sort (hot, new, top for all time periods, controversial, rising) for each subreddit instead of just one sort.

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

Include posts marked as NSFW/over 18.

## `includeCommunityInfo` (type: `boolean`):

Include one extra item per subreddit with community metadata (subscriber count, description, icons, etc.). Costs one additional request per subreddit.

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

Hard cap on total items collected across all subreddits in this run.

## Actor input object example

```json
{
  "subreddits": [
    "python"
  ],
  "sort": "hot",
  "time": "day",
  "maxPostCount": 100,
  "scrapeAllSorts": false,
  "includeNSFW": false,
  "includeCommunityInfo": false,
  "maxItems": 5000
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/reddit-posts-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 = { "subreddits": ["python"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/reddit-posts-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 '{
  "subreddits": [
    "python"
  ]
}' |
apify call scrapesmith/reddit-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Posts Scraper",
        "description": "Scrape posts from any subreddit on Reddit. Get titles, body text, images, videos, upvotes, comment counts, flair, author info, crossposts, and thumbnails. Sort by hot, new, top, rising, or controversial. Filter by date and NSFW. Deep scrape all sorts at once. No login or cookies needed.",
        "version": "0.0",
        "x-build-id": "jkKYFgzNIs2QMWh3H"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~reddit-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-reddit-posts-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/scrapesmith~reddit-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-reddit-posts-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/scrapesmith~reddit-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-reddit-posts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "subreddits"
                ],
                "properties": {
                    "subreddits": {
                        "title": "Subreddits",
                        "type": "array",
                        "description": "Subreddit names to scrape (without the r/ prefix, e.g. 'python').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "hot",
                            "new",
                            "top",
                            "rising",
                            "controversial"
                        ],
                        "type": "string",
                        "description": "Sort order for posts. Ignored if 'Scrape all sorts' is enabled.",
                        "default": "hot"
                    },
                    "time": {
                        "title": "Time period",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time period for 'top' and 'controversial' sorts.",
                        "default": "day"
                    },
                    "maxPostCount": {
                        "title": "Max posts per subreddit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of posts to collect per subreddit (per sort, if 'Scrape all sorts' is enabled).",
                        "default": 100
                    },
                    "postDateLimit": {
                        "title": "Post date limit",
                        "type": "string",
                        "description": "Only collect posts newer than this date (format YYYY-MM-DD). Leave empty to disable. Forces sort to 'new'."
                    },
                    "scrapeAllSorts": {
                        "title": "Scrape all sorts",
                        "type": "boolean",
                        "description": "Scrape every sort (hot, new, top for all time periods, controversial, rising) for each subreddit instead of just one sort.",
                        "default": false
                    },
                    "includeNSFW": {
                        "title": "Include NSFW posts",
                        "type": "boolean",
                        "description": "Include posts marked as NSFW/over 18.",
                        "default": false
                    },
                    "includeCommunityInfo": {
                        "title": "Include community info",
                        "type": "boolean",
                        "description": "Include one extra item per subreddit with community metadata (subscriber count, description, icons, etc.). Costs one additional request per subreddit.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items total",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on total items collected across all subreddits in this run.",
                        "default": 5000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
