# Youtube Scraper (Free) (`scrapesmith/youtube-scraper-free`)

⚡ All in One Free Fast & Affordable YouTube scraper – Extract video titles, views, likes, comments, channels & more from searches, playlists, or channels. No proxies needed. Get 1000 videos in <15 min for free for a limited time. (Approximate platform usage is $0.3/1000 results)

- **URL**: https://beta-securitybyobscurity.apify.com/scrapesmith/youtube-scraper-free.md
- **Developed by:** [Scrape Smith](https://beta-securitybyobscurity.apify.com/scrapesmith) (community)
- **Categories:** Automation, Videos
- **Stats:** 27 total users, 27 monthly users, 88.9% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

# README

## 🎥 YouTube Video Scraper - Fast Data Extraction Tool 2025

🚀 **The fastest YouTube scraping solution: Extract 1000 videos in under 15 minutes for just $0.50**

***

### ⚡ Key Features & Benefits

#### ⚡ Lightning-Fast YouTube Video Data Extraction

- ⏱️ **Extract 1000 YouTube videos in under 15 minutes** - Industry-leading speed
- 🛡️ **No proxy servers required** - Built-in stealth technology eliminates proxy costs
- ⚙️ **Concurrent video processing** - Advanced async architecture maximizes throughput
- 🔎 **Real-time content filtering** - Smart algorithms reduce unnecessary processing time
- 🎬 **YouTube Shorts filtering** - Advanced detection and filtering capabilities

#### 💰 Most Cost-Effective YouTube Scraper

- 💵 **$0.50 per 1000 YouTube videos** - Unbeatable pricing in 2025
- ❌ **Zero proxy fees** - No additional costs for IP rotation or residential proxies
- 🧾 **No hidden charges** - Transparent pricing with no surprises
- 🎯 **Pay per result** - Efficient processing reduces compute costs

#### 📦 Complete YouTube Video Data Extraction

Extract comprehensive YouTube metadata including:

- 📝 Video titles, descriptions, and duration
- 👀 YouTube view count, 👍 like count, 💬 comment count
- 👤 Channel information and subscriber count
- 📅 Publication dates and high-quality thumbnails
- 🎯 Advanced YouTube search filtering options
- ✂️ YouTube Shorts detection and filtering

***

### 💵 YouTube Scraper Pricing 2025

| 🎬 YouTube Videos | 💰 Cost | ⏱️ Processing Time |
| ----------------- | ------- | ------------------ |
| 100 videos        | $0.05  | < 2 minutes        |
| 500 videos        | $0.25  | < 8 minutes        |
| 1000 videos       | $0.50  | < 15 minutes       |
| 5000 videos       | $2.50  | < 60 minutes       |
| 10000 videos      | $5.00  | < 2 hours          |

***

### 🌟 Why Choose Our YouTube Scraper in 2025?

#### ❌ No Expensive Proxy Services Required

- 💸 Traditional scrapers need $10–50/month proxies
- 🛡️ Our stealth tech removes this cost entirely

#### ⚡ Unmatched YouTube Scraping Speed

- 🔧 Optimized request patterns
- ⚙️ Intelligent concurrency
- 🔄 Smart retry mechanisms
- ⏱️ Minimal delays

#### 🏢 Enterprise-Grade YouTube Data Extraction

- 🛡️ Rate limiting compliance
- 🔁 Automatic error recovery
- 📊 Comprehensive scraping logs
- ☁️ Apify platform integration
- 📡 Real-time progress tracking

#### ⚡ Instant YouTube Data Access

- 📥 Videos processed & saved instantly
- 📊 Real-time visibility into extraction progress

***

### 🔒 Support & Reliability

- 📜 Detailed logs
- 🐞 Debug mode available
- 🔄 Auto error recovery
- 📈 Performance monitoring
- 🌍 24/7 availability

***

### ✅ Compliance & Ethics

- 📜 Respects YouTube terms
- 📊 Rate limit compliance
- 🌐 Public data only
- 🔒 No personal data

***

✨ **Start extracting YouTube data today: $0.50 per 1000 videos, no proxy costs, results in under 15 minutes!**

🔑 *Keywords: YouTube scraper, YouTube data extraction, YouTube API alternative, YouTube video scraper, YouTube channel scraper, YouTube metadata extractor, YouTube analytics tool 2025*

# Actor input Schema

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

Search term to find YouTube videos (e.g., 'python tutorial')

## `startUrls` (type: `array`):

Direct YouTube URLs (videos, channels, playlists)

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

Maximum number of videos to scrape per search query or URL

## `maxDatasetResults` (type: `integer`):

Global limit for total results saved to dataset (hard cap: 5000)

## `includeShorts` (type: `boolean`):

Include YouTube Shorts (videos under 90 seconds)

## `includeLive` (type: `boolean`):

Include live streaming videos

## `proxy` (type: `object`):

Proxy settings for requests

## Actor input object example

```json
{
  "searchQuery": "Apify Actors",
  "maxResults": 10,
  "maxDatasetResults": 1000,
  "includeShorts": false,
  "includeLive": false,
  "proxy": {
    "useApifyProxy": 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 = {
    "searchQuery": "Apify Actors",
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/youtube-scraper-free").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 = {
    "searchQuery": "Apify Actors",
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/youtube-scraper-free").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 '{
  "searchQuery": "Apify Actors",
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call scrapesmith/youtube-scraper-free --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Scraper (Free)",
        "description": "⚡ All in One Free Fast & Affordable YouTube scraper – Extract video titles, views, likes, comments, channels & more from searches, playlists, or channels. No proxies needed. Get 1000 videos in <15 min for free for a limited time. (Approximate platform usage is $0.3/1000 results)",
        "version": "0.0",
        "x-build-id": "c9gKTkGp9DFnGslki"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~youtube-scraper-free/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-youtube-scraper-free",
                "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-scraper-free/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-youtube-scraper-free",
                "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-scraper-free/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-youtube-scraper-free",
                "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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term to find YouTube videos (e.g., 'python tutorial')"
                    },
                    "startUrls": {
                        "title": "Direct URLs",
                        "type": "array",
                        "description": "Direct YouTube URLs (videos, channels, playlists)",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum Videos Per Query/URL",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of videos to scrape per search query or URL",
                        "default": 10
                    },
                    "maxDatasetResults": {
                        "title": "Maximum Total Dataset Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Global limit for total results saved to dataset (hard cap: 5000)",
                        "default": 1000
                    },
                    "includeShorts": {
                        "title": "Include Shorts",
                        "type": "boolean",
                        "description": "Include YouTube Shorts (videos under 90 seconds)",
                        "default": false
                    },
                    "includeLive": {
                        "title": "Include Live Streams",
                        "type": "boolean",
                        "description": "Include live streaming videos",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for requests"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
