# YouTube Script AI Analyzer - Hooks, Pacing & CTA Teardown (`dominvo/youtube-script-ai-analyzer`) Actor

Analyze YouTube video scripts in bulk for competitor research. Input video URLs or a channel URL (auto-pulls top-viewed videos). Returns structured JSON per video: hooks, timestamped scene blocks, CTAs, pacing, tone, SEO keywords, and attention-rated winner/weak moments. Charged per analyzed video.

- **URL**: https://apify.com/dominvo/youtube-script-ai-analyzer.md
- **Developed by:** [Domin Vo](https://apify.com/dominvo) (community)
- **Categories:** AI, SEO tools, Videos
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $150.00 / 1,000 video analyzeds

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

### What does YouTube Script AI Analyzer do?

**The YouTube script analyzer for competitor research. Paste a channel — or specific video URLs — and get a structured script teardown for every video:** hook, pacing, CTAs, tone, title alignment, and attention-rated winning moments, all in one sortable JSON row per video.

Point it at a **channel URL** and it automatically finds and analyzes that channel's **top-viewed videos** — no hunting for individual links. Or paste up to 50 specific URLs to compare a curated set head-to-head.

Under the hood it fetches public captions and metadata from [YouTube](https://www.youtube.com), segments each script into timestamped blocks, classifies every block with a fixed schema, and converts a public attention signal into coarse `winner` / `neutral` / `weak` labels. For batches of 3+ videos it also emits a cross-video pattern summary at no extra charge.

Run it from Apify Console, schedule it, or call it via API. Download results as JSON, CSV, or Excel.

### Why use YouTube Script AI Analyzer?

- **Tear down a whole channel in one run.** Paste a channel URL; the Actor ranks its top-viewed recent videos and analyzes each one. Perfect for sizing up a competitor fast.
- **Compare competitor scripts without reading every transcript.** Each run returns timestamped blocks, hook type, CTA placements, SEO keywords, and pacing stats for every video.
- **Evidence-backed labels.** Attention-rated `winner` and `weak` moments come from a public signal, not guesswork.
- **Stable JSON output.** Fixed schema across every run — easy to sort, filter, and pipe into your own tools or automations.
- **Batch pattern detection.** Analyze 3–50 videos and get a cross-video summary: repeated winning tactics, weak moves, common scene sequences, and pacing medians.
- **Pay only for results.** Failed, private, or caption-less videos are not charged.

### Who is this for?

| Persona | Job to be done |
|---|---|
| Content agencies | Compare competitor scripts for a client niche without reading every transcript |
| Faceless-channel operators | Find repeatable script moves from proven videos backed by structured evidence |
| Creator-tool builders | Feed stable script intelligence (JSON) into a workflow or product |

Raw transcript buyers are out of scope — there are 100+ cheaper transcript Actors for that.

### How to use YouTube Script AI Analyzer

1. Open the Actor on [Apify Console](https://console.apify.com/actors/dominvo/youtube-script-ai-analyzer).
2. Either paste public YouTube video URLs into the **Video URLs** field, **or** paste a **Channel URL** (e.g. `https://www.youtube.com/@HalfasInteresting`) and set **Top N** to analyze that channel's top-viewed recent uploads. You can do both — up to 50 videos total.
3. Leave **Include Batch Pattern Summary** checked if you want cross-video patterns (free, requires 3+ usable videos).
4. Click **Start** and wait for the run to complete (typically 30–90 seconds per video; channel runs also spend a little time ranking).
5. Open the **Dataset** tab to browse, sort, or download results.

### Input

Analyze specific videos:

```json
{
    "video_urls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.youtube.com/watch?v=9bZkp7q19f0",
        "https://www.youtube.com/watch?v=JGwWNGJdvx8"
    ],
    "include_batch_summary": true,
    "language": "en"
}
````

Or analyze a channel's top-viewed recent videos:

```json
{
    "channel_url": "https://www.youtube.com/@HalfasInteresting",
    "top_n": 20,
    "include_batch_summary": true,
    "language": "en"
}
```

| Field | Type | Default | Notes |
|---|---|---|---|
| `video_urls` | `string[]` | optional | Public YouTube URLs. Provide these, `channel_url`, or both — up to 50 videos total |
| `channel_url` | `string` | optional | A channel URL. Expands to its top-`top_n` most-viewed **recent** uploads (not all-time) |
| `top_n` | `integer` | `20` | 1–50. How many top-viewed recent videos to pull from `channel_url`. Each is charged |
| `include_batch_summary` | `boolean` | `true` | Emits a batch summary row when 3+ videos succeed. Included, not charged. |
| `language` | `string` | `"en"` | V1: English captions only |

Provide at least one of `video_urls` or `channel_url`. A channel run analyzing 20 videos costs about **$3.00** (20 × $0.15); the ranking step is not charged.

### Output

You can download the dataset in JSON, CSV, HTML, or Excel from the Dataset tab.

#### video\_teardown row (attention rating applied)

```json
{
    "record_type": "video_teardown",
    "video_id": "9bZkp7q19f0",
    "video_url": "https://www.youtube.com/watch?v=9bZkp7q19f0",
    "title": "PSY - GANGNAM STYLE(강남스타일) M/V",
    "duration_sec": 253,
    "attention_rating_status": "applied",
    "analysis_notes": "Strong hook with visual contrast. CTA cluster at 70% mark.",
    "hook_type": "visual_contrast",
    "hook_strength": 0.82,
    "cta_placements": [176.0, 231.0],
    "title_alignment": "Title matches hook framing and first 10 seconds.",
    "seo_keywords": ["gangnam style", "kpop", "viral music video"],
    "block_count": 14,
    "pattern_interrupts_total": 9,
    "interrupts_per_minute": 2.13,
    "blocks": [
        {
            "id": 0,
            "t0": 0.0,
            "t1": 12.4,
            "text": "Oppa Gangnam style...",
            "scene_type": "hook",
            "pulls": ["pattern_interrupt", "high_energy_open"],
            "tone_markers": ["playful", "high_energy"],
            "pattern_interrupts": 1,
            "attention_rating": "winner"
        }
    ]
}
```

#### video\_teardown row (attention rating unavailable)

```json
{
    "record_type": "video_teardown",
    "video_id": "dQw4w9WgXcQ",
    "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "title": "Rick Astley - Never Gonna Give You Up",
    "duration_sec": 212,
    "attention_rating_status": "unavailable",
    "analysis_notes": "Attention rating unavailable — this video's public engagement signal isn't established yet (this can happen with newer or lower-traffic videos). The full script teardown above is complete; only the per-block winner/weak attention labels are affected.",
    "hook_type": "music_intro",
    "hook_strength": null,
    "cta_placements": [],
    "title_alignment": "Title matches song content.",
    "seo_keywords": ["rick astley", "never gonna give you up", "80s pop"],
    "block_count": 11,
    "pattern_interrupts_total": 4,
    "interrupts_per_minute": 1.13,
    "blocks": [
        {
            "id": 0,
            "t0": 0.0,
            "t1": 18.0,
            "text": "We're no strangers to love...",
            "scene_type": "hook",
            "pulls": ["familiar_reference"],
            "tone_markers": ["sincere", "nostalgic"],
            "pattern_interrupts": 0,
            "attention_rating": "unavailable"
        }
    ]
}
```

#### batch\_pattern\_summary row

```json
{
    "record_type": "batch_pattern_summary",
    "source_video_ids": ["9bZkp7q19f0", "dQw4w9WgXcQ", "JGwWNGJdvx8"],
    "repeated_winning_pulls": ["pattern_interrupt", "open_loop"],
    "repeated_weak_moves": ["delayed_hook", "generic_cta"],
    "common_scene_sequences": ["hook -> frame -> story", "exposition -> list_item -> cta"],
    "pacing_summary": {
        "median_block_count": 12.0,
        "median_interrupts_per_minute": 1.8
    },
    "attention_rating_coverage": {
        "applied": 2,
        "unavailable": 1
    }
}
```

### Field Reference

#### video\_teardown fields

| Field | Type | Description |
|---|---|---|
| `record_type` | string | Always `"video_teardown"` |
| `video_id` | string | YouTube video ID |
| `video_url` | string | Original input URL |
| `title` | string | Video title |
| `duration_sec` | integer | Video duration in seconds |
| `attention_rating_status` | string | `"applied"` or `"unavailable"` |
| `analysis_notes` | string | Brief plain-English summary of key observations |
| `hook_type` | string | Identified hook strategy (e.g. `"open_loop"`, `"visual_contrast"`) |
| `hook_strength` | float or null | Rating-backed hook score 0–1; null when rating is unavailable |
| `cta_placements` | float\[] | Timestamps (seconds) where CTAs appear |
| `title_alignment` | string | How well the title aligns with the hook and first block |
| `seo_keywords` | string\[] | Keywords identified in the script |
| `block_count` | integer | Total number of script blocks |
| `pattern_interrupts_total` | integer | Total rhetorical/structural shifts across all blocks |
| `interrupts_per_minute` | float | Pattern interrupts per minute (comparable across videos) |
| `blocks` | object\[] | Timestamped script blocks (see below) |

#### blocks\[] item fields

| Field | Type | Description |
|---|---|---|
| `id` | integer | Block index (0-based) |
| `t0` | float | Start time in seconds |
| `t1` | float | End time in seconds |
| `text` | string | Block transcript text |
| `scene_type` | string | `hook`, `frame`, `story`, `exposition`, `evidence`, `list_item`, `turn`, `payoff`, `cta`, or `outro` |
| `pulls` | string\[] | Attention tactics used (e.g. `"open_loop"`, `"social_proof"`) |
| `tone_markers` | string\[] | Short tone labels (e.g. `"urgent"`, `"conversational"`) |
| `pattern_interrupts` | integer | Structural or rhetorical shifts within this block |
| `attention_rating` | string | `"winner"`, `"neutral"`, `"weak"`, or `"unavailable"` |

#### batch\_pattern\_summary fields

| Field | Type | Description |
|---|---|---|
| `record_type` | string | Always `"batch_pattern_summary"` |
| `source_video_ids` | string\[] | IDs of videos included in this summary |
| `repeated_winning_pulls` | string\[] | Tactics seen in winner-rated blocks across multiple videos |
| `repeated_weak_moves` | string\[] | Patterns seen in weak-rated blocks across multiple videos |
| `common_scene_sequences` | string\[] | Repeated block-order patterns |
| `pacing_summary.median_block_count` | float | Median block count across analyzed videos |
| `pacing_summary.median_interrupts_per_minute` | float | Median interrupts per minute |
| `attention_rating_coverage.applied` | integer | Videos where the attention rating was successfully applied |
| `attention_rating_coverage.unavailable` | integer | Videos where the attention rating was unavailable |

### Pricing

**$0.15 per successfully analyzed video** (launch test price). The `video_analyzed` event is charged once per `video_teardown` row emitted.

| Item | Cost |
|---|---|
| Actor start | $0.00005 (platform fee) |
| Each analyzed video | $0.15 |
| Batch pattern summary | Included — $0 extra |
| Failed, private, or caption-less videos | $0 — not charged |

**Example:** Analyze 10 competitor videos → `$0.00005 + (10 × $0.15)` = **$1.50005**

Pricing is subject to change after the cloud cost spike confirms real per-video LLM and compute costs. Subscribe to Actor updates for changes.

### How to run via API

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run_input = {
    "video_urls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.youtube.com/watch?v=9bZkp7q19f0",
    ],
    "include_batch_summary": True,
    "language": "en",
}

run = client.actor("dominvo/youtube-script-ai-analyzer").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### Tips

- **Start with 3–5 videos** to verify the output structure before running a full batch.
- **Use `include_batch_summary: true`** (the default) any time you submit 3+ URLs — the cross-video summary is the most actionable output for competitor research.
- **Filter by `record_type`** in your downstream tool to separate teardown rows from the summary row.
- **Sort by `interrupts_per_minute`** to quickly find the fastest-paced videos in a batch.
- Videos without English captions are skipped and not charged.

### FAQ

**Is this affiliated with YouTube or Google?**
No. This Actor reads publicly available captions and metadata — the same data accessible in any browser. It is not affiliated with, endorsed by, or a product of YouTube or Google.

**English captions only?**
Yes, V1 supports English captions only. Other languages may be added after demand is confirmed.

**What is the "attention rating"?**
The Actor converts a publicly available per-segment signal into coarse block-level labels: `winner`, `neutral`, or `weak`. This is not YouTube's private creator audience-retention curve and does not represent any internal YouTube analytics data. When the signal is unavailable for a video, all blocks get `attention_rating: "unavailable"` and `attention_rating_status: "unavailable"`.

**What counts as a "failed" video?**
Private videos, deleted videos, age-gated videos, and videos without English captions are all skipped and not charged. You'll see a log message for each skip.

**Can I export to CSV or Excel?**
Yes. Use the Dataset tab's export options or the API with `?format=csv` or `?format=xlsx`.

**Need help or a custom solution?**
Open an issue on the [Issues tab](https://console.apify.com/actors/dominvo/youtube-script-ai-analyzer/issues) or contact the actor author.

# Actor input Schema

## `video_urls` (type: `array`):

List of public YouTube video URLs to analyze. Provide these, a Channel URL, or both — up to 50 videos total per run.

## `channel_url` (type: `string`):

Optional. A YouTube channel URL (e.g. https://www.youtube.com/@HalfasInteresting). The Actor analyzes the channel's most-viewed recent uploads — see Top N. Note: this ranks the most-viewed among recent uploads, not the channel's all-time most-viewed.

## `top_n` (type: `integer`):

When a Channel URL is given, how many of its top-viewed recent videos to analyze. Each analyzed video is charged separately.

## `include_batch_summary` (type: `boolean`):

When true, emits one batch\_pattern\_summary row after processing 3 or more usable videos. Included at no extra charge.

## `language` (type: `string`):

Language code for captions. V1 supports English only.

## Actor input object example

```json
{
  "video_urls": [
    "https://www.youtube.com/watch?v=TScO0fsGdds"
  ],
  "channel_url": "https://www.youtube.com/@HalfasInteresting",
  "top_n": 5,
  "include_batch_summary": true,
  "language": "en"
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "video_urls": [
        "https://www.youtube.com/watch?v=TScO0fsGdds"
    ],
    "channel_url": "https://www.youtube.com/@HalfasInteresting",
    "top_n": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("dominvo/youtube-script-ai-analyzer").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 = {
    "video_urls": ["https://www.youtube.com/watch?v=TScO0fsGdds"],
    "channel_url": "https://www.youtube.com/@HalfasInteresting",
    "top_n": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("dominvo/youtube-script-ai-analyzer").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 '{
  "video_urls": [
    "https://www.youtube.com/watch?v=TScO0fsGdds"
  ],
  "channel_url": "https://www.youtube.com/@HalfasInteresting",
  "top_n": 5
}' |
apify call dominvo/youtube-script-ai-analyzer --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Script AI Analyzer - Hooks, Pacing & CTA Teardown",
        "description": "Analyze YouTube video scripts in bulk for competitor research. Input video URLs or a channel URL (auto-pulls top-viewed videos). Returns structured JSON per video: hooks, timestamped scene blocks, CTAs, pacing, tone, SEO keywords, and attention-rated winner/weak moments. Charged per analyzed video.",
        "version": "0.0",
        "x-build-id": "XpfRzTKpNdAObcgtz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dominvo~youtube-script-ai-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dominvo-youtube-script-ai-analyzer",
                "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/dominvo~youtube-script-ai-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-dominvo-youtube-script-ai-analyzer",
                "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/dominvo~youtube-script-ai-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-dominvo-youtube-script-ai-analyzer",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "video_urls": {
                        "title": "Video URLs",
                        "type": "array",
                        "description": "List of public YouTube video URLs to analyze. Provide these, a Channel URL, or both — up to 50 videos total per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "channel_url": {
                        "title": "Channel URL",
                        "type": "string",
                        "description": "Optional. A YouTube channel URL (e.g. https://www.youtube.com/@HalfasInteresting). The Actor analyzes the channel's most-viewed recent uploads — see Top N. Note: this ranks the most-viewed among recent uploads, not the channel's all-time most-viewed."
                    },
                    "top_n": {
                        "title": "Top N (channel)",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "When a Channel URL is given, how many of its top-viewed recent videos to analyze. Each analyzed video is charged separately.",
                        "default": 20
                    },
                    "include_batch_summary": {
                        "title": "Include Batch Pattern Summary",
                        "type": "boolean",
                        "description": "When true, emits one batch_pattern_summary row after processing 3 or more usable videos. Included at no extra charge.",
                        "default": true
                    },
                    "language": {
                        "title": "Caption Language",
                        "enum": [
                            "en"
                        ],
                        "type": "string",
                        "description": "Language code for captions. V1 supports English only.",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```