# VK Video Search Scraper (`automation-lab/vk-video-search-scraper`) Actor

🎬 Search public VK Video by keyword and export ranked video titles, creators, durations, quality, views, publication details, thumbnails, and stable IDs.

- **URL**: https://apify.com/automation-lab/vk-video-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 77.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## VK Video Search Scraper

Search public VK Video results by keyword and export ranked, structured video metadata without a VK account.

Use the Actor to monitor topics, discover creators, compare visible engagement, build research datasets, or archive public search results over time.

- 🔎 Search one or many keywords
- 🎬 Export canonical video and creator URLs
- 📊 Normalize view counts and durations
- 🕒 Preserve rank, publication text, and scrape time
- 🛡️ Handle VK Video's anonymous browser verification automatically

### What does VK Video Search Scraper do?

VK Video Search Scraper opens the public search experience at `vkvideo.ru`, collects unique video cards, and saves one clean dataset row per video.

Every row is tied to the original query and rank. That makes repeated scheduled runs useful for tracking which videos appear, move, or gain visible views.

The Actor deliberately ignores playlist blocks. Its default dataset contains one consistent entity type: videos.

### Why use this VK Video scraper?

Copying VK Video search results manually is slow and hard to compare over time.

This Actor provides:

- **Structured exports** instead of copied page text
- **Batch searches** for multiple brands, people, or topics
- **Stable IDs** for deduplication across runs
- **Source text and normalized numbers** for auditability
- **Apify automation** through schedules, API calls, webhooks, and integrations

### Who is it for?

#### Social-listening teams

Monitor brand names, products, campaigns, public figures, or emerging topics on VK Video.

#### Content researchers

Discover relevant public videos and creators, then sort results by rank, view count, or duration.

#### Agencies

Repeat the same client keyword set on a schedule and deliver CSV, Excel, JSON, or dashboard-ready data.

#### Media archivists

Capture public discovery metadata and timestamps for later comparison. The Actor does not download video media.

#### Trend analysts

Compare search visibility and visible engagement across keywords, categories, or time periods.

### What VK Video data can you extract?

| Field | Description |
|---|---|
| `query` | Keyword represented by the search page |
| `rank` | One-based position in the collected results |
| `videoId` | Stable VK owner/video compound ID |
| `ownerId` | Numeric owner or community ID |
| `videoUrl` | Canonical public VK Video URL |
| `title` | Video title displayed in search |
| `creatorName` | Public creator or channel name |
| `creatorUrl` | Public VK Video creator URL |
| `duration` | Display duration such as `12:34` |
| `durationSeconds` | Machine-readable duration |
| `quality` | Visible badge such as `FHD` or `4K` |
| `views` | Normalized integer view count |
| `viewsText` | Original localized view text |
| `publishedText` | Relative source text such as `2 года назад` |
| `thumbnailUrl` | Search-card thumbnail URL |
| `searchUrl` | Public search URL used |
| `scrapedAt` | UTC collection timestamp |

Optional fields are omitted when VK Video does not display them on a result card.

### How to scrape VK Video search results

1. Open the Actor input page.
2. Add one or more search keywords.
3. Set a small maximum for your first run.
4. Leave direct access enabled unless your network requires a proxy.
5. Click **Start**.
6. Preview the dataset.
7. Export it or connect an integration.

A first run with one keyword and 10 videos normally finishes well within the default timeout.

### Input: search keywords

Use `queries` for normal keyword searches.

