YouTube Video Details Scraper (views, likes, description, tags) avatar

YouTube Video Details Scraper (views, likes, description, tags)

Pricing

from $0.50 / 1,000 videos

Go to Apify Store
YouTube Video Details Scraper (views, likes, description, tags)

YouTube Video Details Scraper (views, likes, description, tags)

YouTube Video Details Scraper returns views, likes, description, tags, category, channel and comment count for any YouTube video URL or ID — no YouTube Data API key or quota needed.

Pricing

from $0.50 / 1,000 videos

Rating

0.0

(0)

Developer

Murat Uzun

Murat Uzun

Maintained by Community

Actor stats

0

Bookmarked

6

Total users

1

Monthly active users

5 hours ago

Last modified

Features

Limited permissions

Share

What is YouTube Video Details Scraper?

YouTube Video Details Scraper returns views, likes, description, tags, category, channel and comment-count data for any public YouTube video — no YouTube Data API key, no daily quota, and no browser required. Paste a video URL or ID and get one structured row per video: title, exact view and like counts, full description, uploader-set keywords, category, channel name/ID/URL, subscriber count text, publish date, duration and more. Point it at any YouTube video and run it on Apify with scheduling, API access and monitoring built in. Give Track growth between runs a store name and schedule it: every row then also says how many views, likes and comments the video gained since the previous check. It is built for content researchers, SEO and metadata auditors, and developers building AI agents. Pricing is per result: $0.95 per 1,000 videos on the Free plan ($0.50 on Gold and above), and failed videos are not billed.

Under the hood it reads the same ytInitialPlayerResponse block the youtube.com watch page embeds for itself, plus the youtubei/v1/next endpoint the page calls for the sidebar and comments panel — so there is nothing to authenticate and no per-request cost from Google.

Why use YouTube Video Details Scraper?

  • Content research — pull view/like counts, tags and descriptions across a competitor's or influencer's catalog to spot what performs.
  • SEO and metadata audits — check whether a channel's videos have keywords, a filled-in description and a matching category.
  • Monitoring and reporting — schedule a run to track view/like growth on a set of videos over time.
  • AI agent tooling — let an agent look up "how many views does this video have" without writing any scraping code.

How to use YouTube Video Details Scraper

  1. Click Try for free (or Run if you already have it open).
  2. In Videos, paste one or more YouTube URLs or bare video IDs.
  3. Optionally set Max concurrency, Language and Region. Leave Proxy configuration on its default (Residential) for platform runs.
  4. Click Start and watch rows appear in the Dataset tab as they're fetched.
  5. Export the results as JSON, CSV, Excel or HTML, or pull them via the API.

Input

FieldTypeDescription
videosarrayVideo IDs or URLs (watch, shorts, youtu.be). Default: ["dQw4w9WgXcQ"].
monitorStoreNamestringOptional. Track growth between runs under this name (letters, digits, hyphens). See Track growth between runs.
proxyModestringauto, always or never — see Proxy requirement below. Default auto.
proxyConfigurationobjectWhich Apify Proxy group to use when proxyMode needs one. Default: Residential proxy.
maxConcurrencyintegerVideos fetched in parallel, 1–10. Default 3.
languagestringUI language code, e.g. category name. Default en.
regionstring2-letter country code. Default US.

See the Input tab for the full schema with examples.

Example input

{
"videos": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ", "jNQXAC9IVRw"],
"maxConcurrency": 3
}

Track growth between runs

Give Track growth between runs (monitorStoreName) a name, e.g. my-videos, and schedule the run (hourly, daily). The Actor keeps each video's last view, like and comment counts in your own named key-value store. Every later run with the same name adds to each row:

FieldMeaning
firstChecktrue when no earlier run with this name checked the video (gains are null then)
previousCheckAt, hoursSincePreviousWhen the video was checked before, and how long ago
viewsGained, likesGained, commentsGainedChange since that check. Views and likes are exact; YouTube rounds comment counts above 1,000
viewsPerHourviewsGained divided by hoursSincePrevious
{
"videos": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ", "jNQXAC9IVRw"],
"monitorStoreName": "my-videos"
}

