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

Extract videos from YouTube channels, video URLs, or keyword searches. Choose basic data or full metadata with available transcripts, channel profiles, and links. Export JSON, CSV, or Excel with result-based pricing.

- **URL**: https://apify.com/newbs/youtube-channel.md
- **Developed by:** [Newbs](https://apify.com/newbs) (community)
- **Categories:** Social media, Videos
- **Features:** Limited permissions
- **Stats:** 3,130 total users, 46 monthly users, 98.6% runs succeeded, 82 bookmarks
- **User rating**: 4.33 out of 5 stars

## Pricing

from $0.45 / 1,000 direct video results

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## YouTube Channel Scraper

Collect videos from **YouTube channels, individual video URLs, or keyword searches**. Choose basic video data for fast, low-cost collection, or video details with available transcripts for research and analysis. Export results as JSON, CSV, or Excel, or use them through the Apify API.

### Quick start

1. Enter a channel handle such as `@adidas`, a channel URL, or a video URL.
2. Set **Videos per channel or search**. Start with 2 to check the output.
3. Choose **What to collect** using the table below.
4. For search phrases, turn on **Search by keyword**. Set a maximum run charge, then start the Actor.

| What to collect | Best for | What you receive |
| --- | --- | --- |
| **Basic video data** | Video lists, monitoring, and discovery | Title, URL, thumbnail, channel, and metrics available in the listing. No transcripts or proxy requests. |
| **Video details + transcripts** | Content research, summarization, and analysis | Video metadata, channel profiles and links, and available caption text. Automatically retries missing details or captions through proxy when needed. |
| **Use advanced settings** | Existing integrations and custom extraction | Manual control of details, proxy use, language, and transcript recovery. |

A direct video URL returns one video. In Basic mode, it returns the title, thumbnail, and author information exposed by YouTube; listing metrics are not available for an individual URL. Transcripts are YouTube caption text, not speech-to-text generated from audio. **No mode guarantees a transcript for every video.**

### Pricing

Each successful video is charged **once**, at the direct or proxy-assisted rate. The rates are never added together.

| Successful result | Free plan: per 1,000 | Paid plans: per 1,000 |
| --- | ---: | ---: |
| Direct extraction | $0.50 | $0.45 |
| Proxy-assisted extraction | $8.00 | $7.50 |

- **Basic video data** uses the direct rate and never uses proxies.
- **Video details + transcripts** starts directly. A video uses the proxy rate if its extraction, recovery attempts, or source collection actually used a proxy. The preset alone does not determine the rate.
- A successful metadata result remains chargeable when captions are missing, including after an unsuccessful proxy caption attempt.
- Failed or partial video rows and Shorts-only guidance rows are free.
- Pay-per-event prices include run platform usage. There is no additional start fee or rental charge. Post-run storage and dataset access follow Apify's terms. Historical rental runs retain their original billing terms.

For example, **900 direct results plus 100 proxy-assisted results cost $1.25 on the Free plan**, or **$1.155 on a paid plan**. Check the [Pricing tab](https://apify.com/newbs/youtube-channel/pricing) for the effective price and set the maximum run charge before starting. The Actor saves completed results and stops when the remaining allowance cannot cover the next result.

### Input examples

#### Get videos and transcripts from a channel

```json
{
  "channel": ["https://www.youtube.com/@adidas/videos"],
  "numberOfResults": 10,
  "scrapeMode": "transcripts"
}
```

#### Search for videos at the Basic price

```json
{
  "channel": ["running shoes", "summer fashion campaign"],
  "keywords": true,
  "numberOfResults": 25,
  "scrapeMode": "basic"
}
```

The limit applies to **each** channel or search entry. Repeated video IDs are deduplicated across the run, so the final total can be lower. For creator discovery, set **Max videos per channel** to 1 in the advanced search settings.

#### Get an individual video's details

```json
{
  "channel": ["https://www.youtube.com/watch?v=qRr0lmYvp5g"],
  "numberOfResults": 1,
  "scrapeMode": "transcripts"
}
```

Use public channels and regular videos. Playlist URLs and individual Shorts URLs are not supported. For Shorts, use the [YouTube Shorts Scraper](https://apify.com/newbs/youtube-shorts). A channel containing only Shorts returns a free guidance row.

### Output

Results appear while the run is processing. Open the **Overview**, **Basic results**, **Transcript**, or **Channel profile** dataset view, then export or access the dataset through the API.

| Data | Useful fields |
| --- | --- |
| Video identity | `id`, `videoUrl`, `title`, `coverImage` |
| Metadata and engagement | `description`, `publishedAt`, `duration`, `viewCount`, `likeCount`, `commentCount` |
| Channel profile | `channelName`, `channelUrl`, `subscriberCount`, `channelDescription` |
| Channel links | `channelLinks` for structured links; `channelLinksText` for spreadsheets |
| Captions | `transcript`, `transcriptLanguage`, `transcriptStatus`, `transcriptMessage` |
| Result quality and pricing | `scrapingStatus`, `collectionMode`, `detailsStatus`, `proxyUsed`, `sourceProxyUsed` |

Fields that YouTube does not expose remain `null`. Basic mode intentionally leaves full-detail and transcript fields empty. A missing comment count, social link, or caption does not mean the video row failed. `proxyUsed` identifies proxy-priced rows; `proxyRequestCount` counts per-video attempts and excludes shared source collection requests.

A shortened illustrative result:

```json
{
  "id": "qRr0lmYvp5g",
  "videoUrl": "https://www.youtube.com/watch?v=qRr0lmYvp5g",
  "title": "Example video title",
  "collectionMode": "full",
  "scrapingStatus": "success",
  "transcript": "Caption text supplied by YouTube...",
  "transcriptStatus": "available",
  "transcriptMessage": "Transcript available.",
  "proxyUsed": true
}
```

### Missing transcripts and incomplete results

Start with **`transcriptMessage`** for a plain-language explanation. Common cases:

| Status or reason | Meaning / next step |
| --- | --- |
| `not_requested` | Basic mode was selected. Choose Video details + transcripts if captions matter. |
| `no_caption_tracks` | The checked YouTube responses exposed no tracks. This does not prove the video has no captions. |
| `caption_fetch_failed` | Tracks were found, but their text could not be downloaded. |
| `retry_limit` | Custom Standard mode reached its retry cap. Select Video details + transcripts for recovery on every eligible video. |
| `video_limit` / `proxy_limit` | Recovery reached a work or proxy limit. Existing data is retained. |
| `spending_limit` | The remaining charge allowance could not cover proxy recovery. |
| `no_recovery_yield` | Repeated attempts returned no captions, so further recovery stopped. |

Recovery is bounded to control cost and runtime: per-video work has a 45-second active budget, 60 requests, and 12 proxy requests, plus shared proxy allowances. Temporary direct source connection failures receive one retry. These safeguards can leave some captions unavailable.

Open **Run summary and source diagnostics** in the run's Output, or read the key-value store record **`OUTPUT`**, for caption coverage, source errors grouped by code (`sourceErrorCounts`), retry counters, saved/billed counts, and failure details. Good sources continue when another source fails. Valid empty channels finish normally; genuine failures to collect or extract any usable video remain visible as failed runs.

### Advanced settings and compatibility

Most users can leave both Advanced sections closed. Language/country hints and parallelism settings are optional; leave concurrency at its default unless troubleshooting.

The Basic and Video details + transcripts presets override conflicting custom extraction fields. Choose **Use advanced settings** to control `needVideoDetails`, `proxyMode`, `transcriptMode`, or custom proxy configuration yourself.

**Existing saved tasks and API inputs without `scrapeMode` keep their earlier behavior.** Select `"scrapeMode": "transcripts"` explicitly to use the improved recovery. Custom Standard mode has an automatic recovery cap of up to 80 videos on larger runs; the transcript preset attempts every eligible missing caption within the safeguards above.

### Help and integrations

Use the Actor with scheduled Apify tasks, the API, Make, Zapier, or your own data pipeline. Typical uses include competitor monitoring, creator discovery, video catalogs, and caption-based search or summarization.

If results are unexpected, [open an issue](https://apify.com/newbs/youtube-channel/issues) and include a shared run link, the selected mode, one affected channel/video, and what you expected. The run log and `OUTPUT` diagnostics help distinguish invalid input, unavailable content, YouTube blocking, and work limits.

Only collect data you are authorized to access and use it in accordance with applicable terms and laws.

# Changelog

This Actor's version history is a separate document: https://apify.com/newbs/youtube-channel/changelog.md

# Actor input Schema

## `channel` (type: `array`):

Add public channel handles or URLs, regular video URLs, or search terms. Turn on Search by keyword when every entry is a search query. Basic mode also accepts video URLs and returns their title, thumbnail, and author. Playlist and individual Shorts URLs are not supported.

## `numberOfResults` (type: `integer`):

Maximum videos to collect from each entry. A direct video URL returns one video.

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

Video details + transcripts automatically retries missing captions with residential proxy. Successful direct results cost $0.50/1,000; proxy-assisted results cost $8/1,000 instead, even if captions remain unavailable. Basic returns listing data without transcripts or proxy, at $0.50/1,000. Paid-plan discounts apply. Choose advanced settings only to customize recovery. A missing transcript has an explanation in transcriptMessage.

## `keywords` (type: `boolean`):

Turn on to search every entry, including single words. Leave off for channel handles and video URLs.

## `maxVideosPerChannel` (type: `integer`):

Applies to explicit and automatically detected keyword searches. Limits how many videos from the same YouTube channel are returned for each keyword. Leave empty for no per-channel limit. Set 1 for creator discovery use cases.

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

YouTube hl parameter. Examples: en, fr, de, es, ja.

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

YouTube gl parameter. Examples: US, GB, FR, DE, JP.

## `maxVideoDetailConcurrency` (type: `integer`):

Maximum videos processed in parallel. Default 20; memory pressure can temporarily reduce it. Lower this only when troubleshooting.

## `maxChannelConcurrency` (type: `integer`):

How many channel or keyword inputs to collect in parallel. Higher values can improve multi-input runs but can increase YouTube throttling risk.

## `needVideoDetails` (type: `boolean`):

Enabled: collect full metadata and available transcripts. Disabled: return faster basic listing results (URL, title, thumbnail, channel and visible listing metrics). Details-only fields remain null, with collectionMode=basic and detailsStatus=not_requested. See the Basic results dataset view.

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

Auto starts video extraction directly and uses proxy for blocked details or transcript recovery. Successful direct video results cost $0.50 per 1,000; results whose video requests or source collection use proxy cost $8 per 1,000 instead. All run platform usage is included in these result prices. Never disables proxy completely and keeps successful results at the direct rate. Always proxies collection and details. Captions are best effort in every mode. Recovery stops when its run-wide request or transfer allowance is exhausted or repeated attempts produce no usable results; see the run summary.

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

Limited recovery controls cost with an automatic retry cap. Recover every missing transcript attempts recovery for each eligible video, within spending, proxy-transfer, and per-video limits. YouTube may not expose captions for every video.

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

Auto starts each video directly. Proxy-first uses proxy for per-video requests and therefore uses the proxy-assisted result price. Proxy-backed source collection also makes its results proxy-assisted. Captions are not guaranteed.

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

Optional Apify Proxy settings. Leave empty with Auto mode unless you need custom proxy groups or country settings for fallback or Always mode.

## `uniqueChannels` (type: `boolean`):

Applies to explicit and automatically detected keyword searches. Keep at most one result from each YouTube channel per keyword, and deduplicate repeated video URLs across the run.

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

HTTP language preferences sent with each request, for example en-US,en;q=0.9. This nudges YouTube localization but does not guarantee localized results.

## `fastVideoDetailConcurrency` (type: `integer`):

Maximum videos processed in parallel, up to 20. Lower values are respected. Memory pressure temporarily reduces active concurrency without cancelling in-flight work. Default memory is 1,024 MB; 512 MB remains supported. Proxy requests share a separate limit of 2. Fast HTTP detail concurrency takes precedence when both fields are supplied.

## `adaptiveTranscriptProxyFallback` (type: `boolean`):

In standard mode, retry missing captions when coverage is poor, including a bounded early sample on large runs. Successful videos with actual proxy requests use the proxy-assisted result price. Disable this to avoid transcript-only proxy upgrades; choose Never use proxy to disable all proxy requests.

## `adaptiveTranscriptMaxRetries` (type: `integer`):

Maximum missing-transcript rows retried by adaptive recovery in standard mode. Leave empty for automatic caps: all rows for small runs, and up to 80 round-robin rows for larger runs. Lower it when runtime and proxy cost matter more than transcript coverage.

## `adaptiveTranscriptRetryConcurrency` (type: `integer`):

How many videos adaptive caption recovery processes in parallel. Defaults to 8 to overlap lightweight player requests, direct caption downloads, and dataset writes. The shared proxy limit remains 2 requests; increasing queued jobs beyond the default can delay results.

## `residentialFallbackForMissingTranscripts` (type: `boolean`):

Compatibility option. Prefer Transcript mode = Aggressive. When enabled, videos that still miss transcripts after direct caption extraction are retried with Apify residential proxy.

## `streamDatasetItems` (type: `boolean`):

Write completed rows while the run is still processing instead of waiting until the end. Keep enabled for larger runs so partial progress is preserved if a run times out.

## `resetCheckpoint` (type: `boolean`):

Accepted for compatibility. Existing saved video IDs are always restored after a migration or restart to prevent duplicate results and charges. Start a new run for a fresh dataset.

## `maxContinuationPages` (type: `integer`):

Limit continuation requests per channel or keyword. Set 0 to read only the initial results page. Omit for an automatic limit based on numberOfResults (maximum 60).

## Actor input object example

```json
{
  "channel": [
    "https://www.youtube.com/@adidas/videos"
  ],
  "numberOfResults": 2,
  "scrapeMode": "transcripts",
  "keywords": false,
  "localeHl": "en",
  "localeGl": "US",
  "maxChannelConcurrency": 2,
  "needVideoDetails": true,
  "proxyMode": "auto",
  "transcriptMode": "standard",
  "videoDetailProxyStrategy": "auto"
}
```

# Actor output Schema

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

Full dataset items returned by the actor.

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

Dataset view optimized for checking the main video, transcript, transcript status, channel links, and metric fields.

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

Dataset view focused on channel About data, outbound links, profile images, and channel metrics.

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

Dataset view focused on transcript text, transcript status, source, and language.

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

Run status, first-result timings, overlapping stage activity, bounded queue counters, last progress, saved/billed counts, proxy recovery limits, source failures, and sanitized error details. Updated during the run and finalized on handled failure.

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

Listing fields, collection mode, and details status. Useful when full details are disabled.

# 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 = {
    "channel": [
        "https://www.youtube.com/@adidas/videos"
    ],
    "numberOfResults": 2,
    "scrapeMode": "transcripts",
    "localeHl": "en",
    "localeGl": "US",
    "maxChannelConcurrency": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("newbs/youtube-channel").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 = {
    "channel": ["https://www.youtube.com/@adidas/videos"],
    "numberOfResults": 2,
    "scrapeMode": "transcripts",
    "localeHl": "en",
    "localeGl": "US",
    "maxChannelConcurrency": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("newbs/youtube-channel").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 '{
  "channel": [
    "https://www.youtube.com/@adidas/videos"
  ],
  "numberOfResults": 2,
  "scrapeMode": "transcripts",
  "localeHl": "en",
  "localeGl": "US",
  "maxChannelConcurrency": 2
}' |
apify call newbs/youtube-channel --silent --output-dataset

```

## MCP server setup

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

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/GujXNenR4UqabbHLh/builds/V6zZHcmiMHhayypMd/openapi.json