```json
{
  "queries": ["mountain bike", "electric vehicle"],
  "maxResultsPerQuery": 20
}
````

Each query receives an independent rank sequence starting at 1.

### Input: VK Video search URLs

Use `searchUrls` when a workflow already stores public VKVideo search links.

```json
{
  "searchUrls": [
    { "url": "https://vkvideo.ru/?q=space%20documentary" }
  ],
  "maxResultsPerQuery": 10
}
```

The URL must use `vkvideo.ru` and include a non-empty `q` parameter.

### Input limits and retries

`maxResultsPerQuery` accepts 1–200 videos per keyword. Start with 10–20 and increase only when your workflow needs deeper scrolling.

`maxRetries` controls fresh attempts after a transient navigation or verification failure. The default is 2; the maximum is 4.

A run accepts at most 20 combined queries and search URLs. Split larger monitoring lists into scheduled batches.

### Proxy configuration

Direct access is the economical default and automatically handles VK Video's anonymous **Continue** verification page.

If a region or network persistently fails, enable Apify Proxy in the input. Residential proxy bandwidth costs substantially more, so test with a small result limit first.

No VK username, password, cookie, or API token is required.

### Output example

```json
{
  "query": "mountain bike",
  "rank": 1,
  "videoId": "-205153628_456239044",
  "ownerId": "-205153628",
  "videoUrl": "https://vkvideo.ru/video-205153628_456239044",
  "title": "Coolaney Mountain Bike Trails. Sligo. Ireland.",
  "creatorName": "LEXIN LIVE",
  "creatorUrl": "https://vkvideo.ru/@lexin_live",
  "duration": "46:00",
  "durationSeconds": 2760,
  "quality": "4K",
  "views": 9,
  "viewsText": "9 просмотров",
  "publishedText": "29 дней назад",
  "searchUrl": "https://vkvideo.ru/?q=mountain%20bike",
  "scrapedAt": "2026-07-15T05:10:35.827Z"
}
```

### How much does it cost to scrape VK Video?

The Actor uses pay-per-event pricing. A **$0.005 Start** event covers browser setup, followed by one charge per saved video.

| Apify tier | Price per video | 1,000 videos |
|---|---:|---:|
| Free | $0.0020872 | $2.09 |
| Bronze | $0.0018149 | $1.81 |
| Silver | $0.0014157 | $1.42 |
| Gold | $0.001089 | $1.09 |
| Platinum | $0.00072598 | $0.73 |
| Diamond | $0.00050818 | $0.51 |

A representative five-video run finished in about 10 seconds. Use a low `maxResultsPerQuery` to estimate a larger workflow; the run page shows charges as they accrue.

### Scheduling a VK Video monitor

Create an Apify schedule with a fixed query list and run it daily or weekly.

For change tracking:

1. Keep `videoId`, `query`, and `rank` in every snapshot.
2. Store each run's dataset or merge it into a warehouse.
3. Compare new IDs with the previous snapshot.
4. Track rank and `views` changes for existing IDs.

This pattern works well for brand monitoring and campaign research.

### Export formats

Apify datasets support:

- JSON
- CSV
- Excel
- XML
- RSS
- JSONL

Use field selection and unfolding options in the dataset API when preparing a downstream import.

### Integrations

#### Google Sheets

Send a scheduled dataset to a sheet used by researchers or account teams.

#### Webhooks

Trigger an automation after a run succeeds, then fetch the dataset through its API URL.

#### Make and Zapier

Create alerts when a new `videoId` appears for a monitored query.

#### Data warehouses

Load JSON or CSV into BigQuery, Snowflake, PostgreSQL, or an object-storage pipeline.

#### Slack or email

Filter newly discovered videos in your automation layer and send a compact digest.

### API usage

#### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/vk-video-search-scraper').call({
  queries: ['electric vehicle'],
  maxResultsPerQuery: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python API example

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/vk-video-search-scraper').call(run_input={
    'queries': ['electric vehicle'],
    'maxResultsPerQuery': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~vk-video-search-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["electric vehicle"],"maxResultsPerQuery":20}'
```

Fetch items from the `defaultDatasetId` returned by the finished run.

### Use with Apify MCP

Connect AI clients to `https://mcp.apify.com/?tools=automation-lab/vk-video-search-scraper`.

#### Claude Code

```bash
claude mcp add --transport http apify https://mcp.apify.com/?tools=automation-lab/vk-video-search-scraper
```

#### Claude Desktop

Add the HTTP server in **Settings → Developer → Edit Config**.

#### Cursor

Open **Settings → MCP** and add the same server URL.

#### VS Code

Add an MCP server to your workspace or user MCP configuration.

