# YouTube Channel Videos Scraper (`fetch_cat/youtube-channel-videos-scraper`) Actor

Extract recent public YouTube channel videos by URL, handle, or channel ID. Export titles, descriptions, thumbnails, dates, Shorts flags, and views.

- **URL**: https://apify.com/fetch\_cat/youtube-channel-videos-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Videos, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.06 / 1,000 video results

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

Extract recent public videos from YouTube channels by channel URL, handle, or channel ID.

Use this actor when you need a clean dataset of latest videos from one or many public channels.
It returns channel identity, video URLs, titles, descriptions, thumbnails, publication dates, Shorts detection, and view counts when available.

### Choose the right YouTube actor

| Need | Use |
| --- | --- |
| Viewer feedback and replies | YouTube Comments Scraper |
| Recent uploads from a channel | YouTube Channel Videos Scraper |
| Caption text for summaries, RAG, or research | YouTube Transcript Scraper |

### What does YouTube Channel Videos Scraper do?

YouTube Channel Videos Scraper collects recent public video metadata from YouTube channels.

It helps you turn public channel activity into a structured dataset you can export, analyze, or feed into automation.

You can enter:

- 📺 Full channel URLs such as `https://www.youtube.com/@GoogleDevelopers`
- 🧑‍💻 YouTube handles such as `@Apify`
- 🆔 Channel IDs such as `UC_x5XG1OV2P6uZZ5FSM9Ttw`

The actor saves one dataset item for each video found.

### Who is it for?

This scraper is useful for teams that monitor YouTube channels regularly.

- 📈 Marketers tracking competitor publishing schedules
- 📰 Media teams following public creator and brand channels
- 🧪 Researchers building datasets from public video metadata
- 🤖 Automation teams enriching workflows with new YouTube uploads
- 🧑‍💼 Sales and partnerships teams watching partner channel activity

### Why use this YouTube channel video scraper?

YouTube's official API has quotas and setup requirements.

This actor is designed for quick, repeatable exports from public channels.

You can start with a small list of channels, download the results, and schedule the actor when you need fresh monitoring.

### What YouTube video data can I extract?

The dataset contains practical fields for analysis and automation.

| Field | Description |
| --- | --- |
| `channelId` | YouTube channel ID |
| `channelName` | Public channel name |
| `channelUrl` | Channel URL |
| `videoId` | YouTube video ID |
| `videoUrl` | Direct video or Short URL |
| `title` | Video title |
| `description` | Public video description |
| `publishedAt` | Publication timestamp |
| `thumbnailUrl` | Video thumbnail URL |
| `duration` | Duration when available |
| `isShort` | Whether the item is a YouTube Short |
| `viewCount` | View count when available |
| `sourceUrl` | Input channel source used for the result |
| `scrapedAt` | Timestamp when the item was collected |

### How much does it cost to scrape YouTube channel videos?

The actor uses pay-per-result pricing.

You pay a small start fee plus a small amount for each video result saved.

Formula-based validation measured a very low cost per result, so the live price uses the platform-safe minimum floor of about $0.10 per 1,000 video results at the default BRONZE tier, plus a small run-start fee.

The live price uses volume tiers so larger runs become cheaper per result.

Always check the Pricing tab on the actor page for the exact current price.

### How to scrape YouTube channel videos

1. Open the actor on Apify.
2. Add one or more public YouTube channel URLs, handles, or IDs.
3. Choose the maximum number of videos per channel.
4. Decide whether to include Shorts.
5. Click **Start**.
6. Download the dataset as JSON, CSV, Excel, XML, or HTML.

### Input example

```json
{
  "channelUrlsOrIds": [
    "https://www.youtube.com/@GoogleDevelopers",
    "UC_x5XG1OV2P6uZZ5FSM9Ttw"
  ],
  "maxVideosPerChannel": 10,
  "includeShorts": true
}
````

### Input fields

#### `channelUrlsOrIds`

Required.

Add public YouTube channels as URLs, handles, or channel IDs.

Examples:

- `https://www.youtube.com/@GoogleDevelopers`
- `@Apify`
- `UC_x5XG1OV2P6uZZ5FSM9Ttw`

#### `maxVideosPerChannel`

Optional.

Controls how many recent videos to save per channel.

Use a small number for tests and a larger number for scheduled monitoring.

#### `includeShorts`

Optional.

Set to `false` if you only want regular video URLs and want to skip Shorts.

