# YouTube Lead Scraper (`maximedupre/youtube-lead-scraper`) Actor

Find YouTube creator and business leads from keywords or known channels. Export public emails, source evidence, channel identity, websites, social links, and visible channel context for outreach lists.

- **URL**: https://apify.com/maximedupre/youtube-lead-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media, Marketing, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 scraped leads

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 lead scraper for creator emails

YouTube Lead Scraper finds public creator and business leads from [YouTube](https://www.youtube.com/). Add search keywords such as `fitness coach` or `real estate investing`, or add known channel URLs, @handles, or channel IDs, then export public emails with source evidence, channel identity, websites, social links, and visible channel context.

Use this YouTube lead scraper when you need contactable YouTube leads for influencer outreach, agency prospecting, creator partnerships, sponsorship research, or B2B lead generation. It is built for public data that YouTube channels and linked public websites expose. You do not need YouTube cookies, a login, a Google API key, or a private account.

For a small first run, choose one target type. Use **Search keywords** when you want the Actor to discover channels from a niche. Use **YouTube channels** when you already know the channels you want to check. Make a second run when you want to use the other target type.

### ✅ What this Actor does

- Finds YouTube leads from search keywords or known YouTube channels.
- Accepts channel URLs, @handles, channel IDs, and keyword lists.
- Searches public YouTube result pages and checks public channel pages.
- Extracts public email addresses from YouTube channel text when visible.
- Optionally checks public websites linked from the channel for more contact emails.
- Saves only contactable lead rows with at least one public email.
- Adds source evidence so you can audit where the email came from.
- Adds public channel identity, website URL, social links, description, subscriber count, and video count when visible.
- Deduplicates the same email/channel/input combination during the run.
- Works with Apify dataset exports, API access, schedules, webhooks, and integrations.

This Actor does not generate outreach messages, score leads, infer niches, or invent missing channel facts. If a channel does not expose a public email on YouTube or a linked public website, it is skipped instead of saved as a weak lead.

### 📦 YouTube leads you can export

Each dataset row is one accepted public email lead. Fields include:

| Field | What it means |
| --- | --- |
| `email` | Normalized public email address for the lead. |
| `matchedInput` | Search keyword or channel target that produced the row. |
| `sourceUrl` | Public URL where the email was found or evidenced. |
| `sourceTitle` | Channel or page title when visible. |
| `emailSource` | Whether the email came from YouTube channel text or a linked website. |
| `sourceText` | Short public text excerpt for audit when available. |
| `youtubeChannel` | Channel ID, handle, title, and canonical URL when known. |
| `publicWebsiteUrl` | Public website linked from the channel when visible. |
| `socialLinks` | Public social/profile links exposed by the channel. |
| `channelContext` | Description, location, subscriber count, and video count when visible. |

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML, or read it through the Apify API.

### 🚀 Common use cases

- Build creator outreach lists from niches such as fitness, real estate, tech reviews, travel, or beauty.
- Enrich a known list of YouTube channels with public contact emails.
- Find business emails for agencies, sponsorship teams, and partnership research.
- Compare public channel context before outreach.
- Collect source-backed leads for a CRM, spreadsheet, webhook, or internal workflow.
- Schedule repeat lead checks for the same keyword set or channel list.

### ▶️ How to run it

1. Open the Input tab.
2. Fill exactly one target section: **Search keywords** or **YouTube channels**.
3. For keyword runs, choose **Discovery scope** and set **Max leads per search keyword**.
4. Optionally add a location, such as `United States` or `London`.
5. Optionally add email domains, such as `gmail.com` or `company.com`, if you only want matching addresses.
6. Keep **Check linked websites** on when you want the Actor to follow public websites linked from channels.
7. Start the run and open the dataset.

Use small keyword lists for the first run so you can inspect the output shape. For known-channel runs, add channel URLs or handles such as:

```json
{
  "channelTargets": [
    "@mkbhd",
    "https://www.youtube.com/@veritasium"
  ],
  "includeLinkedSites": true
}
````

For keyword discovery, use natural buyer or creator terms:

```json
{
  "searchKeywords": [
    "fitness coach",
    "real estate investing"
  ],
  "resultScope": "channelPages",
  "maxLeadsPerSearch": 25,
  "emailDomains": [],
  "includeLinkedSites": true
}
```

### ⚙️ Input options

- **Search keywords**: niches, roles, products, or places used to discover YouTube leads.
- **YouTube channels**: known channel URLs, @handles, or channel IDs to enrich.
- **Discovery scope**: use channel pages for focused discovery, or all YouTube results for broader keyword runs.
- **Max leads per search keyword**: accepted email leads to save for each keyword.
- **Location**: optional city, country, or region added to keyword searches.
- **Email domains**: optional domains to keep. Leave empty to keep all email domains.
- **Check linked websites**: also check the main public websites linked from channels.

Choose one target type per run. If both target sections are filled, the Actor asks you to keep only one.

### 🧾 Output example

```json
{
  "email": "hello@example.com",
  "matchedInput": "fitness coach",
  "sourceUrl": "https://www.youtube.com/@example/about",
  "sourceTitle": "Example Fitness Coach",
  "emailSource": "youtubeChannel",
  "sourceText": "For coaching inquiries email hello@example.com.",
  "youtubeChannel": {
    "id": "UC_x5XG1OV2P6uZZ5FSM9Ttw",
    "handle": "@example",
    "title": "Example Fitness Coach",
    "url": "https://www.youtube.com/@example"
  },
  "publicWebsiteUrl": "https://example.com",
  "socialLinks": ["https://www.instagram.com/example"],
  "channelContext": {
    "description": "Public channel description text when visible.",
    "location": "United States",
    "subscriberCount": 125000,
    "videoCount": 320
  }
}
```

Some fields can be `null` or empty when YouTube or the linked website does not expose that data publicly.

### 💸 Pricing

This Actor uses pay-per-result pricing. You are charged only when a unique lead row is saved with at least one public contact email. You are not charged for keywords searched, source pages checked, duplicate leads skipped, channels without public emails, or actor startup.

The current price is `$0.004` per accepted lead.

### ⚠️ Limits and caveats

- The Actor only returns public emails it can find on YouTube channel text or linked public websites.
- Not every YouTube channel publishes an email address.
- Some public websites or social profiles may block, rate-limit, or hide contact data.
- Subscriber counts, video counts, locations, descriptions, websites, and social links are included only when visible from the public source.
- Keyword discovery can take longer for broad keywords because the Actor checks candidate channels before saving leads.
- This Actor does not verify mailbox deliverability or send outreach.

### ❓ FAQ

#### 📺 Can I scrape emails from a list of YouTube channels?

Yes. Add channel URLs, @handles, or channel IDs in **YouTube channels** and leave **Search keywords** empty.

#### 🔎 Can I discover leads from a niche keyword?

Yes. Add one or more phrases in **Search keywords**, such as `fitness coach`, `wedding planner`, or `tech reviewer contact email`.

#### 🔐 Does it need a YouTube login or API key?

No. The Actor uses public YouTube pages and public linked websites. It does not need YouTube cookies, a private account, or a Google API key.

#### 📉 Why did my run return fewer leads than the limit?

The limit is a cap, not a guarantee. The Actor saves only channels or linked websites where it finds a public email, and many channels do not publish one.

#### 🔗 Can it find emails on websites linked from YouTube channels?

Yes, when **Check linked websites** is enabled. The Actor checks the main non-social public websites linked from the channel and saves emails found there.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~youtube-lead-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [YouTube Channel Search Scraper ↗](https://apify.com/maximedupre/youtube-channel-search-scraper) - Find public YouTube channels from keywords before checking contact details.
- [YouTube Channel Scraper ↗](https://apify.com/maximedupre/youtube-channel-scraper) - Export public channel profiles and recent video rows.
- [Influencer Scraper ↗](https://apify.com/maximedupre/influencer-scraper) - Find influencer profiles across TikTok, Instagram, and YouTube.
- [YouTube Description Extractor ↗](https://apify.com/maximedupre/youtube-description-extractor) - Extract full public YouTube video descriptions and links.
- [Website URL Crawler ↗](https://apify.com/maximedupre/website-url-crawler) - Map website URLs, links, and sitemap-backed pages.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `searchKeywords` (type: `array`):

Enter niches, roles, products, or places to discover YouTube leads.

## `channelTargets` (type: `array`):

Enter channel URLs, @handles, or channel IDs when you already know which channels to check.

## `resultScope` (type: `string`):

Choose focused channel pages or broader YouTube results for keyword runs.

## `maxLeadsPerSearch` (type: `integer`):

Caps accepted email leads for each search keyword.

## `location` (type: `string`):

Add a city, country, or region when leads should match a place.

## `emailDomains` (type: `array`):

Keep only emails from these domains. Leave empty to keep all domains.

## `includeLinkedSites` (type: `boolean`):

Also look for contact emails on public websites linked from the channel.

## Actor input object example

```json
{
  "channelTargets": [
    "https://www.youtube.com/@IndigoMarketingAgency",
    "https://www.youtube.com/channel/UCztor5qbjvs2y45LTx-9Dsw",
    "https://www.youtube.com/@TECHNICALVARUNPANDEY",
    "https://www.youtube.com/@mkbhd",
    "https://www.youtube.com/@veritasium"
  ],
  "resultScope": "channelPages",
  "maxLeadsPerSearch": 25,
  "location": "United States",
  "emailDomains": [],
  "includeLinkedSites": true
}
```

# Actor output Schema

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

Open the dataset of accepted YouTube lead rows.

# 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 = {
    "channelTargets": [
        "https://www.youtube.com/@IndigoMarketingAgency",
        "https://www.youtube.com/channel/UCztor5qbjvs2y45LTx-9Dsw",
        "https://www.youtube.com/@TECHNICALVARUNPANDEY",
        "https://www.youtube.com/@mkbhd",
        "https://www.youtube.com/@veritasium"
    ],
    "location": "United States"
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/youtube-lead-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 = {
    "channelTargets": [
        "https://www.youtube.com/@IndigoMarketingAgency",
        "https://www.youtube.com/channel/UCztor5qbjvs2y45LTx-9Dsw",
        "https://www.youtube.com/@TECHNICALVARUNPANDEY",
        "https://www.youtube.com/@mkbhd",
        "https://www.youtube.com/@veritasium",
    ],
    "location": "United States",
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/youtube-lead-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 '{
  "channelTargets": [
    "https://www.youtube.com/@IndigoMarketingAgency",
    "https://www.youtube.com/channel/UCztor5qbjvs2y45LTx-9Dsw",
    "https://www.youtube.com/@TECHNICALVARUNPANDEY",
    "https://www.youtube.com/@mkbhd",
    "https://www.youtube.com/@veritasium"
  ],
  "location": "United States"
}' |
apify call maximedupre/youtube-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Lead Scraper",
        "description": "Find YouTube creator and business leads from keywords or known channels. Export public emails, source evidence, channel identity, websites, social links, and visible channel context for outreach lists.",
        "version": "0.0",
        "x-build-id": "Y3GjxmxqBqQqjgGnL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~youtube-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-youtube-lead-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/maximedupre~youtube-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-youtube-lead-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/maximedupre~youtube-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-youtube-lead-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": {
                    "searchKeywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Enter niches, roles, products, or places to discover YouTube leads.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "channelTargets": {
                        "title": "YouTube channels",
                        "type": "array",
                        "description": "Enter channel URLs, @handles, or channel IDs when you already know which channels to check.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultScope": {
                        "title": "Discovery scope",
                        "enum": [
                            "channelPages",
                            "allYouTubeResults"
                        ],
                        "type": "string",
                        "description": "Choose focused channel pages or broader YouTube results for keyword runs.",
                        "default": "channelPages"
                    },
                    "maxLeadsPerSearch": {
                        "title": "Max leads per search keyword",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Caps accepted email leads for each search keyword.",
                        "default": 25
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Add a city, country, or region when leads should match a place."
                    },
                    "emailDomains": {
                        "title": "Email domains",
                        "type": "array",
                        "description": "Keep only emails from these domains. Leave empty to keep all domains.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "includeLinkedSites": {
                        "title": "Check linked websites",
                        "type": "boolean",
                        "description": "Also look for contact emails on public websites linked from the channel.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```