Growth tracking costs nothing extra: the price per video is the same with or without it. OUTPUT.monitor sums the gains of the run (videosTracked, firstChecks, withPreviousCheck, viewsGained, likesGained, commentsGained), and the Growth since last run dataset view shows them as a table.

Proxy requirement

YouTube's watch page and its /player//next endpoints can return a "Sign in to confirm you're not a bot" page to requests coming from Apify's own datacenter IP ranges — this comes and goes (a run can succeed for hours, then start failing without any code change). The Proxy mode input controls how the Actor reacts:

  • Auto (default) — every request is tried directly first, with zero proxy cost; the moment YouTube blocks a direct request, the Actor switches to Apify Proxy (see Proxy configuration) for the rest of that run, so later videos don't re-pay the failed-direct attempt.
  • Always — skip the direct attempt and route everything through the proxy from the start.
  • Never — always request directly, even if that means some videos come back with an error.

When the proxy is in play, the Actor also minimizes what goes through it: it prefers the small /youtubei/v1/player call (a few KB) over the ~1 MB watch page, and skips the (surprisingly large, ~370-420 KB) /next call entirely once a run is already paying for proxy bandwidth — /next only ever adds a few optional fields (exact subscriber-count text, comment count, a like-count fallback), so it isn't worth its size once you're not getting it for free.

Output

One row per video:

{
"videoId": "dQw4w9WgXcQ",
"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
"title": "Rick Astley - Never Gonna Give You Up (Official Video) (4K Remaster)",
"description": "The official video for \"Never Gonna Give You Up\" by Rick Astley...",
"keywords": ["rick astley", "Never Gonna Give You Up", "rick roll"],
"category": "Music",
"channelId": "UCuAXFkgsw1L7xaCfnd5JJOw",
"channelName": "Rick Astley",
"channelUrl": "https://www.youtube.com/@RickAstleyYT",
"subscriberCountText": "4.54M subscribers",
"publishDate": "2009-10-24T23:57:33-07:00",
"uploadDate": "2009-10-24T23:57:33-07:00",
"viewCount": 1815026601,
"likeCount": 19386875,
"commentCountText": "2.4M",
"durationSeconds": 213,
"isLive": false,
"isLiveContent": false,
"isPrivate": false,
"isFamilySafe": true,
"isUnlisted": false,
"thumbnailUrl": "https://i.ytimg.com/vi_webp/dQw4w9WgXcQ/maxresdefault.webp",
"chapters": [],
"hashtags": [
"#RickAstleyNever",
"#RickAstley",
"#NeverGonnaGiveYouUp",
"#WheneverYouNeedSomebody",
"#OfficialMusicVideo"
],
"error": null,
"scrapedAt": "2026-09-13T00:00:00.000Z"
}

You can download the dataset in various formats such as JSON, CSV, Excel or HTML.

Data table

FieldDescription
videoId, url, titleVideo identity
description, keywords, categoryFull description (up to 5000 chars), uploader-set tags and YouTube category
channelId, channelName, channelUrl, subscriberCountText, subscriberCountUploading channel; subscriberCount is the number behind YouTube's rounded text (4.54M → 4540000)
publishDate, uploadDate, durationSecondsTiming
viewCount, likeCount, commentCountText, commentCountEngagement; commentCount is exact below 1,000 and rounded by YouTube above
firstCheck, previousCheckAt, hoursSincePrevious, viewsGained, likesGained, commentsGained, viewsPerHourOnly with monitorStoreName: growth since the previous check
isLive, isLiveContent, isPrivate, isFamilySafe, isUnlistedStatus flags
thumbnailUrlHighest-resolution thumbnail
chapters, hashtagsBest-effort, parsed from the description text
errorNull on useful result rows; failures are written to the ERRORS key-value record

Run it from code

Replace YOUR_APIFY_TOKEN with your Apify API token (or set APIFY_TOKEN in your environment). Input field names are the ones in the Input table above.