### Output example

```json
{
  "channelId": "UC_x5XG1OV2P6uZZ5FSM9Ttw",
  "channelName": "Google for Developers",
  "channelUrl": "https://www.youtube.com/channel/UC_x5XG1OV2P6uZZ5FSM9Ttw",
  "videoId": "eaUd3iYkj_w",
  "videoUrl": "https://www.youtube.com/shorts/eaUd3iYkj_w",
  "title": "In production, which file actually gets loaded?",
  "description": "A package import can look simple on the surface.",
  "publishedAt": "2026-06-15T13:00:09+00:00",
  "thumbnailUrl": "https://i2.ytimg.com/vi/eaUd3iYkj_w/hqdefault.jpg",
  "duration": null,
  "isShort": true,
  "viewCount": 1315,
  "sourceUrl": "https://www.youtube.com/@GoogleDevelopers",
  "scrapedAt": "2026-06-15T20:00:00.000Z"
}
```

### Tips for better results

- ✅ Start with 1-2 channels when testing.
- ✅ Use channel IDs for the most stable input.
- ✅ Use handles for convenience when you do not know the channel ID.
- ✅ Keep `maxVideosPerChannel` modest for fast monitoring runs.
- ✅ Disable Shorts if your analysis only covers standard videos.

### Common use cases

#### Competitor monitoring

Track how often competing brands publish new videos.

Compare titles, descriptions, publication dates, and view counts.

#### Creator discovery

Build a list of recent uploads from public creator channels.

Use the output in downstream enrichment or scoring workflows.

#### Content operations

Monitor your own brand channels and partner channels.

Send new uploads to Slack, Google Sheets, Airtable, or a database.

#### Research datasets

Collect public metadata for trend analysis.

Use publication dates and titles to study activity over time.

### Integrations

Apify datasets can connect to many tools.

Useful workflow patterns include:

- 📊 Export to Google Sheets for editorial planning
- 🧱 Send results to Airtable for content operations
- 🔔 Trigger a webhook when a scheduled run finishes
- 🧠 Feed recent titles and descriptions into an LLM workflow
- 🗄️ Store results in BigQuery, Snowflake, or PostgreSQL

### API usage

You can run this actor from the Apify API.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/youtube-channel-videos-scraper').call({
  channelUrlsOrIds: ['https://www.youtube.com/@GoogleDevelopers'],
  maxVideosPerChannel: 10,
  includeShorts: true,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/youtube-channel-videos-scraper').call(run_input={
    'channelUrlsOrIds': ['https://www.youtube.com/@GoogleDevelopers'],
    'maxVideosPerChannel': 10,
    'includeShorts': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/fetch_cat~youtube-channel-videos-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"channelUrlsOrIds":["https://www.youtube.com/@GoogleDevelopers"],"maxVideosPerChannel":10,"includeShorts":true}'
```

### MCP integration

Use this actor through Apify MCP in Claude Code, Claude Desktop, or other MCP clients.

MCP URL:

`https://mcp.apify.com/?tools=fetch_cat/youtube-channel-videos-scraper`

Claude Code setup:

```bash
claude mcp add apify-youtube-channel-videos "https://mcp.apify.com/?tools=fetch_cat/youtube-channel-videos-scraper"
```

Claude Desktop JSON config:

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

Example prompts:

- "Run the YouTube Channel Videos Scraper for @GoogleDevelopers and summarize the newest video titles."
- "Check these three YouTube channels and tell me which published most recently."
- "Export recent video metadata for this channel list and flag Shorts separately."

### Scheduling

You can schedule the actor to run daily, weekly, or monthly.

Scheduled runs are useful for competitor monitoring and content calendars.

Use a fixed channel list and a low `maxVideosPerChannel` value for fast recurring checks.

### Limitations

The actor focuses on recent public videos from public channels.

It does not log in to YouTube.

It does not extract private, members-only, age-restricted, deleted, or unavailable videos.

Some fields depend on what YouTube exposes publicly for a given video.

### Troubleshooting

#### Why did my run return fewer videos than requested?

A channel may have fewer recent public videos available, or your settings may skip Shorts.

Try enabling `includeShorts` or checking that the channel has recent public uploads.

#### Why did a handle fail to resolve?

Handles can change and some channel URLs redirect.

Try using the channel's `UC...` ID or `/channel/UC...` URL for the most stable input.

