# YouTube Channel Phone Number Scraper (`lurkapi/youtube-channel-phone-scraper`) Actor

Extract phone numbers, WhatsApp links, and social media profiles from YouTube channel About pages. Supports @handles, channel URLs, channel IDs, video URLs, and keyword search.

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

## Pricing

from $10.00 / 1,000 youtube phone 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.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 Channel Phone Number Scraper

Extract phone numbers, WhatsApp links, and contact details from YouTube channels. Give it channel URLs, @handles, or search keywords, and get structured phone data with country detection.

### 📞 What it does

Give it YouTube channels (or keywords to find channels), and it will:

1. **Scan the channel's About page** for phone numbers
2. **Check video descriptions** and pinned comments for contact numbers
3. **Visit linked websites** and scan them for phone numbers and WhatsApp links
4. **Detect the country** and format each number automatically
5. **Return structured results** with phone numbers, social links, and channel metadata

### 📋 How to use it

#### Step 1: Choose your input

You can provide channels in several ways:
- **@handles**: `@mkbhd`, `@JimsPlumbingAUS`
- **Channel URLs**: `https://www.youtube.com/@handle` or `https://www.youtube.com/channel/UCxxx`
- **Channel IDs**: Any ID starting with `UC` (24 characters)
- **Video URLs**: The scraper will find the channel that uploaded the video
- **Keywords**: Search for channels by topic (e.g., "plumber Los Angeles", "dentist near me")

#### Step 2: Configure options

- **Scan Linked Websites**: Enabled by default. Visits websites linked on the channel's About page and checks their homepage, /contact, and /about pages for phone numbers.
- **Validate Phone Numbers**: Enabled by default. Filters out invalid or malformed numbers and detects the country for each phone number.
- **Concurrency**: How many channels to process at once (1-5). Higher is faster but may cause timeouts.

#### Step 3: Run it

Click **Start** and wait for results. Each channel takes about 5-10 seconds to process.

#### Step 4: Get your results

Results appear in the **Output** tab with three views:
- **Overview**: Quick summary with phone numbers and channel info
- **Contacts & Social Links**: All contact details including WhatsApp, website, Instagram, and more
- **Channel Metadata**: Subscriber counts, view counts, country, and join date

Each result includes a `status` field:
- **"Success"**: At least one phone number was found
- **"No phone number found"**: The channel was processed but no phone numbers were detected
- Error messages tell you what went wrong and what to try

### 🌐 Proxy settings

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

- **Automatic (default)**: Apify selects the best proxy for you.
- **Datacenter**: Fast and affordable. Works well for most channels.
- **Residential**: Use if you get frequent blocks or timeouts.
- **Own proxies**: Provide your own proxy URLs.
- **No proxy**: Disable proxies entirely. There will be no IP rotation if you get blocked.

### 💰 Pricing

This scraper uses **pay-per-result** pricing. You only pay when phone numbers are actually found.

| Event | Cost | When charged |
|-------|------|-------------|
| YouTube phone found | $0.010 per number | Phone found in the channel's description, video descriptions, or pinned comment |
| Website phone found | $0.005 per number | Phone found on the channel's linked website |
| Phone validated | $0.002 per number | When validation is enabled (default) |
| Keyword search | $0.05 per query | Each search keyword processed |

YouTube-sourced phone numbers cost more because they come directly from the channel owner. Website-sourced numbers are cheaper since they may be shared business contacts. WhatsApp numbers are charged as phone numbers based on where the link was found (YouTube or website).

**Example**: Processing 100 channels where 12 have phone numbers (5 from YouTube, 10 from websites):
- 5 YouTube phones: 5 x $0.010 = $0.05
- 10 website phones: 10 x $0.005 = $0.05
- 15 phones validated: 15 x $0.002 = $0.03
- **Total: $0.13**

Channels with no phone numbers are not charged.

### 💡 Good to know

