# YouTube Research Digest · Transcripts + AI Summary (`doesaiknow/youtube-research-digest`) Actor

Give one keyword, get one research digest: the top 20 YouTube videos, their full transcripts, and an AI summary with ranked themes, consensus and disagreement, brand mentions and quotable moments with timestamps. One row per keyword. Pay per digest, no seat.

- **URL**: https://apify.com/doesaiknow/youtube-research-digest.md
- **Developed by:** [David S](https://apify.com/doesaiknow) (community)
- **Categories:** AI, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / research digest

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## YouTube Research Digest — YouTube transcript research and AI video summaries

Give this actor one topic keyword and it does the watching for you: it finds the
top-ranking YouTube videos for that keyword, pulls their full transcripts, and returns a
single structured **research digest** — ranked themes, points of consensus and
disagreement, mentioned brands, and quotable moments — plus per-video notes. It is a
**YouTube transcript tool** and a **YouTube video summarizer** in one call, built for
competitor and market research instead of one-off caption downloads.

For content marketers, creators and research teams, one keyword returns one decision-ready
digest of up to 20 videos for **$1.30 or less** — mapping a niche's video landscape in minutes
instead of hours of footage. Output lands as JSON, CSV or Excel and plugs into n8n, Make,
Zapier and AI agents (Claude, ChatGPT) through the Apify API and MCP.

### What does YouTube Research Digest do?

You pass a keyword; the actor searches YouTube for the top videos, reads every transcript
it can, extracts per-video notes (topics, brands, key claims, timestamped quotes), and
synthesizes the whole corpus into one ranked digest — one dataset row per keyword, the
digest plus the evidence it was built from.

What it does **not** do: it does not stream or download video files, it does not touch
private or unlisted videos, and it does not need a Google or YouTube login. It reads the
same public search results and transcripts a signed-out visitor can see.

### Why use YouTube Research Digest

- **One keyword, one digest.** Up to 20 top videos condensed into a single ranked summary —
  no playlist to sit through.
- **Full transcripts, not snippets.** Every available transcript is read end to end, so the
  digest is grounded in what was actually said, with timestamps.
- **Themes ranked, not just listed.** Recurring topics are ranked by how many videos cover
  them, with explicit consensus and disagreement between creators.
- **Brand and quote extraction.** Every brand mention is surfaced with its contexts;
  quotable moments carry the `videoId` and `startSec` so you jump straight to the clip.
- **Flat price per digest.** $1.30 per keyword on the Free plan (down to $0.70 on Gold and above), no seat and no subscription. A keyword that
  returns zero videos is still a delivered `notFound` row.
- **Pipeline-ready output.** Structured JSON per row, exportable to CSV/Excel and callable
  from the API, MCP and no-code tools.

### How to research a YouTube keyword

1. Open the **Input** tab and type a topic keyword under **Keyword** (for example
   `standing desk`).
2. Optionally set **Country** (two-letter ISO code, e.g. `US`) and **Language** (e.g. `en`)
   to target a specific YouTube market.
3. Optionally lower **Number of videos** (`topN`) if you want fewer than the default 20.
4. Click **Start** and wait a few minutes for the run to finish.
5. Open the **Dataset** tab and read the row: start with `digest.themes`, then drill into
   `videos[]` for the per-video notes and `digest.quotableMoments` for clip-ready lines.

Minimal input:

```json
{
  "keyword": "standing desk"
}
````

Targeting a specific market:

```json
{
  "keyword": "standing desk",
  "country": "US",
  "language": "en",
  "topN": 20
}
```

### What data you get

One dataset row per keyword. Here is a real row, trimmed for readability:

```json
{
  "keyword": "standing desk",
  "country": "US",
  "language": "en",
  "videosFound": 20,
  "videosAnalyzed": 18,
  "videos": [
    {
      "videoId": "aaa111",
      "title": "Best Standing Desks 2026 — Tested",
      "url": "https://www.youtube.com/watch?v=aaa111",
      "channel": "Desk Lab",
      "views": 482000,
      "position": 1,
      "topics": ["ergonomics", "motor noise", "stability"],
      "brands": ["Uplift", "Fully"],
      "keyClaims": ["Dual motors are quieter under load"],
      "quotes": [{ "text": "the Uplift barely wobbled at full height", "startSec": 42 }],
      "source": "primary"
    }
  ],
  "digest": {
    "themes": [
      { "theme": "Frame stability at full height", "rank": 1, "videoCount": 2 },
      { "theme": "Alternating sit/stand cadence", "rank": 2, "videoCount": 2 }
    ],
    "consensus": ["Dual-motor frames are more stable than single-motor"],
    "disagreements": ["Whether an anti-fatigue mat is necessary"],
    "brandMentions": [
      { "brand": "Uplift", "videoCount": 1, "contexts": ["praised for stability"] }
    ],
    "quotableMoments": [
      { "text": "the Uplift barely wobbled at full height", "videoId": "aaa111", "startSec": 42 }
    ],
    "source": "primary"
  },
  "notFound": false,
  "contentHash": "8ed50d…",
  "finishedAt": "2026-07-23T18:34:29Z"
}
```

Field by field:

| Field | Type | What it means |
|---|---|---|
| `keyword` | string | The topic keyword you researched (echo of input) |
| `country` / `language` | string | The market used for search and transcripts (echo of input) |
| `videosFound` | int | How many videos the search returned |
| `videosAnalyzed` | int | How many of those had a usable transcript — coverage, not an error |
| `videos[]` | array | Per-video notes: `videoId`, `title`, `url`, `channel`, `views`, `position`, plus extracted `topics`, `brands`, `keyClaims`, `quotes` and a transcript `source` |
| `digest.themes[]` | array | Recurring themes, ranked, each with a `videoCount` |
| `digest.consensus[]` / `digest.disagreements[]` | array | Where creators agree and where they differ |
| `digest.brandMentions[]` | array | Each brand, how many videos mention it, and the contexts |
| `digest.quotableMoments[]` | array | Clip-ready lines with `videoId` and `startSec` |
| `notFound` | bool | `true` when the search returned zero videos — still a delivered row |
| `contentHash` | string | Deterministic hash of the transcript corpus; stable across runs of the same input |
| `finishedAt` | ISO datetime | When the digest was produced |

Every row carries the same keys. A `notFound` row keeps the shape with an empty digest, so
your parser never has to special-case it.

### Input parameters

| Field | Required | Default | Notes |
|---|---|---|---|
| `keyword` | yes | — | The topic keyword to research, e.g. `standing desk` |
| `country` | no | — | Two-letter ISO country code for the YouTube market, e.g. `US`, `GB`, `DE` |
| `language` | no | — | Two-letter language code for results and transcripts, e.g. `en`, `de` |
| `topN` | no | `20` | Number of top videos to analyze; **maximum 20** in this version (one search page) |

You can set these in the **Input** tab, or pass them as JSON through the API and the Apify
MCP server (`mcp.apify.com`), which lets AI agents pick and run this actor from your prompt.

### How much does a YouTube research digest cost?

Pay per event — no monthly seat, no subscription.

| Event | Price (FREE tier) | When it fires |
|---|---|---|
| Actor start | **$0.05**, once per run | The run starts and validates your input |
| Research digest | **$1.30 per keyword** (Free plan) | Once per delivered digest row |

Prices step down with your Apify Store tier:

| | FREE | BRONZE | SILVER | GOLD+ |
|---|---|---|---|---|
| Research digest | $1.30 | $0.80 | $0.75 | **$0.70** |

Everything in the digest — every theme, every brand mention, all per-video notes and
quotable moments — is included in that single per-keyword price. A run needs a per-run
budget of at least **$1.35** (one start plus one digest) to begin.

**You are never charged for the digest event when:** a run stops at your plan's budget cap
before doing any paid work, or a result is served from the 24-hour cache. Those cost the
$0.05 start only.

**You are charged** for a keyword that returns `notFound`, because "no videos rank for this
keyword" is a delivered, decision-ready answer.

### YouTube Research Digest vs watching videos or generic summarizers

| | This actor | Manual research | Single-video summarizer |
|---|---|---|---|
| Input | one keyword | search + watch, video by video | one video URL at a time |
| Scope | top 20 videos, synthesized | as many as you have hours for | one video |
| Themes across videos | **ranked, with consensus/disagreement** | in your head | none — single video only |
| Brand mentions | **extracted across the corpus** | manual note-taking | rarely |
| Quotable moments | **with timestamps** | manual scrubbing | sometimes |
| Output | JSON / CSV / API / MCP | notes | text blob |
| Price | **from $0.70 per keyword digest** | hours of your time | per-video or per-seat |

A single-video summarizer answers "what is in this one video?" This actor answers "what is
the whole niche saying, and where do creators agree or clash?" — the question behind real
**YouTube competitor research**.

### How to use it with AI agents and no-code tools

The output is shaped for software, not just for reading.

- **n8n / Make / Zapier** — trigger with a keyword, read the dataset, then branch on
  `digest.themes` or `digest.brandMentions` to fill a brief or a sheet.
- **AI agents via Apify MCP** — connect `mcp.apify.com` and ask an agent to research a
  keyword on YouTube. Because each row is structured, the agent reasons over it without you
  writing parsing logic.
- **API** — call the actor directly and fetch results as JSON or CSV:

```bash
curl -X POST "https://api.apify.com/v2/acts/doesaiknow~youtube-research-digest/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "keyword": "standing desk", "country": "US" }'
```

### What this actor does not do

- It does **not** download or store video or audio files — it reads transcripts only.
- It does **not** access private, unlisted, age-gated or members-only videos.
- It does **not** log in to Google or YouTube, and it holds no account credentials.
- It does **not** analyze more than 20 videos per run in this version; deeper pagination is
  planned.
- It does **not** guarantee every video has captions — videos without an available
  transcript lower `videosAnalyzed` but never fail the run.
- The digest is a **research summary**, not legal, medical or financial advice; verify
  claims before acting on them.

### FAQ

#### Is this a YouTube transcript tool or a summarizer?

Both. It pulls full transcripts for the top videos on a keyword and then summarizes them
into one ranked digest, so you get the raw transcript signal and the synthesized answer in a
single run.

#### What happens if a video has no captions?

The row is still produced. That video's transcript `source` is `null`, it is excluded from
the synthesis, and `videosAnalyzed` is lower than `videosFound`. Missing captions are
coverage information, not an error.

#### What if no videos rank for my keyword?

You still get a row with `notFound: true` and an empty digest. That is a delivered answer —
"nothing ranks here" is useful for research — and it is billed as one digest.

#### Can I research the same keyword in different countries?

Yes. Set `country` (and optionally `language`) per run. Each distinct market is a separate
input, so `standing desk` in `US` and in `GB` are two different digests.

#### Are results cached?

Identical inputs within 24 hours are served from cache at no digest charge — you pay only
the $0.05 start. Change any input field to force a fresh run.

### Related actors

- **[Google Local Pack Tracker](https://apify.com/doesaiknow/google-local-pack-tracker)** —
  track the Google local 3-pack and AI Overview per keyword and city.
- **[Amazon Listing Optimizer](https://apify.com/doesaiknow/amazon-listing-optimizer)** —
  audit and rewrite Amazon listings by ASIN with keyword gaps and a 0-100 score.
- **[AI Overview Disruption Monitor](https://apify.com/doesaiknow/ai-overview-disruption-monitor)**
  — watch how Google's AI Overview and AI Mode change who gets cited for your queries.

### Legal & support

This actor reads **publicly available YouTube data** — the same search results and
transcripts any visitor sees without logging in.

- **No login, no account access, no gated content.** It never signs in to Google or YouTube
  and never touches private, unlisted or members-only videos.
- **No personal data.** Output contains public video metadata, transcript-derived notes and
  a generated digest — no viewer identities, comments or contact details are collected.
- **Public data only.** Search results and transcripts are derived from public web content.
- **A research aid, not advice.** The digest summarizes what creators said; verify claims
  before you rely on them.

You are responsible for using the output in line with YouTube's terms and any laws that
apply to you. Found a bug or need a new field? Open an issue on the actor's page — feature
requests shape the roadmap. A review on the Store page helps other researchers find it.

### SEO keywords

youtube research tool, youtube transcript tool, youtube video summarizer, youtube competitor
research, video transcription api, youtube transcript api, youtube summary generator, summarize
youtube videos, youtube keyword research, youtube content research, youtube market research,
bulk youtube transcripts, youtube video analysis, youtube niche research, ai youtube summary,
youtube themes extraction, youtube brand mentions, video research digest, youtube seo research,
transcript extraction tool, youtube topic analysis, competitive video research, youtube content
strategy, analyze youtube channel topics

Built by doesaiknow.

# Actor input Schema

## `keyword` (type: `string`):

Topic keyword to research (e.g. "standing desk"). The actor finds the top-ranking YouTube videos for this keyword, pulls their transcripts, and returns one structured research digest.

## `country` (type: `string`):

YouTube market to search in. Leave on "Auto" to let YouTube pick by IP.

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

Language for search results and transcripts. Leave on "Auto" for YouTube's default.

## `topN` (type: `integer`):

How many top videos to analyze (1 search page). Maximum 20 in this version; deeper pagination is a planned feature.

## Actor input object example

```json
{
  "keyword": "standing desk",
  "country": "",
  "language": "",
  "topN": 20
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keyword": "standing desk"
};

// Run the Actor and wait for it to finish
const run = await client.actor("doesaiknow/youtube-research-digest").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 = { "keyword": "standing desk" }

# Run the Actor and wait for it to finish
run = client.actor("doesaiknow/youtube-research-digest").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 '{
  "keyword": "standing desk"
}' |
apify call doesaiknow/youtube-research-digest --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Research Digest · Transcripts + AI Summary",
        "description": "Give one keyword, get one research digest: the top 20 YouTube videos, their full transcripts, and an AI summary with ranked themes, consensus and disagreement, brand mentions and quotable moments with timestamps. One row per keyword. Pay per digest, no seat.",
        "version": "0.1",
        "x-build-id": "5ToHaROydpVe5Vg0W"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/doesaiknow~youtube-research-digest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-doesaiknow-youtube-research-digest",
                "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/doesaiknow~youtube-research-digest/runs": {
            "post": {
                "operationId": "runs-sync-doesaiknow-youtube-research-digest",
                "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/doesaiknow~youtube-research-digest/run-sync": {
            "post": {
                "operationId": "run-sync-doesaiknow-youtube-research-digest",
                "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": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Topic keyword to research (e.g. \"standing desk\"). The actor finds the top-ranking YouTube videos for this keyword, pulls their transcripts, and returns one structured research digest.",
                        "default": "standing desk"
                    },
                    "country": {
                        "title": "Country (optional)",
                        "enum": [
                            "",
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "PL",
                            "SE",
                            "NO",
                            "DK",
                            "FI",
                            "IE",
                            "PT",
                            "CH",
                            "AT",
                            "BE",
                            "CZ",
                            "RO",
                            "GR",
                            "TR",
                            "RU",
                            "UA",
                            "CA",
                            "MX",
                            "BR",
                            "AR",
                            "CL",
                            "CO",
                            "AU",
                            "NZ",
                            "IN",
                            "ID",
                            "JP",
                            "KR",
                            "CN",
                            "TW",
                            "HK",
                            "SG",
                            "MY",
                            "TH",
                            "VN",
                            "PH",
                            "AE",
                            "SA",
                            "IL",
                            "EG",
                            "ZA",
                            "NG",
                            "KE"
                        ],
                        "type": "string",
                        "description": "YouTube market to search in. Leave on \"Auto\" to let YouTube pick by IP.",
                        "default": ""
                    },
                    "language": {
                        "title": "Language (optional)",
                        "enum": [
                            "",
                            "en",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "pt",
                            "nl",
                            "pl",
                            "sv",
                            "no",
                            "da",
                            "fi",
                            "cs",
                            "ro",
                            "el",
                            "tr",
                            "ru",
                            "uk",
                            "ar",
                            "he",
                            "hi",
                            "id",
                            "ja",
                            "ko",
                            "zh",
                            "th",
                            "vi",
                            "ms"
                        ],
                        "type": "string",
                        "description": "Language for search results and transcripts. Leave on \"Auto\" for YouTube's default.",
                        "default": ""
                    },
                    "topN": {
                        "title": "Number of videos",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many top videos to analyze (1 search page). Maximum 20 in this version; deeper pagination is a planned feature.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
