# Reddit Search Scraper (`khadinakbar/reddit-search-scraper`) Actor

Search public Reddit posts by keyword, phrase, or subreddit scope through provider-backed access. Returns structured JSON search results for monitoring, research, and AI workflows. $0.003/result plus usage.

- **URL**: https://apify.com/khadinakbar/reddit-search-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 search result founds

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/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 Search Scraper

Search public Reddit posts by keyword, phrase, brand, product, or topic and export structured JSON results. This actor is intentionally specific: it searches Reddit and returns post-level search results only. It does not scrape full comment threads, subreddit analytics, private content, or user profiles.

The actor uses owner-managed provider access through ScrapeCreators first and SociaVault as fallback when configured. Users do not need to supply a Reddit account, Reddit API key, proxy, or browser session.

**Compatible with:** Apify MCP Server, ChatGPT, Claude, Cursor, Make.com, Zapier, n8n, LangChain, and direct REST API.

---

### What does this Reddit Search Scraper do?

Use this actor when you need to find public Reddit posts matching a keyword or phrase. It supports:

- Search across Reddit by keyword or phrase
- Optional search within a single subreddit
- Sort by relevance, new, top, or comments
- Filter by day, week, month, year, or all time
- Optional post creation cutoff after provider results are returned
- Business-safe default filtering for NSFW posts
- Structured dataset rows for AI agents, monitoring jobs, and spreadsheet exports

Every run writes two key-value store records:

- `OUTPUT` — compact terminal outcome, item count, warnings, and charged result totals
- `RUN_SUMMARY` — detailed diagnostics, provider attempts, input summary, warnings, and validation counts

Terminal outcomes follow the actor contract: `COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, `UPSTREAM_FAILED`, or `CONFIG_ERROR`.

---

### Input

| Field | Required | Description |
|---|---:|---|
| `searchQuery` | Yes | Keyword, phrase, brand, product, or topic to search on Reddit. |
| `withinSubreddit` | No | Optional subreddit name such as `learnpython` or `r/MachineLearning`. |
| `maxResults` | No | Maximum results to save. Default `25`; max `10000`. |
| `sortBy` | No | `relevance`, `new`, `top`, or `comments`. |
| `timeFilter` | No | `day`, `week`, `month`, `year`, or `all`. |
| `postDateLimit` | No | Optional ISO date cutoff such as `2026-01-01`. |
| `includeNsfw` | No | Include posts marked NSFW. Default `false`. |

Example input:

```json
{
  "searchQuery": "OpenAI API pricing",
  "withinSubreddit": "OpenAI",
  "maxResults": 25,
  "sortBy": "relevance",
  "timeFilter": "month",
  "includeNsfw": false
}
````

***

### Output data

Each dataset item is one Reddit search result.

| Field | Example |
|---|---|
| `type` | `search_result` |
| `redditId` | `t3_abc123` |
| `title` | `OpenAI API pricing discussion` |
| `body` | `I am comparing API pricing for a product launch.` |
| `author` | `u/example_user` |
| `subreddit` | `r/OpenAI` |
| `score` | `128` |
| `upvoteRatio` | `0.92` |
| `commentCount` | `42` |
| `url` | `https://www.reddit.com/r/OpenAI/comments/...` |
| `externalUrl` | `https://openai.com/api/pricing/` |
| `flair` | `Discussion` |
| `postType` | `text`, `link`, `image`, `video`, or `gallery` |
| `isNsfw` | `false` |
| `createdAt` | `2026-07-14T12:00:00.000Z` |
| `sourceQuery` | `OpenAI API pricing` |
| `withinSubreddit` | `r/OpenAI` |
| `scrapedAt` | `2026-07-14T12:05:00.000Z` |

***

### Pricing

Pricing is pay-per-result plus Apify platform usage.

| Event | Price |
|---|---:|
| Reddit search result saved | `$0.003` |

Example: saving 100 Reddit search results costs `$0.30` in result events, plus Apify platform usage.

The actor logs the maximum event-charge cap at run start and writes the actual charged result count to `RUN_SUMMARY`.

***

