Youtube Playlist Scraper & Comments

YouTube Playlist Scraper — Videos and Nested Comment Threads

Youtube Playlist Scraper & Comments reads every video in a YouTube playlist — or a channel handle's playlists — and attaches each video's audience comments, including nested reply threads, in the same run. Each dataset row is one video: title, duration, views, channel and playlist context, plus a comments[] array holding comment text, author, approximate likes, relative timestamp and reply data. Every response is structured JSON — ready to pass directly to an LLM, index into a vector store, or feed a monitoring pipeline. Point it at a playlist URL or an @handle and the videos and their comments stream into the dataset as each one finishes.

What is Youtube Playlist Scraper & Comments?

Youtube Playlist Scraper & Comments is an Apify Actor that combines two jobs competing tools keep separate: reading a YouTube playlist's video listing, and pulling each video's comment thread from YouTube's internal youtubei/v1/next endpoint. Give it one or more playlist URLs or @channel handles and it returns one row per video, with that video's comments — and, optionally, their replies — nested directly on the row.

No YouTube account, login or cookie is required. The Actor sends anonymous requests (with only a standard EU-consent cookie set so pages render without a consent wall) and reads only what any visitor already sees.

Under the hood, the two jobs work differently. The playlist reader parses ytInitialData — the JSON payload YouTube embeds directly in the playlist page's HTML — and pulls the video list out of it (src/extract_playlist.py). The comment fetcher is a separate client for YouTube's internal youtubei/v1/next endpoint: it loads the video's watch page to harvest a clientVersion, visitorData and a comment continuation token, then paginates that endpoint to collect comments (src/comments.py). Both read structured data YouTube already renders — neither one screen-scrapes visible HTML text.

• Reads a playlist's full video listing in one crawl: title, duration, view count, thumbnail, channel and playlist metadata
• Resolves an @handle to that channel's playlists automatically, no need to look up playlist URLs by hand
• Attaches each video's top-level comments as a comments[] array in the same row, capped per video with commentsPerVideo
• Requests comments sorted by Top comments or Newest first via commentSort
• Optionally fetches and nests each comment's reply thread under comments[].replies[]
• Falls back from a direct connection to a datacenter, then residential proxy automatically if YouTube blocks a request

⚠️ Limitations to know before you start

