# Youtube AIO Scraper (`scrapesmith/youtube-aio-scraper`) Actor

⚡ YouTube AIO Scraper – Extract video titles, views, likes, comments & channel data from any channel, playlist, search query or direct URL. No API key needed. Export to JSON, CSV or Excel. $0.50/1,000 results. Free plan: 100 results.

- **URL**: https://apify.com/scrapesmith/youtube-aio-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (community)
- **Categories:** Automation, Social media, Marketing
- **Stats:** 360 total users, 28 monthly users, 99.8% runs succeeded, 14 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## YouTube Scraper - Extract Videos from Channels, Playlists, Search & Direct URLs

**Scrape YouTube video data at scale. Extract titles, views, likes, comments, descriptions, thumbnails, channel info, and more from any channel, playlist, search query, or direct video URL - no API key required. Just $0.50 per 1,000 results.**

Whether you need to bulk scrape YouTube videos, extract YouTube channel data for competitor analysis, or build a YouTube dataset for research, this tool delivers clean structured results with no API quotas.

---

### ?? What Is the YouTube Scraper?

The **YouTube Scraper** is a fast, reliable, and affordable Apify Actor that extracts public video data from YouTube using four flexible input methods: **channel URLs**, **playlist URLs**, **search keywords**, and **direct video URLs**. Whether you need a handful of videos or tens of thousands, this YouTube data extraction tool delivers clean, structured results ready for immediate use.

Looking to **scrape YouTube without an API key**? This tool bypasses YouTube Data API quotas entirely - no Google account, no developer credentials, no rate limits. Need a **YouTube video scraper for research or automation**? Just paste your inputs and get your data.

No API key. No login. No quotas. Just enter your input and get your data.

---

### ? Why Use This YouTube Scraper?

- ?? **Unbeatable price** - only **$0.50 per 1,000 results**
- ?? **Four input methods** - channels, playlists, search queries, and direct video URLs in a single tool
- ? **Fast & reliable** - handles large channels and long playlists efficiently
- ?? **No API key required** - bypasses YouTube Data API quotas and restrictions entirely
- ?? **Bulk input support** - add multiple channels, playlists, keywords, or URLs in one run
- ?? **Multiple export formats** - JSON, CSV, XML, Excel, HTML, JSONL
- ?? **Easy integrations** - works with Make.com, Zapier, n8n, Google Sheets, and more
- ?? **AI-ready output** - plug directly into LLM pipelines, LangChain, or any automation workflow

---

### ?? What Data Does It Extract?

For every video scraped, you receive:

| Field | Description |
|---|---|
| `video_id` | Unique YouTube video ID |
| `title` | Full video title |
| `views` | Total number of views |
| `likes` | Total number of likes |
| `comments` | Total number of comments |
| `comments_turned_off` | Whether comments are disabled on the video |
| `duration` | Video duration in HH:MM format |
| `date_posted` | Date the video was published |
| `subscribers` | Subscriber count of the channel at time of scrape |
| `channel_name` | Name of the YouTube channel |
| `channel_id` | Unique ID of the channel |
| `channel_url` | Direct URL to the channel |
| `video_url` | Direct URL to the video |
| `description` | Full video description text |
| `thumbnail` | URL of the video thumbnail image |
| `source_input` | The search term, channel, playlist, or URL used as input |

---

### ?? How to Use the YouTube Scraper

Getting started takes under a minute:

1. **Create a free Apify account** - new accounts get $5 in free monthly credits
2. **Open the YouTube Scraper** in the Apify Store
3. **Choose your input type** - channel URL, playlist URL, search keyword, or direct video URL
4. **Enter your inputs** and set the maximum number of results per input
5. **Click "Save & Start"** and wait for the run to complete
6. **Download your data** in JSON, CSV, Excel, XML, or HTML

You can mix input types in a single run - for example, scrape two channels, a playlist, and a keyword search all at once.

---

### ?? Four Ways to Scrape YouTube

#### ?? By Channel URL
Scrape all videos from any public YouTube channel. Get full video metadata, engagement data, and subscriber counts. Perfect for auditing a channel or tracking a competitor.

Use the `channelUrls` field:
````

https://www.youtube.com/@mkbhd
https://www.youtube.com/channel/UCXuqSBlHAE6Xw-yeJA0Tunw

```

#### ?? By Playlist URL
Extract every video from any public playlist, in order. Great for research collections, course content, or curated series.

Use the `playlistUrls` field:
```

https://www.youtube.com/playlist?list=PLxxxxxxxxxxxxxxxx

```

#### ?? By Search Term
Scrape YouTube search results for any keyword or phrase. Returns the top videos ranked by YouTube for that query - ideal for trend research and competitor keyword analysis.

Use the `searchTerms` field:
```

