# YouTube Channel Lookalike Finder (`automation-lab/youtube-channel-lookalike-finder`) Actor

Find similar YouTube channels from seed creators for influencer discovery, sponsorship prospecting, and competitor research.

- **URL**: https://apify.com/automation-lab/youtube-channel-lookalike-finder.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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 Lookalike Finder

Find similar YouTube channels from seed creators, handles, channel IDs, or topical keywords. Use it to build creator prospect lists, map competitor channels, and discover partnership opportunities from public YouTube pages.

### What does YouTube Channel Lookalike Finder do?

This actor takes one or more seed YouTube channels and searches for channels that look topically related. It samples public channel metadata, recent video titles, and optional keywords, then returns ranked lookalike channel records.

The output is designed for influencer discovery, sponsorship research, content marketing, and competitive intelligence.

### Who is it for?

- 🎯 Influencer marketing teams finding creators similar to a known partner.
- 🧲 Sponsorship sales teams building prospect lists by niche.
- 📈 SEO and content teams mapping topic clusters on YouTube.
- 🧪 Startup founders researching competitors and adjacent creators.
- 🧰 Data teams enriching creator CRMs with public channel metadata.

### Why use this actor?

Manual YouTube discovery is slow. You search a seed channel, inspect videos, try related phrases, and copy channel links one by one. This actor automates that first-pass discovery and gives you structured rows ready for spreadsheets, CRMs, and enrichment workflows.

### How it works

1. Loads public seed channel pages with HTTP.
2. Extracts title, description, channel ID, subscribers when public, and recent video titles.
3. Builds discovery queries from your seed channel and keywords.
4. Searches YouTube channel results.
5. Scores each discovered channel using overlapping topical terms and available public metadata.
6. Saves one dataset item per lookalike channel.

### What data can I extract?

| Field | Description |
| --- | --- |
| `seedChannel` | Source seed channel used for discovery |
| `seedTitle` | Public seed channel title |
| `matchedChannelUrl` | Similar channel URL |
| `matchedChannelId` | YouTube channel ID when available |
| `matchedHandle` | Public @handle when available |
| `matchedTitle` | Similar channel title |
| `description` | Public channel description snippet |
| `subscriberCountText` | Public subscriber count text |
| `subscriberCount` | Parsed subscriber count number |
| `videoCountText` | Public video count text |
| `thumbnailUrl` | Channel thumbnail URL |
| `similarityScore` | 1-100 topical similarity score |
| `similarityReasons` | Human-readable reasons for the match |
| `discoveryQuery` | Query that found the channel |
| `overlapTerms` | Terms shared with seed/keywords |
| `recentVideos` | Recent seed-channel video context |
| `publicEmails` | Emails visible in public page HTML, if any |
| `scrapedAt` | ISO scrape timestamp |

### How much does it cost to find YouTube lookalike channels?

The actor uses pay-per-event pricing. There is a small run-start charge and a per-result charge for each lookalike channel saved. You control cost with `maxResults`.

Start with 10-25 results while testing a niche, then increase the limit for larger prospecting jobs.

### Quick start

1. Open the actor on Apify.
2. Add one or more seed YouTube channels.
3. Add optional keywords for your niche.
4. Set `maxResults`.
5. Run the actor.
6. Export the dataset as CSV, JSON, Excel, or via API.

### Input example

