# YouTube Channel Search Scraper (`automation-lab/youtube-channel-search-scraper`) Actor

🔎 Find YouTube channels by keyword and export handles, URLs, subscriber counts, thumbnails, snippets, and search ranks.

- **URL**: https://apify.com/automation-lab/youtube-channel-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Search Scraper

Find YouTube channels from public search keywords and export clean channel profile rows for lead generation, influencer discovery, partner research, and content-market mapping.

### What does YouTube Channel Search Scraper do?

YouTube Channel Search Scraper turns YouTube search into a structured channel directory.

It searches YouTube with the Channels filter enabled, reads the public search result data embedded in the page, and saves one dataset item for every channel it finds.

Use it when you need a repeatable list of channels around a topic instead of manually copying names, handles, thumbnails, and subscriber snippets from YouTube.

### Who is it for?

- 🎯 Influencer marketers building creator outreach lists.
- 🧲 Lead generation teams finding niche channels and communities.
- 📺 YouTube strategists mapping competitors in a category.
- 🤝 Partnership managers looking for brand-aligned channels.
- 🧪 Researchers tracking public channel discovery results over time.
- 🧰 Agencies that need CSV, JSON, or API-ready exports.

### Why use this actor?

- 🔎 Keyword-based channel discovery.
- 🧾 Structured dataset output.
- ⚡ HTTP-only implementation for low runtime cost.
- 🧩 Works with Apify API, schedules, webhooks, and MCP.
- 🌐 Optional proxy support for larger or repeated batches.
- 🧮 Includes source query and rank for auditability.

### What data can it extract?

| Field | Description |
| --- | --- |
| `channelId` | Stable YouTube channel ID when exposed. |
| `title` | Channel display name. |
| `handle` | YouTube handle, for example `Apify`. |
| `customUrl` | Canonical YouTube path, for example `/@Apify`. |
| `channelUrl` | Full channel URL. |
| `thumbnailUrl` | Channel avatar image URL. |
| `subscriberCountText` | Subscriber count as shown by YouTube. |
| `subscriberCount` | Parsed numeric subscriber estimate when possible. |
| `videoCountText` | Video-count text when YouTube exposes it. |
| `videoCount` | Parsed numeric video count when possible. |
| `description` | Public search snippet or optional About-page description. |
| `isVerified` | Whether a verification badge was detected. |
| `sourceQuery` | Keyword used for the search. |
| `sourceUrl` | Exact YouTube search URL fetched. |
| `searchRank` | Rank inside the search results. |
| `scrapedAt` | ISO timestamp for the scrape. |

### How much does it cost to scrape YouTube channel search results?

This actor uses pay-per-event pricing.

The default package price is designed around a low-cost HTTP workflow:

- Start event: small one-time run fee.
- Result event: charged per channel saved to the dataset.

At the platform-accepted BRONZE result price of $0.00005, 1,000 saved channels cost about $0.05 before any platform-tier discounts. Real cloud runs validated that this remains safely profitable.

### How to use it

1. Open the actor on Apify.
2. Add one or more keywords, such as `apify`, `ai automation`, or `fitness coach`.
3. Set the maximum channels per search.
4. Leave detail enrichment off for the fastest run.
5. Run the actor.
6. Download the dataset as CSV, JSON, Excel, XML, or RSS.

### Input options

#### Keywords

Use keywords when you want the actor to build YouTube channel-search URLs for you.

Example:

```json
{
  "keywords": ["apify", "web scraping"],
  "maxResultsPerSearch": 20
}
````

#### YouTube search URLs

Use search URLs when you already have a YouTube results page. The actor adds the Channels filter if the URL does not include it.

```json
{
  "searchUrls": [
    { "url": "https://www.youtube.com/results?search_query=apify" }
  ],
  "maxResultsPerSearch": 20
}
```

#### Maximum channels per search

`maxResultsPerSearch` controls how many channel rows are saved per keyword or URL.

Keep it small while testing. Increase it when running production lead lists.

#### Fetch channel details

`includeDetails` fetches each channel About page and tries to fill a missing description.

Leave it disabled unless you need that extra enrichment. It adds requests and can make runs slower.

#### Proxy configuration

Proxy use is optional.

For small tests, no proxy is usually cheapest. For repeated or larger runs, enable Apify Proxy in the input if YouTube starts rate-limiting requests.

### Output example

```json
{
  "channelId": "UCTgwcoeGGKmZ3zzCXN2qo_A",
  "title": "Apify",
  "handle": "Apify",
  "customUrl": "/@Apify",
  "channelUrl": "https://www.youtube.com/@Apify",
  "thumbnailUrl": "https://yt3.ggpht.com/...=s176-c-k-c0x00ffffff-no-rj-mo",
  "subscriberCountText": "14K subscribers",
  "subscriberCount": 14000,
  "videoCountText": null,
  "videoCount": null,
  "description": "Welcome to Apify's official YouTube channel!...",
  "isVerified": false,
  "sourceQuery": "apify",
  "sourceUrl": "https://www.youtube.com/results?search_query=apify&sp=EgIQAg%253D%253D",
  "searchRank": 1,
  "scrapedAt": "2026-06-12T08:30:00.000Z"
}
```

### Tips for better results

- ✅ Use specific topics, niches, products, or audience terms.
- ✅ Run multiple related keywords to build a broader prospect list.
- ✅ Keep `maxResultsPerSearch` modest for exploratory runs.
- ✅ Deduplicate downstream by `channelId` or `channelUrl`.
- ✅ Use schedules if you want to compare discovery results over time.

### Integrations

You can connect the output to:

- Google Sheets for creator-review workflows.
- Airtable for outreach pipelines.
- HubSpot or Salesforce for prospecting.
- Slack notifications for new niche channels.
- Make or Zapier automations through Apify webhooks.
- Custom enrichment pipelines that join channel URLs with your CRM.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/youtube-channel-search-scraper').call({
  keywords: ['apify', 'web scraping'],
  maxResultsPerSearch: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/youtube-channel-search-scraper').call(run_input={
    'keywords': ['apify', 'web scraping'],
    'maxResultsPerSearch': 20,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~youtube-channel-search-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["apify","web scraping"],"maxResultsPerSearch":20}'
```

### MCP usage

Use this actor from MCP-compatible clients through Apify MCP Server:

```text
https://mcp.apify.com/?tools=automation-lab/youtube-channel-search-scraper
```

Claude Code CLI setup:

```bash
claude mcp add apify-youtube-channel-search https://mcp.apify.com/?tools=automation-lab/youtube-channel-search-scraper
```

MCP JSON config block:

```json
{
  "mcpServers": {
    "apify-youtube-channel-search": {
      "url": "https://mcp.apify.com/?tools=automation-lab/youtube-channel-search-scraper"
    }
  }
}
```

Example prompts:

- "Find 20 YouTube channels about AI automation and return their URLs."
- "Build a prospect list of YouTube channels for web scraping tutorials."
- "Search three SaaS keywords and summarize the top channels by subscriber count."

### Claude Desktop MCP setup

Add Apify MCP Server to Claude Desktop and include this actor as an allowed tool.

Example JSON configuration:

```json
{
  "mcpServers": {
    "apify-youtube-channel-search": {
      "url": "https://mcp.apify.com/?tools=automation-lab/youtube-channel-search-scraper"
    }
  }
}
```

Then ask Claude to run the actor with your keywords and inspect the dataset.

### Claude Code MCP setup

Use the same Apify MCP URL in your Claude Code MCP configuration:

```bash
claude mcp add apify-youtube-channel-search https://mcp.apify.com/?tools=automation-lab/youtube-channel-search-scraper
```

```text
https://mcp.apify.com/?tools=automation-lab/youtube-channel-search-scraper
```

This is useful for building scripts that automatically discover channels and then enrich them with other data sources.

### Legality and ethical use

This actor extracts publicly available YouTube search result information.

You should use the data responsibly, respect YouTube's terms, avoid abusive request rates, and comply with privacy, spam, and outreach laws that apply to your use case.

Do not use scraped channel lists for deceptive, harmful, or unlawful activity.

### FAQ and troubleshooting

#### The run returned fewer channels than requested

