# Youtube Playlist Scraper (`api-empire/youtube-playlist-scraper`) Actor

🎥 YouTube Playlist Scraper extracts complete playlist data — video titles, URLs, durations, views, publish dates, thumbnails & descriptions. 📦 Export to CSV/JSON. 🚀 Perfect for content audits, research, archiving, analytics & automation.

- **URL**: https://apify.com/api-empire/youtube-playlist-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Automation, Developer tools, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

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

### 🌟 What does a YouTube Playlist Extractor do?

A YouTube Playlist Extractor 🎬 is a powerful tool that lets you automatically pull video details, links, metadata, transcripts, and structured information from any YouTube playlist. Instead of manually copying each video link, this tool extracts everything instantly—saving hours of tedious work.

Using a YouTube playlist extractor improves SEO, content research, and workflow efficiency by giving you clean, organized data that you can use for competitive analysis, content planning, or video audits. Whether you're using an Apify YouTube Playlist Extractor, a YouTube playlist extractor extension, or an online version, the goal is the same: extract playlist data quickly, accurately, and at scale.

This makes it perfect for marketers, creators, researchers, or anyone who needs fast access to YouTube playlist information. 🚀

* * *

### 📥 What can a YouTube Playlist Extractor extract?

Below is everything the tool can pull from YouTube playlists ⬇️

| Data Type | Description |
| --- | --- |
| Video Title | Extracts all video titles in the playlist |
| Video URL | Full link to each YouTube video |
| Channel Name | The creator associated with each video |
| Channel URL | Direct link to the YouTube channel |
| Video Description | Short or full description depending on settings |
| Publish Date | When each video was uploaded |
| Duration | Length of every playlist video |
| Views Count | Total views for each video |
| Thumbnails | URL of the preview image |
| Playlist Metadata | Name, total videos, author, and more |

Perfect for users wanting to export YouTube playlists to spreadsheets, CSV, or even YouTube playlist to PDF formats.

* * *

#### ⭐ Key Features of YouTube Playlist Extractor

Here’s what makes this YouTube Playlist Extractor tool exceptional:

*   🔗 Bulk Playlist Extraction — Extract hundreds or thousands of playlist videos at once.  
      
    
*   🚀 Fast & Scalable — Designed to handle small to massive playlists effortlessly.  
      
    
*   💾 Multiple Output Formats — Export YouTube playlists to CSV, Excel, JSON, or databases.  
      
    
*   🧠 Smart Metadata Capturing — Pulls complete details including titles, descriptions, thumbnails & stats.  
      
    
*   🎤 Transcript Extraction Option — Works perfectly with YouTube playlist transcript extractor workflows.  
      
    
*   🌐 Runs Online — No installation required; works as an Apify YouTube playlist extractor online.  
      
    
*   📊 SEO & Research Friendly — Excellent for content strategists, digital marketers, and data analysts.  
      
    
*   🔍 Compatible With Channels — Also functions as a YouTube channel extractor or YouTube channel extractor online.  
      
    
*   🔒 Safe & Compliant — Built to follow ethical data usage guidelines.  
      
    

These features make it one of the best YouTube playlist downloader and extractor tools available—whether online, via Chrome extension, or API automation.

* * *

### 🔧 How to Use the YouTube Playlist Extractor

Follow this simple step-by-step guide to extract any YouTube playlist like a pro 🎯

1.  Log in to Apify  
    Create a free account or sign in.  
      
    
2.  Select the Actor  
    Search for “YouTube Playlist Extractor” or Apify YouTube playlist extractor in the Apify Store.  
      
    
3.  Enter Input Data  
    Paste your playlist URL(s) into the startUrls field.  
      
    
4.  Choose Your Options  
      
    

*   Extract timestamps  
      
    
*   Include transcripts  
      
    
*   Include full descriptions  
      
    
*   Choose output format  
      
    

6.  Run the Actor  
    Hit Start and let the extractor collect playlist data automatically.  
      
    
7.  Download Your Results  
    Export as CSV, Excel, JSON, PDF, or import directly into your internal systems.  
      
    

This workflow makes it incredibly simple to export YouTube playlist to CSV, Excel, or any structured format for research or automation.

### 🎯 Use Cases

The YouTube Playlist Extractor tool serves a wide range of users:

#### ✔ Marketers

*   Competitor content research  
      
    
*   SEO keyword extraction  
      
    
*   Video content audit  
      
    

#### ✔ Content Creators

*   Analyze successful playlist structures  
      
    
*   Track content trends  
      
    
*   Export YouTube playlist to spreadsheet for planning  
      
    

#### ✔ Researchers & Educators

*   Collect data for analysis  
      
    
*   Create structured study materials  
      
    
*   Convert YouTube playlists to PDF  
      
    

#### ✔ Developers

*   Integrate playlist data into apps  
      
    
*   Create auto-updating dashboards  
      
    
*   Build automation using Apify API  
      
    

#### ✔ Businesses

