# Apify Youtube Eng Scraper (`morph_coder/apify-youtube-eng-scraper`) Actor

YouTube views, likes & video metadata from URLs — no API key, proxy fallback included.

- **URL**: https://apify.com/morph\_coder/apify-youtube-eng-scraper.md
- **Developed by:** [Olek Coder](https://apify.com/morph_coder) (community)
- **Categories:** Social media, Videos, Automation
- **Stats:** 3 total users, 2 monthly users, 95.8% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 1,000 video-metrics-successes

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## YouTube Video Engagement Scraper — Views, Likes, Title & Description

**Actor ID:** `morph_coder~youtube-eng-scraper`

Extract YouTube video **engagement metrics** (views, likes, comments), **title**, **description**, **channel info**, and **duration** from video URLs.

**Default:** Innertube scraping — **no API key**. **Optional:** your own [YouTube Data API v3](https://developers.google.com/youtube/v3) key (input or Actor environment) for official API calls — more reliable on large batches, uses your GCP quota.

> This Actor is **not affiliated** with YouTube or Google. Users must comply with [YouTube Terms of Service](https://www.youtube.com/t/terms) and applicable laws.

### Features

- Scrape metrics and metadata from `watch`, `youtu.be`, `shorts`, and `embed` URLs
- No API key by default — Innertube-based extraction
- Optional **BYOK** — YouTube Data API v3 (input `youtubeApiKey` or env `YOUTUBE_API_KEY`)
- **Smart proxy fallback:** direct → Apify datacenter → residential on blocks (optional manual proxy override)
- Optional **channel stats** (`includeChannelStats`) — subscribers, channel views, joined date; deduplicated per channel ID
- Structured dataset output with extension stubs for upcoming features

#### Coming soon

| Feature | Pricing (planned) |
|---------|-------------------|
| Subtitles | Per video minute |
| Audio transcription | Per video minute |
| AI summary | Per video minute |
| Sentiment analysis | Per video minute |

### Input

| Field | Default | Description |
|-------|---------|-------------|
| `videoUrls` | sample watch URL | YouTube video URLs to scrape |
| `youtubeApiKey` | *(empty)* | Optional BYOK key; enables Data API v3 mode (see below) |
| `features.*.enabled` | `false` | Future add-ons (not available yet) |
| `requestDelayMs` | 200–400 | Pause between requests (innertube) or between API batches |
| `includeChannelStats` | `false` | After videos, enrich each row with unique channel stats (subscribers, etc.) |
| `enableProxyPass2` | `false` | Retry failed innertube URLs via Apify proxy (ignored in API mode) |
| `proxyConfiguration` | no proxy | Optional override; ignored in API mode |

#### Channel stats (`includeChannelStats`)

When enabled, the Actor scrapes videos as usual, collects **unique** `channel.id` values from successful rows, fetches channel metadata, then pushes dataset rows with `channel.stats`:

| Field | Description |
|-------|-------------|
| `subscriberCount` | Total subscribers |
| `videoCount` | Public video count |
| `viewCount` | Total channel views |
| `joinedAt` | Join / creation date when available |
| `description`, `country`, `handle`, `title` | From channel About / API |

**Without API key:** innertube (`getChannel` + About tab) — one request per unique channel. **With API key:** batched `channels.list` (up to 50 per call). Default pipeline is unchanged when the flag is `false`.

**Deduplication:** if many videos share the same channel, the Actor fetches that channel **once**, writes the same `channel.stats` on every matching row, and bills the channel add-on **once per unique channel ID** (see [Pricing](#pricing)).

### YouTube Data API mode (optional, BYOK)

If you provide an API key, the Actor uses **`videos.list`** (official API) instead of Innertube. Good when you need stable results and accept Google quota limits.

| How to set the key | Who typically uses it |
|--------------------|------------------------|
| Input **`youtubeApiKey`** (secret field) | Per-run BYOK from Apify Console or API |
| Actor env **`YOUTUBE_API_KEY`** | Apify Console → Actor → **Environment variables** (key not in run input/logs) |

Priority: **input key** overrides environment. The key is **never logged**.

- Up to **50 video IDs per HTTP request**; `requestDelayMs` applies **between batches**, not every video.
- **`enableProxyPass2`** and **`proxyConfiguration`** are **ignored** (API calls go to Google, not YouTube pages).
- Missing videos → `status: unavailable`. Quota / invalid key → `failed` rows and the run stops.
- Success rows include `extra.dataSource: "youtube-data-api-v3"`.
- Enable **YouTube Data API v3** in [Google Cloud Console](https://console.cloud.google.com/) and create an API key; default free quota is ~10,000 units/day (~10,000 single-video lookups).

### Output

One dataset row per input URL.

| Field | Description |
|-------|-------------|
| `url` | Input video URL |
| `videoId` | YouTube video ID |
| `status` | `success`, `unavailable`, or `failed` (see below) |
| `title`, `description` | Video metadata |
| `durationSeconds` | Length in seconds |
| `publishedAt` | ISO date when available |
| `channel` | `{ id, title, url }`; with `includeChannelStats`, also `stats` (see below) |
| `channel.stats` | When `includeChannelStats`: subscribers, video/view counts, `joinedAt`, description, etc. |
| `channel.stats.billable` | `true` if this channel was counted for pay-per-event `channel-stats-success` |
| `metrics` | `{ viewCount, likeCount, commentCount }` |
| `extra` | Tags, category, thumbnails, `isLive`, `isShort`, etc. |
| `extensions` | Stubs: `subtitles`, `transcription`, `aiSummary`, `sentiment` (all `null` for now) |
| `billable` | `true` when `status` is `success` (pay-per-event `video-metrics-success`) |

#### Result statuses

| Status | Meaning | `billable` (video) | Channel add-on |
|--------|---------|----------------------|----------------|
| `success` | Video metrics fetched | yes (`video-metrics-success`) | only if `includeChannelStats` and channel fetch succeeded |
| `unavailable` | Deleted, private, region-blocked, etc. | no | no |
| `failed` | Rate limit, empty response, network — may retry with proxy | no | no |

`unavailable` and `failed` rows are never charged. Channel stats are an **add-on** on top of successful video rows, not a replacement.

#### Example (success)

```json
{
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "videoId": "dQw4w9WgXcQ",
  "status": "success",
  "title": "Rick Astley - Never Gonna Give You Up (Official Video)",
  "description": "...",
  "durationSeconds": 213,
  "publishedAt": "2009-10-25T06:57:33.000Z",
  "channel": {
    "id": "UCuAXFkgsw1L7xaCfnd5JJOw",
    "title": "Rick Astley",
    "url": "https://www.youtube.com/channel/UCuAXFkgsw1L7xaCfnd5JJOw"
  },
  "metrics": {
    "viewCount": 1700000000,
    "likeCount": 18000000,
    "commentCount": 2400000
  },
  "extensions": {
    "subtitles": null,
    "transcription": null,
    "aiSummary": null,
    "sentiment": null
  },
  "billable": true,
  "fetchedAt": "2026-05-24T12:00:00.000Z"
}
````

### URL validation

Each input string is checked before scraping:

| Case | Result |
|------|--------|
| Valid YouTube video URL or 11-character video ID | Scraped |
| Not a YouTube domain (e.g. TikTok, Vimeo) | `failed` — *URL is not a YouTube link* |
| YouTube channel, playlist-only, homepage | `failed` — *no video ID found* |
| Malformed / empty | `failed` — *Invalid URL format* |

Supported: `youtube.com/watch`, `youtu.be/…`, `/shorts/`, `/embed/`, `/live/`, raw video ID.

### Proxy: anti-bot vs country (geo)

Two separate things:

**1. Type of IP (main goal of auto-fallback)** — whether you look like a normal user or a datacenter bot.

| Level | Purpose |
|-------|---------|
| Direct | Cheapest; works for many videos |
| Datacenter | When YouTube blocks the run IP (429/403) |
| Residential | Stronger “real user” signal when datacenter is blocked |

Auto-escalation changes **IP reputation**, not your language settings.

**2. Proxy country (geo)** — which country YouTube thinks the client is in.

- Matters for **region-blocked** videos and sometimes localized metadata.
- For most public videos, country is **optional**; default Apify proxy country is usually enough.
- Does **not** replace residential vs datacenter — you can have a US residential or US datacenter IP; they behave differently for anti-bot.

To set country manually, enable Apify Proxy in input and choose **Proxy country** in the Console UI (or `apifyProxyCountry` in API input, e.g. `"US"`).

**Default: direct only (fast, no Apify proxy cost)**

All URLs are fetched **without proxy**. Retryable errors (`Empty response`, rate limit) → `status: failed` immediately.

**Optional: `enableProxyPass2: true`**

1. **Pass 1** — direct (same as default).
2. **Pass 2** — retryable failures via **datacenter → residential** (slower, **paid proxy traffic**; may recover ~50% of empty responses on large batches).

**Custom proxy:** `proxyConfiguration.useApifyProxy: true` uses your proxy on every URL (single-pass; ignores `enableProxyPass2`).

### Pricing

On Apify Store, this Actor uses **pay-per-event** billing. **Rates are shown on the Store listing and in the run invoice** — they are configured in Apify Console → Monetization, not in this README.

#### Events

| Event | When it fires |
|-------|----------------|
| `video-metrics-success` | One count per dataset row with `status: success` (video engagement data delivered). |
| `channel-stats-success` | One count per **unique** `channel.id` successfully enriched when `includeChannelStats` is `true`. Not charged if the channel fetch failed (`channel.stats.errorMessage` set). |
| `video-subtitles-minute` | Planned — per video minute (future). |

**Two layers:** successful videos are always billed via `video-metrics-success`. Channel stats are a **separate add-on** only when you enable `includeChannelStats` and the channel profile fetch succeeds.

#### Deduplication (channel add-on)

The Actor does **not** charge per duplicate channel on multiple video rows:

1. Collect unique channel IDs from successful videos.
2. Fetch each channel once.
3. Copy `channel.stats` onto every row that shares that channel.
4. Emit **one** `channel-stats-success` event per unique channel billed.

| Scenario | `video-metrics-success` | `channel-stats-success` |
|----------|-------------------------|-------------------------|
| `success`, `includeChannelStats` off | 1 per success row | 0 |
| 3 success videos, 3 different channels, stats OK | 3 | 3 |
| 10 success videos, same channel, stats OK | 10 | **1** |
| Video `success`, channel fetch failed | 1 | 0 |
| `failed` or `unavailable` | 0 | 0 |

#### Transparency

- **Store / run cost tab:** Apify lists each event and unit count before and after the run.
- **Dataset audit:** row `billable` = video event; `channel.stats.billable` = channel event applied to that row’s channel (same value on all rows sharing one channel ID).

#### Maintainer setup (Console)

- **`apify-default-dataset-item`** → **$0** (do not bill dataset rows separately from custom events).
- Register **`video-metrics-success`** and **`channel-stats-success`** as custom events with prices on the platform.

### Large batches (100+ URLs)

| Setting | Recommendation |
|---------|------------------|
| **Memory** | **1024 MB** minimum (API: `"memory": 1024`). 512 MB can OOM on long runs with youtubei.js. |
| **Run timeout** | **at least 3600 s** (API: `"timeout": 5400`). Rule of thumb: `URLs × 8 seconds`. |
| **requestDelayMs** | Default **400** for 50+ URLs; use **0–300** for speed. `1200` adds ~8 min per 400 URLs but rarely fixes slowness — proxy retries dominate. |
| **Resume** | KV checkpoint skips completed `videoId`s; pass 2 queue is restored after migration. |
| **enableProxyPass2** | Default **false** (fast/cheap). `true` if you need more successes and accept ~2× run time + proxy cost. |
| **Expected `unavailable`** | `This video is unavailable` → `status: unavailable` (not `failed`, not billed) |

### Run via API

```http
POST https://api.apify.com/v2/acts/morph_coder~youtube-eng-scraper/runs?token=YOUR_TOKEN
Content-Type: application/json

{
  "videoUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
  "includeChannelStats": true
}
```

### Maintainer docs

See [DEVELOPMENT.md](DEVELOPMENT.md), [CHECKLIST.md](CHECKLIST.md), and [REFERENCE.md](REFERENCE.md).

# Actor input Schema

## `videoUrls` (type: `array`):

YouTube video URLs only (youtube.com, youtu.be — watch, shorts, embed). Non-YouTube or channel/playlist links return a failed row with an error message.

## `includeChannelStats` (type: `boolean`):

After videos are scraped, fetch subscribers, video count, channel views, joined date, and description for each unique channel. Uses innertube by default; uses YouTube Data API when an API key is set.

## `enableProxyPass2` (type: `boolean`):

If true, retry rate-limited URLs via Apify datacenter → residential proxy (slower, paid proxy traffic). Default false: direct only.

## `requestDelayMs` (type: `integer`):

Pause between requests to reduce YouTube rate limits. Default: 200 (≤10 URLs), 300 (11–50), 400 (50+).

## `youtubeApiKey` (type: `string`):

Your Google Cloud YouTube Data API v3 key (BYOK). Uses official API instead of innertube. Or set YOUTUBE\_API\_KEY in Actor environment variables. Never logged.

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

Optional. useApifyProxy: true = proxy on every URL. Ignored in Data API mode.

## `features` (type: `object`):

Future add-ons with per-minute pricing. Leave all disabled for metrics-only scraping.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "includeChannelStats": false,
  "enableProxyPass2": false,
  "requestDelayMs": 500,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset items from this run.

# 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 = {
    "videoUrls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("morph_coder/apify-youtube-eng-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 = {
    "videoUrls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("morph_coder/apify-youtube-eng-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 '{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call morph_coder/apify-youtube-eng-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apify Youtube Eng Scraper",
        "description": "YouTube views, likes & video metadata from URLs — no API key, proxy fallback included.",
        "version": "0.0",
        "x-build-id": "6qLCaNSwtP2fHpClZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/morph_coder~apify-youtube-eng-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-morph_coder-apify-youtube-eng-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/morph_coder~apify-youtube-eng-scraper/runs": {
            "post": {
                "operationId": "runs-sync-morph_coder-apify-youtube-eng-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/morph_coder~apify-youtube-eng-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-morph_coder-apify-youtube-eng-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": [
                    "videoUrls"
                ],
                "properties": {
                    "videoUrls": {
                        "title": "Video URLs",
                        "type": "array",
                        "description": "YouTube video URLs only (youtube.com, youtu.be — watch, shorts, embed). Non-YouTube or channel/playlist links return a failed row with an error message.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeChannelStats": {
                        "title": "Include channel stats",
                        "type": "boolean",
                        "description": "After videos are scraped, fetch subscribers, video count, channel views, joined date, and description for each unique channel. Uses innertube by default; uses YouTube Data API when an API key is set.",
                        "default": false
                    },
                    "enableProxyPass2": {
                        "title": "Retry with Apify proxy (pass 2)",
                        "type": "boolean",
                        "description": "If true, retry rate-limited URLs via Apify datacenter → residential proxy (slower, paid proxy traffic). Default false: direct only.",
                        "default": false
                    },
                    "requestDelayMs": {
                        "title": "Delay between videos (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Pause between requests to reduce YouTube rate limits. Default: 200 (≤10 URLs), 300 (11–50), 400 (50+).",
                        "default": 500
                    },
                    "youtubeApiKey": {
                        "title": "YouTube Data API key (optional)",
                        "type": "string",
                        "description": "Your Google Cloud YouTube Data API v3 key (BYOK). Uses official API instead of innertube. Or set YOUTUBE_API_KEY in Actor environment variables. Never logged."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. useApifyProxy: true = proxy on every URL. Ignored in Data API mode."
                    },
                    "features": {
                        "title": "Optional features",
                        "type": "object",
                        "description": "Future add-ons with per-minute pricing. Leave all disabled for metrics-only scraping.",
                        "properties": {
                            "subtitles": {
                                "title": "Subtitles",
                                "type": "boolean",
                                "description": "Download video subtitles (coming soon). Not available in this version.",
                                "default": false
                            },
                            "transcription": {
                                "title": "Audio transcription",
                                "type": "boolean",
                                "description": "Transcribe the video audio track (coming soon). Not available in this version.",
                                "default": false
                            },
                            "aiSummary": {
                                "title": "AI summary",
                                "type": "boolean",
                                "description": "Generate an AI summary of the video (coming soon). Not available in this version.",
                                "default": false
                            },
                            "sentiment": {
                                "title": "Sentiment analysis",
                                "type": "boolean",
                                "description": "Analyze sentiment of video content (coming soon). Not available in this version.",
                                "default": false
                            }
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```