- **Phone numbers are rarer than emails on YouTube.** Expect to find phone numbers on 10-20% of channels. Local businesses, service providers, and agencies are most likely to have them.
- **Website scanning finds the most numbers.** Many businesses put their phone number on their website but not their YouTube description. Keep "Scan Linked Websites" enabled for best results.
- **WhatsApp links are detected automatically.** If a channel or their website has a wa.me link, it will be captured and shown in the `whatsappUrl` field.
- **Supported URL formats**: @handles, youtube.com/@handle, youtube.com/channel/UCxxx, youtube.com/c/name, youtube.com/user/name, youtu.be/videoId, youtube.com/watch?v=videoId, youtube.com/shorts/videoId
- **Maximum 500 URLs** per run. Search queries are limited to 20 per run.
- **Data is stored in your Apify storage.** How long results are kept depends on your Apify plan.
- **Toll-free and premium-rate numbers are filtered out** (1-800, 1-900, etc.) since they are not direct contact numbers.

### ❓ FAQ

**Why were no phone numbers found for my channels?**
Not all YouTube channels have public phone numbers. Tech creators, entertainers, and large media channels rarely share phone numbers. Try local businesses, service providers, or agencies for better results. Also make sure "Scan Linked Websites" is enabled.

**Which proxy should I use?**
Start with the default (datacenter) proxy. If you get frequent timeouts or blocks, switch to residential proxies. Most runs work fine with datacenter proxies.

**What phone formats are detected?**
International (+1 555 123 4567), North American ((555) 123-4567, 555-123-4567), tel: links, and WhatsApp links (wa.me/number). Numbers are normalized to E.164 format (+country code + number).

**How long are the results stored?**
Results are stored in your Apify storage. Retention depends on your Apify plan.

**Can I search for channels by keyword?**
Yes. Use the "Search Keywords" input to find channels by topic. For example, "dentist Los Angeles" or "real estate agent Miami". Each keyword search costs $0.05.

### 🔗 Other tools you might like

