YouTube Video Details Scraper: Up to 1,000 Free Results a Month (2026)

Each record carries 35 video fields, including channel information, engagement rates, tags, and hashtags. The underlying HTTP-first approach with automatic Playwright fallback delivers reliable extraction across varied video formats, backed by a track record where 173 of 183 public runs in the last 30 days finished successfully. You can try it on Apify's free plan, which includes $5.00 of monthly usage covering up to 1,000 results at $0.005 per result before run-start fees. This actor is built for data engineers, researchers, and content analysts who need structured video payloads. It is not for anyone who needs full transcript text bodies, which the records do not include.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 1,000 results at $0.005 each before platform usage. Open YouTube Video Details Scraper on Apify and run the prefilled example.

How reliable is YouTube Video Details Scraper in production?

Across the last 30 days of public runs on the Apify platform, YouTube Video Details Scraper recorded 183 runs with the following outcomes.

Outcome	Runs	Share
Succeeded	173	94.5%
Failed	9	4.9%
Aborted by the user	1	0.5%
Timed out	0	0.0%
Total	183	100.0%

Scheduling this actor for unattended runs means accounting for failures where about 5 in a hundred runs fail or are aborted. Building retry logic and failure alerts into your orchestration layer helps protect against these dropped executions. Keeping input batches smaller can also limit the blast radius when a specific batch encounters issues.

What does it cost to run YouTube Video Details Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.01 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Apify plan	Per result	Per 1,000 results
FREE	$0.005	$5.00
BRONZE	$0.00433	$4.33
SILVER	$0.00367	$3.67
GOLD	$0.003	$3.00
PLATINUM	$0.003	$3.00
DIAMOND	$0.003	$3.00

Worked example: collecting 10,000 results costs $50.00 in result charges before run-start fees and platform usage. With 4.9% of runs failing or timing out in the last 30 days, budget for re-running a portion of those batches rather than assuming every run completes.

The primary control driving your result count and overall cost is the videoUrls array, since every specified video or ID generates a dataset record. Setting maxComments above zero will not change the result item count, but it increases the depth of nested data per item. The cheapest way to test feasibility is running a single URL on Apify's free plan before scaling up.

How do you run YouTube Video Details Scraper from the API?

The schema marks 1 of its 8 controls as required: videoUrls. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~youtube-video-details-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"videoUrls":["https://www.youtube.com/watch?v=dQw4w9WgXcQ","https://www.youtube.com/watch?v=jNQXAC9IVRw"],"maxComments":0,"includeChapters":true,"includeEndscreen":true,"includeCards":false,"includeTranscriptMetadata":true,"includeRelatedVideos":0,"proxyCountry":"US"}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.youtube.com/watch?v=jNQXAC9IVRw"
  ],
  "maxComments": 0,
  "includeChapters": True,
  "includeEndscreen": True,
  "includeCards": False,
  "includeTranscriptMetadata": True,
  "includeRelatedVideos": 0,
  "proxyCountry": "US"
}

run = client.actor("crawlerbros~youtube-video-details-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.youtube.com/watch?v=jNQXAC9IVRw"
  ],
  "maxComments": 0,
  "includeChapters": true,
  "includeEndscreen": true,
  "includeCards": false,
  "includeTranscriptMetadata": true,
  "includeRelatedVideos": 0,
  "proxyCountry": "US"
}

