YouTube Channel Videos Scraper

Collect public YouTube channel videos into a clean dataset for publishing analysis, creator research, competitor monitoring, and scheduled data pipelines.

Give the Actor one or more channel handles, channel IDs, or channel URLs. It resolves each channel, follows YouTube continuation pages, and returns one typed record per video with identity, title, URL, thumbnail, publication text, view text, duration, and channel identity.

What does YouTube Channel Videos Scraper do?

The Actor reads the public Videos tab of each supplied YouTube channel.

It can:

• accept @handles, UC... channel IDs, and normal YouTube channel URLs;
• collect several channels in one run;
• continue beyond the first page of videos;
• cap results globally and per channel;
• stop when it reaches an already-seen video ID;
• deduplicate video IDs within each channel;
• export records through Apify datasets as JSON, CSV, Excel, XML, or RSS;
• run manually, through the API, from an Apify Schedule, or through MCP.

It does not download video or audio files. It returns public listing metadata.

Who is it for?

Publishing and content teams

Track uploads from partner, publisher, or competitor channels and send new records to an editorial spreadsheet.

Creator economy analysts

Build channel-level video inventories for format, cadence, title, and view-count analysis.

Competitive intelligence teams

Schedule recurring runs and use stopAtVideoId as a checkpoint so each run returns only newer uploads.

Data engineers

Feed stable video and channel IDs into a warehouse, enrichment job, transcript workflow, or dashboard.

Developers and AI agents

Call the Actor through the Apify API or MCP instead of maintaining YouTube pagination and normalization code.

Why use this Actor?

• Channel-focused input: supply the channels you already care about rather than a broad search query.
• Continuation pagination: collect more than the small recent set exposed by YouTube's Atom feed.
• Monitoring checkpoint: stop before a known video instead of downloading older history on every scheduled run.
• Typed output: receive consistent fields instead of raw YouTube response objects.
• Low-overhead route: the Actor uses logged-out structured responses and does not launch a browser.
• Integration-ready: every video is stored in the run's default dataset.

YouTube changes its public interfaces over time. See Limitations for realistic boundaries.

What data can I extract?

Field	Type	Meaning
channelInput	string	The handle, ID, or URL supplied in the input
channelId	string	Stable YouTube UC... channel ID
channelName	string	Public channel display name
channelUrl	string	Canonical channel URL
videoId	string	Stable YouTube video ID
title	string	Video title shown on the channel Videos tab
url	string	Canonical watch URL
thumbnailUrl	string or null	Best available public thumbnail URL
publishedTimeText	string or null	Relative publication label, such as 2 days ago
viewCountText	string or null	Public localized view label
viewCount	integer or null	Parsed compact view count when available
durationText	string or null	Displayed video duration
scrapedAt	ISO timestamp	Time the record was collected

Nullable fields may be absent from YouTube for scheduled, live, restricted, or specially rendered content.

How to scrape YouTube channel videos

1. Open the Actor in Apify Console.
2. Add one or more values to YouTube channels.
3. Choose the total maxItems limit.
4. Choose maxVideosPerChannel if channels should receive equal caps.
5. Optionally add stopAtVideoId for an incremental monitoring run.
6. Click Start.
7. Open Dataset to preview or export the records.

A useful first run is:

{
  "channels": ["@GoogleDevelopers", "@Apify"],
  "maxItems": 12,
  "maxVideosPerChannel": 6
}

Input parameters

channels

Required array with 1–50 public YouTube channels.

Supported forms include:

@GoogleDevelopers
GoogleDevelopers
UC_x5XG1OV2P6uZZ5FSM9Ttw
https://www.youtube.com/@GoogleDevelopers/videos
https://www.youtube.com/channel/UC_x5XG1OV2P6uZZ5FSM9Ttw

Playlist, search, watch, and non-YouTube URLs are not channel inputs.

maxItems

Maximum records saved across all channels.

• default: 100
• minimum: 1
• maximum: 10000

Channels are processed in input order. When the global limit is reached, later channels are not requested.

maxVideosPerChannel

Maximum records saved for one channel.

• default: 100
• minimum: 1
• maximum: 10000

Use this limit to balance a multi-channel collection.

stopAtVideoId

Optional checkpoint for recurring runs.

The Actor reads newest videos first. It saves videos until it encounters this ID, then stops that channel before saving the checkpoint or any older items.