JavaScript (npm install apify-client):

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('webdatatools/youtube-video-details').call({
videos: ['https://www.youtube.com/watch?v=dQw4w9WgXcQ', 'jNQXAC9IVRw'],
maxConcurrency: 3,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].title, items[0].viewCount, items[0].likeCount);
// Schedule this one: each run also returns views/likes/comments gained since the previous run.
const tracked = await client.actor('webdatatools/youtube-video-details').call({
videos: ['https://www.youtube.com/watch?v=dQw4w9WgXcQ'],
monitorStoreName: 'my-videos',
});
const { items: growth } = await client.dataset(tracked.defaultDatasetId).listItems();
console.log(growth.map((v) => [v.title, v.viewsGained, v.viewsPerHour]));

Python (pip install apify-client):

import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('webdatatools/youtube-video-details').call(
run_input={'videos': ['https://www.youtube.com/watch?v=dQw4w9WgXcQ'], 'maxConcurrency': 3},
)
for item in client.dataset(run['defaultDatasetId']).iterate_items():
print(item['title'], item['viewCount'], item['likeCount'])

Apify CLI (npm install -g apify-cli, then apify login):

$echo '{"videos":["dQw4w9WgXcQ"],"maxConcurrency":3}' | apify call webdatatools/youtube-video-details --output-dataset

Diagnostics and error messages

Failed inputs and failed videos are written to the ERRORS key-value record, never to the billable dataset. Each entry has a stable errorCode, and OUTPUT.errorCodes counts them:

CodeMeaningWhat to do
INVALID_INPUTNot a YouTube video ID or URLUse a watch, Shorts or youtu.be link, or the 11-character ID
VIDEO_UNAVAILABLEYouTube says the video is unavailable, private or removed (its own words are in error)Check the video in a browser
LOAD_FAILEDYouTube blocked or did not answer the requests (proxyMode: "never", or a bot check)Keep proxyMode on auto and run again
NO_DETAILSYouTube answered without a titleRun again later

These are the messages the Actor emits:

WhereMessage (as emitted)Meaning
ERRORS recordInvalid YouTube video ID or URL.The input item is not a recognisable video ID or URL. Not billed.
error fieldYouTube's own playability reason (private, removed, age-restricted and similar), or Video is unavailable, private or has been removedYouTube returned no usable player data for the video. Not billed.
error fieldCould not load video data: HTTP <status> (or Non-JSON response)The watch page and the player API request failed. Not billed.
error fieldCould not find video data on the watch page or the player API (layout changed or blocked)Both sources answered but contained no video data. Not billed.
Run statusNo valid video identifiers. See ERRORS.Every input was invalid; the run fails.
Run statusNo usable video details returned. See ERRORS.No video produced a usable row; the run fails. Start fees may still apply.
OUTPUT recorderrorCodes, monitor, partial, budgetSkippedVideos, deliveryUnconfirmedpartial is true when any diagnostic or budget skip happened. budgetSkippedVideos counts videos not fetched because of the run's spending limit. deliveryUnconfirmed means a dataset upload result is uncertain; it is not retried automatically.

Pricing

This Actor uses Pay-per-event pricing per returned video, plus $0.00005 per run start:

Apify planFreeBronzeSilverGold, Platinum, Diamond
Per 1,000 videos$0.95$0.80$0.65$0.50

Failed and invalid videos are not charged, and growth tracking adds nothing. There is no separate compute-unit charge on top — the price already covers it.

Apify Proxy adds a small infrastructure cost on top of that, paid from your Apify plan's proxy allowance rather than charged to the caller. With the default Auto proxy mode, that cost is $0 whenever YouTube isn't currently blocking the run's IP (the common case). Measured live: in Auto mode with a block triggered mid-run, and in Always mode (proxy used for every request), proxy data transfer cost ~$0.00007 per video in both cases — the Actor's direct-first strategy and its preference for the small /player call over the ~1 MB watch page and the ~400 KB /next call keep this small even in the worst case, well inside the Residential free-plan allowance (20 GB/month).

YouTube Video Details Scraper vs. the YouTube Data API

The official YouTube Data API v3 videos.list endpoint requires a Google Cloud project, an API key, and burns your daily quota (10,000 units — a few thousand video reads) fast. This Actor reads the same public data the youtube.com watch page loads for itself, with no key, no quota, and results delivered as a ready-to-export dataset.

YouTube Video Details Scraper vs. other video detail Actors

