# YouTube Shorts Downloader (`maximedupre/youtube-shorts-downloader`) Actor

Download direct links from public YouTube Shorts URLs. Export playable video links, separate video and audio links when available, quality details, thumbnails, duration, channel details, and canonical URLs.

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

## Pricing

$2.00 / 1,000 downloaded shorts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 downloader for public Shorts URLs

YouTube Shorts Downloader turns public [YouTube Shorts](https://www.youtube.com/shorts/) URLs into direct download links and clean metadata. Paste one or more Shorts links, choose a preferred video quality, and get a dataset with the best available link, separate video and audio streams when YouTube exposes them, thumbnails, duration, channel details, canonical URLs, and scrape timestamps.

Use this YouTube Shorts downloader when you already have Shorts URLs and need repeatable exports for content review, creative research, moderation queues, archiving, reporting, or an API workflow. The Actor is focused on known public Shorts. It does not search YouTube, crawl channels, convert MP3 files, fetch transcripts, or access private videos.

For a quick first run, keep the prefilled public Shorts, leave **Preferred video quality** at `2k`, and start the Actor. Once the output shape fits your workflow, paste your own list of public YouTube Shorts URLs or call the Actor through the Apify API.

### ✅ What this Actor does

- Accepts public YouTube Shorts URLs.
- Accepts common YouTube URL variants such as `youtu.be` links and watch URLs when they point to a Short.
- Deduplicates repeated Shorts before source access.
- Saves one dataset row per reachable public Short.
- Returns the best available direct download link for each saved Short.
- Returns separate video and audio stream links when YouTube exposes them.
- Adds title, channel name, channel ID, channel URL, thumbnail, duration, quality, format, file-size hints, link expiry hints, source URL, and scrape timestamp when available.
- Charges only for successful Shorts saved to the dataset.
- Skips invalid, private, removed, login-only, unavailable, or temporarily unreachable Shorts without saving failure rows.

You do not need YouTube cookies, a YouTube login, or a YouTube API key. The public form stays focused on URLs and quality preference.

### 📦 Data you can export

Each output row represents one reachable YouTube Short. Core fields include:

- `input.url` and `input.index` - the submitted URL and its 1-based position.
- `videoId` - the stable YouTube video ID.
- `canonicalShortsUrl` and `watchUrl` - source links for tracing the Short.
- `title`, `channelName`, `channelId`, and `channelUrl`.
- `durationSeconds` and `thumbnailUrl`.
- `requestedQuality` and `providedQuality`.
- `downloadType` - `playable`, `separate_video_audio`, or `video_only`.
- `bestDownloadUrl` - the primary direct download link selected for the Short.
- `videoDownloadUrl` and `audioDownloadUrl` when separate streams are available.
- `bestFormat`, `videoFormat`, and `audioFormat` with quality, codec, extension, and size hints.
- `media.urlExpiresAt` when the direct link exposes an expiry timestamp.
- `availability.downloadLinkStatus` and `availability.downloadContentType` from a lightweight link check.
- `source`, `videoType`, and `scrapedAt`.

You can open the dataset in Apify, export it as JSON, CSV, Excel, XML, RSS, or HTML, call it through the Apify API, schedule runs, or connect results to webhooks and integrations.

### 🚀 How to run it

1. Open the Actor input.
2. Paste one or more public YouTube Shorts URLs in **YouTube Shorts URLs**.
3. Choose **Preferred video quality**.
4. Start the Actor.
5. Open the dataset and use `bestDownloadUrl` for the primary direct link.
6. Use `videoDownloadUrl` and `audioDownloadUrl` only when your workflow needs separate streams.

Accepted input examples:

```text
https://www.youtube.com/shorts/8Zk5XzLJSAw
https://youtube.com/shorts/8Zk5XzLJSAw
https://youtu.be/8Zk5XzLJSAw
https://www.youtube.com/watch?v=8Zk5XzLJSAw
````

### 🔧 Input options

#### 🔗 YouTube Shorts URLs

Paste public Shorts URLs. The field also accepts Apify request-list items with a `url` field, so you can paste many targets or provide them through the API.

The Actor processes up to 1000 unique URL targets in one run. Duplicate URL forms that point to the same YouTube video ID are processed once.

#### 🎞️ Preferred video quality

Choose the highest quality you want: `8k`, `4k`, `2k`, `1080p`, `720p`, `480p`, or `360p`.

This is a preference, not a guarantee. YouTube decides which formats are available for each Short. The output shows the actual `providedQuality`, selected format details, and whether a single playable link or separate streams were returned.

### 🧾 Output example

```json
{
	"status": "available",
	"input": {
		"url": "https://www.youtube.com/shorts/8Zk5XzLJSAw",
		"index": 1
	},
	"videoId": "8Zk5XzLJSAw",
	"canonicalShortsUrl": "https://www.youtube.com/shorts/8Zk5XzLJSAw",
	"watchUrl": "https://www.youtube.com/watch?v=8Zk5XzLJSAw",
	"title": "wax cracking is even more satisfying when you DIY it #soundon #wax #DIY",
	"channelName": "YouTube",
	"channelId": "UCBR8-60-B28hp2BmDPdntcQ",
	"channelUrl": "https://www.youtube.com/@YouTube",
	"durationSeconds": 25,
	"thumbnailUrl": "https://i.ytimg.com/vi/8Zk5XzLJSAw/hqdefault.jpg",
	"requestedQuality": "2k",
	"providedQuality": "360p",
	"downloadType": "playable",
	"bestDownloadUrl": "https://...",
	"videoDownloadUrl": "https://...",
	"audioDownloadUrl": "https://...",
	"bestFormat": {
		"formatId": "18",
		"quality": "360p",
		"resolution": "360x640",
		"extension": "mp4",
		"videoCodec": "avc1.42001E",
		"audioCodec": "mp4a.40.2",
		"filesizeBytes": 1867885
	},
	"videoFormat": {
		"formatId": "136",
		"quality": "720p",
		"resolution": "720x1280",
		"extension": "mp4",
		"videoCodec": "avc1.4d401f",
		"audioCodec": "none",
		"filesizeBytes": 3088104
	},
	"audioFormat": {
		"formatId": "140",
		"quality": "medium",
		"resolution": "audio only",
		"extension": "m4a",
		"videoCodec": "none",
		"audioCodec": "mp4a.40.2",
		"filesizeBytes": 402514
	},
	"media": {
		"extension": "mp4",
		"mimeType": null,
		"filesizeBytes": 1867885,
		"urlExpiresAt": "2026-06-15T20:00:00.000Z"
	},
	"availability": {
		"downloadLinkStatus": 206,
		"downloadContentType": "video/mp4",
		"note": null
	},
	"source": "youtube",
	"videoType": "short",
	"scrapedAt": "2026-06-15T16:00:00.000Z"
}
```

Some values can be `null` when YouTube does not expose them for a public Short. Direct download links can expire, so use or store them soon after the run.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged only for each reachable YouTube Short saved with download links and metadata.

- **Downloaded Short**: `$0.002` per saved Short, or `$2.00 per 1,000 saved Shorts`.

Invalid, private, removed, login-only, unavailable, skipped, or temporarily unreachable Shorts are not saved as dataset rows and do not create paid events.

### ⚠️ Limits and caveats

YouTube Shorts Downloader works with public Shorts that are reachable during the run. YouTube may hide, remove, rate-limit, or change access to public videos, and some Shorts expose only lower-quality playable links.

The Actor does not bypass privacy controls. Private videos, members-only videos, age-gated content, login-only content, deleted Shorts, channel scraping, Shorts search, comments, transcripts, and MP3 conversion are outside this Actor's scope.

This Actor returns direct source media links. It does not upload merged video files to Apify storage. If you need durable file storage, download the returned links soon after the run and store the files in your own system.

### ❓ FAQ

#### 🔑 Do I need YouTube cookies or an API key?

No. The public input does not ask for YouTube cookies, a login, or a YouTube API key.

#### 🎬 Does it download regular YouTube videos?

No. This Actor is built for YouTube Shorts. Some watch URLs are accepted only when they resolve to a Short.

#### 🎧 Can it convert Shorts to MP3?

No. It returns direct download links and metadata for Shorts. MP3 conversion is not part of this Actor.

#### 📁 Does it save files to Apify storage?

No. It returns the best available direct download link and separate stream links when available. Direct links may expire, so use them soon after the run.

#### 📈 Can I run it from code?

Yes. Start the Actor through the Apify API, pass your Shorts URLs in `shortUrls`, and read the default dataset when the run finishes.

### 📝 Changelog

- 0.2: Improved default runs for more reliable first results and faster hosted validation.
- 0.1: Initial release.

### 🆘 Support

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

### 🔗 Other actors

- [TikTok Video Downloader ↗](https://apify.com/maximedupre/tiktok-video-downloader) - Download public TikTok video and audio media with source metadata.
- [Facebook Media Downloader ↗](https://apify.com/maximedupre/facebook-media-downloader) - Download public Facebook videos and reels with direct media links.
- [Pinterest Video Downloader ↗](https://apify.com/maximedupre/pinterest-video-downloader) - Extract public Pinterest video and image URLs from pin targets.
- [Streamable Video Downloader ↗](https://apify.com/maximedupre/streamable-video-downloader) - Export direct MP4 links and metadata from Streamable URLs or IDs.
- [YouTube Channel Statistics Scraper ↗](https://apify.com/maximedupre/youtube-channel-statistics-scraper) - Export public YouTube channel stats without a YouTube API key.

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

# Actor input Schema

## `shortUrls` (type: `array`):

Paste Shorts URLs. You can also add `youtu.be` or watch URLs when they point to Shorts.

## `preferredResolution` (type: `string`):

Choose the highest quality you want. The output shows the quality that was actually available.

## Actor input object example

```json
{
  "shortUrls": [
    {
      "url": "https://www.youtube.com/shorts/8Zk5XzLJSAw"
    },
    {
      "url": "https://www.youtube.com/shorts/H9AVsyDE4Eg"
    },
    {
      "url": "https://www.youtube.com/shorts/TtJY6F4ZFw0"
    },
    {
      "url": "https://www.youtube.com/shorts/gNfVr0WAdCU"
    },
    {
      "url": "https://www.youtube.com/shorts/c6vzrlXzMyc"
    },
    {
      "url": "https://www.youtube.com/shorts/88i0qxUjbko"
    },
    {
      "url": "https://www.youtube.com/shorts/2mejmJXqhbM"
    },
    {
      "url": "https://www.youtube.com/shorts/brbxXjCpcAM"
    }
  ],
  "preferredResolution": "2k"
}
```

# Actor output Schema

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

Open the dataset with direct download links, selected quality, source details, and scrape timestamps for each reachable public Short.

# 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 = {
    "shortUrls": [
        {
            "url": "https://www.youtube.com/shorts/8Zk5XzLJSAw"
        },
        {
            "url": "https://www.youtube.com/shorts/H9AVsyDE4Eg"
        },
        {
            "url": "https://www.youtube.com/shorts/TtJY6F4ZFw0"
        },
        {
            "url": "https://www.youtube.com/shorts/gNfVr0WAdCU"
        },
        {
            "url": "https://www.youtube.com/shorts/c6vzrlXzMyc"
        },
        {
            "url": "https://www.youtube.com/shorts/88i0qxUjbko"
        },
        {
            "url": "https://www.youtube.com/shorts/2mejmJXqhbM"
        },
        {
            "url": "https://www.youtube.com/shorts/brbxXjCpcAM"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/youtube-shorts-downloader").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 = { "shortUrls": [
        { "url": "https://www.youtube.com/shorts/8Zk5XzLJSAw" },
        { "url": "https://www.youtube.com/shorts/H9AVsyDE4Eg" },
        { "url": "https://www.youtube.com/shorts/TtJY6F4ZFw0" },
        { "url": "https://www.youtube.com/shorts/gNfVr0WAdCU" },
        { "url": "https://www.youtube.com/shorts/c6vzrlXzMyc" },
        { "url": "https://www.youtube.com/shorts/88i0qxUjbko" },
        { "url": "https://www.youtube.com/shorts/2mejmJXqhbM" },
        { "url": "https://www.youtube.com/shorts/brbxXjCpcAM" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/youtube-shorts-downloader").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 '{
  "shortUrls": [
    {
      "url": "https://www.youtube.com/shorts/8Zk5XzLJSAw"
    },
    {
      "url": "https://www.youtube.com/shorts/H9AVsyDE4Eg"
    },
    {
      "url": "https://www.youtube.com/shorts/TtJY6F4ZFw0"
    },
    {
      "url": "https://www.youtube.com/shorts/gNfVr0WAdCU"
    },
    {
      "url": "https://www.youtube.com/shorts/c6vzrlXzMyc"
    },
    {
      "url": "https://www.youtube.com/shorts/88i0qxUjbko"
    },
    {
      "url": "https://www.youtube.com/shorts/2mejmJXqhbM"
    },
    {
      "url": "https://www.youtube.com/shorts/brbxXjCpcAM"
    }
  ]
}' |
apify call maximedupre/youtube-shorts-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Shorts Downloader",
        "description": "Download direct links from public YouTube Shorts URLs. Export playable video links, separate video and audio links when available, quality details, thumbnails, duration, channel details, and canonical URLs.",
        "version": "0.2",
        "x-build-id": "oOQCMolvOF2J8ybDG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~youtube-shorts-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-youtube-shorts-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~youtube-shorts-downloader/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-youtube-shorts-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~youtube-shorts-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-youtube-shorts-downloader",
                "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": [
                    "shortUrls"
                ],
                "properties": {
                    "shortUrls": {
                        "title": "YouTube Shorts URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Paste Shorts URLs. You can also add `youtu.be` or watch URLs when they point to Shorts.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "preferredResolution": {
                        "title": "Preferred video quality",
                        "enum": [
                            "8k",
                            "4k",
                            "2k",
                            "1080p",
                            "720p",
                            "480p",
                            "360p"
                        ],
                        "type": "string",
                        "description": "Choose the highest quality you want. The output shows the quality that was actually available.",
                        "default": "2k"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