Store the newest videoId from a successful run and pass it into the next scheduled run.

Output example

A current record has this shape:

{
  "channelInput": "@GoogleDevelopers",
  "channelId": "UC_x5XG1OV2P6uZZ5FSM9Ttw",
  "channelName": "Google for Developers",
  "channelUrl": "https://www.youtube.com/channel/UC_x5XG1OV2P6uZZ5FSM9Ttw",
  "videoId": "-rYFDefcq3k",
  "title": "Introducing Gemini Robotics 2",
  "url": "https://www.youtube.com/watch?v=-rYFDefcq3k",
  "thumbnailUrl": "https://i.ytimg.com/vi/-rYFDefcq3k/hqdefault.jpg",
  "publishedTimeText": "1 day ago",
  "viewCountText": "7.4K views",
  "viewCount": 7400,
  "durationText": "39:14",
  "scrapedAt": "2026-08-02T04:55:00.000Z"
}

Titles, counts, and relative publication labels naturally change as YouTube updates them.

How much does it cost to scrape YouTube channel videos?

The Actor uses pay-per-event pricing:

• a $0.00005 one-time start event per run;
• a tiered video event for every record saved;
• current BRONZE video price: $0.00048 per video.

At the current BRONZE tier, example Actor charges are approximately:

Saved videos	BRONZE charge calculation
10	10 × $0.00048 video event + $0.00005 start event
100	100 × $0.00048 video event + $0.00005 start event
1,000	1,000 × $0.00048 video event + $0.00005 start event

Higher-volume pricing tiers reduce the per-video price. Your Apify plan also governs platform usage and spending limits. The Actor never charges a video event for a duplicate, rejected, or unsaved record.

Monitor new channel uploads on a schedule

A practical incremental workflow is:

1. Run without stopAtVideoId and store the first returned videoId per channel.
2. Create an Apify Schedule for the desired interval.
3. On the next run, pass the previous newest ID as stopAtVideoId.
4. Send the resulting dataset to your webhook, spreadsheet, or database.
5. Replace the checkpoint with the new first record.

Example:

{
  "channels": ["@GoogleDevelopers"],
  "maxItems": 20,
  "maxVideosPerChannel": 20,
  "stopAtVideoId": "iOK1-b_9Dlg"
}

The Actor returns only records newer than the checkpoint when that ID is still present in the traversed listing.

Export videos to a spreadsheet or pipeline

After a run, use the Dataset Export menu to download JSON, CSV, Excel, XML, or RSS.

For an automated pipeline, read the dataset through the API:

https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json

Good stable keys are:

• videoId for video upserts;
• channelId for channel joins;
• scrapedAt for collection history.

Relative fields such as publishedTimeText should not be treated as exact publication timestamps.

API usage

Use the API patterns below to run the Actor from cURL, JavaScript, or Python and then read its default dataset.

Use the Actor with cURL

Start a run and wait for it to finish:

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~youtube-channel-videos-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "channels": ["@GoogleDevelopers"],
    "maxItems": 10,
    "maxVideosPerChannel": 10
  }'

Keep API tokens in environment variables or a secret manager.

Use the Actor with JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/youtube-channel-videos-scraper').call({
  channels: ['@GoogleDevelopers', '@Apify'],
  maxItems: 20,
  maxVideosPerChannel: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map(({ videoId, title, channelName }) => ({ videoId, title, channelName })));

Use the Actor with Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/youtube-channel-videos-scraper').call(run_input={
    'channels': ['@GoogleDevelopers'],
    'maxItems': 25,
    'maxVideosPerChannel': 25,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
for item in items:
    print(item['channelName'], item['title'], item['url'])

Use the Actor through MCP

Add the Apify MCP server to Claude Code:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/youtube-channel-videos-scraper"

Claude Desktop, Cursor, and VS Code setup

Use this equivalent JSON configuration in Claude Desktop, Cursor, or VS Code:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/youtube-channel-videos-scraper"
    }
  }
}

Example prompts:

• “Collect the 20 newest videos from @GoogleDevelopers and summarize the recurring topics.”
• “Run the YouTube Channel Videos Scraper for these five channel URLs and save at most 10 records per channel.”
• “Return videos newer than checkpoint iOK1-b_9Dlg from @GoogleDevelopers.”

