# Tiktok Comments Scraper (`scrapelabsapi/tiktok-comments-scraper`) Actor

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

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## TikTok Comments Scraper

A powerful Apify Actor that scrapes comments from TikTok videos with support for bulk URLs, usernames, and keywords. This actor provides comprehensive comment data including text, likes, replies, timestamps, and user information.

### Why Choose Us?

- **Bulk Processing**: Process multiple TikTok videos, usernames, or keywords in a single run
- **Smart Proxy Management**: Automatic fallback from no proxy → datacenter → residential proxy with retry logic
- **Flexible Sorting**: Sort comments by newest, oldest, or most liked
- **Comprehensive Data**: Extract complete comment metadata including user profiles and engagement metrics
- **Reliable**: Built-in retry logic and error handling for robust scraping

### Key Features

- ✅ Scrape comments from TikTok video URLs
- ✅ Support for bulk input (URLs, usernames, keywords)
- ✅ Configurable comment limits per video
- ✅ Multiple sort orders (newest, oldest, most liked)
- ✅ Automatic proxy fallback system
- ✅ Detailed logging for monitoring progress
- ✅ Structured JSON output format

### Input

#### JSON Example

```json
{
  "postURLs": [
    "https://www.tiktok.com/@mrbeast/video/7578547467189374239"
  ],
  "commentsPerPost": 100,
  "maxRepliesPerComment": 2,
  "profiles": ["mrbeast"],
  "resultsPerPage": 30,
  "profileScrapeSections": ["videos", "reposts"],
  "profileSorting": "latest",
  "oldestPostDateUnified": null,
  "newestPostDate": null,
  "excludePinnedPosts": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Input Fields

- **postURLs** (optional): Array of TikTok video URLs to scrape comments from. If provided, this takes priority over `profiles`.
- **commentsPerPost** (optional, default: 100): Maximum number of comments to scrape per video (min 1)
- **maxRepliesPerComment** (optional, default: 0): Maximum number of replies to fetch per comment (min 0)
- **profiles** (optional): Array of TikTok usernames (without `@`) to scrape videos from
- **resultsPerPage** (optional, default: 1): Number of videos per profile (1–1000000)
- **profileScrapeSections** (optional, default: `["videos"]`): Which sections to scrape from a profile (`"videos"`, `"reposts"`)
- **profileSorting** (optional, default: `"latest"`): `"latest"`, `"oldest"`, or `"popular"`
- **oldestPostDateUnified** (optional): `"YYYY-MM-DD"` or days ago (`"1"`, `"2"`, …) — only affects profile scraping
- **newestPostDate** (optional): `"YYYY-MM-DD"` — only affects profile scraping
- **excludePinnedPosts** (optional, default: false): Exclude pinned posts during profile scraping
- **proxyConfiguration** (optional): Apify proxy settings. The actor tries no-proxy first and falls back to Apify proxy if blocked.

### Output

#### JSON Example

```json
[
  {
    "videoWebUrl": "https://www.tiktok.com/@mrbeast/video/7578547467189374239",
    "submittedVideoUrl": "https://www.tiktok.com/@mrbeast/video/7578547467189374239",
    "input": "https://www.tiktok.com/@mrbeast/video/7578547467189374239",
    "cid": "7578605549794034443",
    "createTime": 1732995615,
    "createTimeISO": "2025-11-30T19:40:15.000Z",
    "text": "mr beast are you ok ?",
    "diggCount": 7633,
    "likedByAuthor": false,
    "pinnedByAuthor": false,
    "repliesToId": null,
    "replyCommentTotal": 100,
    "uid": "7516601022924489733",
    "uniqueId": "amin.hrizi4",
    "avatarThumbnail": "https://p16-sign-va.tiktokcdn.com/...",
    "mentions": [],
    "detailedMentions": [],
    "replies": []
  }
]
```

#### Output Fields

- **videoWebUrl**: Canonical URL of the video
- **submittedVideoUrl**: Canonical URL of the video (same as `videoWebUrl`)
- **input**: The input URL used for scraping (same as `videoWebUrl` / submitted URL)
- **cid**: Comment ID
- **createTime / createTimeISO**: Comment creation timestamp (unix + ISO)
- **text**: Comment text
- **diggCount**: Comment likes
- **likedByAuthor / pinnedByAuthor**: Flags from TikTok API
- **repliesToId**: Parent comment id (null for top-level)
- **replyCommentTotal**: Total replies count reported by API
- **uid / uniqueId / avatarThumbnail**: Commenter info
- **mentions / detailedMentions**: Mentions extracted from text and `text_extra`
- **replies**: Array of reply objects (same shape as comments, without nested `replies`)

### 🚀 How to Use the Actor (via Apify Console)

1. Log in at https://console.apify.com and go to **Actors**
2. Find your actor (tiktok-comments-scraper) and click it
3. Configure inputs:
   - Add TikTok video URLs in the `startUrls` field
   - Set `maxComments` to limit comments per video
   - Choose `sortOrder` (newest, oldest, or most\_liked)
   - Configure proxy settings if needed
4. Run the actor
5. Monitor logs in real time
6. Access results in the **OUTPUT** tab
7. Export results to JSON or CSV

### Best Use Cases

- **Social Media Analysis**: Analyze engagement and sentiment in TikTok comments
- **Content Research**: Gather feedback and reactions to specific videos
- **Market Research**: Understand audience responses to branded content
- **Trend Analysis**: Track comment patterns and popular discussions
- **Community Monitoring**: Monitor comments for specific topics or keywords

### Frequently Asked Questions

**Q: How many comments can I scrape per video?**\
A: You can scrape up to 10,000 comments per video. Set the `maxComments` parameter to your desired limit.

**Q: What happens if TikTok blocks my requests?**\
A: The actor automatically falls back through proxy options: no proxy → datacenter proxy → residential proxy with 3 retries each.

**Q: Can I scrape comments from multiple videos at once?**\
A: Yes! Add multiple URLs to the `startUrls` array to process them in a single run.

**Q: How are comments sorted?**\
A: You can choose from three sort orders: "newest" (default), "oldest", or "most\_liked".

**Q: Is the data real-time?**\
A: The data reflects the comments available at the time of scraping.

### Support and Feedback

For issues, questions, or feedback, please contact support through the Apify platform.

### Cautions

- Data is collected only from **publicly available sources**
- No data is taken from private accounts or password-protected content
- The end user is responsible for ensuring legal compliance (spam laws, privacy, data protection, etc.)
- Respect TikTok's Terms of Service and rate limits

# Actor input Schema

## `postURLs` (type: `array`):

Add the video URLs you want to extract comments from. Enter URLs one by one or edit it in bulk.

## `commentsPerPost` (type: `integer`):

The number of comments extracted from every result. Due to TikTok API limitations, the actual number of scraped comments may differ, especially for posts with thousands of comments.

## `maxRepliesPerComment` (type: `integer`):

The maximum number of replies you want from a single comment. Note: Successful extraction of all desired replies is currently not guaranteed.

## `profiles` (type: `array`):

Add one or multiple TikTok usernames you want to scrape. You can enter the usernames one by one, or use the Bulk edit section to add a prepared list.

## `resultsPerPage` (type: `integer`):

Add the number of videos you want to scrape per profile.

## `profileScrapeSections` (type: `array`):

If a profile has reposted videos, you can scrape them by selecting Reposts

## `profileSorting` (type: `string`):

Select: Latest / Oldest / Popular. Date filters only work with Latest and Oldest.

## `oldestPostDateUnified` (type: `string`):

Optional filter. Only videos uploaded after or on this date will be scraped. Supports absolute date (YYYY-MM-DD) or relative date (e.g. 5 days, 2 weeks).

## `newestPostDate` (type: `string`):

Optional filter. Only videos uploaded before or on this date will be scraped. Supports absolute date (YYYY-MM-DD) or relative date (e.g. 5 days, 2 weeks).

## `excludePinnedPosts` (type: `boolean`):

Tick to exclude pinned posts from profiles. Pinned posts are usually the first videos on a profile's page.

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

Choose which proxies to use. If TikTok rejects the request, it will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "postURLs": [
    "https://www.tiktok.com/@mrbeast/video/7578547467189374239"
  ],
  "commentsPerPost": 10,
  "maxRepliesPerComment": 3,
  "profiles": [
    "mrbeast"
  ],
  "resultsPerPage": 10,
  "profileScrapeSections": [
    "videos"
  ],
  "profileSorting": "latest",
  "excludePinnedPosts": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "postURLs": [
        "https://www.tiktok.com/@mrbeast/video/7578547467189374239"
    ],
    "profiles": [
        "mrbeast"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapelabsapi/tiktok-comments-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 = {
    "postURLs": ["https://www.tiktok.com/@mrbeast/video/7578547467189374239"],
    "profiles": ["mrbeast"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapelabsapi/tiktok-comments-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 '{
  "postURLs": [
    "https://www.tiktok.com/@mrbeast/video/7578547467189374239"
  ],
  "profiles": [
    "mrbeast"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapelabsapi/tiktok-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiktok Comments Scraper",
        "version": "0.1",
        "x-build-id": "pQkXSM8i8NbYWthNo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapelabsapi~tiktok-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapelabsapi-tiktok-comments-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/scrapelabsapi~tiktok-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapelabsapi-tiktok-comments-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/scrapelabsapi~tiktok-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapelabsapi-tiktok-comments-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": {
                    "postURLs": {
                        "title": "TikTok video URLs",
                        "type": "array",
                        "description": "Add the video URLs you want to extract comments from. Enter URLs one by one or edit it in bulk.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "commentsPerPost": {
                        "title": "Maximum comments per post",
                        "minimum": 1,
                        "type": "integer",
                        "description": "The number of comments extracted from every result. Due to TikTok API limitations, the actual number of scraped comments may differ, especially for posts with thousands of comments.",
                        "default": 10
                    },
                    "maxRepliesPerComment": {
                        "title": "Maximum replies per comment",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The maximum number of replies you want from a single comment. Note: Successful extraction of all desired replies is currently not guaranteed.",
                        "default": 3
                    },
                    "profiles": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "Add one or multiple TikTok usernames you want to scrape. You can enter the usernames one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsPerPage": {
                        "title": "💯 Number of videos per profile",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Add the number of videos you want to scrape per profile.",
                        "default": 10
                    },
                    "profileScrapeSections": {
                        "title": "Profile sections to scrape",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "If a profile has reposted videos, you can scrape them by selecting Reposts",
                        "items": {
                            "type": "string",
                            "enum": [
                                "videos",
                                "reposts"
                            ]
                        },
                        "default": [
                            "videos"
                        ]
                    },
                    "profileSorting": {
                        "title": "Profile video sorting",
                        "enum": [
                            "latest",
                            "popular",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Select: Latest / Oldest / Popular. Date filters only work with Latest and Oldest.",
                        "default": "latest"
                    },
                    "oldestPostDateUnified": {
                        "title": "Scrape profile videos published after [date]",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "Optional filter. Only videos uploaded after or on this date will be scraped. Supports absolute date (YYYY-MM-DD) or relative date (e.g. 5 days, 2 weeks)."
                    },
                    "newestPostDate": {
                        "title": "Scrape videos published before [date]",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "Optional filter. Only videos uploaded before or on this date will be scraped. Supports absolute date (YYYY-MM-DD) or relative date (e.g. 5 days, 2 weeks)."
                    },
                    "excludePinnedPosts": {
                        "title": "Exclude pinned posts",
                        "type": "boolean",
                        "description": "Tick to exclude pinned posts from profiles. Pinned posts are usually the first videos on a profile's page.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. If TikTok rejects the request, it will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
