# YouTube Comments Screenshot (`lurkapi/youtube-comments-screenshot`) Actor

Screenshot YouTube comments as high-quality PNG or WebP images. Supports dark and light themes, keyword search, and batch processing.

- **URL**: https://apify.com/lurkapi/youtube-comments-screenshot.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** Automation, Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 screenshots

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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

## YouTube Comments Screenshot

Turn any YouTube comment into a clean, high-quality screenshot image. Perfect for sharing on social media, embedding in presentations, archiving for research, or creating content compilations.

### 🎬 What it does

Give it a YouTube comment link, and it will:

1. **Open the comment** in a real browser, exactly as it appears on YouTube
2. **Capture a pixel-perfect screenshot** with the avatar, username, badges, likes, hearts, and full comment text
3. **Return the image** as a downloadable PNG or JPEG file, ready to use

Works with light and dark themes, any comment on any public video, and supports batch processing for multiple comments at once.

### 📋 How to use it

#### Step 1: Get the comment link

On YouTube, find the comment you want to screenshot. Then:

1. Click the **three dots** (⋮) next to the comment's timestamp
2. Click **"Copy link"**
3. You'll get a URL that looks like this: `https://www.youtube.com/watch?v=dQw4w9WgXcQ&lc=UgxKz...`

The `&lc=` part at the end is the comment ID. That's how the tool knows which comment to screenshot.

#### Step 2: Paste and configure

Paste the comment link into the **YouTube URLs** field. Then choose your settings:

- **Theme**: Light (white background) or Dark (YouTube dark mode)
- **Image format**: PNG (best quality) or JPEG (smaller file)
- **Image width**: How wide the screenshot should be (default: 600 pixels)

You can paste multiple comment links to screenshot several comments in one run.

**Don't have a comment link?** You can also paste a regular video URL and use the **Comment Keyword** field to search for comments containing specific text. The tool will find and screenshot matching comments automatically.

#### Step 3: Run and download

Click **Start** and wait for the screenshots to appear in the **Output** tab. Each result includes a direct download link to the image.

#### Using the API

