# Youtube Search Scraper (`scrapapi/youtube-search-scraper`) Actor

Scrape YouTube search results at scale. Extract video titles, URLs, views, channel names, upload dates, thumbnails, and more directly from YouTube search pages. Ideal for market research, trend analysis, competitor tracking, and building video datasets.

- **URL**: https://apify.com/scrapapi/youtube-search-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

Scale your YouTube research with the Youtube Search Scraper — a fast, reliable YouTube search results scraper for videos and channels. It helps marketers, developers, data analysts, and researchers scrape YouTube search results without manual browsing, returning clean, flat JSON that’s easy to work with. As a YouTube SERP scraper and YouTube search API alternative, it’s built for trend analysis, competitor tracking, and creating high-quality video datasets at scale. 🚀

### What data / output can you get?

Below are real output fields pushed to the dataset when you scrape YouTube search results or provide direct video/channel URLs.

| Data type | Description | Example value |
| --- | --- | --- |
| type | Record type ("video", "channel", "error", "info") | "video" |
| title | Video title | "Secret Fact" |
| url | Canonical video or channel URL | "https://www.youtube.com/watch?v=bhWoNS6ZSHk" |
| id | Video ID | "bhWoNS6ZSHk" |
| date | Publish date in ISO UTC (where available) | "2024-11-19T00:00:00Z" |
| duration | Video duration (hh:mm:ss or m:ss) | "0:52" |
| viewCount | Video views (integer) | 36334432 |
| likes | Video likes (integer) | 2206496 |
| commentsCount | Number of comments (integer) | 10000 |
| commentsTurnedOff | Whether comments are disabled | false |
| channelName | Channel display name | "The Graham Norton Show" |
| channelUsername | Channel handle (if detected) | "@OfficialGrahamNorton" |
| channelUrl | Canonical channel URL (prefer handle) | "http://www.youtube.com/@OfficialGrahamNorton" |
| channelId | Channel ID | "UC4PziMH5MvvsmqM0VCZTy-g" |
| numberOfSubscribers | Channel subscriber count (if available) | 5470000 |
| channelViewCount | Channel total views (integer if parsed) | 4788755834 |
| channelVideoCount | Channel total videos (integer if parsed) | 2451 |
| thumbnailUrl | Video thumbnail URL | "https://i.ytimg.com/vi/f5ksIepT2mE/hq720.jpg" |
| text | First 500 chars of description (if available) | "Remember this next time you watch #TheGrinch!..." |
| hashtags | Hashtags detected in description (max 5) | ["#TheGrinch", "#GrahamNortonShow"] |
| keywords | Top tags (max 5, >3 chars, excluding "yt:") | ["Graham Norton", "The Graham Norton Show"] |
| input | The original search query or URL that produced the item | "python programming" |
| order | Result index per query (0-based) | 0 |

Notes:
- When you paste a channel URL, the scraper also outputs “channel” records with fields like description, joined, country, subscribers, views, videos, canonicalChannelUrl, channelUsername, channelId, inputUrl, aboutUrl, and links.
- Datasets can be exported to JSON, CSV, or Excel for analysis and reporting.

### Key features

- 💾 Live save to dataset  
  Results are written as they’re scraped. If the run stops early, everything collected so far is safely stored.

- 🛡️ Residential proxy with smart retries  
  The scraper starts in RESIDENTIAL mode and retries up to 3 times with rotated proxies to overcome YouTube blocks and bot detection.

- 🔍 Keyword and URL inputs  
  Search by keywords to scrape YouTube search results, or paste full video/channel URLs to extract direct records. Perfect for a YouTube search results extractor and YouTube channel search scraper workflow.

- 🔢 Sortable results (relevance/date/views/rating)  
  Control ordering with sortBy for precise YouTube search ranking scraper needs.

- ⚡ Batch processing and concurrency  
  Parallel collection with batch execution accelerates large jobs and makes it a robust YouTube search scraping tool for scale.

- 🧾 Flat, analytics-ready JSON  
  Clean, flat fields make it a reliable YouTube search results parser. Easily export YouTube search results to CSV/Excel for BI dashboards.

- 🧠 Channel About extraction (when URL is a channel)  
  Provide a channel URL to get structured About data including country, joined date, subscriber text, view and video counts.

- 🧰 Developer-friendly on Apify  
  Runs reliably in production with the Apify platform. Fetch results via the Apify API and plug into your pipeline as a YouTube search API alternative.

### How to use Youtube Search Scraper - step by step

1) Sign up or log in to Apify  
Create a free Apify account to run the actor in the cloud.

