# 🔥 YouTube Scraper – Transcripts, Dislikes & Heatmaps (`yumitori/youtube-intel`) Actor

YouTube scraper with full transcripts, the most-replayed heatmap, likes AND dislikes, channel profiles with social links, and bulk channel/search scraping — plus chain modes: viral-DNA (heatmap x transcript), niche-map (the algorithm's related-video graph), and gap-finder (demand vs supply).

- **URL**: https://apify.com/yumitori/youtube-intel.md
- **Developed by:** [Yakugusa Yumitori](https://apify.com/yumitori) (community)
- **Categories:** Social media, Videos, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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 Scraper

Scrape any YouTube video, channel, search, or hashtag and get the data other scrapers leave on the table — full transcripts, real dislike counts, the most-replayed heatmap as timestamped points, comments with the creator-hearted signal, Content-ID music and songwriters, sponsor segments, and chapters.

Other YouTube scrapers force you to feed one URL at a time and hand back title-and-views. This one **auto-detects every input** — paste a video, a channel `@handle`, a search term, or a `#hashtag` and it figures out each one — pulls a channel's top videos from a single handle, and ships the deep layer most tools call "impossible." No login, no API key, no setup.

---

### Quick start

```json
{
  "inputs": ["@MrBeast"],
  "maxVideos": 30,
  "includeComments": true
}
````

One handle → the channel's 30 highest-viewed videos, each with transcript, heatmap, dislikes, and top comments — sorted and ready in under a minute.

***

### What you get on every video

**Transcript & chapters** — `transcript` (full text), `transcriptLangs` (every available language), `chapters` (in-video timestamped sections).

**Engagement** — `viewCount`, `ryd.likes`, `ryd.dislikes`, `ryd.rating` — real dislike counts, which most scrapers say isn't possible.

**Most-replayed** — `mostReplayed` and `heatmap`: the exact seconds viewers rewatch, as sortable timestamped points.

**Comments** — `comments[]` with text, author, `likeCount`, `replyCount`, verified / creator flags, and `creatorHearted` (which comments the creator personally amplified), plus `commentCount` and `creatorHeartedCount`.

**Music & sponsors** — `music` (Content-ID song, artist, album, songwriters), `sponsorSegments` + `sponsorDensityPct`, `dearrow` (community title / thumbnail corrections).

**Suppression & SEO** — `isCrawlable` (shadowban flag), geo-availability, family-safe state, `isMonetized`, and the creator's private `keywords`.

Plus `thumbnail`, `url`, `author`, `channelId`, `lengthSeconds`, and `publishedText`.

***

### What you control

| Knob | Default | What it does |
|---|---|---|
| `inputs` | — | video URLs, channel `@handles`, search terms, or `#hashtags` — mixed, auto-detected |
| `maxVideos` | `30` | how many videos per channel / search / hashtag (highest-viewed first) |
| `includeTranscript` | `true` | full multi-language transcripts |
| `includeComments` | `false` | top comments + the creator-hearted signal |
| `mode` | `auto` | leave on auto; or force `video` · `channel-bulk` · `search` · `hashtag` · `viral-dna` · `niche-map` · `gap-finder` |
| Proxy | Residential | needed for transcripts on small / low-view videos (see below) |

**Advanced:** `enrichTop` (how many of the listed videos get the full deep-dive), `enrichBy` (`hottest` / `latest`), `commentsLimit`, `bulkTranscripts` (transcribe every listed video), `tab` (videos / shorts / streams), `includeNeighbors`, and the chain-mode knobs (`momentsPerVideo`, `crawlDepth`, `country`).

***

### Use it for

**Audience research.** Pull a video's comments plus the creator-hearted signal — see what fans care about and which comments the creator amplified.

```json
{ "inputs": ["https://youtube.com/watch?v=dQw4w9WgXcQ"], "includeComments": true, "commentsLimit": 200 }
```

**Competitor sweep.** Feed a channel handle, get its top videos with views, real dislikes, and sponsor density in one run.

```json
{ "inputs": ["@veritasium"], "maxVideos": 50 }
```

**Viral teardown.** Cross the most-replayed heatmap with the transcript to read the exact words said at the rewatch peak — across a whole channel.

```json
{ "inputs": ["@mkbhd"], "mode": "viral-dna" }
```

**Content-gap finding.** Compare search demand against supply to surface underserved topics.

```json
{ "inputs": ["home workout"], "mode": "gap-finder" }
```

**AI / RAG pipelines.** Sweep a niche of videos, export transcripts + comments, feed an LLM for summaries, scripts, or sentiment.

***

### Output

Lands in the default dataset — export as JSON, CSV, Excel, or JSONL. Two pre-built views ship with it:

- **Overview** — thumbnail, title, views, dislikes, transcript, comment count
- **💬 Comments** — one row per comment (commenter, text, likes, creator-hearted) for clean export

#### Sample row

A real row from `dQw4w9WgXcQ` — Rick Astley's "Never Gonna Give You Up": 1.78B views, 512K real dislikes, a 100-point rewatch heatmap, and a transcript in five languages.

```json
{
  "type": "video",
  "videoId": "dQw4w9WgXcQ",
  "url": "https://youtu.be/dQw4w9WgXcQ",
  "thumbnail": "https://i.ytimg.com/vi/dQw4w9WgXcQ/hqdefault.jpg",
  "title": "Rick Astley - Never Gonna Give You Up (Official Video)",
  "author": "Rick Astley",
  "channelId": "UCuAXFkgsw1L7xaCfnd5JJOw",
  "viewCount": 1780516646,
  "lengthSeconds": 213,
  "isCrawlable": true,
  "isMonetized": false,
  "keywords": ["rick astley", "never gonna give you up", "official video"],
  "transcript": "We're no strangers to love, you know the rules and so do I...",
  "transcriptLangs": ["en", "de-DE", "ja", "pt-BR", "es-419"],
  "chapters": [{ "timestamp": "0:00", "title": "Intro" }],
  "mostReplayed": [{ "timeSec": 43, "intensity": 1.0 }, { "timeSec": 86, "intensity": 0.71 }],
  "ryd": { "likes": 19143569, "dislikes": 512180, "rating": 4.9 },
  "music": { "song": "Never Gonna Give You Up", "artist": "Rick Astley", "album": "Whenever You Need Somebody" },
  "sponsorSegments": [],
  "sponsorDensityPct": 0,
  "commentCount": 50,
  "creatorHeartedCount": 1,
  "comments": [
    { "author": "@YouTube", "likeCount": 251000, "replyCount": 961, "creatorHearted": true,
      "text": "can confirm: he never gave us up" }
  ],
  "enriched": true
}
```

***

### Speed, proxies & limits

| Run shape | Time |
|---|---|
| 1 video, full deep-dive | 2–4s |
| 1 channel, 30 videos (top 5 deep-dived) | 15–30s |
| 1 channel, 30 videos, transcribe all | ~1–2 min |
| Search / hashtag, 50 results enriched | ~1–3 min |

**Why transcripts need the Residential proxy.** YouTube gates small / low-view videos on shared datacenter IPs — blanking the transcript and metadata. A residential IP behaves like a home connection, so nothing gets gated (that's why it's the default). Popular / big-channel videos come through fine on **No proxy** — switch to save cost.

**Why a video might be missing a heatmap.** YouTube only generates the most-replayed graph once a video has enough watch data; brand-new or low-view videos won't have one yet, and the row says so.

***

Built and maintained by \[Yakugusa Yumitori]. Custom data work and "can you scrape X?" challenges → <logic.deploy@pm.me>.

> ⚠️ **Unofficial.** This actor is not affiliated with, endorsed by, or sponsored by YouTube or Google LLC. "YouTube" is a trademark of Google LLC, used here for descriptive purposes only.

# Actor input Schema

## `mode` (type: `string`):

Leave on Auto — it figures out each input for you (video URL → that video · @handle → the channel's top videos · search term → results · #tag → hashtag). Only change it to force a mode or run a chain-insight mode.

## `inputs` (type: `array`):

Paste any mix — one per line: video URLs, channel @handles or URLs, search terms, or #hashtags. It auto-detects each one.

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

How many videos to return when the input is a channel, search, or hashtag — highest-viewed first. (A single video URL always returns just that one video.)

## `includeTranscript` (type: `boolean`):

Full multi-language transcripts. ⚠️ Needs the Residential proxy (the default, below) to work on EVERY video — small / low-view videos are gated without it.

## `includeComments` (type: `boolean`):

Top comments with like / reply counts, verified & creator flags, and the ★ creator-hearted signal (which comments the creator personally amplified).

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

IMPORTANT for transcripts: YouTube gates less-popular / low-view videos on shared datacenter IPs, blanking the transcript. A RESIDENTIAL proxy behaves like a home IP so nothing gets gated — that's why it's the default. Only scraping popular/big-channel videos? Switch to No proxy to save cost.

## `enrichTop` (type: `integer`):

For channel/search/hashtag: how many of the returned videos get the FULL deep-dive (transcript, heatmap, comments). The rest get title/views/channel only. 0 = list only (cheapest).

## `enrichBy` (type: `string`):

For channel/search/hashtag: pick which videos get the full deep-dive.

## `bulkTranscripts` (type: `boolean`):

Add a transcript to every returned video, not just the deep-dived ones (cheap; needs Residential proxy).

## `includeNeighbors` (type: `boolean`):

Video mode: add the ~20 videos YouTube recommends next.

## `commentsLimit` (type: `integer`):

How many top comments to pull when Include comments is on.

## `tab` (type: `string`):

For channel modes: which catalog — long-form Videos, Shorts, or past Streams.

## `momentsPerVideo` (type: `integer`):

viral-dna: how many most-replayed moments to extract per video.

## `crawlDepth` (type: `integer`):

niche-map: hops through the related-video graph (2 is plenty; 3 explodes).

## `crawlWidth` (type: `integer`):

niche-map: neighbors followed per node.

## `country` (type: `string`):

gap-finder: gl code for search demand.

## `countries` (type: `array`):

demand: gl codes to compare demand across.

## `maxQueries` (type: `integer`):

gap-finder: autocomplete suggestions to check supply for.

## Actor input object example

```json
{
  "mode": "auto",
  "inputs": [
    "@MrBeast"
  ],
  "maxVideos": 30,
  "includeTranscript": true,
  "includeComments": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "enrichTop": 5,
  "enrichBy": "hottest",
  "bulkTranscripts": false,
  "includeNeighbors": true,
  "commentsLimit": 50,
  "tab": "videos",
  "momentsPerVideo": 2,
  "crawlDepth": 2,
  "crawlWidth": 8,
  "country": "US",
  "countries": [
    "US",
    "GB",
    "DE",
    "JP",
    "BR"
  ],
  "maxQueries": 12
}
```

# 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 = {
    "inputs": [
        "@MrBeast"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("yumitori/youtube-intel").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 = {
    "inputs": ["@MrBeast"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("yumitori/youtube-intel").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 '{
  "inputs": [
    "@MrBeast"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call yumitori/youtube-intel --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🔥 YouTube Scraper – Transcripts, Dislikes & Heatmaps",
        "description": "YouTube scraper with full transcripts, the most-replayed heatmap, likes AND dislikes, channel profiles with social links, and bulk channel/search scraping — plus chain modes: viral-DNA (heatmap x transcript), niche-map (the algorithm's related-video graph), and gap-finder (demand vs supply).",
        "version": "0.1",
        "x-build-id": "l0bpoZXILVPi5EqIa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/yumitori~youtube-intel/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-yumitori-youtube-intel",
                "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/yumitori~youtube-intel/runs": {
            "post": {
                "operationId": "runs-sync-yumitori-youtube-intel",
                "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/yumitori~youtube-intel/run-sync": {
            "post": {
                "operationId": "run-sync-yumitori-youtube-intel",
                "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": [
                    "inputs"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "auto",
                            "video",
                            "channel",
                            "channel-bulk",
                            "search",
                            "hashtag",
                            "viral-dna",
                            "niche-map",
                            "gap-finder",
                            "demand"
                        ],
                        "type": "string",
                        "description": "Leave on Auto — it figures out each input for you (video URL → that video · @handle → the channel's top videos · search term → results · #tag → hashtag). Only change it to force a mode or run a chain-insight mode.",
                        "default": "auto"
                    },
                    "inputs": {
                        "title": "What to scrape",
                        "maxItems": 200,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Paste any mix — one per line: video URLs, channel @handles or URLs, search terms, or #hashtags. It auto-detects each one.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideos": {
                        "title": "Max videos (per channel / search / hashtag)",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many videos to return when the input is a channel, search, or hashtag — highest-viewed first. (A single video URL always returns just that one video.)",
                        "default": 30
                    },
                    "includeTranscript": {
                        "title": "Include transcripts",
                        "type": "boolean",
                        "description": "Full multi-language transcripts. ⚠️ Needs the Residential proxy (the default, below) to work on EVERY video — small / low-view videos are gated without it.",
                        "default": true
                    },
                    "includeComments": {
                        "title": "Include comments",
                        "type": "boolean",
                        "description": "Top comments with like / reply counts, verified & creator flags, and the ★ creator-hearted signal (which comments the creator personally amplified).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy — keep RESIDENTIAL on for transcripts",
                        "type": "object",
                        "description": "IMPORTANT for transcripts: YouTube gates less-popular / low-view videos on shared datacenter IPs, blanking the transcript. A RESIDENTIAL proxy behaves like a home IP so nothing gets gated — that's why it's the default. Only scraping popular/big-channel videos? Switch to No proxy to save cost."
                    },
                    "enrichTop": {
                        "title": "How many videos to deep-dive",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "For channel/search/hashtag: how many of the returned videos get the FULL deep-dive (transcript, heatmap, comments). The rest get title/views/channel only. 0 = list only (cheapest).",
                        "default": 5
                    },
                    "enrichBy": {
                        "title": "Deep-dive which videos",
                        "enum": [
                            "hottest",
                            "latest"
                        ],
                        "type": "string",
                        "description": "For channel/search/hashtag: pick which videos get the full deep-dive.",
                        "default": "hottest"
                    },
                    "bulkTranscripts": {
                        "title": "Transcript on ALL listed videos",
                        "type": "boolean",
                        "description": "Add a transcript to every returned video, not just the deep-dived ones (cheap; needs Residential proxy).",
                        "default": false
                    },
                    "includeNeighbors": {
                        "title": "Include related videos",
                        "type": "boolean",
                        "description": "Video mode: add the ~20 videos YouTube recommends next.",
                        "default": true
                    },
                    "commentsLimit": {
                        "title": "Max comments per video",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many top comments to pull when Include comments is on.",
                        "default": 50
                    },
                    "tab": {
                        "title": "Channel tab",
                        "enum": [
                            "videos",
                            "shorts",
                            "streams"
                        ],
                        "type": "string",
                        "description": "For channel modes: which catalog — long-form Videos, Shorts, or past Streams.",
                        "default": "videos"
                    },
                    "momentsPerVideo": {
                        "title": "Moments per video (viral-dna)",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "viral-dna: how many most-replayed moments to extract per video.",
                        "default": 2
                    },
                    "crawlDepth": {
                        "title": "Crawl depth (niche-map)",
                        "minimum": 1,
                        "maximum": 3,
                        "type": "integer",
                        "description": "niche-map: hops through the related-video graph (2 is plenty; 3 explodes).",
                        "default": 2
                    },
                    "crawlWidth": {
                        "title": "Crawl width (niche-map)",
                        "minimum": 2,
                        "maximum": 20,
                        "type": "integer",
                        "description": "niche-map: neighbors followed per node.",
                        "default": 8
                    },
                    "country": {
                        "title": "Country (gap-finder)",
                        "type": "string",
                        "description": "gap-finder: gl code for search demand.",
                        "default": "US"
                    },
                    "countries": {
                        "title": "Countries (demand)",
                        "type": "array",
                        "description": "demand: gl codes to compare demand across.",
                        "default": [
                            "US",
                            "GB",
                            "DE",
                            "JP",
                            "BR"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxQueries": {
                        "title": "Max queries (gap-finder)",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "gap-finder: autocomplete suggestions to check supply for.",
                        "default": 12
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