YouTube may expose fewer public channel results for a query, or duplicate channels may appear across keywords and get skipped. Try broader keywords or add more related terms.

#### The run is rate-limited

Enable Apify Proxy in the input and keep the result limit modest. If you run large batches frequently, use schedules with conservative intervals.

#### Subscriber counts are missing or odd

YouTube sometimes localizes or hides count labels. The actor keeps the original text field and fills the numeric field only when it can parse a value safely.

### Related scrapers

Explore other Automation Lab actors for YouTube and content workflows:

- https://apify.com/automation-lab/youtube-channel-scraper
- https://apify.com/automation-lab/youtube-comments-scraper
- https://apify.com/automation-lab/youtube-transcript-scraper
- https://apify.com/automation-lab/youtube-video-details-scraper

### Dataset export formats

Apify lets you export results as:

- JSON
- CSV
- Excel
- XML
- RSS
- HTML table

### Scheduling

Use Apify schedules to refresh channel discovery lists weekly or monthly.

This can help monitor which channels appear for strategic keywords over time.

### Webhooks

Use webhooks to send completed datasets to your own API, Slack, Make, Zapier, or another automation system.

A common workflow is: run search → export channels → enrich channel URLs → send qualified leads to CRM.

### Support

If a run fails, include the run URL, input, and what output you expected when contacting support.

Small, reproducible inputs help diagnose YouTube layout or localization changes faster.

# Actor input Schema

## `keywords` (type: `array`):

Search phrases to run on YouTube with the Channels filter enabled.

## `searchUrls` (type: `array`):

Optional YouTube /results URLs. The actor automatically adds the Channels filter when missing.

## `maxResultsPerSearch` (type: `integer`):

Maximum number of channel rows to save for each keyword or search URL.

## `includeDetails` (type: `boolean`):

When enabled, fetches each channel About page to fill a missing description. Leave disabled for the fastest and cheapest runs.

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

Use Apify Proxy if YouTube rate-limits your run. Datacenter proxies are usually enough for small batches; residential can be selected if needed.

## Actor input object example

```json
{
  "keywords": [
    "apify",
    "web scraping"
  ],
  "searchUrls": [
    {
      "url": "https://www.youtube.com/results?search_query=apify&sp=EgIQAg%253D%253D"
    }
  ],
  "maxResultsPerSearch": 20,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "keywords": [
        "apify",
        "web scraping"
    ],
    "searchUrls": [
        {
            "url": "https://www.youtube.com/results?search_query=apify&sp=EgIQAg%253D%253D"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/youtube-channel-search-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 = {
    "keywords": [
        "apify",
        "web scraping",
    ],
    "searchUrls": [{ "url": "https://www.youtube.com/results?search_query=apify&sp=EgIQAg%253D%253D" }],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/youtube-channel-search-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 '{
  "keywords": [
    "apify",
    "web scraping"
  ],
  "searchUrls": [
    {
      "url": "https://www.youtube.com/results?search_query=apify&sp=EgIQAg%253D%253D"
    }
  ]
}' |
apify call automation-lab/youtube-channel-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Search Scraper",
        "description": "🔎 Find YouTube channels by keyword and export handles, URLs, subscriber counts, thumbnails, snippets, and search ranks.",
        "version": "0.1",
        "x-build-id": "KhOHpjHpLatTc9hbb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~youtube-channel-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-youtube-channel-search-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/automation-lab~youtube-channel-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-youtube-channel-search-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/automation-lab~youtube-channel-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-youtube-channel-search-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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Search phrases to run on YouTube with the Channels filter enabled.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "YouTube search URLs",
                        "type": "array",
                        "description": "Optional YouTube /results URLs. The actor automatically adds the Channels filter when missing.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResultsPerSearch": {
                        "title": "Maximum channels per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of channel rows to save for each keyword or search URL.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Fetch channel details",
                        "type": "boolean",
                        "description": "When enabled, fetches each channel About page to fill a missing description. Leave disabled for the fastest and cheapest runs.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use Apify Proxy if YouTube rate-limits your run. Datacenter proxies are usually enough for small batches; residential can be selected if needed.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```