Use this `mcpServers` JSON for Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify-vk-video": {
      "url": "https://mcp.apify.com/?tools=automation-lab/vk-video-search-scraper"
    }
  }
}
```

Example prompts:

- “Search VK Video for `electric vehicle` and summarize the top 10 creators.”
- “Collect 20 videos for these three brand keywords and group them by creator.”
- “Compare the IDs from today's dataset with yesterday's snapshot.”

### Data quality and normalization

The Actor preserves source-localized text while also creating machine-readable values.

For example, `29,1 тыс просмотров` is retained in `viewsText` and normalized to `29100` in `views`.

Relative publication text is not converted into a guessed exact timestamp. That avoids false precision when VK Video displays only “2 years ago.”

### Reliability and anti-bot behavior

VK Video can show an anonymous browser-verification page after repeated requests. The Actor completes its normal **Continue** flow automatically, uses isolated browser attempts, and fails clearly rather than returning a misleading empty dataset.

Searches run sequentially to reduce pressure on the source. Fonts, media playback, and analytics traffic are blocked because they are unnecessary for metadata extraction.

### Limitations

- Only publicly visible search-card metadata is collected.
- Private, deleted, age-restricted, or login-only videos are unavailable.
- Direct video media is not downloaded.
- Likes, comments, full descriptions, and player manifests are not enriched in v1.
- VK may vary result ranking by time, locale, or network.
- A field can be absent when the source card does not display it.

### Legality: is it legal to scrape VK Video?

Public web data can still be subject to laws, contractual terms, copyright, privacy obligations, and database rights.

Use the Actor only for lawful purposes. Collect the minimum data needed, avoid personal-data misuse, respect applicable source terms, and consult counsel for regulated or high-risk use cases.

The Actor does not bypass authentication or access private content.

### Troubleshooting: no videos were saved

Try these steps:

1. Confirm that each keyword is non-empty.
2. Open the search URL manually to verify that public results exist.
3. Reduce the number of queries to one.
4. Keep `maxRetries` at 2.
5. Enable Apify Proxy only if direct access repeatedly fails.

The Actor throws an error when every query fails so an automation will not treat blocked pages as valid empty results.

### Troubleshooting: some fields are missing

VK Video does not show every field on every card. Quality badges, view counts, publication text, or thumbnails may be absent for some results.

The dataset omits unavailable optional values rather than inserting misleading defaults.

### Tips for better VK Video research

- Use precise multi-word phrases for narrower results.
- Run broad and exact brand variants separately.
- Keep query spelling consistent across scheduled snapshots.
- Deduplicate globally by `videoId`, not by title.
- Use `rank` only within the same query and run.
- Preserve `scrapedAt` when loading records into a warehouse.

### Related scrapers

Combine this Actor with [VK Posts Scraper](https://apify.com/automation-lab/vk-posts-scraper) when a project needs both wall-post and video-search discovery.

Browse other social-media automation tools from [automation-lab](https://apify.com/automation-lab).

### FAQ

#### Does it require a VK account?

No. It targets the public anonymous VK Video search surface.

#### Can I search multiple keywords?

Yes. Add up to 20 combined keywords and search URLs per run.

#### Does it download videos?

No. It exports discovery metadata and public URLs, not media files.

#### Can I schedule it?

Yes. Use Apify schedules and webhooks for recurring monitoring.

#### Why preserve Russian source text?

It provides an auditable representation of what VK Video displayed, while normalized numeric fields support analysis.

#### Are playlist rows included?

No. v1 intentionally emits only videos so the default dataset has one stable schema.

#### Can results change between runs?

Yes. Search rank and available metadata may change as VK Video updates its index and recommendation systems.

### Support

For a reproducible report, include the run URL, sanitized input, affected query, and expected behavior. Never post private credentials in a support request.

# Actor input Schema

## `queries` (type: `array`):

Keywords to search on VK Video. Each keyword is processed independently.

## `searchUrls` (type: `array`):

Public vkvideo.ru search URLs containing a q parameter.

## `maxResultsPerQuery` (type: `integer`):

Stops each keyword after this many unique video records.

## `maxRetries` (type: `integer`):

Fresh browser/proxy attempts after a VK Video challenge or transient failure.

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

Direct access is the economical default. Enable Apify Proxy if your run encounters persistent regional or network blocks.

## Actor input object example

```json
{
  "queries": [
    "mountain bike"
  ],
  "searchUrls": [
    {
      "url": "https://vkvideo.ru/?q=mountain%20bike"
    }
  ],
  "maxResultsPerQuery": 10,
  "maxRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Ranked videos found for each search query.

# 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 = {
    "queries": [
        "mountain bike"
    ],
    "searchUrls": [
        {
            "url": "https://vkvideo.ru/?q=mountain%20bike"
        }
    ],
    "maxResultsPerQuery": 10,
    "maxRetries": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/vk-video-search-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 = {
    "queries": ["mountain bike"],
    "searchUrls": [{ "url": "https://vkvideo.ru/?q=mountain%20bike" }],
    "maxResultsPerQuery": 10,
    "maxRetries": 2,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/vk-video-search-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 '{
  "queries": [
    "mountain bike"
  ],
  "searchUrls": [
    {
      "url": "https://vkvideo.ru/?q=mountain%20bike"
    }
  ],
  "maxResultsPerQuery": 10,
  "maxRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/vk-video-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/vk-video-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "VK Video Search Scraper",
        "description": "🎬 Search public VK Video by keyword and export ranked video titles, creators, durations, quality, views, publication details, thumbnails, and stable IDs.",
        "version": "0.1",
        "x-build-id": "PgdpJ1JwN2YZEVXoK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~vk-video-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-vk-video-search-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/automation-lab~vk-video-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-vk-video-search-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/automation-lab~vk-video-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-vk-video-search-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",
                "properties": {
                    "queries": {
                        "title": "🔎 Search keywords",
                        "type": "array",
                        "description": "Keywords to search on VK Video. Each keyword is processed independently.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "VK Video search URLs",
                        "type": "array",
                        "description": "Public vkvideo.ru search URLs containing a q parameter.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum videos per query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Stops each keyword after this many unique video records.",
                        "default": 10
                    },
                    "maxRetries": {
                        "title": "Challenge retries",
                        "minimum": 0,
                        "maximum": 4,
                        "type": "integer",
                        "description": "Fresh browser/proxy attempts after a VK Video challenge or transient failure.",
                        "default": 2
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Direct access is the economical default. Enable Apify Proxy if your run encounters persistent regional or network blocks.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
