Youtube Playlist Scraper

YouTube Playlist Scraper — Videos, Channels and Playlist Data

YouTube Playlist Scraper extracts every video in a playlist as structured JSON: video ID, title, watch URL, duration, view count, thumbnail, plus the channel that published it and the playlist it belongs to. Paste playlist URLs, @usernames or search keywords — bulk input supported — and each video comes back as one typed row. Every response returns normalized JSON: no HTML, no selectors, no parsing.

After reading this you will know exactly which fields you get, how the two detail modes differ, and how to pull a full channel's playlist catalogue in one run.

What is YouTube Playlist Scraper?

YouTube Playlist Scraper is an Apify Actor that turns any YouTube playlist into a video dataset. It accepts three input shapes in the same list — a playlist URL, a channel @username, or a plain search keyword — and returns one row per video with nested channel and playlist objects attached.

No YouTube account, Google login or API key is required. Everything returned is visible to a signed-out visitor.

Key capabilities:

• Scrape videos — title, ID, watch URL, duration, view count, thumbnail
• Scrape channel context — the publishing channel's name, ID and URL, nested on every row
• Scrape playlist context — the parent playlist's metadata, nested on every row
• Toggle detail level with a single boolean
• Export as JSON, CSV or Excel

What data does YouTube Playlist Scraper collect?

Every row is one video, with two nested objects carrying the context that video sits in.

Data Type	Key Fields	JSON Field Names
Video	ID, title, watch URL, playability	videoId, title, videoUrl, isPlayable
Duration	Machine and display forms	duration, durationLabel
Engagement	View count, combined views-and-date string	viewCount, videoInfo
Media	Highest-resolution thumbnail	thumbnail.url
Channel	Publishing channel name, ID, URL	channel.name, channel.id, channel.url
Playlist	Parent playlist metadata	playlistInfo.playlistTitle
Collection	Extraction timestamp	extractedAt

Two detail modes

includeVideoDetails is on by default and controls how much each row carries. With it on, rows include thumbnail.url, videoInfo, durationLabel, the full channel and playlistInfo objects, and extractedAt. Turn it off for a leaner row when you only need identity and duration.

One field that is conditional

viewCount is written only when YouTube exposes a view count for that video. It is omitted from the row rather than set to null or zero. Live streams, some unlisted videos and certain regional variants come back without it. Code that reads it should use a .get() with a default rather than assuming the key is present — the honest behaviour is that a missing view count is reported as missing rather than as a fabricated 0.

duration and durationLabel are both returned: duration is the raw timing text, durationLabel is YouTube's accessible display label. Keep whichever suits your pipeline.

Need more YouTube data?

Four companion Actors cover the rest of the platform. YouTube Search Scraper returns search result sets rather than a fixed playlist. YouTube Channel Finder resolves channels from names and handles. YouTube Community Posts Scraper collects the community tab. YouTube Video Details Scraper goes deep on a single video.

How does YouTube Playlist Scraper differ from the official YouTube Data API?

The official YouTube Data API v3 is a genuine option for playlist data, and for some jobs it is the right one. The differences that matter are setup and quota shape rather than raw capability.

Feature	YouTube Data API v3	YouTube Playlist Scraper
Google Cloud project + API key required	✓	✗
Daily quota governs usage	✓	✗ — Apify usage only
Accepts @username or search keyword as input	✗ — needs resolved IDs	✓
Video, channel and playlist context in one row	✗ — separate endpoint calls	✓
Output shape	Per-endpoint schemas	One normalized row schema
Setup time to first result	Cloud project, key, quota setup	Paste a URL and run

Use the official API when you need authenticated operations on your own channel, guaranteed terms-of-service alignment for a shipped product, or fields the public page does not render. Use YouTube Playlist Scraper when you want playlist contents quickly without a Google Cloud project, when your input is a handle or keyword rather than a resolved playlist ID, or when you want the video, its channel and its playlist joined in a single row instead of stitched from three endpoint calls.

Verify current quota costs and terms against Google's published YouTube Data API documentation before committing to either route.

Why do developers and teams scrape YouTube playlists?

For AI engineers and agent builders

Playlist output is already shaped for indexing. title plus channel.name plus playlistInfo.playlistTitle gives an entity with its context attached, which chunks cleanly into a vector store without a join step. A practical workflow: index a competitor's tutorial playlists so an agent can answer "which of their videos cover authentication, and how long are they" against live catalogue data, using duration to filter for depth and viewCount to rank by traction.

For marketers and content teams

Playlists are how channels signal their content strategy. Pulling a competitor's playlists on a schedule shows what they are grouping together and how often they add to it. Track viewCount per videoId across runs to find which videos in a series actually carry the audience, then check durationLabel against your own format assumptions before commissioning the next batch.

For researchers and analysts

