How to Scrape YouTube Video Metadata, Tags and View Counts in 2026

You have a list of video IDs — from a search run, a channel catalog, a spreadsheet a colleague sent — and you need the facts about each one: exact views, likes if they’re showing, the full description, the creator’s tags, the category, the real publish date. The Data API gives you most of this behind a quota wall but hides the video’s tags entirely unless you own the channel, and rounds some numbers. This guide covers how to hydrate video IDs into complete metadata records in 2026, what the watch page actually exposes, and how to do it at scale.

What’s worth extracting

This is a hydration actor: IDs/URLs in, full per-video facts out. The fields:

• Exact view count — the real integer, not the rounded “1.2M”.
• Like count — when YouTube is exposing it (best-effort; see pitfalls).
• Full description — the complete text, not a snippet.
• Tags / keywords — the creator-set tags, which the public Data API does not return for videos you don’t own. This is the headline field.
• Category — the video’s assigned category.
• Publish date — a real ISO timestamp, not “3 weeks ago”.
• Duration — formatted and in seconds.
• Channel info and thumbnail URLs.
• Flags — live indicator and family-safe status.

Those creator-set tags are the reason this actor exists for SEO people. They’re how a video tells YouTube what it’s about, they’re invisible in the UI, and they’re the closest thing to a competitor’s keyword strategy you can get.

How the data is exposed (watch-page HTML, no API key)

The actor loads each public watch page and parses the embedded page data — the JSON the page ships in its HTML for the player and metadata to hydrate from. Login-free, key-free:

• Reads embedded watch-page data rather than calling the Data API, so it sees fields the API withholds — notably tags and the exact ISO publish date.
• Best-effort like extraction. YouTube has made like counts inconsistent to read; the actor pulls them when present and degrades gracefully when they’re not, rather than failing the row.
• High-volume hydration. Feed thousands of IDs or URLs; the actor processes them with retry logic so transient failures don’t sink the run.
• No login, no API key, fresh access handling per run.

A note on the technique: this reads the watch page, not a player endpoint. That matters because the watch-page HTML carries the rich metadata block (description, tags, category, ISO date) that thinner endpoints omit — it’s the reliable source for full video facts.

▶ Run the YouTube Video Details Scraper — feed video IDs or URLs and get exact views, full descriptions, creator tags, category and ISO publish dates. No login, no API key, built for bulk hydration.

Schema design for downstream use

A clean per-video record after hydration:

{
  "video_id": "dQw4w9WgXcQ",
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "title": "How I Edit My Videos in 2026",
  "views": 184213,
  "likes": 9421,
  "description": "Full description text, links, timestamps and all...",
  "tags": ["video editing", "davinci resolve", "youtube tips", "2026"],
  "category": "Education",
  "published_at": "2026-04-29T15:00:00Z",
  "duration_seconds": 742,
  "duration_text": "12:22",
  "channel_id": "UCxxxxxxxxxxxx",
  "channel_name": "Some Creator",
  "thumbnail_url": "https://i.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg",
  "is_live": false,
  "is_family_safe": true,
  "scraped_at": "2026-06-01T09:00:00Z"
}

Schema choices worth making:

• Keep tags as an array. It’s the SEO payload — store it structured so you can build keyword frequency tables across competitors.
• Use published_at (ISO), not relative text. This is the actor’s advantage over grid/search data — you get an exact timestamp suitable for true time-series.
• Store likes nullable. Sometimes it’s there, sometimes it isn’t; model it as optional so a missing like count doesn’t break your loaders.
• Persist exact views with scraped_at. Snapshot views over time to measure growth — the precise integer makes deltas meaningful.

Where this fits in the suite

This is the enrichment/hydration stage. The flow is usually:

• Search scraper or channel scraper gives you a list of video IDs (with rounded views and relative dates).
• This actor hydrates those IDs into complete records — exact views, full descriptions, tags, ISO dates.
• Comments scraper then pulls the discussion on the videos that matter.

So: discovery upstream, full facts here, conversation downstream. Each actor does one job well rather than one bloated tool doing all three badly.

Typical use cases

• Video SEO and tag research — collect titles, full descriptions and all creator tags to reverse-engineer what ranks for a keyword.
• Competitor content analysis — compare exact views, likes, durations and categories across a set of competitor videos.
• Dataset enrichment — turn bare ID lists into complete per-video metadata for downstream processing or labeling.
• Trend and performance tracking — snapshot view/like growth on a schedule using the exact integers and ISO dates.
• AI and analytics pipelines — feed clean, structured per-video facts into models, dashboards and reports.

Cost math for the managed approach

Pricing is pay-per-event — a small per-run start fee with no per-result charge. Hydrating a few thousand video IDs is dominated by the compute to load and parse each watch page, landing in single-digit dollars per run. Against the Data API, the win is qualitative as much as quantitative: even with quota to spare, the API simply won’t give you the tags — so for tag research there’s no API path at all, only watch-page parsing.

Versus building it yourself, you skip:

• Watch-page parsing maintenance — the embedded data block changes shape; the maintainer absorbs that.
• Best-effort like-count logic — reading likes reliably is a moving target.
• The bulk retry harness for thousands of IDs.

Common pitfalls

• Likes are not guaranteed. YouTube exposes them inconsistently; treat a missing like count as expected, not an error.
• Private/removed videos return nothing. Feed a deleted ID and you get an empty/error row — filter your input or handle gracefully.
• Age-restricted videos can be limited. Some metadata may be partial on restricted content seen anonymously.
• Tags can be empty. Not every creator sets them; an empty tags array is a real result, not a failure.
• Descriptions are long and link-heavy. Store the full text but expect to parse out links/timestamps separately if you need them structured.
• View counts move. Re-hydrate periodically and keep scraped_at to build a clean growth series.

Wrapping up

If you need facts on a couple of videos, the watch page in your browser will do. If you need to hydrate thousands of IDs into complete, tag-bearing, exact-number records — especially for tag-level SEO that the API can’t provide — let a maintained actor parse the watch pages and hand you clean rows.

▶ Open the YouTube Video Details Scraper on Apify — bulk ID/URL hydration with exact views, tags and ISO dates, exported to JSON, CSV or Excel. Start with Apify’s free monthly credit.