- [YouTube Channel Email Scraper](https://apify.com/lurkapi/youtube-channel-email-scraper) - Extract business emails and social links from YouTube channels.
- [YouTube Channel Videos & Stats Scraper](https://apify.com/lurkapi/youtube-channel-videos-stats-scraper) - Scrape all videos from channels with detailed metadata.

### ⚖️ 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.

**Keywords:** youtube phone number scraper, youtube channel phone, youtube contact scraper, youtube whatsapp scraper, youtube lead generation, youtube phone extractor

# Actor input Schema

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

YouTube channel URLs, @handles, channel IDs, or video URLs.
## `searchQueries` (type: `array`):

Search YouTube for channels by keyword. Discovers channels from both channel and video results. Charged per search query.
## `maxResultsPerQuery` (type: `integer`):

How many channels to find and process per keyword search. Lower this to save costs, raise it to discover more channels.
## `country` (type: `string`):

Filter keyword search results by country. Leave empty to search all countries.
## `language` (type: `string`):

Language for keyword search results. Leave empty to search all languages.
## `joinedDateFrom` (type: `string`):

Only include channels that joined YouTube after this date. Channels older than this are skipped (not charged).
## `joinedDateTo` (type: `string`):

Only include channels that joined YouTube before this date. Channels newer than this are skipped (not charged).
## `scanLinkedWebsites` (type: `boolean`):

Visit websites linked on the channel's About page (including /contact and /about pages) and scan them for phone numbers and WhatsApp links.
## `validatePhones` (type: `boolean`):

Check if phone numbers have valid format for their country and detect the country of origin. Charged per phone validated.
## `concurrency` (type: `integer`):

Number of channels to process at the same time (1-5). Higher values are faster but may cause occasional timeouts on YouTube API calls.
## `proxyConfig` (type: `object`):

Select proxies for accessing YouTube.

## Actor input object example

```json
{
  "urls": [
    "@PlumberInLosAngeles"
  ],
  "searchQueries": [],
  "maxResultsPerQuery": 20,
  "country": "",
  "language": "",
  "scanLinkedWebsites": true,
  "validatePhones": true,
  "concurrency": 3,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
````

# Actor output Schema

## `overview` (type: `string`):

No description

## `contacts` (type: `string`):

No description

## `metadata` (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": [
        "@PlumberInLosAngeles"
    ],
    "searchQueries": [],
    "proxyConfig": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/youtube-channel-phone-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 = {
    "urls": ["@PlumberInLosAngeles"],
    "searchQueries": [],
    "proxyConfig": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/youtube-channel-phone-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 '{
  "urls": [
    "@PlumberInLosAngeles"
  ],
  "searchQueries": [],
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call lurkapi/youtube-channel-phone-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Phone Number Scraper",
        "description": "Extract phone numbers, WhatsApp links, and social media profiles from YouTube channel About pages. Supports @handles, channel URLs, channel IDs, video URLs, and keyword search.",
        "version": "0.0",
        "x-build-id": "1K9nTK5Dn9Fzs0Ohe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~youtube-channel-phone-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-youtube-channel-phone-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/lurkapi~youtube-channel-phone-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-youtube-channel-phone-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/lurkapi~youtube-channel-phone-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-youtube-channel-phone-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": {
                    "urls": {
                        "title": "YouTube URLs, @handles, or Channel IDs",
                        "maxItems": 500,
                        "type": "array",
                        "description": "YouTube channel URLs, @handles, channel IDs, or video URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search Keywords",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Search YouTube for channels by keyword. Discovers channels from both channel and video results. Charged per search query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Channels Per Search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many channels to find and process per keyword search. Lower this to save costs, raise it to discover more channels.",
                        "default": 20
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "",
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "Germany",
                            "France",
                            "Spain",
                            "Italy",
                            "Netherlands",
                            "Belgium",
                            "Switzerland",
                            "Austria",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Finland",
                            "Ireland",
                            "Portugal",
                            "Poland",
                            "Czech Republic",
                            "Romania",
                            "Hungary",
                            "Greece",
                            "Turkey",
                            "Russia",
                            "Ukraine",
                            "Israel",
                            "India",
                            "Japan",
                            "South Korea",
                            "China",
                            "Taiwan",
                            "Thailand",
                            "Indonesia",
                            "Malaysia",
                            "Philippines",
                            "Vietnam",
                            "Singapore",
                            "Brazil",
                            "Mexico",
                            "Argentina",
                            "Colombia",
                            "Chile",
                            "South Africa",
                            "Nigeria",
                            "Kenya",
                            "Egypt",
                            "Saudi Arabia",
                            "United Arab Emirates",
                            "New Zealand"
                        ],
                        "type": "string",
                        "description": "Filter keyword search results by country. Leave empty to search all countries.",
                        "default": ""
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "",
                            "English",
                            "Spanish",
                            "French",
                            "German",
                            "Italian",
                            "Portuguese",
                            "Dutch",
                            "Russian",
                            "Japanese",
                            "Korean",
                            "Chinese",
                            "Arabic",
                            "Hindi",
                            "Bengali",
                            "Turkish",
                            "Polish",
                            "Ukrainian",
                            "Romanian",
                            "Czech",
                            "Hungarian",
                            "Swedish",
                            "Norwegian",
                            "Danish",
                            "Finnish",
                            "Greek",
                            "Hebrew",
                            "Thai",
                            "Vietnamese",
                            "Indonesian",
                            "Malay",
                            "Filipino",
                            "Swahili",
                            "Persian",
                            "Urdu"
                        ],
                        "type": "string",
                        "description": "Language for keyword search results. Leave empty to search all languages.",
                        "default": ""
                    },
                    "joinedDateFrom": {
                        "title": "Joined After",
                        "type": "string",
                        "description": "Only include channels that joined YouTube after this date. Channels older than this are skipped (not charged)."
                    },
                    "joinedDateTo": {
                        "title": "Joined Before",
                        "type": "string",
                        "description": "Only include channels that joined YouTube before this date. Channels newer than this are skipped (not charged)."
                    },
                    "scanLinkedWebsites": {
                        "title": "Scan Linked Websites for Phone Numbers",
                        "type": "boolean",
                        "description": "Visit websites linked on the channel's About page (including /contact and /about pages) and scan them for phone numbers and WhatsApp links.",
                        "default": true
                    },
                    "validatePhones": {
                        "title": "Validate Phone Numbers",
                        "type": "boolean",
                        "description": "Check if phone numbers have valid format for their country and detect the country of origin. Charged per phone validated.",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of channels to process at the same time (1-5). Higher values are faster but may cause occasional timeouts on YouTube API calls.",
                        "default": 3
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