#### Why is duration empty?

Duration is returned only when it is available in the public metadata used for the result.

The field is kept in the schema so downstream exports remain stable.

### Data freshness

Each run collects the current public recent-video metadata available at run time.

The `scrapedAt` field records when the item was collected.

Schedule repeated runs if you need history over time.

### Legality and responsible use

This actor extracts public metadata from public YouTube pages and feeds.

You should only use the data in a way that complies with applicable laws, YouTube's terms, and privacy rules.

Do not use scraped data for spam, harassment, or unauthorized profiling.

### Related scrapers

Explore related actors by `fetch_cat`:

- https://apify.com/fetch\_cat/youtube-transcript-scraper
- https://apify.com/fetch\_cat/tiktok-comments-scraper
- https://apify.com/fetch\_cat/reddit-scraper

### FAQ

#### Can I scrape multiple channels in one run?

Yes.

Add multiple values to `channelUrlsOrIds`.

The actor saves up to `maxVideosPerChannel` videos for each channel.

#### Can I use channel IDs instead of URLs?

Yes.

Channel IDs are supported and are the most stable input format.

#### Does this actor download videos?

No.

It extracts metadata and URLs, not video files.

#### Does it include Shorts?

Yes, by default.

Set `includeShorts` to `false` to skip Shorts when they appear.

#### Can I run it from code?

Yes.

Use the Apify API, Apify SDK, webhooks, schedules, or MCP.

### Support

If a public channel input fails, try a channel ID first.

If the issue continues, open an issue on the actor page with your input and run ID.

# Actor input Schema

## `channelUrlsOrIds` (type: `array`):

Add public YouTube channel URLs, @handles, or UC... channel IDs. Examples: https://www.youtube.com/@GoogleDevelopers, @Apify, UC\_x5XG1OV2P6uZZ5FSM9Ttw

## `maxVideosPerChannel` (type: `integer`):

Maximum recent videos to save for each channel. YouTube public channel feeds usually expose the latest batch of public videos.

## `includeShorts` (type: `boolean`):

Keep YouTube Shorts in the output when they appear in the channel's recent videos feed.

## Actor input object example

```json
{
  "channelUrlsOrIds": [
    "https://www.youtube.com/@GoogleDevelopers",
    "UC_x5XG1OV2P6uZZ5FSM9Ttw"
  ],
  "maxVideosPerChannel": 10,
  "includeShorts": true
}
```

# 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 = {
    "channelUrlsOrIds": [
        "https://www.youtube.com/@GoogleDevelopers",
        "UC_x5XG1OV2P6uZZ5FSM9Ttw"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/youtube-channel-videos-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 = { "channelUrlsOrIds": [
        "https://www.youtube.com/@GoogleDevelopers",
        "UC_x5XG1OV2P6uZZ5FSM9Ttw",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/youtube-channel-videos-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 '{
  "channelUrlsOrIds": [
    "https://www.youtube.com/@GoogleDevelopers",
    "UC_x5XG1OV2P6uZZ5FSM9Ttw"
  ]
}' |
apify call fetch_cat/youtube-channel-videos-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Videos Scraper",
        "description": "Extract recent public YouTube channel videos by URL, handle, or channel ID. Export titles, descriptions, thumbnails, dates, Shorts flags, and views.",
        "version": "0.1",
        "x-build-id": "e66agHCEXlJxd39NH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~youtube-channel-videos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-youtube-channel-videos-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/fetch_cat~youtube-channel-videos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-youtube-channel-videos-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/fetch_cat~youtube-channel-videos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-youtube-channel-videos-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": [
                    "channelUrlsOrIds"
                ],
                "properties": {
                    "channelUrlsOrIds": {
                        "title": "Channel URLs, handles, or IDs",
                        "type": "array",
                        "description": "Add public YouTube channel URLs, @handles, or UC... channel IDs. Examples: https://www.youtube.com/@GoogleDevelopers, @Apify, UC_x5XG1OV2P6uZZ5FSM9Ttw",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideosPerChannel": {
                        "title": "Maximum videos per channel",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum recent videos to save for each channel. YouTube public channel feeds usually expose the latest batch of public videos.",
                        "default": 10
                    },
                    "includeShorts": {
                        "title": "Include Shorts",
                        "type": "boolean",
                        "description": "Keep YouTube Shorts in the output when they appear in the channel's recent videos feed.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```