best running shoes 2025
how to learn python

```

#### ?? By Direct Video URL
Scrape one or more specific videos by URL. Get complete metadata, engagement stats, and channel info for each video provided.

Use the `videoUrls` field:
```

https://www.youtube.com/watch?v=xxxxxxxxxxx

````

---

### ?? Sample Input

```json
{
  "maxVideosPerQuery": 10,
  "searchTerms": [
    "pubg"
  ],
  "searchUrls": [],
  "channelUrls": [],
  "playlistUrls": [],
  "videoUrls": []
}
````

***

### ?? Sample Output

```json
{
  "video_id": "dS4VfYZFSjI",
  "title": "PUBG PC : Erangle High Kill Solo Squads WIN Gameplay (No Commentary)",
  "views": 31041,
  "likes": 639,
  "comments": 22,
  "comments_turned_off": false,
  "duration": "24:14",
  "date_posted": "Mar 4, 2026",
  "subscribers": 98600,
  "channel_name": "PUBG BOX",
  "channel_id": "UCibWZzkjMuzaYd0epLLjRpA",
  "channel_url": "https://www.youtube.com/channel/UCibWZzkjMuzaYd0epLLjRpA",
  "video_url": "https://www.youtube.com/watch?v=dS4VfYZFSjI",
  "description": "17 Kills - P90 & Kar98 Sniper Gameplay - Intense Ending - Erangel 2...",
  "thumbnail": "https://i.ytimg.com/vi/dS4VfYZFSjI/hqdefault.jpg",
  "source_input": "pubg"
}
```

***

### ?? Pricing

This Actor uses **pay-per-result (PPR) pricing** - you only pay for the data you actually receive.

| Volume | Cost |
|---|---|
| 1,000 videos | $0.50 |
| 10,000 videos | $5.00 |
| 100,000 videos | $50.00 |
| 1,000,000 videos | $500.00 |

> ?? **New to Apify?** Every free account includes **$5 in monthly credits**. Note: free accounts are limited to **100 results per run** on this Actor. Upgrade to a paid plan to unlock full scraping capacity.

***

### ?? Who Is This For?

#### ?? Content Creators & YouTubers

Analyse what's working in your niche. Scrape top-performing videos in your category, study their titles, descriptions, tags, and publishing patterns to sharpen your own content strategy.

#### ?? Data Analysts & Researchers

Build YouTube datasets for trend analysis, NLP research, sentiment modeling, or academic study. Get clean, structured data ready for direct import into Python, R, or any BI tool.

#### ?? Digital Marketing Agencies & SEO Teams

Track competitor video performance, monitor keyword rankings in YouTube search, benchmark channel growth, and report on engagement metrics - all automated and at scale.

#### ??? Developers & Engineers

Integrate YouTube data into your pipelines via the Apify API or SDK. Schedule daily channel snapshots, trigger runs via webhooks, and push results to any database or storage bucket.

#### ?? AI & Automation Builders

Feed YouTube video metadata and descriptions into LLM workflows, recommendation systems, or knowledge bases. The structured output requires zero preprocessing before ingestion.

#### ?? Academic & Market Researchers

Study viral content patterns, track platform trends, map influencer networks, or collect evidence for media studies. Scrape at scale without hitting API quotas or rate limits.

***

### ?? Use Cases

- **Competitor research** - analyse the full video catalogue of any competitor channel
- **Keyword & SEO research** - discover which titles, tags, and topics rank on YouTube search
- **Influencer vetting** - evaluate a creator's content volume, consistency, and engagement rates
- **Trend detection** - identify rising topics and viral content before they peak
- **Content auditing** - export and review an entire channel's catalogue in one run
- **Playlist analysis** - extract and study curated video collections or course content
- **Market research** - understand consumer interests by analysing what videos people watch
- **Lead generation** - find creators and businesses in your niche via channel data
- **Brand monitoring** - track mentions of your brand or product across YouTube search results
- **Academic research** - collect large-scale video datasets for media studies and cultural analysis

***

### ?? Integrations & Automation

Connect the YouTube Scraper with your favourite tools:

- ?? **Make.com (Integromat)** - automate scheduled YouTube data exports and trigger workflows
- ? **Zapier** - push video data to Google Sheets, Slack, Notion, Airtable, or your CRM
- ?? **n8n** - build no-code pipelines that process YouTube data automatically
- ?? **Google Sheets** - export results directly to spreadsheets for quick analysis and sharing
- ?? **Webhooks** - receive instant notifications when a scraper run finishes

***

### ?? How Does the YouTube Scraper Compare to Alternatives?

| Method | Cost | Scale | No API Key | No-Code |
|---|---|---|---|---|
| **This Scraper** | $0.50/1k | Unlimited | ? | ? |
| YouTube Data API | Free (quota limited) | Very limited | ? | ? |
| Manual copy-paste | Free | Very low | ? | ? |
| Browser extensions | Varies | Limited | ? | ? |
| Custom-built scraper | Dev time | Varies | Varies | ? |

***

### ?? Tips for Best Results

- **Mix input types in one run** - combine channel URLs, keywords, and direct video URLs to maximize data collection efficiency.
- **Use search terms for trend research** - scraping YouTube search results for a keyword shows you exactly what YouTube ranks for that topic.
- **Set a reasonable limit per input** - for large channels with 1,000+ videos, start with a smaller limit to test before running at full scale.
- **Schedule daily runs** to track how channel metrics change over time - useful for monitoring competitor growth.
- **Export to CSV** for spreadsheet analysis; use JSON for API pipelines and automation workflows.
- **For very large jobs**, split inputs across multiple runs or use Apify's scheduling feature for incremental updates.

***

### ? Frequently Asked Questions

**Do I need a YouTube API key to use this?**
No. The YouTube Scraper works independently of the official YouTube Data API. You do not need a Google account, API key, or any credentials.

**Can I scrape multiple channels, playlists, or keywords at once?**
Yes. You can add as many input URLs or search keywords as you need in a single run. Mix channels, playlists, keywords, and direct video URLs all in one go.

**Does it scrape YouTube Shorts and live streams?**
Yes. The scraper extracts all public video types including regular videos, Shorts, and live stream recordings, with content type indicated in the output.

**What formats can I export the data in?**
You can download results as JSON, JSONL, CSV, XML, Excel (.xlsx), or HTML. Data is also accessible programmatically via the Apify API.

**How many results can I get per run?**
There is no hard cap on results - you can scrape as many videos as you need. Simply set your desired limit and the scraper will run until it reaches it or exhausts the available content.

**Does this scraper collect private data?**
No. It only collects publicly available video and channel data. It does not access private videos, user accounts, email addresses, watch histories, or any non-public information.

**Is scraping YouTube legal?**
This scraper collects only publicly available data, consistent with what any regular visitor to YouTube can see. Always ensure your use of scraped data complies with YouTube's Terms of Service, applicable data protection laws (e.g. GDPR, CCPA), and Apify's Terms of Service.

**Can I schedule this scraper to run automatically?**
Yes. You can schedule any Apify Actor to run at custom intervals - hourly, daily, weekly, or on a custom cron schedule - directly from the Apify Console.

**Can I use this YouTube scraper for free?**
Yes. Every new Apify account receives $5 in free monthly credits. Free accounts are limited to 100 results per run. Upgrade to a paid plan for unlimited scraping.

**How do I scrape YouTube videos without an API key or coding?**
Open this Actor in Apify Store, enter your channel URLs, search keywords, or video URLs, set your limit, and click Start. No API key or coding required.

**What if a channel or playlist is very large?**
The scraper handles large channels and playlists efficiently. For very large jobs (100,000+ videos), we recommend splitting inputs across multiple runs or using Apify's scheduling feature to run incremental updates.

**I found a bug or want to request a feature. What should I do?**
Please open a ticket in the **Issues tab** of this Actor on Apify Console. We actively review and respond to all submissions.

***

### ?? Related Actors

Looking for more YouTube data tools? Check these out:

- ?? **YouTube Comments Scraper** - extract comments, replies, likes, and author data from any video
- ?? **YouTube Transcript Scraper** - download full video transcripts and subtitles in any language
- ?? **YouTube Channel Scraper** - deep-dive into channel-level statistics and growth metrics
- ?? **YouTube Search Scraper** - scrape search result rankings by keyword with filters and sorting
- ?? **YouTube Playlist Scraper** - extract every video from a playlist with full metadata

***

### ?? Support

Need help? Here's how to reach us:

- ?? Open an issue in the **Issues tab** of this Actor on Apify Console
- ?? Browse the [Apify Documentation](https://docs.apify.com) for platform guides
- ?? Join the [Apify Discord Community](https://discord.gg/apify) for tips, feedback, and support

***

## *? YouTube Scraper - Extract video data from channels, playlists, search results, and direct URLs. No API key. No quotas. Just results.*

### YouTube Scraper vs Other Methods

| Feature | YouTube Scraper | Manual Copy-Paste | Browser Extensions | Official API |
|---------|-------------|-------------------|-------------------|-------------|
| Bulk extraction | Unlimited | One at a time | Limited | Rate-limited |
| No login needed | Yes | Yes | Often required | Key required |
| API access | REST API + SDKs | No | No | Yes |
| Export formats | CSV, JSON, Excel, XML | None | CSV only | JSON only |
| Scheduling | Automated (cron) | Manual | Manual | Manual |
| Cost | $0.50/1k results | Free but slow | $20-50/month | Free + limits |
| Proxy handling | Built-in | N/A | N/A | N/A |

***

### Tips for Best Results with YouTube Scraper

- **Start small** — test with a small batch first to verify the output matches your needs before running large jobs
- **Use Bulk Edit** — paste hundreds of URLs or inputs at once instead of adding them one by one
- **Schedule regular runs** — set up automated daily or weekly scrapes to keep your dataset fresh
- **Export to Google Sheets** — use the built-in Google Sheets integration for easy sharing and analysis
- **Combine with other scrapers** — pair this tool with other Instagram, YouTube, or social media scrapers for a complete dataset

***

**Can I use YouTube Scraper for free?**
Yes. Every new Apify account gets $5 in free monthly credits. Free accounts are limited to 100 results per run on this Actor. Upgrade to any paid plan to remove the limit.

**How to scrape YouTube videos without coding?**
Just paste your URLs or search terms into the input form, click Start, and download the results. No code, no terminal, no technical skills required. You can also use the REST API or Python/Node.js SDKs if you prefer to code.

**Is there a YouTube videos API?**
Yes. This Actor provides a full REST API. You can trigger runs, check status, and download results programmatically from any language. See the API tab on this Actor's page for endpoints and examples.

**How much does it cost to scrape YouTube videos?**
Pricing is pay-per-result at $0.50 per 1,000 results. You only pay for the data you receive. There are no monthly subscriptions or hidden fees. Free accounts get $5/month in credits.

**Can I integrate YouTube videos scraping into my workflow?**
Yes. This Actor integrates with Make.com, Zapier, n8n, Google Sheets, webhooks, and any REST API client. You can automate YouTube videos extraction as part of any data pipeline.

# Actor input Schema

## `searchTerms` (type: `array`):

Enter search terms to find videos on YouTube (To get more than 600 use extenders like cnn 2025, cnn latest, cnn realtime)

## `maxVideosPerQuery` (type: `integer`):

Maximum number of videos to scrape per search term, channel, or playlist (does not apply to direct video URLs)

## `searchUrls` (type: `array`):

Enter complete YouTube search result URLs (To get more than 600 use extenders like cnn 2025, cnn latest, cnn realtime)

## `channelUrls` (type: `array`):

Enter YouTube channel URLs. Add /videos or /shorts to specify content type.

## `playlistUrls` (type: `array`):

Enter YouTube playlist URLs

## `videoUrls` (type: `array`):

Enter direct YouTube video URLs to scrape individual videos

## Actor input object example

```json
{
  "searchTerms": [
    "cooking"
  ],
  "maxVideosPerQuery": 100,
  "searchUrls": [],
  "channelUrls": [],
  "playlistUrls": [],
  "videoUrls": []
}
```

# 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 = {
    "searchTerms": [
        "cooking"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/youtube-aio-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 = { "searchTerms": ["cooking"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube AIO Scraper",
        "description": "⚡ YouTube AIO Scraper – Extract video titles, views, likes, comments & channel data from any channel, playlist, search query or direct URL. No API key needed. Export to JSON, CSV or Excel. $0.50/1,000 results. Free plan: 100 results.",
        "version": "0.0",
        "x-build-id": "vUhqhURJCwHdFGgeF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~youtube-aio-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-youtube-aio-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/scrapesmith~youtube-aio-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-youtube-aio-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/scrapesmith~youtube-aio-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-youtube-aio-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": {
                    "searchTerms": {
                        "title": "Search Terms (Youtube returns only 500-600 per search term)",
                        "type": "array",
                        "description": "Enter search terms to find videos on YouTube (To get more than 600 use extenders like cnn 2025, cnn latest, cnn realtime)",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideosPerQuery": {
                        "title": "Maximum Videos Per Input",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of videos to scrape per search term, channel, or playlist (does not apply to direct video URLs)",
                        "default": 100
                    },
                    "searchUrls": {
                        "title": "Search URLs (Youtube returns only 500-600 per search url)",
                        "type": "array",
                        "description": "Enter complete YouTube search result URLs (To get more than 600 use extenders like cnn 2025, cnn latest, cnn realtime)",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "channelUrls": {
                        "title": "Channel URLs (Add /videos to scrape regular videos OR /shorts to scrape shorts.)",
                        "type": "array",
                        "description": "Enter YouTube channel URLs. Add /videos or /shorts to specify content type.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "playlistUrls": {
                        "title": "Playlist URLs",
                        "type": "array",
                        "description": "Enter YouTube playlist URLs",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "videoUrls": {
                        "title": "Direct Video URLs",
                        "type": "array",
                        "description": "Enter direct YouTube video URLs to scrape individual videos",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