const run = await client.actor('crawlerbros~youtube-video-details-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which YouTube Video Details Scraper inputs matter, and which can you skip?

The input schema exposes 8 controls, of which videoUrls is the single required parameter. Leave optional toggles like includeChapters and includeTranscriptMetadata at their defaults unless your specific deliverable requires chapter arrays or caption track listings.

videoUrls (array): YouTube video URLs, short links (youtu.be), shorts URLs, or plain video IDs.
maxComments (integer): Maximum number of comments to extract per video. Set to 0 to skip comment extraction. Default: 0.
includeChapters (boolean): Extract chapter markers from the video engagement panel or description timestamps. Default: true.
includeEndscreen (boolean): Extract endscreen elements (suggested videos/channels/playlists shown at video end). Default: true.
includeCards (boolean): Extract interactive info cards embedded in the video. Default: false.
includeTranscriptMetadata (boolean): List available caption/transcript tracks (language codes, auto-generated flag). Does not fetch transcript text. Default: true.
includeRelatedVideos (integer): Number of related/suggested videos to extract from the watch page sidebar. 0 = skip. Default: 0.
proxyCountry (string): Country for proxy routing. Useful for geo-blocked videos. Default: "US".

Fixed-choice controls: proxyCountry accepts 31 values (default US), including US (United States), GB (United Kingdom), CA (Canada), AU (Australia).

What does YouTube Video Details Scraper return?

Returned records are well-suited for content research, tracking metrics over time, and metadata aggregation. They conspicuously do not contain full transcript text bodies or direct creator email addresses.

Video fields

type: string - "video"
inputUrl: string - Original URL provided in input
videoId: string - "dQw4w9WgXcQ"
title: string - "Rick Astley - Never Gonna Give You Up"
description: string - Full video description
channelId: string - "UCuAXFkgsw1L7xaCfnd5JJOw"
channelName: string - "Rick Astley"
publishedDate: string - "2009-10-25"
durationSeconds: integer - 212
viewCount: integer - 1234567890
likeCount: integer - 15000000
commentCount: integer - 500000
commentsDisabled: boolean - false
tags: array - ["rick astley", "never gonna give you up"]
hashtags: array - ["#rickastley", "#nevergonnagiveyouup"]
thumbnails: object - {"default": "...", "medium": "...", "high": "..."}
category: string - "Music"
language: string - "en"
defaultAudioLanguage: string - "en"
liveStatus: string - "none", "live_now", "was_live", or "upcoming"
liveBroadcastDetails: object - Start/end timestamps when applicable
uploadType: string - "normal", "live", "was_live", "premiere", or "short"
engagementRate: float - 0.0162
resolution: string - "1080p"
isFamilySafe: boolean - true
isPlayable: boolean - true
isAgeGated: boolean - false
requiresLogin: boolean - false
playabilityStatus: string - "OK"
availableCountries: array - ["US", "GB", "CA", ...]
clipId: string/null - Clip identifier (clip URLs only)
clipStartMs: integer/null - Clip start time in ms
clipEndMs: integer/null - Clip end time in ms
success: boolean - true
scrapedAt: string - "2026-02-10T12:00:00.000000+00:00"

Channel info (embedded in channel object)

id: string - "UCuAXFkgsw1L7xaCfnd5JJOw"
handle: string - "@rickastley"
url: string - "https://www.youtube.com/@rickastley"
subscriberCount: integer - 2500000
subscriberCountText: string - "2.5M subscribers"
logo: string - Channel avatar URL
badges: array - ["Verified"]

Chapters (embedded in chapters array, when includeChapters=true)

title: string - "Intro"
startSeconds: integer - 0
startTimeText: string - "0:00"
thumbnailUrl: string - Chapter thumbnail URL

Caption tracks (embedded in captionTracks array, when includeTranscriptMetadata=true)

languageCode: string - "en"
languageName: string - "English"
isAutoGenerated: boolean - false
isTranslatable: boolean - true

Comments (embedded in comments array, when maxComments > 0)

commentId: string - "abc123"
text: string - "This song is timeless!"
authorName: string - "MusicFan"
authorChannelId: string - "UC..."
authorProfileImageUrl: string - Profile image URL
publishedTimeText: string - "2 years ago"
likeCount: integer - 1200
isHearted: boolean - false
isPinned: boolean - false

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open YouTube Video Details Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

Populate the videoUrls control with a target array of video URLs or bare IDs, keeping the list short for your first test.
Set maxComments to zero unless you specifically need comment records written to data storage.
Toggle includeChapters to true if you need structured chapter markers with start times and thumbnail URLs.
Adjust proxyCountry to match the target region if you are targeting geo-blocked videos.
Run the actor once and inspect the resulting dataset to verify that video fields and channel info populate correctly.
Review the playabilityStatus and isPlayable fields in the output record before scaling up your input list.
Scale your videoUrls array once your initial test run returns valid metadata without errors.

How do you apply it? Three worked playbooks

These are YouTube Video Details Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Content research

Outcome: Extract full video metadata including chapters, tags, and engagement rates for any video at scale

Configure: Set videoUrls to your target array of URLs, set includeChapters to true, and leave maxComments at zero.

Working method: Run the actor on a small batch of URLs first, inspect the returned tags and engagementRate fields, and then widen your input list.

Deliverable: A dataset containing video metadata, tags, hashtags, and chapter markers for each target URL.

Stop condition: The run encounters persistent failures or returns isPlayable as false for valid public URLs.

Use case 2: Media monitoring

Outcome: Track view counts, like counts, and playability status for a set of videos over time

Configure: Populate videoUrls with your permanent tracking list and configure a scheduled run frequency.

Working method: Capture daily snapshots of viewCount and likeCount, comparing sequential runs to measure growth velocity.

Deliverable: Time-series records of view counts, like counts, and playability status stored in your target dataset.

Stop condition: A sudden drop in success rate or widespread playabilityStatus changes across monitored assets.

Use case 3: SEO analysis

Outcome: Collect titles, descriptions, hashtags, and related videos for keyword and ranking research

Configure: Set videoUrls to target ranking videos and configure includeRelatedVideos to a positive integer like ten.

Working method: Extract titles, descriptions, and related videos from the sidebar to map out topical clusters and competitor reach.

Deliverable: A structured export of titles, descriptions, hashtags, and related video metadata for keyword research.

Stop condition: Returned records lack descriptions or related videos fail to populate in the sidebar array.

What breaks, and how do you design around it?

Over the last 30 days, 4.9% of public runs failed and 0.0% timed out. Build retries and alerting around those rates rather than assuming every run completes.

When encountering geo-blocked videos, set the proxyCountry control to a region where the content is accessible. For private or members-only videos that return unplayable statuses, filter out those items before feeding records into downstream analysis pipelines.

When should you not use YouTube Video Details Scraper?

Do not use this actor if you need to download raw video files or audio streams, for which the YouTube Video Downloader is built. Avoid this tool if your primary objective is harvesting full timestamped transcripts, as this scraper only lists available caption tracks rather than fetching transcript text bodies; use the YouTube Transcript Scraper instead. Similarly, if your task involves discovering channels from scratch rather than analyzing known videos, look to the YouTube Channel Scraper or YouTube Search Scraper for initial collection before passing IDs here.

What should you check before trusting the output?

Verify that the videoId field matches the identifier provided in your input URL.
Check that isPlayable is true and playabilityStatus reads as OK before trusting the engagement metrics.
Inspect the commentCount against the returned comments array length to ensure extraction behaved as expected when maxComments is greater than zero.
Confirm that publishedDate is populated with a valid date string rather than null.
Stop scheduled runs immediately if success is false across consecutive items or if error rates spike.

None of this proves a record is correct. It gives a scheduled YouTube Video Details Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

What happens if a video has comments disabled?

When comments are disabled on a target video, the commentsDisabled boolean field in the output record returns true, and the comments array remains empty even if maxComments is set to a positive integer.

Does setting includeChapters increase the result item count?

No. Enabling chapter extraction embeds chapter markers directly inside the parent video record rather than creating separate dataset rows, meaning your result-based billing charges remain tied strictly to the number of video URLs processed.

How are clip URLs handled by the scraper?

Clip URLs return the metadata of the parent video alongside specific clip identifiers including clipId, clipStartMs, and clipEndMs which define the exact start and end timestamps of the requested clip segment.

Can I extract caption track text using this actor?

No. The includeTranscriptMetadata control only lists available caption tracks and their language codes or auto-generated flags, but it does not fetch the actual text body of the transcript.

What factors influence the total run cost beyond result pricing?

Each run incurs a run-start fee charged every time execution begins regardless of output, alongside platform usage charges billed by Apify based on the memory consumed during the run.

Where to go next

When you are ready to run it, open YouTube Video Details Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the YouTube Video Details Scraper Actor page for the current input schema, pricing tier, and run history.

It is part of the YouTube Scraping Suite, which puts every related Actor on one page with its price and run history.

If you are comparing approaches rather than committing to one Actor, these category pages list every option we publish:

Comment scrapers covers 37 Actors in this family.

Readers running YouTube Video Details Scraper commonly pair it with:

YouTube Video Downloader: Download YouTube videos, playlists, and entire channels in your preferred quality from 360p all the way up to the best available resolution.
YouTube Transcript Scraper: Extract transcripts and captions from YouTube videos with language selection support.
YouTube Channel Scraper: Scrape YouTube channel info and video listings.
YouTube Ads Scraper: Scrape YouTube ads from Google's Ads Transparency Center.
YouTube Comment Scraper: Scrape YouTube video comments with full metadata.
YouTube Search Scraper: Scrape YouTube search results without cookies.
YouTube Shorts Scraper: Scrape YouTube Shorts from any channel.

Related guides:

Resources

Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-24.
Actor last updated by its maintainers on 2026-06-22.
Run outcome figures cover the 30 day public window ending 2026-09-24.
YouTube Video Details Scraper on Apify