# YouTube Channel Scraper (`scraptivo/youtube-channel-scraper`) Actor

Scrape video, Shorts, and community post metadata from YouTube channels. Supports multiple channel URLs with per-channel limits — no video downloads.

- **URL**: https://apify.com/scraptivo/youtube-channel-scraper.md
- **Developed by:** [Scraptivo](https://apify.com/scraptivo) (community)
- **Categories:** Social media, Videos, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.70 / 1,000 user videos

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Channel Scraper** collects video, Shorts, and community post metadata from YouTube channels and turns it into structured data for content research, competitor monitoring, and influencer analytics. Provide one or more channel URLs, then export titles, descriptions, view and like counts, durations, upload dates, tags, and thumbnails to JSON, CSV, or Excel. It needs no YouTube API key and performs no video downloads. Pricing starts at $3 per 1,000 items.

### What can you automate with YouTube Channel Scraper?

- **Track every upload from any channel** — pull the catalog of regular videos, Shorts, and community posts from one or many channels in a single run.
- **Benchmark competitor content** — compare view counts, like counts, upload cadence, and content mix across rival channels.
- **Identify trending creators** — extract engagement metrics per video to shortlist high-performing creators for partnerships.
- **Build structured content databases** — export titles, descriptions, tags, categories, and URLs for research or training datasets.
- **Monitor channel activity** — schedule recurring runs to capture new uploads as they publish.
- **Scrape only what you need** — set separate limits for videos, Shorts, and posts per channel, plus a global cap.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| Content & growth teams | Study formats, topics, and lengths that perform best in any niche. |
| Marketing & brand agencies | Monitor competitor channels and measure campaign impact. |
| Influencer & sponsorship teams | Vet creators by real engagement data before outreach. |
| Researchers & data teams | Assemble video metadata datasets for analysis or model training. |

### What data can you collect from YouTube?

| Data group | Example fields | How it helps |
|---|---|---|
| Content identity | `title`, `id`, `url`, `description`, `contentType` | Identify each video, Short, or post. |
| Engagement | `viewCount`, `likeCount`, `commentCount` | Measure performance and audience response. |
| Channel & publishing | `channelName`, `channelId`, `channelUrl`, `publishedAt`, `uploadDate` | Attribute content and track cadence. |
| Metadata & status | `durationSeconds`, `tags`, `categories`, `isLive`, `wasLive`, `availability`, `ageLimit`, `language`, `subtitleLanguages` | Enrich records with format and access details. |

### How to use YouTube Channel Scraper

1. Open the actor in your Apify console.
2. Paste one or more YouTube channel URLs (`@handle`, `/channel/ID`, `/c/name`, or `/user/name`).
3. Set how many videos, Shorts, and community posts to scrape per channel.
4. Run the actor.
5. Export the dataset to JSON, CSV, or Excel, or read it through the API.

```json
{
  "channelUrls": ["https://www.youtube.com/@TED"],
  "maxVideos": 50,
  "maxShorts": 10,
  "maxPosts": 5,
  "maxItems": 0,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Example workflow

#### Track competitor uploads weekly

1. List your competitor channels in `channelUrls` every Monday.
2. Keep new videos and Shorts published since the last run.
3. Compare view and like counts to spot top-performing topics.
4. Key on the `id` field when merging runs to avoid duplicates.

### Automate and integrate your results

Schedule runs from the Scheduler tab — daily for fast-moving channels, weekly for catalog snapshots. Attach a webhook to trigger a downstream pipeline on completion, and export to Google Sheets, Make, Zapier, Slack, or a database. For recurring pipelines, call the actor through the Apify API:

```shell
curl -X POST "https://api.apify.com/v2/acts/scraptivo/youtube-channel-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"channelUrls": ["https://www.youtube.com/@TED"], "maxVideos": 50}'
```

Within a run the actor deduplicates content automatically; across runs, deduplicate on the `id` field.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---:|---|---|
| `channelUrls` | array | Yes | — | One or more channel URLs; `/videos` or `/shorts` paths are normalized. |
| `maxVideos` | integer | No | `50` | Regular videos per channel from the Videos tab (0 = skip). |
| `maxShorts` | integer | No | `0` | Shorts per channel from the Shorts tab (0 = skip). |
| `maxPosts` | integer | No | `0` | Community posts per channel (0 = skip). |
| `maxItems` | integer | No | `0` | Hard cap on total records across all channels (0 = unlimited). |
| `maxConcurrency` | integer | No | `3` | Parallel metadata fetches (1–10). |
| `proxyConfiguration` | object | No | residential | Proxy settings for anti-bot protection. |

#### Which limits should I set?

At least one of `maxVideos`, `maxShorts`, or `maxPosts` must be above 0 or the run stops with an error. Set only the content types you need — for example `maxVideos: 50` and leave Shorts and posts at 0.

### Output example

```json
{
  "id": "6YNOQTqNfgQ",
  "url": "https://www.youtube.com/watch?v=6YNOQTqNfgQ",
  "title": "Save It to Your Desktop! | Alan Resnick | TED",
  "contentType": "video",
  "channelName": "TED",
  "channelId": "UCAuUUnT6oDeKwE6v1NGQxug",
  "durationSeconds": 634,
  "durationString": "10:34",
  "viewCount": 11981,
  "likeCount": 399,
  "commentCount": 61,
  "publishedAt": "2026-08-07",
  "tags": ["TEDTalk", "TED"],
  "categories": ["People & Blogs"],
  "isLive": false,
  "availability": "public",
  "language": "en"
}
```

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

The actor bills per item: **$3 per 1,000 items**, with Apify plan discounts applied automatically — Bronze $2.90, Silver $2.80, and Gold $2.70 per 1,000. Every video, Short, or community post written to the dataset counts as one item. A run of 1,000 items costs $3; 50,000 items cost $150 before plan discounts. Use `maxItems` to hard-cap the total. Compute and residential proxy usage are billed separately by Apify and offset by your plan's free monthly units.

### Reliability and responsible use

The actor defaults to Apify residential proxies and retries failed item extraction automatically. Some fields are nullable — very old or deleted videos may return partial metadata such as a missing `commentCount`. It scrapes publicly visible channel data only and downloads no media. You are responsible for complying with YouTube's terms and applicable laws when storing or using the data.

### Frequently asked questions

#### Which channel URL formats are accepted?

Any standard format works: `@handle`, `/channel/ID`, `/c/name`, and `/user/name`. Tab URLs like `/videos` or `/shorts` are normalized to the channel root.

#### Why did my run fail with "Nothing to scrape"?

All three content limits are zero. Set at least one of `maxVideos`, `maxShorts`, or `maxPosts` above 0.

#### What counts as one billable item?

Each record in the dataset — a video, Short, or community post — is one item, billed at $3 per 1,000.

#### Does this actor download the videos?

No. It extracts metadata only, which keeps runs fast and cheap.

#### Why are some results empty or partial?

YouTube can throttle datacenter traffic. Lower `maxConcurrency` to 1–3, keep residential proxies enabled, and retry — the actor already retries failed items before reporting them.

#### Can I scrape community posts too?

Yes. Set `maxPosts` above 0 to pull posts from each channel's Posts/Community tab; posts are labeled `contentType: "post"`.

### Related Scraptivo automations

- **[Instagram Post Scraper](https://apify.com/scraptivo/instagram-post-scraper)** — collect Instagram posts and engagement data.
- **[TikTok Creator Analytics](https://apify.com/scraptivo/tiktok-creator-analytics)** — pull TikTok creator stats and content metrics.
- **[Instagram Comment Scraper](https://apify.com/scraptivo/instagram-comment-scraper)** — gather comment data for social research.

### Support and custom workflows

Need a different field, source, or delivery workflow? Contact Scraptivo at scraptivo@gmail.com. Include the Actor name, a sample channel URL, required fields, and expected volume so we can assess the request.

# Actor input Schema

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

One or more YouTube channel URLs (@handle, /channel/ID, /c/name, or /user/name). Trailing tab paths like /videos or /shorts are accepted and normalized.

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

Maximum regular videos to scrape from each channel's Videos tab. Set to 0 to skip videos.

## `maxShorts` (type: `integer`):

Maximum Shorts to scrape from each channel's Shorts tab. Set to 0 to skip Shorts.

## `maxPosts` (type: `integer`):

Maximum community posts to scrape from each channel's Posts/Community tab. Set to 0 to skip posts.

## `maxItems` (type: `integer`):

Hard cap on total records across all channels and content types (0 = unlimited).

## `maxConcurrency` (type: `integer`):

How many items to fetch metadata for at the same time. Higher values are faster but use more resources.

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

Proxy settings for anti-bot protection

## Actor input object example

```json
{
  "channelUrls": [
    "https://www.youtube.com/@TED"
  ],
  "maxVideos": 10,
  "maxShorts": 5,
  "maxPosts": 0,
  "maxItems": 0,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing scraped YouTube channel video, Shorts, and post metadata

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

Aggregate statistics for the scrape run

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "channelUrls": [
        "https://www.youtube.com/@TED"
    ],
    "maxVideos": 10,
    "maxShorts": 5,
    "maxPosts": 0,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraptivo/youtube-channel-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 = {
    "channelUrls": ["https://www.youtube.com/@TED"],
    "maxVideos": 10,
    "maxShorts": 5,
    "maxPosts": 0,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "channelUrls": [
    "https://www.youtube.com/@TED"
  ],
  "maxVideos": 10,
  "maxShorts": 5,
  "maxPosts": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraptivo/youtube-channel-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraptivo/youtube-channel-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/EiyMkG8kP36Z5qTng/builds/4GZf1tt1YQiIBcoGO/openapi.json