21 from .common
import InfoExtractor
, SearchInfoExtractor
22 from .openload
import PhantomJSwrapper
23 from ..compat
import functools
24 from ..jsinterp
import JSInterpreter
69 STREAMING_DATA_CLIENT_NAME
= '__yt_dlp_client'
70 # any clients starting with _ cannot be explicitly requested by the user
73 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
74 'INNERTUBE_CONTEXT': {
77 'clientVersion': '2.20220801.00.00',
80 'INNERTUBE_CONTEXT_CLIENT_NAME': 1
83 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
84 'INNERTUBE_CONTEXT': {
86 'clientName': 'WEB_EMBEDDED_PLAYER',
87 'clientVersion': '1.20220731.00.00',
90 'INNERTUBE_CONTEXT_CLIENT_NAME': 56
93 'INNERTUBE_API_KEY': 'AIzaSyC9XL3ZjWddXya6X74dJoCTL-WEYFDNX30',
94 'INNERTUBE_HOST': 'music.youtube.com',
95 'INNERTUBE_CONTEXT': {
97 'clientName': 'WEB_REMIX',
98 'clientVersion': '1.20220727.01.00',
101 'INNERTUBE_CONTEXT_CLIENT_NAME': 67,
104 'INNERTUBE_API_KEY': 'AIzaSyBUPetSUmoZL-OhlxA7wSac5XinrygCqMo',
105 'INNERTUBE_CONTEXT': {
107 'clientName': 'WEB_CREATOR',
108 'clientVersion': '1.20220726.00.00',
111 'INNERTUBE_CONTEXT_CLIENT_NAME': 62,
114 'INNERTUBE_API_KEY': 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w',
115 'INNERTUBE_CONTEXT': {
117 'clientName': 'ANDROID',
118 'clientVersion': '17.31.35',
119 'androidSdkVersion': 30,
120 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
123 'INNERTUBE_CONTEXT_CLIENT_NAME': 3,
124 'REQUIRE_JS_PLAYER': False
126 'android_embedded': {
127 'INNERTUBE_API_KEY': 'AIzaSyCjc_pVEDi4qsv5MtC2dMXzpIaDoRFLsxw',
128 'INNERTUBE_CONTEXT': {
130 'clientName': 'ANDROID_EMBEDDED_PLAYER',
131 'clientVersion': '17.31.35',
132 'androidSdkVersion': 30,
133 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
136 'INNERTUBE_CONTEXT_CLIENT_NAME': 55,
137 'REQUIRE_JS_PLAYER': False
140 'INNERTUBE_API_KEY': 'AIzaSyAOghZGza2MQSZkY_zfZ370N-PUdXEo8AI',
141 'INNERTUBE_CONTEXT': {
143 'clientName': 'ANDROID_MUSIC',
144 'clientVersion': '5.16.51',
145 'androidSdkVersion': 30,
146 'userAgent': 'com.google.android.apps.youtube.music/5.16.51 (Linux; U; Android 11) gzip'
149 'INNERTUBE_CONTEXT_CLIENT_NAME': 21,
150 'REQUIRE_JS_PLAYER': False
153 'INNERTUBE_API_KEY': 'AIzaSyD_qjV8zaaUMehtLkrKFgVeSX_Iqbtyws8',
154 'INNERTUBE_CONTEXT': {
156 'clientName': 'ANDROID_CREATOR',
157 'clientVersion': '22.30.100',
158 'androidSdkVersion': 30,
159 'userAgent': 'com.google.android.apps.youtube.creator/22.30.100 (Linux; U; Android 11) gzip'
162 'INNERTUBE_CONTEXT_CLIENT_NAME': 14,
163 'REQUIRE_JS_PLAYER': False
165 # iOS clients have HLS live streams. Setting device model to get 60fps formats.
166 # See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/680#issuecomment-1002724558
168 'INNERTUBE_API_KEY': 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc',
169 'INNERTUBE_CONTEXT': {
172 'clientVersion': '17.33.2',
173 'deviceModel': 'iPhone14,3',
174 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
177 'INNERTUBE_CONTEXT_CLIENT_NAME': 5,
178 'REQUIRE_JS_PLAYER': False
181 'INNERTUBE_CONTEXT': {
183 'clientName': 'IOS_MESSAGES_EXTENSION',
184 'clientVersion': '17.33.2',
185 'deviceModel': 'iPhone14,3',
186 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
189 'INNERTUBE_CONTEXT_CLIENT_NAME': 66,
190 'REQUIRE_JS_PLAYER': False
193 'INNERTUBE_API_KEY': 'AIzaSyBAETezhkwP0ZWA02RsqT1zu78Fpt0bC_s',
194 'INNERTUBE_CONTEXT': {
196 'clientName': 'IOS_MUSIC',
197 'clientVersion': '5.21',
198 'deviceModel': 'iPhone14,3',
199 'userAgent': 'com.google.ios.youtubemusic/5.21 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
202 'INNERTUBE_CONTEXT_CLIENT_NAME': 26,
203 'REQUIRE_JS_PLAYER': False
206 'INNERTUBE_CONTEXT': {
208 'clientName': 'IOS_CREATOR',
209 'clientVersion': '22.33.101',
210 'deviceModel': 'iPhone14,3',
211 'userAgent': 'com.google.ios.ytcreator/22.33.101 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
214 'INNERTUBE_CONTEXT_CLIENT_NAME': 15,
215 'REQUIRE_JS_PLAYER': False
217 # mweb has 'ultralow' formats
218 # See: https://github.com/yt-dlp/yt-dlp/pull/557
220 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
221 'INNERTUBE_CONTEXT': {
223 'clientName': 'MWEB',
224 'clientVersion': '2.20220801.00.00',
227 'INNERTUBE_CONTEXT_CLIENT_NAME': 2
229 # This client can access age restricted videos (unless the uploader has disabled the 'allow embedding' option)
230 # See: https://github.com/zerodytrash/YouTube-Internal-Clients
232 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
233 'INNERTUBE_CONTEXT': {
235 'clientName': 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
236 'clientVersion': '2.0',
239 'INNERTUBE_CONTEXT_CLIENT_NAME': 85
244 def _split_innertube_client(client_name
):
245 variant
, *base
= client_name
.rsplit('.', 1)
247 return variant
, base
[0], variant
248 base
, *variant
= client_name
.split('_', 1)
249 return client_name
, base
, variant
[0] if variant
else None
252 def short_client_name(client_name
):
253 main
, *parts
= _split_innertube_client(client_name
)[0].replace('embedscreen', 'e_s').split('_')
254 return join_nonempty(main
[:4], ''.join(x
[0] for x
in parts
)).upper()
257 def build_innertube_clients():
259 'embedUrl': 'https://www.youtube.com/', # Can be any valid URL
261 BASE_CLIENTS
= ('android', 'web', 'tv', 'ios', 'mweb')
262 priority
= qualities(BASE_CLIENTS
[::-1])
264 for client
, ytcfg
in tuple(INNERTUBE_CLIENTS
.items()):
265 ytcfg
.setdefault('INNERTUBE_API_KEY', 'AIzaSyDCU8hByM-4DrUqRUYnGn-3llEO78bcxq8')
266 ytcfg
.setdefault('INNERTUBE_HOST', 'www.youtube.com')
267 ytcfg
.setdefault('REQUIRE_JS_PLAYER', True)
268 ytcfg
['INNERTUBE_CONTEXT']['client'].setdefault('hl', 'en')
270 _
, base_client
, variant
= _split_innertube_client(client
)
271 ytcfg
['priority'] = 10 * priority(base_client
)
274 INNERTUBE_CLIENTS
[f
'{client}_embedscreen'] = embedscreen
= copy
.deepcopy(ytcfg
)
275 embedscreen
['INNERTUBE_CONTEXT']['client']['clientScreen'] = 'EMBED'
276 embedscreen
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
277 embedscreen
['priority'] -= 3
278 elif variant
== 'embedded':
279 ytcfg
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
280 ytcfg
['priority'] -= 2
282 ytcfg
['priority'] -= 3
285 build_innertube_clients()
288 class BadgeType(enum
.Enum
):
289 AVAILABILITY_UNLISTED
= enum
.auto()
290 AVAILABILITY_PRIVATE
= enum
.auto()
291 AVAILABILITY_PUBLIC
= enum
.auto()
292 AVAILABILITY_PREMIUM
= enum
.auto()
293 AVAILABILITY_SUBSCRIPTION
= enum
.auto()
294 LIVE_NOW
= enum
.auto()
297 class YoutubeBaseInfoExtractor(InfoExtractor
):
298 """Provide base functions for Youtube extractors"""
301 r
'channel|c|user|playlist|watch|w|v|embed|e|live|watch_popup|clip|'
302 r
'shorts|movies|results|search|shared|hashtag|trending|explore|feed|feeds|'
303 r
'browse|oembed|get_video_info|iframe_api|s/player|source|'
304 r
'storefront|oops|index|account|t/terms|about|upload|signin|logout')
306 _PLAYLIST_ID_RE
= r
'(?:(?:PL|LL|EC|UU|FL|RD|UL|TL|PU|OLAK5uy_)[0-9A-Za-z-_]{10,}|RDMM|WL|LL|LM)'
308 # _NETRC_MACHINE = 'youtube'
310 # If True it will raise an error if no login info is provided
311 _LOGIN_REQUIRED
= False
314 # invidious-redirect websites
315 r
'(?:www\.)?redirect\.invidious\.io',
316 r
'(?:(?:www|dev)\.)?invidio\.us',
317 # Invidious instances taken from https://github.com/iv-org/documentation/blob/master/docs/instances.md
318 r
'(?:www\.)?invidious\.pussthecat\.org',
319 r
'(?:www\.)?invidious\.zee\.li',
320 r
'(?:www\.)?invidious\.ethibox\.fr',
321 r
'(?:www\.)?iv\.ggtyler\.dev',
322 r
'(?:www\.)?inv\.vern\.i2p',
323 r
'(?:www\.)?am74vkcrjp2d5v36lcdqgsj2m6x36tbrkhsruoegwfcizzabnfgf5zyd\.onion',
324 r
'(?:www\.)?inv\.riverside\.rocks',
325 r
'(?:www\.)?invidious\.silur\.me',
326 r
'(?:www\.)?inv\.bp\.projectsegfau\.lt',
327 r
'(?:www\.)?invidious\.g4c3eya4clenolymqbpgwz3q3tawoxw56yhzk4vugqrl6dtu3ejvhjid\.onion',
328 r
'(?:www\.)?invidious\.slipfox\.xyz',
329 r
'(?:www\.)?invidious\.esmail5pdn24shtvieloeedh7ehz3nrwcdivnfhfcedl7gf4kwddhkqd\.onion',
330 r
'(?:www\.)?inv\.vernccvbvyi5qhfzyqengccj7lkove6bjot2xhh5kajhwvidqafczrad\.onion',
331 r
'(?:www\.)?invidious\.tiekoetter\.com',
332 r
'(?:www\.)?iv\.odysfvr23q5wgt7i456o5t3trw2cw5dgn56vbjfbq2m7xsc5vqbqpcyd\.onion',
333 r
'(?:www\.)?invidious\.nerdvpn\.de',
334 r
'(?:www\.)?invidious\.weblibre\.org',
335 r
'(?:www\.)?inv\.odyssey346\.dev',
336 r
'(?:www\.)?invidious\.dhusch\.de',
337 r
'(?:www\.)?iv\.melmac\.space',
338 r
'(?:www\.)?watch\.thekitty\.zone',
339 r
'(?:www\.)?invidious\.privacydev\.net',
340 r
'(?:www\.)?ng27owmagn5amdm7l5s3rsqxwscl5ynppnis5dqcasogkyxcfqn7psid\.onion',
341 r
'(?:www\.)?invidious\.drivet\.xyz',
342 r
'(?:www\.)?vid\.priv\.au',
343 r
'(?:www\.)?euxxcnhsynwmfidvhjf6uzptsmh4dipkmgdmcmxxuo7tunp3ad2jrwyd\.onion',
344 r
'(?:www\.)?inv\.vern\.cc',
345 r
'(?:www\.)?invidious\.esmailelbob\.xyz',
346 r
'(?:www\.)?invidious\.sethforprivacy\.com',
347 r
'(?:www\.)?yt\.oelrichsgarcia\.de',
348 r
'(?:www\.)?yt\.artemislena\.eu',
349 r
'(?:www\.)?invidious\.flokinet\.to',
350 r
'(?:www\.)?invidious\.baczek\.me',
351 r
'(?:www\.)?y\.com\.sb',
352 r
'(?:www\.)?invidious\.epicsite\.xyz',
353 r
'(?:www\.)?invidious\.lidarshield\.cloud',
354 r
'(?:www\.)?yt\.funami\.tech',
355 r
'(?:www\.)?invidious\.3o7z6yfxhbw7n3za4rss6l434kmv55cgw2vuziwuigpwegswvwzqipyd\.onion',
356 r
'(?:www\.)?osbivz6guyeahrwp2lnwyjk2xos342h4ocsxyqrlaopqjuhwn2djiiyd\.onion',
357 r
'(?:www\.)?u2cvlit75owumwpy4dj2hsmvkq7nvrclkpht7xgyye2pyoxhpmclkrad\.onion',
358 # youtube-dl invidious instances list
359 r
'(?:(?:www|no)\.)?invidiou\.sh',
360 r
'(?:(?:www|fi)\.)?invidious\.snopyta\.org',
361 r
'(?:www\.)?invidious\.kabi\.tk',
362 r
'(?:www\.)?invidious\.mastodon\.host',
363 r
'(?:www\.)?invidious\.zapashcanon\.fr',
364 r
'(?:www\.)?(?:invidious(?:-us)?|piped)\.kavin\.rocks',
365 r
'(?:www\.)?invidious\.tinfoil-hat\.net',
366 r
'(?:www\.)?invidious\.himiko\.cloud',
367 r
'(?:www\.)?invidious\.reallyancient\.tech',
368 r
'(?:www\.)?invidious\.tube',
369 r
'(?:www\.)?invidiou\.site',
370 r
'(?:www\.)?invidious\.site',
371 r
'(?:www\.)?invidious\.xyz',
372 r
'(?:www\.)?invidious\.nixnet\.xyz',
373 r
'(?:www\.)?invidious\.048596\.xyz',
374 r
'(?:www\.)?invidious\.drycat\.fr',
375 r
'(?:www\.)?inv\.skyn3t\.in',
376 r
'(?:www\.)?tube\.poal\.co',
377 r
'(?:www\.)?tube\.connect\.cafe',
378 r
'(?:www\.)?vid\.wxzm\.sx',
379 r
'(?:www\.)?vid\.mint\.lgbt',
380 r
'(?:www\.)?vid\.puffyan\.us',
381 r
'(?:www\.)?yewtu\.be',
382 r
'(?:www\.)?yt\.elukerio\.org',
383 r
'(?:www\.)?yt\.lelux\.fi',
384 r
'(?:www\.)?invidious\.ggc-project\.de',
385 r
'(?:www\.)?yt\.maisputain\.ovh',
386 r
'(?:www\.)?ytprivate\.com',
387 r
'(?:www\.)?invidious\.13ad\.de',
388 r
'(?:www\.)?invidious\.toot\.koeln',
389 r
'(?:www\.)?invidious\.fdn\.fr',
390 r
'(?:www\.)?watch\.nettohikari\.com',
391 r
'(?:www\.)?invidious\.namazso\.eu',
392 r
'(?:www\.)?invidious\.silkky\.cloud',
393 r
'(?:www\.)?invidious\.exonip\.de',
394 r
'(?:www\.)?invidious\.riverside\.rocks',
395 r
'(?:www\.)?invidious\.blamefran\.net',
396 r
'(?:www\.)?invidious\.moomoo\.de',
397 r
'(?:www\.)?ytb\.trom\.tf',
398 r
'(?:www\.)?yt\.cyberhost\.uk',
399 r
'(?:www\.)?kgg2m7yk5aybusll\.onion',
400 r
'(?:www\.)?qklhadlycap4cnod\.onion',
401 r
'(?:www\.)?axqzx4s6s54s32yentfqojs3x5i7faxza6xo3ehd4bzzsg2ii4fv2iid\.onion',
402 r
'(?:www\.)?c7hqkpkpemu6e7emz5b4vyz7idjgdvgaaa3dyimmeojqbgpea3xqjoid\.onion',
403 r
'(?:www\.)?fz253lmuao3strwbfbmx46yu7acac2jz27iwtorgmbqlkurlclmancad\.onion',
404 r
'(?:www\.)?invidious\.l4qlywnpwqsluw65ts7md3khrivpirse744un3x7mlskqauz5pyuzgqd\.onion',
405 r
'(?:www\.)?owxfohz4kjyv25fvlqilyxast7inivgiktls3th44jhk3ej3i7ya\.b32\.i2p',
406 r
'(?:www\.)?4l2dgddgsrkf2ous66i6seeyi6etzfgrue332grh2n7madpwopotugyd\.onion',
407 r
'(?:www\.)?w6ijuptxiku4xpnnaetxvnkc5vqcdu7mgns2u77qefoixi63vbvnpnqd\.onion',
408 r
'(?:www\.)?kbjggqkzv65ivcqj6bumvp337z6264huv5kpkwuv6gu5yjiskvan7fad\.onion',
409 r
'(?:www\.)?grwp24hodrefzvjjuccrkw3mjq4tzhaaq32amf33dzpmuxe7ilepcmad\.onion',
410 r
'(?:www\.)?hpniueoejy4opn7bc4ftgazyqjoeqwlvh2uiku2xqku6zpoa4bf5ruid\.onion',
411 # piped instances from https://github.com/TeamPiped/Piped/wiki/Instances
412 r
'(?:www\.)?piped\.kavin\.rocks',
413 r
'(?:www\.)?piped\.tokhmi\.xyz',
414 r
'(?:www\.)?piped\.syncpundit\.io',
415 r
'(?:www\.)?piped\.mha\.fi',
416 r
'(?:www\.)?watch\.whatever\.social',
417 r
'(?:www\.)?piped\.garudalinux\.org',
418 r
'(?:www\.)?piped\.rivo\.lol',
419 r
'(?:www\.)?piped-libre\.kavin\.rocks',
420 r
'(?:www\.)?yt\.jae\.fi',
421 r
'(?:www\.)?piped\.mint\.lgbt',
423 r
'(?:www\.)?piped\.esmailelbob\.xyz',
424 r
'(?:www\.)?piped\.projectsegfau\.lt',
425 r
'(?:www\.)?piped\.privacydev\.net',
426 r
'(?:www\.)?piped\.palveluntarjoaja\.eu',
427 r
'(?:www\.)?piped\.smnz\.de',
428 r
'(?:www\.)?piped\.adminforge\.de',
429 r
'(?:www\.)?watch\.whatevertinfoil\.de',
430 r
'(?:www\.)?piped\.qdi\.fi',
431 r
'(?:www\.)?piped\.video',
432 r
'(?:www\.)?piped\.aeong\.one',
433 r
'(?:www\.)?piped\.moomoo\.me',
434 r
'(?:www\.)?piped\.chauvet\.pro',
435 r
'(?:www\.)?watch\.leptons\.xyz',
436 r
'(?:www\.)?pd\.vern\.cc',
437 r
'(?:www\.)?piped\.hostux\.net',
438 r
'(?:www\.)?piped\.lunar\.icu',
439 # Hyperpipe instances from https://hyperpipe.codeberg.page/
440 r
'(?:www\.)?hyperpipe\.surge\.sh',
441 r
'(?:www\.)?hyperpipe\.esmailelbob\.xyz',
442 r
'(?:www\.)?listen\.whatever\.social',
443 r
'(?:www\.)?music\.adminforge\.de',
446 # extracted from account/account_menu ep
447 # XXX: These are the supported YouTube UI and API languages,
448 # which is slightly different from languages supported for translation in YouTube studio
449 _SUPPORTED_LANG_CODES
= [
450 'af', 'az', 'id', 'ms', 'bs', 'ca', 'cs', 'da', 'de', 'et', 'en-IN', 'en-GB', 'en', 'es',
451 'es-419', 'es-US', 'eu', 'fil', 'fr', 'fr-CA', 'gl', 'hr', 'zu', 'is', 'it', 'sw', 'lv',
452 'lt', 'hu', 'nl', 'no', 'uz', 'pl', 'pt-PT', 'pt', 'ro', 'sq', 'sk', 'sl', 'sr-Latn', 'fi',
453 'sv', 'vi', 'tr', 'be', 'bg', 'ky', 'kk', 'mk', 'mn', 'ru', 'sr', 'uk', 'el', 'hy', 'iw',
454 'ur', 'ar', 'fa', 'ne', 'mr', 'hi', 'as', 'bn', 'pa', 'gu', 'or', 'ta', 'te', 'kn', 'ml',
455 'si', 'th', 'lo', 'my', 'ka', 'am', 'km', 'zh-CN', 'zh-TW', 'zh-HK', 'ja', 'ko'
458 _IGNORED_WARNINGS
= {'Unavailable videos will be hidden during playback'}
460 _YT_HANDLE_RE
= r
'@[\w.-]{3,30}' # https://support.google.com/youtube/answer/11585688?hl=en
461 _YT_CHANNEL_UCID_RE
= r
'UC[\w-]{22}'
463 def ucid_or_none(self
, ucid
):
464 return self
._search
_regex
(rf
'^({self._YT_CHANNEL_UCID_RE})$', ucid
, 'UC-id', default
=None)
466 def handle_or_none(self
, handle
):
467 return self
._search
_regex
(rf
'^({self._YT_HANDLE_RE})$', handle
, '@-handle', default
=None)
469 def handle_from_url(self
, url
):
470 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_HANDLE_RE})',
471 url
, 'channel handle', default
=None)
473 def ucid_from_url(self
, url
):
474 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_CHANNEL_UCID_RE})',
475 url
, 'channel id', default
=None)
477 @functools.cached_property
478 def _preferred_lang(self
):
480 Returns a language code supported by YouTube for the user preferred language.
481 Returns None if no preferred language set.
483 preferred_lang
= self
._configuration
_arg
('lang', ie_key
='Youtube', casesense
=True, default
=[''])[0]
484 if not preferred_lang
:
486 if preferred_lang
not in self
._SUPPORTED
_LANG
_CODES
:
487 raise ExtractorError(
488 f
'Unsupported language code: {preferred_lang}. Supported language codes (case-sensitive): {join_nonempty(*self._SUPPORTED_LANG_CODES, delim=", ")}.',
490 elif preferred_lang
!= 'en':
492 f
'Preferring "{preferred_lang}" translated fields. Note that some metadata extraction may fail or be incorrect.')
493 return preferred_lang
495 def _initialize_consent(self
):
496 cookies
= self
._get
_cookies
('https://www.youtube.com/')
497 if cookies
.get('__Secure-3PSID'):
500 consent
= cookies
.get('CONSENT')
502 if 'YES' in consent
.value
:
504 consent_id
= self
._search
_regex
(
505 r
'PENDING\+(\d+)', consent
.value
, 'consent', default
=None)
507 consent_id
= random
.randint(100, 999)
508 self
._set
_cookie
('.youtube.com', 'CONSENT', 'YES+cb.20210328-17-p0.en+FX+%s' % consent_id
)
510 def _initialize_pref(self
):
511 cookies
= self
._get
_cookies
('https://www.youtube.com/')
512 pref_cookie
= cookies
.get('PREF')
516 pref
= dict(urllib
.parse
.parse_qsl(pref_cookie
.value
))
518 self
.report_warning('Failed to parse user PREF cookie' + bug_reports_message())
519 pref
.update({'hl': self._preferred_lang or 'en', 'tz': 'UTC'}
)
520 self
._set
_cookie
('.youtube.com', name
='PREF', value
=urllib
.parse
.urlencode(pref
))
522 def _real_initialize(self
):
523 self
._initialize
_pref
()
524 self
._initialize
_consent
()
525 self
._check
_login
_required
()
527 def _check_login_required(self
):
528 if self
._LOGIN
_REQUIRED
and not self
._cookies
_passed
:
529 self
.raise_login_required('Login details are needed to download this content', method
='cookies')
531 _YT_INITIAL_DATA_RE
= r
'(?:window\s*\[\s*["\']ytInitialData
["\']\s*\]|ytInitialData)\s*='
532 _YT_INITIAL_PLAYER_RESPONSE_RE = r'ytInitialPlayerResponse\s*='
534 def _get_default_ytcfg(self, client='web'):
535 return copy.deepcopy(INNERTUBE_CLIENTS[client])
537 def _get_innertube_host(self, client='web'):
538 return INNERTUBE_CLIENTS[client]['INNERTUBE_HOST']
540 def _ytcfg_get_safe(self, ytcfg, getter, expected_type=None, default_client='web'):
541 # try_get but with fallback to default ytcfg client values when present
542 _func = lambda y: try_get(y, getter, expected_type)
543 return _func(ytcfg) or _func(self._get_default_ytcfg(default_client))
545 def _extract_client_name(self, ytcfg, default_client='web'):
546 return self._ytcfg_get_safe(
547 ytcfg, (lambda x: x['INNERTUBE_CLIENT_NAME'],
548 lambda x: x['INNERTUBE_CONTEXT']['client']['clientName']), str, default_client)
550 def _extract_client_version(self, ytcfg, default_client='web'):
551 return self._ytcfg_get_safe(
552 ytcfg, (lambda x: x['INNERTUBE_CLIENT_VERSION'],
553 lambda x: x['INNERTUBE_CONTEXT']['client']['clientVersion']), str, default_client)
555 def _select_api_hostname(self, req_api_hostname, default_client=None):
556 return (self._configuration_arg('innertube_host', [''], ie_key=YoutubeIE.ie_key())[0]
557 or req_api_hostname or self._get_innertube_host(default_client or 'web'))
559 def _extract_api_key(self, ytcfg=None, default_client='web'):
560 return self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_API_KEY'], str, default_client)
562 def _extract_context(self, ytcfg=None, default_client='web'):
564 (ytcfg, self._get_default_ytcfg(default_client)), 'INNERTUBE_CONTEXT', expected_type=dict)
565 # Enforce language and tz for extraction
566 client_context = traverse_obj(context, 'client', expected_type=dict, default={})
567 client_context.update({'hl': self._preferred_lang or 'en', 'timeZone': 'UTC', 'utcOffsetMinutes': 0})
572 def _generate_sapisidhash_header(self, origin='https://www.youtube.com'):
573 time_now = round(time.time())
574 if self._SAPISID is None:
575 yt_cookies = self._get_cookies('https://www.youtube.com')
576 # Sometimes SAPISID cookie isn't present but __Secure-3PAPISID is.
577 # See: https://github.com/yt-dlp/yt-dlp/issues/393
578 sapisid_cookie = dict_get(
579 yt_cookies, ('__Secure-3PAPISID', 'SAPISID'))
580 if sapisid_cookie and sapisid_cookie.value:
581 self._SAPISID = sapisid_cookie.value
582 self.write_debug('Extracted SAPISID cookie')
583 # SAPISID cookie is required if not already present
584 if not yt_cookies.get('SAPISID'):
585 self.write_debug('Copying __Secure-3PAPISID cookie to SAPISID cookie')
587 '.youtube.com', 'SAPISID', self._SAPISID, secure=True, expire_time=time_now + 3600)
589 self._SAPISID = False
590 if not self._SAPISID:
592 # SAPISIDHASH algorithm from https://stackoverflow.com/a/32065323
593 sapisidhash = hashlib.sha1(
594 f'{time_now} {self._SAPISID} {origin}'.encode()).hexdigest()
595 return f'SAPISIDHASH {time_now}_{sapisidhash}'
597 def _call_api(self, ep, query, video_id, fatal=True, headers=None,
598 note='Downloading API JSON', errnote='Unable to download API page',
599 context=None, api_key=None, api_hostname=None, default_client='web'):
601 data = {'context': context} if context else {'context': self._extract_context(default_client=default_client)}
603 real_headers = self.generate_api_headers(default_client=default_client)
604 real_headers.update({'content-type': 'application/json'})
606 real_headers.update(headers)
607 api_key = (self._configuration_arg('innertube_key', [''], ie_key=YoutubeIE.ie_key(), casesense=True)[0]
608 or api_key or self._extract_api_key(default_client=default_client))
609 return self._download_json(
610 f'https://{self._select_api_hostname(api_hostname, default_client)}/youtubei/v1/{ep}',
611 video_id=video_id, fatal=fatal, note=note, errnote=errnote,
612 data=json.dumps(data).encode('utf8'), headers=real_headers,
613 query={'key': api_key, 'prettyPrint': 'false'})
615 def extract_yt_initial_data(self, item_id, webpage, fatal=True):
616 return self._search_json(self._YT_INITIAL_DATA_RE, webpage, 'yt initial data', item_id, fatal=fatal)
619 def _extract_session_index(*data):
621 Index of current account in account list.
622 See: https://github.com/yt-dlp/yt-dlp/pull/519
625 session_index = int_or_none(try_get(ytcfg, lambda x: x['SESSION_INDEX']))
626 if session_index is not None:
630 def _extract_identity_token(self, ytcfg=None, webpage=None):
632 token = try_get(ytcfg, lambda x: x['ID_TOKEN'], str)
636 return self._search_regex(
637 r'\bID_TOKEN["\']\s
*:\s
*["\'](.+?)["\']', webpage,
638 'identity token
', default=None, fatal=False)
641 def _extract_account_syncid(*args):
643 Extract syncId required to download private playlists of secondary channels
644 @params response and/or ytcfg
647 # ytcfg includes channel_syncid if on secondary channel
648 delegated_sid = try_get(data, lambda x: x['DELEGATED_SESSION_ID
'], str)
652 data, (lambda x: x['responseContext
']['mainAppWebResponseContext
']['datasyncId
'],
653 lambda x: x['DATASYNC_ID
']), str) or '').split('||
')
654 if len(sync_ids) >= 2 and sync_ids[1]:
655 # datasyncid is of the form "channel_syncid||user_syncid" for secondary channel
656 # and just "user_syncid||" for primary channel. We only want the channel_syncid
660 def _extract_visitor_data(*args):
662 Extracts visitorData from an API response or ytcfg
663 Appears to be used to track session state
666 args, [('VISITOR_DATA
', ('INNERTUBE_CONTEXT
', 'client
', 'visitorData
'), ('responseContext
', 'visitorData
'))],
669 @functools.cached_property
670 def is_authenticated(self):
671 return bool(self._generate_sapisidhash_header())
673 def extract_ytcfg(self, video_id, webpage):
676 return self._parse_json(
678 r'ytcfg\
.set\s
*\
(\s
*({.+?}
)\s
*\
)\s
*;', webpage, 'ytcfg
',
679 default='{}'), video_id, fatal=False) or {}
681 def generate_api_headers(
682 self
, *, ytcfg
=None, account_syncid
=None, session_index
=None,
683 visitor_data
=None, identity_token
=None, api_hostname
=None, default_client
='web'):
685 origin
= 'https://' + (self
._select
_api
_hostname
(api_hostname
, default_client
))
687 'X-YouTube-Client-Name': str(
688 self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT_CLIENT_NAME'], default_client
=default_client
)),
689 'X-YouTube-Client-Version': self
._extract
_client
_version
(ytcfg
, default_client
),
691 'X-Youtube-Identity-Token': identity_token
or self
._extract
_identity
_token
(ytcfg
),
692 'X-Goog-PageId': account_syncid
or self
._extract
_account
_syncid
(ytcfg
),
693 'X-Goog-Visitor-Id': visitor_data
or self
._extract
_visitor
_data
(ytcfg
),
694 'User-Agent': self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT']['client']['userAgent'], default_client
=default_client
)
696 if session_index
is None:
697 session_index
= self
._extract
_session
_index
(ytcfg
)
698 if account_syncid
or session_index
is not None:
699 headers
['X-Goog-AuthUser'] = session_index
if session_index
is not None else 0
701 auth
= self
._generate
_sapisidhash
_header
(origin
)
703 headers
['Authorization'] = auth
704 headers
['X-Origin'] = origin
705 return filter_dict(headers
)
707 def _download_ytcfg(self
, client
, video_id
):
709 'web': 'https://www.youtube.com',
710 'web_music': 'https://music.youtube.com',
711 'web_embedded': f
'https://www.youtube.com/embed/{video_id}?html5=1'
715 webpage
= self
._download
_webpage
(
716 url
, video_id
, fatal
=False, note
=f
'Downloading {client.replace("_", " ").strip()} client config')
717 return self
.extract_ytcfg(video_id
, webpage
) or {}
720 def _build_api_continuation_query(continuation
, ctp
=None):
722 'continuation': continuation
724 # TODO: Inconsistency with clickTrackingParams.
725 # Currently we have a fixed ctp contained within context (from ytcfg)
726 # and a ctp in root query for continuation.
728 query
['clickTracking'] = {'clickTrackingParams': ctp}
732 def _extract_next_continuation_data(cls
, renderer
):
733 next_continuation
= try_get(
734 renderer
, (lambda x
: x
['continuations'][0]['nextContinuationData'],
735 lambda x
: x
['continuation']['reloadContinuationData']), dict)
736 if not next_continuation
:
738 continuation
= next_continuation
.get('continuation')
741 ctp
= next_continuation
.get('clickTrackingParams')
742 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
745 def _extract_continuation_ep_data(cls
, continuation_ep
: dict):
746 if isinstance(continuation_ep
, dict):
747 continuation
= try_get(
748 continuation_ep
, lambda x
: x
['continuationCommand']['token'], str)
751 ctp
= continuation_ep
.get('clickTrackingParams')
752 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
755 def _extract_continuation(cls
, renderer
):
756 next_continuation
= cls
._extract
_next
_continuation
_data
(renderer
)
757 if next_continuation
:
758 return next_continuation
760 return traverse_obj(renderer
, (
761 ('contents', 'items', 'rows'), ..., 'continuationItemRenderer',
762 ('continuationEndpoint', ('button', 'buttonRenderer', 'command'))
763 ), get_all
=False, expected_type
=cls
._extract
_continuation
_ep
_data
)
766 def _extract_alerts(cls
, data
):
767 for alert_dict
in try_get(data
, lambda x
: x
['alerts'], list) or []:
768 if not isinstance(alert_dict
, dict):
770 for alert
in alert_dict
.values():
771 alert_type
= alert
.get('type')
774 message
= cls
._get
_text
(alert
, 'text')
776 yield alert_type
, message
778 def _report_alerts(self
, alerts
, expected
=True, fatal
=True, only_once
=False):
779 errors
, warnings
= [], []
780 for alert_type
, alert_message
in alerts
:
781 if alert_type
.lower() == 'error' and fatal
:
782 errors
.append([alert_type
, alert_message
])
783 elif alert_message
not in self
._IGNORED
_WARNINGS
:
784 warnings
.append([alert_type
, alert_message
])
786 for alert_type
, alert_message
in (warnings
+ errors
[:-1]):
787 self
.report_warning(f
'YouTube said: {alert_type} - {alert_message}', only_once
=only_once
)
789 raise ExtractorError('YouTube said: %s' % errors
[-1][1], expected
=expected
)
791 def _extract_and_report_alerts(self
, data
, *args
, **kwargs
):
792 return self
._report
_alerts
(self
._extract
_alerts
(data
), *args
, **kwargs
)
794 def _extract_badges(self
, renderer
: dict):
796 'PRIVACY_UNLISTED': BadgeType
.AVAILABILITY_UNLISTED
,
797 'PRIVACY_PRIVATE': BadgeType
.AVAILABILITY_PRIVATE
,
798 'PRIVACY_PUBLIC': BadgeType
.AVAILABILITY_PUBLIC
802 'BADGE_STYLE_TYPE_MEMBERS_ONLY': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
803 'BADGE_STYLE_TYPE_PREMIUM': BadgeType
.AVAILABILITY_PREMIUM
,
804 'BADGE_STYLE_TYPE_LIVE_NOW': BadgeType
.LIVE_NOW
808 'unlisted': BadgeType
.AVAILABILITY_UNLISTED
,
809 'private': BadgeType
.AVAILABILITY_PRIVATE
,
810 'members only': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
811 'live': BadgeType
.LIVE_NOW
,
812 'premium': BadgeType
.AVAILABILITY_PREMIUM
816 for badge
in traverse_obj(renderer
, ('badges', ..., 'metadataBadgeRenderer')):
818 privacy_icon_map
.get(traverse_obj(badge
, ('icon', 'iconType'), expected_type
=str))
819 or badge_style_map
.get(traverse_obj(badge
, 'style'))
822 badges
.append({'type': badge_type}
)
825 # fallback, won't work in some languages
826 label
= traverse_obj(badge
, 'label', expected_type
=str, default
='')
827 for match
, label_badge_type
in label_map
.items():
828 if match
in label
.lower():
829 badges
.append({'type': badge_type}
)
835 def _has_badge(badges
, badge_type
):
836 return bool(traverse_obj(badges
, lambda _
, v
: v
['type'] == badge_type
))
839 def _get_text(data
, *path_list
, max_runs
=None):
840 for path
in path_list
or [None]:
844 obj
= traverse_obj(data
, path
, default
=[])
845 if not any(key
is ... or isinstance(key
, (list, tuple)) for key
in variadic(path
)):
848 text
= try_get(item
, lambda x
: x
['simpleText'], str)
851 runs
= try_get(item
, lambda x
: x
['runs'], list) or []
852 if not runs
and isinstance(item
, list):
855 runs
= runs
[:min(len(runs
), max_runs
or len(runs
))]
856 text
= ''.join(traverse_obj(runs
, (..., 'text'), expected_type
=str))
860 def _get_count(self
, data
, *path_list
):
861 count_text
= self
._get
_text
(data
, *path_list
) or ''
862 count
= parse_count(count_text
)
865 self
._search
_regex
(r
'^([\d,]+)', re
.sub(r
'\s', '', count_text
), 'count', default
=None))
869 def _extract_thumbnails(data
, *path_list
):
871 Extract thumbnails from thumbnails dict
872 @param path_list: path list to level that contains 'thumbnails' key
875 for path
in path_list
or [()]:
876 for thumbnail
in traverse_obj(data
, (*variadic(path
), 'thumbnails', ...)):
877 thumbnail_url
= url_or_none(thumbnail
.get('url'))
878 if not thumbnail_url
:
880 # Sometimes youtube gives a wrong thumbnail URL. See:
881 # https://github.com/yt-dlp/yt-dlp/issues/233
882 # https://github.com/ytdl-org/youtube-dl/issues/28023
883 if 'maxresdefault' in thumbnail_url
:
884 thumbnail_url
= thumbnail_url
.split('?')[0]
886 'url': thumbnail_url
,
887 'height': int_or_none(thumbnail
.get('height')),
888 'width': int_or_none(thumbnail
.get('width')),
893 def extract_relative_time(relative_time_text
):
895 Extracts a relative time from string and converts to dt object
896 e.g. 'streamed 6 days ago', '5 seconds ago (edited)', 'updated today'
898 mobj
= re
.search(r
'(?P<start>today|yesterday|now)|(?P<time>\d+)\s*(?P<unit>microsecond|second|minute|hour|day|week|month|year)s?\s*ago', relative_time_text
)
900 start
= mobj
.group('start')
902 return datetime_from_str(start
)
904 return datetime_from_str('now-%s%s' % (mobj
.group('time'), mobj
.group('unit')))
908 def _parse_time_text(self
, text
):
911 dt
= self
.extract_relative_time(text
)
913 if isinstance(dt
, datetime
.datetime
):
914 timestamp
= calendar
.timegm(dt
.timetuple())
916 if timestamp
is None:
918 unified_timestamp(text
) or unified_timestamp(
920 (r
'([a-z]+\s*\d{1,2},?\s*20\d{2})', r
'(?:.+|^)(?:live|premieres|ed|ing)(?:\s*(?:on|for))?\s*(.+\d)'),
921 text
.lower(), 'time text', default
=None)))
923 if text
and timestamp
is None and self
._preferred
_lang
in (None, 'en'):
925 f
'Cannot parse localized time text "{text}"', only_once
=True)
928 def _extract_response(self
, item_id
, query
, note
='Downloading API JSON', headers
=None,
929 ytcfg
=None, check_get_keys
=None, ep
='browse', fatal
=True, api_hostname
=None,
930 default_client
='web'):
931 for retry
in self
.RetryManager():
933 response
= self
._call
_api
(
934 ep
=ep
, fatal
=True, headers
=headers
,
935 video_id
=item_id
, query
=query
, note
=note
,
936 context
=self
._extract
_context
(ytcfg
, default_client
),
937 api_key
=self
._extract
_api
_key
(ytcfg
, default_client
),
938 api_hostname
=api_hostname
, default_client
=default_client
)
939 except ExtractorError
as e
:
940 if not isinstance(e
.cause
, network_exceptions
):
941 return self
._error
_or
_warning
(e
, fatal
=fatal
)
942 elif not isinstance(e
.cause
, urllib
.error
.HTTPError
):
946 first_bytes
= e
.cause
.read(512)
947 if not is_html(first_bytes
):
950 self
._webpage
_read
_content
(e
.cause
, None, item_id
, prefix
=first_bytes
) or '{}', item_id
, fatal
=False),
951 lambda x
: x
['error']['message'], str)
953 self
._report
_alerts
([('ERROR', yt_error
)], fatal
=False)
954 # Downloading page may result in intermittent 5xx HTTP error
955 # Sometimes a 404 is also recieved. See: https://github.com/ytdl-org/youtube-dl/issues/28289
956 # We also want to catch all other network exceptions since errors in later pages can be troublesome
957 # See https://github.com/yt-dlp/yt-dlp/issues/507#issuecomment-880188210
958 if e
.cause
.code
not in (403, 429):
961 return self
._error
_or
_warning
(e
, fatal
=fatal
)
964 self
._extract
_and
_report
_alerts
(response
, only_once
=True)
965 except ExtractorError
as e
:
966 # YouTube servers may return errors we want to retry on in a 200 OK response
967 # See: https://github.com/yt-dlp/yt-dlp/issues/839
968 if 'unknown error' in e
.msg
.lower():
971 return self
._error
_or
_warning
(e
, fatal
=fatal
)
972 # Youtube sometimes sends incomplete data
973 # See: https://github.com/ytdl-org/youtube-dl/issues/28194
974 if not traverse_obj(response
, *variadic(check_get_keys
)):
975 retry
.error
= ExtractorError('Incomplete data received', expected
=True)
981 def is_music_url(url
):
982 return re
.match(r
'(https?://)?music\.youtube\.com/', url
) is not None
984 def _extract_video(self
, renderer
):
985 video_id
= renderer
.get('videoId')
987 reel_header_renderer
= traverse_obj(renderer
, (
988 'navigationEndpoint', 'reelWatchEndpoint', 'overlay', 'reelPlayerOverlayRenderer',
989 'reelPlayerHeaderSupportedRenderers', 'reelPlayerHeaderRenderer'))
991 title
= self
._get
_text
(renderer
, 'title', 'headline') or self
._get
_text
(reel_header_renderer
, 'reelTitleText')
992 description
= self
._get
_text
(renderer
, 'descriptionSnippet')
994 duration
= int_or_none(renderer
.get('lengthSeconds'))
996 duration
= parse_duration(self
._get
_text
(
997 renderer
, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
999 # XXX: should write a parser to be more general to support more cases (e.g. shorts in shorts tab)
1000 duration
= parse_duration(self
._search
_regex
(
1001 r
'(?i)(ago)(?!.*\1)\s+(?P<duration>[a-z0-9 ,]+?)(?:\s+[\d,]+\s+views)?(?:\s+-\s+play\s+short)?$',
1002 traverse_obj(renderer
, ('title', 'accessibility', 'accessibilityData', 'label'), default
='', expected_type
=str),
1003 video_id
, default
=None, group
='duration'))
1005 channel_id
= traverse_obj(
1006 renderer
, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'),
1007 expected_type
=str, get_all
=False)
1009 channel_id
= traverse_obj(reel_header_renderer
, ('channelNavigationEndpoint', 'browseEndpoint', 'browseId'))
1011 channel_id
= self
.ucid_or_none(channel_id
)
1013 overlay_style
= traverse_obj(
1014 renderer
, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'),
1015 get_all
=False, expected_type
=str)
1016 badges
= self
._extract
_badges
(renderer
)
1018 navigation_url
= urljoin('https://www.youtube.com/', traverse_obj(
1019 renderer
, ('navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url'),
1020 expected_type
=str)) or ''
1021 url
= f
'https://www.youtube.com/watch?v={video_id}'
1022 if overlay_style
== 'SHORTS' or '/shorts/' in navigation_url
:
1023 url
= f
'https://www.youtube.com/shorts/{video_id}'
1025 time_text
= (self
._get
_text
(renderer
, 'publishedTimeText', 'videoInfo')
1026 or self
._get
_text
(reel_header_renderer
, 'timestampText') or '')
1027 scheduled_timestamp
= str_to_int(traverse_obj(renderer
, ('upcomingEventData', 'startTime'), get_all
=False))
1030 'is_upcoming' if scheduled_timestamp
is not None
1031 else 'was_live' if 'streamed' in time_text
.lower()
1032 else 'is_live' if overlay_style
== 'LIVE' or self
._has
_badge
(badges
, BadgeType
.LIVE_NOW
)
1035 # videoInfo is a string like '50K views • 10 years ago'.
1036 view_count_text
= self
._get
_text
(renderer
, 'viewCountText', 'shortViewCountText', 'videoInfo') or ''
1037 view_count
= (0 if 'no views' in view_count_text
.lower()
1038 else self
._get
_count
({'simpleText': view_count_text}
))
1039 view_count_field
= 'concurrent_view_count' if live_status
in ('is_live', 'is_upcoming') else 'view_count'
1041 channel
= (self
._get
_text
(renderer
, 'ownerText', 'shortBylineText')
1042 or self
._get
_text
(reel_header_renderer
, 'channelTitleText'))
1044 channel_handle
= traverse_obj(renderer
, (
1045 'shortBylineText', 'runs', ..., 'navigationEndpoint',
1046 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl'))),
1047 expected_type
=self
.handle_from_url
, get_all
=False)
1050 'ie_key': YoutubeIE
.ie_key(),
1054 'description': description
,
1055 'duration': duration
,
1056 'channel_id': channel_id
,
1058 'channel_url': f
'https://www.youtube.com/channel/{channel_id}' if channel_id
else None,
1059 'uploader': channel
,
1060 'uploader_id': channel_handle
,
1061 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
1062 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
1063 'timestamp': (self
._parse
_time
_text
(time_text
)
1064 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
1066 'release_timestamp': scheduled_timestamp
,
1068 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
1069 else self
._availability
(
1070 is_private
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
) or None,
1071 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
1072 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
1073 is_unlisted
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
) or None),
1074 view_count_field
: view_count
,
1075 'live_status': live_status
1079 class YoutubeIE(YoutubeBaseInfoExtractor
):
1081 _VALID_URL
= r
"""(?x)^
1083 (?:https?://|//) # http(s):// or protocol-independent URL
1084 (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
1085 (?:www\.)?deturl\.com/www\.youtube\.com|
1086 (?:www\.)?pwnyoutube\.com|
1087 (?:www\.)?hooktube\.com|
1088 (?:www\.)?yourepeat\.com|
1089 tube\.majestyc\.net|
1091 youtube\.googleapis\.com)/ # the various hostnames, with wildcard subdomains
1092 (?:.*?\#/)? # handle anchor (#/) redirect urls
1093 (?: # the various things that can precede the ID:
1094 (?:(?:v|embed|e|shorts|live)/(?!videoseries|live_stream)) # v/ or embed/ or e/ or shorts/
1095 |(?: # or the v= param in all its forms
1096 (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
1097 (?:\?|\#!?) # the params delimiter ? or # or #!
1098 (?:.*?[&;])?? # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&v=V36LpHqtcDY)
1103 youtu\.be| # just youtu.be/xxxx
1104 vid\.plus| # or vid.plus/xxxx
1105 zwearz\.com/watch| # or zwearz.com/watch/xxxx
1108 |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
1110 )? # all until now is optional -> you can pass the naked ID
1111 (?P<id>[0-9A-Za-z_-]{11}) # here is it! the YouTube video ID
1112 (?(1).+)? # if we found the ID, everything can follow
1114 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
1119 <(?:[0-9A-Za-z-]+?)?iframe[^>]+?src=|
1127 (?P
<url
>(?
:https?
:)?
//(?
:www\
.)?
youtube(?
:-nocookie
)?\
.com
/
1128 (?
:embed|v|p
)/[0-9A
-Za
-z_
-]{11}
.*?
)
1130 # https://wordpress.org/plugins/lazy-load-for-videos/
1132 <a\s
[^
>]*\bhref
="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"
1133 \s
[^
>]*\bclass
="[^"]*\blazy
-load
-youtube
''',
1135 _RETURN_TYPE = 'video' # XXX: How to handle multifeed?
1138 r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
1139 r'/(?P<id>[a-zA-Z0-9_-]{8,})/player(?:_ias\.vflset(?:/[a-zA-Z]{2,3}_[a-zA-Z]{2,3})?|-plasma-ias-(?:phone|tablet)-[a-z]{2}_[A-Z]{2}\.vflset)/base\.js$',
1140 r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
1143 '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1144 '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1145 '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
1146 '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
1147 '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
1148 '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1149 '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1150 '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1151 # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
1152 '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
1153 '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1154 '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1155 '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1156 '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1157 '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1158 '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1159 '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1160 '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1164 '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1165 '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1166 '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1167 '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1168 '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
1169 '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1170 '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1172 # Apple HTTP Live Streaming
1173 '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1174 '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1175 '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1176 '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1177 '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1178 '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1179 '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1180 '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
1183 '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
1184 '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
1185 '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1186 '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
1187 '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
1188 '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'}, # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
1189 '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
1190 '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1191 '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
1192 '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1193 '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1194 '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
1197 '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
1198 '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
1199 '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
1200 '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1201 '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1202 '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
1203 '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
1206 '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1207 '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1208 '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1209 '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1210 '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1211 '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1212 '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
1213 '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1214 '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1215 '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1216 '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1217 '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1218 '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1219 '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1220 '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1221 # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
1222 '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1223 '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1224 '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1225 '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1226 '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1227 '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1230 '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
1231 '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
1233 # Dash webm audio with opus inside
1234 '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
1235 '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
1236 '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
1239 '_rtmp': {'protocol': 'rtmp'},
1241 # av01 video only formats sometimes served with "unknown" codecs
1242 '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1243 '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1244 '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1245 '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1246 '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1247 '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1248 '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1249 '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1251 _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1258 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1260 'id': 'BaW_jenozKc',
1262 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1263 'channel': 'Philipp Hagemeister',
1264 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1265 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1266 'upload_date': '20121002',
1267 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1268 'categories': ['Science & Technology'],
1269 'tags': ['youtube-dl'],
1273 'availability': 'public',
1274 'playable_in_embed': True,
1275 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1276 'live_status': 'not_live',
1280 'comment_count': int,
1281 'channel_follower_count': int,
1282 'uploader': 'Philipp Hagemeister',
1283 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1284 'uploader_id': '@PhilippHagemeister',
1285 'heatmap': 'count:100',
1289 'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1290 'note': 'Embed-only video (#1746)',
1292 'id': 'yZIXLfi8CZQ',
1294 'upload_date': '20120608',
1295 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1296 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1299 'skip': 'Private video',
1302 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1303 'note': 'Use the first video ID in the URL',
1305 'id': 'BaW_jenozKc',
1307 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1308 'channel': 'Philipp Hagemeister',
1309 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1310 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1311 'upload_date': '20121002',
1312 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1313 'categories': ['Science & Technology'],
1314 'tags': ['youtube-dl'],
1318 'availability': 'public',
1319 'playable_in_embed': True,
1320 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1321 'live_status': 'not_live',
1323 'comment_count': int,
1324 'channel_follower_count': int,
1325 'uploader': 'Philipp Hagemeister',
1326 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1327 'uploader_id': '@PhilippHagemeister',
1330 'skip_download': True,
1334 'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1335 'note': '256k DASH audio (format 141) via DASH manifest',
1337 'id': 'a9LDPn-MO4I',
1339 'upload_date': '20121002',
1341 'title': 'UHDTV TEST 8K VIDEO.mp4'
1344 'youtube_include_dash_manifest': True,
1347 'skip': 'format 141 not served anymore',
1349 # DASH manifest with encrypted signature
1351 'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1353 'id': 'IB3lcPjvWLA',
1355 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1356 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1358 'upload_date': '20131011',
1361 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1362 'playable_in_embed': True,
1363 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1365 'track': 'The Spark',
1366 'live_status': 'not_live',
1367 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1368 'channel': 'Afrojack',
1370 'availability': 'public',
1371 'categories': ['Music'],
1373 'alt_title': 'The Spark',
1374 'channel_follower_count': int,
1375 'uploader': 'Afrojack',
1376 'uploader_url': 'https://www.youtube.com/@Afrojack',
1377 'uploader_id': '@Afrojack',
1380 'youtube_include_dash_manifest': True,
1381 'format': '141/bestaudio[ext=m4a]',
1384 # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1386 'note': 'Embed allowed age-gate video',
1387 'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1389 'id': 'HtVdAasjOgU',
1391 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1392 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1394 'upload_date': '20140605',
1396 'categories': ['Gaming'],
1397 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1398 'availability': 'needs_auth',
1399 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1401 'channel': 'The Witcher',
1402 'live_status': 'not_live',
1404 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1405 'playable_in_embed': True,
1407 'channel_follower_count': int,
1408 'uploader': 'The Witcher',
1409 'uploader_url': 'https://www.youtube.com/@thewitcher',
1410 'uploader_id': '@thewitcher',
1414 'note': 'Age-gate video with embed allowed in public site',
1415 'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1417 'id': 'HsUATh_Nc2U',
1419 'title': 'Godzilla 2 (Official Video)',
1420 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1421 'upload_date': '20200408',
1423 'availability': 'needs_auth',
1424 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1425 'channel': 'FlyingKitty',
1426 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1428 'categories': ['Entertainment'],
1429 'live_status': 'not_live',
1430 'tags': ['Flyingkitty', 'godzilla 2'],
1431 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1434 'playable_in_embed': True,
1435 'channel_follower_count': int,
1436 'uploader': 'FlyingKitty',
1437 'uploader_url': 'https://www.youtube.com/@FlyingKitty900',
1438 'uploader_id': '@FlyingKitty900',
1439 'comment_count': int,
1443 'note': 'Age-gate video embedable only with clientScreen=EMBED',
1444 'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1446 'id': 'Tq92D6wQ1mg',
1447 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1449 'upload_date': '20191228',
1450 'description': 'md5:17eccca93a786d51bc67646756894066',
1453 'availability': 'needs_auth',
1454 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1456 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1457 'channel': 'Projekt Melody',
1458 'live_status': 'not_live',
1459 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1460 'playable_in_embed': True,
1461 'categories': ['Entertainment'],
1463 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1464 'comment_count': int,
1465 'channel_follower_count': int,
1466 'uploader': 'Projekt Melody',
1467 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
1468 'uploader_id': '@ProjektMelody',
1472 'note': 'Non-Agegated non-embeddable video',
1473 'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1475 'id': 'MeJVWBSsPAY',
1477 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1478 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1479 'upload_date': '20130730',
1480 'track': 'Such mich find mich',
1482 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1484 'playable_in_embed': False,
1485 'creator': 'OOMPH!',
1486 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1488 'alt_title': 'Such mich find mich',
1490 'channel': 'Herr Lurik',
1491 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1492 'categories': ['Music'],
1493 'availability': 'public',
1494 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1495 'live_status': 'not_live',
1497 'channel_follower_count': int,
1498 'uploader': 'Herr Lurik',
1499 'uploader_url': 'https://www.youtube.com/@HerrLurik',
1500 'uploader_id': '@HerrLurik',
1504 'note': 'Non-bypassable age-gated video',
1505 'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1506 'only_matching': True,
1508 # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1509 # YouTube Red ad is not captured for creator
1511 'url': '__2ABJjxzNo',
1513 'id': '__2ABJjxzNo',
1516 'upload_date': '20100430',
1517 'creator': 'deadmau5',
1518 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1519 'title': 'Deadmau5 - Some Chords (HD)',
1520 'alt_title': 'Some Chords',
1521 'availability': 'public',
1523 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1525 'live_status': 'not_live',
1526 'channel': 'deadmau5',
1527 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1529 'track': 'Some Chords',
1530 'artist': 'deadmau5',
1531 'playable_in_embed': True,
1533 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1534 'categories': ['Music'],
1535 'album': 'Some Chords',
1536 'channel_follower_count': int,
1537 'uploader': 'deadmau5',
1538 'uploader_url': 'https://www.youtube.com/@deadmau5',
1539 'uploader_id': '@deadmau5',
1541 'expected_warnings': [
1542 'DASH manifest missing',
1545 # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1547 'url': 'lqQg6PlCWgI',
1549 'id': 'lqQg6PlCWgI',
1552 'upload_date': '20150827',
1553 'description': 'md5:04bbbf3ccceb6795947572ca36f45904',
1554 'title': 'Hockey - Women - GER-AUS - London 2012 Olympic Games',
1556 'release_timestamp': 1343767800,
1557 'playable_in_embed': True,
1558 'categories': ['Sports'],
1559 'release_date': '20120731',
1560 'channel': 'Olympics',
1561 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1562 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1563 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1565 'availability': 'public',
1566 'live_status': 'was_live',
1568 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1569 'channel_follower_count': int,
1570 'uploader': 'Olympics',
1571 'uploader_url': 'https://www.youtube.com/@Olympics',
1572 'uploader_id': '@Olympics',
1575 'skip_download': 'requires avconv',
1580 'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1582 'id': '_b-2C3KPAM0',
1584 'stretched_ratio': 16 / 9.,
1586 'upload_date': '20110310',
1587 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1588 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1589 'playable_in_embed': True,
1593 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1594 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1595 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1597 'categories': ['People & Blogs'],
1599 'live_status': 'not_live',
1600 'availability': 'unlisted',
1601 'comment_count': int,
1602 'channel_follower_count': int,
1604 'uploader_url': 'https://www.youtube.com/@AllenMeow',
1605 'uploader_id': '@AllenMeow',
1608 # url_encoded_fmt_stream_map is empty string
1610 'url': 'qEJwOuvDf7I',
1612 'id': 'qEJwOuvDf7I',
1614 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1616 'upload_date': '20150404',
1619 'skip_download': 'requires avconv',
1621 'skip': 'This live event has ended.',
1623 # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1625 'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1627 'id': 'FIl7x6_3R5Y',
1629 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1630 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1632 'upload_date': '20150625',
1633 'formats': 'mincount:31',
1635 'skip': 'not actual anymore',
1637 # DASH manifest with segment_list
1639 'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1640 'md5': '8ce563a1d667b599d21064e982ab9e31',
1642 'id': 'CsmdDsKjzN8',
1644 'upload_date': '20150501', # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1645 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1646 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1649 'youtube_include_dash_manifest': True,
1650 'format': '135', # bestvideo
1652 'skip': 'This live event has ended.',
1655 # Multifeed videos (multiple cameras), URL can be of any Camera
1656 # TODO: fix multifeed titles
1657 'url': 'https://www.youtube.com/watch?v=zaPI8MvL8pg',
1659 'id': 'zaPI8MvL8pg',
1660 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04',
1661 'description': 'md5:563ccbc698b39298481ca3c571169519',
1665 'id': 'j5yGuxZ8lLU',
1667 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Chris)',
1668 'description': 'md5:563ccbc698b39298481ca3c571169519',
1670 'channel_follower_count': int,
1671 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1672 'availability': 'public',
1673 'playable_in_embed': True,
1674 'upload_date': '20131105',
1675 'categories': ['Gaming'],
1676 'live_status': 'was_live',
1678 'release_timestamp': 1383701910,
1679 'thumbnail': 'https://i.ytimg.com/vi/j5yGuxZ8lLU/maxresdefault.jpg',
1680 'comment_count': int,
1683 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1684 'channel': 'WiiLikeToPlay',
1686 'release_date': '20131106',
1687 'uploader': 'WiiLikeToPlay',
1688 'uploader_id': '@WLTP',
1689 'uploader_url': 'https://www.youtube.com/@WLTP',
1693 'id': 'zaPI8MvL8pg',
1695 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Tyson)',
1696 'availability': 'public',
1697 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1698 'channel': 'WiiLikeToPlay',
1699 'channel_follower_count': int,
1700 'description': 'md5:563ccbc698b39298481ca3c571169519',
1705 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1706 'release_timestamp': 1383701915,
1707 'comment_count': int,
1708 'upload_date': '20131105',
1709 'thumbnail': 'https://i.ytimg.com/vi/zaPI8MvL8pg/maxresdefault.jpg',
1710 'release_date': '20131106',
1711 'playable_in_embed': True,
1712 'live_status': 'was_live',
1713 'categories': ['Gaming'],
1715 'uploader': 'WiiLikeToPlay',
1716 'uploader_id': '@WLTP',
1717 'uploader_url': 'https://www.youtube.com/@WLTP',
1721 'id': 'R7r3vfO7Hao',
1723 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Spencer)',
1724 'thumbnail': 'https://i.ytimg.com/vi/R7r3vfO7Hao/maxresdefault.jpg',
1725 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1727 'availability': 'public',
1728 'playable_in_embed': True,
1729 'upload_date': '20131105',
1730 'description': 'md5:563ccbc698b39298481ca3c571169519',
1731 'channel_follower_count': int,
1733 'release_date': '20131106',
1734 'comment_count': int,
1735 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1736 'channel': 'WiiLikeToPlay',
1737 'categories': ['Gaming'],
1738 'release_timestamp': 1383701914,
1739 'live_status': 'was_live',
1743 'uploader': 'WiiLikeToPlay',
1744 'uploader_id': '@WLTP',
1745 'uploader_url': 'https://www.youtube.com/@WLTP',
1748 'params': {'skip_download': True},
1751 # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1752 'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1754 'id': 'gVfLd0zydlo',
1755 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1757 'playlist_count': 2,
1758 'skip': 'Not multifeed anymore',
1761 'url': 'https://vid.plus/FlRa-iH7PGw',
1762 'only_matching': True,
1765 'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1766 'only_matching': True,
1769 # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1770 # Also tests cut-off URL expansion in video description (see
1771 # https://github.com/ytdl-org/youtube-dl/issues/1892,
1772 # https://github.com/ytdl-org/youtube-dl/issues/8164)
1773 'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1775 'id': 'lsguqyKfVQg',
1777 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1778 'alt_title': 'Dark Walk',
1779 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1781 'upload_date': '20151119',
1782 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1783 'track': 'Dark Walk',
1784 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1785 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1786 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1787 'categories': ['Film & Animation'],
1789 'live_status': 'not_live',
1790 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1791 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1793 'availability': 'public',
1794 'channel': 'IronSoulElf',
1795 'playable_in_embed': True,
1798 'channel_follower_count': int
1801 'skip_download': True,
1805 # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1806 'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1807 'only_matching': True,
1810 # Video with yt:stretch=17:0
1811 'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1813 'id': 'Q39EVAstoRM',
1815 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1816 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1817 'upload_date': '20151107',
1820 'skip_download': True,
1822 'skip': 'This video does not exist.',
1825 # Video with incomplete 'yt:stretch=16:'
1826 'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1827 'only_matching': True,
1830 # Video licensed under Creative Commons
1831 'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1833 'id': 'M4gD1WSo5mA',
1835 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1836 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1838 'upload_date': '20150128',
1839 'license': 'Creative Commons Attribution license (reuse allowed)',
1840 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1841 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1844 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1845 'channel': 'The Berkman Klein Center for Internet & Society',
1846 'availability': 'public',
1848 'categories': ['Education'],
1849 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1850 'live_status': 'not_live',
1851 'playable_in_embed': True,
1852 'channel_follower_count': int,
1854 'uploader': 'The Berkman Klein Center for Internet & Society',
1855 'uploader_id': '@BKCHarvard',
1856 'uploader_url': 'https://www.youtube.com/@BKCHarvard',
1859 'skip_download': True,
1863 'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1865 'id': 'eQcmzGIKrzg',
1867 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1868 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1870 'upload_date': '20151120',
1871 'license': 'Creative Commons Attribution license (reuse allowed)',
1872 'playable_in_embed': True,
1875 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1877 'availability': 'public',
1878 'categories': ['News & Politics'],
1879 'channel': 'Bernie Sanders',
1880 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1882 'live_status': 'not_live',
1883 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1884 'comment_count': int,
1885 'channel_follower_count': int,
1887 'uploader': 'Bernie Sanders',
1888 'uploader_url': 'https://www.youtube.com/@BernieSanders',
1889 'uploader_id': '@BernieSanders',
1892 'skip_download': True,
1896 'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;v=V36LpHqtcDY',
1897 'only_matching': True,
1900 # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1901 'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1902 'only_matching': True,
1905 # Rental video preview
1906 'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1908 'id': 'uGpuVWrhIzE',
1910 'title': 'Piku - Trailer',
1911 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1912 'upload_date': '20150811',
1913 'license': 'Standard YouTube License',
1916 'skip_download': True,
1918 'skip': 'This video is not available.',
1921 # YouTube Red video with episode data
1922 'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1924 'id': 'iqKdEhx-dD4',
1926 'title': 'Isolation - Mind Field (Ep 1)',
1927 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1929 'upload_date': '20170118',
1930 'series': 'Mind Field',
1932 'episode_number': 1,
1933 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1936 'availability': 'public',
1938 'channel': 'Vsauce',
1939 'episode': 'Episode 1',
1940 'categories': ['Entertainment'],
1941 'season': 'Season 1',
1942 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
1943 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
1945 'playable_in_embed': True,
1946 'live_status': 'not_live',
1947 'channel_follower_count': int,
1948 'uploader': 'Vsauce',
1949 'uploader_url': 'https://www.youtube.com/@Vsauce',
1950 'uploader_id': '@Vsauce',
1953 'skip_download': True,
1955 'expected_warnings': [
1956 'Skipping DASH manifest',
1960 # The following content has been identified by the YouTube community
1961 # as inappropriate or offensive to some audiences.
1962 'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
1964 'id': '6SJNVb0GnPI',
1966 'title': 'Race Differences in Intelligence',
1967 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
1969 'upload_date': '20140124',
1972 'skip_download': True,
1974 'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
1978 'url': '1t24XAntNCY',
1979 'only_matching': True,
1982 # geo restricted to JP
1983 'url': 'sJL6WA-aGkQ',
1984 'only_matching': True,
1987 'url': 'https://invidio.us/watch?v=BaW_jenozKc',
1988 'only_matching': True,
1991 'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
1992 'only_matching': True,
1995 # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
1996 'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
1997 'only_matching': True,
2001 'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
2002 'only_matching': True,
2005 # Video with unsupported adaptive stream type formats
2006 'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
2008 'id': 'Z4Vy8R84T1U',
2010 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
2011 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
2013 'upload_date': '20130923',
2014 'formats': 'maxcount:10',
2017 'skip_download': True,
2018 'youtube_include_dash_manifest': False,
2020 'skip': 'not actual anymore',
2023 # Youtube Music Auto-generated description
2024 # TODO: fix metadata extraction
2025 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2027 'id': 'MgNrAu2pzNs',
2029 'title': 'Voyeur Girl',
2030 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
2031 'upload_date': '20190312',
2032 'artist': 'Stephen',
2033 'track': 'Voyeur Girl',
2034 'album': 'it\'s too much love to know my dear',
2035 'release_date': '20190313',
2036 'release_year': 2019,
2037 'alt_title': 'Voyeur Girl',
2039 'playable_in_embed': True,
2041 'categories': ['Music'],
2042 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
2043 'channel': 'Stephen', # TODO: should be "Stephen - Topic"
2044 'uploader': 'Stephen',
2045 'availability': 'public',
2046 'creator': 'Stephen',
2048 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
2050 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
2052 'live_status': 'not_live',
2053 'channel_follower_count': int
2056 'skip_download': True,
2060 'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
2061 'only_matching': True,
2064 # invalid -> valid video id redirection
2065 'url': 'DJztXj2GPfl',
2067 'id': 'DJztXj2GPfk',
2069 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
2070 'description': 'md5:bf577a41da97918e94fa9798d9228825',
2071 'upload_date': '20090125',
2072 'artist': 'Panjabi MC',
2073 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
2074 'album': 'Beware of the Boys (Mundian To Bach Ke)',
2077 'skip_download': True,
2079 'skip': 'Video unavailable',
2082 # empty description results in an empty string
2083 'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
2085 'id': 'x41yOUIvK2k',
2087 'title': 'IMG 3456',
2089 'upload_date': '20170613',
2091 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
2093 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
2095 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
2096 'availability': 'public',
2098 'categories': ['Pets & Animals'],
2100 'playable_in_embed': True,
2101 'live_status': 'not_live',
2102 'channel': 'l\'Or Vert asbl',
2103 'channel_follower_count': int,
2104 'uploader': 'l\'Or Vert asbl',
2105 'uploader_url': 'https://www.youtube.com/@ElevageOrVert',
2106 'uploader_id': '@ElevageOrVert',
2109 'skip_download': True,
2113 # with '};' inside yt initial data (see [1])
2114 # see [2] for an example with '};' inside ytInitialPlayerResponse
2115 # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
2116 # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
2117 'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
2119 'id': 'CHqg6qOn4no',
2121 'title': 'Part 77 Sort a list of simple types in c#',
2122 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
2123 'upload_date': '20130831',
2124 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
2126 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
2127 'live_status': 'not_live',
2128 'categories': ['Education'],
2129 'availability': 'public',
2130 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
2132 'playable_in_embed': True,
2136 'channel': 'kudvenkat',
2137 'comment_count': int,
2138 'channel_follower_count': int,
2140 'uploader': 'kudvenkat',
2141 'uploader_url': 'https://www.youtube.com/@Csharp-video-tutorialsBlogspot',
2142 'uploader_id': '@Csharp-video-tutorialsBlogspot',
2145 'skip_download': True,
2149 # another example of '};' in ytInitialData
2150 'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
2151 'only_matching': True,
2154 'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
2155 'only_matching': True,
2158 # https://github.com/ytdl-org/youtube-dl/pull/28094
2159 'url': 'OtqTfy26tG0',
2161 'id': 'OtqTfy26tG0',
2163 'title': 'Burn Out',
2164 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
2165 'upload_date': '20141120',
2166 'artist': 'The Cinematic Orchestra',
2167 'track': 'Burn Out',
2168 'album': 'Every Day',
2170 'live_status': 'not_live',
2171 'alt_title': 'Burn Out',
2175 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2176 'creator': 'The Cinematic Orchestra',
2177 'channel': 'The Cinematic Orchestra',
2178 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
2179 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2180 'availability': 'public',
2181 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
2182 'categories': ['Music'],
2183 'playable_in_embed': True,
2184 'channel_follower_count': int,
2185 'uploader': 'The Cinematic Orchestra',
2186 'comment_count': int,
2189 'skip_download': True,
2193 # controversial video, only works with bpctr when authenticated with cookies
2194 'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
2195 'only_matching': True,
2198 # controversial video, requires bpctr/contentCheckOk
2199 'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
2201 'id': 'SZJvDhaSDnc',
2203 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
2204 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
2205 'upload_date': '20140716',
2206 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
2208 'categories': ['News & Politics'],
2210 'channel': 'CBS Mornings',
2211 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
2212 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
2214 'availability': 'needs_auth',
2215 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
2217 'live_status': 'not_live',
2218 'playable_in_embed': True,
2219 'channel_follower_count': int,
2220 'uploader': 'CBS Mornings',
2221 'uploader_url': 'https://www.youtube.com/@CBSMornings',
2222 'uploader_id': '@CBSMornings',
2226 # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
2227 'url': 'cBvYw8_A0vQ',
2229 'id': 'cBvYw8_A0vQ',
2231 'title': '4K Ueno Okachimachi Street Scenes 上野御徒町歩き',
2232 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
2233 'upload_date': '20201120',
2235 'categories': ['Travel & Events'],
2236 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2238 'channel': 'Walk around Japan',
2239 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
2240 'thumbnail': 'https://i.ytimg.com/vi_webp/cBvYw8_A0vQ/hqdefault.webp',
2242 'availability': 'public',
2243 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2244 'live_status': 'not_live',
2245 'playable_in_embed': True,
2246 'channel_follower_count': int,
2247 'uploader': 'Walk around Japan',
2248 'uploader_url': 'https://www.youtube.com/@walkaroundjapan7124',
2249 'uploader_id': '@walkaroundjapan7124',
2252 'skip_download': True,
2255 # Has multiple audio streams
2256 'url': 'WaOKSUlf4TM',
2257 'only_matching': True
2259 # Requires Premium: has format 141 when requested using YTM url
2260 'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2261 'only_matching': True
2263 # multiple subtitles with same lang_code
2264 'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2265 'only_matching': True,
2267 # Force use android client fallback
2268 'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2270 'id': 'YOelRv7fMxY',
2271 'title': 'DIGGING A SECRET TUNNEL Part 1',
2273 'upload_date': '20210624',
2274 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2275 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2276 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2278 'categories': ['Entertainment'],
2280 'channel': 'colinfurze',
2281 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2282 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2284 'availability': 'public',
2286 'live_status': 'not_live',
2287 'playable_in_embed': True,
2288 'channel_follower_count': int,
2290 'uploader': 'colinfurze',
2291 'uploader_url': 'https://www.youtube.com/@colinfurze',
2292 'uploader_id': '@colinfurze',
2295 'format': '17', # 3gp format available on android
2296 'extractor_args': {'youtube': {'player_client': ['android']}},
2300 # Skip download of additional client configs (remix client config in this case)
2301 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2302 'only_matching': True,
2304 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2308 'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2309 'only_matching': True,
2311 'note': 'Storyboards',
2312 'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2314 'id': '5KLPxDtMqe8',
2317 'title': 'Your Brain is Plastic',
2318 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2319 'upload_date': '20140324',
2321 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2322 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2324 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2325 'playable_in_embed': True,
2327 'availability': 'public',
2328 'channel': 'SciShow',
2329 'live_status': 'not_live',
2331 'categories': ['Education'],
2333 'channel_follower_count': int,
2335 'uploader': 'SciShow',
2336 'uploader_url': 'https://www.youtube.com/@SciShow',
2337 'uploader_id': '@SciShow',
2338 }, 'params': {'format': 'mhtml', 'skip_download': True}
2340 # Ensure video upload_date is in UTC timezone (video was uploaded 1641170939)
2341 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2343 'id': '2NUZ8W2llS4',
2345 'title': 'The NP that test your phone performance 🙂',
2346 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2347 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2348 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2352 'categories': ['Gaming'],
2354 'playable_in_embed': True,
2355 'live_status': 'not_live',
2356 'upload_date': '20220103',
2358 'availability': 'public',
2359 'channel': 'Leon Nguyen',
2360 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2361 'comment_count': int,
2362 'channel_follower_count': int,
2363 'uploader': 'Leon Nguyen',
2364 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2365 'uploader_id': '@LeonNguyen',
2368 # Same video as above, but with --compat-opt no-youtube-prefer-utc-upload-date
2369 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2371 'id': '2NUZ8W2llS4',
2373 'title': 'The NP that test your phone performance 🙂',
2374 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2375 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2376 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2380 'categories': ['Gaming'],
2382 'playable_in_embed': True,
2383 'live_status': 'not_live',
2384 'upload_date': '20220102',
2386 'availability': 'public',
2387 'channel': 'Leon Nguyen',
2388 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2389 'comment_count': int,
2390 'channel_follower_count': int,
2391 'uploader': 'Leon Nguyen',
2392 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2393 'uploader_id': '@LeonNguyen',
2395 'params': {'compat_opts': ['no-youtube-prefer-utc-upload-date']}
2397 # date text is premiered video, ensure upload date in UTC (published 1641172509)
2398 'url': 'https://www.youtube.com/watch?v=mzZzzBU6lrM',
2400 'id': 'mzZzzBU6lrM',
2402 'title': 'I Met GeorgeNotFound In Real Life...',
2403 'description': 'md5:978296ec9783a031738b684d4ebf302d',
2404 'channel_id': 'UC_8NknAFiyhOUaZqHR3lq3Q',
2405 'channel_url': 'https://www.youtube.com/channel/UC_8NknAFiyhOUaZqHR3lq3Q',
2409 'categories': ['Entertainment'],
2411 'playable_in_embed': True,
2412 'live_status': 'not_live',
2413 'release_timestamp': 1641172509,
2414 'release_date': '20220103',
2415 'upload_date': '20220103',
2417 'availability': 'public',
2418 'channel': 'Quackity',
2419 'thumbnail': 'https://i.ytimg.com/vi/mzZzzBU6lrM/maxresdefault.jpg',
2420 'channel_follower_count': int,
2421 'uploader': 'Quackity',
2422 'uploader_id': '@Quackity',
2423 'uploader_url': 'https://www.youtube.com/@Quackity',
2426 { # continuous livestream. Microformat upload date should be preferred.
2427 # Upload date was 2021-06-19 (not UTC), while stream start is 2021-11-27
2428 'url': 'https://www.youtube.com/watch?v=kgx4WGK0oNU',
2430 'id': 'kgx4WGK0oNU',
2431 'title': r're:jazz\/lofi hip hop radio🌱chill beats to relax\/study to \[LIVE 24\/7\] \d{4}-\d{2}-\d{2} \d{2}:\d{2}',
2433 'channel_id': 'UC84whx2xxsiA1gXHXXqKGOA',
2434 'availability': 'public',
2436 'release_timestamp': 1637975704,
2437 'upload_date': '20210619',
2438 'channel_url': 'https://www.youtube.com/channel/UC84whx2xxsiA1gXHXXqKGOA',
2439 'live_status': 'is_live',
2440 'thumbnail': 'https://i.ytimg.com/vi/kgx4WGK0oNU/maxresdefault.jpg',
2441 'channel': 'Abao in Tokyo',
2442 'channel_follower_count': int,
2443 'release_date': '20211127',
2445 'categories': ['People & Blogs'],
2448 'playable_in_embed': True,
2449 'description': 'md5:2ef1d002cad520f65825346e2084e49d',
2450 'concurrent_view_count': int,
2451 'uploader': 'Abao in Tokyo',
2452 'uploader_url': 'https://www.youtube.com/@abaointokyo',
2453 'uploader_id': '@abaointokyo',
2455 'params': {'skip_download': True}
2457 # Story. Requires specific player params to work.
2458 'url': 'https://www.youtube.com/watch?v=vv8qTUWmulI',
2460 'id': 'vv8qTUWmulI',
2462 'availability': 'unlisted',
2464 'channel_id': 'UCzIZ8HrzDgc-pNQDUG6avBA',
2465 'upload_date': '20220526',
2466 'categories': ['Education'],
2468 'channel': 'IT\'S HISTORY',
2471 'playable_in_embed': True,
2473 'live_status': 'not_live',
2475 'thumbnail': 'https://i.ytimg.com/vi_webp/vv8qTUWmulI/maxresdefault.webp',
2476 'channel_url': 'https://www.youtube.com/channel/UCzIZ8HrzDgc-pNQDUG6avBA',
2478 'skip': 'stories get removed after some period of time',
2480 'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2482 'id': 'tjjjtzRLHvA',
2484 'title': 'ハッシュタグ無し };if window.ytcsi',
2485 'upload_date': '20220323',
2487 'availability': 'unlisted',
2488 'channel': 'Lesmiscore',
2489 'thumbnail': r're:^https?://.*\.jpg',
2491 'categories': ['Music'],
2494 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2495 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2496 'live_status': 'not_live',
2497 'playable_in_embed': True,
2498 'channel_follower_count': int,
2501 'uploader_id': '@lesmiscore',
2502 'uploader': 'Lesmiscore',
2503 'uploader_url': 'https://www.youtube.com/@lesmiscore',
2506 # Prefer primary title+description language metadata by default
2507 # Do not prefer translated description if primary is empty
2508 'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2510 'id': 'el3E4MbxRqQ',
2512 'title': 'dlp test video 2 - primary sv no desc',
2514 'channel': 'cole-dlp-test-acc',
2517 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2519 'playable_in_embed': True,
2520 'availability': 'unlisted',
2521 'thumbnail': r're:^https?://.*\.jpg',
2524 'live_status': 'not_live',
2525 'upload_date': '20220908',
2526 'categories': ['People & Blogs'],
2527 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2528 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2529 'uploader_id': '@coletdjnz',
2530 'uploader': 'cole-dlp-test-acc',
2532 'params': {'skip_download': True}
2534 # Extractor argument: prefer translated title+description
2535 'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2537 'id': 'gHKT4uU8Zng',
2539 'channel': 'cole-dlp-test-acc',
2542 'live_status': 'not_live',
2543 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2544 'upload_date': '20220728',
2546 'categories': ['People & Blogs'],
2547 'thumbnail': r're:^https?://.*\.jpg',
2548 'title': 'dlp test video title translated (fr)',
2549 'availability': 'public',
2551 'description': 'dlp test video description translated (fr)',
2552 'playable_in_embed': True,
2553 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2554 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2555 'uploader_id': '@coletdjnz',
2556 'uploader': 'cole-dlp-test-acc',
2558 'params': {'skip_download': True, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2559 'expected_warnings': [r'Preferring "fr" translated fields'],
2561 'note': '6 channel audio',
2562 'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2563 'only_matching': True,
2565 'note': 'Multiple HLS formats with same itag',
2566 'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2568 'id': 'kX3nB4PpJko',
2570 'categories': ['Entertainment'],
2571 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2572 'live_status': 'not_live',
2574 'channel_follower_count': int,
2575 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2576 'title': 'Last To Take Hand Off Jet, Keeps It!',
2577 'channel': 'MrBeast',
2578 'playable_in_embed': True,
2580 'upload_date': '20221112',
2581 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2583 'availability': 'public',
2584 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2587 'uploader': 'MrBeast',
2588 'uploader_url': 'https://www.youtube.com/@MrBeast',
2589 'uploader_id': '@MrBeast',
2591 'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2593 'note': 'Audio formats with Dynamic Range Compression',
2594 'url': 'https://www.youtube.com/watch?v=Tq92D6wQ1mg',
2596 'id': 'Tq92D6wQ1mg',
2598 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
2599 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
2600 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
2601 'channel_follower_count': int,
2602 'description': 'md5:17eccca93a786d51bc67646756894066',
2603 'upload_date': '20191228',
2604 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
2605 'playable_in_embed': True,
2607 'categories': ['Entertainment'],
2608 'thumbnail': 'https://i.ytimg.com/vi/Tq92D6wQ1mg/sddefault.jpg',
2610 'channel': 'Projekt Melody',
2612 'availability': 'needs_auth',
2613 'comment_count': int,
2614 'live_status': 'not_live',
2616 'uploader': 'Projekt Melody',
2617 'uploader_id': '@ProjektMelody',
2618 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
2620 'params': {'extractor_args': {'youtube': {'player_client': ['tv_embedded']}}, 'format': '251-drc'},
2623 'url': 'https://www.youtube.com/live/qVv6vCqciTM',
2625 'id': 'qVv6vCqciTM',
2628 'comment_count': int,
2629 'chapters': 'count:13',
2630 'upload_date': '20221223',
2631 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
2632 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
2634 'release_date': '20221223',
2635 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
2636 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
2638 'playable_in_embed': True,
2640 'availability': 'public',
2641 'channel_follower_count': int,
2642 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
2643 'categories': ['Entertainment'],
2644 'live_status': 'was_live',
2645 'release_timestamp': 1671793345,
2646 'channel': 'さなちゃんねる',
2647 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
2648 'uploader': 'さなちゃんねる',
2649 'uploader_url': 'https://www.youtube.com/@sana_natori',
2650 'uploader_id': '@sana_natori',
2654 # Fallbacks when webpage and web client is unavailable
2655 'url': 'https://www.youtube.com/watch?v=wSSmNUl9Snw',
2657 'id': 'wSSmNUl9Snw',
2659 # 'categories': ['Science & Technology'],
2661 'chapters': 'count:2',
2662 'channel': 'Scott Manley',
2665 # 'availability': 'public',
2666 'channel_follower_count': int,
2667 'live_status': 'not_live',
2668 'upload_date': '20170831',
2671 'uploader_url': 'https://www.youtube.com/@scottmanley',
2672 'description': 'md5:f4bed7b200404b72a394c2f97b782c02',
2673 'uploader': 'Scott Manley',
2674 'uploader_id': '@scottmanley',
2675 'title': 'The Computer Hack That Saved Apollo 14',
2676 'channel_id': 'UCxzC4EngIsMrPmbm6Nxvb-A',
2677 'thumbnail': r're:^https?://.*\.webp',
2678 'channel_url': 'https://www.youtube.com/channel/UCxzC4EngIsMrPmbm6Nxvb-A',
2679 'playable_in_embed': True,
2682 'extractor_args': {'youtube': {'player_client': ['android'], 'player_skip': ['webpage']}},
2688 # YouTube <object> embed
2690 'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2691 'md5': '873c81d308b979f0e23ee7e620b312a3',
2693 'id': 'msN87y-iEx0',
2695 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2696 'upload_date': '20080526',
2697 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2699 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2700 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2701 'playable_in_embed': True,
2702 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2704 'comment_count': int,
2705 'channel': 'Christopher Sykes',
2706 'live_status': 'not_live',
2707 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2708 'availability': 'public',
2711 'categories': ['Science & Technology'],
2712 'channel_follower_count': int,
2713 'uploader': 'Christopher Sykes',
2714 'uploader_url': 'https://www.youtube.com/@ChristopherSykesDocumentaries',
2715 'uploader_id': '@ChristopherSykesDocumentaries',
2718 'skip_download': True,
2724 def suitable(cls, url):
2725 from ..utils import parse_qs
2728 if qs.get('list', [None])[0]:
2730 return super().suitable(url)
2732 def __init__(self, *args, **kwargs):
2733 super().__init__(*args, **kwargs)
2734 self._code_cache = {}
2735 self._player_cache = {}
2737 def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2738 lock = threading.Lock()
2739 start_time = time.time()
2740 formats = [f for f in formats if f.get('is_from_start')]
2742 def refetch_manifest(format_id, delay):
2743 nonlocal formats, start_time, is_live
2744 if time.time() <= start_time + delay:
2747 _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2748 video_details = traverse_obj(prs, (..., 'videoDetails'), expected_type=dict)
2749 microformats = traverse_obj(
2750 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2752 _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2753 is_live = live_status == 'is_live'
2754 start_time = time.time()
2756 def mpd_feed(format_id, delay):
2758 @returns (manifest_url, manifest_stream_number, is_live) or None
2760 for retry in self.RetryManager(fatal=False):
2762 refetch_manifest(format_id, delay)
2764 f = next((f for f in formats if f['format_id'] == format_id), None)
2767 retry.error = f'{video_id}: Video is no longer live'
2769 retry.error = f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}'
2771 return f['manifest_url'], f['manifest_stream_number'], is_live
2775 f['is_live'] = is_live
2776 gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2777 live_start_time, mpd_feed, not is_live and f.copy())
2779 f['fragments'] = gen
2780 f['protocol'] = 'http_dash_segments_generator'
2782 f['fragments'] = LazyList(gen({}))
2783 del f['is_from_start']
2785 def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2786 FETCH_SPAN, MAX_DURATION = 5, 432000
2788 mpd_url, stream_number, is_live = None, None, True
2791 download_start_time = ctx.get('start') or time.time()
2793 lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2794 if lack_early_segments:
2795 self.report_warning(bug_reports_message(
2796 'Starting download from the last 120 hours of the live stream since '
2797 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2798 lack_early_segments = True
2800 known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2801 fragments, fragment_base_url = None, None
2803 def _extract_sequence_from_mpd(refresh_sequence, immediate):
2804 nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2805 # Obtain from MPD's maximum seq value
2806 old_mpd_url = mpd_url
2807 last_error = ctx.pop('last_error', None)
2808 expire_fast = immediate or last_error and isinstance(last_error, urllib.error.HTTPError) and last_error.code == 403
2809 mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2810 or (mpd_url, stream_number, False))
2811 if not refresh_sequence:
2812 if expire_fast and not is_live:
2813 return False, last_seq
2814 elif old_mpd_url == mpd_url:
2815 return True, last_seq
2816 if manifestless_orig_fmt:
2817 fmt_info = manifestless_orig_fmt
2820 fmts, _ = self._extract_mpd_formats_and_subtitles(
2821 mpd_url, None, note=False, errnote=False, fatal=False)
2822 except ExtractorError:
2825 no_fragment_score += 2
2826 return False, last_seq
2827 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2828 fragments = fmt_info['fragments']
2829 fragment_base_url = fmt_info['fragment_base_url']
2830 assert fragment_base_url
2832 _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2833 return True, _last_seq
2835 self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2837 fetch_time = time.time()
2838 if no_fragment_score > 30:
2840 if last_segment_url:
2841 # Obtain from "X-Head-Seqnum" header value from each segment
2843 urlh = self._request_webpage(
2844 last_segment_url, None, note=False, errnote=False, fatal=False)
2845 except ExtractorError:
2847 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2848 if last_seq is None:
2849 no_fragment_score += 2
2850 last_segment_url = None
2853 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2854 no_fragment_score += 2
2855 if not should_continue:
2858 if known_idx > last_seq:
2859 last_segment_url = None
2864 if begin_index < 0 and known_idx < 0:
2865 # skip from the start when it's negative value
2866 known_idx = last_seq + begin_index
2867 if lack_early_segments:
2868 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2870 for idx in range(known_idx, last_seq):
2871 # do not update sequence here or you'll get skipped some part of it
2872 should_continue, _ = _extract_sequence_from_mpd(False, False)
2873 if not should_continue:
2875 raise ExtractorError('breaking out of outer loop')
2876 last_segment_url = urljoin(fragment_base_url, 'sq/%d' % idx)
2878 'url': last_segment_url,
2879 'fragment_count': last_seq,
2881 if known_idx == last_seq:
2882 no_fragment_score += 5
2884 no_fragment_score = 0
2885 known_idx = last_seq
2886 except ExtractorError:
2889 if manifestless_orig_fmt:
2890 # Stop at the first iteration if running for post-live manifestless;
2891 # fragment count no longer increase since it starts
2894 time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2896 def _extract_player_url(self, *ytcfgs, webpage=None):
2897 player_url = traverse_obj(
2898 ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2899 get_all=False, expected_type=str)
2902 return urljoin('https://www.youtube.com', player_url)
2904 def _download_player_url(self, video_id, fatal=False):
2905 res = self._download_webpage(
2906 'https://www.youtube.com/iframe_api',
2907 note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2909 player_version = self._search_regex(
2910 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2912 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2914 def _signature_cache_id(self, example_sig):
2915 """ Return a string representation of a signature """
2916 return '.'.join(str(len(part)) for part in example_sig.split('.'))
2919 def _extract_player_info(cls, player_url):
2920 for player_re in cls._PLAYER_INFO_RE:
2921 id_m = re.search(player_re, player_url)
2925 raise ExtractorError('Cannot identify player %r' % player_url)
2926 return id_m.group('id')
2928 def _load_player(self, video_id, player_url, fatal=True):
2929 player_id = self._extract_player_info(player_url)
2930 if player_id not in self._code_cache:
2931 code = self._download_webpage(
2932 player_url, video_id, fatal=fatal,
2933 note='Downloading player ' + player_id,
2934 errnote='Download of %s failed' % player_url)
2936 self._code_cache[player_id] = code
2937 return self._code_cache.get(player_id)
2939 def _extract_signature_function(self, video_id, player_url, example_sig):
2940 player_id = self._extract_player_info(player_url)
2942 # Read from filesystem cache
2943 func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2944 assert os.path.basename(func_id) == func_id
2946 self.write_debug(f'Extracting signature function {func_id}')
2947 cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
2950 code = self._load_player(video_id, player_url)
2952 res = self._parse_sig_js(code)
2953 test_string = ''.join(map(chr, range(len(example_sig))))
2954 cache_spec = [ord(c) for c in res(test_string)]
2955 self.cache.store('youtube-sigfuncs', func_id, cache_spec)
2957 return lambda s: ''.join(s[i] for i in cache_spec)
2959 def _print_sig_code(self, func, example_sig):
2960 if not self.get_param('youtube_print_sig_code'):
2963 def gen_sig_code(idxs):
2964 def _genslice(start, end, step):
2965 starts = '' if start == 0 else str(start)
2966 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
2967 steps = '' if step == 1 else (':%d' % step)
2968 return f's[{starts}{ends}{steps}]'
2971 # Quelch pyflakes warnings - start will be set when step is set
2972 start = '(Never used)'
2973 for i, prev in zip(idxs[1:], idxs[:-1]):
2974 if step is not None:
2975 if i - prev == step:
2977 yield _genslice(start, prev, step)
2980 if i - prev in [-1, 1]:
2985 yield 's[%d]' % prev
2989 yield _genslice(start, i, step)
2991 test_string = ''.join(map(chr, range(len(example_sig))))
2992 cache_res = func(test_string)
2993 cache_spec = [ord(c) for c in cache_res]
2994 expr_code = ' + '.join(gen_sig_code(cache_spec))
2995 signature_id_tuple = '(%s)' % (
2996 ', '.join(str(len(p)) for p in example_sig.split('.')))
2997 code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
2998 ' return %s\n') % (signature_id_tuple, expr_code)
2999 self.to_screen('Extracted signature function:\n' + code)
3001 def _parse_sig_js(self, jscode):
3002 funcname = self._search_regex(
3003 (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3004 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3005 r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
3006 r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
3007 r'(?:\b|[^a-zA-Z0-9$])(?P<sig>[a-zA-Z0-9$]{2,})\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)(?:;[a-zA-Z0-9$]{2}\.[a-zA-Z0-9$]{2}\(a,\d+\))?',
3008 r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
3010 r'("|\')signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3011 r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
3012 r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3013 r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3014 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3015 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
3016 jscode, 'Initial JS player signature function name', group='sig')
3018 jsi = JSInterpreter(jscode)
3019 initial_function = jsi.extract_function(funcname)
3020 return lambda s: initial_function([s])
3022 def _cached(self, func, *cache_id):
3023 def inner(*args, **kwargs):
3024 if cache_id not in self._player_cache:
3026 self._player_cache[cache_id] = func(*args, **kwargs)
3027 except ExtractorError as e:
3028 self._player_cache[cache_id] = e
3029 except Exception as e:
3030 self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
3032 ret = self._player_cache[cache_id]
3033 if isinstance(ret, Exception):
3038 def _decrypt_signature(self, s, video_id, player_url):
3039 """Turn the encrypted s field into a working signature"""
3040 extract_sig = self._cached(
3041 self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
3042 func = extract_sig(video_id, player_url, s)
3043 self._print_sig_code(func, s)
3046 def _decrypt_nsig(self, s, video_id, player_url):
3047 """Turn the encrypted n field into a working signature"""
3048 if player_url is None:
3049 raise ExtractorError('Cannot decrypt nsig without player_url')
3050 player_url = urljoin('https://www.youtube.com', player_url)
3053 jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
3054 except ExtractorError as e:
3055 raise ExtractorError('Unable to extract nsig function code', cause=e)
3056 if self.get_param('youtube_print_sig_code'):
3057 self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
3060 extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
3061 ret = extract_nsig(jsi, func_code)(s)
3062 except JSInterpreter.Exception as e:
3064 jsi = PhantomJSwrapper(self, timeout=5000)
3065 except ExtractorError:
3067 self.report_warning(
3068 f'Native nsig extraction failed: Trying with PhantomJS\n'
3069 f' n = {s} ; player = {player_url}', video_id)
3070 self.write_debug(e, only_once=True)
3072 args, func_body = func_code
3074 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
3075 video_id=video_id, note='Executing signature code').strip()
3077 self.write_debug(f'Decrypted nsig {s} => {ret}')
3080 def _extract_n_function_name(self, jscode):
3081 funcname, idx = self._search_regex(
3082 r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
3083 jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
3087 return json.loads(js_to_json(self._search_regex(
3088 rf'var {re.escape(funcname)}\s*=\s*(\[.+?\]);', jscode,
3089 f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
3091 def _extract_n_function_code(self, video_id, player_url):
3092 player_id = self._extract_player_info(player_url)
3093 func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
3094 jscode = func_code or self._load_player(video_id, player_url)
3095 jsi = JSInterpreter(jscode)
3098 return jsi, player_id, func_code
3100 func_name = self._extract_n_function_name(jscode)
3103 func_code = self._search_regex(
3104 r'''(?xs
)%s\s
*=\s
*function\s
*\
((?P
<var
>[\w$
]+)\
)\s
*
3105 # NB: The end of the regex is intentionally kept strict
3106 {(?P<code>.+?}\s
*return\
[\w$
]+.join\
(""\
))};''' % func_name,
3107 jscode, 'nsig function', group=('var', 'code'), default=None)
3109 func_code = ([func_code[0]], func_code[1])
3111 self.write_debug('Extracting nsig function with jsinterp')
3112 func_code = jsi.extract_function_code(func_name)
3114 self.cache.store('youtube-nsig', player_id, func_code)
3115 return jsi, player_id, func_code
3117 def _extract_n_function_from_code(self, jsi, func_code):
3118 func = jsi.extract_function_from_code(*func_code)
3120 def extract_nsig(s):
3123 except JSInterpreter.Exception:
3125 except Exception as e:
3126 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
3128 if ret.startswith('enhanced_except_'):
3129 raise JSInterpreter.Exception('Signature function returned an exception')
3134 def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3136 Extract signatureTimestamp (sts)
3137 Required to tell API what sig/player version is in use.
3140 if isinstance(ytcfg, dict):
3141 sts = int_or_none(ytcfg.get('STS'))
3144 # Attempt to extract from player
3145 if player_url is None:
3146 error_msg = 'Cannot extract signature timestamp without player_url.'
3148 raise ExtractorError(error_msg)
3149 self.report_warning(error_msg)
3151 code = self._load_player(video_id, player_url, fatal=fatal)
3153 sts = int_or_none(self._search_regex(
3154 r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3155 'JS player signature timestamp', group='sts', fatal=fatal))
3158 def _mark_watched(self, video_id, player_responses):
3159 for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3160 label = 'fully ' if is_full else ''
3161 url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3162 expected_type=url_or_none)
3164 self.report_warning(f'Unable to mark {label}watched')
3166 parsed_url = urllib.parse.urlparse(url)
3167 qs = urllib.parse.parse_qs(parsed_url.query)
3169 # cpn generation algorithm is reverse engineered from base.js.
3170 # In fact it works even with dummy cpn.
3171 CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3172 cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16))
3174 # # more consistent results setting it to right before the end
3175 video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3180 'cmt': video_length,
3181 'el': 'detailpage', # otherwise defaults to "shorts"
3185 # these seem to mark watchtime "history" in the real world
3186 # they're required, so send in a single value
3192 url = urllib.parse.urlunparse(
3193 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3195 self._download_webpage(
3196 url, video_id, f'Marking {label}watched',
3197 'Unable to mark watched', fatal=False)
3200 def _extract_from_webpage(cls, url, webpage):
3201 # Invidious Instances
3202 # https://github.com/yt-dlp/yt-dlp/issues/195
3203 # https://github.com/iv-org/invidious/pull/1730
3205 r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3208 yield cls.url_result(mobj.group('url'), cls)
3209 raise cls.StopExtraction()
3211 yield from super()._extract_from_webpage(url, webpage)
3213 # lazyYT YouTube embed
3214 for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3215 yield cls.url_result(unescapeHTML(id_), cls, id_)
3217 # Wordpress "YouTube Video Importer" plugin
3218 for m in re.findall(r'''(?x
)<div
[^
>]+
3219 class=(?P
<q1
>[\'"])[^\'"]*\byvii
_single
_video
_player
\b[^
\'"]*(?P=q1)[^>]+
3220 data-video_id=(?P<q2>[\'"])([^
\'"]+)(?P=q2)''', webpage):
3221 yield cls.url_result(m[-1], cls, m[-1])
3224 def extract_id(cls, url):
3225 video_id = cls.get_temp_id(url)
3227 raise ExtractorError(f'Invalid URL: {url}')
3230 def _extract_chapters_from_json(self, data, duration):
3231 chapter_list = traverse_obj(
3233 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3234 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters'
3235 ), expected_type=list)
3237 return self._extract_chapters_helper(
3239 start_function=lambda chapter: float_or_none(
3240 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3241 title_function=lambda chapter: traverse_obj(
3242 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3245 def _extract_chapters_from_engagement_panel(self, data, duration):
3246 content_list = traverse_obj(
3248 ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3250 chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3251 chapter_title = lambda chapter: self._get_text(chapter, 'title')
3253 return next(filter(None, (
3254 self._extract_chapters_helper(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3255 chapter_time, chapter_title, duration)
3256 for contents in content_list)), [])
3258 def _extract_heatmap_from_player_overlay(self, data):
3259 content_list = traverse_obj(data, (
3260 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer', 'decoratedPlayerBarRenderer', 'playerBar',
3261 'multiMarkersPlayerBarRenderer', 'markersMap', ..., 'value', 'heatmap', 'heatmapRenderer', 'heatMarkers', {list}))
3262 return next(filter(None, (
3263 traverse_obj(contents, (..., 'heatMarkerRenderer', {
3264 'start_time': ('timeRangeStartMillis', {functools.partial(float_or_none, scale=1000)}),
3265 'end_time': {lambda x: (x['timeRangeStartMillis'] + x['markerDurationMillis']) / 1000},
3266 'value': ('heatMarkerIntensityScoreNormalized', {float_or_none}),
3267 })) for contents in content_list)), None)
3269 def _extract_comment(self, comment_renderer, parent=None):
3270 comment_id = comment_renderer.get('commentId')
3276 'text': self._get_text(comment_renderer, 'contentText'),
3277 'like_count': self._get_count(comment_renderer, 'voteCount'),
3278 'author_id': traverse_obj(comment_renderer, ('authorEndpoint', 'browseEndpoint', 'browseId', {self.ucid_or_none})),
3279 'author': self._get_text(comment_renderer, 'authorText'),
3280 'author_thumbnail': traverse_obj(comment_renderer, ('authorThumbnail', 'thumbnails', -1, 'url', {url_or_none})),
3281 'parent': parent or 'root',
3284 # Timestamp is an estimate calculated from the current time and time_text
3285 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3286 timestamp = self._parse_time_text(time_text)
3289 # FIXME: non-standard, but we need a way of showing that it is an estimate.
3290 '_time_text': time_text,
3291 'timestamp': timestamp,
3294 info['author_url'] = urljoin(
3295 'https://www.youtube.com', traverse_obj(comment_renderer, ('authorEndpoint', (
3296 ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'))),
3297 expected_type=str, get_all=False))
3299 author_is_uploader = traverse_obj(comment_renderer, 'authorIsChannelOwner')
3300 if author_is_uploader is not None:
3301 info['author_is_uploader'] = author_is_uploader
3303 comment_abr = traverse_obj(
3304 comment_renderer, ('actionsButtons', 'commentActionButtonsRenderer'), expected_type=dict)
3305 if comment_abr is not None:
3306 info['is_favorited'] = 'creatorHeart' in comment_abr
3308 comment_ab_icontype = traverse_obj(
3309 comment_renderer, ('authorCommentBadge', 'authorCommentBadgeRenderer', 'icon', 'iconType'))
3310 if comment_ab_icontype is not None:
3311 info['author_is_verified'] = comment_ab_icontype in ('CHECK_CIRCLE_THICK', 'OFFICIAL_ARTIST_BADGE')
3313 is_pinned = traverse_obj(comment_renderer, 'pinnedCommentBadge')
3315 info['is_pinned'] = True
3319 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3321 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3323 def extract_header(contents):
3324 _continuation = None
3325 for content in contents:
3326 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3327 expected_comment_count = self._get_count(
3328 comments_header_renderer, 'countText', 'commentsCount')
3330 if expected_comment_count is not None:
3331 tracker['est_total'] = expected_comment_count
3332 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3333 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3335 sort_menu_item = try_get(
3336 comments_header_renderer,
3337 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3338 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3340 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3341 if not _continuation:
3344 sort_text = str_or_none(sort_menu_item.get('title'))
3346 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3347 self.to_screen('Sorting comments by %s' % sort_text.lower())
3349 return _continuation
3351 def extract_thread(contents):
3353 tracker['current_page_thread'] = 0
3354 for content in contents:
3355 if not parent and tracker['total_parent_comments'] >= max_parents:
3357 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3358 comment_renderer = get_first(
3359 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3360 expected_type=dict, default={})
3362 comment = self._extract_comment(comment_renderer, parent)
3365 comment_id = comment['id']
3366 if comment.get('is_pinned'):
3367 tracker['pinned_comment_ids'].add(comment_id)
3368 # Sometimes YouTube may break and give us infinite looping comments.
3369 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3370 if comment_id in tracker['seen_comment_ids']:
3371 if comment_id in tracker['pinned_comment_ids'] and not comment.get('is_pinned'):
3372 # Pinned comments may appear a second time in newest first sort
3373 # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3375 self.report_warning('Detected YouTube comments looping. Stopping comment extraction as we probably cannot get any more.')
3378 tracker['seen_comment_ids'].add(comment['id'])
3380 tracker['running_total'] += 1
3381 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3384 # Attempt to get the replies
3385 comment_replies_renderer = try_get(
3386 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3388 if comment_replies_renderer:
3389 tracker['current_page_thread'] += 1
3390 comment_entries_iter = self._comment_entries(
3391 comment_replies_renderer, ytcfg, video_id,
3392 parent=comment.get('id'), tracker=tracker)
3393 yield from itertools.islice(comment_entries_iter, min(
3394 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3396 # Keeps track of counts across recursive calls
3401 current_page_thread=0,
3402 total_parent_comments=0,
3403 total_reply_comments=0,
3404 seen_comment_ids=set(),
3405 pinned_comment_ids=set()
3409 # YouTube comments have a max depth of 2
3410 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3412 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3413 'Set max replies in the max-comments extractor argument instead')
3414 if max_depth == 1 and parent:
3417 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
3418 lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
3420 continuation = self._extract_continuation(root_continuation_data)
3423 is_forced_continuation = False
3424 is_first_continuation = parent is None
3425 if is_first_continuation and not continuation:
3426 # Sometimes you can get comments by generating the continuation yourself,
3427 # even if YouTube initially reports them being disabled - e.g. stories comments.
3428 # Note: if the comment section is actually disabled, YouTube may return a response with
3429 # required check_get_keys missing. So we will disable that check initially in this case.
3430 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3431 is_forced_continuation = True
3433 continuation_items_path = (
3434 'onResponseReceivedEndpoints', ..., ('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems')
3435 for page_num in itertools.count(0):
3436 if not continuation:
3438 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3439 comment_prog_str = f"({tracker['running_total']}
/~{tracker['est_total']}
)"
3441 if is_first_continuation:
3442 note_prefix = 'Downloading comment section API JSON'
3444 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3445 tracker['current_page_thread'], comment_prog_str)
3447 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
3448 ' ' if parent else '', ' replies' if parent else '',
3449 page_num, comment_prog_str)
3451 # Do a deep check for incomplete data as sometimes YouTube may return no comments for a continuation
3452 # Ignore check if YouTube says the comment count is 0.
3453 check_get_keys = None
3454 if not is_forced_continuation and not (tracker['est_total'] == 0 and tracker['running_total'] == 0):
3455 check_get_keys = [[*continuation_items_path, ..., (
3456 'commentsHeaderRenderer' if is_first_continuation else ('commentThreadRenderer', 'commentRenderer'))]]
3458 response = self._extract_response(
3459 item_id=None, query=continuation,
3460 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3461 check_get_keys=check_get_keys)
3462 except ExtractorError as e:
3463 # Ignore incomplete data error for replies if retries didn't work.
3464 # This is to allow any other parent comments and comment threads to be downloaded.
3465 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3466 if 'incomplete data' in str(e).lower() and parent and self.get_param('ignoreerrors') is True:
3467 self.report_warning(
3468 'Received incomplete data for a comment reply thread and retrying did not help. '
3469 'Ignoring to let other comments be downloaded.')
3472 is_forced_continuation = False
3474 for continuation_items in traverse_obj(response, continuation_items_path, expected_type=list, default=[]):
3475 if is_first_continuation:
3476 continuation = extract_header(continuation_items)
3477 is_first_continuation = False
3482 for entry in extract_thread(continuation_items):
3486 continuation = self._extract_continuation({'contents': continuation_items})
3490 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3491 if message and not parent and tracker['running_total'] == 0:
3492 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3493 raise self.CommentsDisabled
3496 def _generate_comment_continuation(video_id):
3498 Generates initial comment section continuation token from given video id
3500 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3501 return base64.b64encode(token.encode()).decode()
3503 def _get_comments(self, ytcfg, video_id, contents, webpage):
3504 """Entry for comment extraction"""
3505 def _real_comment_extract(contents):
3507 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3508 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3509 yield from self._comment_entries(renderer, ytcfg, video_id)
3511 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3512 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3515 def _get_checkok_params():
3516 return {'contentCheckOk': True, 'racyCheckOk': True}
3519 def _generate_player_context(cls, sts=None):
3521 'html5Preference': 'HTML5_PREF_WANTS',
3524 context['signatureTimestamp'] = sts
3526 'playbackContext': {
3527 'contentPlaybackContext': context
3529 **cls._get_checkok_params()
3533 def _is_agegated(player_response):
3534 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3537 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3538 AGE_GATE_REASONS = (
3539 'confirm your age', 'age-restricted', 'inappropriate', # reason
3540 'age_verification_required', 'age_check_required', # status
3542 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3545 def _is_unplayable(player_response):
3546 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3548 _STORY_PLAYER_PARAMS = '8AEB'
3550 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3552 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3553 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3554 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3555 headers = self.generate_api_headers(
3556 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3559 'videoId': video_id,
3561 if smuggled_data.get('is_story') or _split_innertube_client(client)[0] == 'android':
3562 yt_query['params'] = self._STORY_PLAYER_PARAMS
3564 yt_query.update(self._generate_player_context(sts))
3565 return self._extract_response(
3566 item_id=video_id, ep='player', query=yt_query,
3567 ytcfg=player_ytcfg, headers=headers, fatal=True,
3568 default_client=client,
3569 note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
3572 def _get_requested_clients(self, url, smuggled_data):
3573 requested_clients = []
3574 default = ['android', 'web']
3575 allowed_clients = sorted(
3576 (client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'),
3577 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3578 for client in self._configuration_arg('player_client'):
3579 if client in allowed_clients:
3580 requested_clients.append(client)
3581 elif client == 'default':
3582 requested_clients.extend(default)
3583 elif client == 'all':
3584 requested_clients.extend(allowed_clients)
3586 self.report_warning(f'Skipping unsupported client {client}')
3587 if not requested_clients:
3588 requested_clients = default
3590 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3591 requested_clients.extend(
3592 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3594 return orderedSet(requested_clients)
3596 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3599 initial_pr = self._search_json(
3600 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3602 all_clients = set(clients)
3603 clients = clients[::-1]
3606 def append_client(*client_names):
3607 """ Append the first client name that exists but not already used """
3608 for client_name in client_names:
3609 actual_client = _split_innertube_client(client_name)[0]
3610 if actual_client in INNERTUBE_CLIENTS:
3611 if actual_client not in all_clients:
3612 clients.append(client_name)
3613 all_clients.add(actual_client)
3616 # Android player_response does not have microFormats which are needed for
3617 # extraction of some data. So we return the initial_pr with formats
3618 # stripped out even if not requested by the user
3619 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3621 pr = dict(initial_pr)
3622 pr['streamingData'] = None
3626 tried_iframe_fallback = False
3629 client, base_client, variant = _split_innertube_client(clients.pop())
3630 player_ytcfg = master_ytcfg if client == 'web' else {}
3631 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3632 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3634 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3635 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3636 if 'js' in self._configuration_arg('player_skip'):
3637 require_js_player = False
3640 if not player_url and not tried_iframe_fallback and require_js_player:
3641 player_url = self._download_player_url(video_id)
3642 tried_iframe_fallback = True
3645 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3646 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3647 except ExtractorError as e:
3649 self.report_warning(last_error)
3654 # YouTube may return a different video player response than expected.
3655 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3656 pr_video_id = traverse_obj(pr, ('videoDetails', 'videoId'))
3657 if pr_video_id and pr_video_id != video_id:
3658 self.report_warning(
3659 f'Skipping player response from {client} client (got player response for video "{pr_video_id}
" instead of "{video_id}
")' + bug_reports_message())
3661 # Save client name for introspection later
3662 name = short_client_name(client)
3663 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3664 sd[STREAMING_DATA_CLIENT_NAME] = name
3665 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3666 f[STREAMING_DATA_CLIENT_NAME] = name
3669 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3670 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3671 append_client(f'{base_client}_creator')
3672 elif self._is_agegated(pr):
3673 if variant == 'tv_embedded':
3674 append_client(f'{base_client}_embedded')
3676 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3681 self.report_warning(last_error)
3682 return prs, player_url
3684 def _needs_live_processing(self, live_status, duration):
3685 if (live_status == 'is_live' and self.get_param('live_from_start')
3686 or live_status == 'post_live' and (duration or 0) > 4 * 3600):
3689 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3690 CHUNK_SIZE = 10 << 20
3691 itags, stream_ids = collections.defaultdict(set), []
3692 itag_qualities, res_qualities = {}, {0: None}
3694 # Normally tiny is the smallest video-only formats. But
3695 # audio-only formats with unknown quality may get tagged as tiny
3697 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3698 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
3700 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3701 all_formats = self._configuration_arg('include_duplicate_formats')
3703 def build_fragments(f):
3705 'url': update_url_query(f['url'], {
3706 'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}'
3708 } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3710 for fmt in streaming_formats:
3711 if fmt.get('targetDurationSec'):
3714 itag = str_or_none(fmt.get('itag'))
3715 audio_track = fmt.get('audioTrack') or {}
3716 stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3718 if stream_id in stream_ids:
3721 quality = fmt.get('quality')
3722 height = int_or_none(fmt.get('height'))
3723 if quality == 'tiny' or not quality:
3724 quality = fmt.get('audioQuality', '').lower() or quality
3725 # The 3gp format (17) in android client has a quality of "small
",
3726 # but is actually worse than other formats
3731 itag_qualities[itag] = quality
3733 res_qualities[height] = quality
3734 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3735 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3736 # number of fragment that would subsequently requested with (`&sq=N`)
3737 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3740 fmt_url = fmt.get('url')
3742 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3743 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3744 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3745 if not all((sc, fmt_url, player_url, encrypted_sig)):
3748 fmt_url += '&%s=%s' % (
3749 traverse_obj(sc, ('sp', -1)) or 'signature',
3750 self._decrypt_signature(encrypted_sig, video_id, player_url)
3752 except ExtractorError as e:
3753 self.report_warning('Signature extraction failed: Some formats may be missing',
3754 video_id=video_id, only_once=True)
3755 self.write_debug(e, only_once=True)
3758 query = parse_qs(fmt_url)
3762 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3763 fmt_url = update_url_query(fmt_url, {
3764 'n': decrypt_nsig(query['n'][0], video_id, player_url)
3766 except ExtractorError as e:
3768 if isinstance(e, JSInterpreter.Exception):
3769 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3770 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3772 self.report_warning(
3773 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3774 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3775 self.write_debug(e, only_once=True)
3777 self.report_warning(
3778 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3779 video_id=video_id, only_once=True)
3782 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3783 language_preference = (
3784 10 if audio_track.get('audioIsDefault') and 10
3785 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3787 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3788 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3789 # Make sure to avoid false positives with small duration differences.
3790 # E.g. __2ABJjxzNo, ySuUZEjARPY
3791 is_damaged = try_get(fmt, lambda x: float(x['approxDurationMs']) / duration < 500)
3793 self.report_warning(
3794 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3796 client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3798 'asr': int_or_none(fmt.get('audioSampleRate')),
3799 'filesize': int_or_none(fmt.get('contentLength')),
3800 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3801 'format_note': join_nonempty(
3802 join_nonempty(audio_track.get('displayName'),
3803 language_preference > 0 and ' (default)', delim=''),
3804 fmt.get('qualityLabel') or quality.replace('audio_quality_', ''),
3805 fmt.get('isDrc') and 'DRC',
3806 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3807 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3808 throttled and 'THROTTLED', is_damaged and 'DAMAGED',
3809 (self.get_param('verbose') or all_formats) and client_name,
3811 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3812 'source_preference': -10 if throttled else -5 if itag == '22' else -1,
3813 'fps': int_or_none(fmt.get('fps')) or None,
3814 'audio_channels': fmt.get('audioChannels'),
3816 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3817 'has_drm': bool(fmt.get('drmFamilies')),
3820 'width': int_or_none(fmt.get('width')),
3821 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3822 'desc' if language_preference < -1 else '') or None,
3823 'language_preference': language_preference,
3824 # Strictly de-prioritize damaged and 3gp formats
3825 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3827 mime_mobj = re.match(
3828 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3830 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3831 dct.update(parse_codecs(mime_mobj.group(2)))
3833 itags[itag].add(('https
', dct.get('language
')))
3834 stream_ids.append(stream_id)
3835 single_stream = 'none
' in (dct.get('acodec
'), dct.get('vcodec
'))
3836 if single_stream and dct.get('ext
'):
3837 dct['container
'] = dct['ext
'] + '_dash
'
3839 if all_formats and dct['filesize
']:
3842 'format_id
': f'{dct["format_id"]}
-dashy
' if all_formats else dct['format_id
'],
3843 'protocol
': 'http_dash_segments
',
3844 'fragments
': build_fragments(dct),
3846 dct['downloader_options
'] = {'http_chunk_size': CHUNK_SIZE}
3849 needs_live_processing = self._needs_live_processing(live_status, duration)
3850 skip_bad_formats = not self._configuration_arg('include_incomplete_formats
')
3852 skip_manifests = set(self._configuration_arg('skip
'))
3853 if (not self.get_param('youtube_include_hls_manifest
', True)
3854 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3855 or needs_live_processing and skip_bad_formats):
3856 skip_manifests.add('hls
')
3858 if not self.get_param('youtube_include_dash_manifest
', True):
3859 skip_manifests.add('dash
')
3860 if self._configuration_arg('include_live_dash
'):
3861 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3862 'Use include_incomplete_formats extractor argument instead
')
3863 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3864 skip_manifests.add('dash
')
3866 def process_manifest_format(f, proto, client_name, itag):
3867 key = (proto, f.get('language
'))
3868 if not all_formats and key in itags[itag]:
3870 itags[itag].add(key)
3872 if itag and all_formats:
3873 f['format_id
'] = f'{itag}
-{proto}
'
3874 elif any(p != proto for p, _ in itags[itag]):
3875 f['format_id
'] = f'{itag}
-{proto}
'
3877 f['format_id
'] = itag
3879 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
3880 if f['quality
'] == -1 and f.get('height
'):
3881 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
3882 if self.get_param('verbose
'):
3883 f['format_note
'] = join_nonempty(f.get('format_note
'), client_name, delim=', ')
3887 for sd in streaming_data:
3888 client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
3890 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
3891 if hls_manifest_url:
3892 fmts, subs = self._extract_m3u8_formats_and_subtitles(
3893 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
3894 subtitles = self._merge_subtitles(subs, subtitles)
3896 if process_manifest_format(f, 'hls
', client_name, self._search_regex(
3897 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
3900 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
3901 if dash_manifest_url:
3902 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
3903 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
3905 if process_manifest_format(f, 'dash
', client_name, f['format_id
']):
3906 f['filesize
'] = int_or_none(self._search_regex(
3907 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
3908 if needs_live_processing:
3909 f['is_from_start
'] = True
3914 def _extract_storyboard(self, player_responses, duration):
3916 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
3917 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
3921 for i, args in enumerate(spec):
3922 args = args.split('#')
3923 counts
= list(map(int_or_none
, args
[:5]))
3924 if len(args
) != 8 or not all(counts
):
3925 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
3927 width
, height
, frame_count
, cols
, rows
= counts
3930 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
3931 fragment_count
= frame_count
/ (cols
* rows
)
3932 fragment_duration
= duration
/ fragment_count
3934 'format_id': f
'sb{i}',
3935 'format_note': 'storyboard',
3937 'protocol': 'mhtml',
3943 'fps': frame_count
/ duration
,
3947 'url': url
.replace('$M', str(j
)),
3948 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
3949 } for j
in range(math
.ceil(fragment_count
))],
3952 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
3954 if 'webpage' not in self
._configuration
_arg
('player_skip'):
3955 query
= {'bpctr': '9999999999', 'has_verified': '1'}
3956 if smuggled_data
.get('is_story'):
3957 query
['pp'] = self
._STORY
_PLAYER
_PARAMS
3958 webpage
= self
._download
_webpage
(
3959 webpage_url
, video_id
, fatal
=False, query
=query
)
3961 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
3963 player_responses
, player_url
= self
._extract
_player
_responses
(
3964 self
._get
_requested
_clients
(url
, smuggled_data
),
3965 video_id
, webpage
, master_ytcfg
, smuggled_data
)
3967 return webpage
, master_ytcfg
, player_responses
, player_url
3969 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
3970 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
3971 is_live
= get_first(video_details
, 'isLive')
3973 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
3974 live_content
= get_first(video_details
, 'isLiveContent')
3975 is_upcoming
= get_first(video_details
, 'isUpcoming')
3976 post_live
= get_first(video_details
, 'isPostLiveDvr')
3977 live_status
= ('post_live' if post_live
3978 else 'is_live' if is_live
3979 else 'is_upcoming' if is_upcoming
3980 else 'was_live' if live_content
3981 else 'not_live' if False in (is_live
, live_content
)
3983 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'))
3984 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
3986 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
3988 def _real_extract(self
, url
):
3989 url
, smuggled_data
= unsmuggle_url(url
, {})
3990 video_id
= self
._match
_id
(url
)
3992 base_url
= self
.http_scheme() + '//www.youtube.com/'
3993 webpage_url
= base_url
+ 'watch?v=' + video_id
3995 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
3997 playability_statuses
= traverse_obj(
3998 player_responses
, (..., 'playabilityStatus'), expected_type
=dict)
4000 trailer_video_id
= get_first(
4001 playability_statuses
,
4002 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
4004 if trailer_video_id
:
4005 return self
.url_result(
4006 trailer_video_id
, self
.ie_key(), trailer_video_id
)
4008 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
4009 if webpage
else (lambda x
: None))
4011 video_details
= traverse_obj(player_responses
, (..., 'videoDetails'), expected_type
=dict)
4012 microformats
= traverse_obj(
4013 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
4016 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
4017 video_title
= (self
._preferred
_lang
and translated_title
4018 or get_first(video_details
, 'title') # primary
4020 or search_meta(['og:title', 'twitter:title', 'title']))
4021 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
4022 original_description
= get_first(video_details
, 'shortDescription')
4023 video_description
= (
4024 self
._preferred
_lang
and translated_description
4025 # If original description is blank, it will be an empty string.
4026 # Do not prefer translated description in this case.
4027 or original_description
if original_description
is not None else translated_description
)
4029 multifeed_metadata_list
= get_first(
4031 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
4033 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
4034 if self
.get_param('noplaylist'):
4035 self
.to_screen('Downloading just video %s because of --no-playlist' % video_id
)
4039 for feed
in multifeed_metadata_list
.split(','):
4040 # Unquote should take place before split on comma (,) since textual
4041 # fields may contain comma as well (see
4042 # https://github.com/ytdl-org/youtube-dl/issues/8536)
4043 feed_data
= urllib
.parse
.parse_qs(
4044 urllib
.parse
.unquote_plus(feed
))
4046 def feed_entry(name
):
4048 feed_data
, lambda x
: x
[name
][0], str)
4050 feed_id
= feed_entry('id')
4053 feed_title
= feed_entry('title')
4056 title
+= ' (%s)' % feed_title
4058 '_type': 'url_transparent',
4059 'ie_key': 'Youtube',
4061 '%swatch?v=%s' % (base_url
, feed_data
['id'][0]),
4062 {'force_singlefeed': True}
),
4065 feed_ids
.append(feed_id
)
4067 'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
4068 % (', '.join(feed_ids
), video_id
))
4069 return self
.playlist_result(
4070 entries
, video_id
, video_title
, video_description
)
4072 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
4073 or int_or_none(get_first(microformats
, 'lengthSeconds'))
4074 or parse_duration(search_meta('duration')) or None)
4076 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
4077 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
4078 if live_status
== 'post_live':
4079 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
4082 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
4083 self
.report_drm(video_id
)
4085 playability_statuses
,
4086 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
4087 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
4088 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
4090 if subreason
== 'The uploader has not made this video available in your country.':
4091 countries
= get_first(microformats
, 'availableCountries')
4093 regions_allowed
= search_meta('regionsAllowed')
4094 countries
= regions_allowed
.split(',') if regions_allowed
else None
4095 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
4096 reason
+= f
'. {subreason}'
4098 self
.raise_no_formats(reason
, expected
=True)
4100 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
4101 if not keywords
and webpage
:
4103 unescapeHTML(m
.group('content'))
4104 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
4105 for keyword
in keywords
:
4106 if keyword
.startswith('yt:stretch='):
4107 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
4109 # NB: float is intentional for forcing float division
4110 w
, h
= (float(v
) for v
in mobj
.groups())
4114 if f
.get('vcodec') != 'none':
4115 f
['stretched_ratio'] = ratio
4117 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
4118 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
4121 'url': thumbnail_url
,
4123 original_thumbnails
= thumbnails
.copy()
4125 # The best resolution thumbnails sometimes does not appear in the webpage
4126 # See: https://github.com/yt-dlp/yt-dlp/issues/340
4127 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4129 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4130 # in resolution, these are not the custom thumbnail. So de-prioritize them
4131 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4132 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3'
4134 n_thumbnail_names
= len(thumbnail_names
)
4136 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4137 video_id
=video_id
, name
=name
, ext
=ext
,
4138 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
4139 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
4140 for thumb
in thumbnails
:
4141 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
4142 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
4143 self
._remove
_duplicate
_formats
(thumbnails
)
4144 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
4146 category
= get_first(microformats
, 'category') or search_meta('genre')
4147 channel_id
= self
.ucid_or_none(str_or_none(
4148 get_first(video_details
, 'channelId')
4149 or get_first(microformats
, 'externalChannelId')
4150 or search_meta('channelId')))
4151 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
4153 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
4154 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
4155 if not duration
and live_end_time
and live_start_time
:
4156 duration
= live_end_time
- live_start_time
4158 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
4160 def is_bad_format(fmt
):
4161 if needs_live_processing
and not fmt
.get('is_from_start'):
4163 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
4164 and fmt
.get('protocol') == 'http_dash_segments'):
4167 for fmt
in filter(is_bad_format
, formats
):
4168 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4169 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 4 hours)', delim
=' ')
4171 if needs_live_processing
:
4172 self
._prepare
_live
_from
_start
_formats
(
4173 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4175 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4177 channel_handle
= self
.handle_from_url(owner_profile_url
)
4181 'title': video_title
,
4183 'thumbnails': thumbnails
,
4184 # The best thumbnail that we are sure exists. Prevents unnecessary
4185 # URL checking if user don't care about getting the best possible thumbnail
4186 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4187 'description': video_description
,
4188 'channel_id': channel_id
,
4189 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None),
4190 'duration': duration
,
4191 'view_count': int_or_none(
4192 get_first((video_details
, microformats
), (..., 'viewCount'))
4193 or search_meta('interactionCount')),
4194 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4195 'age_limit': 18 if (
4196 get_first(microformats
, 'isFamilySafe') is False
4197 or search_meta('isFamilyFriendly') == 'false'
4198 or search_meta('og:restrictions:age') == '18+') else 0,
4199 'webpage_url': webpage_url
,
4200 'categories': [category
] if category
else None,
4202 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4203 'live_status': live_status
,
4204 'release_timestamp': live_start_time
,
4205 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4206 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto')
4210 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4212 def get_lang_code(track
):
4213 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4214 or track
.get('languageCode'))
4216 # Converted into dicts to remove duplicates
4218 get_lang_code(sub
): sub
4219 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...))}
4220 translation_languages
= {
4221 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4222 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...))}
4224 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4225 lang_subs
= container
.setdefault(lang_code
, [])
4226 for fmt
in self
._SUBTITLE
_FORMATS
:
4232 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4236 # NB: Constructing the full subtitle dictionary is slow
4237 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4238 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4239 for lang_code
, caption_track
in captions
.items():
4240 base_url
= caption_track
.get('baseUrl')
4241 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4244 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4245 if caption_track
.get('kind') != 'asr':
4249 subtitles
, base_url
, lang_code
, lang_name
, {})
4250 if not caption_track
.get('isTranslatable'):
4252 for trans_code
, trans_name
in translation_languages
.items():
4255 orig_trans_code
= trans_code
4256 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4257 if not get_translated_subs
:
4259 trans_code
+= f
'-{lang_code}'
4260 trans_name
+= format_field(lang_name
, None, ' from %s')
4261 # Add an "-orig" label to the original language so that it can be distinguished.
4262 # The subs are returned without "-orig" as well for compatibility
4263 if lang_code
== f
'a-{orig_trans_code}':
4265 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4266 # Setting tlang=lang returns damaged subtitles.
4267 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4268 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4270 info
['automatic_captions'] = automatic_captions
4271 info
['subtitles'] = subtitles
4273 parsed_url
= urllib
.parse
.urlparse(url
)
4274 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4275 query
= urllib
.parse
.parse_qs(component
)
4276 for k
, v
in query
.items():
4277 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4279 if d_k
not in info
and k
in s_ks
:
4280 info
[d_k
] = parse_duration(query
[k
][0])
4282 # Youtube Music Auto-generated description
4283 if video_description
:
4286 (?P<track>[^·\n]+)·(?P<artist>[^\n]+)\n+
4288 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4289 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4290 (.+?\nArtist\s*:\s*(?P<clean_artist>[^\n]+))?
4291 .+\nAuto-generated\ by\ YouTube\.\s*$
4292 ''', video_description
)
4294 release_year
= mobj
.group('release_year')
4295 release_date
= mobj
.group('release_date')
4297 release_date
= release_date
.replace('-', '')
4298 if not release_year
:
4299 release_year
= release_date
[:4]
4301 'album': mobj
.group('album'.strip()),
4302 'artist': mobj
.group('clean_artist') or ', '.join(a
.strip() for a
in mobj
.group('artist').split('·')),
4303 'track': mobj
.group('track').strip(),
4304 'release_date': release_date
,
4305 'release_year': int_or_none(release_year
),
4310 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4311 if not traverse_obj(initial_data
, 'contents'):
4312 self
.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4314 if not initial_data
:
4315 query
= {'videoId': video_id}
4316 query
.update(self
._get
_checkok
_params
())
4317 initial_data
= self
._extract
_response
(
4318 item_id
=video_id
, ep
='next', fatal
=False,
4319 ytcfg
=master_ytcfg
, query
=query
, check_get_keys
='contents',
4320 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4321 note
='Downloading initial data API JSON')
4323 info
['comment_count'] = traverse_obj(initial_data
, (
4324 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4325 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount'
4327 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4328 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo'
4329 ), expected_type
=self
._get
_count
, get_all
=False)
4331 try: # This will error if there is no livechat
4332 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4333 except (KeyError, IndexError, TypeError):
4336 info
.setdefault('subtitles', {})['live_chat'] = [{
4337 # url is needed to set cookies
4338 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4339 'video_id': video_id
,
4341 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4342 else 'youtube_live_chat_replay'),
4346 info
['chapters'] = (
4347 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4348 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4349 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4352 info
['heatmap'] = self
._extract
_heatmap
_from
_player
_overlay
(initial_data
)
4354 contents
= traverse_obj(
4355 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4356 expected_type
=list, default
=[])
4358 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4360 stl
= vpir
.get('superTitleLink')
4362 stl
= self
._get
_text
(stl
)
4365 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4366 info
['location'] = stl
4368 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4371 'series': mobj
.group(1),
4372 'season_number': int(mobj
.group(2)),
4373 'episode_number': int(mobj
.group(3)),
4375 for tlb
in (try_get(
4377 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4381 tlb
, ('toggleButtonRenderer', ...),
4382 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4384 for getter
, regex
in [(
4385 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4386 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4387 lambda x
: x
['accessibility'],
4388 lambda x
: x
['accessibilityData']['accessibilityData'],
4389 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4390 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4392 mobj
= re
.match(regex
, label
)
4394 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4396 sbr_tooltip
= try_get(
4397 vpir
, lambda x
: x
['sentimentBar']['sentimentBarRenderer']['tooltip'])
4399 like_count
, dislike_count
= sbr_tooltip
.split(' / ')
4401 'like_count': str_to_int(like_count
),
4402 'dislike_count': str_to_int(dislike_count
),
4404 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4406 vc
= self
._get
_count
(vcr
, 'viewCount')
4407 # Upcoming premieres with waiting count are treated as live here
4408 if vcr
.get('isLive'):
4409 info
['concurrent_view_count'] = vc
4410 elif info
.get('view_count') is None:
4411 info
['view_count'] = vc
4413 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4415 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4417 'channel': self
._get
_text
(vor
, 'title'),
4418 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4420 if not channel_handle
:
4421 channel_handle
= self
.handle_from_url(
4423 ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4424 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4425 {str}
), get_all
=False))
4429 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4431 multiple_songs
= False
4433 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4434 multiple_songs
= True
4437 mrr
= row
.get('metadataRowRenderer') or {}
4438 mrr_title
= mrr
.get('title')
4441 mrr_title
= self
._get
_text
(mrr
, 'title')
4442 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4443 if mrr_title
== 'License':
4444 info
['license'] = mrr_contents_text
4445 elif not multiple_songs
:
4446 if mrr_title
== 'Album':
4447 info
['album'] = mrr_contents_text
4448 elif mrr_title
== 'Artist':
4449 info
['artist'] = mrr_contents_text
4450 elif mrr_title
== 'Song':
4451 info
['track'] = mrr_contents_text
4454 'uploader': info
.get('channel'),
4455 'uploader_id': channel_handle
,
4456 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4458 # The upload date for scheduled, live and past live streams / premieres in microformats
4459 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4460 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4462 unified_strdate(get_first(microformats
, 'uploadDate'))
4463 or unified_strdate(search_meta('uploadDate')))
4464 if not upload_date
or (
4465 live_status
in ('not_live', None)
4466 and 'no-youtube-prefer-utc-upload-date' not in self
.get_param('compat_opts', [])
4468 upload_date
= strftime_or_none(
4469 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText')), '%Y%m%d') or upload_date
4470 info
['upload_date'] = upload_date
4472 for s_k
, d_k
in [('artist', 'creator'), ('track', 'alt_title')]:
4477 badges
= self
._extract
_badges
(traverse_obj(contents
, (..., 'videoPrimaryInfoRenderer'), get_all
=False))
4479 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4480 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4482 info
['availability'] = (
4483 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4484 else self
._availability
(
4485 is_private
=is_private
,
4487 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4488 or False if initial_data
and is_private
is not None else None),
4489 needs_subscription
=(
4490 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4491 or False if initial_data
and is_private
is not None else None),
4492 needs_auth
=info
['age_limit'] >= 18,
4493 is_unlisted
=None if is_private
is None else (
4494 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4495 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4497 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4499 self
.mark_watched(video_id
, player_responses
)
4504 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4506 def passthrough_smuggled_data(func
):
4507 def _smuggle(info
, smuggled_data
):
4508 if info
.get('_type') not in ('url', 'url_transparent'):
4510 if smuggled_data
.get('is_music_url'):
4511 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4512 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4513 smuggled_data
.pop('is_music_url')
4514 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4516 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4519 @functools.wraps(func
)
4520 def wrapper(self
, url
):
4521 url
, smuggled_data
= unsmuggle_url(url
, {})
4522 if self
.is_music_url(url
):
4523 smuggled_data
['is_music_url'] = True
4524 info_dict
= func(self
, url
, smuggled_data
)
4526 _smuggle(info_dict
, smuggled_data
)
4527 if info_dict
.get('entries'):
4528 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4533 def _extract_basic_item_renderer(item
):
4534 # Modified from _extract_grid_item_renderer
4535 known_basic_renderers
= (
4536 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer'
4538 for key
, renderer
in item
.items():
4539 if not isinstance(renderer
, dict):
4541 elif key
in known_basic_renderers
:
4543 elif key
.startswith('grid') and key
.endswith('Renderer'):
4546 def _extract_channel_renderer(self
, renderer
):
4547 channel_id
= self
.ucid_or_none(renderer
['channelId'])
4548 title
= self
._get
_text
(renderer
, 'title')
4549 channel_url
= format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None)
4550 # As of 2023-03-01 YouTube doesn't use the channel handles on these renderers yet.
4551 # However we can expect them to change that in the future.
4552 channel_handle
= self
.handle_from_url(
4553 traverse_obj(renderer
, (
4554 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4555 ('browseEndpoint', 'canonicalBaseUrl')),
4556 {str}
), get_all
=False))
4561 'ie_key': YoutubeTabIE
.ie_key(),
4564 'channel_id': channel_id
,
4565 'channel_url': channel_url
,
4567 'uploader_id': channel_handle
,
4568 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4569 'channel_follower_count': self
._get
_count
(renderer
, 'subscriberCountText'),
4570 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
4571 'playlist_count': self
._get
_count
(renderer
, 'videoCountText'),
4572 'description': self
._get
_text
(renderer
, 'descriptionSnippet'),
4575 def _grid_entries(self
, grid_renderer
):
4576 for item
in grid_renderer
['items']:
4577 if not isinstance(item
, dict):
4579 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4580 if not isinstance(renderer
, dict):
4582 title
= self
._get
_text
(renderer
, 'title')
4585 playlist_id
= renderer
.get('playlistId')
4587 yield self
.url_result(
4588 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4589 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4593 video_id
= renderer
.get('videoId')
4595 yield self
._extract
_video
(renderer
)
4598 channel_id
= renderer
.get('channelId')
4600 yield self
._extract
_channel
_renderer
(renderer
)
4602 # generic endpoint URL support
4603 ep_url
= urljoin('https://www.youtube.com/', try_get(
4604 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4607 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4608 if ie
.suitable(ep_url
):
4609 yield self
.url_result(
4610 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4613 def _music_reponsive_list_entry(self
, renderer
):
4614 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4616 title
= traverse_obj(renderer
, (
4617 'flexColumns', 0, 'musicResponsiveListItemFlexColumnRenderer',
4618 'text', 'runs', 0, 'text'))
4619 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4620 ie
=YoutubeIE
.ie_key(), video_id
=video_id
, title
=title
)
4621 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4623 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4625 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4626 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4627 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4628 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4629 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4631 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4632 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4634 def _shelf_entries_from_content(self
, shelf_renderer
):
4635 content
= shelf_renderer
.get('content')
4636 if not isinstance(content
, dict):
4638 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4640 # TODO: add support for nested playlists so each shelf is processed
4641 # as separate playlist
4642 # TODO: this includes only first N items
4643 yield from self
._grid
_entries
(renderer
)
4644 renderer
= content
.get('horizontalListRenderer')
4649 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4651 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4653 shelf_url
= urljoin('https://www.youtube.com', ep
)
4655 # Skipping links to another channels, note that checking for
4656 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4658 if skip_channels
and '/channels?' in shelf_url
:
4660 title
= self
._get
_text
(shelf_renderer
, 'title')
4661 yield self
.url_result(shelf_url
, video_title
=title
)
4662 # Shelf may not contain shelf URL, fallback to extraction from content
4663 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4665 def _playlist_entries(self
, video_list_renderer
):
4666 for content
in video_list_renderer
['contents']:
4667 if not isinstance(content
, dict):
4669 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4670 if not isinstance(renderer
, dict):
4672 video_id
= renderer
.get('videoId')
4675 yield self
._extract
_video
(renderer
)
4677 def _rich_entries(self
, rich_grid_renderer
):
4678 renderer
= traverse_obj(
4680 ('content', ('videoRenderer', 'reelItemRenderer', 'playlistRenderer')), get_all
=False) or {}
4681 video_id
= renderer
.get('videoId')
4683 yield self
._extract
_video
(renderer
)
4685 playlist_id
= renderer
.get('playlistId')
4687 yield self
.url_result(
4688 f
'https://www.youtube.com/playlist?list={playlist_id}',
4689 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4690 video_title
=self
._get
_text
(renderer
, 'title'))
4693 def _video_entry(self
, video_renderer
):
4694 video_id
= video_renderer
.get('videoId')
4696 return self
._extract
_video
(video_renderer
)
4698 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4699 url
= urljoin('https://youtube.com', traverse_obj(
4700 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4702 return self
.url_result(
4703 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4705 def _post_thread_entries(self
, post_thread_renderer
):
4706 post_renderer
= try_get(
4707 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4708 if not post_renderer
:
4711 video_renderer
= try_get(
4712 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4713 video_id
= video_renderer
.get('videoId')
4715 entry
= self
._extract
_video
(video_renderer
)
4718 # playlist attachment
4719 playlist_id
= try_get(
4720 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4722 yield self
.url_result(
4723 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4724 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4725 # inline video links
4726 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4728 if not isinstance(run
, dict):
4731 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4734 if not YoutubeIE
.suitable(ep_url
):
4736 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4737 if video_id
== ep_video_id
:
4739 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4741 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4742 contents
= post_thread_continuation
.get('contents')
4743 if not isinstance(contents
, list):
4745 for content
in contents
:
4746 renderer
= content
.get('backstagePostThreadRenderer')
4747 if isinstance(renderer
, dict):
4748 yield from self
._post
_thread
_entries
(renderer
)
4750 renderer
= content
.get('videoRenderer')
4751 if isinstance(renderer
, dict):
4752 yield self
._video
_entry
(renderer
)
4755 def _rich_grid_entries(self, contents):
4756 for content in contents:
4757 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4759 entry = self._video_entry(video_renderer)
4764 def _report_history_entries(self
, renderer
):
4765 for url
in traverse_obj(renderer
, (
4766 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4767 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4768 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4769 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4771 def _extract_entries(self
, parent_renderer
, continuation_list
):
4772 # continuation_list is modified in-place with continuation_list = [continuation_token]
4773 continuation_list
[:] = [None]
4774 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4775 for content
in contents
:
4776 if not isinstance(content
, dict):
4778 is_renderer
= traverse_obj(
4779 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4782 if content
.get('richItemRenderer'):
4783 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4785 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4786 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4787 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4788 yield from self
._report
_history
_entries
(table
)
4789 continuation_list
[0] = self
._extract
_continuation
(table
)
4792 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4793 for isr_content
in isr_contents
:
4794 if not isinstance(isr_content
, dict):
4798 'playlistVideoListRenderer': self
._playlist
_entries
,
4799 'gridRenderer': self
._grid
_entries
,
4800 'reelShelfRenderer': self
._grid
_entries
,
4801 'shelfRenderer': self
._shelf
_entries
,
4802 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4803 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4804 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4805 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4806 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4807 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)]
4809 for key
, renderer
in isr_content
.items():
4810 if key
not in known_renderers
:
4812 for entry
in known_renderers
[key
](renderer
):
4815 continuation_list
[0] = self
._extract
_continuation
(renderer
)
4818 if not continuation_list
[0]:
4819 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
4821 if not continuation_list
[0]:
4822 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4824 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
4825 continuation_list
= [None]
4826 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
4827 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
4831 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
4832 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
4833 yield from extract_entries(parent_renderer
)
4834 continuation
= continuation_list
[0]
4836 for page_num
in itertools
.count(1):
4837 if not continuation
:
4839 headers
= self
.generate_api_headers(
4840 ytcfg
=ytcfg
, account_syncid
=account_syncid
, visitor_data
=visitor_data
)
4841 response
= self
._extract
_response
(
4842 item_id
=f
'{item_id} page {page_num}',
4843 query
=continuation
, headers
=headers
, ytcfg
=ytcfg
,
4844 check_get_keys
=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4848 # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
4849 # See: https://github.com/ytdl-org/youtube-dl/issues/28702
4850 visitor_data
= self
._extract
_visitor
_data
(response
) or visitor_data
4853 'videoRenderer': (self
._grid
_entries
, 'items'), # for membership tab
4854 'gridPlaylistRenderer': (self
._grid
_entries
, 'items'),
4855 'gridVideoRenderer': (self
._grid
_entries
, 'items'),
4856 'gridChannelRenderer': (self
._grid
_entries
, 'items'),
4857 'playlistVideoRenderer': (self
._playlist
_entries
, 'contents'),
4858 'itemSectionRenderer': (extract_entries
, 'contents'), # for feeds
4859 'richItemRenderer': (extract_entries
, 'contents'), # for hashtag
4860 'backstagePostThreadRenderer': (self
._post
_thread
_continuation
_entries
, 'contents'),
4861 'reportHistoryTableRowRenderer': (self
._report
_history
_entries
, 'rows'),
4862 'playlistVideoListContinuation': (self
._playlist
_entries
, None),
4863 'gridContinuation': (self
._grid
_entries
, None),
4864 'itemSectionContinuation': (self
._post
_thread
_continuation
_entries
, None),
4865 'sectionListContinuation': (extract_entries
, None), # for feeds
4868 continuation_items
= traverse_obj(response
, (
4869 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
4870 'appendContinuationItemsAction', 'continuationItems'
4871 ), 'continuationContents', get_all
=False)
4872 continuation_item
= traverse_obj(continuation_items
, 0, None, expected_type
=dict, default
={})
4874 video_items_renderer
= None
4875 for key
in continuation_item
.keys():
4876 if key
not in known_renderers
:
4878 func
, parent_key
= known_renderers
[key
]
4879 video_items_renderer
= {parent_key: continuation_items}
if parent_key
else continuation_items
4880 continuation_list
= [None]
4881 yield from func(video_items_renderer
)
4882 continuation
= continuation_list
[0] or self
._extract
_continuation
(video_items_renderer
)
4884 if not video_items_renderer
:
4888 def _extract_selected_tab(tabs
, fatal
=True):
4889 for tab_renderer
in tabs
:
4890 if tab_renderer
.get('selected'):
4893 raise ExtractorError('Unable to find selected tab')
4896 def _extract_tab_renderers(response
):
4897 return traverse_obj(
4898 response
, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type
=dict)
4900 def _extract_from_tabs(self
, item_id
, ytcfg
, data
, tabs
):
4901 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
4903 selected_tab
= self
._extract
_selected
_tab
(tabs
)
4904 metadata
['title'] += format_field(selected_tab
, 'title', ' - %s')
4905 metadata
['title'] += format_field(selected_tab
, 'expandedText', ' - %s')
4907 return self
.playlist_result(
4909 selected_tab
, metadata
['id'], ytcfg
,
4910 self
._extract
_account
_syncid
(ytcfg
, data
),
4911 self
._extract
_visitor
_data
(data
, ytcfg
)),
4914 def _extract_metadata_from_tabs(self
, item_id
, data
):
4915 info
= {'id': item_id}
4917 metadata_renderer
= traverse_obj(data
, ('metadata', 'channelMetadataRenderer'), expected_type
=dict)
4918 if metadata_renderer
:
4919 channel_id
= traverse_obj(metadata_renderer
, ('externalId', {self.ucid_or_none}
),
4920 ('channelUrl', {self.ucid_from_url}
))
4922 'channel': metadata_renderer
.get('title'),
4923 'channel_id': channel_id
,
4925 if info
['channel_id']:
4926 info
['id'] = info
['channel_id']
4928 metadata_renderer
= traverse_obj(data
, ('metadata', 'playlistMetadataRenderer'), expected_type
=dict)
4930 # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
4931 # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
4932 def _get_uncropped(url
):
4933 return url_or_none((url
or '').split('=')[0] + '=s0')
4935 avatar_thumbnails
= self
._extract
_thumbnails
(metadata_renderer
, 'avatar')
4936 if avatar_thumbnails
:
4937 uncropped_avatar
= _get_uncropped(avatar_thumbnails
[0]['url'])
4938 if uncropped_avatar
:
4939 avatar_thumbnails
.append({
4940 'url': uncropped_avatar
,
4941 'id': 'avatar_uncropped',
4945 channel_banners
= self
._extract
_thumbnails
(
4946 data
, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
4947 for banner
in channel_banners
:
4948 banner
['preference'] = -10
4951 uncropped_banner
= _get_uncropped(channel_banners
[0]['url'])
4952 if uncropped_banner
:
4953 channel_banners
.append({
4954 'url': uncropped_banner
,
4955 'id': 'banner_uncropped',
4959 # Deprecated - remove primary_sidebar_renderer when layout discontinued
4960 primary_sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer')
4961 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer'), expected_type
=dict)
4963 primary_thumbnails
= self
._extract
_thumbnails
(
4964 primary_sidebar_renderer
, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
4965 playlist_thumbnails
= self
._extract
_thumbnails
(
4966 playlist_header_renderer
, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
4969 'title': (traverse_obj(metadata_renderer
, 'title')
4970 or self
._get
_text
(data
, ('header', 'hashtagHeaderRenderer', 'hashtag'))
4972 'availability': self
._extract
_availability
(data
),
4973 'channel_follower_count': self
._get
_count
(data
, ('header', ..., 'subscriberCountText')),
4974 'description': try_get(metadata_renderer
, lambda x
: x
.get('description', '')),
4975 'tags': try_get(metadata_renderer
or {}, lambda x
: x
.get('keywords', '').split()),
4976 'thumbnails': (primary_thumbnails
or playlist_thumbnails
) + avatar_thumbnails
+ channel_banners
,
4980 traverse_obj(metadata_renderer
, (('vanityChannelUrl', ('ownerUrls', ...)), {self.handle_from_url}
), get_all
=False)
4981 or traverse_obj(data
, ('header', ..., 'channelHandleText', {self.handle_or_none}
), get_all
=False))
4985 'uploader_id': channel_handle
,
4986 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4988 # Playlist stats is a text runs array containing [video count, view count, last updated].
4989 # last updated or (view count and last updated) may be missing.
4990 playlist_stats
= get_first(
4991 (primary_sidebar_renderer
, playlist_header_renderer
), (('stats', 'briefStats', 'numVideosText'), ))
4993 last_updated_unix
= self
._parse
_time
_text
(
4994 self
._get
_text
(playlist_stats
, 2) # deprecated, remove when old layout discontinued
4995 or self
._get
_text
(playlist_header_renderer
, ('byline', 1, 'playlistBylineRenderer', 'text')))
4996 info
['modified_date'] = strftime_or_none(last_updated_unix
, '%Y%m%d')
4998 info
['view_count'] = self
._get
_count
(playlist_stats
, 1)
4999 if info
['view_count'] is None: # 0 is allowed
5000 info
['view_count'] = self
._get
_count
(playlist_header_renderer
, 'viewCountText')
5001 if info
['view_count'] is None:
5002 info
['view_count'] = self
._get
_count
(data
, (
5003 'contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., 'tabRenderer', 'content', 'sectionListRenderer',
5004 'contents', ..., 'itemSectionRenderer', 'contents', ..., 'channelAboutFullMetadataRenderer', 'viewCountText'))
5006 info
['playlist_count'] = self
._get
_count
(playlist_stats
, 0)
5007 if info
['playlist_count'] is None: # 0 is allowed
5008 info
['playlist_count'] = self
._get
_count
(playlist_header_renderer
, ('byline', 0, 'playlistBylineRenderer', 'text'))
5010 if not info
.get('channel_id'):
5011 owner
= traverse_obj(playlist_header_renderer
, 'ownerText')
5012 if not owner
: # Deprecated
5013 owner
= traverse_obj(
5014 self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarSecondaryInfoRenderer'),
5015 ('videoOwner', 'videoOwnerRenderer', 'title'))
5016 owner_text
= self
._get
_text
(owner
)
5017 browse_ep
= traverse_obj(owner
, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
5019 'channel': self
._search
_regex
(r
'^by (.+) and \d+ others?$', owner_text
, 'uploader', default
=owner_text
),
5020 'channel_id': self
.ucid_or_none(browse_ep
.get('browseId')),
5021 'uploader_id': self
.handle_from_url(urljoin('https://www.youtube.com', browse_ep
.get('canonicalBaseUrl')))
5025 'uploader': info
['channel'],
5026 'channel_url': format_field(info
.get('channel_id'), None, 'https://www.youtube.com/channel/%s', default
=None),
5027 'uploader_url': format_field(info
.get('uploader_id'), None, 'https://www.youtube.com/%s', default
=None),
5032 def _extract_inline_playlist(self
, playlist
, playlist_id
, data
, ytcfg
):
5033 first_id
= last_id
= response
= None
5034 for page_num
in itertools
.count(1):
5035 videos
= list(self
._playlist
_entries
(playlist
))
5038 start
= next((i
for i
, v
in enumerate(videos
) if v
['id'] == last_id
), -1) + 1
5039 if start
>= len(videos
):
5041 yield from videos
[start
:]
5042 first_id
= first_id
or videos
[0]['id']
5043 last_id
= videos
[-1]['id']
5044 watch_endpoint
= try_get(
5045 playlist
, lambda x
: x
['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
5046 headers
= self
.generate_api_headers(
5047 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5048 visitor_data
=self
._extract
_visitor
_data
(response
, data
, ytcfg
))
5050 'playlistId': playlist_id
,
5051 'videoId': watch_endpoint
.get('videoId') or last_id
,
5052 'index': watch_endpoint
.get('index') or len(videos
),
5053 'params': watch_endpoint
.get('params') or 'OAE%3D'
5055 response
= self
._extract
_response
(
5056 item_id
='%s page %d' % (playlist_id
, page_num
),
5057 query
=query
, ep
='next', headers
=headers
, ytcfg
=ytcfg
,
5058 check_get_keys
='contents'
5061 response
, lambda x
: x
['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
5063 def _extract_from_playlist(self
, item_id
, url
, data
, playlist
, ytcfg
):
5064 title
= playlist
.get('title') or try_get(
5065 data
, lambda x
: x
['titleText']['simpleText'], str)
5066 playlist_id
= playlist
.get('playlistId') or item_id
5068 # Delegating everything except mix playlists to regular tab-based playlist URL
5069 playlist_url
= urljoin(url
, try_get(
5070 playlist
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
5073 # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
5074 # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
5075 is_known_unviewable
= re
.fullmatch(r
'MLCT|RLTD[\w-]{22}', playlist_id
)
5077 if playlist_url
and playlist_url
!= url
and not is_known_unviewable
:
5078 return self
.url_result(
5079 playlist_url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
5082 return self
.playlist_result(
5083 self
._extract
_inline
_playlist
(playlist
, playlist_id
, data
, ytcfg
),
5084 playlist_id
=playlist_id
, playlist_title
=title
)
5086 def _extract_availability(self
, data
):
5088 Gets the availability of a given playlist/tab.
5089 Note: Unless YouTube tells us explicitly, we do not assume it is public
5090 @param data: response
5092 sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer') or {}
5093 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer')) or {}
5094 player_header_privacy
= playlist_header_renderer
.get('privacy')
5096 badges
= self
._extract
_badges
(sidebar_renderer
)
5098 # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
5099 privacy_setting_icon
= get_first(
5100 (playlist_header_renderer
, sidebar_renderer
),
5101 ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
5102 lambda _
, v
: v
['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
5105 microformats_is_unlisted
= traverse_obj(
5106 data
, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type
=bool)
5110 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
5111 or player_header_privacy
== 'PUBLIC'
5112 or privacy_setting_icon
== 'PRIVACY_PUBLIC')
5113 else self
._availability
(
5115 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
5116 or player_header_privacy
== 'PRIVATE' if player_header_privacy
is not None
5117 else privacy_setting_icon
== 'PRIVACY_PRIVATE' if privacy_setting_icon
is not None else None),
5119 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
5120 or player_header_privacy
== 'UNLISTED' if player_header_privacy
is not None
5121 else privacy_setting_icon
== 'PRIVACY_UNLISTED' if privacy_setting_icon
is not None
5122 else microformats_is_unlisted
if microformats_is_unlisted
is not None else None),
5123 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
5124 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
5128 def _extract_sidebar_info_renderer(data
, info_renderer
, expected_type
=dict):
5129 sidebar_renderer
= try_get(
5130 data
, lambda x
: x
['sidebar']['playlistSidebarRenderer']['items'], list) or []
5131 for item
in sidebar_renderer
:
5132 renderer
= try_get(item
, lambda x
: x
[info_renderer
], expected_type
)
5136 def _reload_with_unavailable_videos(self
, item_id
, data
, ytcfg
):
5138 Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
5140 is_playlist
= bool(traverse_obj(
5141 data
, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
5144 headers
= self
.generate_api_headers(
5145 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5146 visitor_data
=self
._extract
_visitor
_data
(data
, ytcfg
))
5148 'params': 'wgYCCAA=',
5149 'browseId': f
'VL{item_id}'
5151 return self
._extract
_response
(
5152 item_id
=item_id
, headers
=headers
, query
=query
,
5153 check_get_keys
='contents', fatal
=False, ytcfg
=ytcfg
,
5154 note
='Redownloading playlist API JSON with unavailable videos')
5156 @functools.cached_property
5157 def skip_webpage(self
):
5158 return 'webpage' in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key())
5160 def _extract_webpage(self
, url
, item_id
, fatal
=True):
5161 webpage
, data
= None, None
5162 for retry
in self
.RetryManager(fatal
=fatal
):
5164 webpage
= self
._download
_webpage
(url
, item_id
, note
='Downloading webpage')
5165 data
= self
.extract_yt_initial_data(item_id
, webpage
or '', fatal
=fatal
) or {}
5166 except ExtractorError
as e
:
5167 if isinstance(e
.cause
, network_exceptions
):
5168 if not isinstance(e
.cause
, urllib
.error
.HTTPError
) or e
.cause
.code
not in (403, 429):
5171 self
._error
_or
_warning
(e
, fatal
=fatal
)
5175 self
._extract
_and
_report
_alerts
(data
)
5176 except ExtractorError
as e
:
5177 self
._error
_or
_warning
(e
, fatal
=fatal
)
5180 # Sometimes youtube returns a webpage with incomplete ytInitialData
5181 # See: https://github.com/yt-dlp/yt-dlp/issues/116
5182 if not traverse_obj(data
, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
5183 retry
.error
= ExtractorError('Incomplete yt initial data received')
5186 return webpage
, data
5188 def _report_playlist_authcheck(self
, ytcfg
, fatal
=True):
5189 """Use if failed to extract ytcfg (and data) from initial webpage"""
5190 if not ytcfg
and self
.is_authenticated
:
5191 msg
= 'Playlists that require authentication may not extract correctly without a successful webpage download'
5192 if 'authcheck' not in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key()) and fatal
:
5193 raise ExtractorError(
5194 f
'{msg}. If you are not downloading private content, or '
5195 'your cookies are only for the first account and channel,'
5196 ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
5198 self
.report_warning(msg
, only_once
=True)
5200 def _extract_data(self
, url
, item_id
, ytcfg
=None, fatal
=True, webpage_fatal
=False, default_client
='web'):
5202 if not self
.skip_webpage
:
5203 webpage
, data
= self
._extract
_webpage
(url
, item_id
, fatal
=webpage_fatal
)
5204 ytcfg
= ytcfg
or self
.extract_ytcfg(item_id
, webpage
)
5205 # Reject webpage data if redirected to home page without explicitly requesting
5206 selected_tab
= self
._extract
_selected
_tab
(self
._extract
_tab
_renderers
(data
), fatal
=False) or {}
5207 if (url
!= 'https://www.youtube.com/feed/recommended'
5208 and selected_tab
.get('tabIdentifier') == 'FEwhat_to_watch' # Home page
5209 and 'no-youtube-channel-redirect' not in self
.get_param('compat_opts', [])):
5210 msg
= 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
5212 raise ExtractorError(msg
, expected
=True)
5213 self
.report_warning(msg
, only_once
=True)
5215 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=fatal
)
5216 data
= self
._extract
_tab
_endpoint
(url
, item_id
, ytcfg
, fatal
=fatal
, default_client
=default_client
)
5219 def _extract_tab_endpoint(self
, url
, item_id
, ytcfg
=None, fatal
=True, default_client
='web'):
5220 headers
= self
.generate_api_headers(ytcfg
=ytcfg
, default_client
=default_client
)
5221 resolve_response
= self
._extract
_response
(
5222 item_id
=item_id
, query
={'url': url}
, check_get_keys
='endpoint', headers
=headers
, ytcfg
=ytcfg
, fatal
=fatal
,
5223 ep
='navigation/resolve_url', note
='Downloading API parameters API JSON', default_client
=default_client
)
5224 endpoints
= {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5225 for ep_key
, ep
in endpoints
.items():
5226 params
= try_get(resolve_response
, lambda x
: x
['endpoint'][ep_key
], dict)
5228 return self
._extract
_response
(
5229 item_id
=item_id
, query
=params
, ep
=ep
, headers
=headers
,
5230 ytcfg
=ytcfg
, fatal
=fatal
, default_client
=default_client
,
5231 check_get_keys
=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5232 err_note
= 'Failed to resolve url (does the playlist exist?)'
5234 raise ExtractorError(err_note
, expected
=True)
5235 self
.report_warning(err_note
, item_id
)
5237 _SEARCH_PARAMS
= None
5239 def _search_results(self
, query
, params
=NO_DEFAULT
, default_client
='web'):
5240 data
= {'query': query}
5241 if params
is NO_DEFAULT
:
5242 params
= self
._SEARCH
_PARAMS
5244 data
['params'] = params
5247 ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5248 ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5250 ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5251 ('continuationContents', ),
5253 display_id
= f
'query "{query}"'
5254 check_get_keys
= tuple({keys[0] for keys in content_keys}
)
5255 ytcfg
= self
._download
_ytcfg
(default_client
, display_id
) if not self
.skip_webpage
else {}
5256 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=False)
5258 continuation_list
= [None]
5260 for page_num
in itertools
.count(1):
5261 data
.update(continuation_list
[0] or {})
5262 headers
= self
.generate_api_headers(
5263 ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(search
), default_client
=default_client
)
5264 search
= self
._extract
_response
(
5265 item_id
=f
'{display_id} page {page_num}', ep
='search', query
=data
,
5266 default_client
=default_client
, check_get_keys
=check_get_keys
, ytcfg
=ytcfg
, headers
=headers
)
5267 slr_contents
= traverse_obj(search
, *content_keys
)
5268 yield from self
._extract
_entries
({'contents': list(variadic(slr_contents))}
, continuation_list
)
5269 if not continuation_list
[0]:
5273 class YoutubeTabIE(YoutubeTabBaseInfoExtractor
):
5274 IE_DESC
= 'YouTube Tabs'
5275 _VALID_URL
= r
'''(?x:
5277 (?!consent\.)(?:\w+\.)?
5279 youtube(?:kids)?\.com|
5283 (?P<channel_type>channel|c|user|browse)/|
5286 (?:playlist|watch)\?.*?\blist=
5288 (?!(?:%(reserved_names)s)\b) # Direct URLs
5292 'reserved_names': YoutubeBaseInfoExtractor
._RESERVED
_NAMES
,
5293 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
5295 IE_NAME
= 'youtube:tab'
5298 'note': 'playlists, multipage',
5299 'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5300 'playlist_mincount': 94,
5302 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5303 'title': 'Igor Kleiner - Playlists',
5304 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5305 'uploader': 'Igor Kleiner',
5306 'uploader_id': '@IgorDataScience',
5307 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5308 'channel': 'Igor Kleiner',
5309 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5310 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5311 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5312 'channel_follower_count': int
5315 'note': 'playlists, multipage, different order',
5316 'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5317 'playlist_mincount': 94,
5319 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5320 'title': 'Igor Kleiner - Playlists',
5321 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5322 'uploader': 'Igor Kleiner',
5323 'uploader_id': '@IgorDataScience',
5324 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5325 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5326 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5327 'channel': 'Igor Kleiner',
5328 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5329 'channel_follower_count': int
5332 'note': 'playlists, series',
5333 'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5334 'playlist_mincount': 5,
5336 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5337 'title': '3Blue1Brown - Playlists',
5338 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5339 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5340 'channel': '3Blue1Brown',
5341 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5342 'uploader_id': '@3blue1brown',
5343 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5344 'uploader': '3Blue1Brown',
5345 'tags': ['Mathematics'],
5346 'channel_follower_count': int
5349 'note': 'playlists, singlepage',
5350 'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5351 'playlist_mincount': 4,
5353 'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5354 'title': 'ThirstForScience - Playlists',
5355 'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5356 'uploader': 'ThirstForScience',
5357 'uploader_url': 'https://www.youtube.com/@ThirstForScience',
5358 'uploader_id': '@ThirstForScience',
5359 'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5360 'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5362 'channel': 'ThirstForScience',
5363 'channel_follower_count': int
5366 'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5367 'only_matching': True,
5369 'note': 'basic, single video playlist',
5370 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5372 'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5373 'title': 'youtube-dl public playlist',
5377 'modified_date': '20201130',
5378 'channel': 'Sergey M.',
5379 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5380 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5381 'availability': 'public',
5382 'uploader': 'Sergey M.',
5383 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5384 'uploader_id': '@sergeym.6173',
5386 'playlist_count': 1,
5388 'note': 'empty playlist',
5389 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5391 'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5392 'title': 'youtube-dl empty playlist',
5394 'channel': 'Sergey M.',
5396 'modified_date': '20160902',
5397 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5398 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5399 'availability': 'public',
5400 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5401 'uploader_id': '@sergeym.6173',
5402 'uploader': 'Sergey M.',
5404 'playlist_count': 0,
5407 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5409 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5410 'title': 'lex will - Home',
5411 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5412 'uploader': 'lex will',
5413 'uploader_id': '@lexwill718',
5414 'channel': 'lex will',
5415 'tags': ['bible', 'history', 'prophesy'],
5416 'uploader_url': 'https://www.youtube.com/@lexwill718',
5417 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5418 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5419 'channel_follower_count': int
5421 'playlist_mincount': 2,
5423 'note': 'Videos tab',
5424 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5426 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5427 'title': 'lex will - Videos',
5428 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5429 'uploader': 'lex will',
5430 'uploader_id': '@lexwill718',
5431 'tags': ['bible', 'history', 'prophesy'],
5432 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5433 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5434 'uploader_url': 'https://www.youtube.com/@lexwill718',
5435 'channel': 'lex will',
5436 'channel_follower_count': int
5438 'playlist_mincount': 975,
5440 'note': 'Videos tab, sorted by popular',
5441 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5443 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5444 'title': 'lex will - Videos',
5445 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5446 'uploader': 'lex will',
5447 'uploader_id': '@lexwill718',
5448 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5449 'uploader_url': 'https://www.youtube.com/@lexwill718',
5450 'channel': 'lex will',
5451 'tags': ['bible', 'history', 'prophesy'],
5452 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5453 'channel_follower_count': int
5455 'playlist_mincount': 199,
5457 'note': 'Playlists tab',
5458 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5460 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5461 'title': 'lex will - Playlists',
5462 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5463 'uploader': 'lex will',
5464 'uploader_id': '@lexwill718',
5465 'uploader_url': 'https://www.youtube.com/@lexwill718',
5466 'channel': 'lex will',
5467 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5468 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5469 'tags': ['bible', 'history', 'prophesy'],
5470 'channel_follower_count': int
5472 'playlist_mincount': 17,
5474 'note': 'Community tab',
5475 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5477 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5478 'title': 'lex will - Community',
5479 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5480 'channel': 'lex will',
5481 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5482 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5483 'tags': ['bible', 'history', 'prophesy'],
5484 'channel_follower_count': int,
5485 'uploader_url': 'https://www.youtube.com/@lexwill718',
5486 'uploader_id': '@lexwill718',
5487 'uploader': 'lex will',
5489 'playlist_mincount': 18,
5491 'note': 'Channels tab',
5492 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5494 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5495 'title': 'lex will - Channels',
5496 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5497 'channel': 'lex will',
5498 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5499 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5500 'tags': ['bible', 'history', 'prophesy'],
5501 'channel_follower_count': int,
5502 'uploader_url': 'https://www.youtube.com/@lexwill718',
5503 'uploader_id': '@lexwill718',
5504 'uploader': 'lex will',
5506 'playlist_mincount': 12,
5508 'note': 'Search tab',
5509 'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5510 'playlist_mincount': 40,
5512 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5513 'title': '3Blue1Brown - Search - linear algebra',
5514 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5515 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5516 'tags': ['Mathematics'],
5517 'channel': '3Blue1Brown',
5518 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5519 'channel_follower_count': int,
5520 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5521 'uploader_id': '@3blue1brown',
5522 'uploader': '3Blue1Brown',
5525 'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5526 'only_matching': True,
5528 'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5529 'only_matching': True,
5531 'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5532 'only_matching': True,
5534 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5535 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5537 'title': '29C3: Not my department',
5538 'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5539 'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5542 'modified_date': '20150605',
5543 'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5544 'channel_url': 'https://www.youtube.com/channel/UCEPzS1rYsrkqzSLNp76nrcg',
5545 'channel': 'Christiaan008',
5546 'availability': 'public',
5547 'uploader_id': '@ChRiStIaAn008',
5548 'uploader': 'Christiaan008',
5549 'uploader_url': 'https://www.youtube.com/@ChRiStIaAn008',
5551 'playlist_count': 96,
5553 'note': 'Large playlist',
5554 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5556 'title': 'Uploads from Cauchemar',
5557 'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5558 'channel_url': 'https://www.youtube.com/channel/UCBABnxM4Ar9ten8Mdjj1j0Q',
5560 'modified_date': r
're:\d{8}',
5561 'channel': 'Cauchemar',
5564 'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5565 'availability': 'public',
5566 'uploader_id': '@Cauchemar89',
5567 'uploader': 'Cauchemar',
5568 'uploader_url': 'https://www.youtube.com/@Cauchemar89',
5570 'playlist_mincount': 1123,
5571 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5573 'note': 'even larger playlist, 8832 videos',
5574 'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5575 'only_matching': True,
5577 'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5578 'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5580 'title': 'Uploads from Interstellar Movie',
5581 'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5584 'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5585 'channel_url': 'https://www.youtube.com/channel/UCXw-G3eDE9trcvY2sBMM_aA',
5586 'channel': 'Interstellar Movie',
5588 'modified_date': r
're:\d{8}',
5589 'availability': 'public',
5590 'uploader_id': '@InterstellarMovie',
5591 'uploader': 'Interstellar Movie',
5592 'uploader_url': 'https://www.youtube.com/@InterstellarMovie',
5594 'playlist_mincount': 21,
5596 'note': 'Playlist with "show unavailable videos" button',
5597 'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5599 'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5600 'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5602 'channel': 'Phim Siêu Nhân Nhật Bản',
5605 'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5606 'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5607 'modified_date': r
're:\d{8}',
5608 'availability': 'public',
5609 'uploader_url': 'https://www.youtube.com/@phimsieunhannhatban',
5610 'uploader_id': '@phimsieunhannhatban',
5611 'uploader': 'Phim Siêu Nhân Nhật Bản',
5613 'playlist_mincount': 200,
5614 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5616 'note': 'Playlist with unavailable videos in page 7',
5617 'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5619 'title': 'Uploads from BlankTV',
5620 'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5621 'channel': 'BlankTV',
5622 'channel_url': 'https://www.youtube.com/channel/UC8l9frL61Yl5KFOl87nIm2w',
5623 'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5626 'modified_date': r
're:\d{8}',
5628 'availability': 'public',
5629 'uploader_id': '@blanktv',
5630 'uploader': 'BlankTV',
5631 'uploader_url': 'https://www.youtube.com/@blanktv',
5633 'playlist_mincount': 1000,
5634 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5636 'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5637 'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5639 'title': 'Data Analysis with Dr Mike Pound',
5640 'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5641 'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5644 'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5645 'channel_url': 'https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA',
5646 'channel': 'Computerphile',
5647 'availability': 'public',
5648 'modified_date': '20190712',
5649 'uploader_id': '@Computerphile',
5650 'uploader': 'Computerphile',
5651 'uploader_url': 'https://www.youtube.com/@Computerphile',
5653 'playlist_mincount': 11,
5655 'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5656 'only_matching': True,
5658 'note': 'Playlist URL that does not actually serve a playlist',
5659 'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5661 'id': 'FqZTN594JQw',
5663 'title': "Smiley's People 01 detective, Adventure Series, Action",
5664 'upload_date': '20150526',
5665 'license': 'Standard YouTube License',
5666 'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5667 'categories': ['People & Blogs'],
5673 'skip_download': True,
5675 'skip': 'This video is not available.',
5676 'add_ie': [YoutubeIE
.ie_key()],
5678 'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5679 'only_matching': True,
5681 'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5682 'only_matching': True,
5684 'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5686 'id': 'AlTsmyW4auo', # This will keep changing
5689 'upload_date': r
're:\d{8}',
5691 'categories': ['News & Politics'],
5694 'release_timestamp': int,
5695 'channel': 'Sky News',
5696 'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5699 'thumbnail': r
're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5700 'playable_in_embed': True,
5701 'release_date': r
're:\d+',
5702 'availability': 'public',
5703 'live_status': 'is_live',
5704 'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5705 'channel_follower_count': int,
5706 'concurrent_view_count': int,
5707 'uploader_url': 'https://www.youtube.com/@SkyNews',
5708 'uploader_id': '@SkyNews',
5709 'uploader': 'Sky News',
5712 'skip_download': True,
5714 'expected_warnings': ['Ignoring subtitle tracks found in '],
5716 'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5718 'id': 'a48o2S1cPoo',
5720 'title': 'The Young Turks - Live Main Show',
5721 'upload_date': '20150715',
5722 'license': 'Standard YouTube License',
5723 'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5724 'categories': ['News & Politics'],
5725 'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5729 'skip_download': True,
5731 'only_matching': True,
5733 'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5734 'only_matching': True,
5736 'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5737 'only_matching': True,
5739 'note': 'A channel that is not live. Should raise error',
5740 'url': 'https://www.youtube.com/user/numberphile/live',
5741 'only_matching': True,
5743 'url': 'https://www.youtube.com/feed/trending',
5744 'only_matching': True,
5746 'url': 'https://www.youtube.com/feed/library',
5747 'only_matching': True,
5749 'url': 'https://www.youtube.com/feed/history',
5750 'only_matching': True,
5752 'url': 'https://www.youtube.com/feed/subscriptions',
5753 'only_matching': True,
5755 'url': 'https://www.youtube.com/feed/watch_later',
5756 'only_matching': True,
5758 'note': 'Recommended - redirects to home page.',
5759 'url': 'https://www.youtube.com/feed/recommended',
5760 'only_matching': True,
5762 'note': 'inline playlist with not always working continuations',
5763 'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5764 'only_matching': True,
5766 'url': 'https://www.youtube.com/course',
5767 'only_matching': True,
5769 'url': 'https://www.youtube.com/zsecurity',
5770 'only_matching': True,
5772 'url': 'http://www.youtube.com/NASAgovVideo/videos',
5773 'only_matching': True,
5775 'url': 'https://www.youtube.com/TheYoungTurks/live',
5776 'only_matching': True,
5778 'url': 'https://www.youtube.com/hashtag/cctv9',
5784 'playlist_mincount': 300, # not consistent but should be over 300
5786 'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
5787 'only_matching': True,
5789 'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
5790 'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5791 'only_matching': True
5793 'note': '/browse/ should redirect to /channel/',
5794 'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
5795 'only_matching': True
5797 'note': 'VLPL, should redirect to playlist?list=PL...',
5798 'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5800 'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5801 'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
5802 'title': 'NCS : All Releases 💿',
5803 'channel_url': 'https://www.youtube.com/channel/UC_aEa8K-EOJ3D6gOs7HcyNg',
5804 'modified_date': r
're:\d{8}',
5806 'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
5808 'channel': 'NoCopyrightSounds',
5809 'availability': 'public',
5810 'uploader_url': 'https://www.youtube.com/@NoCopyrightSounds',
5811 'uploader': 'NoCopyrightSounds',
5812 'uploader_id': '@NoCopyrightSounds',
5814 'playlist_mincount': 166,
5815 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden', 'YouTube Music is not directly supported'],
5817 # TODO: fix 'unviewable' issue with this playlist when reloading with unavailable videos
5818 'note': 'Topic, should redirect to playlist?list=UU...',
5819 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5821 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5822 'title': 'Uploads from Royalty Free Music - Topic',
5824 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5825 'channel': 'Royalty Free Music - Topic',
5827 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5828 'modified_date': r
're:\d{8}',
5830 'availability': 'public',
5831 'uploader': 'Royalty Free Music - Topic',
5833 'playlist_mincount': 101,
5834 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5836 # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
5837 # Treat as a general feed
5838 'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
5840 'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
5841 'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
5844 'playlist_mincount': 9,
5846 'note': 'Youtube music Album',
5847 'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
5849 'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
5850 'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
5854 'availability': 'unlisted',
5855 'modified_date': r
're:\d{8}',
5857 'playlist_count': 50,
5858 'expected_warnings': ['YouTube Music is not directly supported'],
5860 'note': 'unlisted single video playlist',
5861 'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5863 'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5864 'title': 'yt-dlp unlisted playlist test',
5865 'availability': 'unlisted',
5867 'modified_date': '20220418',
5868 'channel': 'colethedj',
5871 'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5872 'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5873 'uploader_url': 'https://www.youtube.com/@colethedj1894',
5874 'uploader_id': '@colethedj1894',
5875 'uploader': 'colethedj',
5879 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
5880 'id': 'BaW_jenozKc',
5882 'ie_key': 'Youtube',
5884 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
5885 'channel_url': 'https://www.youtube.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
5887 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc',
5888 'channel': 'Philipp Hagemeister',
5889 'uploader_id': '@PhilippHagemeister',
5890 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
5891 'uploader': 'Philipp Hagemeister',
5894 'playlist_count': 1,
5895 'params': {'extract_flat': True}
,
5897 'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
5898 'url': 'https://www.youtube.com/feed/recommended',
5900 'id': 'recommended',
5901 'title': 'recommended',
5904 'playlist_mincount': 50,
5906 'skip_download': True,
5907 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5910 'note': 'API Fallback: /videos tab, sorted by oldest first',
5911 'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
5913 'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5914 'title': 'Cody\'sLab - Videos',
5915 'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
5916 'channel': 'Cody\'sLab',
5917 'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5919 'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
5920 'channel_follower_count': int
5922 'playlist_mincount': 650,
5924 'skip_download': True,
5925 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5927 'skip': 'Query for sorting no longer works',
5929 'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
5930 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5932 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5933 'title': 'Uploads from Royalty Free Music - Topic',
5934 'modified_date': r
're:\d{8}',
5935 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5937 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5939 'channel': 'Royalty Free Music - Topic',
5941 'availability': 'public',
5942 'uploader': 'Royalty Free Music - Topic',
5944 'playlist_mincount': 101,
5946 'skip_download': True,
5947 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5949 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5951 'note': 'non-standard redirect to regional channel',
5952 'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
5953 'only_matching': True
5955 'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
5956 'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
5958 'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
5959 'modified_date': '20220407',
5960 'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
5962 'availability': 'unlisted',
5963 'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
5964 'channel': 'pukkandan',
5965 'description': 'Test for collaborative playlist',
5966 'title': 'yt-dlp test - collaborative playlist',
5968 'uploader_url': 'https://www.youtube.com/@pukkandan',
5969 'uploader_id': '@pukkandan',
5970 'uploader': 'pukkandan',
5972 'playlist_mincount': 2
5974 'note': 'translated tab name',
5975 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
5977 'id': 'UCiu-3thuViMebBjw_5nWYrA',
5979 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
5980 'description': 'test description',
5981 'title': 'cole-dlp-test-acc - 再生リスト',
5982 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
5983 'channel': 'cole-dlp-test-acc',
5984 'uploader_url': 'https://www.youtube.com/@coletdjnz',
5985 'uploader_id': '@coletdjnz',
5986 'uploader': 'cole-dlp-test-acc',
5988 'playlist_mincount': 1,
5989 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
5990 'expected_warnings': ['Preferring "ja"'],
5992 # XXX: this should really check flat playlist entries, but the test suite doesn't support that
5993 'note': 'preferred lang set with playlist with translated video titles',
5994 'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
5996 'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
5999 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6000 'channel': 'cole-dlp-test-acc',
6001 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6002 'description': 'test',
6003 'title': 'dlp test playlist',
6004 'availability': 'public',
6005 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6006 'uploader_id': '@coletdjnz',
6007 'uploader': 'cole-dlp-test-acc',
6009 'playlist_mincount': 1,
6010 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6011 'expected_warnings': ['Preferring "ja"'],
6013 # shorts audio pivot for 2GtVksBMYFM.
6014 'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
6016 'id': 'sfv_audio_pivot',
6017 'title': 'sfv_audio_pivot',
6020 'playlist_mincount': 50,
6023 # Channel with a real live tab (not to be mistaken with streams tab)
6024 # Do not treat like it should redirect to live stream
6025 'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
6027 'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
6028 'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
6031 'playlist_mincount': 20,
6033 # Tab name is not the same as tab id
6034 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
6036 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6037 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
6040 'playlist_mincount': 8,
6042 # Home tab id is literally home. Not to get mistaken with featured
6043 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
6045 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6046 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
6049 'playlist_mincount': 8,
6051 # Should get three playlists for videos, shorts and streams tabs
6052 'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6054 'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6055 'title': 'Polka Ch. 尾丸ポルカ',
6056 'channel_follower_count': int,
6057 'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6058 'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6059 'description': 'md5:e56b74b5bb7e9c701522162e9abfb822',
6060 'channel': 'Polka Ch. 尾丸ポルカ',
6062 'uploader_url': 'https://www.youtube.com/@OmaruPolka',
6063 'uploader': 'Polka Ch. 尾丸ポルカ',
6064 'uploader_id': '@OmaruPolka',
6066 'playlist_count': 3,
6068 # Shorts tab with channel with handle
6069 # TODO: fix channel description
6070 'url': 'https://www.youtube.com/@NotJustBikes/shorts',
6072 'id': 'UC0intLFzLaudFG-xAvUEO-A',
6073 'title': 'Not Just Bikes - Shorts',
6075 'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
6076 'description': 'md5:26bc55af26855a608a5cf89dfa595c8d',
6077 'channel_follower_count': int,
6078 'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
6079 'channel': 'Not Just Bikes',
6080 'uploader_url': 'https://www.youtube.com/@NotJustBikes',
6081 'uploader': 'Not Just Bikes',
6082 'uploader_id': '@NotJustBikes',
6084 'playlist_mincount': 10,
6087 'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
6089 'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6090 'title': '中村悠一 - Live',
6092 'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6093 'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
6095 'channel_follower_count': int,
6096 'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
6097 'uploader_url': 'https://www.youtube.com/@Yuichi-Nakamura',
6098 'uploader_id': '@Yuichi-Nakamura',
6101 'playlist_mincount': 60,
6103 # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
6104 # See test_youtube_lists
6105 'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
6106 'only_matching': True,
6108 # No uploads and no UCID given. Should fail with no uploads error
6109 # See test_youtube_lists
6110 'url': 'https://www.youtube.com/news',
6111 'only_matching': True
6113 # No videos tab but has a shorts tab
6114 'url': 'https://www.youtube.com/c/TKFShorts',
6116 'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6117 'title': 'Shorts Break - Shorts',
6119 'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6120 'channel': 'Shorts Break',
6121 'description': 'md5:6de33c5e7ba686e5f3efd4e19c7ef499',
6122 'channel_follower_count': int,
6123 'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
6124 'uploader_url': 'https://www.youtube.com/@ShortsBreak_Official',
6125 'uploader': 'Shorts Break',
6126 'uploader_id': '@ShortsBreak_Official',
6128 'playlist_mincount': 30,
6130 # Trending Now Tab. tab id is empty
6131 'url': 'https://www.youtube.com/feed/trending',
6134 'title': 'trending - Now',
6137 'playlist_mincount': 30,
6139 # Trending Gaming Tab. tab id is empty
6140 'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
6143 'title': 'trending - Gaming',
6146 'playlist_mincount': 30,
6148 # Shorts url result in shorts tab
6149 # TODO: Fix channel id extraction
6150 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
6152 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6153 'title': 'cole-dlp-test-acc - Shorts',
6154 'channel': 'cole-dlp-test-acc',
6155 'description': 'test description',
6156 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6157 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6159 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6160 'uploader_id': '@coletdjnz',
6161 'uploader': 'cole-dlp-test-acc',
6165 # Channel data is not currently available for short renderers (as of 2023-03-01)
6167 'ie_key': 'Youtube',
6168 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
6169 'id': 'sSM9J5YH_60',
6170 'title': 'SHORT short',
6175 'params': {'extract_flat': True}
,
6177 # Live video status should be extracted
6178 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
6180 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6181 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live', # TODO, should be Minecraft - Live or Minecraft - Topic - Live
6187 'ie_key': 'Youtube',
6188 'url': 'startswith:https://www.youtube.com/watch?v=',
6191 'live_status': 'is_live',
6194 'concurrent_view_count': int,
6197 'uploader_url': str,
6201 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6202 'playlist_mincount': 1
6204 # Channel renderer metadata. Contains number of videos on the channel
6205 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/channels',
6207 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6208 'title': 'cole-dlp-test-acc - Channels',
6209 'channel': 'cole-dlp-test-acc',
6210 'description': 'test description',
6211 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6212 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6214 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6215 'uploader_id': '@coletdjnz',
6216 'uploader': 'cole-dlp-test-acc',
6221 'ie_key': 'YoutubeTab',
6222 'url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6223 'id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6224 'channel_id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6225 'title': 'PewDiePie',
6226 'channel': 'PewDiePie',
6227 'channel_url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6229 'channel_follower_count': int,
6230 'playlist_count': int,
6231 'uploader': 'PewDiePie',
6232 'uploader_url': 'https://www.youtube.com/@PewDiePie',
6233 'uploader_id': '@PewDiePie',
6236 'params': {'extract_flat': True}
,
6238 'url': 'https://www.youtube.com/@3blue1brown/about',
6240 'id': 'UCYO_jab_esuFRV4b17AJtAw',
6241 'tags': ['Mathematics'],
6242 'title': '3Blue1Brown - About',
6243 'channel_follower_count': int,
6244 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
6245 'channel': '3Blue1Brown',
6247 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
6248 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
6249 'uploader_url': 'https://www.youtube.com/@3blue1brown',
6250 'uploader_id': '@3blue1brown',
6251 'uploader': '3Blue1Brown',
6253 'playlist_count': 0,
6255 # Podcasts tab, with rich entry playlistRenderers
6256 'url': 'https://www.youtube.com/@99percentinvisiblepodcast/podcasts',
6258 'id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6259 'channel_id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6260 'uploader_url': 'https://www.youtube.com/@99percentinvisiblepodcast',
6261 'description': 'md5:3a0ed38f1ad42a68ef0428c04a15695c',
6262 'title': '99 Percent Invisible - Podcasts',
6263 'uploader': '99 Percent Invisible',
6264 'channel_follower_count': int,
6265 'channel_url': 'https://www.youtube.com/channel/UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6267 'channel': '99 Percent Invisible',
6268 'uploader_id': '@99percentinvisiblepodcast',
6270 'playlist_count': 1,
6272 # Releases tab, with rich entry playlistRenderers (same as Podcasts tab)
6273 'url': 'https://www.youtube.com/@AHimitsu/releases',
6275 'id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6276 'channel': 'A Himitsu',
6277 'uploader_url': 'https://www.youtube.com/@AHimitsu',
6278 'title': 'A Himitsu - Releases',
6279 'uploader_id': '@AHimitsu',
6280 'uploader': 'A Himitsu',
6281 'channel_id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6283 'description': 'I make music',
6284 'channel_url': 'https://www.youtube.com/channel/UCgFwu-j5-xNJml2FtTrrB3A',
6285 'channel_follower_count': int,
6287 'playlist_mincount': 10,
6291 def suitable(cls
, url
):
6292 return False if YoutubeIE
.suitable(url
) else super().suitable(url
)
6294 _URL_RE
= re
.compile(rf
'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
6296 def _get_url_mobj(self
, url
):
6297 mobj
= self
._URL
_RE
.match(url
).groupdict()
6298 mobj
.update((k
, '') for k
, v
in mobj
.items() if v
is None)
6301 def _extract_tab_id_and_name(self
, tab
, base_url
='https://www.youtube.com'):
6302 tab_name
= (tab
.get('title') or '').lower()
6303 tab_url
= urljoin(base_url
, traverse_obj(
6304 tab
, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
6306 tab_id
= (tab_url
and self
._get
_url
_mobj
(tab_url
)['tab'][1:]
6307 or traverse_obj(tab
, 'tabIdentifier', expected_type
=str))
6310 'TAB_ID_SPONSORSHIPS': 'membership',
6311 }.get(tab_id
, tab_id
), tab_name
6313 # Fallback to tab name if we cannot get the tab id.
6314 # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6315 # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6317 self
.write_debug(f
'Falling back to selected tab name: {tab_name}')
6321 }.get(tab_name
, tab_name
), tab_name
6323 def _has_tab(self
, tabs
, tab_id
):
6324 return any(self
._extract
_tab
_id
_and
_name
(tab
)[0] == tab_id
for tab
in tabs
)
6326 @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6327 def _real_extract(self
, url
, smuggled_data
):
6328 item_id
= self
._match
_id
(url
)
6329 url
= urllib
.parse
.urlunparse(
6330 urllib
.parse
.urlparse(url
)._replace
(netloc
='www.youtube.com'))
6331 compat_opts
= self
.get_param('compat_opts', [])
6333 mobj
= self
._get
_url
_mobj
(url
)
6334 pre
, tab
, post
, is_channel
= mobj
['pre'], mobj
['tab'], mobj
['post'], not mobj
['not_channel']
6335 if is_channel
and smuggled_data
.get('is_music_url'):
6336 if item_id
[:2] == 'VL': # Youtube music VL channels have an equivalent playlist
6337 return self
.url_result(
6338 f
'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE
, item_id
[2:])
6339 elif item_id
[:2] == 'MP': # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6340 mdata
= self
._extract
_tab
_endpoint
(
6341 f
'https://music.youtube.com/channel/{item_id}', item_id
, default_client
='web_music')
6342 murl
= traverse_obj(mdata
, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6343 get_all
=False, expected_type
=str)
6345 raise ExtractorError('Failed to resolve album to playlist')
6346 return self
.url_result(murl
, YoutubeTabIE
)
6347 elif mobj
['channel_type'] == 'browse': # Youtube music /browse/ should be changed to /channel/
6348 return self
.url_result(
6349 f
'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE
, item_id
)
6351 original_tab_id
, display_id
= tab
[1:], f
'{item_id}{tab}'
6352 if is_channel
and not tab
and 'no-youtube-channel-redirect' not in compat_opts
:
6353 url
= f
'{pre}/videos{post}'
6354 if smuggled_data
.get('is_music_url'):
6355 self
.report_warning(f
'YouTube Music is not directly supported. Redirecting to {url}')
6357 # Handle both video/playlist URLs
6359 video_id
, playlist_id
= [traverse_obj(qs
, (key
, 0)) for key
in ('v', 'list')]
6360 if not video_id
and mobj
['not_channel'].startswith('watch'):
6362 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6363 raise ExtractorError('A video URL was given without video ID', expected
=True)
6364 # Common mistake: https://www.youtube.com/watch?list=playlist_id
6365 self
.report_warning(f
'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6366 return self
.url_result(
6367 f
'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE
, playlist_id
)
6369 if not self
._yes
_playlist
(playlist_id
, video_id
):
6370 return self
.url_result(
6371 f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6373 data
, ytcfg
= self
._extract
_data
(url
, display_id
)
6375 # YouTube may provide a non-standard redirect to the regional channel
6376 # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6377 # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6378 redirect_url
= traverse_obj(
6379 data
, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all
=False)
6380 if redirect_url
and 'no-youtube-channel-redirect' not in compat_opts
:
6381 redirect_url
= ''.join((urljoin('https://www.youtube.com', redirect_url
), tab
, post
))
6382 self
.to_screen(f
'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6383 return self
.url_result(redirect_url
, YoutubeTabIE
)
6385 tabs
, extra_tabs
= self
._extract
_tab
_renderers
(data
), []
6386 if is_channel
and tabs
and 'no-youtube-channel-redirect' not in compat_opts
:
6387 selected_tab
= self
._extract
_selected
_tab
(tabs
)
6388 selected_tab_id
, selected_tab_name
= self
._extract
_tab
_id
_and
_name
(selected_tab
, url
) # NB: Name may be translated
6389 self
.write_debug(f
'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6391 if not original_tab_id
and selected_tab_name
:
6392 self
.to_screen('Downloading all uploads of the channel. '
6393 'To download only the videos in a specific tab, pass the tab\'s URL')
6394 if self
._has
_tab
(tabs
, 'streams'):
6395 extra_tabs
.append(''.join((pre
, '/streams', post
)))
6396 if self
._has
_tab
(tabs
, 'shorts'):
6397 extra_tabs
.append(''.join((pre
, '/shorts', post
)))
6398 # XXX: Members-only tab should also be extracted
6400 if not extra_tabs
and selected_tab_id
!= 'videos':
6401 # Channel does not have streams, shorts or videos tabs
6402 if item_id
[:2] != 'UC':
6403 raise ExtractorError('This channel has no uploads', expected
=True)
6405 # Topic channels don't have /videos. Use the equivalent playlist instead
6406 pl_id
= f
'UU{item_id[2:]}'
6407 pl_url
= f
'https://www.youtube.com/playlist?list={pl_id}'
6409 data
, ytcfg
= self
._extract
_data
(pl_url
, pl_id
, ytcfg
=ytcfg
, fatal
=True, webpage_fatal
=True)
6410 except ExtractorError
:
6411 raise ExtractorError('This channel has no uploads', expected
=True)
6413 item_id
, url
= pl_id
, pl_url
6415 f
'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6417 elif extra_tabs
and selected_tab_id
!= 'videos':
6418 # When there are shorts/live tabs but not videos tab
6419 url
, data
= f
'{pre}{post}', None
6421 elif (original_tab_id
or 'videos') != selected_tab_id
:
6422 if original_tab_id
== 'live':
6423 # Live tab should have redirected to the video
6424 # Except in the case the channel has an actual live tab
6425 # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6426 raise UserNotLive(video_id
=item_id
)
6427 elif selected_tab_name
:
6428 raise ExtractorError(f
'This channel does not have a {original_tab_id} tab', expected
=True)
6430 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6431 url
= f
'{pre}{post}'
6433 # YouTube sometimes provides a button to reload playlist with unavailable videos.
6434 if 'no-youtube-unavailable-videos' not in compat_opts
:
6435 data
= self
._reload
_with
_unavailable
_videos
(display_id
, data
, ytcfg
) or data
6436 self
._extract
_and
_report
_alerts
(data
, only_once
=True)
6438 tabs
, entries
= self
._extract
_tab
_renderers
(data
), []
6440 entries
= [self
._extract
_from
_tabs
(item_id
, ytcfg
, data
, tabs
)]
6442 'extractor_key': YoutubeTabIE
.ie_key(),
6443 'extractor': YoutubeTabIE
.IE_NAME
,
6446 if self
.get_param('playlist_items') == '0':
6447 entries
.extend(self
.url_result(u
, YoutubeTabIE
) for u
in extra_tabs
)
6448 else: # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6449 entries
.extend(map(self
._real
_extract
, extra_tabs
))
6451 if len(entries
) == 1:
6454 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
6455 uploads_url
= 'the Uploads (UU) playlist URL'
6456 if try_get(metadata
, lambda x
: x
['channel_id'].startswith('UC')):
6457 uploads_url
= f
'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6459 'Downloading as multiple playlists, separated by tabs. '
6460 f
'To download as a single playlist instead, pass {uploads_url}')
6461 return self
.playlist_result(entries
, item_id
, **metadata
)
6464 playlist
= traverse_obj(
6465 data
, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type
=dict)
6467 return self
._extract
_from
_playlist
(item_id
, url
, data
, playlist
, ytcfg
)
6469 video_id
= traverse_obj(
6470 data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str) or video_id
6472 if tab
!= '/live': # live tab is expected to redirect to video
6473 self
.report_warning(f
'Unable to recognize playlist. Downloading just video {video_id}')
6474 return self
.url_result(f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6476 raise ExtractorError('Unable to recognize tab page')
6479 class YoutubePlaylistIE(InfoExtractor
):
6480 IE_DESC
= 'YouTube playlists'
6481 _VALID_URL
= r
'''(?x)(?:
6486 youtube(?:kids)?\.com|
6491 (?P<id>%(playlist_id)s)
6493 'playlist_id': YoutubeBaseInfoExtractor
._PLAYLIST
_ID
_RE
,
6494 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
6496 IE_NAME
= 'youtube:playlist'
6498 'note': 'issue #673',
6499 'url': 'PLBB231211A4F62143',
6501 'title': '[OLD]Team Fortress 2 (Class-based LP)',
6502 'id': 'PLBB231211A4F62143',
6503 'uploader': 'Wickman',
6504 'uploader_id': '@WickmanVT',
6505 'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6507 'uploader_url': 'https://www.youtube.com/@WickmanVT',
6508 'modified_date': r
're:\d{8}',
6509 'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6510 'channel': 'Wickman',
6512 'channel_url': 'https://www.youtube.com/channel/UCKSpbfbl5kRQpTdL7kMc-1Q',
6513 'availability': 'public',
6515 'playlist_mincount': 29,
6517 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6519 'title': 'YDL_safe_search',
6520 'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6522 'playlist_count': 2,
6523 'skip': 'This playlist is private',
6526 'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6527 'playlist_count': 4,
6530 'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6531 'uploader': 'milan',
6532 'uploader_id': '@milan5503',
6534 'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6536 'modified_date': '20140919',
6539 'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6540 'uploader_url': 'https://www.youtube.com/@milan5503',
6541 'availability': 'public',
6543 'expected_warnings': [r
'[Uu]navailable videos? (is|are|will be) hidden'],
6545 'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6546 'playlist_mincount': 455,
6548 'title': '2018 Chinese New Singles (11/6 updated)',
6549 'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6551 'uploader_id': '@music_king',
6552 'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6555 'channel_url': 'https://www.youtube.com/channel/UC21nz3_MesPLqtDqwdvnoxA',
6557 'uploader_url': 'https://www.youtube.com/@music_king',
6558 'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6559 'modified_date': r
're:\d{8}',
6560 'availability': 'public',
6562 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6564 'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6565 'only_matching': True,
6567 # music album playlist
6568 'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6569 'only_matching': True,
6573 def suitable(cls
, url
):
6574 if YoutubeTabIE
.suitable(url
):
6576 from ..utils
import parse_qs
6578 if qs
.get('v', [None])[0]:
6580 return super().suitable(url
)
6582 def _real_extract(self
, url
):
6583 playlist_id
= self
._match
_id
(url
)
6584 is_music_url
= YoutubeBaseInfoExtractor
.is_music_url(url
)
6585 url
= update_url_query(
6586 'https://www.youtube.com/playlist',
6587 parse_qs(url
) or {'list': playlist_id}
)
6589 url
= smuggle_url(url
, {'is_music_url': True}
)
6590 return self
.url_result(url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6593 class YoutubeYtBeIE(InfoExtractor
):
6594 IE_DESC
= 'youtu.be'
6595 _VALID_URL
= r
'https?://youtu\.be/(?P<id>[0-9A-Za-z_-]{11})/*?.*?\blist=(?P<playlist_id>%(playlist_id)s)' % {'playlist_id': YoutubeBaseInfoExtractor._PLAYLIST_ID_RE}
6597 'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6599 'id': 'yeWKywCrFtk',
6601 'title': 'Small Scale Baler and Braiding Rugs',
6602 'uploader': 'Backus-Page House Museum',
6603 'uploader_id': '@backuspagemuseum',
6604 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/@backuspagemuseum',
6605 'upload_date': '20161008',
6606 'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6607 'categories': ['Nonprofits & Activism'],
6611 'playable_in_embed': True,
6612 'thumbnail': r
're:^https?://.*\.webp',
6613 'channel': 'Backus-Page House Museum',
6614 'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6615 'live_status': 'not_live',
6617 'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6618 'availability': 'public',
6620 'comment_count': int,
6621 'channel_follower_count': int
6625 'skip_download': True,
6628 'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6629 'only_matching': True,
6632 def _real_extract(self
, url
):
6633 mobj
= self
._match
_valid
_url
(url
)
6634 video_id
= mobj
.group('id')
6635 playlist_id
= mobj
.group('playlist_id')
6636 return self
.url_result(
6637 update_url_query('https://www.youtube.com/watch', {
6639 'list': playlist_id
,
6640 'feature': 'youtu.be',
6641 }), ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6644 class YoutubeLivestreamEmbedIE(InfoExtractor
):
6645 IE_DESC
= 'YouTube livestream embeds'
6646 _VALID_URL
= r
'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6648 'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6649 'only_matching': True,
6652 def _real_extract(self
, url
):
6653 channel_id
= self
._match
_id
(url
)
6654 return self
.url_result(
6655 f
'https://www.youtube.com/channel/{channel_id}/live',
6656 ie
=YoutubeTabIE
.ie_key(), video_id
=channel_id
)
6659 class YoutubeYtUserIE(InfoExtractor
):
6660 IE_DESC
= 'YouTube user videos; "ytuser:" prefix'
6661 IE_NAME
= 'youtube:user'
6662 _VALID_URL
= r
'ytuser:(?P<id>.+)'
6664 'url': 'ytuser:phihag',
6665 'only_matching': True,
6668 def _real_extract(self
, url
):
6669 user_id
= self
._match
_id
(url
)
6670 return self
.url_result(f
'https://www.youtube.com/user/{user_id}', YoutubeTabIE
, user_id
)
6673 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor
):
6674 IE_NAME
= 'youtube:favorites'
6675 IE_DESC
= 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6676 _VALID_URL
= r
':ytfav(?:ou?rite)?s?'
6677 _LOGIN_REQUIRED
= True
6680 'only_matching': True,
6682 'url': ':ytfavorites',
6683 'only_matching': True,
6686 def _real_extract(self
, url
):
6687 return self
.url_result(
6688 'https://www.youtube.com/playlist?list=LL',
6689 ie
=YoutubeTabIE
.ie_key())
6692 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor
):
6693 IE_NAME
= 'youtube:notif'
6694 IE_DESC
= 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6695 _VALID_URL
= r
':ytnotif(?:ication)?s?'
6696 _LOGIN_REQUIRED
= True
6699 'only_matching': True,
6701 'url': ':ytnotifications',
6702 'only_matching': True,
6705 def _extract_notification_menu(self
, response
, continuation_list
):
6706 notification_list
= traverse_obj(
6708 ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6709 ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6710 expected_type
=list) or []
6711 continuation_list
[0] = None
6712 for item
in notification_list
:
6713 entry
= self
._extract
_notification
_renderer
(item
.get('notificationRenderer'))
6716 continuation
= item
.get('continuationItemRenderer')
6718 continuation_list
[0] = continuation
6720 def _extract_notification_renderer(self
, notification
):
6721 video_id
= traverse_obj(
6722 notification
, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str)
6723 url
= f
'https://www.youtube.com/watch?v={video_id}'
6726 browse_ep
= traverse_obj(
6727 notification
, ('navigationEndpoint', 'browseEndpoint'), expected_type
=dict)
6728 channel_id
= self
.ucid_or_none(traverse_obj(browse_ep
, 'browseId', expected_type
=str))
6729 post_id
= self
._search
_regex
(
6730 r
'/post/(.+)', traverse_obj(browse_ep
, 'canonicalBaseUrl', expected_type
=str),
6731 'post id', default
=None)
6732 if not channel_id
or not post_id
:
6734 # The direct /post url redirects to this in the browser
6735 url
= f
'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
6737 channel
= traverse_obj(
6738 notification
, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
6740 notification_title
= self
._get
_text
(notification
, 'shortMessage')
6741 if notification_title
:
6742 notification_title
= notification_title
.replace('\xad', '') # remove soft hyphens
6743 # TODO: handle recommended videos
6744 title
= self
._search
_regex
(
6745 rf
'{re.escape(channel or "")}[^:]+: (.+)', notification_title
,
6746 'video title', default
=None)
6747 timestamp
= (self
._parse
_time
_text
(self
._get
_text
(notification
, 'sentTimeText'))
6748 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
6753 'ie_key': (YoutubeIE
if video_id
else YoutubeTabIE
).ie_key(),
6754 'video_id': video_id
,
6756 'channel_id': channel_id
,
6758 'uploader': channel
,
6759 'thumbnails': self
._extract
_thumbnails
(notification
, 'videoThumbnail'),
6760 'timestamp': timestamp
,
6763 def _notification_menu_entries(self
, ytcfg
):
6764 continuation_list
= [None]
6766 for page
in itertools
.count(1):
6767 ctoken
= traverse_obj(
6768 continuation_list
, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type
=str)
6769 response
= self
._extract
_response
(
6770 item_id
=f
'page {page}', query
={'ctoken': ctoken}
if ctoken
else {}, ytcfg
=ytcfg
,
6771 ep
='notification/get_notification_menu', check_get_keys
='actions',
6772 headers
=self
.generate_api_headers(ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(response
)))
6773 yield from self
._extract
_notification
_menu
(response
, continuation_list
)
6774 if not continuation_list
[0]:
6777 def _real_extract(self
, url
):
6778 display_id
= 'notifications'
6779 ytcfg
= self
._download
_ytcfg
('web', display_id
) if not self
.skip_webpage
else {}
6780 self
._report
_playlist
_authcheck
(ytcfg
)
6781 return self
.playlist_result(self
._notification
_menu
_entries
(ytcfg
), display_id
, display_id
)
6784 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6785 IE_DESC
= 'YouTube search'
6786 IE_NAME
= 'youtube:search'
6787 _SEARCH_KEY
= 'ytsearch'
6788 _SEARCH_PARAMS
= 'EgIQAQ%3D%3D' # Videos only
6790 'url': 'ytsearch5:youtube-dl test video',
6791 'playlist_count': 5,
6793 'id': 'youtube-dl test video',
6794 'title': 'youtube-dl test video',
6799 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6800 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ ':date'
6801 _SEARCH_KEY
= 'ytsearchdate'
6802 IE_DESC
= 'YouTube search, newest videos first'
6803 _SEARCH_PARAMS
= 'CAISAhAB' # Videos only, sorted by date
6805 'url': 'ytsearchdate5:youtube-dl test video',
6806 'playlist_count': 5,
6808 'id': 'youtube-dl test video',
6809 'title': 'youtube-dl test video',
6814 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor
):
6815 IE_DESC
= 'YouTube search URLs with sorting and filter support'
6816 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ '_url'
6817 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6819 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
6820 'playlist_mincount': 5,
6822 'id': 'youtube-dl test video',
6823 'title': 'youtube-dl test video',
6826 'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
6827 'playlist_mincount': 5,
6833 'url': 'https://www.youtube.com/results?search_query=%23cats',
6834 'playlist_mincount': 1,
6838 # The test suite does not have support for nested playlists
6840 # 'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
6846 'url': 'https://www.youtube.com/results?search_query=kurzgesagt&sp=EgIQAg%253D%253D',
6849 'title': 'kurzgesagt',
6854 'id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6855 'url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6856 'ie_key': 'YoutubeTab',
6857 'channel': 'Kurzgesagt – In a Nutshell',
6858 'description': 'md5:4ae48dfa9505ffc307dad26342d06bfc',
6859 'title': 'Kurzgesagt – In a Nutshell',
6860 'channel_id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6861 'playlist_count': int, # XXX: should have a way of saying > 1
6862 'channel_url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6864 'uploader_id': '@kurzgesagt',
6865 'uploader_url': 'https://www.youtube.com/@kurzgesagt',
6866 'uploader': 'Kurzgesagt – In a Nutshell',
6869 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6870 'playlist_mincount': 1,
6872 'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
6873 'only_matching': True,
6876 def _real_extract(self
, url
):
6878 query
= (qs
.get('search_query') or qs
.get('q'))[0]
6879 return self
.playlist_result(self
._search
_results
(query
, qs
.get('sp', (None,))[0]), query
, query
)
6882 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor
):
6883 IE_DESC
= 'YouTube music search URLs with selectable sections, e.g. #songs'
6884 IE_NAME
= 'youtube:music:search_url'
6885 _VALID_URL
= r
'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6887 'url': 'https://music.youtube.com/search?q=royalty+free+music',
6888 'playlist_count': 16,
6890 'id': 'royalty free music',
6891 'title': 'royalty free music',
6894 'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
6895 'playlist_mincount': 30,
6897 'id': 'royalty free music - songs',
6898 'title': 'royalty free music - songs',
6900 'params': {'extract_flat': 'in_playlist'}
6902 'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
6903 'playlist_mincount': 30,
6905 'id': 'royalty free music - community playlists',
6906 'title': 'royalty free music - community playlists',
6908 'params': {'extract_flat': 'in_playlist'}
6912 'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
6913 'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
6914 'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
6915 'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
6916 'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
6917 'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
6920 def _real_extract(self
, url
):
6922 query
= (qs
.get('search_query') or qs
.get('q'))[0]
6923 params
= qs
.get('sp', (None,))[0]
6925 section
= next((k
for k
, v
in self
._SECTIONS
.items() if v
== params
), params
)
6927 section
= urllib
.parse
.unquote_plus((url
.split('#') + [''])[1]).lower()
6928 params
= self
._SECTIONS
.get(section
)
6931 title
= join_nonempty(query
, section
, delim
=' - ')
6932 return self
.playlist_result(self
._search
_results
(query
, params
, default_client
='web_music'), title
, title
)
6935 class YoutubeFeedsInfoExtractor(InfoExtractor
):
6937 Base class for feed extractors
6938 Subclasses must re-define the _FEED_NAME property.
6940 _LOGIN_REQUIRED
= True
6941 _FEED_NAME
= 'feeds'
6943 def _real_initialize(self
):
6944 YoutubeBaseInfoExtractor
._check
_login
_required
(self
)
6948 return f
'youtube:{self._FEED_NAME}'
6950 def _real_extract(self
, url
):
6951 return self
.url_result(
6952 f
'https://www.youtube.com/feed/{self._FEED_NAME}', ie
=YoutubeTabIE
.ie_key())
6955 class YoutubeWatchLaterIE(InfoExtractor
):
6956 IE_NAME
= 'youtube:watchlater'
6957 IE_DESC
= 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
6958 _VALID_URL
= r
':ytwatchlater'
6960 'url': ':ytwatchlater',
6961 'only_matching': True,
6964 def _real_extract(self
, url
):
6965 return self
.url_result(
6966 'https://www.youtube.com/playlist?list=WL', ie
=YoutubeTabIE
.ie_key())
6969 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor
):
6970 IE_DESC
= 'YouTube recommended videos; ":ytrec" keyword'
6971 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
6972 _FEED_NAME
= 'recommended'
6973 _LOGIN_REQUIRED
= False
6976 'only_matching': True,
6978 'url': ':ytrecommended',
6979 'only_matching': True,
6981 'url': 'https://youtube.com',
6982 'only_matching': True,
6986 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor
):
6987 IE_DESC
= 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
6988 _VALID_URL
= r
':ytsub(?:scription)?s?'
6989 _FEED_NAME
= 'subscriptions'
6992 'only_matching': True,
6994 'url': ':ytsubscriptions',
6995 'only_matching': True,
6999 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor
):
7000 IE_DESC
= 'Youtube watch history; ":ythis" keyword (requires cookies)'
7001 _VALID_URL
= r
':ythis(?:tory)?'
7002 _FEED_NAME
= 'history'
7004 'url': ':ythistory',
7005 'only_matching': True,
7009 class YoutubeStoriesIE(InfoExtractor
):
7010 IE_DESC
= 'YouTube channel stories; "ytstories:" prefix'
7011 IE_NAME
= 'youtube:stories'
7012 _VALID_URL
= r
'ytstories:UC(?P<id>[A-Za-z0-9_-]{21}[AQgw])$'
7014 'url': 'ytstories:UCwFCb4jeqaKWnciAYM-ZVHg',
7015 'only_matching': True,
7018 def _real_extract(self
, url
):
7019 playlist_id
= f
'RLTD{self._match_id(url)}'
7020 return self
.url_result(
7021 smuggle_url(f
'https://www.youtube.com/playlist?list={playlist_id}&playnext=1', {'is_story': True}
),
7022 ie
=YoutubeTabIE
, video_id
=playlist_id
)
7025 class YoutubeShortsAudioPivotIE(InfoExtractor
):
7026 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
7027 IE_NAME
= 'youtube:shorts:pivot:audio'
7028 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
7030 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
7031 'only_matching': True,
7035 def _generate_audio_pivot_params(video_id
):
7037 Generates sfv_audio_pivot browse params for this video id
7039 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
7040 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
7042 def _real_extract(self
, url
):
7043 video_id
= self
._match
_id
(url
)
7044 return self
.url_result(
7045 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
7049 class YoutubeTruncatedURLIE(InfoExtractor
):
7050 IE_NAME
= 'youtube:truncated_url'
7051 IE_DESC
= False # Do not list
7052 _VALID_URL
= r
'''(?x)
7054 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
7057 annotation_id=annotation_[^&]+|
7063 attribution_link\?a=[^&]+
7069 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
7070 'only_matching': True,
7072 'url': 'https://www.youtube.com/watch?',
7073 'only_matching': True,
7075 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
7076 'only_matching': True,
7078 'url': 'https://www.youtube.com/watch?feature=foo',
7079 'only_matching': True,
7081 'url': 'https://www.youtube.com/watch?hl=en-GB',
7082 'only_matching': True,
7084 'url': 'https://www.youtube.com/watch?t=2372',
7085 'only_matching': True,
7088 def _real_extract(self
, url
):
7089 raise ExtractorError(
7090 'Did you forget to quote the URL? Remember that & is a meta '
7091 'character in most shells, so you want to put the URL in quotes, '
7093 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
7094 ' or simply youtube-dl BaW_jenozKc .',
7098 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
7099 IE_NAME
= 'youtube:clip'
7100 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7102 # FIXME: Other metadata should be extracted from the clip, not from the base video
7103 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7105 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7107 'section_start': 29.0,
7108 'section_end': 39.7,
7111 'availability': 'public',
7112 'categories': ['Gaming'],
7113 'channel': 'Scott The Woz',
7114 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7115 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7116 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7118 'playable_in_embed': True,
7120 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7121 'title': 'Mobile Games on Console - Scott The Woz',
7122 'upload_date': '20210920',
7123 'uploader': 'Scott The Woz',
7124 'uploader_id': '@ScottTheWoz',
7125 'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7127 'live_status': 'not_live',
7128 'channel_follower_count': int,
7129 'chapters': 'count:20',
7133 def _real_extract(self
, url
):
7134 clip_id
= self
._match
_id
(url
)
7135 _
, data
= self
._extract
_webpage
(url
, clip_id
)
7137 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7139 raise ExtractorError('Unable to find video ID')
7141 clip_data
= traverse_obj(data
, (
7142 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7143 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7144 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7145 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
7148 '_type': 'url_transparent',
7149 'url': f
'https://www.youtube.com/watch?v={video_id}',
7150 'ie_key': YoutubeIE
.ie_key(),
7152 'section_start': int(clip_data
['startTimeMs']) / 1000,
7153 'section_end': int(clip_data
['endTimeMs']) / 1000,
7157 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor
):
7158 IE_NAME
= 'youtube:consent'
7159 IE_DESC
= False # Do not list
7160 _VALID_URL
= r
'https?://consent\.youtube\.com/m\?'
7162 'url': 'https://consent.youtube.com/m?continue=https%3A%2F%2Fwww.youtube.com%2Flive%2FqVv6vCqciTM%3Fcbrd%3D1&gl=NL&m=0&pc=yt&hl=en&src=1',
7164 'id': 'qVv6vCqciTM',
7167 'uploader_id': '@sana_natori',
7168 'comment_count': int,
7169 'chapters': 'count:13',
7170 'upload_date': '20221223',
7171 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7172 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7173 'uploader_url': 'https://www.youtube.com/@sana_natori',
7175 'release_date': '20221223',
7176 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7177 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7179 'playable_in_embed': True,
7181 'availability': 'public',
7182 'channel_follower_count': int,
7183 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7184 'categories': ['Entertainment'],
7185 'live_status': 'was_live',
7186 'release_timestamp': 1671793345,
7187 'channel': 'さなちゃんねる',
7188 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7189 'uploader': 'さなちゃんねる',
7191 'add_ie': ['Youtube'],
7192 'params': {'skip_download': 'Youtube'}
,
7195 def _real_extract(self
, url
):
7196 redirect_url
= url_or_none(parse_qs(url
).get('continue', [None])[-1])
7197 if not redirect_url
:
7198 raise ExtractorError('Invalid cookie consent redirect URL', expected
=True)
7199 return self
.url_result(redirect_url
)
7202 class YoutubeTruncatedIDIE(InfoExtractor
):
7203 IE_NAME
= 'youtube:truncated_id'
7204 IE_DESC
= False # Do not list
7205 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7208 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7209 'only_matching': True,
7212 def _real_extract(self
, url
):
7213 video_id
= self
._match
_id
(url
)
7214 raise ExtractorError(
7215 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',