### API usage

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~reddit-search-scraper/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "OpenAI API pricing",
    "maxResults": 25,
    "sortBy": "relevance",
    "timeFilter": "month"
  }'
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('khadinakbar/reddit-search-scraper').call({
  searchQuery: 'OpenAI API pricing',
  withinSubreddit: 'OpenAI',
  maxResults: 25,
  sortBy: 'relevance',
  timeFilter: 'month',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("khadinakbar/reddit-search-scraper").call(
    run_input={
        "searchQuery": "OpenAI API pricing",
        "maxResults": 25,
        "timeFilter": "month",
    }
)

items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(items[:3])
```

***

### Common use cases

#### Brand monitoring

Search for your brand, product, competitor, or campaign name and export posts where people discuss it.

#### Product research

Find pain points and buying intent by searching terms such as `CRM recommendations for startups`, `Shopify alternatives`, or `API pricing`.

#### AI and market research

Collect Reddit post titles, bodies, scores, comment counts, and permalinks for topic clustering, sentiment analysis, or qualitative research.

#### Subreddit-scoped search

Set `withinSubreddit` when you already know the community you want to inspect, such as `learnpython`, `OpenAI`, `MachineLearning`, or `Entrepreneur`.

***

### Limitations and legal boundaries

This actor is for public Reddit search results only. It does not access private, banned, quarantined, deleted, geo-restricted, or login-only content. It does not provide full comment-thread scraping; use a dedicated comments actor for that.

Use the data only where your rights, approvals, and downstream purpose allow it. Do not use this actor for unauthorized redistribution, private-content access, or AI training unless your permissions explicitly cover that use.

Provider availability and Reddit behavior can affect search coverage. When a provider route fails, the actor tries the configured fallback provider and records diagnostics in `RUN_SUMMARY`.

***

### FAQ

**Do I need a Reddit account?**\
No. Users do not provide Reddit credentials. The actor is intended for public Reddit search results.

**Can I search inside a subreddit?**\
Yes. Set `withinSubreddit` to a subreddit name such as `learnpython`.

**Does it return comments?**\
No. This actor is intentionally search-result-only and returns post-level records.

**What happens when no matches are found?**\
The run succeeds with `VALID_EMPTY`, zero dataset rows, and zero result-event charges.

**What happens if only some work succeeds?**\
Useful partial output is preserved and the run succeeds with `PARTIAL`; see `RUN_SUMMARY` for warnings.

# Actor input Schema

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

Use this when the user wants to search public Reddit posts by keyword, topic, brand, phrase, or question. Accepts plain text such as 'OpenAI API pricing' or 'CRM recommendations for startups'. Required; blank strings return an INVALID\_INPUT summary. Do not put subreddit URLs here — use withinSubreddit to scope a keyword search.

## `withinSubreddit` (type: `string`):

Optional subreddit scope for the search query. Accepts a subreddit name with or without r/ prefix, such as 'learnpython' or 'r/MachineLearning'. Leave blank to search across Reddit. This is not a post URL field.

## `maxResults` (type: `integer`):

Maximum number of Reddit search result records to return. Each saved result is charged as one result event. Defaults to 25, minimum 1, maximum 10000. Use small values for smoke tests and larger values for monitoring or research exports.

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

How to sort Reddit search results. Use 'relevance' for the closest keyword match, 'new' for recent posts, 'top' for highly scored posts, or 'comments' for heavily discussed posts. Defaults to relevance. This affects search ranking only, not comment extraction.

## `timeFilter` (type: `string`):

Time window for Reddit search results. Use 'day', 'week', 'month', 'year', or 'all'. Defaults to month for useful recent monitoring results. This is a search filter, not a post creation date guarantee.

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

Optional post creation cutoff applied after provider search results are returned. Use ISO 8601 format such as '2026-01-01' or '2026-01-01T00:00:00Z'. Leave blank to keep all provider results. Invalid dates are ignored and reported as a PARTIAL warning.

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

When enabled, includes Reddit posts marked NSFW in the dataset. Disabled by default to keep monitoring and business research outputs safer. This does not bypass private, quarantined, deleted, or login-only content. NSFW filtering depends on provider metadata.

## Actor input object example

```json
{
  "searchQuery": "OpenAI API pricing",
  "withinSubreddit": "learnpython",
  "maxResults": 25,
  "sortBy": "relevance",
  "timeFilter": "month",
  "postDateLimit": "2026-01-01",
  "includeNsfw": false
}
```

# Actor output Schema

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

Dataset of Reddit search result records. Each row is one public Reddit post returned for the query.

## `output` (type: `string`):

Compact run outcome, item count, warning list, and charged result count.

## `runSummary` (type: `string`):

Detailed diagnostics including provider attempts, input summary, validation counts, and cost-cap state.

# 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 = {
    "searchQuery": "artificial intelligence trends",
    "maxResults": 25,
    "sortBy": "relevance",
    "timeFilter": "month",
    "includeNsfw": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/reddit-search-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 = {
    "searchQuery": "artificial intelligence trends",
    "maxResults": 25,
    "sortBy": "relevance",
    "timeFilter": "month",
    "includeNsfw": False,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/reddit-search-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 '{
  "searchQuery": "artificial intelligence trends",
  "maxResults": 25,
  "sortBy": "relevance",
  "timeFilter": "month",
  "includeNsfw": false
}' |
apify call khadinakbar/reddit-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Search Scraper",
        "description": "Search public Reddit posts by keyword, phrase, or subreddit scope through provider-backed access. Returns structured JSON search results for monitoring, research, and AI workflows. $0.003/result plus usage.",
        "version": "1.0",
        "x-build-id": "GGJm1saQ740o0OAby"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~reddit-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-reddit-search-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/khadinakbar~reddit-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-reddit-search-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/khadinakbar~reddit-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-reddit-search-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": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Use this when the user wants to search public Reddit posts by keyword, topic, brand, phrase, or question. Accepts plain text such as 'OpenAI API pricing' or 'CRM recommendations for startups'. Required; blank strings return an INVALID_INPUT summary. Do not put subreddit URLs here — use withinSubreddit to scope a keyword search."
                    },
                    "withinSubreddit": {
                        "title": "Limit search to subreddit",
                        "type": "string",
                        "description": "Optional subreddit scope for the search query. Accepts a subreddit name with or without r/ prefix, such as 'learnpython' or 'r/MachineLearning'. Leave blank to search across Reddit. This is not a post URL field."
                    },
                    "maxResults": {
                        "title": "Maximum search results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Reddit search result records to return. Each saved result is charged as one result event. Defaults to 25, minimum 1, maximum 10000. Use small values for smoke tests and larger values for monitoring or research exports.",
                        "default": 25
                    },
                    "sortBy": {
                        "title": "Sort search results by",
                        "enum": [
                            "relevance",
                            "new",
                            "top",
                            "comments"
                        ],
                        "type": "string",
                        "description": "How to sort Reddit search results. Use 'relevance' for the closest keyword match, 'new' for recent posts, 'top' for highly scored posts, or 'comments' for heavily discussed posts. Defaults to relevance. This affects search ranking only, not comment extraction.",
                        "default": "relevance"
                    },
                    "timeFilter": {
                        "title": "Time filter",
                        "enum": [
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time window for Reddit search results. Use 'day', 'week', 'month', 'year', or 'all'. Defaults to month for useful recent monitoring results. This is a search filter, not a post creation date guarantee.",
                        "default": "month"
                    },
                    "postDateLimit": {
                        "title": "Ignore posts older than date",
                        "type": "string",
                        "description": "Optional post creation cutoff applied after provider search results are returned. Use ISO 8601 format such as '2026-01-01' or '2026-01-01T00:00:00Z'. Leave blank to keep all provider results. Invalid dates are ignored and reported as a PARTIAL warning."
                    },
                    "includeNsfw": {
                        "title": "Include NSFW results",
                        "type": "boolean",
                        "description": "When enabled, includes Reddit posts marked NSFW in the dataset. Disabled by default to keep monitoring and business research outputs safer. This does not bypass private, quarantined, deleted, or login-only content. NSFW filtering depends on provider metadata.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
