# YouTube Shorts Scraper — Titles, Views, Hashtags & Viral Score (`khadinakbar/youtube-shorts-scraper`) Actor

Scrape YouTube Shorts by keyword, channel, or hashtag. Extracts titles, views, likes, comments, audio/music metadata, hashtags, engagement rate, and viral score. No proxy required for keyword searches.

- **URL**: https://apify.com/khadinakbar/youtube-shorts-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Videos, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 short scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Shorts Scraper — Views, Likes, Audio & Viral Score

### What Does YouTube Shorts Scraper Do?

YouTube Shorts Scraper extracts structured data from YouTube Shorts — the short-form vertical video format that's now driving billions of views per day. Unlike general YouTube scrapers, this actor is purpose-built for Shorts and returns Shorts-specific data that no other tool captures: **audio/music metadata**, **engagement rates**, and a calculated **viral score** that tells you exactly how much a Short overperformed relative to the channel's subscriber count.

You can scrape Shorts by keyword search, creator channel, hashtag, or direct video URL. Export to CSV, JSON, or push directly to your pipeline.

---

### Why Use YouTube Shorts Scraper?

- **No API quota limits** — YouTube's official API caps you at 10,000 units/day. This actor has no cap.
- **Shorts-specific data** — returns audio title, audio author, engagement rate, and viral score that general scrapers miss.
- **4 input modes** — search keywords, channel URLs, hashtag pages, or direct Short URLs. Mix and match in the same run.
- **MCP-ready** — structured JSON output with semantic field names, ready to pipe into Claude, ChatGPT, or any AI agent.
- **Engagement rate & viral score** — built-in calculated fields save you post-processing time.

---

### What Data Can YouTube Shorts Scraper Extract?

| Field | Type | Description |
|-------|------|-------------|
| `video_id` | string | YouTube's 11-character video ID |
| `title` | string | Short title |
| `description` | string | Full description with hashtags |
| `url` | string | Direct URL to the Short |
| `channel_name` | string | Creator's channel name |
| `channel_id` | string | YouTube channel ID (UCxxx…) |
| `channel_url` | string | Creator's channel URL |
| `channel_subscribers` | number | Channel subscriber count |
| `view_count` | number | Total views |
| `like_count` | number | Total likes |
| `comment_count` | number | Total comments |
| `duration_seconds` | number | Length in seconds |
| `published_at` | string | Upload date (ISO 8601) |
| `hashtags` | array | Hashtags from title & description |
| `audio_title` | string | Sound/music track title |
| `audio_author` | string | Sound/music creator |
| `thumbnail_url` | string | High-resolution thumbnail URL |
| `engagement_rate` | number | (likes + comments) / views |
| `viral_score` | number | views / subscribers (>1.0 = viral) |
| `scraped_at` | string | Scrape timestamp (ISO 8601) |
| `source_url` | string | Discovery URL used |

---

### How to Scrape YouTube Shorts — Step by Step

#### 1. By Keyword Search

Enter search terms to find Shorts about any topic. The actor automatically applies YouTube's Shorts filter so you get only short-form videos, not regular videos.