```json
{
  "seedChannels": ["https://www.youtube.com/@mkbhd"],
  "keywords": ["consumer technology reviews"],
  "maxResults": 25,
  "maxVideosPerSeed": 6,
  "includeEmails": true,
  "languageCode": "en",
  "regionCode": "US"
}
````

### Input fields

#### `seedChannels`

Seed YouTube channels. You can use full URLs, `@handles`, channel IDs, or plain handles.

#### `keywords`

Optional topical phrases. These help the actor broaden discovery beyond the seed channel metadata.

#### `maxResults`

Maximum similar channel records to save.

#### `maxVideosPerSeed`

How many recent seed-channel video titles to use as similarity context.

#### `includeEmails`

When enabled, the actor extracts email addresses only if they are visible in public page HTML/metadata without login.

#### `languageCode` and `regionCode`

YouTube localization hints used while fetching pages and search results.

### Output example

```json
{
  "seedChannel": "https://www.youtube.com/@mkbhd",
  "seedTitle": "Marques Brownlee",
  "matchedChannelUrl": "https://www.youtube.com/@exampletech",
  "matchedHandle": "@exampletech",
  "matchedTitle": "Example Tech Reviews",
  "subscriberCountText": "1.2M subscribers",
  "subscriberCount": 1200000,
  "similarityScore": 74,
  "similarityReasons": ["Shared topical terms: tech, reviews", "Discovered from query: consumer technology reviews"],
  "discoveryQuery": "consumer technology reviews",
  "overlapTerms": ["tech", "reviews"],
  "publicEmails": [],
  "scrapedAt": "2026-05-24T00:00:00.000Z"
}
```

### Tips for better results

- Use 2-5 seed channels from the same niche.
- Add keywords that buyers or fans would use.
- Keep `maxResults` low for test runs.
- Use region and language hints for localized creator discovery.
- Review `similarityReasons` before importing records into a CRM.

### Common workflows

#### Influencer prospecting

Start with creators you already sponsor. Export similar channels and enrich them with your internal outreach status.

#### Competitor research

Start with a competitor's YouTube channel. Discover adjacent channels competing for the same audience.

#### Content gap analysis

Use keyword-only or seed-plus-keyword runs to map creators around a topic cluster.

#### Agency lead generation

Run one seed channel per client vertical, export CSV, and hand qualified rows to outreach specialists.

### Integrations

- Google Sheets: export CSV or connect via Apify API.
- Airtable: import JSON/CSV dataset exports.
- HubSpot: send matched channel URLs to enrichment workflows.
- Clay: use dataset API output as a lead source.
- Make/Zapier: trigger follow-up automations after each run.

### API usage

#### 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-lookalike-finder').call({
  seedChannels: ['https://www.youtube.com/@mkbhd'],
  keywords: ['consumer technology reviews'],
  maxResults: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/youtube-channel-lookalike-finder').call(run_input={
    'seedChannels': ['https://www.youtube.com/@mkbhd'],
    'keywords': ['consumer technology reviews'],
    'maxResults': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~youtube-channel-lookalike-finder/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"seedChannels":["https://www.youtube.com/@mkbhd"],"keywords":["consumer technology reviews"],"maxResults":25}'
```

### MCP: use with AI agents

Use Apify MCP with Claude Code, Claude Desktop, or other MCP clients:

`https://mcp.apify.com/?tools=automation-lab/youtube-channel-lookalike-finder`

Claude Code CLI setup:

```bash
claude mcp add apify-youtube-lookalikes https://mcp.apify.com/?tools=automation-lab/youtube-channel-lookalike-finder
```

Claude Desktop JSON configuration:

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

Example prompts:

- "Find 25 channels similar to this YouTube creator and summarize the top prospects."
- "Build a spreadsheet of creator prospects for consumer tech reviews."
- "Compare the similarity reasons and pick the best sponsorship targets."

### Data quality notes

YouTube may localize labels and hide some counts. The actor stores both raw count text and parsed numeric values when parsing is possible. Similarity scores are discovery signals, not a guarantee of audience overlap.

### Limits and caveats

This actor uses public YouTube pages only. It does not log in, bypass paywalls, access private contact details, or call private YouTube APIs. Some public data may be unavailable depending on channel settings and YouTube layout changes.

### Troubleshooting

#### Why did I get fewer results than requested?

The search niche may have fewer public channel results, or duplicates may be removed across queries. Add broader keywords or more seed channels.

#### Why are public emails empty?

Most YouTube contact emails require login or CAPTCHA on the About page. This actor only returns emails visible in public HTML/metadata without login.

### Legality

This actor extracts publicly available information. You are responsible for using the data lawfully, respecting applicable privacy rules, honoring YouTube's terms, and complying with outreach regulations such as CAN-SPAM and GDPR.

### Related scrapers

- YouTube Scraper: https://apify.com/automation-lab/youtube-scraper
- YouTube Channel Scraper: https://apify.com/automation-lab/youtube-channel-scraper
- TikTok Profile Scraper: https://apify.com/automation-lab/tiktok-profile-scraper
- Instagram Profile Scraper: https://apify.com/automation-lab/instagram-profile-scraper
- Website Email Scraper: https://apify.com/automation-lab/website-email-scraper

### FAQ

#### Can I use only keywords?