Channel-handle playlist selection is not deterministic. When playlistInputs contains an @handle (or any input that resolves to a channel's /playlists page), the Actor collects that page's playlist links into a Python set() before taking the first 10 (src/main.py:430, extract_playlists_from_user_page). Set iteration order in Python is not guaranteed to be stable across runs, so which 10 playlists get processed — and in what order — can vary between two runs against the same channel. If you need a specific, repeatable playlist, pass its playlist URL directly instead of a handle.

Playlist videos are read from a single page load, with no follow-up pagination. The playlist reader makes one HTTP request per playlist and parses only the video list embedded in that page's initial ytInitialData payload (src/extract_playlist.py) — there is no continuation-token fetch for additional videos. If a playlist's initial page load renders fewer videos than your maxVideos value, you will get fewer rows than requested; this is a property of the single-request design, not a bug in the counting.

Reply threads are capped at 100 replies per comment, and comment pagination stops after 80 pages. Both are fixed in code (src/comments.py: cap: int = 100 in _fetch_replies, and page > 80 in scrape_comments) and are not exposed as input parameters — commentsPerVideo and includeReplies do not raise either ceiling.

commentsDisabled: false does not always mean comments were scraped successfully. It is true only when the watch page loads but exposes no comment continuation (comments genuinely turned off). It is false both when comments were fetched normally and when the watch page failed to load at all — check commentsScraped alongside it to tell the two apart. It is null only when includeComments was off for the whole run.

What data can you get with Youtube Playlist Scraper & Comments?

One run returns two things per playlist: the video listing, and each video's comment thread nested on its own row.

Result Type	Extracted Fields	Primary Use Case
Video	videoId, title, videoUrl, duration, durationLabel, viewCount, videoInfo, channel, playlistInfo, thumbnail.url, extractedAt	Playlist inventory, content audits, course/series tracking
Comment	text, author, authorChannelUrl, authorAvatarUrl, likesApprox, publishedTime, replyCount, isPinned, isHearted	Sentiment analysis, audience research, moderation review
Reply	text, author, authorChannelUrl, authorAvatarUrl, likesApprox, publishedTime	Conversation-thread analysis

Nested comment threads with replies

This is what separates this Actor from a video-only comments scraper: comments are not a second dataset you have to join yourself — they arrive already attached to the video that produced them, via playlistInfo linking each row back to its source playlist. Each comment carries likesApprox (YouTube exposes only a rounded like count, e.g. 1.2K, never an exact figure) and publishedTime as a relative string ("2 years ago" — YouTube does not publish an absolute comment timestamp). When includeReplies is on, every comment with replyCount > 0 gets its reply thread nested under comments[].replies[]:

{
  "text": "This tutorial saved me hours, thank you!",
  "author": "@devlearner22",
  "authorChannelUrl": "https://www.youtube.com/channel/UCabc123",
  "authorAvatarUrl": "https://yt3.ggpht.com/abc123",
  "likesApprox": 214,
  "publishedTime": "8 months ago",
  "replyCount": 2,
  "isPinned": false,
  "isHearted": true,
  "replies": [
    {
      "text": "Glad it helped!",
      "author": "@channelowner",
      "authorChannelUrl": "https://www.youtube.com/channel/UCowner",
      "authorAvatarUrl": "https://yt3.ggpht.com/owner",
      "likesApprox": 12,
      "publishedTime": "8 months ago"
    }
  ]
}

Video and playlist metadata

Every row also carries the video's own metadata and the playlist it was read from. channel is a nested object (name, id, url); playlistInfo carries playlistId, playlistUrl, playlistTitle, playlistDescription, owner, videoCount and totalVideosInPlaylist — plus lastUpdated, totalDuration and totalDurationMinutes, which are always null in the current build (src/extract_playlist.py, extract_playlist_info never assigns them). Use playlistInfo.playlistTitle to group video rows back into their source playlist when a run covers several.

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

The YouTube Data API v3 is Google's official interface for playlist and comment data, and it returns exact rather than approximate figures where the underlying data supports it — but every call is metered against a quota, and pulling a playlist's videos and their comments takes several separate resource calls per playlist.

Feature	YouTube Data API v3	Youtube Playlist Scraper & Comments
Setup	Google Cloud project, then an API key or OAuth 2.0 credential	Apify account only
Playlist videos	playlistItems.list, paginated per call	One playlistInputs entry crawls the whole playlist in one run
Video comments	commentThreads.list, called per video	comments[] attached automatically per video when includeComments is on
Reply threads	comments.list with a parent ID, called per thread	includeReplies nests comments[].replies[] automatically (capped at 100 per thread)
Default daily quota	10,000 units/day combined for most endpoints, per Google's published documentation (developers.google.com/youtube/v3/getting-started, checked 26 July 2026)	No YouTube-side quota; bounded by maxVideos and commentsPerVideo
Access to blocked/anti-bot responses	Not applicable — official, authenticated access	Apify Proxy auto-fallback: direct → datacenter → residential

Use the official API when you already have a Google Cloud project, need exact (non-approximate) counts, or are building on a supported, quota-governed integration. Use Youtube Playlist Scraper & Comments when you want a playlist's videos and comments in one run without managing a Google Cloud project, an API key, or per-resource pagination code.

What is the difference between a YouTube comments scraper and a playlist scraper with comments?

A comments-only scraper takes a single video or Shorts URL and returns that one video's comment thread — you have to already know which videos you want and supply each URL yourself. A playlist scraper with comments takes the playlist as the query: it discovers every video in it in one crawl, then attaches each video's comments to its own row automatically.

That distinction matters for anyone auditing a course, a channel's back-catalogue, or a competitor's video series — the input you actually have is usually the playlist link or the channel, not a hand-built list of video URLs. Youtube Playlist Scraper & Comments returns both objects in one run: the video row (videoId, playlistInfo) and its comments[] array, so you never have to run a separate video-discovery step before you can start pulling comments.

How to scrape a YouTube playlist and its comments with Youtube Playlist Scraper & Comments?

1. Open Youtube Playlist Scraper & Comments on its Apify Store listing and click Try for free
2. Paste one or more playlist URLs or @channel handles into Playlists to read (playlistInputs) — this is the only required input
3. Set Videos per playlist (maxVideos), Scrape comments (includeComments), Comments per video (commentsPerVideo), Comment order (commentSort) and Include replies (includeReplies) to shape coverage
4. Leave Network / proxy (proxyConfiguration) as-is, or set Apify Proxy — the Actor escalates automatically if YouTube blocks a request
5. Click Start, then download the dataset as JSON, CSV or Excel, or view it in the Videos & Comments table

How to run multiple playlists in one job

playlistInputs is a list — add as many playlist URLs or @handle entries as you need, and each is processed in turn, with its videos (and their comments) pushed to the dataset live as each one completes. An @handle resolves to that channel's /playlists page and processes the playlists found there (see the limitations above for the exact selection caveat on handle inputs).

⬇️ Input

Parameter	Required	Type	Description	Example Value
playlistInputs	Yes	array	One or more playlist URLs or @channel handles. Each playlist's videos are scraped, then their comments are attached per video. Minimum 1 item.	["https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw"]
maxVideos	No	integer	How many videos to read from each playlist before scraping comments. 0 = every video the playlist page exposes. Minimum 0, maximum 1000. Default 10.	25
includeVideoDetails	No	boolean	On = each row carries the full video record (thumbnail, videoInfo, durationLabel, channel & playlist objects, extractedAt). Off = a slim row. Default true.	true
includeComments	No	boolean	Attach a comments[] array to each video row (text, author, author channel, approx likes, relative time, reply count, pinned/hearted flags). Default true.	true
commentsPerVideo	No	integer	Cap on top-level comments collected per video. 0 = as many as the API paginates. Minimum 0, maximum 2000. Default 50.	100
commentSort	No	string	Which comment ranking to request from YouTube. One of top (Top comments), newest (Newest first). Default top.	top
includeReplies	No	boolean	For every top-level comment that has replies, fetch its reply thread and nest them under comments[].replies[]. Default false.	false
proxyConfiguration	No	object	Optional. Runs direct first, then auto-falls back datacenter → residential if YouTube blocks the playlist or comment requests.	{"useApifyProxy": false}

Example input

{
  "playlistInputs": [
    "https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw",
    "@kurzgesagt"
  ],
  "maxVideos": 25,
  "includeVideoDetails": true,
  "includeComments": true,
  "commentsPerVideo": 100,
  "commentSort": "top",
  "includeReplies": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

Common pitfall: playlistInputs accepts a full playlist URL (with ?list=...) or a bare @handle — a plain keyword or search phrase is not resolved and is logged as a warning with no rows produced for that entry. If you paste a channel's /videos or /playlists URL without a handle, use the @handle form instead so the Actor can resolve it.

⬆️ Output

Typed JSON, one row per video, pushed to the dataset live as each video (and its comments) finishes. Export as JSON, CSV or Excel from the Apify Console, or read the dataset through the Apify API.

Scraped results

A run with includeVideoDetails: true and includeComments: true — three rows from the same playlist:

[
  {
    "thumbnail.url": "https://i.ytimg.com/vi/abc123/hqdefault.jpg",
    "title": "Building a REST API in 20 Minutes",
    "videoUrl": "https://www.youtube.com/watch?v=abc123",
    "videoId": "abc123",
    "duration": "20:14",
    "durationLabel": "20 minutes, 14 seconds",
    "isPlayable": true,
    "channel": {
      "name": "DevLearner",
      "id": "UCabc123",
      "url": "https://www.youtube.com/@DevLearner"
    },
    "videoInfo": "184K views • 8 months ago",
    "playlistInfo": {
      "playlistId": "PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw",
      "playlistUrl": "https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw",
      "playlistTitle": "Backend Development Crash Course",
      "playlistDescription": null,
      "lastUpdated": null,
      "owner": "DevLearner",
      "videoCount": 42,
      "totalVideosInPlaylist": 42,
      "totalDuration": null,
      "totalDurationMinutes": null
    },
    "extractedAt": "2026-07-26T09:03:11Z",
    "viewCount": "184K views",
    "comments": [
      {
        "text": "This tutorial saved me hours, thank you!",
        "author": "@devlearner22",
        "authorChannelUrl": "https://www.youtube.com/channel/UCabc123",
        "authorAvatarUrl": "https://yt3.ggpht.com/abc123",
        "likesApprox": 214,
        "publishedTime": "8 months ago",
        "replyCount": 2,
        "isPinned": false,
        "isHearted": true
      }
    ],
    "commentsScraped": 100,
    "commentsDisabled": false
  },
  {
    "thumbnail.url": "https://i.ytimg.com/vi/def456/hqdefault.jpg",
    "title": "Deploying with Docker: A Practical Guide",
    "videoUrl": "https://www.youtube.com/watch?v=def456",
    "videoId": "def456",
    "duration": "15:47",
    "durationLabel": "15 minutes, 47 seconds",
    "isPlayable": true,
    "channel": {
      "name": "DevLearner",
      "id": "UCabc123",
      "url": "https://www.youtube.com/@DevLearner"
    },
    "videoInfo": "97K views • 6 months ago",
    "playlistInfo": {
      "playlistId": "PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw",
      "playlistUrl": "https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw",
      "playlistTitle": "Backend Development Crash Course",
      "playlistDescription": null,
      "lastUpdated": null,
      "owner": "DevLearner",
      "videoCount": 42,
      "totalVideosInPlaylist": 42,
      "totalDuration": null,
      "totalDurationMinutes": null
    },
    "extractedAt": "2026-07-26T09:03:42Z",
    "viewCount": "97K views",
    "comments": [],
    "commentsScraped": 0,
    "commentsDisabled": true
  },
  {
    "thumbnail.url": "https://i.ytimg.com/vi/ghi789/hqdefault.jpg",
    "title": "Kids Learning Video (Comments Off)",
    "videoUrl": "https://www.youtube.com/watch?v=ghi789",
    "videoId": "ghi789",
    "duration": "4:02",
    "durationLabel": "4 minutes, 2 seconds",
    "isPlayable": true,
    "channel": {
      "name": "DevLearner",
      "id": "UCabc123",
      "url": "https://www.youtube.com/@DevLearner"
    },
    "videoInfo": "12K views • 1 year ago",
    "playlistInfo": {
      "playlistId": "PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw",
      "playlistUrl": "https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw",
      "playlistTitle": "Backend Development Crash Course",
      "playlistDescription": null,
      "lastUpdated": null,
      "owner": "DevLearner",
      "videoCount": 42,
      "totalVideosInPlaylist": 42,
      "totalDuration": null,
      "totalDurationMinutes": null
    },
    "extractedAt": "2026-07-26T09:04:02Z",
    "comments": [],
    "commentsScraped": 0,
    "commentsDisabled": false
  }
]

Note the third row: no viewCount key at all — viewCount is only added to the row when the playlist page's metadata rows include a view count string; when they don't, the key is omitted rather than set to null (src/extract_playlist.py:232).

With includeVideoDetails: false, each row is slim instead:

{
  "videoId": "abc123",
  "title": "Building a REST API in 20 Minutes",
  "videoUrl": "https://www.youtube.com/watch?v=abc123",
  "duration": "20:14",
  "viewCount": "184K views",
  "channel": { "name": "DevLearner" },
  "playlistInfo": { "playlistTitle": "Backend Development Crash Course" },
  "comments": [],
  "commentsScraped": 100,
  "commentsDisabled": false
}

In the slim shape, viewCount is always present as a key — it is read with .get() from the underlying video record and comes back null rather than omitted when no view count was found, which differs from the full-row behaviour above.

Every pushed row is charged under the single row_result event (src/main.py:170, Actor.push_data(item, charged_event_name='row_result')); there are no separate uncharged accounting or error rows in this Actor.

How does Youtube Playlist Scraper & Comments handle rate limits and blocking?

Playlist reads and comment fetches use independent proxy states, each with the same escalation ladder: try a direct connection first, then an Apify datacenter proxy (SHADER group), then an Apify residential proxy — retrying up to 3 times on the residential rung with exponential backoff (src/main.py, src/comments.py). Once either state has escalated to residential it stays there for the rest of that request path rather than dropping back down.

For comments specifically, a 403 or 429 response triggers the same direct → datacenter → residential escalation inside make_request, with up to 3 attempts total per request (src/comments.py, MAX_RETRIES = 3, RETRY_DELAY = 2.0). A playlist or comment fetch that still fails after exhausting the ladder is logged and skipped — the run continues with the next playlist or video rather than stopping.

How can I use the data extracted with Youtube Playlist Scraper & Comments?

• Content and community managers: pull comments[] across a channel's playlist to see which videos are drawing engagement (likesApprox, replyCount) versus which have commentsDisabled: true, and prioritize moderation or reply effort accordingly.
• AI engineers and LLM developers: an agent issues a playlist URL, receives typed JSON with comments[].text per video, and passes it directly to a model as grounded context — no HTML parsing or scraping code in the agent itself.
• Market and audience researchers: compare videoInfo/viewCount against comment volume and sentiment across a competitor's playlist to gauge which topics land with their audience. Because commentSort: "newest" requests YouTube's own newest-first ranking, a repeated pull surfaces fresh reactions to a video without re-reading comments you already collected.
• Course and content curators: use playlistInfo.playlistTitle and videoCount to audit a training playlist's structure and confirm every video is still playable (isPlayable) and has an active comment section (commentsDisabled).
• Trust and safety / moderation teams: scan comments[].text and isHearted/isPinned flags across a playlist's videos to find where a creator has engaged with, or pinned, specific audience feedback, without opening each video individually.

How do you monitor playlist and comment activity over time?

Monitoring here means re-running the same playlistInputs on a schedule and diffing the results against the previous run. Because every row carries extractedAt, videoId and commentsScraped, you can detect two kinds of change: new videos added to a playlist (a videoId that wasn't in the previous run's rows) and rising engagement on an existing video (an increase in commentsScraped or in the likesApprox values inside comments[]).

The specific fields worth diffing between runs are videoId (new videos), commentsScraped (comment-volume change), and comments[]._cid-equivalent identity — since comment objects don't expose a stable ID field, use the combination of author + publishedTime + text to detect genuinely new comments rather than re-fetched ones.

A practical workflow: schedule a weekly run across a channel's key playlists with commentSort: "newest" and a modest commentsPerVideo, store each run's dataset, then alert when a video's commentsScraped jumps sharply or a previously commentsDisabled: true video flips to false. Set this up with Apify's Schedule feature on the Actor, which triggers a run automatically on a cron-style interval and writes each run to its own dataset.

Integrate Youtube Playlist Scraper & Comments and automate your workflow

Youtube Playlist Scraper & Comments works with any language or tool that can send an HTTP request, since it runs as a standard Apify Actor.

REST API with Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/youtube-playlist-scraper-comments").call(run_input={
    "playlistInputs": ["https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw"],
    "maxVideos": 25,
    "includeComments": True,
    "commentsPerVideo": 100,
})