*   Monitor brand mentions  
      
    
*   Evaluate industry influencers  
      
    
*   Generate reports from playlist data  
      
    

Whether you need a YouTube playlist extractor extension, downloader, or online version—this tool covers all use cases.

### 💼 Why Choose Us?

Choosing our YouTube Playlist Extractor gives you:

*   🔥 High-Speed Scraping optimized for large playlists  
      
    
*   📊 Enterprise-Grade Data Accuracy  
      
    
*   🌍 Cloud-Based Automation (no installation required)  
      
    
*   👨‍💻 Apify-powered reliability  
      
    
*   🎯 SEO-focused structured data outputs  
      
    
*   🔐 Privacy and compliance standards  
      
    
*   💸 Free tier options available (Apify YouTube playlist extractor free)  
      
    

Our extractor stands out because it’s built for scalability, ideal for professionals who rely on accurate data for content strategy, audits, or research.

* * *

### 📈 How many results can you scrape with the YouTube Playlist Extractor?

One of the biggest advantages of using an Apify-powered YouTube playlist extractor online is its ability to handle massive datasets without slowing down.

You can scrape:

*   ✔ Small playlists (10–50 videos)  
      
    
*   ✔ Medium playlists (100–500 videos)  
      
    
*   ✔ Large playlists (500–5,000 videos)  
      
    
*   ✔ Ultra-large channels & playlist collections  
      
    

Because YouTube playlists can sometimes contain thousands of videos, our YouTube channel extractor and playlist extractor scale seamlessly using distributed cloud execution.

This makes it perfect for:

*   Research institutions collecting large datasets  
      
    
*   SEO agencies performing competitive audits  
      
    
*   Developers building video-based applications  
      
    
*   Creators analyzing historical performance  
      
    

The tool can return tens of thousands of video results depending on your input, making it one of the most powerful and flexible playlist extraction tools available.

* * *

### ⚖️ Is it legal to scrape YouTube playlists?

Scraping YouTube playlists is generally legal when done ethically, meaning:

*   You extract only publicly available information  
      
    
*   You comply with YouTube's Terms of Service  
      
    
*   You avoid bypassing access restrictions  
      
    
*   You use the extracted data responsibly  
      
    
*   You do not republish copyrighted content without permission  
      
    

Most users extract playlist data for analysis, SEO research, automation, or academic purposes, which is typically acceptable.

Our tool is designed to follow safe, compliant practices without revealing or exploiting any hidden operations.

* * *