```json
{
    "urls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ&lc=UgxKz...",
        "https://www.youtube.com/watch?v=9bZkp7q19f0"
    ],
    "commentKeyword": "amazing",
    "maxComments": 5,
    "theme": "dark",
    "imageFormat": "png",
    "imageWidth": 600
}
````

### 📊 Output fields

Each row in the output represents one comment.

| Field | Description |
|-------|-------------|
| `status` | "Success" or an error message explaining what went wrong |
| `videoId` | YouTube video ID |
| `videoUrl` | Full YouTube video URL |
| `commentId` | Unique comment ID |
| `commentUrl` | Direct link to the comment on YouTube |
| `commentText` | The full comment text |
| `authorName` | Display name of the commenter |
| `authorChannelId` | Commenter's channel ID |
| `likeCount` | Number of likes on the comment |
| `replyCount` | Number of replies (top-level comments only) |
| `publishedAt` | When the comment was posted (ISO 8601 datetime) |
| `publishedTimeText` | Relative time as shown on YouTube (e.g. "3 weeks ago") |
| `isPinned` | Whether the comment is pinned by the video creator |
| `isHearted` | Whether the creator hearted this comment |
| `isAuthorChannelOwner` | Whether the commenter is the video creator |
| `isVerified` | Whether the commenter has a verified badge |
| `isReply` | Whether this is a reply to another comment |
| `parentCommentId` | The parent comment's ID (for replies only) |
| `screenshotUrl` | Direct download link to the screenshot image |
| `screenshotKey` | Storage key for the screenshot file |
| `imageFormat` | Format used for the screenshot (png or jpeg) |
| `theme` | Theme used for the screenshot (light or dark) |

#### Example output

```json
{
    "status": "Success",
    "videoId": "dQw4w9WgXcQ",
    "videoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "commentId": "UgxKz...",
    "commentUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ&lc=UgxKz...",
    "commentText": "This song is a masterpiece.",
    "authorName": "MusicFan42",
    "authorChannelId": "UC...",
    "likeCount": 1200,
    "replyCount": 15,
    "publishedAt": "2024-03-15T10:30:00.000Z",
    "publishedTimeText": "1 year ago",
    "isPinned": false,
    "isHearted": true,
    "isAuthorChannelOwner": false,
    "isVerified": false,
    "isReply": false,
    "parentCommentId": null,
    "screenshotUrl": "https://api.apify.com/v2/key-value-stores/.../records/comment_dQw4w9WgXcQ_UgxKz.png",
    "screenshotKey": "comment_dQw4w9WgXcQ_UgxKz.png",
    "imageFormat": "png",
    "theme": "dark"
}
```

### 🌐 Proxy settings

By default, the Actor uses Apify's datacenter proxies to access YouTube.

- **Automatic (default)**: Apify selects the best proxy.
- **Datacenter**: Fast and affordable.
- **Residential**: Use if you get frequent blocks from YouTube.
- **Own proxies**: Provide your own proxy URLs.
- **No proxy**: Disable proxies. There will be no IP rotation if you get blocked.

### 💰 Pricing

Pay only for what you use:

| Event | Cost | Per 1,000 |
|-------|------|-----------|
| Screenshot taken | $0.03 | $30 |
| Comment search | $0.005 | $5 |

**Example:** Searching a video for "love" and screenshotting 5 matching comments costs $0.005 (one search) + $0.15 (five screenshots) = **$0.155 total**.

Direct comment URLs (with `&lc=`) do not incur a search fee — only the per-screenshot price.

### 💡 Good to know

- **Supported URL formats**: `youtube.com/watch?v=XXX&lc=YYY`, `youtube.com/watch?v=XXX`, `youtu.be/XXX`, `youtube.com/shorts/XXX`, or bare 11-character video IDs.
- **Comment links are the most reliable input.** When you use a direct comment link (with `&lc=`), the tool goes straight to that comment. Keyword search requires scanning through comments and may miss very old or deeply nested ones.
- **Batch processing**: Add multiple URLs to screenshot several comments in one run. Each URL is processed independently.
- **Max comments**: When searching by keyword, you can screenshot up to 100 matching comments per video.
- **Long comments**: Comments with "Read more" are automatically expanded before the screenshot is taken.
- **Screenshot storage**: Images are stored in your Apify key-value store. How long they're kept depends on your Apify plan.

### ❓ FAQ

**Why did my screenshot fail?**
The most common reasons are: the video is private or deleted, comments are turned off, or YouTube temporarily blocked the request. Try again, or switch to residential proxies if failures keep happening.

**The comment I'm looking for wasn't found. Why?**
When searching by comment ID, the tool scans up to 50 pages of comments. For videos with thousands of comments, the target may be beyond that range. Using the direct comment link (with `&lc=`) is the most reliable way to find a specific comment.

**How do I get the comment link?**
On YouTube, click the three dots (⋮) next to the comment's timestamp, then click "Copy link." The URL will contain `&lc=` followed by the comment ID.

**Which image format should I use?**
PNG gives the highest quality and supports transparency. JPEG produces smaller files but with slight compression. For social media sharing, either works fine.

**Which proxy should I use?**
Start with the default (datacenter). If you get frequent errors or empty results, switch to residential proxies.

**How long are the screenshots stored?**
Screenshots are stored in your Apify key-value store. How long they're kept depends on your Apify plan.

**Can I screenshot comments from private videos?**
No. The tool can only access comments on public videos.

### 🔗 Other tools you might like

- [YouTube Comments Scraper](https://apify.com/lurkapi/youtube-comments-scraper) - Extract comment data from any YouTube video without screenshots.
- [YouTube Video Transcript Download](https://apify.com/lurkapi/youtube-transcript-download) - Download video transcripts and subtitles.

### ⚖️ Disclaimer

This tool is intended for personal, research, and educational use. You are responsible for complying with YouTube's Terms of Service and applicable laws in your jurisdiction. The developer is not liable for misuse. Data availability depends on YouTube at run time.

**Access limitations:** Some YouTube features may restrict access from certain IP ranges or require sign-in. Comments on age-restricted, region-blocked, or members-only videos may not be accessible. If you experience frequent failures, try using residential proxies in the proxy settings.

**Keywords:** youtube comments screenshot, youtube comment image, screenshot youtube comments, comment to image, youtube comment capture, youtube comment png

# Actor input Schema

## `urls` (type: `array`):

Paste YouTube URLs. Two kinds work:

**Video URL**: screenshots multiple comments from the video. Top comments by default, or filtered when "Search keyword" is set:
`https://www.youtube.com/watch?v=VIDEO_ID`