for video in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(video["title"], video["commentsScraped"], "comments")

Scheduled monitoring and delivery

Use Apify's Schedule feature on the Actor to trigger runs automatically on a recurring interval — no code required. Each scheduled run writes to its own dataset, which you can pull with the same apify_client call above, or connect through Apify's integrations (Make, Zapier, Slack, Google Drive and others) to route new results wherever you need them.

Is it legal to scrape YouTube playlists and comments?

Scraping publicly accessible web pages is broadly permissible in the United States — courts have held that accessing data a website makes available to any visitor, without bypassing a login, does not violate the Computer Fraud and Abuse Act (hiQ Labs, Inc. v. LinkedIn Corp., 938 F.3d 985, 9th Cir. 2019). Youtube Playlist Scraper & Comments returns only what an anonymous visitor already sees on a playlist page or a video's comment section.

Comment data includes personal identifiers of individual commenters — display name/handle, channel URL and avatar image — so GDPR and CCPA-style personal-data obligations can attach to what you do with comments[] after extraction, even though the data itself was public. Video and playlist metadata (title, duration, view count) is the creator's own published content rather than personal data in the same sense.

Video and playlist titles, descriptions and view counts are the creator's own published content; systematically republishing them at scale — as opposed to extracting them for internal analysis — is governed by YouTube's own Terms of Service and general database/unfair-competition rules rather than personal-data law.