### 🧩 Input Parameters (JSON Example)
```json
{
  "playlistInputs": [
    "https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw",
    "@apify",
    "web scraping tutorials"
  ],
  "maxVideos": 10,
  "sortOrder": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### 📤 Output Format (JSON Example)

```json
[
  {
    "videoId": "I-beHln9Gus",
    "title": "Cold Email Automation with LangChain, Lemlist & Apify",
    "videoUrl": "https://www.youtube.com/watch?v=I-beHln9Gus",
    "duration": "5:54",
    "viewCount": "5.7K views",
    "channel": {
      "name": "Rabbitmetrics",
      "id": "rabbitmetrics",
      "url": "https://www.youtube.com/@rabbitmetrics"
    },
    "playlistInfo": {
      "playlistId": "PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw",
      "playlistTitle": "Community Tutorials",
      "playlistDescription": "Tutorials and videos featuring Apify and Crawlee...",
      "owner": "Apify",
      "videoCount": 10,
      "totalDuration": "58 minutes"
    },
    "extractedAt": "2025-11-24T02:15:07.216427Z"
  }
]
```

### ❓ FAQ

#### 1. Is the YouTube Playlist Extractor free?

Yes! The Apify YouTube Playlist Extractor free tier allows you to run smaller playlists.

#### 2. Can I export a YouTube playlist to Excel?

Absolutely — export as CSV or XLSX for spreadsheet use.

#### 3. Does this work with private playlists?

No. Only public playlists can be extracted.

#### 4. Can I extract YouTube channel videos?

Yes — it also functions as a YouTube channel extractor.

#### 5. Does it support transcript extraction?

Yes, through the YouTube playlist transcript extractor option.

#### 6. Is there a Chrome extension?

Yes, many use it as the best YouTube playlist downloader Chrome tool.

#### 7. Can I export playlists to PDF?

Yes — convert the extracted data into YouTube playlist to PDF format.

#### 8. Does it work online?

Yes — it's a fully cloud-based YouTube playlist extract online tool.

### ⭐ Conclusion

The YouTube Playlist Extractor is a powerful, fast, and SEO-friendly tool that helps you seamlessly extract playlist data, export it to CSV or Excel, and streamline research or content workflows. Whether for marketing, analysis, or automation, it delivers accurate, scalable, and reliable results—quickly and effortlessly. 🚀

### What are other Youtube scraping tools?

If you want to scrape specific Youtube data, you can use any of the dedicated scrapers below for faster and more targeted results.

| Scraper Name | Scraper Name |
|---|---|
| [Youtube B2b Email Scraper](https://apify.com/api-empire/youtube-b2b-email-scraper) | [YouTube Most Replayed Scraper](https://apify.com/api-empire/youtube-most-replayed-scraper) |
| [Youtube B2b Lead Scraper](https://apify.com/api-empire/youtube-b2b-lead-scraper) | [Youtube Phone Number Scraper](https://apify.com/api-empire/youtube-phone-number-scraper) |
| [Youtube B2b Phone Number Scraper](https://apify.com/api-empire/youtube-b2b-phone-number-scraper) | [Youtube Scraper](https://apify.com/api-empire/youtube-scraper) |
| [Youtube Channel Email Scraper](https://apify.com/api-empire/youtube-channel-email-scraper) | [Youtube Search And Channel Scraper](https://apify.com/api-empire/youtube-search-and-channel-scraper) |
| [Youtube Channel Finder](https://apify.com/api-empire/youtube-channel-finder) | [Youtube Search Scraper](https://apify.com/api-empire/youtube-search-scraper) |
| [Youtube Channel Lead Scraper](https://apify.com/api-empire/youtube-channel-lead-scraper) | [Youtube Shorts Scraper](https://apify.com/api-empire/youtube-shorts-scraper) |
| [Youtube Channel Phone Number Scraper](https://apify.com/api-empire/youtube-channel-phone-number-scraper) | [Youtube Transcript Scraper](https://apify.com/api-empire/youtube-transcript-scraper) |
| [Youtube Channel Scraper](https://apify.com/api-empire/youtube-channel-scraper) | [Youtube Trending Scraper](https://apify.com/api-empire/youtube-trending-scraper) |
| [Youtube Comments Scraper](https://apify.com/api-empire/youtube-comments-scraper) | [Youtube Video Details Scraper](https://apify.com/api-empire/youtube-video-details-scraper) |
| [YouTube Community Posts Scraper](https://apify.com/api-empire/youtube-community-posts-scraper) | [YouTube Video Scraper By Hashtag](https://apify.com/api-empire/youtube-video-scraper-by-hashtag) |
| [Youtube Email Scraper](https://apify.com/api-empire/youtube-email-scraper) | [YouTube Video Subtitles Scraper](https://apify.com/api-empire/youtube-video-subtitles-scraper) |
| [YouTube Lead Scraper](https://apify.com/api-empire/youtube-lead-scraper) | [YouTube Video Summarizer](https://apify.com/api-empire/youtube-video-summarizer) |
| [Youtube Metadata Scraper](https://apify.com/api-empire/youtube-metadata-scraper) |  |

# Actor input Schema

## `playlistInputs` (type: `array`):

🔗 Paste one or more: playlist URLs · @usernames · or search keywords. Bulk input supported.

## `maxVideos` (type: `integer`):

📊 How many videos to scrape per playlist. Use 0 for no limit (all videos).

## `includeVideoDetails` (type: `boolean`):

When on, each row includes extra fields (thumbnail, videoInfo, durationLabel, full channel/playlist, extractedAt).

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

🛡️ Optional. Starts without proxy; auto fallback to datacenter → residential if blocked.

## Actor input object example

```json
{
  "playlistInputs": [
    "https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw"
  ],
  "maxVideos": 10,
  "includeVideoDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "playlistInputs": [
        "https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-empire/youtube-playlist-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 = {
    "playlistInputs": ["https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("api-empire/youtube-playlist-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 '{
  "playlistInputs": [
    "https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call api-empire/youtube-playlist-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Playlist Scraper",
        "description": "🎥 YouTube Playlist Scraper extracts complete playlist data — video titles, URLs, durations, views, publish dates, thumbnails & descriptions. 📦 Export to CSV/JSON. 🚀 Perfect for content audits, research, archiving, analytics & automation.",
        "version": "0.1",
        "x-build-id": "dwDM8A6RqDOgzM2gt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~youtube-playlist-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-youtube-playlist-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/api-empire~youtube-playlist-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-youtube-playlist-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/api-empire~youtube-playlist-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-youtube-playlist-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": [
                    "playlistInputs"
                ],
                "properties": {
                    "playlistInputs": {
                        "title": "📋 Playlist Inputs",
                        "minItems": 1,
                        "type": "array",
                        "description": "🔗 Paste one or more: playlist URLs · @usernames · or search keywords. Bulk input supported.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideos": {
                        "title": "🎯 Max Videos per Playlist",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "📊 How many videos to scrape per playlist. Use 0 for no limit (all videos).",
                        "default": 10
                    },
                    "includeVideoDetails": {
                        "title": "📄 Include video details",
                        "type": "boolean",
                        "description": "When on, each row includes extra fields (thumbnail, videoInfo, durationLabel, full channel/playlist, extractedAt).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy",
                        "type": "object",
                        "description": "🛡️ Optional. Starts without proxy; auto fallback to datacenter → residential if blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```