Yes. If no seed channel is provided, the actor can run from keywords, but seed channels usually produce better topical context.

#### Does it use the official YouTube API?

No. It extracts public web data from YouTube pages.

#### Can it find hidden business emails?

No. It only returns emails that are public in visible HTML/metadata without authentication.

#### Can I export to Excel?

Yes. Apify datasets support CSV, JSON, XML, RSS, and Excel-compatible exports.

#### How should I pick seed channels?

Use channels that represent your target niche clearly. Avoid mixing unrelated niches in the same small run.

### Changelog

- 0.1.0 Initial build with seed channel loading, YouTube channel search, similarity scoring, and public email extraction from visible HTML.

### Support

If a run fails or YouTube changes its page structure, open an Apify issue with the run URL and input. Include seed channels, keywords, and expected output so we can reproduce quickly.

# Actor input Schema

## `seedChannels` (type: `array`):

YouTube channel URLs, @handles, channel IDs, or plain handles to use as the source creators.

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

Optional topical keywords that broaden discovery beyond the seed channel metadata.

## `maxResults` (type: `integer`):

Maximum number of similar channel records to save.

## `maxVideosPerSeed` (type: `integer`):

How many recent seed-channel video titles to use as extra similarity signals.

## `includeEmails` (type: `boolean`):

Extract email addresses only when they appear in public page HTML/metadata without login.

## `languageCode` (type: `string`):

Preferred YouTube interface language for search and channel pages.

## `regionCode` (type: `string`):

Preferred YouTube region hint for search pages.

## Actor input object example

```json
{
  "seedChannels": [
    "https://www.youtube.com/@mkbhd"
  ],
  "keywords": [
    "consumer technology reviews"
  ],
  "maxResults": 20,
  "maxVideosPerSeed": 6,
  "includeEmails": true,
  "languageCode": "en",
  "regionCode": "US"
}
```

# 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 = {
    "seedChannels": [
        "https://www.youtube.com/@mkbhd"
    ],
    "keywords": [
        "consumer technology reviews"
    ],
    "languageCode": "en",
    "regionCode": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/youtube-channel-lookalike-finder").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 = {
    "seedChannels": ["https://www.youtube.com/@mkbhd"],
    "keywords": ["consumer technology reviews"],
    "languageCode": "en",
    "regionCode": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/youtube-channel-lookalike-finder").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 '{
  "seedChannels": [
    "https://www.youtube.com/@mkbhd"
  ],
  "keywords": [
    "consumer technology reviews"
  ],
  "languageCode": "en",
  "regionCode": "US"
}' |
apify call automation-lab/youtube-channel-lookalike-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Lookalike Finder",
        "description": "Find similar YouTube channels from seed creators for influencer discovery, sponsorship prospecting, and competitor research.",
        "version": "0.1",
        "x-build-id": "84IwyoaFMNoawgjWt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~youtube-channel-lookalike-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-youtube-channel-lookalike-finder",
                "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-lookalike-finder/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-youtube-channel-lookalike-finder",
                "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-lookalike-finder/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-youtube-channel-lookalike-finder",
                "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": {
                    "seedChannels": {
                        "title": "Seed YouTube channels",
                        "type": "array",
                        "description": "YouTube channel URLs, @handles, channel IDs, or plain handles to use as the source creators.",
                        "default": [
                            "https://www.youtube.com/@mkbhd"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Extra discovery keywords",
                        "type": "array",
                        "description": "Optional topical keywords that broaden discovery beyond the seed channel metadata.",
                        "default": [
                            "consumer technology reviews"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum lookalike channels",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of similar channel records to save.",
                        "default": 20
                    },
                    "maxVideosPerSeed": {
                        "title": "Recent videos sampled per seed",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many recent seed-channel video titles to use as extra similarity signals.",
                        "default": 6
                    },
                    "includeEmails": {
                        "title": "Include public emails if visible",
                        "type": "boolean",
                        "description": "Extract email addresses only when they appear in public page HTML/metadata without login.",
                        "default": true
                    },
                    "languageCode": {
                        "title": "Language code",
                        "type": "string",
                        "description": "Preferred YouTube interface language for search and channel pages.",
                        "default": "en"
                    },
                    "regionCode": {
                        "title": "Region code",
                        "type": "string",
                        "description": "Preferred YouTube region hint for search pages.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