Tips for reliable runs

• Prefer stable UC... channel IDs when a channel may rename its handle.
• Start with small limits while testing a new list of channels.
• Use both global and per-channel limits for predictable multi-channel runs.
• Keep the newest ID from each run if you are building incremental monitoring.
• Inspect logs when a channel resolves but returns no public Videos tab.
• Schedule at a cadence appropriate for the channels; polling every minute is rarely useful.
• Deduplicate downstream by videoId if you intentionally collect overlapping runs.

Failure behavior

Malformed input fails the run with a clear error.

If one channel fails but another succeeds, the Actor logs the failed channel and preserves useful records from successful channels.

If every supplied channel fails to resolve or load, the run fails rather than reporting a misleading empty success.

A valid channel with no public video records can complete with zero records for that channel.

Temporary network errors, HTTP 429 responses, and upstream server errors are retried with bounded backoff.

Limitations

• Only public channel video listings are supported.
• Private, members-only, deleted, age-restricted, or region-limited data may be absent.
• The Actor does not log in and cannot access YouTube Studio or private analytics.
• It does not return likes, comments, transcripts, tags, descriptions, exact publish timestamps, or downloaded media.
• viewCount is parsed from YouTube's compact public label and can be rounded.
• publishedTimeText is relative text, not an exact ISO date.
• A handle can change; a channel ID is more stable.
• YouTube may change its logged-out response structure or rate-limit requests.
• The monitoring checkpoint must occur within the traversed range; use a sufficient limit.
• Channel order matters when maxItems is lower than the sum of per-channel limits.

Responsible and legal use

This Actor collects public listing metadata.

You are responsible for:

• complying with YouTube's terms and applicable laws;
• choosing a reasonable run frequency;
• respecting privacy, copyright, and database rights;
• avoiding profiling or harmful decisions based on scraped data;
• securing exported datasets and API credentials;
• honoring deletion or access obligations that apply to your use case.

Do not use the Actor to bypass access controls or collect private account data.

Troubleshooting

My channel does not resolve

Use a full public channel URL or its UC... ID. Verify that you supplied a channel page rather than a playlist or video URL.

I received fewer videos than requested

The channel may have fewer public videos, the checkpoint may have been reached, the global limit may have been consumed by earlier channels, or YouTube may not expose some content in the Videos tab.

My monitoring run returned zero records

Zero is expected when the checkpoint is currently the newest video. Confirm the checkpoint ID belongs to the supplied channel and raise the per-channel limit if it is older than the traversed range.

Why is viewCount null?

Some rendered items do not expose a public count, and scheduled or special content can use labels that are not numeric. Inspect viewCountText for the source label.

Can I scrape Shorts?

This Actor targets the channel Videos tab. Shorts shown there may appear, but separate Shorts-tab coverage is not promised. Use the related YouTube Shorts Actor for a Shorts-specific workflow.

Does the Actor need a proxy?

No proxy input is required. The Actor uses a public logged-out structured route and bounded retries.

Related Automation Lab Actors

• YouTube Channel Scraper — collect broader channel metadata together with videos.
• YouTube Playlist Scraper — extract videos organized in a specific playlist.
• YouTube Transcript — retrieve transcript text after discovering video IDs.
• YouTube Shorts Scraper — use a Shorts-focused input and output workflow.

FAQ

Does this use the official YouTube Data API?

No. It reads public logged-out YouTube channel responses and does not require a Google API key or consume a user's Data API quota.

Can I collect all videos from a large channel?

Set both limits high enough. The Actor follows continuation pages until it reaches the channel end or a configured limit. Begin with a smaller run to confirm expected cost and output.

Can I sort by popular or oldest?

No. The current product reads the normal newest-first Videos tab so it can support incremental monitoring.

Can I get exact publication dates?

Not from this Actor's channel-listing route. It preserves YouTube's displayed relative publication text. Use a separate detail-enrichment step when exact dates are required.

Are duplicate videos charged twice?

The Actor deduplicates video IDs within each processed channel before charging and saving them. Downstream deduplication is still recommended across separate runs.

Can I run it every day?

Yes. Use an Apify Schedule and a checkpoint. Choose a cadence and limits that match the upload frequency of the channels you monitor.

Where are results stored?

Every video is written to the run's default Apify dataset. Dataset retention follows your Apify account plan and storage settings.