Scraping for one-off research carries a different risk profile than scraping at scale for AI training or resale. Consult your legal team for commercial use cases involving bulk storage or redistribution of comment data.

❓ Frequently asked questions

Does Youtube Playlist Scraper & Comments support comments in languages other than English?

No — the comment fetcher requests YouTube's youtubei endpoint with a hardcoded language='en' and region='US' (src/main.py:150-151), so comment text and relative timestamps come back in whatever language YouTube serves for that locale, not a language you can select per run.

Can I control which comments come back first?

Yes, with commentSort: top requests YouTube's Top comments ranking (the default), and newest requests comments in newest-first order. Both are requested directly from YouTube's own sort menu — the Actor harvests the matching continuation token from the watch page (src/comments.py, _extract_tokens) rather than fetching one ranking and re-sorting it locally, so the order you get matches what a visitor would see after clicking that same sort option.

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

Both the playlist reader and the comment fetcher escalate independently through a direct connection, then an Apify datacenter proxy, then an Apify residential proxy, retrying on the residential rung before giving up on that request. See "How does Youtube Playlist Scraper & Comments handle rate limits and blocking?" above for the exact ladder.

Does Youtube Playlist Scraper & Comments extract nested reply threads?

Yes — turn on includeReplies and every top-level comment with replyCount > 0 gets its replies fetched and nested under comments[].replies[]. Reply objects carry text, author, authorChannelUrl, authorAvatarUrl, likesApprox and publishedTime, but not replyCount, isPinned or isHearted, and replies are not nested more than one level deep. Reply fetching is capped at 100 replies per comment thread, hardcoded and not configurable.

