# YouTube Search Scraper & API (`parsebird/youtube-search-scraper`) Actor

Scrape YouTube search results — videos, channels, playlists, shorts, and movies. Filter by type, duration, upload date, sort order, and video features (HD, 4K, CC, Live). Get titles, view counts, thumbnails, channel info, and publish dates. Export as JSON, CSV, Excel.

- **URL**: https://apify.com/parsebird/youtube-search-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Videos, Social media, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.40 / 1,000 youtube search results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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 Search Scraper

Scrape [YouTube](https://www.youtube.com) search results at scale — videos, channels, playlists, shorts, and movies. Extract titles, view counts, durations, thumbnails, channel info, and publish dates into structured data. Filter by content type, duration, upload date, sort order, geo, language, and video features (HD, 4K, CC, Live, HDR). Built for content researchers, marketers, media analysts, and data engineers who need clean, structured YouTube search data without API quotas.

<table><tr>
<td style="border-left:4px solid #FF0000;padding:12px 16px;font-weight:600">
Search any keyword on YouTube with advanced filters — type, duration, upload date, sort order, country, language, and 11 video feature flags. Get structured results with view counts, thumbnails, channel metadata, and publish dates. No API key needed.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

````

YouTube Search Scraper (parsebird/youtube-search-scraper) — Scrapes YouTube search results for videos, channels, playlists, shorts, and movies. Input: {"query": "python tutorial", "maxResults": 100, "type": "video", "sortBy": "relevance"}. Filters: type (video/channel/playlist/movie/shorts), sortBy (relevance/popularity), duration (under3min/3to20min/over20min), uploadDate (today/week/month/year), geo (2-letter country code), lang (language code), features ({HD, subtitles, CCommons, 3D, Live, Purchased, 4K, 360, Location, HDR, VR180}), scrapeAllResults (bool), local (bool). Outputs per result: id, title, description, type, viewCount, duration, url, thumbnail, date, channelName, channelUrl, channelHandle, channelThumbnail, searchQuery, scrapedAt, raw. API: POST https://api.apify.com/v2/acts/parsebird~youtube-search-scraper/runs?token=YOUR\_TOKEN. Get token: https://console.apify.com/account#/integrations

````

### What does YouTube Search Scraper do?

The **YouTube Search Scraper** turns any search query into structured JSON, CSV, or Excel data — the same results you see on [YouTube](https://www.youtube.com), but in a machine-readable format. Enter a keyword, set your filters, and the scraper:

- 🔍 Searches YouTube's internal API for fast, reliable results (no browser, no headless Chrome, no API key)
- 📹 Returns videos, channels, playlists, shorts, and movies — filter by type or get all at once
- 📊 Extracts view counts, durations, thumbnails, channel names, handles, and publish dates
- 🌍 Supports geo-targeting (country code) and language localization for region-specific results
- ⏱️ Filters by duration (under 3 min, 3–20 min, over 20 min) and upload date (today, week, month, year)
- 🎬 Applies video feature filters — HD, 4K, HDR, Live, Subtitles/CC, Creative Commons, 360°, VR180, and more
- 📈 Sorts by relevance or popularity (view count)
- ♾️ Paginates automatically — scrape hundreds or thousands of results per query
- ⚡ Runs on lightweight infrastructure (128–512 MB) — fast and cost-efficient

The YouTube Search Scraper uses YouTube's own internal InnerTube API — the same API that powers youtube.com — so results are always fresh and accurate.

### What data can you extract from YouTube search?

| Field | Description |
|-------|-------------|
| `id` | YouTube video, channel, or playlist ID |
| `title` | Result title as displayed on YouTube |
| `description` | Description snippet from search results |
| `type` | Content type — `video`, `channel`, `playlist`, `shorts`, `movie`, or `live` |
| `viewCount` | Number of views (integer) |
| `duration` | Video length (e.g. `10:30`, `1:05:22`) |
| `url` | Direct URL to the video, channel, or playlist |
| `thumbnail` | High-resolution thumbnail URL |
| `date` | Estimated publish date (ISO 8601) |
| `channelName` | Channel display name |
| `channelUrl` | Channel URL |
| `channelHandle` | Channel handle (e.g. `@mkbhd`) |
| `channelThumbnail` | Channel avatar URL |
| `searchQuery` | The query that produced this result |
| `scrapedAt` | Timestamp when the data was collected |
| `raw` | Full raw response from YouTube's API |

### How to scrape YouTube search results

1. Open the [YouTube Search Scraper](https://apify.com/parsebird/youtube-search-scraper) on Apify
2. Enter your **Search Query** — any keyword or phrase (e.g. "python tutorial", "cooking recipes", "tech reviews")
3. Set **Max Results** to control how many results to collect (default: 100)
4. Optionally select a **Result Type** — Video, Channel, Playlist, Movie, or Shorts
5. Apply filters: **Sort By**, **Duration**, **Upload Date**, **Country**, **Language**
6. Toggle **Video Features** for specific requirements (HD, 4K, Subtitles, Live, etc.)
7. Click **Start** and wait for results
8. Export your data as **JSON, CSV, or Excel** from the dataset tab

**Quick start input:**

```json
{
    "query": "python tutorial",
    "maxResults": 100,
    "type": "video"
}
````

**Filtered search — popular HD videos from this month:**

```json
{
    "query": "machine learning",
    "maxResults": 200,
    "type": "video",
    "sortBy": "popularity",
    "duration": "3to20min",
    "uploadDate": "month",
    "features": {
        "HD": true,
        "subtitles": true
    }
}
```

**Localized search — Spanish tech videos in Spain:**

```json
{
    "query": "tutoriales de programación",
    "maxResults": 50,
    "type": "video",
    "geo": "ES",
    "lang": "es"
}
```

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `query` | string | **Yes** | — | Keywords to search for on YouTube |
| `maxResults` | integer | No | 100 | Maximum number of results to return |
| `scrapeAllResults` | boolean | No | false | Scrape all available results (overrides maxResults) |
| `type` | string | No | (all) | Filter by type: `video`, `channel`, `playlist`, `movie`, `shorts` |
| `sortBy` | string | No | relevance | Sort order: `relevance` or `popularity` |
| `duration` | string | No | (any) | Filter by length: `under3min`, `3to20min`, `over20min` |
| `uploadDate` | string | No | (any) | Time frame: `today`, `week`, `month`, `year` |
| `geo` | string | No | — | 2-letter country code (e.g. `US`, `GB`, `IN`) |
| `lang` | string | No | — | Language code (e.g. `en`, `es`, `fr`) |
| `features` | object | No | — | Video feature filters: HD, Subtitles, CC, 3D, Live, Purchased, 4K, 360, Location, HDR, VR180 |
| `local` | boolean | No | false | Request localized data from YouTube |

### Output example

```json
{
    "id": "3URtTIdnXIk",
    "title": "These CATS are too FUNNY! 🤣 | New Cat Videos 2025",
    "description": "You like cats? We got em! No dogs! Just cats! Seriously, all cats!...",
    "type": "video",
    "viewCount": 15553834,
    "duration": "1:00:17",
    "url": "https://www.youtube.com/watch?v=3URtTIdnXIk",
    "thumbnail": "https://i.ytimg.com/vi/3URtTIdnXIk/hq720.jpg?sqp=...",
    "date": "2025-06-20T00:00:00Z",
    "channelName": "The Pet Collective",
    "channelUrl": "https://www.youtube.com/channel/UCPIvT-zcQl2H0vabdXJGcpg",
    "channelHandle": "@petcollective",
    "channelThumbnail": "https://yt3.ggpht.com/...",
    "searchQuery": "cats",
    "scrapedAt": "2026-06-20T14:58:23.000Z"
}
```

### Use cases

- **Content research** — Find trending videos in any niche to inform your content strategy
- **Competitor analysis** — Track what content competitors are publishing and how it performs
- **Market research** — Discover popular topics, emerging trends, and audience interests by keyword
- **Influencer discovery** — Find channels and creators relevant to your brand or industry
- **SEO and keyword research** — Analyze which YouTube keywords generate the most views and engagement
- **Academic research** — Collect YouTube search data for social media studies and media analysis
- **Ad placement research** — Identify high-performing content categories for YouTube advertising
- **Training data collection** — Build datasets of video metadata for machine learning models
- **Playlist curation** — Automatically find and organize videos by topic, duration, or popularity
- **Trend monitoring** — Schedule daily/weekly runs to track how search results change over time

### How much does it cost to scrape YouTube?

The YouTube Search Scraper uses [pay-per-event pricing](https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event). You are charged per result scraped — no compute fees on top.

| Event | Price per event | Price per 1,000 |
|-------|----------------|-----------------|
| `result-scraped` | $0.001 | **$1.00** |

Each result pushed to the dataset counts as one event. For example, scraping 500 YouTube search results costs $0.50.

**Cost examples:**

| Scenario | Results | Cost |
|----------|---------|------|
| Quick keyword research | 100 | $0.10 |
| Comprehensive topic analysis | 1,000 | $1.00 |
| Large-scale trend monitoring | 10,000 | $10.00 |

[Apify Free plan](https://apify.com/pricing) includes $5/month in platform credits — enough for 5,000 results per month at no cost.

### Integrations and API access

Use the YouTube Search Scraper programmatically via the [Apify API](https://docs.apify.com/api/v2), [JavaScript client](https://docs.apify.com/api/client/js), or [Python client](https://docs.apify.com/api/client/python).

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("parsebird/youtube-search-scraper").call(run_input={
    "query": "machine learning",
    "maxResults": 200,
    "type": "video",
    "sortBy": "popularity",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["viewCount"])
```

**JavaScript:**

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

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("parsebird/youtube-search-scraper").call({
    query: "machine learning",
    maxResults: 200,
    type: "video",
    sortBy: "popularity",
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => console.log(item.title, item.viewCount));
```

You can also connect the YouTube Search Scraper to [Google Sheets](https://apify.com/integrations/google-sheets), [Slack](https://apify.com/integrations/slack), [Zapier](https://apify.com/integrations/zapier), [Make](https://apify.com/integrations/make), [GitHub](https://apify.com/integrations/github), and other platforms via [Apify integrations](https://apify.com/integrations). Schedule runs [daily, weekly, or at any interval](https://docs.apify.com/platform/schedules) for automated YouTube data collection.

### Is it legal to scrape YouTube?

Scraping publicly available data from YouTube is generally considered legal based on the [2022 US appeals court ruling](https://blog.apify.com/is-web-scraping-legal/) in *hiQ Labs v. LinkedIn*. This actor only accesses publicly available search results — it does not log in, bypass authentication, or download copyrighted video content.

Always review [YouTube's Terms of Service](https://www.youtube.com/t/terms) and comply with applicable laws in your jurisdiction. For guidance, see [Apify's guide to web scraping legality](https://blog.apify.com/is-web-scraping-legal/).

### Other YouTube scrapers

Looking for more YouTube data? Check out these related actors on Apify:

- [YouTube Scraper](https://apify.com/bernardo/youtube-scraper) — Scrape YouTube video details, comments, and channel data
- [YouTube Channel Scraper](https://apify.com/streamers/youtube-channel-scraper) — Extract channel metadata, video lists, and subscriber counts
- [YouTube Transcript Scraper](https://apify.com/topaz_javon/youtube-transcript-scraper) — Download video transcripts and captions

### FAQ

**How many results can I scrape per run?**
The default is 100 results per run. You can increase `maxResults` to any number, or enable `scrapeAllResults` to paginate until YouTube stops returning results. YouTube typically returns up to a few hundred results per search query.

**How fast is the YouTube Search Scraper?**
Very fast — it uses YouTube's internal API directly, so there's no browser rendering overhead. A typical run of 100 results completes in under 30 seconds. The actor uses only 128–512 MB of memory.

**Can I filter by multiple video features at once?**
Yes. Enable multiple feature flags (HD, 4K, Subtitles, etc.) and they are combined with AND logic — only results matching all selected features are returned.

**Can I schedule recurring runs?**
Yes. Use [Apify's scheduling feature](https://docs.apify.com/platform/schedules) to run the scraper daily, weekly, or at any custom interval. Combine with [integrations](https://apify.com/integrations) to automatically send results to Google Sheets, Slack, or a webhook.

**What's the difference between this and the YouTube Data API?**
The YouTube Data API requires an API key, has strict daily quotas (10,000 units/day), and charges for additional usage. This scraper uses YouTube's internal API with no quotas and no API key needed. The output is comparable — titles, view counts, thumbnails, channel info, and more.

**Does this scraper download videos?**
No. This actor only extracts search result metadata (titles, URLs, view counts, etc.). It does not download, stream, or store any video content.

**What does the `raw` field contain?**
The `raw` field contains the full YouTube API response for each result. This includes additional data like badge info, thumbnail variants, and navigation endpoints that may be useful for advanced use cases.

**Can I use this with my AI assistant or MCP server?**
Yes. Copy the AI assistant block from the top of this page into ChatGPT, Claude, or Cursor. You can also use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) to connect this actor to any AI agent framework.

**Something isn't working. How do I get help?**
Open an issue in the [Issues tab](https://apify.com/parsebird/youtube-search-scraper/issues) on the actor page. Include your input configuration and any error messages.

# Actor input Schema

## `query` (type: `string`):

The keywords to search for on YouTube (e.g. 'python tutorial', 'cooking recipes', 'tech reviews').

## `maxResults` (type: `integer`):

Maximum number of results to return. Ignored if 'Scrape all available results' is enabled.

## `scrapeAllResults` (type: `boolean`):

Keep paginating until YouTube stops returning results. This may take a long time and produce a very large dataset.

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

Filter results by content type. Leave empty to return all types.

## `sortBy` (type: `string`):

How to sort the search results. Sorting is not available for Shorts.

## `duration` (type: `string`):

Filter videos by length. Only applies when searching for videos.

## `uploadDate` (type: `string`):

Restrict results to a specific time frame.

## `geo` (type: `string`):

2-letter ISO country code to get results relevant to a specific country (e.g. US, GB, IN, DE).

## `lang` (type: `string`):

Language code for results (e.g. en, es, fr, de, ja).

## `features` (type: `object`):

Toggle YouTube feature filters. Multiple features are combined with AND logic.

## `local` (type: `boolean`):

Request localized data from YouTube using the country and language settings above.

## Actor input object example

```json
{
  "query": "cats",
  "maxResults": 50,
  "scrapeAllResults": false,
  "sortBy": "relevance",
  "local": false
}
```

# Actor output Schema

## `dataset` (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 = {
    "query": "cats",
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/youtube-search-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "query": "cats",
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/youtube-search-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "cats",
  "maxResults": 50
}' |
apify call parsebird/youtube-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Search Scraper & API",
        "description": "Scrape YouTube search results — videos, channels, playlists, shorts, and movies. Filter by type, duration, upload date, sort order, and video features (HD, 4K, CC, Live). Get titles, view counts, thumbnails, channel info, and publish dates. Export as JSON, CSV, Excel.",
        "version": "1.0",
        "x-build-id": "E13gwMr63nVrW97s4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parsebird~youtube-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parsebird-youtube-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parsebird~youtube-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parsebird-youtube-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parsebird~youtube-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parsebird-youtube-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "The keywords to search for on YouTube (e.g. 'python tutorial', 'cooking recipes', 'tech reviews')."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of results to return. Ignored if 'Scrape all available results' is enabled.",
                        "default": 100
                    },
                    "scrapeAllResults": {
                        "title": "Scrape all available results",
                        "type": "boolean",
                        "description": "Keep paginating until YouTube stops returning results. This may take a long time and produce a very large dataset.",
                        "default": false
                    },
                    "type": {
                        "title": "Result Type",
                        "enum": [
                            "video",
                            "channel",
                            "playlist",
                            "movie",
                            "shorts"
                        ],
                        "type": "string",
                        "description": "Filter results by content type. Leave empty to return all types."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "popularity"
                        ],
                        "type": "string",
                        "description": "How to sort the search results. Sorting is not available for Shorts.",
                        "default": "relevance"
                    },
                    "duration": {
                        "title": "Video Duration",
                        "enum": [
                            "under3min",
                            "3to20min",
                            "over20min"
                        ],
                        "type": "string",
                        "description": "Filter videos by length. Only applies when searching for videos."
                    },
                    "uploadDate": {
                        "title": "Upload Date",
                        "enum": [
                            "today",
                            "week",
                            "month",
                            "year"
                        ],
                        "type": "string",
                        "description": "Restrict results to a specific time frame."
                    },
                    "geo": {
                        "title": "Country",
                        "pattern": "^[A-Z]{2}$",
                        "type": "string",
                        "description": "2-letter ISO country code to get results relevant to a specific country (e.g. US, GB, IN, DE)."
                    },
                    "lang": {
                        "title": "Language",
                        "pattern": "^[a-z]{2}$",
                        "type": "string",
                        "description": "Language code for results (e.g. en, es, fr, de, ja)."
                    },
                    "features": {
                        "title": "Video Features",
                        "type": "object",
                        "description": "Toggle YouTube feature filters. Multiple features are combined with AND logic.",
                        "properties": {
                            "360": {
                                "title": "360°",
                                "type": "boolean",
                                "description": "Only show 360° videos.",
                                "default": false,
                                "editor": "checkbox"
                            },
                            "HD": {
                                "title": "HD",
                                "type": "boolean",
                                "description": "Only show HD videos.",
                                "default": false,
                                "editor": "checkbox"
                            },
                            "subtitles": {
                                "title": "Subtitles/CC",
                                "type": "boolean",
                                "description": "Only show videos with subtitles or closed captions.",
                                "default": false,
                                "editor": "checkbox"
                            },
                            "CCommons": {
                                "title": "Creative Commons",
                                "type": "boolean",
                                "description": "Only show Creative Commons licensed videos.",
                                "default": false,
                                "editor": "checkbox"
                            },
                            "3D": {
                                "title": "3D",
                                "type": "boolean",
                                "description": "Only show 3D videos.",
                                "default": false,
                                "editor": "checkbox"
                            },
                            "Live": {
                                "title": "Live",
                                "type": "boolean",
                                "description": "Only show live videos.",
                                "default": false,
                                "editor": "checkbox"
                            },
                            "Purchased": {
                                "title": "Purchased",
                                "type": "boolean",
                                "description": "Only show purchased content.",
                                "default": false,
                                "editor": "checkbox"
                            },
                            "4K": {
                                "title": "4K",
                                "type": "boolean",
                                "description": "Only show 4K videos.",
                                "default": false,
                                "editor": "checkbox"
                            },
                            "Location": {
                                "title": "Location",
                                "type": "boolean",
                                "description": "Only show videos with location metadata.",
                                "default": false,
                                "editor": "checkbox"
                            },
                            "HDR": {
                                "title": "HDR",
                                "type": "boolean",
                                "description": "Only show HDR videos.",
                                "default": false,
                                "editor": "checkbox"
                            },
                            "VR180": {
                                "title": "VR180",
                                "type": "boolean",
                                "description": "Only show VR180 videos.",
                                "default": false,
                                "editor": "checkbox"
                            }
                        },
                        "additionalProperties": false
                    },
                    "local": {
                        "title": "Localized Results",
                        "type": "boolean",
                        "description": "Request localized data from YouTube using the country and language settings above.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```