2) Open the actor in the Apify Store  
Search for “Youtube Search Scraper” and click Try for free.

3) Add your input  
In the queries field, add one or more search queries or YouTube URLs (one per line). For example:  
- “python programming”  
- “best cooking channels”  
- “https://www.youtube.com/watch?v=VIDEO_ID”  
- “https://www.youtube.com/@ChannelHandle”

4) Configure options  
Adjust maxResults and sortBy. You can also set uploadDate, duration, type, enable a proxy in proxyConfiguration, or toggle debug for verbose logs.

5) Start the run  
Click Start. The job searches YouTube and streams results to the default dataset in near real time.

6) Monitor progress  
Logs show retries, proxy usage, and collection progress (e.g., [x/y] collected). Errors or empty result info are also recorded to the dataset.

7) Export your data  
Open the dataset and export to JSON, CSV, or Excel. Use it for analytics, dashboards, and downstream workflows.

Pro tip: Paste a channel URL into queries to collect a structured “channel” record. This is useful when you need a focused YouTube channel search scraper output alongside video results.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research and trend tracking | Track topics, categories, and creators by collecting search results at scale. Use the YouTube search results scraper to quantify interest and momentum. |
| Competitor benchmarking | Compare view, like, and comment counts across competing videos to inform strategy with a YouTube search results extractor. |
| Content planning | Identify high-performing formats and keywords to plan videos using a YouTube keyword search scraper workflow. |
| Data journalism & research | Build datasets of videos and channels for longitudinal analysis and reporting, exporting YouTube search results to CSV for reproducibility. |
| Brand and channel monitoring | Pull fresh results around branded terms and channels to monitor activity and performance without the official API. |
| SEO and SERP analysis | Use the YouTube SERP scraper behavior to study ranking, sorting, and surface-level engagement signals (views, likes, comments). |
| API pipelines | Integrate the dataset into ETL pipelines as a YouTube search API alternative; fetch via Apify API post-run. |

### Why choose Youtube Search Scraper?

The scraper focuses on precision, reliability, and production-grade scale — purpose-built for automation and analytics.

- ✅ Accurate, flat JSON designed for dashboards and data pipelines
- ⚡ Fast batch collection with parallel execution for large jobs
- 🔒 Robust proxy handling (RESIDENTIAL with retries) to reduce blocks
- 🧩 Developer-ready on Apify; fetch results programmatically
- 🧪 Sort control (relevance/date/views/rating) for consistent testing
- 💾 Streamed “live save” results — never lose partial progress
- 🛠️ Better than browser extensions or unstable scripts — runs server-side, repeatable, and observable

In short: a production-ready YouTube search scraping tool you can trust for scale.

### Is it legal / ethical to use Youtube Search Scraper?

Yes — when used responsibly. This actor processes publicly available YouTube pages and returns structured metadata. You are responsible for ensuring that your usage complies with YouTube’s Terms of Service and applicable laws (e.g., GDPR, CCPA).  
Guidelines:
- Only collect publicly available content
- Avoid scraping private, unlisted, or restricted content
- Respect platform terms and applicable data regulations
- Verify compliance with your legal team for edge cases

### Input parameters & output format