**Comment URL**: screenshots one specific comment:
`https://www.youtube.com/watch?v=VIDEO_ID&lc=COMMENT_ID`

To get a comment URL: on YouTube, click the three dots (⋮) next to the comment → "Copy link". The copied URL includes `&lc=...`.

You can mix both types in the same run.

## `commentKeyword` (type: `string`):

Filter comments by text. Example: `amazing` → only screenshot comments containing the word "amazing".

**Leave empty** to screenshot the top comments of each video (no filter, YouTube's default "Top comments" order).

**Not used** for direct comment URLs, which already target a specific comment.

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

Cap how many comments to screenshot per video URL. Applies to both keyword search and top-comments mode. Ignored for direct comment URLs (always 1).

## `theme` (type: `string`):

Match YouTube's light or dark mode look.

## `imageWidth` (type: `string`):

Output image width in pixels. Higher values produce sharper screenshots but larger files.

## `imageFormat` (type: `string`):

PNG for lossless output, JPEG for smaller file size.

## `proxyConfig` (type: `object`):

Select proxies for accessing YouTube.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=9bZkp7q19f0"
  ],
  "maxComments": 1,
  "theme": "light",
  "imageWidth": "1200",
  "imageFormat": "png",
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `screenshots` (type: `string`):

No description

# 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 = {
    "urls": [
        "https://www.youtube.com/watch?v=9bZkp7q19f0"
    ],
    "proxyConfig": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/youtube-comments-screenshot").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 = {
    "urls": ["https://www.youtube.com/watch?v=9bZkp7q19f0"],
    "proxyConfig": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/youtube-comments-screenshot").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 '{
  "urls": [
    "https://www.youtube.com/watch?v=9bZkp7q19f0"
  ],
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call lurkapi/youtube-comments-screenshot --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Comments Screenshot",
        "description": "Screenshot YouTube comments as high-quality PNG or WebP images. Supports dark and light themes, keyword search, and batch processing.",
        "version": "0.0",
        "x-build-id": "zSEHbNfJugP4cALc4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~youtube-comments-screenshot/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-youtube-comments-screenshot",
                "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/lurkapi~youtube-comments-screenshot/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-youtube-comments-screenshot",
                "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/lurkapi~youtube-comments-screenshot/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-youtube-comments-screenshot",
                "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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "YouTube URLs",
                        "type": "array",
                        "description": "Paste YouTube URLs. Two kinds work:\n\n**Video URL**: screenshots multiple comments from the video. Top comments by default, or filtered when \"Search keyword\" is set:\n`https://www.youtube.com/watch?v=VIDEO_ID`\n\n**Comment URL**: screenshots one specific comment:\n`https://www.youtube.com/watch?v=VIDEO_ID&lc=COMMENT_ID`\n\nTo get a comment URL: on YouTube, click the three dots (⋮) next to the comment → \"Copy link\". The copied URL includes `&lc=...`.\n\nYou can mix both types in the same run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "commentKeyword": {
                        "title": "Search keyword (optional)",
                        "type": "string",
                        "description": "Filter comments by text. Example: `amazing` → only screenshot comments containing the word \"amazing\".\n\n**Leave empty** to screenshot the top comments of each video (no filter, YouTube's default \"Top comments\" order).\n\n**Not used** for direct comment URLs, which already target a specific comment."
                    },
                    "maxComments": {
                        "title": "Max matching comments per video",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Cap how many comments to screenshot per video URL. Applies to both keyword search and top-comments mode. Ignored for direct comment URLs (always 1).",
                        "default": 1
                    },
                    "theme": {
                        "title": "Theme",
                        "enum": [
                            "light",
                            "dark"
                        ],
                        "type": "string",
                        "description": "Match YouTube's light or dark mode look.",
                        "default": "light"
                    },
                    "imageWidth": {
                        "title": "Image width",
                        "enum": [
                            "360",
                            "480",
                            "600",
                            "720",
                            "960",
                            "1200",
                            "1800",
                            "2400"
                        ],
                        "type": "string",
                        "description": "Output image width in pixels. Higher values produce sharper screenshots but larger files.",
                        "default": "1200"
                    },
                    "imageFormat": {
                        "title": "Image format",
                        "enum": [
                            "png",
                            "jpeg"
                        ],
                        "type": "string",
                        "description": "PNG for lossless output, JPEG for smaller file size.",
                        "default": "png"
                    },
                    "proxyConfig": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxies for accessing YouTube.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