A playlist is a curated, publicly declared corpus — which makes it a defensible sampling frame. Collect the full video list with extractedAt stamped on each row so the snapshot is reproducible, and note that only public metadata is captured: no comments, no watch history, no personal data beyond the publishing channel's public identity.

For developers building data products

videoId is a stable key, so a playlist collection can be re-run and diffed to detect additions and removals without fuzzy matching. That makes scheduled monitoring, a course-catalogue product, or an internal content index straightforward to build on top — one Actor call in, one normalized row schema out, every time.

How to scrape YouTube playlists (step by step)

YouTube Playlist Scraper runs on Apify. Start it from the Apify Console or call it through the Apify API.

1. Open YouTube Playlist Scraper on Apify and click Try for free
2. Paste one or more entries into Playlist Inputs — playlist URLs, @usernames, or search keywords, mixed freely. At least one is required.
3. Set Max Videos per Playlist, or use 0 for no limit
4. Leave Include video details on unless you want lean rows
5. Click Start, then export as JSON, CSV or Excel

The proxy is off by default. If YouTube blocks or throttles you, the Actor falls back automatically to datacenter and then residential.

What to do when YouTube changes its structure

The scraper is maintained, and the output schema is held stable across updates — field names and types do not change on your end when YouTube changes its front end. Your integration keeps reading the same keys.

⬇️ Input

Parameter	Required	Type	Description	Example Value
playlistInputs	✅ Yes	array	Playlist URLs, @usernames, or search keywords. Minimum 1 item. Bulk input supported.	["https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw"]
maxVideos	No	integer	Videos to scrape per playlist. 0 means no limit. Minimum 0, maximum 1000. Default 10.	100
includeVideoDetails	No	boolean	When on, rows include thumbnail.url, videoInfo, durationLabel, full channel and playlistInfo, and extractedAt. Default true.	true
proxyConfiguration	No	object	Apify Proxy settings. Starts without proxy; auto fallback to datacenter then residential if blocked. Default is no proxy.	{"useApifyProxy": false}

Common pitfall: setting maxVideos to 0 expecting zero results. 0 means no limit — it collects the entire playlist. Use 1 for a single-video smoke test.

Example input

{
  "playlistInputs": [
    "https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw",
    "@GoogleDevelopers"
  ],
  "maxVideos": 100,
  "includeVideoDetails": true,
  "proxyConfiguration": { "useApifyProxy": false }
}

⬆️ Output

One row per video, with a consistent schema across runs. Export as JSON, CSV or Excel, or read the dataset through the Apify API.

Scraped videos

{
  "videoId": "dQw4w9WgXcQ",
  "title": "Build a REST API with FastAPI — Part 3: Authentication",
  "videoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "duration": "18:42",
  "durationLabel": "18 minutes, 42 seconds",
  "isPlayable": true,
  "viewCount": "142,318 views",
  "videoInfo": "142,318 views · 8 months ago",
  "thumbnail.url": "https://i.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg",
  "channel": {
    "name": "Google Developers",
    "id": "UC_x5XG1OV2P6uZZ5FSM9Ttw",
    "url": "https://www.youtube.com/@GoogleDevelopers"
  },
  "playlistInfo": {
    "playlistTitle": "FastAPI from Scratch"
  },
  "extractedAt": "2026-07-25T09:14:02Z"
}

With includeVideoDetails set to false, thumbnail.url, videoInfo, durationLabel, channel, playlistInfo and extractedAt are omitted and the row reduces to core video identity and duration.

How does YouTube Playlist Scraper compare to other YouTube scrapers?

Feature	YouTube Playlist Scraper	Generic alternative
Output format	Normalized JSON row schema	Varies; often HTML-derived
Input flexibility	Playlist URL, @username or keyword	Usually resolved IDs or URLs only
Context per row	Video + channel + playlist joined	Video only; context fetched separately
Credentials required	None	Often a Google API key
Proxy / anti-bot handling	Automatic fallback ladder	Developer managed

If you are building an AI agent or a RAG pipeline, the output format row is the decision-maker — parsing HTML inside an agent loop is a reliability failure mode, not a feature. If you need transcripts, comments or per-video deep metadata, a purpose-built Actor for that job will serve you better than a playlist scraper.

How many videos can you scrape with YouTube Playlist Scraper?

maxVideos accepts 0 to 1,000 per playlist, where 0 means no limit and collects the whole playlist. The cap applies per playlist, not per run — supply five playlists with maxVideos: 100 and you can receive up to 500 rows.

Beyond that, the practical ceiling is whatever the playlist itself contains. There is no Actor-imposed limit on how many playlists a single run can process; playlistInputs is a list and each entry is handled in turn.

Integrate YouTube Playlist Scraper and automate your workflow

YouTube Playlist Scraper is an Apify Actor, so it works with anything that can call the Apify API or consume a dataset.