Prices are each Actor's Free-plan price per 1,000 videos from its pricing tab; features are what its live input schema and README document. Checked November 15, 2026.

YouTube Video Details Scraper (this)thenetaji/youtube-video-details-scraperdelicious_zebu/youtube-video-data-scraperaolmo/youtube-video-details
Price per 1,000 videos$0.95 ($0.50 Gold+)$0.95 ($0.50 Gold+)$1.20 ($0.50 Gold+)$1.00 + $0.50 per 1,000 changed videos
Views, likes, description, tags, channelYesDocumentedDocumentedDocumented
Growth since the previous runYes, no extra chargeNot documentedNot documented (README suggests scheduling)Documented (viewsChange, charged per changed video)
Failed videos not charged, stable error codesYes (ERRORS, errorCode)Invalid and unavailable videos skippedNot documentedNot documented

Choose this Actor to watch a list of videos for growth at the leader's price with no charge for changes.

Using YouTube Video Details Scraper with AI agents / MCP

Connect your MCP client to the official Apify MCP server, authorize your Apify account, and select webdatatools/youtube-video-details.

This Actor is published with Pay-per-event pricing and limited permissions, so it is directly callable through the Apify MCP Server and AI agent frameworks that support Apify tools — an agent can ask "how many views and likes does this video have" and get structured JSON back without any custom scraping code.

FAQ

How much does a typical run cost? You pay per useful result row: 1,000 videos cost $0.95 on the Free plan and $0.50 on Gold and above, plus $0.00005 per run start. Failed rows and diagnostic rows are not written to the dataset and are not billed. Set Max total charge on the run to cap spend: the Actor reads the remaining budget before it fetches anything, skips videos beyond it, and reports them as budgetSkippedVideos in OUTPUT.

Is this legal? The Actor reads publicly visible video metadata the same way a browser loading youtube.com does. Respect YouTube's Terms of Service and applicable data-protection law for how you store and use the results.

What about private, deleted or unavailable videos? Failed requests and invalid inputs go into the ERRORS key-value record, outside the billable dataset. A run with no usable videos fails; mixed runs retain usable videos and report diagnostics. Start fees may still apply. Read OUTPUT for requested and attempted videos, result and diagnostic rows, budget skips and partial-output status. An uncertain dataset upload is reported as deliveryUnconfirmed and is not retried automatically.

What happens with age-restricted videos? If YouTube exposes usable public metadata, it is returned. Restrictions, unavailable videos and access blocks can prevent extraction; these failures are reported in ERRORS. Field availability is not guaranteed.

Why is likeCount sometimes approximate? YouTube's watch page exposes an exact like count for almost every video. On the rare video where that field is missing, the Actor falls back to the like button's own compact count/accessibility text, which can be off by a handful due to normal live-count drift between the two page loads.

Are chapters always filled in? No — chapters are parsed on a best-effort basis from timestamp lines in the description (the same convention YouTube's own chapter-list detector uses), and only returned when at least two distinct timestamps are found. Many videos have no chapter list at all, so this is often an empty array.

Will large batches get rate-limited? The Actor routes requests through Apify Proxy by default (see Proxy requirement above) — each parallel request gets its own proxy session. For very large batches, keep maxConcurrency at 2–3; on an HTTP 429 the Actor waits 5 seconds and retries once before giving up on that page.

Can I use this in n8n, Make or Zapier? Yes — call the Actor via its Apify API endpoint from any of these tools' native Apify integration or a generic HTTP node, or trigger it from a webhook.

If this Actor saved you time, a short review on its Apify Store page helps other users find it. Nothing is offered in return.

Part of the webdatatools web-intelligence suite — every Actor is pay-per-event, reads public data without a login, and returns one clean row per entity:

Browse the whole suite at webdatatools, or call ten of these Actors straight from Claude, Cursor or Cline with the webdatatools MCP server.

Website & domain intelligence

Content for AI, LLMs and RAG

Search, video and social

Leads, jobs and company data

Developer, app and research data

Support

Found a bug or have a feature request? Open an issue on the Actor's Issues tab in Apify Console. Custom scraping solutions are also available on request.

If this Actor is useful to you, you can leave a review on its Apify Store page. Nothing is offered in return.