**Example input:**
```json
{
  "searchQueries": ["morning routine", "cooking hacks", "gym motivation"],
  "maxResults": 50
}
````

#### 2. By Creator Channel

Paste the Shorts tab URL of any YouTube channel to get all of their Shorts:

```json
{
  "channelUrls": [
    "https://www.youtube.com/@MrBeast/shorts",
    "https://www.youtube.com/@GordonRamsay/shorts"
  ],
  "maxResults": 100
}
```

#### 3. By Hashtag

Scrape all Shorts using a specific hashtag:

```json
{
  "hashtagUrls": [
    "https://www.youtube.com/hashtag/morningroutine",
    "https://www.youtube.com/hashtag/fyp"
  ],
  "maxResults": 30
}
```

#### 4. By Direct Short URL

Get full details for specific Shorts you already have URLs for:

```json
{
  "startUrls": [
    { "url": "https://www.youtube.com/shorts/VIDEO_ID_1" },
    { "url": "https://www.youtube.com/shorts/VIDEO_ID_2" }
  ]
}
```

***

### Understanding the Viral Score

The `viral_score` field is unique to this actor. It's calculated as:

```
viral_score = view_count / channel_subscribers
```

- **Score > 1.0** — The Short got more views than the channel has subscribers. Strong viral signal.
- **Score > 5.0** — Exceptional breakout performance.
- **Score < 0.5** — Below-average performance for this creator's audience.

This is the fastest way to identify which Shorts broke out of a creator's existing audience.

***

### Understanding the Engagement Rate

```
engagement_rate = (likes + comments) / views
```

Industry benchmarks for YouTube Shorts:

- **< 1% (0.01)** — Low engagement
- **1–5% (0.01–0.05)** — Average
- **> 5% (0.05)** — High engagement — content resonating strongly

***

### Pricing

This actor uses Pay-Per-Event pricing. You only pay for what you scrape.

| Plan | Price per Short |
|------|----------------|
| Free | $0.003 |
| Bronze | $0.0025 |
| Silver | $0.002 |
| Gold | $0.0015 |
| Platinum | $0.001 |
| Diamond | $0.0008 |

**Example cost:** 1,000 Shorts on the Free plan = **$3.00**

***

### Use Cases

**Content creators** — Analyze what Shorts formats, lengths, and topics get the highest engagement in your niche before you create.

**Brand marketers** — Find creators producing viral Shorts about topics relevant to your brand for influencer outreach.

**Trend analysts** — Monitor trending Shorts by hashtag or keyword to spot emerging trends before they peak.

**AI / ML teams** — Collect structured Shorts metadata at scale for training datasets, content recommendation models, or trend prediction.

**Competitive intelligence** — See exactly which Shorts your competitors post, how they perform, and what audio/music they use.

**SEO & Content Strategy** — Identify the top hashtags and audio tracks driving Shorts virality in any niche.

***

### Integration & Export

Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools.

**API example (Node.js):**

```javascript
const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('USERNAME/youtube-shorts-scraper').call({
  searchQueries: ['morning routine'],
  maxResults: 20,
});

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

**Scheduled runs:** Set up daily or weekly scraping runs in Apify Console to monitor Shorts trends over time.

***

### Frequently Asked Questions

**Does this require a YouTube account or login?**
No. All data scraped is from public YouTube pages. No credentials needed.

**Can I scrape private or age-restricted Shorts?**
No. Only publicly accessible Shorts can be scraped.

**Why are some fields null?**
YouTube sometimes hides like counts, disables comments, or doesn't show subscriber counts. When data isn't available, the field returns `null` rather than an incorrect value.

**How many Shorts can I scrape per run?**
There's no hard cap. Use `maxResults` to control the volume. For very large runs (1,000+), we recommend running multiple smaller jobs.

**Is the audio data always available?**
Audio/music metadata is extracted when YouTube displays it on the Shorts page. Original audio created by the creator may not have a listed track title.

***

### Technical Notes

- The actor uses a real Chromium browser (via Playwright) to navigate YouTube, avoiding bot detection.
- YouTube data structures update frequently. If you notice missing fields, please report an issue and we'll update the parser.
- For high-volume scraping, residential proxies are recommended via the proxy configuration option.

***

### Legal Disclaimer

*This actor is intended for lawful data collection from publicly available YouTube pages. Users are responsible for compliance with applicable laws, YouTube's Terms of Service, and data protection regulations (GDPR, CCPA, etc.). Do not use this tool to collect data on private individuals or for any unlawful purpose. Scraping YouTube at high volumes may violate their ToS — use responsibly.*

# Actor input Schema

## `searchQuery` (type: `string`):

Single keyword or phrase to search YouTube Shorts for (e.g. 'gym motivation', 'cooking hacks 2025'). For multiple keywords in one run, use the Search keywords list below.

## `searchQueries` (type: `array`):

List of keywords or topics to search YouTube Shorts for. Each query runs separately and up to maxResults Shorts are scraped per query. Use this for batch keyword research.

## `channelUrls` (type: `array`):

YouTube channel /shorts tab URLs to scrape all Shorts from a specific creator. Example: https://www.youtube.com/@MrBeast/shorts — paste the full URL including /shorts. Use for competitor analysis or creator research.

## `hashtagUrls` (type: `array`):

YouTube hashtag page URLs to scrape all Shorts tagged with a specific hashtag. Example: https://www.youtube.com/hashtag/gymtok — paste the full URL. Best for trend and niche research.

## `startUrls` (type: `array`):

Specific YouTube Short URLs to fetch full metadata for. Example: https://www.youtube.com/shorts/VIDEO\_ID. Use when you already have a list of Shorts you want to enrich with engagement data.

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

