# YouTube Quote Miner (`lead_maker/youtube-transcript-search`) Actor

YouTube transcript keyword search and quote finder for content creators. Search entire channels for words, phrases, or quotes. Get exact timestamps, preview clips instantly, and download snippets. Find every mention of a topic across hundreds of videos in minutes.

- **URL**: https://apify.com/lead\_maker/youtube-transcript-search.md
- **Developed by:** [Lead Maker](https://apify.com/lead_maker) (community)
- **Categories:** Social media, Automation, Videos
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## YouTube Quote Miner — Transcript Keyword Search & Clip Finder

Search **YouTube channel transcripts** for specific **keywords, quotes, and phrases** with precise timestamps. Extract clips, find **quote mentions**, and download video snippets from any channel — the ultimate **YouTube transcript search tool** built for **content creators**, researchers, and marketers.

Every other **YouTube transcript scraper** just dumps the full transcript. This Actor searches it — finding the exact moments a topic is mentioned across hundreds of videos, with **clickable timestamp links**, an **interactive HTML report**, and **ready-to-use download commands**.

### 🎯 Best For

- **Content creators** — find clips from any channel discussing your topic, no more scrubbing through hours of video
- **Researchers** — locate every mention of a subject across a creator's entire video library
- **Podcast editors** — search for specific **quotes** or sound bites across episodes
- **Journalists** — find what a YouTuber has said about a particular topic over time
- **Marketers** — discover **brand mentions** across YouTube channels at scale
- **Agencies** — build clip libraries from competitor or partner channels automatically

### 📊 What You Get

Each search result includes:

- **Video title** and **channel name**
- **Exact timestamp** (HH:MM:SS) where the keyword appears
- **Clickable YouTube link** that jumps to that exact moment
- **Transcript excerpt** with the keyword highlighted in context
- **yt-dlp command** to download just that clip (not the whole video)
- **Mention count** — how many times the keyword appears in the merged clip

Plus these output files:

| File | Description |
|------|-------------|
| `report.html` | Interactive HTML report with video thumbnails and copy-to-clipboard buttons |
| `results.csv` | All results as a CSV spreadsheet for Excel or Google Sheets |
| `download_all.bat` | Windows batch script to download every clip |
| `download_all.sh` | Linux/Mac shell script to download every clip |
| `SUMMARY` | JSON summary with per-video breakdown ranked by mentions |

### ⚙️ How It Works

**Step 1 — Enter a channel and keyword**

Paste one or more **YouTube channel URLs** and the **keywords** you're looking for. The Actor accepts `/@handle`, `/channel/ID`, and `/c/name` formats. Multiple channels and keywords can be comma-separated or one per line.

**Step 2 — The Actor scans all transcripts**

The Actor lists every video in the channel, fetches each transcript, and searches for your keyword. **YouTube Shorts** are automatically excluded (optional). Results stream to your dataset as they're found — you don't have to wait for all videos to finish.

**Step 3 — Browse results and download clips**

Open the **HTML report** to preview results with video thumbnails. Click any thumbnail to jump to that moment in YouTube. Copy the **yt-dlp command** to download just the clip. Export everything as **CSV** for spreadsheets.

### 🔑 Key Features

- **YouTube transcript keyword search** — full-text search across all video captions and transcripts
- **Multiple keyword search** — search for several terms at once (e.g., `black hole, dark matter, gravity`)
- **Search multiple YouTube channels** — scan across several channels in one run
- **YouTube caption search** — works with both auto-generated and manual captions
- **Smart clip merging** — if a keyword is mentioned 5 times in 30 seconds, you get 1 clip instead of 5
- **Minimum clip duration filter** — skip brief passing mentions, only keep extended discussions
- **Exclude YouTube Shorts** — automatically skip videos under 60 seconds
- **Interactive HTML report** — visual report with video thumbnails and one-click copy buttons
- **CSV export** — download results as a spreadsheet
- **Batch download scripts** — `.bat` and `.sh` scripts to grab all clips at once
- **Timestamp links** — click to jump directly to the moment in YouTube
- **Abort-safe** — results saved every 25 videos, so aborting early keeps everything found so far
- **No API key needed** — works without a YouTube Data API key
- **Residential proxies** — rotates IPs to avoid YouTube rate limiting

### 📝 Input

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `channelUrls` | string | Yes | — | One or more **YouTube channel URLs**, comma-separated or one per line |
| `keywords` | string | Yes | — | One or more **search terms**, comma-separated |
| `maxVideos` | integer | No | all | Max videos to scan per channel (most recent first) |
| `excludeShorts` | boolean | No | true | Skip **YouTube Shorts** (videos under 60s) |
| `minClipDurationSec` | integer | No | 0 | Only keep clips at least this many seconds long |
| `snippetPaddingSec` | integer | No | 15 | Seconds of extra video before/after each match |
| `mergeGapSec` | integer | No | 30 | Merge mentions within this many seconds into one clip |
| `contextLines` | integer | No | 3 | Transcript lines of context around each match |
| `language` | string | No | `en` | Preferred transcript language code |

#### Example Input

```json
{
    "channelUrls": "https://www.youtube.com/@veritasium, https://www.youtube.com/@3blue1brown",
    "keywords": "black hole, dark matter",
    "maxVideos": 50,
    "excludeShorts": true
}
````

### 💰 Pricing

Apify charges for compute time, proxy bandwidth, and storage. Typical costs:

| Videos scanned | Approximate cost |
|---------------|-----------------|
| 10 videos | ~$0.05 |
| 50 videos | ~$0.25 |
| 100 videos | ~$0.50 |
| 500 videos | ~$2.50 |

Costs vary based on transcript length, proxy usage, and how many results are found. Residential proxies (recommended for reliability) cost more than datacenter proxies. You can set a **max cost per run** in Apify to control spending.

### 📤 Sample Output

```json
{
    "channelName": "veritasium",
    "videoTitle": "Something Strange Happens When You Follow Einstein's Math",
    "keyword": "black hole",
    "timestampFormatted": "00:02:22",
    "videoUrlAtTimestamp": "https://www.youtube.com/watch?v=6akmv1bsz1M&t=142",
    "transcriptExcerpt": "...and when we look at the center of the galaxy we find a **black hole** that weighs four million times...",
    "mentionCount": 3,
    "ytDlpCommand": "yt-dlp --download-sections \"*00:02:07-00:02:37\" -o \"Something_Strange_00-02-07.%(ext)s\" \"https://www.youtube.com/watch?v=6akmv1bsz1M\""
}
```

### 🏢 Built for Teams & Automation

- **API integration** — trigger runs programmatically via the Apify API
- **Scheduling** — set up recurring searches on a daily or weekly cadence
- **Webhooks** — get notified when a run completes
- **Multiple concurrent runs** — search different channels in parallel
- **Integrations** — connect to Google Sheets, Slack, Zapier, Make, and more via Apify integrations

### ❓ FAQ

**Does it work with auto-generated captions?**
Yes — the Actor uses whatever transcript is available on a video, including YouTube's **auto-generated captions** and manually uploaded subtitle tracks.

**What languages are supported?**
Any language with available transcripts. Set the `language` parameter to your preferred language code (e.g., `es` for Spanish, `de` for German, `ja` for Japanese). Falls back to English if unavailable.

**How long does a full channel scan take?**
A 500-video channel takes roughly **15-25 minutes** with the built-in rate limiting. You can limit with `maxVideos` for faster runs.

**What if I abort the run early?**
Results are saved every 25 videos — you keep everything found so far, including the **HTML report** and **CSV**.

**Can I search multiple channels at once?**
Yes — comma-separate the URLs or put one per line. Each channel is searched sequentially.

**Can I search for multiple keywords?**
Yes — comma-separate the keywords. Each keyword is searched independently across all transcripts.

**What happens if a video has no transcript?**
It's skipped gracefully. The summary tells you how many videos had transcripts and how many were skipped.

**Do I need a YouTube Data API key?**
No. The Actor uses `scrapetube` to list videos and `youtube-transcript-api` to fetch transcripts — no Google API key required.

**Why are some videos showing as blocked?**
YouTube rate-limits transcript requests. The Actor uses **Apify residential proxies** and **IP rotation** to minimize this. If too many consecutive videos are blocked, the Actor stops that channel early and moves on.

### 🔄 How Does This Compare to Other YouTube Transcript Tools?

**YouTube Quote Miner vs manual transcript reading**
Manually reading transcripts means opening each video, enabling captions, and scrubbing through the timeline. This Actor searches **hundreds of videos in minutes** and gives you exact timestamps.

**YouTube Quote Miner vs YouTube's built-in search**
YouTube search finds videos *about* a topic — it doesn't search *within* transcripts. This Actor finds the exact moment a word is spoken, even if the video title has nothing to do with it.

**YouTube Quote Miner vs generic transcript scrapers**
Most **YouTube transcript scrapers** just dump the full text. This Actor **searches** it — finding specific keywords, highlighting matches, generating timestamps, and building download commands.

**YouTube Quote Miner vs ChatGPT + YouTube**
AI chatbots can summarize a single video, but they can't search across hundreds of videos for specific keyword mentions with exact timecodes and clip download commands.

### 🔧 Technical Details

- Uses `scrapetube` to list channel videos (no API key needed)
- Uses `youtube-transcript-api` to fetch timestamped transcripts and captions
- **Residential proxy rotation** per request to avoid YouTube IP blocks
- **2-minute timeout** on channel listing to prevent hangs
- Saves results every 25 videos (abort-safe)
- Stops a channel after 15 consecutive transcript failures to save compute
- 1.5 second delay between requests for reliability

# Actor input Schema

## `channelUrls` (type: `string`):

Paste one or more YouTube channel URLs, separated by commas. Example: https://www.youtube.com/@veritasium, https://www.youtube.com/@3blue1brown

## `keywords` (type: `string`):

What to look for in the video transcripts. Separate multiple terms with commas. Example: black hole, dark matter

## `maxVideos` (type: `integer`):

Only search this many of the most recent videos. Leave empty to search the entire channel.

## `excludeShorts` (type: `boolean`):

Skip YouTube Shorts (videos under 60 seconds).

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

Language code for transcripts (e.g., 'en', 'es', 'de'). Falls back to English if unavailable.

## `snippetPaddingSec` (type: `integer`):

How many seconds of extra video to include before and after each match. Gives you more context around the keyword.

## `mergeGapSec` (type: `integer`):

If the keyword is mentioned multiple times within this many seconds, combine them into one clip instead of creating separate ones. Set to 0 to keep every mention separate.

## `minClipDurationSec` (type: `integer`):

Skip clips shorter than this. Useful for filtering out brief, passing mentions and only keeping longer discussions.

## `concurrency` (type: `integer`):

How many video transcripts to fetch at the same time. Higher = faster but uses more proxy bandwidth. Default 5 is a good balance.

## `contextLines` (type: `integer`):

How many lines of transcript to show before and after each match in the results.

## Actor input object example

```json
{
  "channelUrls": "https://www.youtube.com/@veritasium",
  "keywords": "science",
  "maxVideos": 10,
  "excludeShorts": true,
  "language": "en",
  "snippetPaddingSec": 15,
  "mergeGapSec": 30,
  "minClipDurationSec": 0,
  "concurrency": 5,
  "contextLines": 3
}
```

# Actor output Schema

## `report` (type: `string`):

HTML report with embedded YouTube players for each match, copy-to-clipboard buttons for yt-dlp commands, and a per-video breakdown table.

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

Dataset with all matches including channel name, video title, keyword, timestamp, transcript excerpt, YouTube timestamp link, and yt-dlp command.

## `csv` (type: `string`):

All results as a CSV spreadsheet for use in Excel or Google Sheets.

## `summary` (type: `string`):

JSON summary with total mentions, clips, videos searched, and per-video breakdown ranked by mention count.

# 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 = {
    "channelUrls": "https://www.youtube.com/@veritasium",
    "keywords": "science",
    "maxVideos": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("lead_maker/youtube-transcript-search").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 = {
    "channelUrls": "https://www.youtube.com/@veritasium",
    "keywords": "science",
    "maxVideos": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("lead_maker/youtube-transcript-search").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 '{
  "channelUrls": "https://www.youtube.com/@veritasium",
  "keywords": "science",
  "maxVideos": 10
}' |
apify call lead_maker/youtube-transcript-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Quote Miner",
        "description": "YouTube transcript keyword search and quote finder for content creators. Search entire channels for words, phrases, or quotes. Get exact timestamps, preview clips instantly, and download snippets. Find every mention of a topic across hundreds of videos in minutes.",
        "version": "0.1",
        "x-build-id": "IpXAXOGDMnIrQxEit"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lead_maker~youtube-transcript-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lead_maker-youtube-transcript-search",
                "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/lead_maker~youtube-transcript-search/runs": {
            "post": {
                "operationId": "runs-sync-lead_maker-youtube-transcript-search",
                "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/lead_maker~youtube-transcript-search/run-sync": {
            "post": {
                "operationId": "run-sync-lead_maker-youtube-transcript-search",
                "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": [
                    "channelUrls",
                    "keywords"
                ],
                "properties": {
                    "channelUrls": {
                        "title": "Channel URL(s)",
                        "type": "string",
                        "description": "Paste one or more YouTube channel URLs, separated by commas. Example: https://www.youtube.com/@veritasium, https://www.youtube.com/@3blue1brown"
                    },
                    "keywords": {
                        "title": "Search Keywords or Phrases",
                        "type": "string",
                        "description": "What to look for in the video transcripts. Separate multiple terms with commas. Example: black hole, dark matter"
                    },
                    "maxVideos": {
                        "title": "Max Videos per Channel",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only search this many of the most recent videos. Leave empty to search the entire channel."
                    },
                    "excludeShorts": {
                        "title": "Exclude YouTube Shorts",
                        "type": "boolean",
                        "description": "Skip YouTube Shorts (videos under 60 seconds).",
                        "default": true
                    },
                    "language": {
                        "title": "Transcript Language",
                        "type": "string",
                        "description": "Language code for transcripts (e.g., 'en', 'es', 'de'). Falls back to English if unavailable.",
                        "default": "en"
                    },
                    "snippetPaddingSec": {
                        "title": "Clip Padding",
                        "minimum": 0,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How many seconds of extra video to include before and after each match. Gives you more context around the keyword.",
                        "default": 15
                    },
                    "mergeGapSec": {
                        "title": "Merge Nearby Mentions",
                        "minimum": 0,
                        "maximum": 300,
                        "type": "integer",
                        "description": "If the keyword is mentioned multiple times within this many seconds, combine them into one clip instead of creating separate ones. Set to 0 to keep every mention separate.",
                        "default": 30
                    },
                    "minClipDurationSec": {
                        "title": "Minimum Clip Length",
                        "minimum": 0,
                        "maximum": 600,
                        "type": "integer",
                        "description": "Skip clips shorter than this. Useful for filtering out brief, passing mentions and only keeping longer discussions.",
                        "default": 0
                    },
                    "concurrency": {
                        "title": "Speed (Concurrent Fetches)",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many video transcripts to fetch at the same time. Higher = faster but uses more proxy bandwidth. Default 5 is a good balance.",
                        "default": 5
                    },
                    "contextLines": {
                        "title": "Transcript Context",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many lines of transcript to show before and after each match in the results.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
