# YouTube Region Restriction Checker (`maximedupre/youtube-region-restriction-checker`) Actor

Check where YouTube videos can be viewed. Export allowed countries, blocked countries, counts, target-country availability, canonical video IDs, titles, channels, and thumbnails without YouTube login, cookies, or API keys.

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

## Pricing

$2.65 / 1,000 checked videos

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

### 🌍 Check YouTube region restrictions

Use **YouTube Region Restriction Checker** to check where public [YouTube](https://www.youtube.com/) videos can be viewed by country. Add YouTube watch URLs, Shorts URLs, youtu.be links, embed URLs, or raw video IDs, and the Actor returns country availability, blocked countries, allowed countries, and video metadata in a clean dataset.

It is built for quick regional availability checks without a YouTube login, cookies, or API key. Use it when you need to audit licensing windows, verify campaign markets, check whether a video is globally available, or export YouTube video region availability for your own workflow.

### ✅ What this Actor does

- Checks public YouTube videos for region restriction data.
- Exports allowed countries, blocked countries, ISO country codes, and counts.
- Compares each video against your target countries, such as `US`, `GB`, `DE`, or `Japan`.
- Includes canonical video IDs, video URLs, titles, channels, duration, thumbnails, and playability status when available.
- Deduplicates repeated video targets by canonical YouTube video ID during the run.
- Runs through Apify infrastructure and can be used from the Apify API, schedules, integrations, or dataset exports.

### 🎯 Common use cases

- Check whether music videos, trailers, sports clips, educational videos, or branded content are blocked in important markets.
- Build a YouTube video availability report for media buying, localization, rights management, or creator operations.
- Monitor a list of videos before launching regional campaigns.
- Verify target-country availability before embedding or sharing YouTube links with an audience.
- Export structured YouTube region restriction data for spreadsheets, BI tools, or internal QA checks.

### 🚀 How to run

1. Paste one or more YouTube video targets into **Video targets**.
2. Add optional **Target countries** as ISO country codes or country names.
3. Start the Actor.
4. Open the dataset and export results as JSON, CSV, Excel, XML, or through the Apify API.

### 🧾 Input

The Actor accepts public YouTube video targets. You can mix formats in the same run:

```text
https://www.youtube.com/watch?v=dQw4w9WgXcQ
https://youtu.be/9bZkp7q19f0
https://www.youtube.com/shorts/aqz-KE-bpKQ
dQw4w9WgXcQ
````

Target countries are optional. Use them when you want a quick market-by-market status in addition to the full allowed and blocked country lists.

```json
{
  "videoTargets": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://youtu.be/9bZkp7q19f0"
  ],
  "targetCountries": ["US", "GB", "Germany", "Japan"]
}
```

### 📦 Output

Each checked video is saved as one dataset item. The output includes:

- `videoId` and `videoUrl`
- `title`, `channelId`, `channelTitle`, `durationSeconds`, and `thumbnailUrl`
- `playabilityStatus` and `playabilityReason`
- `allowedCountries` and `blockedCountries`
- `allowedCountryCodes` and `blockedCountryCodes`
- `totalAllowedCountries` and `totalBlockedCountries`
- `isGloballyAvailable` and `regionRestrictionStatus`
- `targetCountries` with each requested country's availability
- `checkedAt`

Example item:

```json
{
  "status": "checked",
  "playabilityStatus": "OK",
  "videoId": "dQw4w9WgXcQ",
  "videoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "title": "Example video title",
  "channelTitle": "Example channel",
  "allowedCountries": ["Canada", "Germany", "United Kingdom", "United States"],
  "blockedCountries": ["France", "Japan"],
  "allowedCountryCodes": ["CA", "DE", "GB", "US"],
  "blockedCountryCodes": ["FR", "JP"],
  "totalAllowedCountries": 4,
  "totalBlockedCountries": 2,
  "isGloballyAvailable": false,
  "regionRestrictionStatus": "restricted",
  "targetCountries": [
    {
      "input": "US",
      "countryCode": "US",
      "countryName": "United States",
      "availability": "allowed"
    },
    {
      "input": "Japan",
      "countryCode": "JP",
      "countryName": "Japan",
      "availability": "blocked"
    }
  ],
  "checkedAt": "2026-06-14T12:00:00.000Z"
}
```

### 💳 Pricing

This Actor uses pay-per-result pricing. You are charged only for videos that are successfully checked and emitted to the dataset.

- Event: `checked-video`
- Price: `$0.00265` per checked video
- Approximate cost: `$2.65` per 1,000 checked videos

### ⚠️ Limits and notes

- The Actor checks public YouTube pages and does not use private accounts, cookies, or the official YouTube API.
- Private, removed, age-gated, unavailable, or bot-check-protected videos may not emit a dataset row if YouTube does not expose usable region availability data.
- YouTube may report a video as playable while still omitting explicit country lists. In that case, the Actor records the availability fields that YouTube exposes.
- Region availability can change over time when uploaders, rights holders, or YouTube update restrictions.

### ❓ FAQ

#### Can I check raw YouTube video IDs?

Yes. You can enter raw 11-character YouTube video IDs, full watch URLs, Shorts URLs, youtu.be links, or embed URLs.

#### Do I need a YouTube API key?

No. The Actor does not require a YouTube API key, login, cookies, or OAuth setup.

#### What happens if I provide duplicate videos?

The run deduplicates targets by canonical YouTube video ID, so the dataset contains one checked result per unique video.

#### Can I check only a few countries?

Yes. Add target countries to get a compact allowed, blocked, or unknown status for the markets you care about. The Actor still returns the full allowed and blocked country data when YouTube exposes it.

#### Does it download videos?

No. This Actor checks region availability and video metadata only. It does not download video files.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

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

### 🔗 Other actors

- [YouTube Trending Videos Scraper ↗](https://apify.com/maximedupre/youtube-trending-videos-scraper) - Track trending YouTube videos by region and category.
- [YouTube Channel Statistics Scraper ↗](https://apify.com/maximedupre/youtube-channel-statistics-scraper) - Export public YouTube channel statistics for reporting.
- [YouTube Channel Search Scraper ↗](https://apify.com/maximedupre/youtube-channel-search-scraper) - Find public YouTube channels from search keywords.
- [YouTube Channel Scraper ↗](https://apify.com/maximedupre/youtube-channel-scraper) - Collect public YouTube channel profiles and recent video data.
- [TikTok Transcript Scraper ↗](https://apify.com/maximedupre/tiktok-transcript-scraper) - Extract public TikTok transcript text for video analysis.

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

# Actor input Schema

## `videoTargets` (type: `array`):

Paste YouTube watch URLs, Shorts URLs, youtu.be links, embed URLs, or video IDs.

## `targetCountries` (type: `array`):

Add country names or ISO country codes to get focused availability for your markets.

## Actor input object example

```json
{
  "videoTargets": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.youtube.com/watch?v=FZ4lg_VF1Bk",
    "https://www.youtube.com/watch?v=J75GuCvhLAE",
    "https://www.youtube.com/watch?v=pRpeEdMmmQ0",
    "https://www.youtube.com/watch?v=fLexgOxsZu0",
    "https://www.youtube.com/watch?v=jNQXAC9IVRw",
    "https://www.youtube.com/watch?v=M7lc1UVf-VE",
    "https://www.youtube.com/watch?v=VPRjCeoBqrI",
    "https://www.youtube.com/watch?v=hTWKbfoikeg",
    "https://www.youtube.com/watch?v=YVkUvmDQ3HY",
    "https://www.youtube.com/watch?v=8UVNT4wvIGY",
    "https://www.youtube.com/watch?v=Zi_XLOBDo_Y",
    "https://www.youtube.com/watch?v=RgKAFK5djSk",
    "https://www.youtube.com/watch?v=nfs8NYg7yQM",
    "https://www.youtube.com/watch?v=tVj0ZTS4WF4",
    "https://www.youtube.com/watch?v=nfWlot6h_JM",
    "https://www.youtube.com/watch?v=J5qWnG5RQTk",
    "https://www.youtube.com/watch?v=QJO3ROT-A4E",
    "https://www.youtube.com/watch?v=fRh_vgS2dFE",
    "https://www.youtube.com/watch?v=t4H_Zoh7G5A",
    "https://www.youtube.com/watch?v=C-u5WLJ9Yk4",
    "https://www.youtube.com/watch?v=eVTXPUF4Oz4",
    "https://www.youtube.com/watch?v=HyHNuVaZJ-k",
    "https://www.youtube.com/watch?v=6Ejga4kJUts",
    "https://www.youtube.com/watch?v=CD-E-LDc384"
  ],
  "targetCountries": [
    "US",
    "GB",
    "DE",
    "JP"
  ]
}
```

# Actor output Schema

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

Open the dataset with one accepted YouTube region availability result per checked video.

# 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 = {
    "videoTargets": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.youtube.com/watch?v=FZ4lg_VF1Bk",
        "https://www.youtube.com/watch?v=J75GuCvhLAE",
        "https://www.youtube.com/watch?v=pRpeEdMmmQ0",
        "https://www.youtube.com/watch?v=fLexgOxsZu0",
        "https://www.youtube.com/watch?v=jNQXAC9IVRw",
        "https://www.youtube.com/watch?v=M7lc1UVf-VE",
        "https://www.youtube.com/watch?v=VPRjCeoBqrI",
        "https://www.youtube.com/watch?v=hTWKbfoikeg",
        "https://www.youtube.com/watch?v=YVkUvmDQ3HY",
        "https://www.youtube.com/watch?v=8UVNT4wvIGY",
        "https://www.youtube.com/watch?v=Zi_XLOBDo_Y",
        "https://www.youtube.com/watch?v=RgKAFK5djSk",
        "https://www.youtube.com/watch?v=nfs8NYg7yQM",
        "https://www.youtube.com/watch?v=tVj0ZTS4WF4",
        "https://www.youtube.com/watch?v=nfWlot6h_JM",
        "https://www.youtube.com/watch?v=J5qWnG5RQTk",
        "https://www.youtube.com/watch?v=QJO3ROT-A4E",
        "https://www.youtube.com/watch?v=fRh_vgS2dFE",
        "https://www.youtube.com/watch?v=t4H_Zoh7G5A",
        "https://www.youtube.com/watch?v=C-u5WLJ9Yk4",
        "https://www.youtube.com/watch?v=eVTXPUF4Oz4",
        "https://www.youtube.com/watch?v=HyHNuVaZJ-k",
        "https://www.youtube.com/watch?v=6Ejga4kJUts",
        "https://www.youtube.com/watch?v=CD-E-LDc384"
    ],
    "targetCountries": [
        "US",
        "GB",
        "DE",
        "JP"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/youtube-region-restriction-checker").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 = {
    "videoTargets": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.youtube.com/watch?v=FZ4lg_VF1Bk",
        "https://www.youtube.com/watch?v=J75GuCvhLAE",
        "https://www.youtube.com/watch?v=pRpeEdMmmQ0",
        "https://www.youtube.com/watch?v=fLexgOxsZu0",
        "https://www.youtube.com/watch?v=jNQXAC9IVRw",
        "https://www.youtube.com/watch?v=M7lc1UVf-VE",
        "https://www.youtube.com/watch?v=VPRjCeoBqrI",
        "https://www.youtube.com/watch?v=hTWKbfoikeg",
        "https://www.youtube.com/watch?v=YVkUvmDQ3HY",
        "https://www.youtube.com/watch?v=8UVNT4wvIGY",
        "https://www.youtube.com/watch?v=Zi_XLOBDo_Y",
        "https://www.youtube.com/watch?v=RgKAFK5djSk",
        "https://www.youtube.com/watch?v=nfs8NYg7yQM",
        "https://www.youtube.com/watch?v=tVj0ZTS4WF4",
        "https://www.youtube.com/watch?v=nfWlot6h_JM",
        "https://www.youtube.com/watch?v=J5qWnG5RQTk",
        "https://www.youtube.com/watch?v=QJO3ROT-A4E",
        "https://www.youtube.com/watch?v=fRh_vgS2dFE",
        "https://www.youtube.com/watch?v=t4H_Zoh7G5A",
        "https://www.youtube.com/watch?v=C-u5WLJ9Yk4",
        "https://www.youtube.com/watch?v=eVTXPUF4Oz4",
        "https://www.youtube.com/watch?v=HyHNuVaZJ-k",
        "https://www.youtube.com/watch?v=6Ejga4kJUts",
        "https://www.youtube.com/watch?v=CD-E-LDc384",
    ],
    "targetCountries": [
        "US",
        "GB",
        "DE",
        "JP",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/youtube-region-restriction-checker").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 '{
  "videoTargets": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.youtube.com/watch?v=FZ4lg_VF1Bk",
    "https://www.youtube.com/watch?v=J75GuCvhLAE",
    "https://www.youtube.com/watch?v=pRpeEdMmmQ0",
    "https://www.youtube.com/watch?v=fLexgOxsZu0",
    "https://www.youtube.com/watch?v=jNQXAC9IVRw",
    "https://www.youtube.com/watch?v=M7lc1UVf-VE",
    "https://www.youtube.com/watch?v=VPRjCeoBqrI",
    "https://www.youtube.com/watch?v=hTWKbfoikeg",
    "https://www.youtube.com/watch?v=YVkUvmDQ3HY",
    "https://www.youtube.com/watch?v=8UVNT4wvIGY",
    "https://www.youtube.com/watch?v=Zi_XLOBDo_Y",
    "https://www.youtube.com/watch?v=RgKAFK5djSk",
    "https://www.youtube.com/watch?v=nfs8NYg7yQM",
    "https://www.youtube.com/watch?v=tVj0ZTS4WF4",
    "https://www.youtube.com/watch?v=nfWlot6h_JM",
    "https://www.youtube.com/watch?v=J5qWnG5RQTk",
    "https://www.youtube.com/watch?v=QJO3ROT-A4E",
    "https://www.youtube.com/watch?v=fRh_vgS2dFE",
    "https://www.youtube.com/watch?v=t4H_Zoh7G5A",
    "https://www.youtube.com/watch?v=C-u5WLJ9Yk4",
    "https://www.youtube.com/watch?v=eVTXPUF4Oz4",
    "https://www.youtube.com/watch?v=HyHNuVaZJ-k",
    "https://www.youtube.com/watch?v=6Ejga4kJUts",
    "https://www.youtube.com/watch?v=CD-E-LDc384"
  ],
  "targetCountries": [
    "US",
    "GB",
    "DE",
    "JP"
  ]
}' |
apify call maximedupre/youtube-region-restriction-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Region Restriction Checker",
        "description": "Check where YouTube videos can be viewed. Export allowed countries, blocked countries, counts, target-country availability, canonical video IDs, titles, channels, and thumbnails without YouTube login, cookies, or API keys.",
        "version": "0.1",
        "x-build-id": "JljDJJzztigfVBuUL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~youtube-region-restriction-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-youtube-region-restriction-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~youtube-region-restriction-checker/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-youtube-region-restriction-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~youtube-region-restriction-checker/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-youtube-region-restriction-checker",
                "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": [
                    "videoTargets"
                ],
                "properties": {
                    "videoTargets": {
                        "title": "YouTube videos",
                        "maxItems": 1000,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Paste YouTube watch URLs, Shorts URLs, youtu.be links, embed URLs, or video IDs.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "targetCountries": {
                        "title": "Target countries",
                        "maxItems": 250,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Add country names or ISO country codes to get focused availability for your markets.",
                        "items": {
                            "type": "string",
                            "minLength": 2
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```