# YouTube Channel Statistics Scraper (`maximedupre/youtube-channel-statistics-scraper`) Actor

Get public YouTube channel statistics from URLs, @handles, channel IDs, /c URLs, /user URLs, or plain handles. Export subscriber count, total views, video count, profile fields, images, and source URLs. No YouTube API key or login needed.

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

## Pricing

from $2.65 / 1,000 channel statistics

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 channel statistics scraper without an API key

YouTube Channel Statistics Scraper collects public channel-level stats from [YouTube](https://www.youtube.com/). Add channel URLs, @handles, channel IDs, `/c/...` URLs, `/user/...` URLs, or plain handles, then export one clean row per channel with subscriber count, total views, video count, profile details, source URLs, and scrape metadata.

Use this YouTube channel statistics scraper for creator research, influencer lists, competitor tracking, channel reports, lead enrichment, or scheduled checks of public YouTube channels. You do not need YouTube cookies, a login, or a YouTube API key. For a representative first run, keep the prefilled channels.

The Actor is focused on channel statistics, not video crawling. If you only need the public size and identity of each channel, you get a compact dataset that is easy to export as JSON, CSV, Excel, XML, RSS, or HTML, or use through the Apify API, schedules, webhooks, and integrations.

### ✅ What this Actor does

- Scrapes public YouTube channel About pages.
- Accepts YouTube channel URLs, @handles, channel IDs, `/c/...` URLs, `/user/...` URLs, and plain handles.
- Saves one dataset item per successfully collected public channel.
- Returns both display text and parsed numbers for subscribers, total views, and videos.
- Adds channel identity fields such as channel ID, handle, canonical URL, title, description, country, and verification status.
- Adds avatar and banner image URLs when YouTube exposes them.
- Keeps the submitted target, normalized target, source URL, input position, scrape time, and status for traceability.
- Skips unsupported, private, removed, blocked, or unresolved channels without saving misleading rows.

### 📦 Data you can export

Each output item represents one public YouTube channel statistics result. Fields include:

- `sourceTarget`, `sourceUrl`, `normalizedTarget`, and `inputPosition`
- `channelId`, `channelHandle`, `channelUrl`, and `channelTitle`
- `channelDescription`, `country`, `isVerified`, `avatarUrl`, and `bannerUrl`
- `subscriberCountText` and `subscriberCount`
- `totalViewsText` and `totalViews`
- `videoCountText` and `videoCount`
- `createdAtText` and `createdAt`
- `channelLinks`, `scrapedAt`, and `status`

Some fields can be `null` or empty when YouTube does not show them on the public channel page. The dataset contains usable scraped channel rows only; targets that cannot be resolved are reported in the run log.

### 🚀 How to run it

1. Open the Input tab.
2. Add one YouTube channel per line in **YouTube channels**.
3. Keep the prefilled channels for a representative first run, or replace them with your own list.
4. Leave deduplication on if repeated inputs should be checked once.
5. Run the Actor and open the dataset.
6. Export the rows or connect them to your workflow with the Apify API, scheduler, webhooks, or integrations.

Accepted input examples:

```json
{
	"channels": [
		"@mkbhd",
		"veritasium",
		"https://www.youtube.com/@NASA",
		"https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ",
		"https://www.youtube.com/c/Google",
		"https://www.youtube.com/user/youtube"
	],
	"deduplicateChannels": true,
	"languageHint": "en",
	"countryHint": "US"
}
````

### 🧾 Output example

```json
{
	"sourceTarget": "@mkbhd",
	"sourceUrl": "https://www.youtube.com/@mkbhd/about",
	"normalizedTarget": "@mkbhd",
	"inputPosition": 1,
	"channelId": "UCBJycsmduvYEL83R_U4JriQ",
	"channelHandle": "@mkbhd",
	"channelUrl": "https://www.youtube.com/@mkbhd",
	"channelTitle": "Marques Brownlee",
	"channelDescription": "MKBHD: Quality Tech Videos",
	"subscriberCountText": "21M subscribers",
	"subscriberCount": 21000000,
	"totalViewsText": "4,900,000,000 views",
	"totalViews": 4900000000,
	"videoCountText": "1.8K videos",
	"videoCount": 1800,
	"country": "United States",
	"createdAtText": "Joined Mar 21, 2008",
	"createdAt": "2008-03-21",
	"isVerified": true,
	"avatarUrl": "https://yt3.googleusercontent.com/...",
	"bannerUrl": "https://yt3.googleusercontent.com/...",
	"channelLinks": [],
	"scrapedAt": "2026-05-31T00:00:00.000Z",
	"status": "ok"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing with no Actor-start charge.

- **Channel statistics**: `$0.00265` per saved channel statistics result.

You only pay for channel statistics results that are saved to the dataset. Unsupported or unavailable targets do not create paid output rows.

### 💡 Common use cases

- Build influencer and creator lists with subscriber, view, and video counts.
- Compare public YouTube channel size across competitors or partners.
- Enrich lead lists with channel IDs, handles, profile text, and country.
- Monitor channel growth snapshots on a schedule.
- Feed public YouTube channel stats into spreadsheets, BI tools, CRMs, or AI workflows.
- Keep a lightweight channel statistics dataset without scraping every video.

### ⚠️ Limits and caveats

- This Actor scrapes public YouTube channel pages only.
- It does not scrape channel videos, comments, transcripts, emails, downloads, private channels, or hidden analytics.
- Subscriber, view, video, country, image, and joined-date fields depend on what YouTube shows publicly at run time.
- Private, removed, blocked, unsupported, or unresolved channels may return no row with a warning in the run log.
- Plain handles are treated as YouTube @handles. Use a full URL when the channel uses an older `/c/...` or `/user/...` path and the plain handle does not resolve.

### ❓ FAQ

#### Do I need a YouTube API key?

No. The Actor works with public YouTube channel pages and does not ask for a YouTube API key, cookies, or login.

#### Can I paste different channel formats in one run?

Yes. You can mix @handles, plain handles, channel IDs, full channel URLs, `/c/...` URLs, and `/user/...` URLs in the same input list.

#### Does this scrape YouTube videos?

No. This Actor returns channel-level statistics only. Use a YouTube channel or video scraper if you need video rows, publish dates, thumbnails, comments, or transcripts.

#### Why did a channel return no row?

The channel may be private, removed, blocked, unsupported, temporarily unavailable, or missing public channel statistics on the page YouTube returned during the run.

#### Can I schedule channel statistics checks?

Yes. You can schedule repeat runs on Apify and export each dataset through API calls, webhooks, or integrations.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

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

### 🔗 Other actors

- [YouTube Channel Scraper ↗](https://apify.com/maximedupre/youtube-channel-scraper) - Get YouTube channel profiles and recent video rows.
- [Social Media Stats Checker ↗](https://apify.com/maximedupre/social-media-stats-checker) - Check public profile stats across YouTube and other social platforms.
- [TikTok Profile Mention Scraper ↗](https://apify.com/maximedupre/tiktok-profile-mention-scraper) - Find public TikTok videos that mention selected profiles.
- [Twitch Scraper ↗](https://apify.com/maximedupre/twitch-scraper) - Export public Twitch channel, stream, game, clip, and VOD metadata.
- [Instagram Downloader API ↗](https://apify.com/maximedupre/instagram-downloader-api) - Extract direct media links and metadata from public Instagram URLs.

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

# Actor input Schema

## `channels` (type: `array`):

Add one public channel per line. You can mix @handles, plain handles, /channel/UC... IDs, /c/... URLs, /user/... URLs, and full YouTube channel URLs in one run.

## `deduplicateChannels` (type: `boolean`):

Check repeated channel targets once per run.

## `languageHint` (type: `string`):

Two-letter language hint for YouTube pages, such as en.

## `countryHint` (type: `string`):

Two-letter country hint for YouTube pages, such as US.

## Actor input object example

```json
{
  "channels": [
    "@mkbhd",
    "@veritasium",
    "@MrBeast",
    "@NASA",
    "@Google",
    "@YouTube",
    "@TED",
    "@NatGeo",
    "@BBCNews",
    "@CNN",
    "@WIRED",
    "@LinusTechTips",
    "@MarkRober",
    "@SmarterEveryDay",
    "@kurzgesagt",
    "@vlogbrothers",
    "@CrashCourse",
    "@MinutePhysics",
    "@FirstWeFeast",
    "@BonAppetit",
    "@IGN",
    "@Vox",
    "@TheDailyShow",
    "@Netflix",
    "@DudePerfect",
    "@TSeries"
  ],
  "deduplicateChannels": true,
  "languageHint": "en",
  "countryHint": "US"
}
```

# Actor output Schema

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

Open the dataset with scraped YouTube channel statistics.

# 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 = {
    "channels": [
        "@mkbhd",
        "@veritasium",
        "@MrBeast",
        "@NASA",
        "@Google",
        "@YouTube",
        "@TED",
        "@NatGeo",
        "@BBCNews",
        "@CNN",
        "@WIRED",
        "@LinusTechTips",
        "@MarkRober",
        "@SmarterEveryDay",
        "@kurzgesagt",
        "@vlogbrothers",
        "@CrashCourse",
        "@MinutePhysics",
        "@FirstWeFeast",
        "@BonAppetit",
        "@IGN",
        "@Vox",
        "@TheDailyShow",
        "@Netflix",
        "@DudePerfect",
        "@TSeries"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/youtube-channel-statistics-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 = { "channels": [
        "@mkbhd",
        "@veritasium",
        "@MrBeast",
        "@NASA",
        "@Google",
        "@YouTube",
        "@TED",
        "@NatGeo",
        "@BBCNews",
        "@CNN",
        "@WIRED",
        "@LinusTechTips",
        "@MarkRober",
        "@SmarterEveryDay",
        "@kurzgesagt",
        "@vlogbrothers",
        "@CrashCourse",
        "@MinutePhysics",
        "@FirstWeFeast",
        "@BonAppetit",
        "@IGN",
        "@Vox",
        "@TheDailyShow",
        "@Netflix",
        "@DudePerfect",
        "@TSeries",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/youtube-channel-statistics-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 '{
  "channels": [
    "@mkbhd",
    "@veritasium",
    "@MrBeast",
    "@NASA",
    "@Google",
    "@YouTube",
    "@TED",
    "@NatGeo",
    "@BBCNews",
    "@CNN",
    "@WIRED",
    "@LinusTechTips",
    "@MarkRober",
    "@SmarterEveryDay",
    "@kurzgesagt",
    "@vlogbrothers",
    "@CrashCourse",
    "@MinutePhysics",
    "@FirstWeFeast",
    "@BonAppetit",
    "@IGN",
    "@Vox",
    "@TheDailyShow",
    "@Netflix",
    "@DudePerfect",
    "@TSeries"
  ]
}' |
apify call maximedupre/youtube-channel-statistics-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Statistics Scraper",
        "description": "Get public YouTube channel statistics from URLs, @handles, channel IDs, /c URLs, /user URLs, or plain handles. Export subscriber count, total views, video count, profile fields, images, and source URLs. No YouTube API key or login needed.",
        "version": "0.0",
        "x-build-id": "Kp8ghSC7H3a4emmiG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~youtube-channel-statistics-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-youtube-channel-statistics-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-channel-statistics-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-youtube-channel-statistics-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-channel-statistics-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-youtube-channel-statistics-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "channels"
                ],
                "properties": {
                    "channels": {
                        "title": "YouTube channels",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Add one public channel per line. You can mix @handles, plain handles, /channel/UC... IDs, /c/... URLs, /user/... URLs, and full YouTube channel URLs in one run.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "deduplicateChannels": {
                        "title": "Deduplicate channels",
                        "type": "boolean",
                        "description": "Check repeated channel targets once per run.",
                        "default": true
                    },
                    "languageHint": {
                        "title": "Page language",
                        "type": "string",
                        "description": "Two-letter language hint for YouTube pages, such as en.",
                        "default": "en"
                    },
                    "countryHint": {
                        "title": "Page country",
                        "type": "string",
                        "description": "Two-letter country hint for YouTube pages, such as US.",
                        "default": "US"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```