REST API integration

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("youtube-playlist-scraper").call(run_input={
    "playlistInputs": ["https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw"],
    "maxVideos": 0,
    "includeVideoDetails": True,
})

for video in client.dataset(run["defaultDatasetId"]).iterate_items():
    views = video.get("viewCount", "n/a")   # omitted when YouTube exposes no count
    print(video["videoId"], video["duration"], views, video["title"])

Works in Python, Node.js, Go, Ruby, cURL — any language that can send an HTTP request.

Automation platforms (n8n, Make, Zapier)

In n8n, use the Apify node — or an HTTP Request node pointed at the Apify run endpoint with your token — and pass the same JSON input shown above; the dataset comes back as items you can map directly into a following node. In Make, the Apify module exposes run-and-wait, so a playlist sweep can feed a Google Sheets or Airtable step with no code. Both platforms support scheduling, which is enough for a weekly catalogue refresh.

Is it legal to scrape YouTube playlists?

Playlist contents and video metadata are published for public discovery, and YouTube Playlist Scraper collects only what a signed-out visitor sees — no account, no login, no API key.

The output is content and channel metadata rather than personal data: video titles, durations, view counts, playlist names, and the publishing channel's public identity. No viewer information, comments or watch history is collected, so the personal-data regimes that govern profile scraping do not attach to this output in the same way. The obligations that do apply are contractual — YouTube's terms of service — and copyright-related if you republish titles, thumbnails or descriptions as your own catalogue.

Consult legal counsel for commercial applications that republish or redistribute collected metadata at scale.

Frequently asked questions

Does YouTube Playlist Scraper work without a YouTube or Google account?

Yes. No account, no login, no Google Cloud project, no API key. The only credential involved is your Apify token.

How fresh is the data?

Every run fetches the playlist live from YouTube. Nothing is served from a cache, and extractedAt stamps each row with its collection time so a stored dataset carries its own provenance.

Why is viewCount missing from some rows?

Because YouTube did not expose a view count for that video. The field is written only when a count is available, so it is omitted rather than set to null or 0 — a fabricated zero would silently corrupt any average you computed. Read it with a default: video.get("viewCount").

What happens if a video is private, deleted or region-blocked?

It does not appear in the playlist data YouTube serves, so it produces no row. The run continues with the remaining videos. Because videoId is stable, comparing today's run against a stored earlier one identifies exactly which videos left the playlist.

Can I scrape private or unlisted playlists?

No. Only publicly accessible playlists are returned. An unlisted playlist is reachable only by direct link and is not resolvable from a handle or keyword search.

Can I pass a channel handle or a keyword instead of a playlist URL?

Yes — that is what playlistInputs is for. Playlist URLs, @usernames and plain search keywords can be mixed in the same list, and each entry is processed in turn. This is the main reason the Actor is easier to point at a target than an ID-based API.

Does YouTube Playlist Scraper work for AI agent workflows and LLM pipelines?

Yes. It is callable as a standard HTTP endpoint through the Apify API, so LangChain, CrewAI, n8n or a hand-written tool definition can invoke it and receive typed JSON. No parsing step is needed before passing a row into an LLM context window or a vector store.

How does YouTube Playlist Scraper handle YouTube's anti-bot measures?

The default configuration sends requests directly, with no proxy — which is the fastest and cheapest path and works for most runs. If YouTube blocks or throttles, the Actor falls back automatically to Apify datacenter proxies and then to residential. You never configure a proxy account or rotate an IP.

How does YouTube Playlist Scraper compare to other YouTube scrapers?

Checked on the Apify Store on 25 July 2026, the most-used YouTube Actors solve adjacent problems rather than this one. apidojo/youtube-scraper is a broad pay-per-result YouTube scraper covering multiple surfaces. karamelo/youtube-full-channel-transcripts-extractor targets transcript extraction across a whole channel. api-ninja/youtube-search-scraper handles search result sets. If you need transcripts or search, those are better fits. This Actor is narrower on purpose: playlist contents, with channel and playlist context joined onto every video row, and handle-or-keyword input so you do not need a resolved playlist ID to start.

Does YouTube Playlist Scraper return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with stable field names. No HTML, no selectors, no parsing. Pass a row directly into an LLM context window, index it into a vector store, or route it through an agent tool.

Can I use YouTube Playlist Scraper without managing proxies?

Yes. Proxy fallback is handled by the Actor — direct first, then datacenter, then residential. You send one API call and receive structured JSON.

What happens when YouTube changes its structure?

The scraper is maintained and the output schema is held stable across updates. Field names and types do not change on your end, so your integration keeps working without edits.

Your feedback

Found a bug, or missing a field YouTube exposes that is not in the output? Open an issue on the Actor's Issues tab. Reports with the exact input JSON and the playlist URL are the fastest to reproduce.