Maximum number of Shorts to scrape per search keyword, channel, or hashtag URL. Direct Short URLs are always fully scraped. For best results keep under 100; use 500+ only with residential proxies.

## `maxConcurrency` (type: `integer`):

Number of browser tabs open simultaneously. Lower values (1-3) reduce bot detection risk and memory usage. Higher values (5-10) speed up large runs but may trigger rate limits.

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

Proxy settings. No proxy is needed for keyword searches and basic metadata. Switch to Apify residential proxies if individual Short pages are blocked or if you need view counts from private/unlisted videos.

## Actor input object example

```json
{
  "searchQuery": "morning routine tips",
  "searchQueries": [],
  "channelUrls": [],
  "hashtagUrls": [],
  "startUrls": [],
  "maxResults": 20,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset containing all scraped YouTube Shorts. Access via API or download as CSV/JSON from the Apify console.

## `csvExport` (type: `string`):

Download all scraped Shorts as a CSV file, ready for Excel or Google Sheets.

# 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 = {
    "searchQuery": "morning routine tips",
    "searchQueries": [],
    "channelUrls": [],
    "hashtagUrls": [],
    "startUrls": [],
    "maxResults": 20,
    "maxConcurrency": 3,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/youtube-shorts-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 = {
    "searchQuery": "morning routine tips",
    "searchQueries": [],
    "channelUrls": [],
    "hashtagUrls": [],
    "startUrls": [],
    "maxResults": 20,
    "maxConcurrency": 3,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/youtube-shorts-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 '{
  "searchQuery": "morning routine tips",
  "searchQueries": [],
  "channelUrls": [],
  "hashtagUrls": [],
  "startUrls": [],
  "maxResults": 20,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call khadinakbar/youtube-shorts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Shorts Scraper — Titles, Views, Hashtags & Viral Score",
        "description": "Scrape YouTube Shorts by keyword, channel, or hashtag. Extracts titles, views, likes, comments, audio/music metadata, hashtags, engagement rate, and viral score. No proxy required for keyword searches.",
        "version": "1.0",
        "x-build-id": "zisiBcvaquN2LaN0b"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~youtube-shorts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-youtube-shorts-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/khadinakbar~youtube-shorts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-youtube-shorts-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/khadinakbar~youtube-shorts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-youtube-shorts-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": {
                    "searchQuery": {
                        "title": "Search keyword (quick start)",
                        "type": "string",
                        "description": "Single keyword or phrase to search YouTube Shorts for (e.g. 'gym motivation', 'cooking hacks 2025'). For multiple keywords in one run, use the Search keywords list below."
                    },
                    "searchQueries": {
                        "title": "Search keywords (multiple)",
                        "type": "array",
                        "description": "List of keywords or topics to search YouTube Shorts for. Each query runs separately and up to maxResults Shorts are scraped per query. Use this for batch keyword research.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "channelUrls": {
                        "title": "Channel URLs (Shorts tab)",
                        "type": "array",
                        "description": "YouTube channel /shorts tab URLs to scrape all Shorts from a specific creator. Example: https://www.youtube.com/@MrBeast/shorts — paste the full URL including /shorts. Use for competitor analysis or creator research.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "hashtagUrls": {
                        "title": "Hashtag URLs",
                        "type": "array",
                        "description": "YouTube hashtag page URLs to scrape all Shorts tagged with a specific hashtag. Example: https://www.youtube.com/hashtag/gymtok — paste the full URL. Best for trend and niche research.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Direct Short URLs",
                        "type": "array",
                        "description": "Specific YouTube Short URLs to fetch full metadata for. Example: https://www.youtube.com/shorts/VIDEO_ID. Use when you already have a list of Shorts you want to enrich with engagement data.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "Short URL",
                                    "description": "URL of a YouTube Short (e.g. https://www.youtube.com/shorts/VIDEO_ID)"
                                }
                            }
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Max Shorts per input",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of Shorts to scrape per search keyword, channel, or hashtag URL. Direct Short URLs are always fully scraped. For best results keep under 100; use 500+ only with residential proxies.",
                        "default": 20
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent browser pages",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of browser tabs open simultaneously. Lower values (1-3) reduce bot detection risk and memory usage. Higher values (5-10) speed up large runs but may trigger rate limits.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. No proxy is needed for keyword searches and basic metadata. Switch to Apify residential proxies if individual Short pages are blocked or if you need view counts from private/unlisted videos."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```