How many videos and comments does Youtube Playlist Scraper & Comments return per playlist?

maxVideos accepts 0–1000 (default 10; 0 means every video on the playlist's initial page load). Because the playlist reader does not paginate beyond that single page load, very large playlists can return fewer videos than maxVideos requests — see the limitations section above. commentsPerVideo accepts 0–2000 per video (default 50; 0 means as many as YouTube's pagination exposes, subject to the 80-page internal cap).

How do I monitor a playlist's comment activity over time?

Schedule a recurring run on the same playlistInputs with Apify's Schedule feature, then compare each run's videoId list (for new videos) and commentsScraped values (for engagement change) against the previous run's dataset. See "How do you monitor playlist and comment activity over time?" above for the full workflow.

Does Youtube Playlist Scraper & Comments work with Claude, ChatGPT and other AI agent frameworks?

Yes. It is callable as a standard HTTP endpoint through the Apify API, so any agent framework that can make a request — LangChain, CrewAI, a custom tool definition — can trigger a run and receive typed JSON with comments[] already attached per video, ready to use as grounded context.

How does Youtube Playlist Scraper & Comments compare to other YouTube scrapers?

Checked on the Apify Store on 26 July 2026: streamers/youtube-comments-scraper and apidojo/youtube-comments-scraper both take video or Shorts URLs and return comment threads for those specific videos — neither discovers a playlist's video list for you, so you need your own list of video URLs before either can start. apidojo/youtube-scraper-api covers videos, channels, playlists and search in one Actor, but its own FAQ states it returns comment counts only and points readers to a separate comments Actor for full comment threads — meaning a playlist-plus-comments job on that ecosystem needs two Actor runs and a join step. Youtube Playlist Scraper & Comments' difference is doing both in one run: discovering a playlist's (or channel handle's) videos and attaching each one's full comment thread — including nested replies — without a second Actor or a hand-built list of video URLs.

Can I use Youtube Playlist Scraper & Comments without managing proxies or YouTube credentials?

Yes. No YouTube account, cookie or API key is required — the Actor sends anonymous requests. Proxy escalation (direct → datacenter → residential) is automatic for both the playlist reader and the comment fetcher; you only need to supply a proxyConfiguration if you want to force a starting tier. The one credential you need is your Apify account to run the Actor.

💬 Your feedback

Found a bug, or hit a video/playlist shape the Actor doesn't handle? Let us know on the Actor's Issues tab on Apify — reports that include the playlist or video URL and the run's input JSON are the fastest to reproduce and fix.