Example input
```json
{
  "queries": [
    "python programming",
    "https://www.youtube.com/@OfficialGrahamNorton"
  ],
  "maxResults": 10,
  "sortBy": "relevance",
  "uploadDate": "",
  "duration": "",
  "type": "video",
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "debug": false
}
````

Parameters

- queries (array of string)\
  One search query or URL per line. Examples: « python programming », « best cooking channels », or a full URL like https://www.youtube.com/watch?v=... or https://www.youtube.com/@ChannelName. Mix keywords and URLs in the same run.\
  Default: \["python programming"] — Required: no

- maxResults (integer)\
  Maximum number of results to fetch for each query (1–2000). Higher values mean more data but longer runs. Default 10 is good for quick tests.\
  Default: 10 — Required: no

- sortBy (string; enum: relevance, date, viewCount, rating)\
  How YouTube results are ordered. Same options as YouTube’s sort dropdown.\
  Default: "relevance" — Required: no

- uploadDate (string; enum: "", lastHour, today, thisWeek, thisMonth, thisYear)\
  Restrict results to a time window. Leave “None” (empty string) for no date filter.\
  Default: "" — Required: no

- duration (string; enum: "", short, medium, long)\
  Only include videos in a length range: Short (<4 min), Medium (4–20 min), or Long (>20 min). Leave “None” (empty string) for any duration.\
  Default: "" — Required: no

- type (string; enum: video, channel, playlist, movie)\
  Type of results to return. Use “video” for standard search results.\
  Default: "video" — Required: no

- proxyConfiguration (object)\
  Optional proxy settings. Leave empty for no proxy; the actor starts in RESIDENTIAL mode to improve reliability on YouTube.\
  Default: none — Required: no

- debug (boolean)\
  Turn on for extra log output (requests, retries, proxy switches).\
  Default: false — Required: no

Example output

Video record

```json
{
  "title": "Our Respect For Jim Carrey After Hearing This! #Shorts",
  "type": "video",
  "channelName": "The Graham Norton Show",
  "date": "2022-12-15T00:00:00Z",
  "text": "Remember this next time you watch #TheGrinch!...",
  "thumbnailUrl": "https://i.ytimg.com/vi/f5ksIepT2mE/hq720.jpg",
  "order": 0,
  "input": "python programming",
  "hashtags": ["#TheGrinch", "#GrahamNortonShow"],
  "channelId": "UC4PziMH5MvvsmqM0VCZTy-g",
  "channelUrl": "http://www.youtube.com/@OfficialGrahamNorton",
  "channelUsername": "@OfficialGrahamNorton",
  "numberOfSubscribers": 5470000,
  "channelViewCount": 4788755834,
  "channelVideoCount": 2451,
  "hiddenSubscriberCount": false,
  "id": "f5ksIepT2mE",
  "url": "https://www.youtube.com/watch?v=f5ksIepT2mE",
  "viewCount": 36334432,
  "likes": 2206496,
  "commentsCount": 10000,
  "commentsTurnedOff": false,
  "duration": "0:52",
  "keywords": ["Graham Norton", "The Graham Norton Show"],
  "isMembersOnly": false
}
```

Channel record (when input is a channel URL)

```json
{
  "type": "channel",
  "url": "https://www.youtube.com/@OfficialGrahamNorton",
  "description": "Official channel description...",
  "joined": "Jan 1, 2010",
  "country": "Not specified",
  "subscribers": "N/A",
  "views": "N/A",
  "videos": "N/A",
  "canonicalChannelUrl": "http://www.youtube.com/@OfficialGrahamNorton",
  "channelUsername": "@OfficialGrahamNorton",
  "channelId": "UC4PziMH5MvvsmqM0VCZTy-g",
  "links": [],
  "inputUrl": "https://www.youtube.com/@OfficialGrahamNorton",
  "aboutUrl": "https://www.youtube.com/@OfficialGrahamNorton/about"
}
```

Also present:

- Error records: {"type": "error", "error": "..."} and optionally url/input
- Info records: {"type": "info", "input": "...", "message": "No results"}

### FAQ

#### Is this a YouTube search API alternative?

Yes. It scrapes public YouTube search results and returns structured JSON, making it a practical YouTube search API alternative for many workflows.

#### Do I need to log in or provide cookies?

No. The actor runs without login by default. It can operate without cookies, and it handles YouTube access via robust residential proxies and retries.

#### How many results can I scrape per query?

You can set maxResults from 1 to 2000 per query. The scraper processes results in batches with concurrency to speed up large collections.

#### Can I sort the results like on YouTube?

Yes. Use sortBy to order by relevance, date, viewCount, or rating — just like the YouTube UI. This is useful for YouTube search ranking scraper experiments.

#### Does it handle channels as well as videos?

Yes. If you provide a channel URL in queries, the actor outputs a “channel” record with About-page metadata (e.g., description, joined, country, and canonical channel URL).

#### What fields are included in the output?

Video records include title, url, id, date, duration, viewCount, likes, commentsCount, commentsTurnedOff, channelName, channelUsername, channelUrl, channelId, numberOfSubscribers, channelViewCount, channelVideoCount, thumbnailUrl, text, hashtags, keywords, input, order, and isMembersOnly.

#### Can I export YouTube search results to CSV or Excel?

Yes. After the run, open the dataset and export results to JSON, CSV, or Excel. This makes it a simple YouTube search results to CSV workflow.

#### Is there a free trial and what’s the pricing?

A trial is available (120 trial minutes). The current plan is a flat price per month: $19.99. You can start testing the actor on Apify and scale as needed.

### Closing CTA / Final thoughts

The Youtube Search Scraper is built for fast, reliable collection of YouTube search results and channel/video metadata at scale. With live-save output, residential proxy reliability, and flat JSON, it’s ideal for marketers, developers, analysts, and researchers. Use it as a YouTube search results scraper to power dashboards, automate pipelines via the Apify API, and export to CSV/Excel for reporting. Start extracting smarter — and turn YouTube SERPs into actionable data today.

# Actor input Schema

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

📝 One search query or URL per line. Examples: « python programming », « best cooking channels », or a full URL like https://www.youtube.com/watch?v=... or https://www.youtube.com/@ChannelName. Mix keywords and URLs in the same run.

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

📈 Maximum number of results to fetch for each query (1–2000). Higher values mean more data but longer runs. Default 10 is good for quick tests.

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

🔀 How YouTube results are ordered: by relevance, upload date, view count, or rating. Same options you’d see on YouTube’s sort dropdown.

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

📆 Restrict results to videos uploaded in this time window: last hour, today, this week, month, or year. Leave « None » for no date filter.

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

⏱️ Only include videos in this length range: Short (<4 min), Medium (4–20 min), or Long (>20 min). Leave « None » to allow any duration.

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

🎬 Type of results to return: Video, Channel, Playlist, or Movie. Use « Video » for standard search results.

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

🌐 No proxy by default. If YouTube blocks the run, the actor automatically switches to RESIDENTIAL proxy. You can also set a custom proxy here (e.g. Apify proxy) if you prefer.

## `debug` (type: `boolean`):

🐛 Turn on for extra log output (requests, retries, proxy switches). Useful for troubleshooting; leave off for normal runs.

## Actor input object example

```json
{
  "queries": [
    "python programming"
  ],
  "maxResults": 10,
  "sortBy": "relevance",
  "uploadDate": "",
  "duration": "",
  "type": "video",
  "debug": false
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "queries": [
        "python programming"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/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 = { "queries": ["python programming"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapapi/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 '{
  "queries": [
    "python programming"
  ]
}' |
apify call scrapapi/youtube-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Search Scraper",
        "description": "Scrape YouTube search results at scale. Extract video titles, URLs, views, channel names, upload dates, thumbnails, and more directly from YouTube search pages. Ideal for market research, trend analysis, competitor tracking, and building video datasets.",
        "version": "0.2",
        "x-build-id": "BUpARXTROnGXN5Ffz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~youtube-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~youtube-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~youtube-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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",
                "properties": {
                    "queries": {
                        "title": "🔎 Search queries",
                        "type": "array",
                        "description": "📝 One search query or URL per line. Examples: « python programming », « best cooking channels », or a full URL like https://www.youtube.com/watch?v=... or https://www.youtube.com/@ChannelName. Mix keywords and URLs in the same run.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "python programming"
                        ]
                    },
                    "maxResults": {
                        "title": "📊 Max results per query",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "📈 Maximum number of results to fetch for each query (1–2000). Higher values mean more data but longer runs. Default 10 is good for quick tests.",
                        "default": 10
                    },
                    "sortBy": {
                        "title": "↕️ Sort by",
                        "enum": [
                            "relevance",
                            "date",
                            "viewCount",
                            "rating"
                        ],
                        "type": "string",
                        "description": "🔀 How YouTube results are ordered: by relevance, upload date, view count, or rating. Same options you’d see on YouTube’s sort dropdown.",
                        "default": "relevance"
                    },
                    "uploadDate": {
                        "title": "📅 Upload date filter",
                        "enum": [
                            "",
                            "lastHour",
                            "today",
                            "thisWeek",
                            "thisMonth",
                            "thisYear"
                        ],
                        "type": "string",
                        "description": "📆 Restrict results to videos uploaded in this time window: last hour, today, this week, month, or year. Leave « None » for no date filter.",
                        "default": ""
                    },
                    "duration": {
                        "title": "⏱️ Duration filter",
                        "enum": [
                            "",
                            "short",
                            "medium",
                            "long"
                        ],
                        "type": "string",
                        "description": "⏱️ Only include videos in this length range: Short (<4 min), Medium (4–20 min), or Long (>20 min). Leave « None » to allow any duration.",
                        "default": ""
                    },
                    "type": {
                        "title": "📺 Search type",
                        "enum": [
                            "video",
                            "channel",
                            "playlist",
                            "movie"
                        ],
                        "type": "string",
                        "description": "🎬 Type of results to return: Video, Channel, Playlist, or Movie. Use « Video » for standard search results.",
                        "default": "video"
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy (optional)",
                        "type": "object",
                        "description": "🌐 No proxy by default. If YouTube blocks the run, the actor automatically switches to RESIDENTIAL proxy. You can also set a custom proxy here (e.g. Apify proxy) if you prefer."
                    },
                    "debug": {
                        "title": "🐛 Verbose logging",
                        "type": "boolean",
                        "description": "🐛 Turn on for extra log output (requests, retries, proxy switches). Useful for troubleshooting; leave off for normal runs.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
