# Kick VOD Transcription (`scrapersdelight/kick-transcript-scraper`) Actor

Transcribe Kick.com VODs (which have no captions). Returns VOD metadata plus a searchable transcript in TXT/SRT/VTT, by channel or VOD URL. Run on a schedule to transcribe new VODs automatically.

- **URL**: https://apify.com/scrapersdelight/kick-transcript-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Videos, AI
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 per record returneds

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

## 🎙️ Kick VOD Transcript Scraper — faster-whisper

**Turn any [Kick.com](https://kick.com) VOD into a searchable transcript. Kick ships no captions, so this actor pulls the VOD audio and transcribes it with `faster-whisper` (Whisper `large-v3-turbo`) — giving you clean text plus SRT/VTT subtitles and timestamped segments, by channel or VOD URL. Run it on a schedule to auto-transcribe new streams as they go up.**

No login, no browser automation. Metadata comes from Kick's public API; the transcript is generated on Apify's own compute — **no external API key needed**.

---

### What does it do?

Kick exposes VODs through a public JSON API, but **none of them have a caption/subtitle track** — so the only way to get a transcript is speech-to-text. This actor does exactly that:

1. 🔎 **Finds VODs** — newest N per channel, or specific VOD URLs.
2. 🎧 **Extracts the audio** — pulls the lowest-bandwidth HLS variant (audio intact) and converts it to 16 kHz mono with ffmpeg. A `maxMinutesPerVod` cap keeps long streams affordable.
3. 📝 **Transcribes with faster-whisper** — model `large-v3-turbo` by default (the speed/accuracy sweet spot), with `large-v3` and `distil-large-v3` options.
4. 📤 **Returns** VOD metadata + transcript as **plain text, SRT, VTT, and/or timestamped segments**.
5. 🔔 **Monitors** — schedule it to transcribe only newly-published VODs and alert via Slack/email/webhook.

---

### What data does it extract?

Per VOD:

- 🆔 `vod_uuid`, 📺 `channel`, 🏷️ `title`, 🎮 `category`
- 🌐 `language` (detected), ⏱️ `duration_ms`, `audio_minutes` (transcribed), 👁️ `views`, 📅 `created_at`
- 🔗 `vod_url`, 🖼️ `thumbnail`
- 📝 `transcript` (plain text) — always included
- 🎬 `srt`, `vtt` — subtitle formats (optional)
- ⏲️ `segments[]` — `{start, end, text}` timestamped lines (optional)
- ✨ `is_new` (monitor mode), 🕒 `scraped_at`

---

### Who is it for?

- 🔎 **Researchers & journalists** searching what streamers actually said, by keyword.
- ✂️ **Clippers & editors** finding moments fast with timestamped segments + SRT/VTT.
- 🛡️ **Trust & safety / brand monitoring** scanning streams for terms.
- 🤖 **AI / dataset builders** assembling speech datasets and feeding RAG pipelines.

---

### How to use it (step by step)

1. Click **Try for free**.
2. Enter one or more **channel slugs** (e.g. `xqc`) — or paste **VOD URLs**.
3. Set **Max minutes per VOD** (default 60) — Kick streams are long; this bounds cost.
4. Pick a **model** (`large-v3-turbo` is recommended) and **formats** (txt / srt / vtt / segments).
5. Click **Start**, then open the **Dataset** tab to view/export.
6. *(Optional)* set **monitorMode** + a **Schedule** + an alert channel to auto-transcribe new VODs.

#### Quick start

```json
{ "channelSlugs": ["xqc"], "maxVods": 1, "maxMinutesPerVod": 30 }
````

#### New-VOD monitor example

```json
{
  "channelSlugs": ["trainwreckstv"],
  "monitorMode": true,
  "maxMinutesPerVod": 120,
  "slackWebhookUrl": "https://hooks.slack.com/services/…"
}
```

***

### Input

| Field | What it does |
|-------|--------------|
| `channelSlugs` | Kick channels to pull the newest VODs from |
| `vodUrls` | specific VOD URLs / UUIDs to transcribe |
| `maxVods` | newest VODs per channel |
| `sinceDate` | only VODs on/after this date |
| `maxMinutesPerVod` | **cost guard** — cap audio pulled per VOD (0 = whole VOD) |
| `model` | `large-v3-turbo` · `large-v3` · `distil-large-v3` |
| `language` / `translateToEnglish` | spoken language (or auto) / output English translation |
| `transcriptFormats` | `txt` · `srt` · `vtt` · `segments` |
| `includeMetadataOnly` | skip ASR, return metadata only (fast/cheap) |
| `monitorMode`, `alertOnNewVod` | recurring new-VOD watcher + alerts |
| `webhookUrl`, `slackWebhookUrl`, `emailRecipients` | alert channels |

***

### Output

Each VOD is one dataset record (fields above). Export to **JSON, CSV, Excel, HTML, or RSS**, or fetch via the **Apify API**. The transcript is plain text; SRT/VTT are ready to drop into a video editor.

***

### How much does it cost?

Pay-per-event — you pay for what you transcribe, no subscription:

| Event | What it covers | Suggested price |
|-------|----------------|-----------------|
| `lot-scraped` | each VOD returned | ~$0.01 / VOD |
| `audio-minute-transcribed` | each minute of audio transcribed | ~$0.012 / minute |
| `monitor-run-completed` | each scheduled watch run | ~$0.05 / run |
| `new-lot-detected` | each newly-published VOD | ~$0.02 / VOD |
| `alert-delivered` | each Slack/email/webhook push | ~$0.005 / alert |

*(Final per-event prices are set on the actor's pricing page. Use `maxMinutesPerVod` to control spend on long streams.)*

***

### How does transcription work?

It uses **[faster-whisper](https://github.com/SYSTRAN/faster-whisper)** (the CTranslate2 build of OpenAI's Whisper), running on Apify's compute — **no API key, nothing leaves Apify**. Default model is **`large-v3-turbo`** (as accurate as Whisper large-v2 but ~6× faster); `distil-large-v3` is cheaper/faster, `large-v3` is maximum accuracy. A VAD filter skips long silences so you're not billed for dead air.

***

### Is it legal to transcribe Kick VODs?

This actor reads **publicly available VOD data** via Kick's own public endpoints and transcribes the audio. Transcripts of public broadcasts are widely used for research, accessibility, and indexing, but the underlying streams may be covered by copyright and by Kick's Terms of Service. **You are responsible for your use — review Kick's Terms of Service and the applicable rights before redistributing transcripts or audio.**

***

### FAQ

**Why ASR instead of captions?**
Kick doesn't provide captions/subtitles for VODs, so there's no caption track to extract — a transcript can only be produced by speech-to-text.

**Kick streams are 10+ hours — won't that be expensive?**
Set `maxMinutesPerVod` (default 60) to bound how much audio is transcribed per VOD. Billing is per transcribed minute, so you control the spend.

**Which languages?**
Whisper supports ~99 languages and auto-detects by default; set `language` to force one, or `translateToEnglish` for an English translation.

**Can I get subtitles?**
Yes — add `srt` and/or `vtt` to `transcriptFormats` for ready-to-use subtitle files, or `segments` for `{start,end,text}` timestamps.

**Can I auto-transcribe new streams?**
Yes. Turn on `monitorMode`, attach an Apify **Schedule**, and add a Slack/webhook/email channel — each run transcribes only VODs new since the last run.

***

### Feedback

Want speaker labels, word-level timestamps, or another platform? Open an issue on the actor.

# Actor input Schema

## `channelSlugs` (type: `array`):

Kick channel names (from kick.com/<slug>), e.g. \['xqc','trainwreckstv']. The newest VODs per channel are transcribed.

## `vodUrls` (type: `array`):

Specific VODs — full https://kick.com/<channel>/videos/<uuid> URLs or bare VOD UUIDs. Use instead of, or alongside, channel slugs.

## `maxVods` (type: `integer`):

How many of the newest VODs to take from each channel. Each VOD can be hours long, so keep this small unless you bound the length below. Raise for bigger batches (give the run more timeout).

## `sinceDate` (type: `string`):

Optional ISO date (YYYY-MM-DD). Only transcribe VODs created on or after this date.

## `maxMinutesPerVod` (type: `integer`):

Cap how much audio is pulled & transcribed per VOD (cost + time guard — Kick streams run 10+ hours, and transcription is slow). 0 = the whole VOD. Prefilled to 1 for a fast demo run; raise for longer transcripts, but increase the run timeout to match (Whisper takes roughly real-time on CPU).

## `model` (type: `string`):

faster-whisper model. Turbo is the speed/accuracy meta; large-v3 for max accuracy; distil for cheapest/fastest. (Advanced: you can also paste a Hugging Face CT2 model id.)

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

Spoken language code (e.g. en, es, de) or 'auto' to detect. Defaults to auto-detect.

## `translateToEnglish` (type: `boolean`):

Output an English translation instead of a same-language transcript (Whisper translate task).

## `transcriptFormats` (type: `array`):

Which transcript representations to include on each record. Plain text is always included.

## `includeMetadataOnly` (type: `boolean`):

Return just VOD metadata (title, category, duration, views, URL) without transcribing — fast and cheap. Turn off to get transcripts.

## `monitorMode` (type: `boolean`):

Recurring watcher: diff against the prior run's seen VODs (per channel set) and output/alert ONLY newly-published VODs. Pair with an Apify Schedule to auto-transcribe new streams.

## `alertOnNewVod` (type: `boolean`):

In monitor mode, deliver an alert for each newly-published VOD via the channels below.

## `webhookUrl` (type: `string`):

POST endpoint for new-VOD alert payloads (Make / Zapier / n8n / custom).

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL for formatted new-VOD cards.

## `emailRecipients` (type: `array`):

Email addresses for the new-VOD digest (sent via apify/send-mail).

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

Proxy settings for the Kick API + segment downloads. Datacenter rotation is usually enough.

## `diagnose` (type: `boolean`):

Dev only. Resolves the channel's newest VOD and the HLS variants/segments without downloading audio or transcribing, then exits.

## Actor input object example

```json
{
  "channelSlugs": [
    "xqc"
  ],
  "maxVods": 1,
  "maxMinutesPerVod": 1,
  "model": "large-v3-turbo",
  "language": "auto",
  "translateToEnglish": false,
  "transcriptFormats": [
    "txt"
  ],
  "includeMetadataOnly": false,
  "monitorMode": false,
  "alertOnNewVod": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "diagnose": false
}
```

# Actor output Schema

## `transcripts` (type: `string`):

The dataset of transcribed VODs (one item per VOD: metadata + transcript).

# 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 = {
    "channelSlugs": [
        "xqc"
    ],
    "maxMinutesPerVod": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/kick-transcript-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 = {
    "channelSlugs": ["xqc"],
    "maxMinutesPerVod": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/kick-transcript-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 '{
  "channelSlugs": [
    "xqc"
  ],
  "maxMinutesPerVod": 1
}' |
apify call scrapersdelight/kick-transcript-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kick VOD Transcription",
        "description": "Transcribe Kick.com VODs (which have no captions). Returns VOD metadata plus a searchable transcript in TXT/SRT/VTT, by channel or VOD URL. Run on a schedule to transcribe new VODs automatically.",
        "version": "0.1",
        "x-build-id": "m9pWZd8J7ZzB5BO2K"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapersdelight~kick-transcript-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapersdelight-kick-transcript-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/scrapersdelight~kick-transcript-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapersdelight-kick-transcript-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/scrapersdelight~kick-transcript-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapersdelight-kick-transcript-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": {
                    "channelSlugs": {
                        "title": "Channel slugs",
                        "type": "array",
                        "description": "Kick channel names (from kick.com/<slug>), e.g. ['xqc','trainwreckstv']. The newest VODs per channel are transcribed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "vodUrls": {
                        "title": "VOD URLs / IDs",
                        "type": "array",
                        "description": "Specific VODs — full https://kick.com/<channel>/videos/<uuid> URLs or bare VOD UUIDs. Use instead of, or alongside, channel slugs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVods": {
                        "title": "Max VODs per channel",
                        "minimum": 1,
                        "type": "integer",
                        "description": "How many of the newest VODs to take from each channel. Each VOD can be hours long, so keep this small unless you bound the length below. Raise for bigger batches (give the run more timeout).",
                        "default": 1
                    },
                    "sinceDate": {
                        "title": "Only VODs since (date)",
                        "type": "string",
                        "description": "Optional ISO date (YYYY-MM-DD). Only transcribe VODs created on or after this date."
                    },
                    "maxMinutesPerVod": {
                        "title": "Max minutes per VOD",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap how much audio is pulled & transcribed per VOD (cost + time guard — Kick streams run 10+ hours, and transcription is slow). 0 = the whole VOD. Prefilled to 1 for a fast demo run; raise for longer transcripts, but increase the run timeout to match (Whisper takes roughly real-time on CPU).",
                        "default": 5
                    },
                    "model": {
                        "title": "Transcription model",
                        "enum": [
                            "large-v3-turbo",
                            "large-v3",
                            "distil-large-v3"
                        ],
                        "type": "string",
                        "description": "faster-whisper model. Turbo is the speed/accuracy meta; large-v3 for max accuracy; distil for cheapest/fastest. (Advanced: you can also paste a Hugging Face CT2 model id.)",
                        "default": "large-v3-turbo"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Spoken language code (e.g. en, es, de) or 'auto' to detect. Defaults to auto-detect.",
                        "default": "auto"
                    },
                    "translateToEnglish": {
                        "title": "Translate to English",
                        "type": "boolean",
                        "description": "Output an English translation instead of a same-language transcript (Whisper translate task).",
                        "default": false
                    },
                    "transcriptFormats": {
                        "title": "Transcript formats",
                        "type": "array",
                        "description": "Which transcript representations to include on each record. Plain text is always included.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "txt",
                                "srt",
                                "vtt",
                                "segments"
                            ],
                            "enumTitles": [
                                "Plain text",
                                "SRT subtitles",
                                "VTT subtitles",
                                "Timestamped segments (array)"
                            ]
                        },
                        "default": [
                            "txt"
                        ]
                    },
                    "includeMetadataOnly": {
                        "title": "Metadata only (skip transcription)",
                        "type": "boolean",
                        "description": "Return just VOD metadata (title, category, duration, views, URL) without transcribing — fast and cheap. Turn off to get transcripts.",
                        "default": false
                    },
                    "monitorMode": {
                        "title": "Monitor mode (new-VOD watcher)",
                        "type": "boolean",
                        "description": "Recurring watcher: diff against the prior run's seen VODs (per channel set) and output/alert ONLY newly-published VODs. Pair with an Apify Schedule to auto-transcribe new streams.",
                        "default": false
                    },
                    "alertOnNewVod": {
                        "title": "Alert on new VODs",
                        "type": "boolean",
                        "description": "In monitor mode, deliver an alert for each newly-published VOD via the channels below.",
                        "default": true
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "POST endpoint for new-VOD alert payloads (Make / Zapier / n8n / custom)."
                    },
                    "slackWebhookUrl": {
                        "title": "Slack webhook URL",
                        "type": "string",
                        "description": "Slack incoming-webhook URL for formatted new-VOD cards."
                    },
                    "emailRecipients": {
                        "title": "Email recipients",
                        "type": "array",
                        "description": "Email addresses for the new-VOD digest (sent via apify/send-mail).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings for the Kick API + segment downloads. Datacenter rotation is usually enough.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "diagnose": {
                        "title": "Diagnostic mode (dev)",
                        "type": "boolean",
                        "description": "Dev only. Resolves the channel's newest VOD and the HLS variants/segments without downloading audio or transcribing, then exits.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```