20 from .common
import InfoExtractor
, SearchInfoExtractor
21 from .openload
import PhantomJSwrapper
22 from ..compat
import functools
23 from ..jsinterp
import JSInterpreter
24 from ..networking
.exceptions
import HTTPError
, network_exceptions
68 STREAMING_DATA_CLIENT_NAME
= '__yt_dlp_client'
69 # any clients starting with _ cannot be explicitly requested by the user
72 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
73 'INNERTUBE_CONTEXT': {
76 'clientVersion': '2.20220801.00.00',
79 'INNERTUBE_CONTEXT_CLIENT_NAME': 1
82 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
83 'INNERTUBE_CONTEXT': {
85 'clientName': 'WEB_EMBEDDED_PLAYER',
86 'clientVersion': '1.20220731.00.00',
89 'INNERTUBE_CONTEXT_CLIENT_NAME': 56
92 'INNERTUBE_API_KEY': 'AIzaSyC9XL3ZjWddXya6X74dJoCTL-WEYFDNX30',
93 'INNERTUBE_HOST': 'music.youtube.com',
94 'INNERTUBE_CONTEXT': {
96 'clientName': 'WEB_REMIX',
97 'clientVersion': '1.20220727.01.00',
100 'INNERTUBE_CONTEXT_CLIENT_NAME': 67,
103 'INNERTUBE_API_KEY': 'AIzaSyBUPetSUmoZL-OhlxA7wSac5XinrygCqMo',
104 'INNERTUBE_CONTEXT': {
106 'clientName': 'WEB_CREATOR',
107 'clientVersion': '1.20220726.00.00',
110 'INNERTUBE_CONTEXT_CLIENT_NAME': 62,
113 'INNERTUBE_API_KEY': 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w',
114 'INNERTUBE_CONTEXT': {
116 'clientName': 'ANDROID',
117 'clientVersion': '18.11.34',
118 'androidSdkVersion': 30,
119 'userAgent': 'com.google.android.youtube/18.11.34 (Linux; U; Android 11) gzip'
122 'INNERTUBE_CONTEXT_CLIENT_NAME': 3,
123 'REQUIRE_JS_PLAYER': False
125 'android_embedded': {
126 'INNERTUBE_API_KEY': 'AIzaSyCjc_pVEDi4qsv5MtC2dMXzpIaDoRFLsxw',
127 'INNERTUBE_CONTEXT': {
129 'clientName': 'ANDROID_EMBEDDED_PLAYER',
130 'clientVersion': '18.11.34',
131 'androidSdkVersion': 30,
132 'userAgent': 'com.google.android.youtube/18.11.34 (Linux; U; Android 11) gzip'
135 'INNERTUBE_CONTEXT_CLIENT_NAME': 55,
136 'REQUIRE_JS_PLAYER': False
139 'INNERTUBE_API_KEY': 'AIzaSyAOghZGza2MQSZkY_zfZ370N-PUdXEo8AI',
140 'INNERTUBE_CONTEXT': {
142 'clientName': 'ANDROID_MUSIC',
143 'clientVersion': '5.16.51',
144 'androidSdkVersion': 30,
145 'userAgent': 'com.google.android.apps.youtube.music/5.16.51 (Linux; U; Android 11) gzip'
148 'INNERTUBE_CONTEXT_CLIENT_NAME': 21,
149 'REQUIRE_JS_PLAYER': False
152 'INNERTUBE_API_KEY': 'AIzaSyD_qjV8zaaUMehtLkrKFgVeSX_Iqbtyws8',
153 'INNERTUBE_CONTEXT': {
155 'clientName': 'ANDROID_CREATOR',
156 'clientVersion': '22.30.100',
157 'androidSdkVersion': 30,
158 'userAgent': 'com.google.android.apps.youtube.creator/22.30.100 (Linux; U; Android 11) gzip'
161 'INNERTUBE_CONTEXT_CLIENT_NAME': 14,
162 'REQUIRE_JS_PLAYER': False
164 # iOS clients have HLS live streams. Setting device model to get 60fps formats.
165 # See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/680#issuecomment-1002724558
167 'INNERTUBE_API_KEY': 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc',
168 'INNERTUBE_CONTEXT': {
171 'clientVersion': '18.11.34',
172 'deviceModel': 'iPhone14,3',
173 'userAgent': 'com.google.ios.youtube/18.11.34 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
176 'INNERTUBE_CONTEXT_CLIENT_NAME': 5,
177 'REQUIRE_JS_PLAYER': False
180 'INNERTUBE_CONTEXT': {
182 'clientName': 'IOS_MESSAGES_EXTENSION',
183 'clientVersion': '18.11.34',
184 'deviceModel': 'iPhone14,3',
185 'userAgent': 'com.google.ios.youtube/18.11.34 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
188 'INNERTUBE_CONTEXT_CLIENT_NAME': 66,
189 'REQUIRE_JS_PLAYER': False
192 'INNERTUBE_API_KEY': 'AIzaSyBAETezhkwP0ZWA02RsqT1zu78Fpt0bC_s',
193 'INNERTUBE_CONTEXT': {
195 'clientName': 'IOS_MUSIC',
196 'clientVersion': '5.21',
197 'deviceModel': 'iPhone14,3',
198 'userAgent': 'com.google.ios.youtubemusic/5.21 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
201 'INNERTUBE_CONTEXT_CLIENT_NAME': 26,
202 'REQUIRE_JS_PLAYER': False
205 'INNERTUBE_CONTEXT': {
207 'clientName': 'IOS_CREATOR',
208 'clientVersion': '22.33.101',
209 'deviceModel': 'iPhone14,3',
210 'userAgent': 'com.google.ios.ytcreator/22.33.101 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
213 'INNERTUBE_CONTEXT_CLIENT_NAME': 15,
214 'REQUIRE_JS_PLAYER': False
216 # mweb has 'ultralow' formats
217 # See: https://github.com/yt-dlp/yt-dlp/pull/557
219 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
220 'INNERTUBE_CONTEXT': {
222 'clientName': 'MWEB',
223 'clientVersion': '2.20220801.00.00',
226 'INNERTUBE_CONTEXT_CLIENT_NAME': 2
228 # This client can access age restricted videos (unless the uploader has disabled the 'allow embedding' option)
229 # See: https://github.com/zerodytrash/YouTube-Internal-Clients
231 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
232 'INNERTUBE_CONTEXT': {
234 'clientName': 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
235 'clientVersion': '2.0',
238 'INNERTUBE_CONTEXT_CLIENT_NAME': 85
243 def _split_innertube_client(client_name
):
244 variant
, *base
= client_name
.rsplit('.', 1)
246 return variant
, base
[0], variant
247 base
, *variant
= client_name
.split('_', 1)
248 return client_name
, base
, variant
[0] if variant
else None
251 def short_client_name(client_name
):
252 main
, *parts
= _split_innertube_client(client_name
)[0].replace('embedscreen', 'e_s').split('_')
253 return join_nonempty(main
[:4], ''.join(x
[0] for x
in parts
)).upper()
256 def build_innertube_clients():
258 'embedUrl': 'https://www.youtube.com/', # Can be any valid URL
260 BASE_CLIENTS
= ('ios', 'android', 'web', 'tv', 'mweb')
261 priority
= qualities(BASE_CLIENTS
[::-1])
263 for client
, ytcfg
in tuple(INNERTUBE_CLIENTS
.items()):
264 ytcfg
.setdefault('INNERTUBE_API_KEY', 'AIzaSyDCU8hByM-4DrUqRUYnGn-3llEO78bcxq8')
265 ytcfg
.setdefault('INNERTUBE_HOST', 'www.youtube.com')
266 ytcfg
.setdefault('REQUIRE_JS_PLAYER', True)
267 ytcfg
['INNERTUBE_CONTEXT']['client'].setdefault('hl', 'en')
269 _
, base_client
, variant
= _split_innertube_client(client
)
270 ytcfg
['priority'] = 10 * priority(base_client
)
273 INNERTUBE_CLIENTS
[f
'{client}_embedscreen'] = embedscreen
= copy
.deepcopy(ytcfg
)
274 embedscreen
['INNERTUBE_CONTEXT']['client']['clientScreen'] = 'EMBED'
275 embedscreen
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
276 embedscreen
['priority'] -= 3
277 elif variant
== 'embedded':
278 ytcfg
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
279 ytcfg
['priority'] -= 2
281 ytcfg
['priority'] -= 3
284 build_innertube_clients()
287 class BadgeType(enum
.Enum
):
288 AVAILABILITY_UNLISTED
= enum
.auto()
289 AVAILABILITY_PRIVATE
= enum
.auto()
290 AVAILABILITY_PUBLIC
= enum
.auto()
291 AVAILABILITY_PREMIUM
= enum
.auto()
292 AVAILABILITY_SUBSCRIPTION
= enum
.auto()
293 LIVE_NOW
= enum
.auto()
294 VERIFIED
= 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|cf)\.)?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'):
499 socs
= cookies
.get('SOCS')
500 if socs
and not socs
.value
.startswith('CAA'): # not consented
502 self
._set
_cookie
('.youtube.com', 'SOCS', 'CAI', secure
=True) # accept all (required for mixes)
504 def _initialize_pref(self
):
505 cookies
= self
._get
_cookies
('https://www.youtube.com/')
506 pref_cookie
= cookies
.get('PREF')
510 pref
= dict(urllib
.parse
.parse_qsl(pref_cookie
.value
))
512 self
.report_warning('Failed to parse user PREF cookie' + bug_reports_message())
513 pref
.update({'hl': self._preferred_lang or 'en', 'tz': 'UTC'}
)
514 self
._set
_cookie
('.youtube.com', name
='PREF', value
=urllib
.parse
.urlencode(pref
))
516 def _real_initialize(self
):
517 self
._initialize
_pref
()
518 self
._initialize
_consent
()
519 self
._check
_login
_required
()
521 def _check_login_required(self
):
522 if self
._LOGIN
_REQUIRED
and not self
._cookies
_passed
:
523 self
.raise_login_required('Login details are needed to download this content', method
='cookies')
525 _YT_INITIAL_DATA_RE
= r
'(?:window\s*\[\s*["\']ytInitialData
["\']\s*\]|ytInitialData)\s*='
526 _YT_INITIAL_PLAYER_RESPONSE_RE = r'ytInitialPlayerResponse\s*='
528 def _get_default_ytcfg(self, client='web'):
529 return copy.deepcopy(INNERTUBE_CLIENTS[client])
531 def _get_innertube_host(self, client='web'):
532 return INNERTUBE_CLIENTS[client]['INNERTUBE_HOST']
534 def _ytcfg_get_safe(self, ytcfg, getter, expected_type=None, default_client='web'):
535 # try_get but with fallback to default ytcfg client values when present
536 _func = lambda y: try_get(y, getter, expected_type)
537 return _func(ytcfg) or _func(self._get_default_ytcfg(default_client))
539 def _extract_client_name(self, ytcfg, default_client='web'):
540 return self._ytcfg_get_safe(
541 ytcfg, (lambda x: x['INNERTUBE_CLIENT_NAME'],
542 lambda x: x['INNERTUBE_CONTEXT']['client']['clientName']), str, default_client)
544 def _extract_client_version(self, ytcfg, default_client='web'):
545 return self._ytcfg_get_safe(
546 ytcfg, (lambda x: x['INNERTUBE_CLIENT_VERSION'],
547 lambda x: x['INNERTUBE_CONTEXT']['client']['clientVersion']), str, default_client)
549 def _select_api_hostname(self, req_api_hostname, default_client=None):
550 return (self._configuration_arg('innertube_host', [''], ie_key=YoutubeIE.ie_key())[0]
551 or req_api_hostname or self._get_innertube_host(default_client or 'web'))
553 def _extract_api_key(self, ytcfg=None, default_client='web'):
554 return self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_API_KEY'], str, default_client)
556 def _extract_context(self, ytcfg=None, default_client='web'):
558 (ytcfg, self._get_default_ytcfg(default_client)), 'INNERTUBE_CONTEXT', expected_type=dict)
559 # Enforce language and tz for extraction
560 client_context = traverse_obj(context, 'client', expected_type=dict, default={})
561 client_context.update({'hl': self._preferred_lang or 'en', 'timeZone': 'UTC', 'utcOffsetMinutes': 0})
566 def _generate_sapisidhash_header(self, origin='https://www.youtube.com'):
567 time_now = round(time.time())
568 if self._SAPISID is None:
569 yt_cookies = self._get_cookies('https://www.youtube.com')
570 # Sometimes SAPISID cookie isn't present but __Secure-3PAPISID is.
571 # See: https://github.com/yt-dlp/yt-dlp/issues/393
572 sapisid_cookie = dict_get(
573 yt_cookies, ('__Secure-3PAPISID', 'SAPISID'))
574 if sapisid_cookie and sapisid_cookie.value:
575 self._SAPISID = sapisid_cookie.value
576 self.write_debug('Extracted SAPISID cookie')
577 # SAPISID cookie is required if not already present
578 if not yt_cookies.get('SAPISID'):
579 self.write_debug('Copying __Secure-3PAPISID cookie to SAPISID cookie')
581 '.youtube.com', 'SAPISID', self._SAPISID, secure=True, expire_time=time_now + 3600)
583 self._SAPISID = False
584 if not self._SAPISID:
586 # SAPISIDHASH algorithm from https://stackoverflow.com/a/32065323
587 sapisidhash = hashlib.sha1(
588 f'{time_now} {self._SAPISID} {origin}'.encode()).hexdigest()
589 return f'SAPISIDHASH {time_now}_{sapisidhash}'
591 def _call_api(self, ep, query, video_id, fatal=True, headers=None,
592 note='Downloading API JSON', errnote='Unable to download API page',
593 context=None, api_key=None, api_hostname=None, default_client='web'):
595 data = {'context': context} if context else {'context': self._extract_context(default_client=default_client)}
597 real_headers = self.generate_api_headers(default_client=default_client)
598 real_headers.update({'content-type': 'application/json'})
600 real_headers.update(headers)
601 api_key = (self._configuration_arg('innertube_key', [''], ie_key=YoutubeIE.ie_key(), casesense=True)[0]
602 or api_key or self._extract_api_key(default_client=default_client))
603 return self._download_json(
604 f'https://{self._select_api_hostname(api_hostname, default_client)}/youtubei/v1/{ep}',
605 video_id=video_id, fatal=fatal, note=note, errnote=errnote,
606 data=json.dumps(data).encode('utf8'), headers=real_headers,
607 query={'key': api_key, 'prettyPrint': 'false'})
609 def extract_yt_initial_data(self, item_id, webpage, fatal=True):
610 return self._search_json(self._YT_INITIAL_DATA_RE, webpage, 'yt initial data', item_id, fatal=fatal)
613 def _extract_session_index(*data):
615 Index of current account in account list.
616 See: https://github.com/yt-dlp/yt-dlp/pull/519
619 session_index = int_or_none(try_get(ytcfg, lambda x: x['SESSION_INDEX']))
620 if session_index is not None:
624 def _extract_identity_token(self, ytcfg=None, webpage=None):
626 token = try_get(ytcfg, lambda x: x['ID_TOKEN'], str)
630 return self._search_regex(
631 r'\bID_TOKEN["\']\s
*:\s
*["\'](.+?)["\']', webpage,
632 'identity token
', default=None, fatal=False)
635 def _extract_account_syncid(*args):
637 Extract syncId required to download private playlists of secondary channels
638 @params response and/or ytcfg
641 # ytcfg includes channel_syncid if on secondary channel
642 delegated_sid = try_get(data, lambda x: x['DELEGATED_SESSION_ID
'], str)
646 data, (lambda x: x['responseContext
']['mainAppWebResponseContext
']['datasyncId
'],
647 lambda x: x['DATASYNC_ID
']), str) or '').split('||
')
648 if len(sync_ids) >= 2 and sync_ids[1]:
649 # datasyncid is of the form "channel_syncid||user_syncid" for secondary channel
650 # and just "user_syncid||" for primary channel. We only want the channel_syncid
654 def _extract_visitor_data(*args):
656 Extracts visitorData from an API response or ytcfg
657 Appears to be used to track session state
660 args, [('VISITOR_DATA
', ('INNERTUBE_CONTEXT
', 'client
', 'visitorData
'), ('responseContext
', 'visitorData
'))],
663 @functools.cached_property
664 def is_authenticated(self):
665 return bool(self._generate_sapisidhash_header())
667 def extract_ytcfg(self, video_id, webpage):
670 return self._parse_json(
672 r'ytcfg\
.set\s
*\
(\s
*({.+?}
)\s
*\
)\s
*;', webpage, 'ytcfg
',
673 default='{}'), video_id, fatal=False) or {}
675 def generate_api_headers(
676 self
, *, ytcfg
=None, account_syncid
=None, session_index
=None,
677 visitor_data
=None, identity_token
=None, api_hostname
=None, default_client
='web'):
679 origin
= 'https://' + (self
._select
_api
_hostname
(api_hostname
, default_client
))
681 'X-YouTube-Client-Name': str(
682 self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT_CLIENT_NAME'], default_client
=default_client
)),
683 'X-YouTube-Client-Version': self
._extract
_client
_version
(ytcfg
, default_client
),
685 'X-Youtube-Identity-Token': identity_token
or self
._extract
_identity
_token
(ytcfg
),
686 'X-Goog-PageId': account_syncid
or self
._extract
_account
_syncid
(ytcfg
),
687 'X-Goog-Visitor-Id': visitor_data
or self
._extract
_visitor
_data
(ytcfg
),
688 'User-Agent': self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT']['client']['userAgent'], default_client
=default_client
)
690 if session_index
is None:
691 session_index
= self
._extract
_session
_index
(ytcfg
)
692 if account_syncid
or session_index
is not None:
693 headers
['X-Goog-AuthUser'] = session_index
if session_index
is not None else 0
695 auth
= self
._generate
_sapisidhash
_header
(origin
)
697 headers
['Authorization'] = auth
698 headers
['X-Origin'] = origin
699 return filter_dict(headers
)
701 def _download_ytcfg(self
, client
, video_id
):
703 'web': 'https://www.youtube.com',
704 'web_music': 'https://music.youtube.com',
705 'web_embedded': f
'https://www.youtube.com/embed/{video_id}?html5=1'
709 webpage
= self
._download
_webpage
(
710 url
, video_id
, fatal
=False, note
=f
'Downloading {client.replace("_", " ").strip()} client config')
711 return self
.extract_ytcfg(video_id
, webpage
) or {}
714 def _build_api_continuation_query(continuation
, ctp
=None):
716 'continuation': continuation
718 # TODO: Inconsistency with clickTrackingParams.
719 # Currently we have a fixed ctp contained within context (from ytcfg)
720 # and a ctp in root query for continuation.
722 query
['clickTracking'] = {'clickTrackingParams': ctp}
726 def _extract_next_continuation_data(cls
, renderer
):
727 next_continuation
= try_get(
728 renderer
, (lambda x
: x
['continuations'][0]['nextContinuationData'],
729 lambda x
: x
['continuation']['reloadContinuationData']), dict)
730 if not next_continuation
:
732 continuation
= next_continuation
.get('continuation')
735 ctp
= next_continuation
.get('clickTrackingParams')
736 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
739 def _extract_continuation_ep_data(cls
, continuation_ep
: dict):
740 if isinstance(continuation_ep
, dict):
741 continuation
= try_get(
742 continuation_ep
, lambda x
: x
['continuationCommand']['token'], str)
745 ctp
= continuation_ep
.get('clickTrackingParams')
746 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
749 def _extract_continuation(cls
, renderer
):
750 next_continuation
= cls
._extract
_next
_continuation
_data
(renderer
)
751 if next_continuation
:
752 return next_continuation
754 return traverse_obj(renderer
, (
755 ('contents', 'items', 'rows'), ..., 'continuationItemRenderer',
756 ('continuationEndpoint', ('button', 'buttonRenderer', 'command'))
757 ), get_all
=False, expected_type
=cls
._extract
_continuation
_ep
_data
)
760 def _extract_alerts(cls
, data
):
761 for alert_dict
in try_get(data
, lambda x
: x
['alerts'], list) or []:
762 if not isinstance(alert_dict
, dict):
764 for alert
in alert_dict
.values():
765 alert_type
= alert
.get('type')
768 message
= cls
._get
_text
(alert
, 'text')
770 yield alert_type
, message
772 def _report_alerts(self
, alerts
, expected
=True, fatal
=True, only_once
=False):
773 errors
, warnings
= [], []
774 for alert_type
, alert_message
in alerts
:
775 if alert_type
.lower() == 'error' and fatal
:
776 errors
.append([alert_type
, alert_message
])
777 elif alert_message
not in self
._IGNORED
_WARNINGS
:
778 warnings
.append([alert_type
, alert_message
])
780 for alert_type
, alert_message
in (warnings
+ errors
[:-1]):
781 self
.report_warning(f
'YouTube said: {alert_type} - {alert_message}', only_once
=only_once
)
783 raise ExtractorError('YouTube said: %s' % errors
[-1][1], expected
=expected
)
785 def _extract_and_report_alerts(self
, data
, *args
, **kwargs
):
786 return self
._report
_alerts
(self
._extract
_alerts
(data
), *args
, **kwargs
)
788 def _extract_badges(self
, badge_list
: list):
790 Extract known BadgeType's from a list of badge renderers.
791 @returns [{'type': BadgeType}]
794 'PRIVACY_UNLISTED': BadgeType
.AVAILABILITY_UNLISTED
,
795 'PRIVACY_PRIVATE': BadgeType
.AVAILABILITY_PRIVATE
,
796 'PRIVACY_PUBLIC': BadgeType
.AVAILABILITY_PUBLIC
,
797 'CHECK_CIRCLE_THICK': BadgeType
.VERIFIED
,
798 'OFFICIAL_ARTIST_BADGE': BadgeType
.VERIFIED
,
799 'CHECK': BadgeType
.VERIFIED
,
803 'BADGE_STYLE_TYPE_MEMBERS_ONLY': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
804 'BADGE_STYLE_TYPE_PREMIUM': BadgeType
.AVAILABILITY_PREMIUM
,
805 'BADGE_STYLE_TYPE_LIVE_NOW': BadgeType
.LIVE_NOW
,
806 'BADGE_STYLE_TYPE_VERIFIED': BadgeType
.VERIFIED
,
807 'BADGE_STYLE_TYPE_VERIFIED_ARTIST': BadgeType
.VERIFIED
,
811 'unlisted': BadgeType
.AVAILABILITY_UNLISTED
,
812 'private': BadgeType
.AVAILABILITY_PRIVATE
,
813 'members only': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
814 'live': BadgeType
.LIVE_NOW
,
815 'premium': BadgeType
.AVAILABILITY_PREMIUM
,
816 'verified': BadgeType
.VERIFIED
,
817 'official artist channel': BadgeType
.VERIFIED
,
821 for badge
in traverse_obj(badge_list
, (..., lambda key
, _
: re
.search(r
'[bB]adgeRenderer$', key
))):
823 icon_type_map
.get(traverse_obj(badge
, ('icon', 'iconType'), expected_type
=str))
824 or badge_style_map
.get(traverse_obj(badge
, 'style'))
827 badges
.append({'type': badge_type}
)
830 # fallback, won't work in some languages
831 label
= traverse_obj(
832 badge
, 'label', ('accessibilityData', 'label'), 'tooltip', 'iconTooltip', get_all
=False, expected_type
=str, default
='')
833 for match
, label_badge_type
in label_map
.items():
834 if match
in label
.lower():
835 badges
.append({'type': label_badge_type}
)
841 def _has_badge(badges
, badge_type
):
842 return bool(traverse_obj(badges
, lambda _
, v
: v
['type'] == badge_type
))
845 def _get_text(data
, *path_list
, max_runs
=None):
846 for path
in path_list
or [None]:
850 obj
= traverse_obj(data
, path
, default
=[])
851 if not any(key
is ... or isinstance(key
, (list, tuple)) for key
in variadic(path
)):
854 text
= try_get(item
, lambda x
: x
['simpleText'], str)
857 runs
= try_get(item
, lambda x
: x
['runs'], list) or []
858 if not runs
and isinstance(item
, list):
861 runs
= runs
[:min(len(runs
), max_runs
or len(runs
))]
862 text
= ''.join(traverse_obj(runs
, (..., 'text'), expected_type
=str))
866 def _get_count(self
, data
, *path_list
):
867 count_text
= self
._get
_text
(data
, *path_list
) or ''
868 count
= parse_count(count_text
)
871 self
._search
_regex
(r
'^([\d,]+)', re
.sub(r
'\s', '', count_text
), 'count', default
=None))
875 def _extract_thumbnails(data
, *path_list
):
877 Extract thumbnails from thumbnails dict
878 @param path_list: path list to level that contains 'thumbnails' key
881 for path
in path_list
or [()]:
882 for thumbnail
in traverse_obj(data
, (*variadic(path
), 'thumbnails', ...)):
883 thumbnail_url
= url_or_none(thumbnail
.get('url'))
884 if not thumbnail_url
:
886 # Sometimes youtube gives a wrong thumbnail URL. See:
887 # https://github.com/yt-dlp/yt-dlp/issues/233
888 # https://github.com/ytdl-org/youtube-dl/issues/28023
889 if 'maxresdefault' in thumbnail_url
:
890 thumbnail_url
= thumbnail_url
.split('?')[0]
892 'url': thumbnail_url
,
893 'height': int_or_none(thumbnail
.get('height')),
894 'width': int_or_none(thumbnail
.get('width')),
899 def extract_relative_time(relative_time_text
):
901 Extracts a relative time from string and converts to dt object
902 e.g. 'streamed 6 days ago', '5 seconds ago (edited)', 'updated today', '8 yr ago'
905 # XXX: this could be moved to a general function in utils/_utils.py
906 # The relative time text strings are roughly the same as what
907 # Javascript's Intl.RelativeTimeFormat function generates.
908 # See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
910 r
'(?P<start>today|yesterday|now)|(?P<time>\d+)\s*(?P<unit>sec(?:ond)?|s|min(?:ute)?|h(?:our|r)?|d(?:ay)?|w(?:eek|k)?|mo(?:nth)?|y(?:ear|r)?)s?\s*ago',
913 start
= mobj
.group('start')
915 return datetime_from_str(start
)
917 return datetime_from_str('now-%s%s' % (mobj
.group('time'), mobj
.group('unit')))
921 def _parse_time_text(self
, text
):
924 dt
= self
.extract_relative_time(text
)
926 if isinstance(dt
, datetime
.datetime
):
927 timestamp
= calendar
.timegm(dt
.timetuple())
929 if timestamp
is None:
931 unified_timestamp(text
) or unified_timestamp(
933 (r
'([a-z]+\s*\d{1,2},?\s*20\d{2})', r
'(?:.+|^)(?:live|premieres|ed|ing)(?:\s*(?:on|for))?\s*(.+\d)'),
934 text
.lower(), 'time text', default
=None)))
936 if text
and timestamp
is None and self
._preferred
_lang
in (None, 'en'):
938 f
'Cannot parse localized time text "{text}"', only_once
=True)
941 def _extract_response(self
, item_id
, query
, note
='Downloading API JSON', headers
=None,
942 ytcfg
=None, check_get_keys
=None, ep
='browse', fatal
=True, api_hostname
=None,
943 default_client
='web'):
944 raise_for_incomplete
= bool(self
._configuration
_arg
('raise_incomplete_data', ie_key
=YoutubeIE
))
945 # Incomplete Data should be a warning by default when retries are exhausted, while other errors should be fatal.
946 icd_retries
= iter(self
.RetryManager(fatal
=raise_for_incomplete
))
947 icd_rm
= next(icd_retries
)
948 main_retries
= iter(self
.RetryManager())
949 main_rm
= next(main_retries
)
950 # Manual retry loop for multiple RetryManagers
951 # The proper RetryManager MUST be advanced after an error
952 # and its result MUST be checked if the manager is non fatal
955 response
= self
._call
_api
(
956 ep
=ep
, fatal
=True, headers
=headers
,
957 video_id
=item_id
, query
=query
, note
=note
,
958 context
=self
._extract
_context
(ytcfg
, default_client
),
959 api_key
=self
._extract
_api
_key
(ytcfg
, default_client
),
960 api_hostname
=api_hostname
, default_client
=default_client
)
961 except ExtractorError
as e
:
962 if not isinstance(e
.cause
, network_exceptions
):
963 return self
._error
_or
_warning
(e
, fatal
=fatal
)
964 elif not isinstance(e
.cause
, HTTPError
):
969 first_bytes
= e
.cause
.response
.read(512)
970 if not is_html(first_bytes
):
973 self
._webpage
_read
_content
(e
.cause
.response
, None, item_id
, prefix
=first_bytes
) or '{}', item_id
, fatal
=False),
974 lambda x
: x
['error']['message'], str)
976 self
._report
_alerts
([('ERROR', yt_error
)], fatal
=False)
977 # Downloading page may result in intermittent 5xx HTTP error
978 # Sometimes a 404 is also received. See: https://github.com/ytdl-org/youtube-dl/issues/28289
979 # We also want to catch all other network exceptions since errors in later pages can be troublesome
980 # See https://github.com/yt-dlp/yt-dlp/issues/507#issuecomment-880188210
981 if e
.cause
.status
not in (403, 429):
985 return self
._error
_or
_warning
(e
, fatal
=fatal
)
988 self
._extract
_and
_report
_alerts
(response
, only_once
=True)
989 except ExtractorError
as e
:
990 # YouTube's servers may return errors we want to retry on in a 200 OK response
991 # See: https://github.com/yt-dlp/yt-dlp/issues/839
992 if 'unknown error' in e
.msg
.lower():
996 return self
._error
_or
_warning
(e
, fatal
=fatal
)
997 # Youtube sometimes sends incomplete data
998 # See: https://github.com/ytdl-org/youtube-dl/issues/28194
999 if not traverse_obj(response
, *variadic(check_get_keys
)):
1000 icd_rm
.error
= ExtractorError('Incomplete data received', expected
=True)
1001 should_retry
= next(icd_retries
, None)
1002 if not should_retry
:
1009 def is_music_url(url
):
1010 return re
.match(r
'(https?://)?music\.youtube\.com/', url
) is not None
1012 def _extract_video(self
, renderer
):
1013 video_id
= renderer
.get('videoId')
1015 reel_header_renderer
= traverse_obj(renderer
, (
1016 'navigationEndpoint', 'reelWatchEndpoint', 'overlay', 'reelPlayerOverlayRenderer',
1017 'reelPlayerHeaderSupportedRenderers', 'reelPlayerHeaderRenderer'))
1019 title
= self
._get
_text
(renderer
, 'title', 'headline') or self
._get
_text
(reel_header_renderer
, 'reelTitleText')
1020 description
= self
._get
_text
(renderer
, 'descriptionSnippet')
1022 duration
= int_or_none(renderer
.get('lengthSeconds'))
1023 if duration
is None:
1024 duration
= parse_duration(self
._get
_text
(
1025 renderer
, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
1026 if duration
is None:
1027 # XXX: should write a parser to be more general to support more cases (e.g. shorts in shorts tab)
1028 duration
= parse_duration(self
._search
_regex
(
1029 r
'(?i)(ago)(?!.*\1)\s+(?P<duration>[a-z0-9 ,]+?)(?:\s+[\d,]+\s+views)?(?:\s+-\s+play\s+short)?$',
1030 traverse_obj(renderer
, ('title', 'accessibility', 'accessibilityData', 'label'), default
='', expected_type
=str),
1031 video_id
, default
=None, group
='duration'))
1033 channel_id
= traverse_obj(
1034 renderer
, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'),
1035 expected_type
=str, get_all
=False)
1037 channel_id
= traverse_obj(reel_header_renderer
, ('channelNavigationEndpoint', 'browseEndpoint', 'browseId'))
1039 channel_id
= self
.ucid_or_none(channel_id
)
1041 overlay_style
= traverse_obj(
1042 renderer
, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'),
1043 get_all
=False, expected_type
=str)
1044 badges
= self
._extract
_badges
(traverse_obj(renderer
, 'badges'))
1045 owner_badges
= self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges'))
1046 navigation_url
= urljoin('https://www.youtube.com/', traverse_obj(
1047 renderer
, ('navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url'),
1048 expected_type
=str)) or ''
1049 url
= f
'https://www.youtube.com/watch?v={video_id}'
1050 if overlay_style
== 'SHORTS' or '/shorts/' in navigation_url
:
1051 url
= f
'https://www.youtube.com/shorts/{video_id}'
1053 time_text
= (self
._get
_text
(renderer
, 'publishedTimeText', 'videoInfo')
1054 or self
._get
_text
(reel_header_renderer
, 'timestampText') or '')
1055 scheduled_timestamp
= str_to_int(traverse_obj(renderer
, ('upcomingEventData', 'startTime'), get_all
=False))
1058 'is_upcoming' if scheduled_timestamp
is not None
1059 else 'was_live' if 'streamed' in time_text
.lower()
1060 else 'is_live' if overlay_style
== 'LIVE' or self
._has
_badge
(badges
, BadgeType
.LIVE_NOW
)
1063 # videoInfo is a string like '50K views • 10 years ago'.
1064 view_count_text
= self
._get
_text
(renderer
, 'viewCountText', 'shortViewCountText', 'videoInfo') or ''
1065 view_count
= (0 if 'no views' in view_count_text
.lower()
1066 else self
._get
_count
({'simpleText': view_count_text}
))
1067 view_count_field
= 'concurrent_view_count' if live_status
in ('is_live', 'is_upcoming') else 'view_count'
1069 channel
= (self
._get
_text
(renderer
, 'ownerText', 'shortBylineText')
1070 or self
._get
_text
(reel_header_renderer
, 'channelTitleText'))
1072 channel_handle
= traverse_obj(renderer
, (
1073 'shortBylineText', 'runs', ..., 'navigationEndpoint',
1074 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl'))),
1075 expected_type
=self
.handle_from_url
, get_all
=False)
1078 'ie_key': YoutubeIE
.ie_key(),
1082 'description': description
,
1083 'duration': duration
,
1084 'channel_id': channel_id
,
1086 'channel_url': f
'https://www.youtube.com/channel/{channel_id}' if channel_id
else None,
1087 'uploader': channel
,
1088 'uploader_id': channel_handle
,
1089 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
1090 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
1091 'timestamp': (self
._parse
_time
_text
(time_text
)
1092 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
1094 'release_timestamp': scheduled_timestamp
,
1096 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
1097 else self
._availability
(
1098 is_private
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
) or None,
1099 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
1100 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
1101 is_unlisted
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
) or None),
1102 view_count_field
: view_count
,
1103 'live_status': live_status
,
1104 'channel_is_verified': True if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
) else None
1108 class YoutubeIE(YoutubeBaseInfoExtractor
):
1110 _VALID_URL
= r
"""(?x)^
1112 (?:https?://|//) # http(s):// or protocol-independent URL
1113 (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
1114 (?:www\.)?deturl\.com/www\.youtube\.com|
1115 (?:www\.)?pwnyoutube\.com|
1116 (?:www\.)?hooktube\.com|
1117 (?:www\.)?yourepeat\.com|
1118 tube\.majestyc\.net|
1120 youtube\.googleapis\.com)/ # the various hostnames, with wildcard subdomains
1121 (?:.*?\#/)? # handle anchor (#/) redirect urls
1122 (?: # the various things that can precede the ID:
1123 (?:(?:v|embed|e|shorts|live)/(?!videoseries|live_stream)) # v/ or embed/ or e/ or shorts/
1124 |(?: # or the v= param in all its forms
1125 (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
1126 (?:\?|\#!?) # the params delimiter ? or # or #!
1127 (?:.*?[&;])?? # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&v=V36LpHqtcDY)
1132 youtu\.be| # just youtu.be/xxxx
1133 vid\.plus| # or vid.plus/xxxx
1134 zwearz\.com/watch| # or zwearz.com/watch/xxxx
1137 |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
1139 )? # all until now is optional -> you can pass the naked ID
1140 (?P<id>[0-9A-Za-z_-]{11}) # here is it! the YouTube video ID
1141 (?(1).+)? # if we found the ID, everything can follow
1143 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
1148 <(?:[0-9A-Za-z-]+?)?iframe[^>]+?src=|
1156 (?P
<url
>(?
:https?
:)?
//(?
:www\
.)?
youtube(?
:-nocookie
)?\
.com
/
1157 (?
:embed|v|p
)/[0-9A
-Za
-z_
-]{11}
.*?
)
1159 # https://wordpress.org/plugins/lazy-load-for-videos/
1161 <a\s
[^
>]*\bhref
="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"
1162 \s
[^
>]*\bclass
="[^"]*\blazy
-load
-youtube
''',
1164 _RETURN_TYPE = 'video' # XXX: How to handle multifeed?
1167 r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
1168 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$',
1169 r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
1172 '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1173 '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1174 '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
1175 '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
1176 '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
1177 '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1178 '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1179 '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1180 # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
1181 '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
1182 '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1183 '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1184 '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1185 '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1186 '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1187 '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1188 '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1189 '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1193 '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1194 '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1195 '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1196 '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1197 '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
1198 '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1199 '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1201 # Apple HTTP Live Streaming
1202 '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1203 '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1204 '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1205 '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1206 '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1207 '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1208 '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1209 '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
1212 '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
1213 '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
1214 '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1215 '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
1216 '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
1217 '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'}, # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
1218 '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
1219 '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1220 '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
1221 '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1222 '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1223 '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
1226 '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
1227 '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
1228 '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
1229 '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1230 '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1231 '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
1232 '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
1235 '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1236 '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1237 '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1238 '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1239 '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1240 '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1241 '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
1242 '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1243 '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1244 '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1245 '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1246 '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1247 '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1248 '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1249 '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1250 # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
1251 '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1252 '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1253 '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1254 '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1255 '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1256 '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1259 '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
1260 '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
1262 # Dash webm audio with opus inside
1263 '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
1264 '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
1265 '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
1268 '_rtmp': {'protocol': 'rtmp'},
1270 # av01 video only formats sometimes served with "unknown" codecs
1271 '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1272 '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1273 '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1274 '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1275 '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1276 '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1277 '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1278 '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1280 _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1287 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1289 'id': 'BaW_jenozKc',
1291 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1292 'channel': 'Philipp Hagemeister',
1293 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1294 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1295 'upload_date': '20121002',
1296 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1297 'categories': ['Science & Technology'],
1298 'tags': ['youtube-dl'],
1302 'availability': 'public',
1303 'playable_in_embed': True,
1304 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1305 'live_status': 'not_live',
1309 'comment_count': int,
1310 'channel_follower_count': int,
1311 'uploader': 'Philipp Hagemeister',
1312 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1313 'uploader_id': '@PhilippHagemeister',
1314 'heatmap': 'count:100',
1318 'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1319 'note': 'Embed-only video (#1746)',
1321 'id': 'yZIXLfi8CZQ',
1323 'upload_date': '20120608',
1324 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1325 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1328 'skip': 'Private video',
1331 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1332 'note': 'Use the first video ID in the URL',
1334 'id': 'BaW_jenozKc',
1336 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1337 'channel': 'Philipp Hagemeister',
1338 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1339 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1340 'upload_date': '20121002',
1341 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1342 'categories': ['Science & Technology'],
1343 'tags': ['youtube-dl'],
1347 'availability': 'public',
1348 'playable_in_embed': True,
1349 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1350 'live_status': 'not_live',
1352 'comment_count': int,
1353 'channel_follower_count': int,
1354 'uploader': 'Philipp Hagemeister',
1355 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1356 'uploader_id': '@PhilippHagemeister',
1357 'heatmap': 'count:100',
1360 'skip_download': True,
1364 'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1365 'note': '256k DASH audio (format 141) via DASH manifest',
1367 'id': 'a9LDPn-MO4I',
1369 'upload_date': '20121002',
1371 'title': 'UHDTV TEST 8K VIDEO.mp4'
1374 'youtube_include_dash_manifest': True,
1377 'skip': 'format 141 not served anymore',
1379 # DASH manifest with encrypted signature
1381 'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1383 'id': 'IB3lcPjvWLA',
1385 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1386 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1388 'upload_date': '20131011',
1391 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1392 'playable_in_embed': True,
1393 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1395 'track': 'The Spark',
1396 'live_status': 'not_live',
1397 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1398 'channel': 'Afrojack',
1400 'availability': 'public',
1401 'categories': ['Music'],
1403 'alt_title': 'The Spark',
1404 'channel_follower_count': int,
1405 'uploader': 'Afrojack',
1406 'uploader_url': 'https://www.youtube.com/@Afrojack',
1407 'uploader_id': '@Afrojack',
1410 'youtube_include_dash_manifest': True,
1411 'format': '141/bestaudio[ext=m4a]',
1414 # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1416 'note': 'Embed allowed age-gate video',
1417 'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1419 'id': 'HtVdAasjOgU',
1421 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1422 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1424 'upload_date': '20140605',
1426 'categories': ['Gaming'],
1427 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1428 'availability': 'needs_auth',
1429 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1431 'channel': 'The Witcher',
1432 'live_status': 'not_live',
1434 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1435 'playable_in_embed': True,
1437 'channel_follower_count': int,
1438 'uploader': 'The Witcher',
1439 'uploader_url': 'https://www.youtube.com/@thewitcher',
1440 'uploader_id': '@thewitcher',
1441 'comment_count': int,
1442 'channel_is_verified': True,
1443 'heatmap': 'count:100',
1447 'note': 'Age-gate video with embed allowed in public site',
1448 'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1450 'id': 'HsUATh_Nc2U',
1452 'title': 'Godzilla 2 (Official Video)',
1453 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1454 'upload_date': '20200408',
1456 'availability': 'needs_auth',
1457 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1458 'channel': 'FlyingKitty',
1459 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1461 'categories': ['Entertainment'],
1462 'live_status': 'not_live',
1463 'tags': ['Flyingkitty', 'godzilla 2'],
1464 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1467 'playable_in_embed': True,
1468 'channel_follower_count': int,
1469 'uploader': 'FlyingKitty',
1470 'uploader_url': 'https://www.youtube.com/@FlyingKitty900',
1471 'uploader_id': '@FlyingKitty900',
1472 'comment_count': int,
1473 'channel_is_verified': True,
1477 'note': 'Age-gate video embedable only with clientScreen=EMBED',
1478 'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1480 'id': 'Tq92D6wQ1mg',
1481 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1483 'upload_date': '20191228',
1484 'description': 'md5:17eccca93a786d51bc67646756894066',
1487 'availability': 'needs_auth',
1488 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1490 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1491 'channel': 'Projekt Melody',
1492 'live_status': 'not_live',
1493 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1494 'playable_in_embed': True,
1495 'categories': ['Entertainment'],
1497 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1498 'comment_count': int,
1499 'channel_follower_count': int,
1500 'uploader': 'Projekt Melody',
1501 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
1502 'uploader_id': '@ProjektMelody',
1506 'note': 'Non-Agegated non-embeddable video',
1507 'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1509 'id': 'MeJVWBSsPAY',
1511 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1512 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1513 'upload_date': '20130730',
1514 'track': 'Such mich find mich',
1516 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1518 'playable_in_embed': False,
1519 'creator': 'OOMPH!',
1520 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1522 'alt_title': 'Such mich find mich',
1524 'channel': 'Herr Lurik',
1525 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1526 'categories': ['Music'],
1527 'availability': 'public',
1528 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1529 'live_status': 'not_live',
1531 'channel_follower_count': int,
1532 'uploader': 'Herr Lurik',
1533 'uploader_url': 'https://www.youtube.com/@HerrLurik',
1534 'uploader_id': '@HerrLurik',
1538 'note': 'Non-bypassable age-gated video',
1539 'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1540 'only_matching': True,
1542 # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1543 # YouTube Red ad is not captured for creator
1545 'url': '__2ABJjxzNo',
1547 'id': '__2ABJjxzNo',
1550 'upload_date': '20100430',
1551 'creator': 'deadmau5',
1552 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1553 'title': 'Deadmau5 - Some Chords (HD)',
1554 'alt_title': 'Some Chords',
1555 'availability': 'public',
1557 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1559 'live_status': 'not_live',
1560 'channel': 'deadmau5',
1561 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1563 'track': 'Some Chords',
1564 'artist': 'deadmau5',
1565 'playable_in_embed': True,
1567 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1568 'categories': ['Music'],
1569 'album': 'Some Chords',
1570 'channel_follower_count': int,
1571 'uploader': 'deadmau5',
1572 'uploader_url': 'https://www.youtube.com/@deadmau5',
1573 'uploader_id': '@deadmau5',
1575 'expected_warnings': [
1576 'DASH manifest missing',
1579 # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1581 'url': 'lqQg6PlCWgI',
1583 'id': 'lqQg6PlCWgI',
1586 'upload_date': '20150827',
1587 'description': 'md5:04bbbf3ccceb6795947572ca36f45904',
1588 'title': 'Hockey - Women - GER-AUS - London 2012 Olympic Games',
1590 'release_timestamp': 1343767800,
1591 'playable_in_embed': True,
1592 'categories': ['Sports'],
1593 'release_date': '20120731',
1594 'channel': 'Olympics',
1595 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1596 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1597 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1599 'availability': 'public',
1600 'live_status': 'was_live',
1602 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1603 'channel_follower_count': int,
1604 'uploader': 'Olympics',
1605 'uploader_url': 'https://www.youtube.com/@Olympics',
1606 'uploader_id': '@Olympics',
1607 'channel_is_verified': True,
1610 'skip_download': 'requires avconv',
1615 'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1617 'id': '_b-2C3KPAM0',
1619 'stretched_ratio': 16 / 9.,
1621 'upload_date': '20110310',
1622 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1623 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1624 'playable_in_embed': True,
1628 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1629 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1630 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1632 'categories': ['People & Blogs'],
1634 'live_status': 'not_live',
1635 'availability': 'unlisted',
1636 'comment_count': int,
1637 'channel_follower_count': int,
1639 'uploader_url': 'https://www.youtube.com/@AllenMeow',
1640 'uploader_id': '@AllenMeow',
1643 # url_encoded_fmt_stream_map is empty string
1645 'url': 'qEJwOuvDf7I',
1647 'id': 'qEJwOuvDf7I',
1649 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1651 'upload_date': '20150404',
1654 'skip_download': 'requires avconv',
1656 'skip': 'This live event has ended.',
1658 # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1660 'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1662 'id': 'FIl7x6_3R5Y',
1664 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1665 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1667 'upload_date': '20150625',
1668 'formats': 'mincount:31',
1670 'skip': 'not actual anymore',
1672 # DASH manifest with segment_list
1674 'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1675 'md5': '8ce563a1d667b599d21064e982ab9e31',
1677 'id': 'CsmdDsKjzN8',
1679 'upload_date': '20150501', # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1680 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1681 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1684 'youtube_include_dash_manifest': True,
1685 'format': '135', # bestvideo
1687 'skip': 'This live event has ended.',
1690 # Multifeed videos (multiple cameras), URL can be of any Camera
1691 # TODO: fix multifeed titles
1692 'url': 'https://www.youtube.com/watch?v=zaPI8MvL8pg',
1694 'id': 'zaPI8MvL8pg',
1695 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04',
1696 'description': 'md5:563ccbc698b39298481ca3c571169519',
1700 'id': 'j5yGuxZ8lLU',
1702 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Chris)',
1703 'description': 'md5:563ccbc698b39298481ca3c571169519',
1705 'channel_follower_count': int,
1706 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1707 'availability': 'public',
1708 'playable_in_embed': True,
1709 'upload_date': '20131105',
1710 'categories': ['Gaming'],
1711 'live_status': 'was_live',
1713 'release_timestamp': 1383701910,
1714 'thumbnail': 'https://i.ytimg.com/vi/j5yGuxZ8lLU/maxresdefault.jpg',
1715 'comment_count': int,
1718 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1719 'channel': 'WiiLikeToPlay',
1721 'release_date': '20131106',
1722 'uploader': 'WiiLikeToPlay',
1723 'uploader_id': '@WLTP',
1724 'uploader_url': 'https://www.youtube.com/@WLTP',
1728 'id': 'zaPI8MvL8pg',
1730 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Tyson)',
1731 'availability': 'public',
1732 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1733 'channel': 'WiiLikeToPlay',
1734 'channel_follower_count': int,
1735 'description': 'md5:563ccbc698b39298481ca3c571169519',
1740 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1741 'release_timestamp': 1383701915,
1742 'comment_count': int,
1743 'upload_date': '20131105',
1744 'thumbnail': 'https://i.ytimg.com/vi/zaPI8MvL8pg/maxresdefault.jpg',
1745 'release_date': '20131106',
1746 'playable_in_embed': True,
1747 'live_status': 'was_live',
1748 'categories': ['Gaming'],
1750 'uploader': 'WiiLikeToPlay',
1751 'uploader_id': '@WLTP',
1752 'uploader_url': 'https://www.youtube.com/@WLTP',
1756 'id': 'R7r3vfO7Hao',
1758 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Spencer)',
1759 'thumbnail': 'https://i.ytimg.com/vi/R7r3vfO7Hao/maxresdefault.jpg',
1760 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1762 'availability': 'public',
1763 'playable_in_embed': True,
1764 'upload_date': '20131105',
1765 'description': 'md5:563ccbc698b39298481ca3c571169519',
1766 'channel_follower_count': int,
1768 'release_date': '20131106',
1769 'comment_count': int,
1770 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1771 'channel': 'WiiLikeToPlay',
1772 'categories': ['Gaming'],
1773 'release_timestamp': 1383701914,
1774 'live_status': 'was_live',
1778 'uploader': 'WiiLikeToPlay',
1779 'uploader_id': '@WLTP',
1780 'uploader_url': 'https://www.youtube.com/@WLTP',
1783 'params': {'skip_download': True},
1786 # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1787 'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1789 'id': 'gVfLd0zydlo',
1790 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1792 'playlist_count': 2,
1793 'skip': 'Not multifeed anymore',
1796 'url': 'https://vid.plus/FlRa-iH7PGw',
1797 'only_matching': True,
1800 'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1801 'only_matching': True,
1804 # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1805 # Also tests cut-off URL expansion in video description (see
1806 # https://github.com/ytdl-org/youtube-dl/issues/1892,
1807 # https://github.com/ytdl-org/youtube-dl/issues/8164)
1808 'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1810 'id': 'lsguqyKfVQg',
1812 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1813 'alt_title': 'Dark Walk',
1814 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1816 'upload_date': '20151119',
1817 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1818 'track': 'Dark Walk',
1819 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1820 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1821 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1822 'categories': ['Film & Animation'],
1824 'live_status': 'not_live',
1825 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1826 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1828 'availability': 'public',
1829 'channel': 'IronSoulElf',
1830 'playable_in_embed': True,
1833 'channel_follower_count': int
1836 'skip_download': True,
1840 # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1841 'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1842 'only_matching': True,
1845 # Video with yt:stretch=17:0
1846 'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1848 'id': 'Q39EVAstoRM',
1850 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1851 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1852 'upload_date': '20151107',
1855 'skip_download': True,
1857 'skip': 'This video does not exist.',
1860 # Video with incomplete 'yt:stretch=16:'
1861 'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1862 'only_matching': True,
1865 # Video licensed under Creative Commons
1866 'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1868 'id': 'M4gD1WSo5mA',
1870 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1871 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1873 'upload_date': '20150128',
1874 'license': 'Creative Commons Attribution license (reuse allowed)',
1875 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1876 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1879 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1880 'channel': 'The Berkman Klein Center for Internet & Society',
1881 'availability': 'public',
1883 'categories': ['Education'],
1884 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1885 'live_status': 'not_live',
1886 'playable_in_embed': True,
1887 'channel_follower_count': int,
1889 'uploader': 'The Berkman Klein Center for Internet & Society',
1890 'uploader_id': '@BKCHarvard',
1891 'uploader_url': 'https://www.youtube.com/@BKCHarvard',
1894 'skip_download': True,
1898 'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1900 'id': 'eQcmzGIKrzg',
1902 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1903 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1905 'upload_date': '20151120',
1906 'license': 'Creative Commons Attribution license (reuse allowed)',
1907 'playable_in_embed': True,
1910 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1912 'availability': 'public',
1913 'categories': ['News & Politics'],
1914 'channel': 'Bernie Sanders',
1915 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1917 'live_status': 'not_live',
1918 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1919 'comment_count': int,
1920 'channel_follower_count': int,
1922 'uploader': 'Bernie Sanders',
1923 'uploader_url': 'https://www.youtube.com/@BernieSanders',
1924 'uploader_id': '@BernieSanders',
1925 'channel_is_verified': True,
1926 'heatmap': 'count:100',
1929 'skip_download': True,
1933 'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;v=V36LpHqtcDY',
1934 'only_matching': True,
1937 # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1938 'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1939 'only_matching': True,
1942 # Rental video preview
1943 'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1945 'id': 'uGpuVWrhIzE',
1947 'title': 'Piku - Trailer',
1948 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1949 'upload_date': '20150811',
1950 'license': 'Standard YouTube License',
1953 'skip_download': True,
1955 'skip': 'This video is not available.',
1958 # YouTube Red video with episode data
1959 'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1961 'id': 'iqKdEhx-dD4',
1963 'title': 'Isolation - Mind Field (Ep 1)',
1964 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1966 'upload_date': '20170118',
1967 'series': 'Mind Field',
1969 'episode_number': 1,
1970 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1973 'availability': 'public',
1975 'channel': 'Vsauce',
1976 'episode': 'Episode 1',
1977 'categories': ['Entertainment'],
1978 'season': 'Season 1',
1979 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
1980 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
1982 'playable_in_embed': True,
1983 'live_status': 'not_live',
1984 'channel_follower_count': int,
1985 'uploader': 'Vsauce',
1986 'uploader_url': 'https://www.youtube.com/@Vsauce',
1987 'uploader_id': '@Vsauce',
1988 'comment_count': int,
1989 'channel_is_verified': True,
1992 'skip_download': True,
1994 'expected_warnings': [
1995 'Skipping DASH manifest',
1999 # The following content has been identified by the YouTube community
2000 # as inappropriate or offensive to some audiences.
2001 'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
2003 'id': '6SJNVb0GnPI',
2005 'title': 'Race Differences in Intelligence',
2006 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
2008 'upload_date': '20140124',
2011 'skip_download': True,
2013 'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
2017 'url': '1t24XAntNCY',
2018 'only_matching': True,
2021 # geo restricted to JP
2022 'url': 'sJL6WA-aGkQ',
2023 'only_matching': True,
2026 'url': 'https://invidio.us/watch?v=BaW_jenozKc',
2027 'only_matching': True,
2030 'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
2031 'only_matching': True,
2034 # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
2035 'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
2036 'only_matching': True,
2040 'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
2041 'only_matching': True,
2044 # Video with unsupported adaptive stream type formats
2045 'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
2047 'id': 'Z4Vy8R84T1U',
2049 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
2050 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
2052 'upload_date': '20130923',
2053 'formats': 'maxcount:10',
2056 'skip_download': True,
2057 'youtube_include_dash_manifest': False,
2059 'skip': 'not actual anymore',
2062 # Youtube Music Auto-generated description
2063 # TODO: fix metadata extraction
2064 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2066 'id': 'MgNrAu2pzNs',
2068 'title': 'Voyeur Girl',
2069 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
2070 'upload_date': '20190312',
2071 'artists': ['Stephen'],
2072 'creators': ['Stephen'],
2073 'track': 'Voyeur Girl',
2074 'album': 'it\'s too much love to know my dear',
2075 'release_date': '20190313',
2076 'alt_title': 'Voyeur Girl',
2078 'playable_in_embed': True,
2080 'categories': ['Music'],
2081 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
2082 'channel': 'Stephen', # TODO: should be "Stephen - Topic"
2083 'uploader': 'Stephen',
2084 'availability': 'public',
2086 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
2088 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
2090 'live_status': 'not_live',
2091 'channel_follower_count': int
2094 'skip_download': True,
2098 'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
2099 'only_matching': True,
2102 # invalid -> valid video id redirection
2103 'url': 'DJztXj2GPfl',
2105 'id': 'DJztXj2GPfk',
2107 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
2108 'description': 'md5:bf577a41da97918e94fa9798d9228825',
2109 'upload_date': '20090125',
2110 'artist': 'Panjabi MC',
2111 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
2112 'album': 'Beware of the Boys (Mundian To Bach Ke)',
2115 'skip_download': True,
2117 'skip': 'Video unavailable',
2120 # empty description results in an empty string
2121 'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
2123 'id': 'x41yOUIvK2k',
2125 'title': 'IMG 3456',
2127 'upload_date': '20170613',
2129 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
2131 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
2133 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
2134 'availability': 'public',
2136 'categories': ['Pets & Animals'],
2138 'playable_in_embed': True,
2139 'live_status': 'not_live',
2140 'channel': 'l\'Or Vert asbl',
2141 'channel_follower_count': int,
2142 'uploader': 'l\'Or Vert asbl',
2143 'uploader_url': 'https://www.youtube.com/@ElevageOrVert',
2144 'uploader_id': '@ElevageOrVert',
2147 'skip_download': True,
2151 # with '};' inside yt initial data (see [1])
2152 # see [2] for an example with '};' inside ytInitialPlayerResponse
2153 # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
2154 # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
2155 'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
2157 'id': 'CHqg6qOn4no',
2159 'title': 'Part 77 Sort a list of simple types in c#',
2160 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
2161 'upload_date': '20130831',
2162 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
2164 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
2165 'live_status': 'not_live',
2166 'categories': ['Education'],
2167 'availability': 'public',
2168 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
2170 'playable_in_embed': True,
2174 'channel': 'kudvenkat',
2175 'comment_count': int,
2176 'channel_follower_count': int,
2178 'uploader': 'kudvenkat',
2179 'uploader_url': 'https://www.youtube.com/@Csharp-video-tutorialsBlogspot',
2180 'uploader_id': '@Csharp-video-tutorialsBlogspot',
2181 'channel_is_verified': True,
2182 'heatmap': 'count:100',
2185 'skip_download': True,
2189 # another example of '};' in ytInitialData
2190 'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
2191 'only_matching': True,
2194 'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
2195 'only_matching': True,
2198 # https://github.com/ytdl-org/youtube-dl/pull/28094
2199 'url': 'OtqTfy26tG0',
2201 'id': 'OtqTfy26tG0',
2203 'title': 'Burn Out',
2204 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
2205 'upload_date': '20141120',
2206 'artist': 'The Cinematic Orchestra',
2207 'track': 'Burn Out',
2208 'album': 'Every Day',
2210 'live_status': 'not_live',
2211 'alt_title': 'Burn Out',
2215 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2216 'creator': 'The Cinematic Orchestra',
2217 'channel': 'The Cinematic Orchestra',
2218 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
2219 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2220 'availability': 'public',
2221 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
2222 'categories': ['Music'],
2223 'playable_in_embed': True,
2224 'channel_follower_count': int,
2225 'uploader': 'The Cinematic Orchestra',
2226 'comment_count': int,
2229 'skip_download': True,
2233 # controversial video, only works with bpctr when authenticated with cookies
2234 'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
2235 'only_matching': True,
2238 # controversial video, requires bpctr/contentCheckOk
2239 'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
2241 'id': 'SZJvDhaSDnc',
2243 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
2244 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
2245 'upload_date': '20140716',
2246 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
2248 'categories': ['News & Politics'],
2250 'channel': 'CBS Mornings',
2251 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
2252 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
2254 'availability': 'needs_auth',
2255 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
2257 'live_status': 'not_live',
2258 'playable_in_embed': True,
2259 'channel_follower_count': int,
2260 'uploader': 'CBS Mornings',
2261 'uploader_url': 'https://www.youtube.com/@CBSMornings',
2262 'uploader_id': '@CBSMornings',
2263 'comment_count': int,
2264 'channel_is_verified': True,
2268 # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
2269 'url': 'cBvYw8_A0vQ',
2271 'id': 'cBvYw8_A0vQ',
2273 'title': '4K Ueno Okachimachi Street Scenes 上野御徒町歩き',
2274 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
2275 'upload_date': '20201120',
2277 'categories': ['Travel & Events'],
2278 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2280 'channel': 'Walk around Japan',
2281 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
2282 'thumbnail': 'https://i.ytimg.com/vi_webp/cBvYw8_A0vQ/hqdefault.webp',
2284 'availability': 'public',
2285 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2286 'live_status': 'not_live',
2287 'playable_in_embed': True,
2288 'channel_follower_count': int,
2289 'uploader': 'Walk around Japan',
2290 'uploader_url': 'https://www.youtube.com/@walkaroundjapan7124',
2291 'uploader_id': '@walkaroundjapan7124',
2294 'skip_download': True,
2297 # Has multiple audio streams
2298 'url': 'WaOKSUlf4TM',
2299 'only_matching': True
2301 # Requires Premium: has format 141 when requested using YTM url
2302 'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2303 'only_matching': True
2305 # multiple subtitles with same lang_code
2306 'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2307 'only_matching': True,
2309 # Force use android client fallback
2310 'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2312 'id': 'YOelRv7fMxY',
2313 'title': 'DIGGING A SECRET TUNNEL Part 1',
2315 'upload_date': '20210624',
2316 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2317 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2318 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2320 'categories': ['Entertainment'],
2322 'channel': 'colinfurze',
2323 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2324 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2326 'availability': 'public',
2328 'live_status': 'not_live',
2329 'playable_in_embed': True,
2330 'channel_follower_count': int,
2332 'uploader': 'colinfurze',
2333 'uploader_url': 'https://www.youtube.com/@colinfurze',
2334 'uploader_id': '@colinfurze',
2335 'comment_count': int,
2336 'channel_is_verified': True,
2337 'heatmap': 'count:100',
2340 'format': '17', # 3gp format available on android
2341 'extractor_args': {'youtube': {'player_client': ['android']}},
2345 # Skip download of additional client configs (remix client config in this case)
2346 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2347 'only_matching': True,
2349 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2353 'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2354 'only_matching': True,
2356 'note': 'Storyboards',
2357 'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2359 'id': '5KLPxDtMqe8',
2362 'title': 'Your Brain is Plastic',
2363 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2364 'upload_date': '20140324',
2366 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2367 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2369 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2370 'playable_in_embed': True,
2372 'availability': 'public',
2373 'channel': 'SciShow',
2374 'live_status': 'not_live',
2376 'categories': ['Education'],
2378 'channel_follower_count': int,
2380 'uploader': 'SciShow',
2381 'uploader_url': 'https://www.youtube.com/@SciShow',
2382 'uploader_id': '@SciShow',
2383 'comment_count': int,
2384 'channel_is_verified': True,
2385 'heatmap': 'count:100',
2386 }, 'params': {'format': 'mhtml', 'skip_download': True}
2388 # Ensure video upload_date is in UTC timezone (video was uploaded 1641170939)
2389 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2391 'id': '2NUZ8W2llS4',
2393 'title': 'The NP that test your phone performance 🙂',
2394 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2395 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2396 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2400 'categories': ['Gaming'],
2402 'playable_in_embed': True,
2403 'live_status': 'not_live',
2404 'upload_date': '20220103',
2406 'availability': 'public',
2407 'channel': 'Leon Nguyen',
2408 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2409 'comment_count': int,
2410 'channel_follower_count': int,
2411 'uploader': 'Leon Nguyen',
2412 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2413 'uploader_id': '@LeonNguyen',
2414 'heatmap': 'count:100',
2417 # Same video as above, but with --compat-opt no-youtube-prefer-utc-upload-date
2418 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2420 'id': '2NUZ8W2llS4',
2422 'title': 'The NP that test your phone performance 🙂',
2423 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2424 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2425 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2429 'categories': ['Gaming'],
2431 'playable_in_embed': True,
2432 'live_status': 'not_live',
2433 'upload_date': '20220102',
2435 'availability': 'public',
2436 'channel': 'Leon Nguyen',
2437 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2438 'comment_count': int,
2439 'channel_follower_count': int,
2440 'uploader': 'Leon Nguyen',
2441 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2442 'uploader_id': '@LeonNguyen',
2443 'heatmap': 'count:100',
2445 'params': {'compat_opts': ['no-youtube-prefer-utc-upload-date']}
2447 # date text is premiered video, ensure upload date in UTC (published 1641172509)
2448 'url': 'https://www.youtube.com/watch?v=mzZzzBU6lrM',
2450 'id': 'mzZzzBU6lrM',
2452 'title': 'I Met GeorgeNotFound In Real Life...',
2453 'description': 'md5:978296ec9783a031738b684d4ebf302d',
2454 'channel_id': 'UC_8NknAFiyhOUaZqHR3lq3Q',
2455 'channel_url': 'https://www.youtube.com/channel/UC_8NknAFiyhOUaZqHR3lq3Q',
2459 'categories': ['Entertainment'],
2461 'playable_in_embed': True,
2462 'live_status': 'not_live',
2463 'release_timestamp': 1641172509,
2464 'release_date': '20220103',
2465 'upload_date': '20220103',
2467 'availability': 'public',
2468 'channel': 'Quackity',
2469 'thumbnail': 'https://i.ytimg.com/vi/mzZzzBU6lrM/maxresdefault.jpg',
2470 'channel_follower_count': int,
2471 'uploader': 'Quackity',
2472 'uploader_id': '@Quackity',
2473 'uploader_url': 'https://www.youtube.com/@Quackity',
2474 'comment_count': int,
2475 'channel_is_verified': True,
2476 'heatmap': 'count:100',
2479 { # continuous livestream. Microformat upload date should be preferred.
2480 # Upload date was 2021-06-19 (not UTC), while stream start is 2021-11-27
2481 'url': 'https://www.youtube.com/watch?v=kgx4WGK0oNU',
2483 'id': 'kgx4WGK0oNU',
2484 '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}',
2486 'channel_id': 'UC84whx2xxsiA1gXHXXqKGOA',
2487 'availability': 'public',
2489 'release_timestamp': 1637975704,
2490 'upload_date': '20210619',
2491 'channel_url': 'https://www.youtube.com/channel/UC84whx2xxsiA1gXHXXqKGOA',
2492 'live_status': 'is_live',
2493 'thumbnail': 'https://i.ytimg.com/vi/kgx4WGK0oNU/maxresdefault.jpg',
2494 'channel': 'Abao in Tokyo',
2495 'channel_follower_count': int,
2496 'release_date': '20211127',
2498 'categories': ['People & Blogs'],
2501 'playable_in_embed': True,
2502 'description': 'md5:2ef1d002cad520f65825346e2084e49d',
2503 'concurrent_view_count': int,
2504 'uploader': 'Abao in Tokyo',
2505 'uploader_url': 'https://www.youtube.com/@abaointokyo',
2506 'uploader_id': '@abaointokyo',
2508 'params': {'skip_download': True}
2510 'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2512 'id': 'tjjjtzRLHvA',
2514 'title': 'ハッシュタグ無し };if window.ytcsi',
2515 'upload_date': '20220323',
2517 'availability': 'unlisted',
2518 'channel': 'Lesmiscore',
2519 'thumbnail': r're:^https?://.*\.jpg',
2521 'categories': ['Music'],
2524 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2525 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2526 'live_status': 'not_live',
2527 'playable_in_embed': True,
2528 'channel_follower_count': int,
2531 'uploader_id': '@lesmiscore',
2532 'uploader': 'Lesmiscore',
2533 'uploader_url': 'https://www.youtube.com/@lesmiscore',
2536 # Prefer primary title+description language metadata by default
2537 # Do not prefer translated description if primary is empty
2538 'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2540 'id': 'el3E4MbxRqQ',
2542 'title': 'dlp test video 2 - primary sv no desc',
2544 'channel': 'cole-dlp-test-acc',
2547 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2549 'playable_in_embed': True,
2550 'availability': 'unlisted',
2551 'thumbnail': r're:^https?://.*\.jpg',
2554 'live_status': 'not_live',
2555 'upload_date': '20220908',
2556 'categories': ['People & Blogs'],
2557 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2558 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2559 'uploader_id': '@coletdjnz',
2560 'uploader': 'cole-dlp-test-acc',
2562 'params': {'skip_download': True}
2564 # Extractor argument: prefer translated title+description
2565 'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2567 'id': 'gHKT4uU8Zng',
2569 'channel': 'cole-dlp-test-acc',
2572 'live_status': 'not_live',
2573 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2574 'upload_date': '20220728',
2576 'categories': ['People & Blogs'],
2577 'thumbnail': r're:^https?://.*\.jpg',
2578 'title': 'dlp test video title translated (fr)',
2579 'availability': 'public',
2581 'description': 'dlp test video description translated (fr)',
2582 'playable_in_embed': True,
2583 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2584 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2585 'uploader_id': '@coletdjnz',
2586 'uploader': 'cole-dlp-test-acc',
2588 'params': {'skip_download': True, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2589 'expected_warnings': [r'Preferring "fr" translated fields'],
2591 'note': '6 channel audio',
2592 'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2593 'only_matching': True,
2595 'note': 'Multiple HLS formats with same itag',
2596 'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2598 'id': 'kX3nB4PpJko',
2600 'categories': ['Entertainment'],
2601 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2602 'live_status': 'not_live',
2604 'channel_follower_count': int,
2605 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2606 'title': 'Last To Take Hand Off Jet, Keeps It!',
2607 'channel': 'MrBeast',
2608 'playable_in_embed': True,
2610 'upload_date': '20221112',
2611 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2613 'availability': 'public',
2614 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2617 'uploader': 'MrBeast',
2618 'uploader_url': 'https://www.youtube.com/@MrBeast',
2619 'uploader_id': '@MrBeast',
2620 'comment_count': int,
2621 'channel_is_verified': True,
2622 'heatmap': 'count:100',
2624 'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2626 'note': 'Audio formats with Dynamic Range Compression',
2627 'url': 'https://www.youtube.com/watch?v=Tq92D6wQ1mg',
2629 'id': 'Tq92D6wQ1mg',
2631 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
2632 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
2633 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
2634 'channel_follower_count': int,
2635 'description': 'md5:17eccca93a786d51bc67646756894066',
2636 'upload_date': '20191228',
2637 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
2638 'playable_in_embed': True,
2640 'categories': ['Entertainment'],
2641 'thumbnail': 'https://i.ytimg.com/vi/Tq92D6wQ1mg/sddefault.jpg',
2643 'channel': 'Projekt Melody',
2645 'availability': 'needs_auth',
2646 'comment_count': int,
2647 'live_status': 'not_live',
2649 'uploader': 'Projekt Melody',
2650 'uploader_id': '@ProjektMelody',
2651 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
2653 'params': {'extractor_args': {'youtube': {'player_client': ['tv_embedded']}}, 'format': '251-drc'},
2656 'url': 'https://www.youtube.com/live/qVv6vCqciTM',
2658 'id': 'qVv6vCqciTM',
2661 'comment_count': int,
2662 'chapters': 'count:13',
2663 'upload_date': '20221223',
2664 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
2665 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
2667 'release_date': '20221223',
2668 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
2669 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
2671 'playable_in_embed': True,
2673 'availability': 'public',
2674 'channel_follower_count': int,
2675 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
2676 'categories': ['Entertainment'],
2677 'live_status': 'was_live',
2678 'release_timestamp': 1671793345,
2679 'channel': 'さなちゃんねる',
2680 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
2681 'uploader': 'さなちゃんねる',
2682 'uploader_url': 'https://www.youtube.com/@sana_natori',
2683 'uploader_id': '@sana_natori',
2684 'channel_is_verified': True,
2685 'heatmap': 'count:100',
2689 # Fallbacks when webpage and web client is unavailable
2690 'url': 'https://www.youtube.com/watch?v=wSSmNUl9Snw',
2692 'id': 'wSSmNUl9Snw',
2694 # 'categories': ['Science & Technology'],
2696 'chapters': 'count:2',
2697 'channel': 'Scott Manley',
2700 # 'availability': 'public',
2701 'channel_follower_count': int,
2702 'live_status': 'not_live',
2703 'upload_date': '20170831',
2706 'uploader_url': 'https://www.youtube.com/@scottmanley',
2707 'description': 'md5:f4bed7b200404b72a394c2f97b782c02',
2708 'uploader': 'Scott Manley',
2709 'uploader_id': '@scottmanley',
2710 'title': 'The Computer Hack That Saved Apollo 14',
2711 'channel_id': 'UCxzC4EngIsMrPmbm6Nxvb-A',
2712 'thumbnail': r're:^https?://.*\.webp',
2713 'channel_url': 'https://www.youtube.com/channel/UCxzC4EngIsMrPmbm6Nxvb-A',
2714 'playable_in_embed': True,
2715 'comment_count': int,
2716 'channel_is_verified': True,
2717 'heatmap': 'count:100',
2720 'extractor_args': {'youtube': {'player_client': ['android'], 'player_skip': ['webpage']}},
2726 # YouTube <object> embed
2728 'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2729 'md5': '873c81d308b979f0e23ee7e620b312a3',
2731 'id': 'msN87y-iEx0',
2733 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2734 'upload_date': '20080526',
2735 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2737 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2738 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2739 'playable_in_embed': True,
2740 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2742 'comment_count': int,
2743 'channel': 'Christopher Sykes',
2744 'live_status': 'not_live',
2745 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2746 'availability': 'public',
2749 'categories': ['Science & Technology'],
2750 'channel_follower_count': int,
2751 'uploader': 'Christopher Sykes',
2752 'uploader_url': 'https://www.youtube.com/@ChristopherSykesDocumentaries',
2753 'uploader_id': '@ChristopherSykesDocumentaries',
2754 'heatmap': 'count:100',
2757 'skip_download': True,
2763 def suitable(cls, url):
2764 from ..utils import parse_qs
2767 if qs.get('list', [None])[0]:
2769 return super().suitable(url)
2771 def __init__(self, *args, **kwargs):
2772 super().__init__(*args, **kwargs)
2773 self._code_cache = {}
2774 self._player_cache = {}
2776 def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2777 lock = threading.Lock()
2778 start_time = time.time()
2779 formats = [f for f in formats if f.get('is_from_start')]
2781 def refetch_manifest(format_id, delay):
2782 nonlocal formats, start_time, is_live
2783 if time.time() <= start_time + delay:
2786 _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2787 video_details = traverse_obj(prs, (..., 'videoDetails'), expected_type=dict)
2788 microformats = traverse_obj(
2789 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2791 _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2792 is_live = live_status == 'is_live'
2793 start_time = time.time()
2795 def mpd_feed(format_id, delay):
2797 @returns (manifest_url, manifest_stream_number, is_live) or None
2799 for retry in self.RetryManager(fatal=False):
2801 refetch_manifest(format_id, delay)
2803 f = next((f for f in formats if f['format_id'] == format_id), None)
2806 retry.error = f'{video_id}: Video is no longer live'
2808 retry.error = f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}'
2810 return f['manifest_url'], f['manifest_stream_number'], is_live
2814 f['is_live'] = is_live
2815 gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2816 live_start_time, mpd_feed, not is_live and f.copy())
2818 f['fragments'] = gen
2819 f['protocol'] = 'http_dash_segments_generator'
2821 f['fragments'] = LazyList(gen({}))
2822 del f['is_from_start']
2824 def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2825 FETCH_SPAN, MAX_DURATION = 5, 432000
2827 mpd_url, stream_number, is_live = None, None, True
2830 download_start_time = ctx.get('start') or time.time()
2832 lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2833 if lack_early_segments:
2834 self.report_warning(bug_reports_message(
2835 'Starting download from the last 120 hours of the live stream since '
2836 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2837 lack_early_segments = True
2839 known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2840 fragments, fragment_base_url = None, None
2842 def _extract_sequence_from_mpd(refresh_sequence, immediate):
2843 nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2844 # Obtain from MPD's maximum seq value
2845 old_mpd_url = mpd_url
2846 last_error = ctx.pop('last_error', None)
2847 expire_fast = immediate or last_error and isinstance(last_error, HTTPError) and last_error.status == 403
2848 mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2849 or (mpd_url, stream_number, False))
2850 if not refresh_sequence:
2851 if expire_fast and not is_live:
2852 return False, last_seq
2853 elif old_mpd_url == mpd_url:
2854 return True, last_seq
2855 if manifestless_orig_fmt:
2856 fmt_info = manifestless_orig_fmt
2859 fmts, _ = self._extract_mpd_formats_and_subtitles(
2860 mpd_url, None, note=False, errnote=False, fatal=False)
2861 except ExtractorError:
2864 no_fragment_score += 2
2865 return False, last_seq
2866 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2867 fragments = fmt_info['fragments']
2868 fragment_base_url = fmt_info['fragment_base_url']
2869 assert fragment_base_url
2871 _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2872 return True, _last_seq
2874 self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2876 fetch_time = time.time()
2877 if no_fragment_score > 30:
2879 if last_segment_url:
2880 # Obtain from "X-Head-Seqnum" header value from each segment
2882 urlh = self._request_webpage(
2883 last_segment_url, None, note=False, errnote=False, fatal=False)
2884 except ExtractorError:
2886 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2887 if last_seq is None:
2888 no_fragment_score += 2
2889 last_segment_url = None
2892 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2893 no_fragment_score += 2
2894 if not should_continue:
2897 if known_idx > last_seq:
2898 last_segment_url = None
2903 if begin_index < 0 and known_idx < 0:
2904 # skip from the start when it's negative value
2905 known_idx = last_seq + begin_index
2906 if lack_early_segments:
2907 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2909 for idx in range(known_idx, last_seq):
2910 # do not update sequence here or you'll get skipped some part of it
2911 should_continue, _ = _extract_sequence_from_mpd(False, False)
2912 if not should_continue:
2914 raise ExtractorError('breaking out of outer loop')
2915 last_segment_url = urljoin(fragment_base_url, 'sq/%d' % idx)
2917 'url': last_segment_url,
2918 'fragment_count': last_seq,
2920 if known_idx == last_seq:
2921 no_fragment_score += 5
2923 no_fragment_score = 0
2924 known_idx = last_seq
2925 except ExtractorError:
2928 if manifestless_orig_fmt:
2929 # Stop at the first iteration if running for post-live manifestless;
2930 # fragment count no longer increase since it starts
2933 time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2935 def _extract_player_url(self, *ytcfgs, webpage=None):
2936 player_url = traverse_obj(
2937 ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2938 get_all=False, expected_type=str)
2941 return urljoin('https://www.youtube.com', player_url)
2943 def _download_player_url(self, video_id, fatal=False):
2944 res = self._download_webpage(
2945 'https://www.youtube.com/iframe_api',
2946 note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2948 player_version = self._search_regex(
2949 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2951 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2953 def _signature_cache_id(self, example_sig):
2954 """ Return a string representation of a signature """
2955 return '.'.join(str(len(part)) for part in example_sig.split('.'))
2958 def _extract_player_info(cls, player_url):
2959 for player_re in cls._PLAYER_INFO_RE:
2960 id_m = re.search(player_re, player_url)
2964 raise ExtractorError('Cannot identify player %r' % player_url)
2965 return id_m.group('id')
2967 def _load_player(self, video_id, player_url, fatal=True):
2968 player_id = self._extract_player_info(player_url)
2969 if player_id not in self._code_cache:
2970 code = self._download_webpage(
2971 player_url, video_id, fatal=fatal,
2972 note='Downloading player ' + player_id,
2973 errnote='Download of %s failed' % player_url)
2975 self._code_cache[player_id] = code
2976 return self._code_cache.get(player_id)
2978 def _extract_signature_function(self, video_id, player_url, example_sig):
2979 player_id = self._extract_player_info(player_url)
2981 # Read from filesystem cache
2982 func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2983 assert os.path.basename(func_id) == func_id
2985 self.write_debug(f'Extracting signature function {func_id}')
2986 cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
2989 code = self._load_player(video_id, player_url)
2991 res = self._parse_sig_js(code)
2992 test_string = ''.join(map(chr, range(len(example_sig))))
2993 cache_spec = [ord(c) for c in res(test_string)]
2994 self.cache.store('youtube-sigfuncs', func_id, cache_spec)
2996 return lambda s: ''.join(s[i] for i in cache_spec)
2998 def _print_sig_code(self, func, example_sig):
2999 if not self.get_param('youtube_print_sig_code'):
3002 def gen_sig_code(idxs):
3003 def _genslice(start, end, step):
3004 starts = '' if start == 0 else str(start)
3005 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
3006 steps = '' if step == 1 else (':%d' % step)
3007 return f's[{starts}{ends}{steps}]'
3010 # Quelch pyflakes warnings - start will be set when step is set
3011 start = '(Never used)'
3012 for i, prev in zip(idxs[1:], idxs[:-1]):
3013 if step is not None:
3014 if i - prev == step:
3016 yield _genslice(start, prev, step)
3019 if i - prev in [-1, 1]:
3024 yield 's[%d]' % prev
3028 yield _genslice(start, i, step)
3030 test_string = ''.join(map(chr, range(len(example_sig))))
3031 cache_res = func(test_string)
3032 cache_spec = [ord(c) for c in cache_res]
3033 expr_code = ' + '.join(gen_sig_code(cache_spec))
3034 signature_id_tuple = '(%s)' % (
3035 ', '.join(str(len(p)) for p in example_sig.split('.')))
3036 code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
3037 ' return %s\n') % (signature_id_tuple, expr_code)
3038 self.to_screen('Extracted signature function:\n' + code)
3040 def _parse_sig_js(self, jscode):
3041 funcname = self._search_regex(
3042 (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3043 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3044 r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
3045 r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
3046 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+\))?',
3047 r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
3049 r'("|\')signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3050 r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
3051 r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3052 r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3053 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3054 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
3055 jscode, 'Initial JS player signature function name', group='sig')
3057 jsi = JSInterpreter(jscode)
3058 initial_function = jsi.extract_function(funcname)
3059 return lambda s: initial_function([s])
3061 def _cached(self, func, *cache_id):
3062 def inner(*args, **kwargs):
3063 if cache_id not in self._player_cache:
3065 self._player_cache[cache_id] = func(*args, **kwargs)
3066 except ExtractorError as e:
3067 self._player_cache[cache_id] = e
3068 except Exception as e:
3069 self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
3071 ret = self._player_cache[cache_id]
3072 if isinstance(ret, Exception):
3077 def _decrypt_signature(self, s, video_id, player_url):
3078 """Turn the encrypted s field into a working signature"""
3079 extract_sig = self._cached(
3080 self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
3081 func = extract_sig(video_id, player_url, s)
3082 self._print_sig_code(func, s)
3085 def _decrypt_nsig(self, s, video_id, player_url):
3086 """Turn the encrypted n field into a working signature"""
3087 if player_url is None:
3088 raise ExtractorError('Cannot decrypt nsig without player_url')
3089 player_url = urljoin('https://www.youtube.com', player_url)
3092 jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
3093 except ExtractorError as e:
3094 raise ExtractorError('Unable to extract nsig function code', cause=e)
3095 if self.get_param('youtube_print_sig_code'):
3096 self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
3099 extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
3100 ret = extract_nsig(jsi, func_code)(s)
3101 except JSInterpreter.Exception as e:
3103 jsi = PhantomJSwrapper(self, timeout=5000)
3104 except ExtractorError:
3106 self.report_warning(
3107 f'Native nsig extraction failed: Trying with PhantomJS\n'
3108 f' n = {s} ; player = {player_url}', video_id)
3109 self.write_debug(e, only_once=True)
3111 args, func_body = func_code
3113 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
3114 video_id=video_id, note='Executing signature code').strip()
3116 self.write_debug(f'Decrypted nsig {s} => {ret}')
3119 def _extract_n_function_name(self, jscode):
3120 funcname, idx = self._search_regex(
3121 r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
3122 jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
3126 return json.loads(js_to_json(self._search_regex(
3127 rf'var {re.escape(funcname)}\s*=\s*(\[.+?\])\s*[,;]', jscode,
3128 f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
3130 def _extract_n_function_code(self, video_id, player_url):
3131 player_id = self._extract_player_info(player_url)
3132 func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
3133 jscode = func_code or self._load_player(video_id, player_url)
3134 jsi = JSInterpreter(jscode)
3137 return jsi, player_id, func_code
3139 func_name = self._extract_n_function_name(jscode)
3142 func_code = self._search_regex(
3143 r'''(?xs
)%s\s
*=\s
*function\s
*\
((?P
<var
>[\w$
]+)\
)\s
*
3144 # NB: The end of the regex is intentionally kept strict
3145 {(?P<code>.+?}\s
*return\
[\w$
]+.join\
(""\
))};''' % func_name,
3146 jscode, 'nsig function', group=('var', 'code'), default=None)
3148 func_code = ([func_code[0]], func_code[1])
3150 self.write_debug('Extracting nsig function with jsinterp')
3151 func_code = jsi.extract_function_code(func_name)
3153 self.cache.store('youtube-nsig', player_id, func_code)
3154 return jsi, player_id, func_code
3156 def _extract_n_function_from_code(self, jsi, func_code):
3157 func = jsi.extract_function_from_code(*func_code)
3159 def extract_nsig(s):
3162 except JSInterpreter.Exception:
3164 except Exception as e:
3165 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
3167 if ret.startswith('enhanced_except_'):
3168 raise JSInterpreter.Exception('Signature function returned an exception')
3173 def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3175 Extract signatureTimestamp (sts)
3176 Required to tell API what sig/player version is in use.
3179 if isinstance(ytcfg, dict):
3180 sts = int_or_none(ytcfg.get('STS'))
3183 # Attempt to extract from player
3184 if player_url is None:
3185 error_msg = 'Cannot extract signature timestamp without player_url.'
3187 raise ExtractorError(error_msg)
3188 self.report_warning(error_msg)
3190 code = self._load_player(video_id, player_url, fatal=fatal)
3192 sts = int_or_none(self._search_regex(
3193 r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3194 'JS player signature timestamp', group='sts', fatal=fatal))
3197 def _mark_watched(self, video_id, player_responses):
3198 for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3199 label = 'fully ' if is_full else ''
3200 url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3201 expected_type=url_or_none)
3203 self.report_warning(f'Unable to mark {label}watched')
3205 parsed_url = urllib.parse.urlparse(url)
3206 qs = urllib.parse.parse_qs(parsed_url.query)
3208 # cpn generation algorithm is reverse engineered from base.js.
3209 # In fact it works even with dummy cpn.
3210 CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3211 cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16))
3213 # # more consistent results setting it to right before the end
3214 video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3219 'cmt': video_length,
3220 'el': 'detailpage', # otherwise defaults to "shorts"
3224 # these seem to mark watchtime "history" in the real world
3225 # they're required, so send in a single value
3231 url = urllib.parse.urlunparse(
3232 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3234 self._download_webpage(
3235 url, video_id, f'Marking {label}watched',
3236 'Unable to mark watched', fatal=False)
3239 def _extract_from_webpage(cls, url, webpage):
3240 # Invidious Instances
3241 # https://github.com/yt-dlp/yt-dlp/issues/195
3242 # https://github.com/iv-org/invidious/pull/1730
3244 r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3247 yield cls.url_result(mobj.group('url'), cls)
3248 raise cls.StopExtraction()
3250 yield from super()._extract_from_webpage(url, webpage)
3252 # lazyYT YouTube embed
3253 for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3254 yield cls.url_result(unescapeHTML(id_), cls, id_)
3256 # Wordpress "YouTube Video Importer" plugin
3257 for m in re.findall(r'''(?x
)<div
[^
>]+
3258 class=(?P
<q1
>[\'"])[^\'"]*\byvii
_single
_video
_player
\b[^
\'"]*(?P=q1)[^>]+
3259 data-video_id=(?P<q2>[\'"])([^
\'"]+)(?P=q2)''', webpage):
3260 yield cls.url_result(m[-1], cls, m[-1])
3263 def extract_id(cls, url):
3264 video_id = cls.get_temp_id(url)
3266 raise ExtractorError(f'Invalid URL: {url}')
3269 def _extract_chapters_from_json(self, data, duration):
3270 chapter_list = traverse_obj(
3272 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3273 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters'
3274 ), expected_type=list)
3276 return self._extract_chapters_helper(
3278 start_function=lambda chapter: float_or_none(
3279 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3280 title_function=lambda chapter: traverse_obj(
3281 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3284 def _extract_chapters_from_engagement_panel(self, data, duration):
3285 content_list = traverse_obj(
3287 ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3289 chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3290 chapter_title = lambda chapter: self._get_text(chapter, 'title')
3292 return next(filter(None, (
3293 self._extract_chapters_helper(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3294 chapter_time, chapter_title, duration)
3295 for contents in content_list)), [])
3297 def _extract_heatmap(self, data):
3298 return traverse_obj(data, (
3299 'frameworkUpdates', 'entityBatchUpdate', 'mutations',
3300 lambda _, v: v['payload']['macroMarkersListEntity']['markersList']['markerType'] == 'MARKER_TYPE_HEATMAP',
3301 'payload', 'macroMarkersListEntity', 'markersList', 'markers', ..., {
3302 'start_time': ('startMillis', {functools.partial(float_or_none, scale=1000)}),
3303 'end_time': {lambda x: (int(x['startMillis']) + int(x['durationMillis'])) / 1000},
3304 'value': ('intensityScoreNormalized', {float_or_none}),
3307 def _extract_comment(self, comment_renderer, parent=None):
3308 comment_id = comment_renderer.get('commentId')
3314 'text': self._get_text(comment_renderer, 'contentText'),
3315 'like_count': self._get_count(comment_renderer, 'voteCount'),
3316 'author_id': traverse_obj(comment_renderer, ('authorEndpoint', 'browseEndpoint', 'browseId', {self.ucid_or_none})),
3317 'author': self._get_text(comment_renderer, 'authorText'),
3318 'author_thumbnail': traverse_obj(comment_renderer, ('authorThumbnail', 'thumbnails', -1, 'url', {url_or_none})),
3319 'parent': parent or 'root',
3322 # Timestamp is an estimate calculated from the current time and time_text
3323 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3324 timestamp = self._parse_time_text(time_text)
3327 # FIXME: non-standard, but we need a way of showing that it is an estimate.
3328 '_time_text': time_text,
3329 'timestamp': timestamp,
3332 info['author_url'] = urljoin(
3333 'https://www.youtube.com', traverse_obj(comment_renderer, ('authorEndpoint', (
3334 ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'))),
3335 expected_type=str, get_all=False))
3337 author_is_uploader = traverse_obj(comment_renderer, 'authorIsChannelOwner')
3338 if author_is_uploader is not None:
3339 info['author_is_uploader'] = author_is_uploader
3341 comment_abr = traverse_obj(
3342 comment_renderer, ('actionButtons', 'commentActionButtonsRenderer'), expected_type=dict)
3343 if comment_abr is not None:
3344 info['is_favorited'] = 'creatorHeart' in comment_abr
3346 badges = self._extract_badges([traverse_obj(comment_renderer, 'authorCommentBadge')])
3347 if self._has_badge(badges, BadgeType.VERIFIED):
3348 info['author_is_verified'] = True
3350 is_pinned = traverse_obj(comment_renderer, 'pinnedCommentBadge')
3352 info['is_pinned'] = True
3356 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3358 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3360 def extract_header(contents):
3361 _continuation = None
3362 for content in contents:
3363 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3364 expected_comment_count = self._get_count(
3365 comments_header_renderer, 'countText', 'commentsCount')
3367 if expected_comment_count is not None:
3368 tracker['est_total'] = expected_comment_count
3369 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3370 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3372 sort_menu_item = try_get(
3373 comments_header_renderer,
3374 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3375 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3377 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3378 if not _continuation:
3381 sort_text = str_or_none(sort_menu_item.get('title'))
3383 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3384 self.to_screen('Sorting comments by %s' % sort_text.lower())
3386 return _continuation
3388 def extract_thread(contents):
3390 tracker['current_page_thread'] = 0
3391 for content in contents:
3392 if not parent and tracker['total_parent_comments'] >= max_parents:
3394 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3395 comment_renderer = get_first(
3396 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3397 expected_type=dict, default={})
3399 comment = self._extract_comment(comment_renderer, parent)
3402 comment_id = comment['id']
3403 if comment.get('is_pinned'):
3404 tracker['pinned_comment_ids'].add(comment_id)
3405 # Sometimes YouTube may break and give us infinite looping comments.
3406 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3407 if comment_id in tracker['seen_comment_ids']:
3408 if comment_id in tracker['pinned_comment_ids'] and not comment.get('is_pinned'):
3409 # Pinned comments may appear a second time in newest first sort
3410 # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3412 self.report_warning(
3413 'Detected YouTube comments looping. Stopping comment extraction '
3414 f'{"for this thread" if parent else ""} as we probably cannot get any more.')
3417 tracker['seen_comment_ids'].add(comment['id'])
3419 tracker['running_total'] += 1
3420 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3423 # Attempt to get the replies
3424 comment_replies_renderer = try_get(
3425 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3427 if comment_replies_renderer:
3428 tracker['current_page_thread'] += 1
3429 comment_entries_iter = self._comment_entries(
3430 comment_replies_renderer, ytcfg, video_id,
3431 parent=comment.get('id'), tracker=tracker)
3432 yield from itertools.islice(comment_entries_iter, min(
3433 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3435 # Keeps track of counts across recursive calls
3440 current_page_thread=0,
3441 total_parent_comments=0,
3442 total_reply_comments=0,
3443 seen_comment_ids=set(),
3444 pinned_comment_ids=set()
3448 # YouTube comments have a max depth of 2
3449 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3451 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3452 'Set max replies in the max-comments extractor argument instead')
3453 if max_depth == 1 and parent:
3456 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
3457 lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
3459 continuation = self._extract_continuation(root_continuation_data)
3462 is_forced_continuation = False
3463 is_first_continuation = parent is None
3464 if is_first_continuation and not continuation:
3465 # Sometimes you can get comments by generating the continuation yourself,
3466 # even if YouTube initially reports them being disabled - e.g. stories comments.
3467 # Note: if the comment section is actually disabled, YouTube may return a response with
3468 # required check_get_keys missing. So we will disable that check initially in this case.
3469 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3470 is_forced_continuation = True
3472 continuation_items_path = (
3473 'onResponseReceivedEndpoints', ..., ('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems')
3474 for page_num in itertools.count(0):
3475 if not continuation:
3477 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3478 comment_prog_str = f"({tracker['running_total']}
/~{tracker['est_total']}
)"
3480 if is_first_continuation:
3481 note_prefix = 'Downloading comment section API JSON'
3483 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3484 tracker['current_page_thread'], comment_prog_str)
3486 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
3487 ' ' if parent else '', ' replies' if parent else '',
3488 page_num, comment_prog_str)
3490 # Do a deep check for incomplete data as sometimes YouTube may return no comments for a continuation
3491 # Ignore check if YouTube says the comment count is 0.
3492 check_get_keys = None
3493 if not is_forced_continuation and not (tracker['est_total'] == 0 and tracker['running_total'] == 0):
3494 check_get_keys = [[*continuation_items_path, ..., (
3495 'commentsHeaderRenderer' if is_first_continuation else ('commentThreadRenderer', 'commentRenderer'))]]
3497 response = self._extract_response(
3498 item_id=None, query=continuation,
3499 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3500 check_get_keys=check_get_keys)
3501 except ExtractorError as e:
3502 # Ignore incomplete data error for replies if retries didn't work.
3503 # This is to allow any other parent comments and comment threads to be downloaded.
3504 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3505 if 'incomplete data' in str(e).lower() and parent:
3506 if self.get_param('ignoreerrors') in (True, 'only_download'):
3507 self.report_warning(
3508 'Received incomplete data for a comment reply thread and retrying did not help. '
3509 'Ignoring to let other comments be downloaded. Pass --no-ignore-errors to not ignore.')
3512 raise ExtractorError(
3513 'Incomplete data received for comment reply thread. '
3514 'Pass --ignore-errors to ignore and allow rest of comments to download.',
3517 is_forced_continuation = False
3519 for continuation_items in traverse_obj(response, continuation_items_path, expected_type=list, default=[]):
3520 if is_first_continuation:
3521 continuation = extract_header(continuation_items)
3522 is_first_continuation = False
3527 for entry in extract_thread(continuation_items):
3531 continuation = self._extract_continuation({'contents': continuation_items})
3535 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3536 if message and not parent and tracker['running_total'] == 0:
3537 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3538 raise self.CommentsDisabled
3541 def _generate_comment_continuation(video_id):
3543 Generates initial comment section continuation token from given video id
3545 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3546 return base64.b64encode(token.encode()).decode()
3548 def _get_comments(self, ytcfg, video_id, contents, webpage):
3549 """Entry for comment extraction"""
3550 def _real_comment_extract(contents):
3552 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3553 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3554 yield from self._comment_entries(renderer, ytcfg, video_id)
3556 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3557 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3560 def _get_checkok_params():
3561 return {'contentCheckOk': True, 'racyCheckOk': True}
3564 def _generate_player_context(cls, sts=None):
3566 'html5Preference': 'HTML5_PREF_WANTS',
3569 context['signatureTimestamp'] = sts
3571 'playbackContext': {
3572 'contentPlaybackContext': context
3574 **cls._get_checkok_params()
3578 def _is_agegated(player_response):
3579 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3582 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3583 AGE_GATE_REASONS = (
3584 'confirm your age', 'age-restricted', 'inappropriate', # reason
3585 'age_verification_required', 'age_check_required', # status
3587 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3590 def _is_unplayable(player_response):
3591 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3593 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3595 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3596 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3597 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3598 headers = self.generate_api_headers(
3599 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3602 'videoId': video_id,
3604 if _split_innertube_client(client)[0] == 'android':
3605 yt_query['params'] = 'CgIQBg=='
3607 pp_arg = self._configuration_arg('player_params', [None], casesense=True)[0]
3609 yt_query['params'] = pp_arg
3611 yt_query.update(self._generate_player_context(sts))
3612 return self._extract_response(
3613 item_id=video_id, ep='player', query=yt_query,
3614 ytcfg=player_ytcfg, headers=headers, fatal=True,
3615 default_client=client,
3616 note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
3619 def _get_requested_clients(self, url, smuggled_data):
3620 requested_clients = []
3621 default = ['ios', 'android', 'web']
3622 allowed_clients = sorted(
3623 (client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'),
3624 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3625 for client in self._configuration_arg('player_client'):
3626 if client in allowed_clients:
3627 requested_clients.append(client)
3628 elif client == 'default':
3629 requested_clients.extend(default)
3630 elif client == 'all':
3631 requested_clients.extend(allowed_clients)
3633 self.report_warning(f'Skipping unsupported client {client}')
3634 if not requested_clients:
3635 requested_clients = default
3637 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3638 requested_clients.extend(
3639 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3641 return orderedSet(requested_clients)
3643 def _invalid_player_response(self, pr, video_id):
3644 # YouTube may return a different video player response than expected.
3645 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3646 if (pr_id := traverse_obj(pr, ('videoDetails', 'videoId'))) != video_id:
3649 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3652 initial_pr = self._search_json(
3653 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3656 if initial_pr and not self._invalid_player_response(initial_pr, video_id):
3657 # Android player_response does not have microFormats which are needed for
3658 # extraction of some data. So we return the initial_pr with formats
3659 # stripped out even if not requested by the user
3660 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3661 prs.append({**initial_pr, 'streamingData': None})
3663 all_clients = set(clients)
3664 clients = clients[::-1]
3666 def append_client(*client_names):
3667 """ Append the first client name that exists but not already used """
3668 for client_name in client_names:
3669 actual_client = _split_innertube_client(client_name)[0]
3670 if actual_client in INNERTUBE_CLIENTS:
3671 if actual_client not in all_clients:
3672 clients.append(client_name)
3673 all_clients.add(actual_client)
3676 tried_iframe_fallback = False
3678 skipped_clients = {}
3680 client, base_client, variant = _split_innertube_client(clients.pop())
3681 player_ytcfg = master_ytcfg if client == 'web' else {}
3682 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3683 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3685 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3686 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3687 if 'js' in self._configuration_arg('player_skip'):
3688 require_js_player = False
3691 if not player_url and not tried_iframe_fallback and require_js_player:
3692 player_url = self._download_player_url(video_id)
3693 tried_iframe_fallback = True
3696 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3697 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3698 except ExtractorError as e:
3699 self.report_warning(e)
3702 if pr_id := self._invalid_player_response(pr, video_id):
3703 skipped_clients[client] = pr_id
3705 # Save client name for introspection later
3706 name = short_client_name(client)
3707 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3708 sd[STREAMING_DATA_CLIENT_NAME] = name
3709 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3710 f[STREAMING_DATA_CLIENT_NAME] = name
3713 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3714 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3715 append_client(f'{base_client}_creator')
3716 elif self._is_agegated(pr):
3717 if variant == 'tv_embedded':
3718 append_client(f'{base_client}_embedded')
3720 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3723 self.report_warning(
3724 f'Skipping player responses from {"/".join(skipped_clients)} clients '
3725 f'(got player responses for video "{"/".join(set(skipped_clients.values()))}
" instead of "{video_id}
")')
3727 raise ExtractorError(
3728 'All player responses are invalid. Your IP is likely being blocked by Youtube', expected=True)
3730 raise ExtractorError('Failed to extract any player response')
3731 return prs, player_url
3733 def _needs_live_processing(self, live_status, duration):
3734 if (live_status == 'is_live' and self.get_param('live_from_start')
3735 or live_status == 'post_live' and (duration or 0) > 2 * 3600):
3738 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3739 CHUNK_SIZE = 10 << 20
3740 itags, stream_ids = collections.defaultdict(set), []
3741 itag_qualities, res_qualities = {}, {0: None}
3743 # Normally tiny is the smallest video-only formats. But
3744 # audio-only formats with unknown quality may get tagged as tiny
3746 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3747 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
3749 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3750 format_types = self._configuration_arg('formats')
3751 all_formats = 'duplicate' in format_types
3752 if self._configuration_arg('include_duplicate_formats'):
3754 self._downloader.deprecated_feature('[youtube] include_duplicate_formats extractor argument is deprecated. '
3755 'Use formats=duplicate extractor argument instead')
3757 def build_fragments(f):
3759 'url': update_url_query(f['url'], {
3760 'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}'
3762 } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3764 for fmt in streaming_formats:
3765 if fmt.get('targetDurationSec'):
3768 itag = str_or_none(fmt.get('itag'))
3769 audio_track = fmt.get('audioTrack') or {}
3770 stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3772 if stream_id in stream_ids:
3775 quality = fmt.get('quality')
3776 height = int_or_none(fmt.get('height'))
3777 if quality == 'tiny' or not quality:
3778 quality = fmt.get('audioQuality', '').lower() or quality
3779 # The 3gp format (17) in android client has a quality of "small
",
3780 # but is actually worse than other formats
3785 itag_qualities[itag] = quality
3787 res_qualities[height] = quality
3788 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3789 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3790 # number of fragment that would subsequently requested with (`&sq=N`)
3791 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3794 fmt_url = fmt.get('url')
3796 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3797 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3798 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3799 if not all((sc, fmt_url, player_url, encrypted_sig)):
3802 fmt_url += '&%s=%s' % (
3803 traverse_obj(sc, ('sp', -1)) or 'signature',
3804 self._decrypt_signature(encrypted_sig, video_id, player_url)
3806 except ExtractorError as e:
3807 self.report_warning('Signature extraction failed: Some formats may be missing',
3808 video_id=video_id, only_once=True)
3809 self.write_debug(e, only_once=True)
3812 query = parse_qs(fmt_url)
3816 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3817 fmt_url = update_url_query(fmt_url, {
3818 'n': decrypt_nsig(query['n'][0], video_id, player_url)
3820 except ExtractorError as e:
3822 if isinstance(e, JSInterpreter.Exception):
3823 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3824 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3826 self.report_warning(
3827 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3828 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3829 self.write_debug(e, only_once=True)
3831 self.report_warning(
3832 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3833 video_id=video_id, only_once=True)
3836 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3837 language_preference = (
3838 10 if audio_track.get('audioIsDefault') and 10
3839 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3841 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3842 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3843 # Make sure to avoid false positives with small duration differences.
3844 # E.g. __2ABJjxzNo, ySuUZEjARPY
3845 is_damaged = try_get(fmt, lambda x: float(x['approxDurationMs']) / duration < 500)
3847 self.report_warning(
3848 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3850 client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3851 name = fmt.get('qualityLabel') or quality.replace('audio_quality_', '') or ''
3852 fps = int_or_none(fmt.get('fps')) or 0
3854 'asr': int_or_none(fmt.get('audioSampleRate')),
3855 'filesize': int_or_none(fmt.get('contentLength')),
3856 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3857 'format_note': join_nonempty(
3858 join_nonempty(audio_track.get('displayName'),
3859 language_preference > 0 and ' (default)', delim=''),
3860 name, fmt.get('isDrc') and 'DRC',
3861 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3862 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3863 throttled and 'THROTTLED', is_damaged and 'DAMAGED',
3864 (self.get_param('verbose') or all_formats) and client_name,
3866 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3867 'source_preference': ((-10 if throttled else -5 if itag == '22' else -1)
3868 + (100 if 'Premium' in name else 0)),
3869 'fps': fps if fps > 1 else None, # For some formats, fps is wrongly returned as 1
3870 'audio_channels': fmt.get('audioChannels'),
3872 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3873 'has_drm': bool(fmt.get('drmFamilies')),
3876 'width': int_or_none(fmt.get('width')),
3877 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3878 'desc' if language_preference < -1 else '') or None,
3879 'language_preference': language_preference,
3880 # Strictly de-prioritize damaged and 3gp formats
3881 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3883 mime_mobj = re.match(
3884 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3886 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3887 dct.update(parse_codecs(mime_mobj.group(2)))
3889 itags[itag].add(('https
', dct.get('language
')))
3890 stream_ids.append(stream_id)
3891 single_stream = 'none
' in (dct.get('acodec
'), dct.get('vcodec
'))
3892 if single_stream and dct.get('ext
'):
3893 dct['container
'] = dct['ext
'] + '_dash
'
3895 if (all_formats or 'dashy
' in format_types) and dct['filesize
']:
3898 'format_id
': f'{dct["format_id"]}
-dashy
' if all_formats else dct['format_id
'],
3899 'protocol
': 'http_dash_segments
',
3900 'fragments
': build_fragments(dct),
3902 if all_formats or 'dashy
' not in format_types:
3903 dct['downloader_options
'] = {'http_chunk_size': CHUNK_SIZE}
3906 needs_live_processing = self._needs_live_processing(live_status, duration)
3907 skip_bad_formats = 'incomplete
' not in format_types
3908 if self._configuration_arg('include_incomplete_formats
'):
3909 skip_bad_formats = False
3910 self._downloader.deprecated_feature('[youtube
] include_incomplete_formats extractor argument
is deprecated
. '
3911 'Use formats
=incomplete extractor argument instead
')
3913 skip_manifests = set(self._configuration_arg('skip
'))
3914 if (not self.get_param('youtube_include_hls_manifest
', True)
3915 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3916 or needs_live_processing and skip_bad_formats):
3917 skip_manifests.add('hls
')
3919 if not self.get_param('youtube_include_dash_manifest
', True):
3920 skip_manifests.add('dash
')
3921 if self._configuration_arg('include_live_dash
'):
3922 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3923 'Use formats
=incomplete extractor argument instead
')
3924 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3925 skip_manifests.add('dash
')
3927 def process_manifest_format(f, proto, client_name, itag):
3928 key = (proto, f.get('language
'))
3929 if not all_formats and key in itags[itag]:
3931 itags[itag].add(key)
3933 if itag and all_formats:
3934 f['format_id
'] = f'{itag}
-{proto}
'
3935 elif any(p != proto for p, _ in itags[itag]):
3936 f['format_id
'] = f'{itag}
-{proto}
'
3938 f['format_id
'] = itag
3940 if f.get('source_preference
') is None:
3941 f['source_preference
'] = -1
3943 if itag in ('616', '235'):
3944 f['format_note
'] = join_nonempty(f.get('format_note
'), 'Premium
', delim=' ')
3945 f['source_preference
'] += 100
3947 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
3948 if f['quality
'] == -1 and f.get('height
'):
3949 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
3950 if self.get_param('verbose
') or all_formats:
3951 f['format_note
'] = join_nonempty(f.get('format_note
'), client_name, delim=', ')
3952 if f.get('fps
') and f['fps
'] <= 1:
3955 if proto == 'hls
' and f.get('has_drm
'):
3956 f['has_drm
'] = 'maybe
'
3957 f['source_preference
'] -= 5
3961 for sd in streaming_data:
3962 client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
3964 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
3965 if hls_manifest_url:
3966 fmts, subs = self._extract_m3u8_formats_and_subtitles(
3967 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
3968 subtitles = self._merge_subtitles(subs, subtitles)
3970 if process_manifest_format(f, 'hls
', client_name, self._search_regex(
3971 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
3974 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
3975 if dash_manifest_url:
3976 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
3977 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
3979 if process_manifest_format(f, 'dash
', client_name, f['format_id
']):
3980 f['filesize
'] = int_or_none(self._search_regex(
3981 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
3982 if needs_live_processing:
3983 f['is_from_start
'] = True
3988 def _extract_storyboard(self, player_responses, duration):
3990 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
3991 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
3995 for i, args in enumerate(spec):
3996 args = args.split('#')
3997 counts
= list(map(int_or_none
, args
[:5]))
3998 if len(args
) != 8 or not all(counts
):
3999 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
4001 width
, height
, frame_count
, cols
, rows
= counts
4004 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
4005 fragment_count
= frame_count
/ (cols
* rows
)
4006 fragment_duration
= duration
/ fragment_count
4008 'format_id': f
'sb{i}',
4009 'format_note': 'storyboard',
4011 'protocol': 'mhtml',
4017 'fps': frame_count
/ duration
,
4021 'url': url
.replace('$M', str(j
)),
4022 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
4023 } for j
in range(math
.ceil(fragment_count
))],
4026 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
4028 if 'webpage' not in self
._configuration
_arg
('player_skip'):
4029 query
= {'bpctr': '9999999999', 'has_verified': '1'}
4030 pp
= self
._configuration
_arg
('player_params', [None], casesense
=True)[0]
4033 webpage
= self
._download
_webpage
(
4034 webpage_url
, video_id
, fatal
=False, query
=query
)
4036 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
4038 player_responses
, player_url
= self
._extract
_player
_responses
(
4039 self
._get
_requested
_clients
(url
, smuggled_data
),
4040 video_id
, webpage
, master_ytcfg
, smuggled_data
)
4042 return webpage
, master_ytcfg
, player_responses
, player_url
4044 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
4045 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
4046 is_live
= get_first(video_details
, 'isLive')
4048 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
4049 live_content
= get_first(video_details
, 'isLiveContent')
4050 is_upcoming
= get_first(video_details
, 'isUpcoming')
4051 post_live
= get_first(video_details
, 'isPostLiveDvr')
4052 live_status
= ('post_live' if post_live
4053 else 'is_live' if is_live
4054 else 'is_upcoming' if is_upcoming
4055 else 'was_live' if live_content
4056 else 'not_live' if False in (is_live
, live_content
)
4058 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'))
4059 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
4060 if all(f
.get('has_drm') for f
in formats
):
4061 # If there are no formats that definitely don't have DRM, all have DRM
4065 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
4067 def _real_extract(self
, url
):
4068 url
, smuggled_data
= unsmuggle_url(url
, {})
4069 video_id
= self
._match
_id
(url
)
4071 base_url
= self
.http_scheme() + '//www.youtube.com/'
4072 webpage_url
= base_url
+ 'watch?v=' + video_id
4074 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
4076 playability_statuses
= traverse_obj(
4077 player_responses
, (..., 'playabilityStatus'), expected_type
=dict)
4079 trailer_video_id
= get_first(
4080 playability_statuses
,
4081 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
4083 if trailer_video_id
:
4084 return self
.url_result(
4085 trailer_video_id
, self
.ie_key(), trailer_video_id
)
4087 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
4088 if webpage
else (lambda x
: None))
4090 video_details
= traverse_obj(player_responses
, (..., 'videoDetails'), expected_type
=dict)
4091 microformats
= traverse_obj(
4092 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
4095 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
4096 video_title
= (self
._preferred
_lang
and translated_title
4097 or get_first(video_details
, 'title') # primary
4099 or search_meta(['og:title', 'twitter:title', 'title']))
4100 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
4101 original_description
= get_first(video_details
, 'shortDescription')
4102 video_description
= (
4103 self
._preferred
_lang
and translated_description
4104 # If original description is blank, it will be an empty string.
4105 # Do not prefer translated description in this case.
4106 or original_description
if original_description
is not None else translated_description
)
4108 multifeed_metadata_list
= get_first(
4110 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
4112 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
4113 if self
.get_param('noplaylist'):
4114 self
.to_screen('Downloading just video %s because of --no-playlist' % video_id
)
4118 for feed
in multifeed_metadata_list
.split(','):
4119 # Unquote should take place before split on comma (,) since textual
4120 # fields may contain comma as well (see
4121 # https://github.com/ytdl-org/youtube-dl/issues/8536)
4122 feed_data
= urllib
.parse
.parse_qs(
4123 urllib
.parse
.unquote_plus(feed
))
4125 def feed_entry(name
):
4127 feed_data
, lambda x
: x
[name
][0], str)
4129 feed_id
= feed_entry('id')
4132 feed_title
= feed_entry('title')
4135 title
+= ' (%s)' % feed_title
4137 '_type': 'url_transparent',
4138 'ie_key': 'Youtube',
4140 '%swatch?v=%s' % (base_url
, feed_data
['id'][0]),
4141 {'force_singlefeed': True}
),
4144 feed_ids
.append(feed_id
)
4146 'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
4147 % (', '.join(feed_ids
), video_id
))
4148 return self
.playlist_result(
4149 entries
, video_id
, video_title
, video_description
)
4151 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
4152 or int_or_none(get_first(microformats
, 'lengthSeconds'))
4153 or parse_duration(search_meta('duration')) or None)
4155 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
4156 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
4157 if live_status
== 'post_live':
4158 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
4161 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
4162 self
.report_drm(video_id
)
4164 playability_statuses
,
4165 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
4166 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
4167 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
4169 if subreason
== 'The uploader has not made this video available in your country.':
4170 countries
= get_first(microformats
, 'availableCountries')
4172 regions_allowed
= search_meta('regionsAllowed')
4173 countries
= regions_allowed
.split(',') if regions_allowed
else None
4174 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
4175 reason
+= f
'. {subreason}'
4177 self
.raise_no_formats(reason
, expected
=True)
4179 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
4180 if not keywords
and webpage
:
4182 unescapeHTML(m
.group('content'))
4183 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
4184 for keyword
in keywords
:
4185 if keyword
.startswith('yt:stretch='):
4186 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
4188 # NB: float is intentional for forcing float division
4189 w
, h
= (float(v
) for v
in mobj
.groups())
4193 if f
.get('vcodec') != 'none':
4194 f
['stretched_ratio'] = ratio
4196 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
4197 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
4200 'url': thumbnail_url
,
4202 original_thumbnails
= thumbnails
.copy()
4204 # The best resolution thumbnails sometimes does not appear in the webpage
4205 # See: https://github.com/yt-dlp/yt-dlp/issues/340
4206 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4208 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4209 # in resolution, these are not the custom thumbnail. So de-prioritize them
4210 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4211 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3'
4213 n_thumbnail_names
= len(thumbnail_names
)
4215 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4216 video_id
=video_id
, name
=name
, ext
=ext
,
4217 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
4218 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
4219 for thumb
in thumbnails
:
4220 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
4221 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
4222 self
._remove
_duplicate
_formats
(thumbnails
)
4223 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
4225 category
= get_first(microformats
, 'category') or search_meta('genre')
4226 channel_id
= self
.ucid_or_none(str_or_none(
4227 get_first(video_details
, 'channelId')
4228 or get_first(microformats
, 'externalChannelId')
4229 or search_meta('channelId')))
4230 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
4232 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
4233 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
4234 if not duration
and live_end_time
and live_start_time
:
4235 duration
= live_end_time
- live_start_time
4237 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
4239 def is_bad_format(fmt
):
4240 if needs_live_processing
and not fmt
.get('is_from_start'):
4242 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
4243 and fmt
.get('protocol') == 'http_dash_segments'):
4246 for fmt
in filter(is_bad_format
, formats
):
4247 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4248 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 2 hours)', delim
=' ')
4250 if needs_live_processing
:
4251 self
._prepare
_live
_from
_start
_formats
(
4252 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4254 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4256 channel_handle
= self
.handle_from_url(owner_profile_url
)
4260 'title': video_title
,
4262 'thumbnails': thumbnails
,
4263 # The best thumbnail that we are sure exists. Prevents unnecessary
4264 # URL checking if user don't care about getting the best possible thumbnail
4265 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4266 'description': video_description
,
4267 'channel_id': channel_id
,
4268 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None),
4269 'duration': duration
,
4270 'view_count': int_or_none(
4271 get_first((video_details
, microformats
), (..., 'viewCount'))
4272 or search_meta('interactionCount')),
4273 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4274 'age_limit': 18 if (
4275 get_first(microformats
, 'isFamilySafe') is False
4276 or search_meta('isFamilyFriendly') == 'false'
4277 or search_meta('og:restrictions:age') == '18+') else 0,
4278 'webpage_url': webpage_url
,
4279 'categories': [category
] if category
else None,
4281 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4282 'live_status': live_status
,
4283 'release_timestamp': live_start_time
,
4284 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4285 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto')
4289 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4291 def get_lang_code(track
):
4292 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4293 or track
.get('languageCode'))
4295 # Converted into dicts to remove duplicates
4297 get_lang_code(sub
): sub
4298 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...))}
4299 translation_languages
= {
4300 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4301 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...))}
4303 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4304 lang_subs
= container
.setdefault(lang_code
, [])
4305 for fmt
in self
._SUBTITLE
_FORMATS
:
4311 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4315 # NB: Constructing the full subtitle dictionary is slow
4316 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4317 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4318 for lang_code
, caption_track
in captions
.items():
4319 base_url
= caption_track
.get('baseUrl')
4320 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4323 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4324 if caption_track
.get('kind') != 'asr':
4328 subtitles
, base_url
, lang_code
, lang_name
, {})
4329 if not caption_track
.get('isTranslatable'):
4331 for trans_code
, trans_name
in translation_languages
.items():
4334 orig_trans_code
= trans_code
4335 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4336 if not get_translated_subs
:
4338 trans_code
+= f
'-{lang_code}'
4339 trans_name
+= format_field(lang_name
, None, ' from %s')
4340 if lang_code
== f
'a-{orig_trans_code}':
4341 # Set audio language based on original subtitles
4343 if f
.get('acodec') != 'none' and not f
.get('language'):
4344 f
['language'] = orig_trans_code
4345 # Add an "-orig" label to the original language so that it can be distinguished.
4346 # The subs are returned without "-orig" as well for compatibility
4348 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4349 # Setting tlang=lang returns damaged subtitles.
4350 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4351 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4353 info
['automatic_captions'] = automatic_captions
4354 info
['subtitles'] = subtitles
4356 parsed_url
= urllib
.parse
.urlparse(url
)
4357 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4358 query
= urllib
.parse
.parse_qs(component
)
4359 for k
, v
in query
.items():
4360 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4362 if d_k
not in info
and k
in s_ks
:
4363 info
[d_k
] = parse_duration(query
[k
][0])
4365 # Youtube Music Auto-generated description
4366 if (video_description
or '').strip().endswith('\nAuto-generated by YouTube.'):
4367 # XXX: Causes catastrophic backtracking if description has "·"
4368 # E.g. https://www.youtube.com/watch?v=DoPaAxMQoiI
4369 # Simulating atomic groups: (?P<a>[^xy]+)x => (?=(?P<a>[^xy]+))(?P=a)x
4370 # reduces it, but does not fully fix it. https://regex101.com/r/8Ssf2h/2
4373 (?=(?P<track>[^\n·]+))(?P=track)·
4374 (?=(?P<artist>[^\n]+))(?P=artist)\n+
4375 (?=(?P<album>[^\n]+))(?P=album)\n
4376 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4377 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4379 (?=(?P<clean_artist>[^\n]+))(?P=clean_artist)\n
4380 )?.+\nAuto-generated\ by\ YouTube\.\s*$
4381 ''', video_description
)
4383 release_year
= mobj
.group('release_year')
4384 release_date
= mobj
.group('release_date')
4386 release_date
= release_date
.replace('-', '')
4387 if not release_year
:
4388 release_year
= release_date
[:4]
4390 'album': mobj
.group('album'.strip()),
4391 'artists': ([a
] if (a
:= mobj
.group('clean_artist'))
4392 else [a
.strip() for a
in mobj
.group('artist').split('·')]),
4393 'track': mobj
.group('track').strip(),
4394 'release_date': release_date
,
4395 'release_year': int_or_none(release_year
),
4400 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4401 if not traverse_obj(initial_data
, 'contents'):
4402 self
.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4404 if not initial_data
:
4405 query
= {'videoId': video_id}
4406 query
.update(self
._get
_checkok
_params
())
4407 initial_data
= self
._extract
_response
(
4408 item_id
=video_id
, ep
='next', fatal
=False,
4409 ytcfg
=master_ytcfg
, query
=query
, check_get_keys
='contents',
4410 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4411 note
='Downloading initial data API JSON')
4413 info
['comment_count'] = traverse_obj(initial_data
, (
4414 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4415 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount'
4417 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4418 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo'
4419 ), expected_type
=self
._get
_count
, get_all
=False)
4421 try: # This will error if there is no livechat
4422 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4423 except (KeyError, IndexError, TypeError):
4426 info
.setdefault('subtitles', {})['live_chat'] = [{
4427 # url is needed to set cookies
4428 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4429 'video_id': video_id
,
4431 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4432 else 'youtube_live_chat_replay'),
4436 info
['chapters'] = (
4437 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4438 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4439 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4442 info
['heatmap'] = self
._extract
_heatmap
(initial_data
)
4444 contents
= traverse_obj(
4445 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4446 expected_type
=list, default
=[])
4448 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4450 stl
= vpir
.get('superTitleLink')
4452 stl
= self
._get
_text
(stl
)
4455 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4456 info
['location'] = stl
4458 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4461 'series': mobj
.group(1),
4462 'season_number': int(mobj
.group(2)),
4463 'episode_number': int(mobj
.group(3)),
4465 for tlb
in (try_get(
4467 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4471 tlb
, ('toggleButtonRenderer', ...),
4472 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4474 for getter
, regex
in [(
4475 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4476 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4477 lambda x
: x
['accessibility'],
4478 lambda x
: x
['accessibilityData']['accessibilityData'],
4479 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4480 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4482 mobj
= re
.match(regex
, label
)
4484 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4487 info
['like_count'] = traverse_obj(vpir
, (
4488 'videoActions', 'menuRenderer', 'topLevelButtons', ...,
4489 'segmentedLikeDislikeButtonViewModel', 'likeButtonViewModel', 'likeButtonViewModel',
4490 'toggleButtonViewModel', 'toggleButtonViewModel', 'defaultButtonViewModel',
4491 'buttonViewModel', 'accessibilityText', {parse_count}
), get_all
=False)
4493 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4495 vc
= self
._get
_count
(vcr
, 'viewCount')
4496 # Upcoming premieres with waiting count are treated as live here
4497 if vcr
.get('isLive'):
4498 info
['concurrent_view_count'] = vc
4499 elif info
.get('view_count') is None:
4500 info
['view_count'] = vc
4502 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4504 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4506 'channel': self
._get
_text
(vor
, 'title'),
4507 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4509 if not channel_handle
:
4510 channel_handle
= self
.handle_from_url(
4512 ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4513 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4514 {str}
), get_all
=False))
4518 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4520 multiple_songs
= False
4522 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4523 multiple_songs
= True
4526 mrr
= row
.get('metadataRowRenderer') or {}
4527 mrr_title
= mrr
.get('title')
4530 mrr_title
= self
._get
_text
(mrr
, 'title')
4531 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4532 if mrr_title
== 'License':
4533 info
['license'] = mrr_contents_text
4534 elif not multiple_songs
:
4535 if mrr_title
== 'Album':
4536 info
['album'] = mrr_contents_text
4537 elif mrr_title
== 'Artist':
4538 info
['artists'] = [mrr_contents_text
] if mrr_contents_text
else None
4539 elif mrr_title
== 'Song':
4540 info
['track'] = mrr_contents_text
4541 owner_badges
= self
._extract
_badges
(traverse_obj(vsir
, ('owner', 'videoOwnerRenderer', 'badges')))
4542 if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
):
4543 info
['channel_is_verified'] = True
4546 'uploader': info
.get('channel'),
4547 'uploader_id': channel_handle
,
4548 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4550 # The upload date for scheduled, live and past live streams / premieres in microformats
4551 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4552 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4554 unified_strdate(get_first(microformats
, 'uploadDate'))
4555 or unified_strdate(search_meta('uploadDate')))
4556 if not upload_date
or (
4557 live_status
in ('not_live', None)
4558 and 'no-youtube-prefer-utc-upload-date' not in self
.get_param('compat_opts', [])
4560 upload_date
= strftime_or_none(
4561 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText'))) or upload_date
4562 info
['upload_date'] = upload_date
4564 if upload_date
and live_status
not in ('is_live', 'post_live', 'is_upcoming'):
4565 # Newly uploaded videos' HLS formats are potentially problematic and need to be checked
4566 upload_datetime
= datetime_from_str(upload_date
).replace(tzinfo
=datetime
.timezone
.utc
)
4567 if upload_datetime
>= datetime_from_str('today-2days'):
4568 for fmt
in info
['formats']:
4569 if fmt
.get('protocol') == 'm3u8_native':
4570 fmt
['__needs_testing'] = True
4572 for s_k
, d_k
in [('artists', 'creators'), ('track', 'alt_title')]:
4577 badges
= self
._extract
_badges
(traverse_obj(vpir
, 'badges'))
4579 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4580 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4582 info
['availability'] = (
4583 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4584 else self
._availability
(
4585 is_private
=is_private
,
4587 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4588 or False if initial_data
and is_private
is not None else None),
4589 needs_subscription
=(
4590 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4591 or False if initial_data
and is_private
is not None else None),
4592 needs_auth
=info
['age_limit'] >= 18,
4593 is_unlisted
=None if is_private
is None else (
4594 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4595 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4597 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4599 self
.mark_watched(video_id
, player_responses
)
4604 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4606 def passthrough_smuggled_data(func
):
4607 def _smuggle(info
, smuggled_data
):
4608 if info
.get('_type') not in ('url', 'url_transparent'):
4610 if smuggled_data
.get('is_music_url'):
4611 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4612 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4613 smuggled_data
.pop('is_music_url')
4614 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4616 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4619 @functools.wraps(func
)
4620 def wrapper(self
, url
):
4621 url
, smuggled_data
= unsmuggle_url(url
, {})
4622 if self
.is_music_url(url
):
4623 smuggled_data
['is_music_url'] = True
4624 info_dict
= func(self
, url
, smuggled_data
)
4626 _smuggle(info_dict
, smuggled_data
)
4627 if info_dict
.get('entries'):
4628 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4633 def _extract_basic_item_renderer(item
):
4634 # Modified from _extract_grid_item_renderer
4635 known_basic_renderers
= (
4636 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer'
4638 for key
, renderer
in item
.items():
4639 if not isinstance(renderer
, dict):
4641 elif key
in known_basic_renderers
:
4643 elif key
.startswith('grid') and key
.endswith('Renderer'):
4646 def _extract_channel_renderer(self
, renderer
):
4647 channel_id
= self
.ucid_or_none(renderer
['channelId'])
4648 title
= self
._get
_text
(renderer
, 'title')
4649 channel_url
= format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None)
4650 channel_handle
= self
.handle_from_url(
4651 traverse_obj(renderer
, (
4652 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4653 ('browseEndpoint', 'canonicalBaseUrl')),
4654 {str}
), get_all
=False))
4655 if not channel_handle
:
4656 # As of 2023-06-01, YouTube sets subscriberCountText to the handle in search
4657 channel_handle
= self
.handle_or_none(self
._get
_text
(renderer
, 'subscriberCountText'))
4662 'ie_key': YoutubeTabIE
.ie_key(),
4665 'channel_id': channel_id
,
4666 'channel_url': channel_url
,
4668 'uploader_id': channel_handle
,
4669 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4670 # See above. YouTube sets videoCountText to the subscriber text in search channel renderers.
4671 # However, in feed/channels this is set correctly to the subscriber count
4672 'channel_follower_count': traverse_obj(
4673 renderer
, 'subscriberCountText', 'videoCountText', expected_type
=self
._get
_count
),
4674 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
4676 # videoCountText may be the subscriber count
4677 self
._get
_count
(renderer
, 'videoCountText')
4678 if self
._get
_count
(renderer
, 'subscriberCountText') is not None else None),
4679 'description': self
._get
_text
(renderer
, 'descriptionSnippet'),
4680 'channel_is_verified': True if self
._has
_badge
(
4681 self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges')), BadgeType
.VERIFIED
) else None,
4684 def _grid_entries(self
, grid_renderer
):
4685 for item
in grid_renderer
['items']:
4686 if not isinstance(item
, dict):
4688 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4689 if not isinstance(renderer
, dict):
4691 title
= self
._get
_text
(renderer
, 'title')
4694 playlist_id
= renderer
.get('playlistId')
4696 yield self
.url_result(
4697 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4698 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4702 video_id
= renderer
.get('videoId')
4704 yield self
._extract
_video
(renderer
)
4707 channel_id
= renderer
.get('channelId')
4709 yield self
._extract
_channel
_renderer
(renderer
)
4711 # generic endpoint URL support
4712 ep_url
= urljoin('https://www.youtube.com/', try_get(
4713 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4716 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4717 if ie
.suitable(ep_url
):
4718 yield self
.url_result(
4719 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4722 def _music_reponsive_list_entry(self
, renderer
):
4723 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4725 title
= traverse_obj(renderer
, (
4726 'flexColumns', 0, 'musicResponsiveListItemFlexColumnRenderer',
4727 'text', 'runs', 0, 'text'))
4728 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4729 ie
=YoutubeIE
.ie_key(), video_id
=video_id
, title
=title
)
4730 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4732 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4734 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4735 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4736 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4737 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4738 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4740 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4741 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4743 def _shelf_entries_from_content(self
, shelf_renderer
):
4744 content
= shelf_renderer
.get('content')
4745 if not isinstance(content
, dict):
4747 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4749 # TODO: add support for nested playlists so each shelf is processed
4750 # as separate playlist
4751 # TODO: this includes only first N items
4752 yield from self
._grid
_entries
(renderer
)
4753 renderer
= content
.get('horizontalListRenderer')
4758 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4760 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4762 shelf_url
= urljoin('https://www.youtube.com', ep
)
4764 # Skipping links to another channels, note that checking for
4765 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4767 if skip_channels
and '/channels?' in shelf_url
:
4769 title
= self
._get
_text
(shelf_renderer
, 'title')
4770 yield self
.url_result(shelf_url
, video_title
=title
)
4771 # Shelf may not contain shelf URL, fallback to extraction from content
4772 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4774 def _playlist_entries(self
, video_list_renderer
):
4775 for content
in video_list_renderer
['contents']:
4776 if not isinstance(content
, dict):
4778 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4779 if not isinstance(renderer
, dict):
4781 video_id
= renderer
.get('videoId')
4784 yield self
._extract
_video
(renderer
)
4786 def _rich_entries(self
, rich_grid_renderer
):
4787 renderer
= traverse_obj(
4789 ('content', ('videoRenderer', 'reelItemRenderer', 'playlistRenderer')), get_all
=False) or {}
4790 video_id
= renderer
.get('videoId')
4792 yield self
._extract
_video
(renderer
)
4794 playlist_id
= renderer
.get('playlistId')
4796 yield self
.url_result(
4797 f
'https://www.youtube.com/playlist?list={playlist_id}',
4798 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4799 video_title
=self
._get
_text
(renderer
, 'title'))
4802 def _video_entry(self
, video_renderer
):
4803 video_id
= video_renderer
.get('videoId')
4805 return self
._extract
_video
(video_renderer
)
4807 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4808 url
= urljoin('https://youtube.com', traverse_obj(
4809 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4811 return self
.url_result(
4812 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4814 def _post_thread_entries(self
, post_thread_renderer
):
4815 post_renderer
= try_get(
4816 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4817 if not post_renderer
:
4820 video_renderer
= try_get(
4821 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4822 video_id
= video_renderer
.get('videoId')
4824 entry
= self
._extract
_video
(video_renderer
)
4827 # playlist attachment
4828 playlist_id
= try_get(
4829 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4831 yield self
.url_result(
4832 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4833 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4834 # inline video links
4835 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4837 if not isinstance(run
, dict):
4840 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4843 if not YoutubeIE
.suitable(ep_url
):
4845 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4846 if video_id
== ep_video_id
:
4848 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4850 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4851 contents
= post_thread_continuation
.get('contents')
4852 if not isinstance(contents
, list):
4854 for content
in contents
:
4855 renderer
= content
.get('backstagePostThreadRenderer')
4856 if isinstance(renderer
, dict):
4857 yield from self
._post
_thread
_entries
(renderer
)
4859 renderer
= content
.get('videoRenderer')
4860 if isinstance(renderer
, dict):
4861 yield self
._video
_entry
(renderer
)
4864 def _rich_grid_entries(self, contents):
4865 for content in contents:
4866 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4868 entry = self._video_entry(video_renderer)
4873 def _report_history_entries(self
, renderer
):
4874 for url
in traverse_obj(renderer
, (
4875 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4876 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4877 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4878 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4880 def _extract_entries(self
, parent_renderer
, continuation_list
):
4881 # continuation_list is modified in-place with continuation_list = [continuation_token]
4882 continuation_list
[:] = [None]
4883 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4884 for content
in contents
:
4885 if not isinstance(content
, dict):
4887 is_renderer
= traverse_obj(
4888 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4891 if content
.get('richItemRenderer'):
4892 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4894 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4895 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4896 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4897 yield from self
._report
_history
_entries
(table
)
4898 continuation_list
[0] = self
._extract
_continuation
(table
)
4901 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4902 for isr_content
in isr_contents
:
4903 if not isinstance(isr_content
, dict):
4907 'playlistVideoListRenderer': self
._playlist
_entries
,
4908 'gridRenderer': self
._grid
_entries
,
4909 'reelShelfRenderer': self
._grid
_entries
,
4910 'shelfRenderer': self
._shelf
_entries
,
4911 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4912 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4913 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4914 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4915 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4916 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)],
4917 'richGridRenderer': lambda x
: self
._extract
_entries
(x
, continuation_list
),
4919 for key
, renderer
in isr_content
.items():
4920 if key
not in known_renderers
:
4922 for entry
in known_renderers
[key
](renderer
):
4925 continuation_list
[0] = self
._extract
_continuation
(renderer
)
4928 if not continuation_list
[0]:
4929 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
4931 if not continuation_list
[0]:
4932 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4934 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
4935 continuation_list
= [None]
4936 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
4937 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
4941 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
4942 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
4943 yield from extract_entries(parent_renderer
)
4944 continuation
= continuation_list
[0]
4945 seen_continuations
= set()
4946 for page_num
in itertools
.count(1):
4947 if not continuation
:
4949 continuation_token
= continuation
.get('continuation')
4950 if continuation_token
is not None and continuation_token
in seen_continuations
:
4951 self
.write_debug('Detected YouTube feed looping - assuming end of feed.')
4953 seen_continuations
.add(continuation_token
)
4954 headers
= self
.generate_api_headers(
4955 ytcfg
=ytcfg
, account_syncid
=account_syncid
, visitor_data
=visitor_data
)
4956 response
= self
._extract
_response
(
4957 item_id
=f
'{item_id} page {page_num}',
4958 query
=continuation
, headers
=headers
, ytcfg
=ytcfg
,
4959 check_get_keys
=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4963 # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
4964 # See: https://github.com/ytdl-org/youtube-dl/issues/28702
4965 visitor_data
= self
._extract
_visitor
_data
(response
) or visitor_data
4968 'videoRenderer': (self
._grid
_entries
, 'items'), # for membership tab
4969 'gridPlaylistRenderer': (self
._grid
_entries
, 'items'),
4970 'gridVideoRenderer': (self
._grid
_entries
, 'items'),
4971 'gridChannelRenderer': (self
._grid
_entries
, 'items'),
4972 'playlistVideoRenderer': (self
._playlist
_entries
, 'contents'),
4973 'itemSectionRenderer': (extract_entries
, 'contents'), # for feeds
4974 'richItemRenderer': (extract_entries
, 'contents'), # for hashtag
4975 'backstagePostThreadRenderer': (self
._post
_thread
_continuation
_entries
, 'contents'),
4976 'reportHistoryTableRowRenderer': (self
._report
_history
_entries
, 'rows'),
4977 'playlistVideoListContinuation': (self
._playlist
_entries
, None),
4978 'gridContinuation': (self
._grid
_entries
, None),
4979 'itemSectionContinuation': (self
._post
_thread
_continuation
_entries
, None),
4980 'sectionListContinuation': (extract_entries
, None), # for feeds
4983 continuation_items
= traverse_obj(response
, (
4984 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
4985 'appendContinuationItemsAction', 'continuationItems'
4986 ), 'continuationContents', get_all
=False)
4987 continuation_item
= traverse_obj(continuation_items
, 0, None, expected_type
=dict, default
={})
4989 video_items_renderer
= None
4990 for key
in continuation_item
.keys():
4991 if key
not in known_renderers
:
4993 func
, parent_key
= known_renderers
[key
]
4994 video_items_renderer
= {parent_key: continuation_items}
if parent_key
else continuation_items
4995 continuation_list
= [None]
4996 yield from func(video_items_renderer
)
4997 continuation
= continuation_list
[0] or self
._extract
_continuation
(video_items_renderer
)
4999 if not video_items_renderer
:
5003 def _extract_selected_tab(tabs
, fatal
=True):
5004 for tab_renderer
in tabs
:
5005 if tab_renderer
.get('selected'):
5008 raise ExtractorError('Unable to find selected tab')
5011 def _extract_tab_renderers(response
):
5012 return traverse_obj(
5013 response
, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type
=dict)
5015 def _extract_from_tabs(self
, item_id
, ytcfg
, data
, tabs
):
5016 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
5018 selected_tab
= self
._extract
_selected
_tab
(tabs
)
5019 metadata
['title'] += format_field(selected_tab
, 'title', ' - %s')
5020 metadata
['title'] += format_field(selected_tab
, 'expandedText', ' - %s')
5022 return self
.playlist_result(
5024 selected_tab
, metadata
['id'], ytcfg
,
5025 self
._extract
_account
_syncid
(ytcfg
, data
),
5026 self
._extract
_visitor
_data
(data
, ytcfg
)),
5029 def _extract_metadata_from_tabs(self
, item_id
, data
):
5030 info
= {'id': item_id}
5032 metadata_renderer
= traverse_obj(data
, ('metadata', 'channelMetadataRenderer'), expected_type
=dict)
5033 if metadata_renderer
:
5034 channel_id
= traverse_obj(metadata_renderer
, ('externalId', {self.ucid_or_none}
),
5035 ('channelUrl', {self.ucid_from_url}
))
5037 'channel': metadata_renderer
.get('title'),
5038 'channel_id': channel_id
,
5040 if info
['channel_id']:
5041 info
['id'] = info
['channel_id']
5043 metadata_renderer
= traverse_obj(data
, ('metadata', 'playlistMetadataRenderer'), expected_type
=dict)
5045 # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
5046 # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
5047 def _get_uncropped(url
):
5048 return url_or_none((url
or '').split('=')[0] + '=s0')
5050 avatar_thumbnails
= self
._extract
_thumbnails
(metadata_renderer
, 'avatar')
5051 if avatar_thumbnails
:
5052 uncropped_avatar
= _get_uncropped(avatar_thumbnails
[0]['url'])
5053 if uncropped_avatar
:
5054 avatar_thumbnails
.append({
5055 'url': uncropped_avatar
,
5056 'id': 'avatar_uncropped',
5060 channel_banners
= self
._extract
_thumbnails
(
5061 data
, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
5062 for banner
in channel_banners
:
5063 banner
['preference'] = -10
5066 uncropped_banner
= _get_uncropped(channel_banners
[0]['url'])
5067 if uncropped_banner
:
5068 channel_banners
.append({
5069 'url': uncropped_banner
,
5070 'id': 'banner_uncropped',
5074 # Deprecated - remove primary_sidebar_renderer when layout discontinued
5075 primary_sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer')
5076 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer'), expected_type
=dict)
5078 primary_thumbnails
= self
._extract
_thumbnails
(
5079 primary_sidebar_renderer
, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
5080 playlist_thumbnails
= self
._extract
_thumbnails
(
5081 playlist_header_renderer
, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
5084 'title': (traverse_obj(metadata_renderer
, 'title')
5085 or self
._get
_text
(data
, ('header', 'hashtagHeaderRenderer', 'hashtag'))
5087 'availability': self
._extract
_availability
(data
),
5088 'channel_follower_count': self
._get
_count
(data
, ('header', ..., 'subscriberCountText')),
5089 'description': try_get(metadata_renderer
, lambda x
: x
.get('description', '')),
5090 'tags': try_get(metadata_renderer
or {}, lambda x
: x
.get('keywords', '').split()),
5091 'thumbnails': (primary_thumbnails
or playlist_thumbnails
) + avatar_thumbnails
+ channel_banners
,
5095 traverse_obj(metadata_renderer
, (('vanityChannelUrl', ('ownerUrls', ...)), {self.handle_from_url}
), get_all
=False)
5096 or traverse_obj(data
, ('header', ..., 'channelHandleText', {self.handle_or_none}
), get_all
=False))
5100 'uploader_id': channel_handle
,
5101 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
5104 channel_badges
= self
._extract
_badges
(traverse_obj(data
, ('header', ..., 'badges'), get_all
=False))
5105 if self
._has
_badge
(channel_badges
, BadgeType
.VERIFIED
):
5106 info
['channel_is_verified'] = True
5107 # Playlist stats is a text runs array containing [video count, view count, last updated].
5108 # last updated or (view count and last updated) may be missing.
5109 playlist_stats
= get_first(
5110 (primary_sidebar_renderer
, playlist_header_renderer
), (('stats', 'briefStats', 'numVideosText'), ))
5112 last_updated_unix
= self
._parse
_time
_text
(
5113 self
._get
_text
(playlist_stats
, 2) # deprecated, remove when old layout discontinued
5114 or self
._get
_text
(playlist_header_renderer
, ('byline', 1, 'playlistBylineRenderer', 'text')))
5115 info
['modified_date'] = strftime_or_none(last_updated_unix
)
5117 info
['view_count'] = self
._get
_count
(playlist_stats
, 1)
5118 if info
['view_count'] is None: # 0 is allowed
5119 info
['view_count'] = self
._get
_count
(playlist_header_renderer
, 'viewCountText')
5120 if info
['view_count'] is None:
5121 info
['view_count'] = self
._get
_count
(data
, (
5122 'contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., 'tabRenderer', 'content', 'sectionListRenderer',
5123 'contents', ..., 'itemSectionRenderer', 'contents', ..., 'channelAboutFullMetadataRenderer', 'viewCountText'))
5125 info
['playlist_count'] = self
._get
_count
(playlist_stats
, 0)
5126 if info
['playlist_count'] is None: # 0 is allowed
5127 info
['playlist_count'] = self
._get
_count
(playlist_header_renderer
, ('byline', 0, 'playlistBylineRenderer', 'text'))
5129 if not info
.get('channel_id'):
5130 owner
= traverse_obj(playlist_header_renderer
, 'ownerText')
5131 if not owner
: # Deprecated
5132 owner
= traverse_obj(
5133 self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarSecondaryInfoRenderer'),
5134 ('videoOwner', 'videoOwnerRenderer', 'title'))
5135 owner_text
= self
._get
_text
(owner
)
5136 browse_ep
= traverse_obj(owner
, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
5138 'channel': self
._search
_regex
(r
'^by (.+) and \d+ others?$', owner_text
, 'uploader', default
=owner_text
),
5139 'channel_id': self
.ucid_or_none(browse_ep
.get('browseId')),
5140 'uploader_id': self
.handle_from_url(urljoin('https://www.youtube.com', browse_ep
.get('canonicalBaseUrl')))
5144 'uploader': info
['channel'],
5145 'channel_url': format_field(info
.get('channel_id'), None, 'https://www.youtube.com/channel/%s', default
=None),
5146 'uploader_url': format_field(info
.get('uploader_id'), None, 'https://www.youtube.com/%s', default
=None),
5151 def _extract_inline_playlist(self
, playlist
, playlist_id
, data
, ytcfg
):
5152 first_id
= last_id
= response
= None
5153 for page_num
in itertools
.count(1):
5154 videos
= list(self
._playlist
_entries
(playlist
))
5157 start
= next((i
for i
, v
in enumerate(videos
) if v
['id'] == last_id
), -1) + 1
5158 if start
>= len(videos
):
5160 yield from videos
[start
:]
5161 first_id
= first_id
or videos
[0]['id']
5162 last_id
= videos
[-1]['id']
5163 watch_endpoint
= try_get(
5164 playlist
, lambda x
: x
['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
5165 headers
= self
.generate_api_headers(
5166 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5167 visitor_data
=self
._extract
_visitor
_data
(response
, data
, ytcfg
))
5169 'playlistId': playlist_id
,
5170 'videoId': watch_endpoint
.get('videoId') or last_id
,
5171 'index': watch_endpoint
.get('index') or len(videos
),
5172 'params': watch_endpoint
.get('params') or 'OAE%3D'
5174 response
= self
._extract
_response
(
5175 item_id
='%s page %d' % (playlist_id
, page_num
),
5176 query
=query
, ep
='next', headers
=headers
, ytcfg
=ytcfg
,
5177 check_get_keys
='contents'
5180 response
, lambda x
: x
['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
5182 def _extract_from_playlist(self
, item_id
, url
, data
, playlist
, ytcfg
):
5183 title
= playlist
.get('title') or try_get(
5184 data
, lambda x
: x
['titleText']['simpleText'], str)
5185 playlist_id
= playlist
.get('playlistId') or item_id
5187 # Delegating everything except mix playlists to regular tab-based playlist URL
5188 playlist_url
= urljoin(url
, try_get(
5189 playlist
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
5192 # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
5193 # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
5194 is_known_unviewable
= re
.fullmatch(r
'MLCT|RLTD[\w-]{22}', playlist_id
)
5196 if playlist_url
and playlist_url
!= url
and not is_known_unviewable
:
5197 return self
.url_result(
5198 playlist_url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
5201 return self
.playlist_result(
5202 self
._extract
_inline
_playlist
(playlist
, playlist_id
, data
, ytcfg
),
5203 playlist_id
=playlist_id
, playlist_title
=title
)
5205 def _extract_availability(self
, data
):
5207 Gets the availability of a given playlist/tab.
5208 Note: Unless YouTube tells us explicitly, we do not assume it is public
5209 @param data: response
5211 sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer') or {}
5212 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer')) or {}
5213 player_header_privacy
= playlist_header_renderer
.get('privacy')
5215 badges
= self
._extract
_badges
(traverse_obj(sidebar_renderer
, 'badges'))
5217 # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
5218 privacy_setting_icon
= get_first(
5219 (playlist_header_renderer
, sidebar_renderer
),
5220 ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
5221 lambda _
, v
: v
['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
5224 microformats_is_unlisted
= traverse_obj(
5225 data
, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type
=bool)
5229 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
5230 or player_header_privacy
== 'PUBLIC'
5231 or privacy_setting_icon
== 'PRIVACY_PUBLIC')
5232 else self
._availability
(
5234 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
5235 or player_header_privacy
== 'PRIVATE' if player_header_privacy
is not None
5236 else privacy_setting_icon
== 'PRIVACY_PRIVATE' if privacy_setting_icon
is not None else None),
5238 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
5239 or player_header_privacy
== 'UNLISTED' if player_header_privacy
is not None
5240 else privacy_setting_icon
== 'PRIVACY_UNLISTED' if privacy_setting_icon
is not None
5241 else microformats_is_unlisted
if microformats_is_unlisted
is not None else None),
5242 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
5243 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
5247 def _extract_sidebar_info_renderer(data
, info_renderer
, expected_type
=dict):
5248 sidebar_renderer
= try_get(
5249 data
, lambda x
: x
['sidebar']['playlistSidebarRenderer']['items'], list) or []
5250 for item
in sidebar_renderer
:
5251 renderer
= try_get(item
, lambda x
: x
[info_renderer
], expected_type
)
5255 def _reload_with_unavailable_videos(self
, item_id
, data
, ytcfg
):
5257 Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
5259 is_playlist
= bool(traverse_obj(
5260 data
, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
5263 headers
= self
.generate_api_headers(
5264 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5265 visitor_data
=self
._extract
_visitor
_data
(data
, ytcfg
))
5267 'params': 'wgYCCAA=',
5268 'browseId': f
'VL{item_id}'
5270 return self
._extract
_response
(
5271 item_id
=item_id
, headers
=headers
, query
=query
,
5272 check_get_keys
='contents', fatal
=False, ytcfg
=ytcfg
,
5273 note
='Redownloading playlist API JSON with unavailable videos')
5275 @functools.cached_property
5276 def skip_webpage(self
):
5277 return 'webpage' in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key())
5279 def _extract_webpage(self
, url
, item_id
, fatal
=True):
5280 webpage
, data
= None, None
5281 for retry
in self
.RetryManager(fatal
=fatal
):
5283 webpage
= self
._download
_webpage
(url
, item_id
, note
='Downloading webpage')
5284 data
= self
.extract_yt_initial_data(item_id
, webpage
or '', fatal
=fatal
) or {}
5285 except ExtractorError
as e
:
5286 if isinstance(e
.cause
, network_exceptions
):
5287 if not isinstance(e
.cause
, HTTPError
) or e
.cause
.status
not in (403, 429):
5290 self
._error
_or
_warning
(e
, fatal
=fatal
)
5294 self
._extract
_and
_report
_alerts
(data
)
5295 except ExtractorError
as e
:
5296 self
._error
_or
_warning
(e
, fatal
=fatal
)
5299 # Sometimes youtube returns a webpage with incomplete ytInitialData
5300 # See: https://github.com/yt-dlp/yt-dlp/issues/116
5301 if not traverse_obj(data
, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
5302 retry
.error
= ExtractorError('Incomplete yt initial data received')
5306 return webpage
, data
5308 def _report_playlist_authcheck(self
, ytcfg
, fatal
=True):
5309 """Use if failed to extract ytcfg (and data) from initial webpage"""
5310 if not ytcfg
and self
.is_authenticated
:
5311 msg
= 'Playlists that require authentication may not extract correctly without a successful webpage download'
5312 if 'authcheck' not in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key()) and fatal
:
5313 raise ExtractorError(
5314 f
'{msg}. If you are not downloading private content, or '
5315 'your cookies are only for the first account and channel,'
5316 ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
5318 self
.report_warning(msg
, only_once
=True)
5320 def _extract_data(self
, url
, item_id
, ytcfg
=None, fatal
=True, webpage_fatal
=False, default_client
='web'):
5322 if not self
.skip_webpage
:
5323 webpage
, data
= self
._extract
_webpage
(url
, item_id
, fatal
=webpage_fatal
)
5324 ytcfg
= ytcfg
or self
.extract_ytcfg(item_id
, webpage
)
5325 # Reject webpage data if redirected to home page without explicitly requesting
5326 selected_tab
= self
._extract
_selected
_tab
(self
._extract
_tab
_renderers
(data
), fatal
=False) or {}
5327 if (url
!= 'https://www.youtube.com/feed/recommended'
5328 and selected_tab
.get('tabIdentifier') == 'FEwhat_to_watch' # Home page
5329 and 'no-youtube-channel-redirect' not in self
.get_param('compat_opts', [])):
5330 msg
= 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
5332 raise ExtractorError(msg
, expected
=True)
5333 self
.report_warning(msg
, only_once
=True)
5335 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=fatal
)
5336 data
= self
._extract
_tab
_endpoint
(url
, item_id
, ytcfg
, fatal
=fatal
, default_client
=default_client
)
5339 def _extract_tab_endpoint(self
, url
, item_id
, ytcfg
=None, fatal
=True, default_client
='web'):
5340 headers
= self
.generate_api_headers(ytcfg
=ytcfg
, default_client
=default_client
)
5341 resolve_response
= self
._extract
_response
(
5342 item_id
=item_id
, query
={'url': url}
, check_get_keys
='endpoint', headers
=headers
, ytcfg
=ytcfg
, fatal
=fatal
,
5343 ep
='navigation/resolve_url', note
='Downloading API parameters API JSON', default_client
=default_client
)
5344 endpoints
= {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5345 for ep_key
, ep
in endpoints
.items():
5346 params
= try_get(resolve_response
, lambda x
: x
['endpoint'][ep_key
], dict)
5348 return self
._extract
_response
(
5349 item_id
=item_id
, query
=params
, ep
=ep
, headers
=headers
,
5350 ytcfg
=ytcfg
, fatal
=fatal
, default_client
=default_client
,
5351 check_get_keys
=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5352 err_note
= 'Failed to resolve url (does the playlist exist?)'
5354 raise ExtractorError(err_note
, expected
=True)
5355 self
.report_warning(err_note
, item_id
)
5357 _SEARCH_PARAMS
= None
5359 def _search_results(self
, query
, params
=NO_DEFAULT
, default_client
='web'):
5360 data
= {'query': query}
5361 if params
is NO_DEFAULT
:
5362 params
= self
._SEARCH
_PARAMS
5364 data
['params'] = params
5367 ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5368 ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5370 ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5371 ('continuationContents', ),
5373 display_id
= f
'query "{query}"'
5374 check_get_keys
= tuple({keys[0] for keys in content_keys}
)
5375 ytcfg
= self
._download
_ytcfg
(default_client
, display_id
) if not self
.skip_webpage
else {}
5376 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=False)
5378 continuation_list
= [None]
5380 for page_num
in itertools
.count(1):
5381 data
.update(continuation_list
[0] or {})
5382 headers
= self
.generate_api_headers(
5383 ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(search
), default_client
=default_client
)
5384 search
= self
._extract
_response
(
5385 item_id
=f
'{display_id} page {page_num}', ep
='search', query
=data
,
5386 default_client
=default_client
, check_get_keys
=check_get_keys
, ytcfg
=ytcfg
, headers
=headers
)
5387 slr_contents
= traverse_obj(search
, *content_keys
)
5388 yield from self
._extract
_entries
({'contents': list(variadic(slr_contents))}
, continuation_list
)
5389 if not continuation_list
[0]:
5393 class YoutubeTabIE(YoutubeTabBaseInfoExtractor
):
5394 IE_DESC
= 'YouTube Tabs'
5395 _VALID_URL
= r
'''(?x:
5397 (?!consent\.)(?:\w+\.)?
5399 youtube(?:kids)?\.com|
5403 (?P<channel_type>channel|c|user|browse)/|
5406 (?:playlist|watch)\?.*?\blist=
5408 (?!(?:%(reserved_names)s)\b) # Direct URLs
5412 'reserved_names': YoutubeBaseInfoExtractor
._RESERVED
_NAMES
,
5413 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
5415 IE_NAME
= 'youtube:tab'
5418 'note': 'playlists, multipage',
5419 'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5420 'playlist_mincount': 94,
5422 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5423 'title': 'Igor Kleiner - Playlists',
5424 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5425 'uploader': 'Igor Kleiner',
5426 'uploader_id': '@IgorDataScience',
5427 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5428 'channel': 'Igor Kleiner',
5429 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5430 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5431 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5432 'channel_follower_count': int
5435 'note': 'playlists, multipage, different order',
5436 'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5437 'playlist_mincount': 94,
5439 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5440 'title': 'Igor Kleiner - Playlists',
5441 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5442 'uploader': 'Igor Kleiner',
5443 'uploader_id': '@IgorDataScience',
5444 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5445 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5446 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5447 'channel': 'Igor Kleiner',
5448 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5449 'channel_follower_count': int
5452 'note': 'playlists, series',
5453 'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5454 'playlist_mincount': 5,
5456 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5457 'title': '3Blue1Brown - Playlists',
5458 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5459 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5460 'channel': '3Blue1Brown',
5461 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5462 'uploader_id': '@3blue1brown',
5463 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5464 'uploader': '3Blue1Brown',
5465 'tags': ['Mathematics'],
5466 'channel_follower_count': int,
5467 'channel_is_verified': True,
5470 'note': 'playlists, singlepage',
5471 'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5472 'playlist_mincount': 4,
5474 'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5475 'title': 'ThirstForScience - Playlists',
5476 'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5477 'uploader': 'ThirstForScience',
5478 'uploader_url': 'https://www.youtube.com/@ThirstForScience',
5479 'uploader_id': '@ThirstForScience',
5480 'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5481 'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5483 'channel': 'ThirstForScience',
5484 'channel_follower_count': int
5487 'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5488 'only_matching': True,
5490 'note': 'basic, single video playlist',
5491 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5493 'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5494 'title': 'youtube-dl public playlist',
5498 'modified_date': '20201130',
5499 'channel': 'Sergey M.',
5500 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5501 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5502 'availability': 'public',
5503 'uploader': 'Sergey M.',
5504 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5505 'uploader_id': '@sergeym.6173',
5507 'playlist_count': 1,
5509 'note': 'empty playlist',
5510 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5512 'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5513 'title': 'youtube-dl empty playlist',
5515 'channel': 'Sergey M.',
5517 'modified_date': '20160902',
5518 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5519 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5520 'availability': 'public',
5521 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5522 'uploader_id': '@sergeym.6173',
5523 'uploader': 'Sergey M.',
5525 'playlist_count': 0,
5528 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5530 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5531 'title': 'lex will - Home',
5532 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5533 'uploader': 'lex will',
5534 'uploader_id': '@lexwill718',
5535 'channel': 'lex will',
5536 'tags': ['bible', 'history', 'prophesy'],
5537 'uploader_url': 'https://www.youtube.com/@lexwill718',
5538 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5539 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5540 'channel_follower_count': int
5542 'playlist_mincount': 2,
5544 'note': 'Videos tab',
5545 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5547 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5548 'title': 'lex will - Videos',
5549 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5550 'uploader': 'lex will',
5551 'uploader_id': '@lexwill718',
5552 'tags': ['bible', 'history', 'prophesy'],
5553 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5554 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5555 'uploader_url': 'https://www.youtube.com/@lexwill718',
5556 'channel': 'lex will',
5557 'channel_follower_count': int
5559 'playlist_mincount': 975,
5561 'note': 'Videos tab, sorted by popular',
5562 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5564 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5565 'title': 'lex will - Videos',
5566 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5567 'uploader': 'lex will',
5568 'uploader_id': '@lexwill718',
5569 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5570 'uploader_url': 'https://www.youtube.com/@lexwill718',
5571 'channel': 'lex will',
5572 'tags': ['bible', 'history', 'prophesy'],
5573 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5574 'channel_follower_count': int
5576 'playlist_mincount': 199,
5578 'note': 'Playlists tab',
5579 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5581 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5582 'title': 'lex will - Playlists',
5583 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5584 'uploader': 'lex will',
5585 'uploader_id': '@lexwill718',
5586 'uploader_url': 'https://www.youtube.com/@lexwill718',
5587 'channel': 'lex will',
5588 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5589 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5590 'tags': ['bible', 'history', 'prophesy'],
5591 'channel_follower_count': int
5593 'playlist_mincount': 17,
5595 'note': 'Community tab',
5596 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5598 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5599 'title': 'lex will - Community',
5600 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5601 'channel': 'lex will',
5602 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5603 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5604 'tags': ['bible', 'history', 'prophesy'],
5605 'channel_follower_count': int,
5606 'uploader_url': 'https://www.youtube.com/@lexwill718',
5607 'uploader_id': '@lexwill718',
5608 'uploader': 'lex will',
5610 'playlist_mincount': 18,
5612 'note': 'Channels tab',
5613 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5615 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5616 'title': 'lex will - Channels',
5617 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5618 'channel': 'lex will',
5619 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5620 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5621 'tags': ['bible', 'history', 'prophesy'],
5622 'channel_follower_count': int,
5623 'uploader_url': 'https://www.youtube.com/@lexwill718',
5624 'uploader_id': '@lexwill718',
5625 'uploader': 'lex will',
5627 'playlist_mincount': 12,
5629 'note': 'Search tab',
5630 'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5631 'playlist_mincount': 40,
5633 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5634 'title': '3Blue1Brown - Search - linear algebra',
5635 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5636 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5637 'tags': ['Mathematics'],
5638 'channel': '3Blue1Brown',
5639 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5640 'channel_follower_count': int,
5641 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5642 'uploader_id': '@3blue1brown',
5643 'uploader': '3Blue1Brown',
5644 'channel_is_verified': True,
5647 'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5648 'only_matching': True,
5650 'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5651 'only_matching': True,
5653 'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5654 'only_matching': True,
5656 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5657 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5659 'title': '29C3: Not my department',
5660 'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5661 'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5664 'modified_date': '20150605',
5665 'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5666 'channel_url': 'https://www.youtube.com/channel/UCEPzS1rYsrkqzSLNp76nrcg',
5667 'channel': 'Christiaan008',
5668 'availability': 'public',
5669 'uploader_id': '@ChRiStIaAn008',
5670 'uploader': 'Christiaan008',
5671 'uploader_url': 'https://www.youtube.com/@ChRiStIaAn008',
5673 'playlist_count': 96,
5675 'note': 'Large playlist',
5676 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5678 'title': 'Uploads from Cauchemar',
5679 'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5680 'channel_url': 'https://www.youtube.com/channel/UCBABnxM4Ar9ten8Mdjj1j0Q',
5682 'modified_date': r
're:\d{8}',
5683 'channel': 'Cauchemar',
5686 'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5687 'availability': 'public',
5688 'uploader_id': '@Cauchemar89',
5689 'uploader': 'Cauchemar',
5690 'uploader_url': 'https://www.youtube.com/@Cauchemar89',
5692 'playlist_mincount': 1123,
5693 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5695 'note': 'even larger playlist, 8832 videos',
5696 'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5697 'only_matching': True,
5699 'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5700 'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5702 'title': 'Uploads from Interstellar Movie',
5703 'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5706 'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5707 'channel_url': 'https://www.youtube.com/channel/UCXw-G3eDE9trcvY2sBMM_aA',
5708 'channel': 'Interstellar Movie',
5710 'modified_date': r
're:\d{8}',
5711 'availability': 'public',
5712 'uploader_id': '@InterstellarMovie',
5713 'uploader': 'Interstellar Movie',
5714 'uploader_url': 'https://www.youtube.com/@InterstellarMovie',
5716 'playlist_mincount': 21,
5718 'note': 'Playlist with "show unavailable videos" button',
5719 'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5721 'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5722 'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5724 'channel': 'Phim Siêu Nhân Nhật Bản',
5727 'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5728 'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5729 'modified_date': r
're:\d{8}',
5730 'availability': 'public',
5731 'uploader_url': 'https://www.youtube.com/@phimsieunhannhatban',
5732 'uploader_id': '@phimsieunhannhatban',
5733 'uploader': 'Phim Siêu Nhân Nhật Bản',
5735 'playlist_mincount': 200,
5736 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5738 'note': 'Playlist with unavailable videos in page 7',
5739 'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5741 'title': 'Uploads from BlankTV',
5742 'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5743 'channel': 'BlankTV',
5744 'channel_url': 'https://www.youtube.com/channel/UC8l9frL61Yl5KFOl87nIm2w',
5745 'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5748 'modified_date': r
're:\d{8}',
5750 'availability': 'public',
5751 'uploader_id': '@blanktv',
5752 'uploader': 'BlankTV',
5753 'uploader_url': 'https://www.youtube.com/@blanktv',
5755 'playlist_mincount': 1000,
5756 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5758 'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5759 'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5761 'title': 'Data Analysis with Dr Mike Pound',
5762 'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5763 'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5766 'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5767 'channel_url': 'https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA',
5768 'channel': 'Computerphile',
5769 'availability': 'public',
5770 'modified_date': '20190712',
5771 'uploader_id': '@Computerphile',
5772 'uploader': 'Computerphile',
5773 'uploader_url': 'https://www.youtube.com/@Computerphile',
5775 'playlist_mincount': 11,
5777 'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5778 'only_matching': True,
5780 'note': 'Playlist URL that does not actually serve a playlist',
5781 'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5783 'id': 'FqZTN594JQw',
5785 'title': "Smiley's People 01 detective, Adventure Series, Action",
5786 'upload_date': '20150526',
5787 'license': 'Standard YouTube License',
5788 'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5789 'categories': ['People & Blogs'],
5795 'skip_download': True,
5797 'skip': 'This video is not available.',
5798 'add_ie': [YoutubeIE
.ie_key()],
5800 'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5801 'only_matching': True,
5803 'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5804 'only_matching': True,
5806 'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5808 'id': 'hGkQjiJLjWQ', # This will keep changing
5811 'upload_date': r
're:\d{8}',
5813 'categories': ['News & Politics'],
5816 'release_timestamp': int,
5817 'channel': 'Sky News',
5818 'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5821 'thumbnail': r
're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5822 'playable_in_embed': True,
5823 'release_date': r
're:\d+',
5824 'availability': 'public',
5825 'live_status': 'is_live',
5826 'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5827 'channel_follower_count': int,
5828 'concurrent_view_count': int,
5829 'uploader_url': 'https://www.youtube.com/@SkyNews',
5830 'uploader_id': '@SkyNews',
5831 'uploader': 'Sky News',
5832 'channel_is_verified': True,
5835 'skip_download': True,
5837 'expected_warnings': ['Ignoring subtitle tracks found in '],
5839 'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5841 'id': 'a48o2S1cPoo',
5843 'title': 'The Young Turks - Live Main Show',
5844 'upload_date': '20150715',
5845 'license': 'Standard YouTube License',
5846 'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5847 'categories': ['News & Politics'],
5848 'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5852 'skip_download': True,
5854 'only_matching': True,
5856 'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5857 'only_matching': True,
5859 'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5860 'only_matching': True,
5862 'note': 'A channel that is not live. Should raise error',
5863 'url': 'https://www.youtube.com/user/numberphile/live',
5864 'only_matching': True,
5866 'url': 'https://www.youtube.com/feed/trending',
5867 'only_matching': True,
5869 'url': 'https://www.youtube.com/feed/library',
5870 'only_matching': True,
5872 'url': 'https://www.youtube.com/feed/history',
5873 'only_matching': True,
5875 'url': 'https://www.youtube.com/feed/subscriptions',
5876 'only_matching': True,
5878 'url': 'https://www.youtube.com/feed/watch_later',
5879 'only_matching': True,
5881 'note': 'Recommended - redirects to home page.',
5882 'url': 'https://www.youtube.com/feed/recommended',
5883 'only_matching': True,
5885 'note': 'inline playlist with not always working continuations',
5886 'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5887 'only_matching': True,
5889 'url': 'https://www.youtube.com/course',
5890 'only_matching': True,
5892 'url': 'https://www.youtube.com/zsecurity',
5893 'only_matching': True,
5895 'url': 'http://www.youtube.com/NASAgovVideo/videos',
5896 'only_matching': True,
5898 'url': 'https://www.youtube.com/TheYoungTurks/live',
5899 'only_matching': True,
5901 'url': 'https://www.youtube.com/hashtag/cctv9',
5907 'playlist_mincount': 300, # not consistent but should be over 300
5909 'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
5910 'only_matching': True,
5912 'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
5913 'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5914 'only_matching': True
5916 'note': '/browse/ should redirect to /channel/',
5917 'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
5918 'only_matching': True
5920 'note': 'VLPL, should redirect to playlist?list=PL...',
5921 'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5923 'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5924 'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
5925 'title': 'NCS : All Releases 💿',
5926 'channel_url': 'https://www.youtube.com/channel/UC_aEa8K-EOJ3D6gOs7HcyNg',
5927 'modified_date': r
're:\d{8}',
5929 'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
5931 'channel': 'NoCopyrightSounds',
5932 'availability': 'public',
5933 'uploader_url': 'https://www.youtube.com/@NoCopyrightSounds',
5934 'uploader': 'NoCopyrightSounds',
5935 'uploader_id': '@NoCopyrightSounds',
5937 'playlist_mincount': 166,
5938 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden', 'YouTube Music is not directly supported'],
5940 # TODO: fix 'unviewable' issue with this playlist when reloading with unavailable videos
5941 'note': 'Topic, should redirect to playlist?list=UU...',
5942 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5944 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5945 'title': 'Uploads from Royalty Free Music - Topic',
5947 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5948 'channel': 'Royalty Free Music - Topic',
5950 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5951 'modified_date': r
're:\d{8}',
5953 'availability': 'public',
5954 'uploader': 'Royalty Free Music - Topic',
5956 'playlist_mincount': 101,
5957 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5959 # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
5960 # Treat as a general feed
5961 'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
5963 'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
5964 'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
5967 'playlist_mincount': 9,
5969 'note': 'Youtube music Album',
5970 'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
5972 'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
5973 'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
5977 'availability': 'unlisted',
5978 'modified_date': r
're:\d{8}',
5980 'playlist_count': 50,
5981 'expected_warnings': ['YouTube Music is not directly supported'],
5983 'note': 'unlisted single video playlist',
5984 'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5986 'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5987 'title': 'yt-dlp unlisted playlist test',
5988 'availability': 'unlisted',
5990 'modified_date': '20220418',
5991 'channel': 'colethedj',
5994 'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5995 'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5996 'uploader_url': 'https://www.youtube.com/@colethedj1894',
5997 'uploader_id': '@colethedj1894',
5998 'uploader': 'colethedj',
6002 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
6003 'id': 'BaW_jenozKc',
6005 'ie_key': 'Youtube',
6007 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
6008 'channel_url': 'https://www.youtube.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
6010 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc',
6011 'channel': 'Philipp Hagemeister',
6012 'uploader_id': '@PhilippHagemeister',
6013 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
6014 'uploader': 'Philipp Hagemeister',
6017 'playlist_count': 1,
6018 'params': {'extract_flat': True}
,
6020 'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
6021 'url': 'https://www.youtube.com/feed/recommended',
6023 'id': 'recommended',
6024 'title': 'recommended',
6027 'playlist_mincount': 50,
6029 'skip_download': True,
6030 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6033 'note': 'API Fallback: /videos tab, sorted by oldest first',
6034 'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
6036 'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6037 'title': 'Cody\'sLab - Videos',
6038 'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
6039 'channel': 'Cody\'sLab',
6040 'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6042 'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
6043 'channel_follower_count': int
6045 'playlist_mincount': 650,
6047 'skip_download': True,
6048 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6050 'skip': 'Query for sorting no longer works',
6052 'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
6053 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
6055 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
6056 'title': 'Uploads from Royalty Free Music - Topic',
6057 'modified_date': r
're:\d{8}',
6058 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
6060 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
6062 'channel': 'Royalty Free Music - Topic',
6064 'availability': 'public',
6065 'uploader': 'Royalty Free Music - Topic',
6067 'playlist_mincount': 101,
6069 'skip_download': True,
6070 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6072 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
6074 'note': 'non-standard redirect to regional channel',
6075 'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
6076 'only_matching': True
6078 'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
6079 'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6081 'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6082 'modified_date': '20220407',
6083 'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
6085 'availability': 'unlisted',
6086 'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
6087 'channel': 'pukkandan',
6088 'description': 'Test for collaborative playlist',
6089 'title': 'yt-dlp test - collaborative playlist',
6091 'uploader_url': 'https://www.youtube.com/@pukkandan',
6092 'uploader_id': '@pukkandan',
6093 'uploader': 'pukkandan',
6095 'playlist_mincount': 2
6097 'note': 'translated tab name',
6098 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
6100 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6102 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6103 'description': 'test description',
6104 'title': 'cole-dlp-test-acc - 再生リスト',
6105 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6106 'channel': 'cole-dlp-test-acc',
6107 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6108 'uploader_id': '@coletdjnz',
6109 'uploader': 'cole-dlp-test-acc',
6111 'playlist_mincount': 1,
6112 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6113 'expected_warnings': ['Preferring "ja"'],
6115 # XXX: this should really check flat playlist entries, but the test suite doesn't support that
6116 'note': 'preferred lang set with playlist with translated video titles',
6117 'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6119 'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6122 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6123 'channel': 'cole-dlp-test-acc',
6124 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6125 'description': 'test',
6126 'title': 'dlp test playlist',
6127 'availability': 'public',
6128 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6129 'uploader_id': '@coletdjnz',
6130 'uploader': 'cole-dlp-test-acc',
6132 'playlist_mincount': 1,
6133 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6134 'expected_warnings': ['Preferring "ja"'],
6136 # shorts audio pivot for 2GtVksBMYFM.
6137 'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
6139 'id': 'sfv_audio_pivot',
6140 'title': 'sfv_audio_pivot',
6143 'playlist_mincount': 50,
6146 # Channel with a real live tab (not to be mistaken with streams tab)
6147 # Do not treat like it should redirect to live stream
6148 'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
6150 'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
6151 'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
6154 'playlist_mincount': 20,
6156 # Tab name is not the same as tab id
6157 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
6159 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6160 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
6163 'playlist_mincount': 8,
6165 # Home tab id is literally home. Not to get mistaken with featured
6166 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
6168 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6169 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
6172 'playlist_mincount': 8,
6174 # Should get three playlists for videos, shorts and streams tabs
6175 'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6177 'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6178 'title': 'Polka Ch. 尾丸ポルカ',
6179 'channel_follower_count': int,
6180 'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6181 'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6182 'description': 'md5:e56b74b5bb7e9c701522162e9abfb822',
6183 'channel': 'Polka Ch. 尾丸ポルカ',
6185 'uploader_url': 'https://www.youtube.com/@OmaruPolka',
6186 'uploader': 'Polka Ch. 尾丸ポルカ',
6187 'uploader_id': '@OmaruPolka',
6189 'playlist_count': 3,
6191 # Shorts tab with channel with handle
6192 # TODO: fix channel description
6193 'url': 'https://www.youtube.com/@NotJustBikes/shorts',
6195 'id': 'UC0intLFzLaudFG-xAvUEO-A',
6196 'title': 'Not Just Bikes - Shorts',
6198 'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
6199 'description': 'md5:26bc55af26855a608a5cf89dfa595c8d',
6200 'channel_follower_count': int,
6201 'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
6202 'channel': 'Not Just Bikes',
6203 'uploader_url': 'https://www.youtube.com/@NotJustBikes',
6204 'uploader': 'Not Just Bikes',
6205 'uploader_id': '@NotJustBikes',
6207 'playlist_mincount': 10,
6210 'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
6212 'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6213 'title': '中村悠一 - Live',
6215 'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6216 'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
6218 'channel_follower_count': int,
6219 'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
6220 'uploader_url': 'https://www.youtube.com/@Yuichi-Nakamura',
6221 'uploader_id': '@Yuichi-Nakamura',
6224 'playlist_mincount': 60,
6226 # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
6227 # See test_youtube_lists
6228 'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
6229 'only_matching': True,
6231 # No uploads and no UCID given. Should fail with no uploads error
6232 # See test_youtube_lists
6233 'url': 'https://www.youtube.com/news',
6234 'only_matching': True
6236 # No videos tab but has a shorts tab
6237 'url': 'https://www.youtube.com/c/TKFShorts',
6239 'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6240 'title': 'Shorts Break - Shorts',
6242 'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6243 'channel': 'Shorts Break',
6244 'description': 'md5:6de33c5e7ba686e5f3efd4e19c7ef499',
6245 'channel_follower_count': int,
6246 'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
6247 'uploader_url': 'https://www.youtube.com/@ShortsBreak_Official',
6248 'uploader': 'Shorts Break',
6249 'uploader_id': '@ShortsBreak_Official',
6251 'playlist_mincount': 30,
6253 # Trending Now Tab. tab id is empty
6254 'url': 'https://www.youtube.com/feed/trending',
6257 'title': 'trending - Now',
6260 'playlist_mincount': 30,
6262 # Trending Gaming Tab. tab id is empty
6263 'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
6266 'title': 'trending - Gaming',
6269 'playlist_mincount': 30,
6271 # Shorts url result in shorts tab
6272 # TODO: Fix channel id extraction
6273 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
6275 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6276 'title': 'cole-dlp-test-acc - Shorts',
6277 'channel': 'cole-dlp-test-acc',
6278 'description': 'test description',
6279 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6280 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6282 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6283 'uploader_id': '@coletdjnz',
6284 'uploader': 'cole-dlp-test-acc',
6288 # Channel data is not currently available for short renderers (as of 2023-03-01)
6290 'ie_key': 'Youtube',
6291 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
6292 'id': 'sSM9J5YH_60',
6293 'title': 'SHORT short',
6298 'params': {'extract_flat': True}
,
6300 # Live video status should be extracted
6301 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
6303 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6304 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live', # TODO, should be Minecraft - Live or Minecraft - Topic - Live
6310 'ie_key': 'Youtube',
6311 'url': 'startswith:https://www.youtube.com/watch?v=',
6314 'live_status': 'is_live',
6317 'concurrent_view_count': int,
6320 'uploader_url': str,
6322 'channel_is_verified': bool, # this will keep changing
6325 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6326 'playlist_mincount': 1
6328 # Channel renderer metadata. Contains number of videos on the channel
6329 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/channels',
6331 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6332 'title': 'cole-dlp-test-acc - Channels',
6333 'channel': 'cole-dlp-test-acc',
6334 'description': 'test description',
6335 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6336 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6338 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6339 'uploader_id': '@coletdjnz',
6340 'uploader': 'cole-dlp-test-acc',
6345 'ie_key': 'YoutubeTab',
6346 'url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6347 'id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6348 'channel_id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6349 'title': 'PewDiePie',
6350 'channel': 'PewDiePie',
6351 'channel_url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6353 'channel_follower_count': int,
6354 'playlist_count': int,
6355 'uploader': 'PewDiePie',
6356 'uploader_url': 'https://www.youtube.com/@PewDiePie',
6357 'uploader_id': '@PewDiePie',
6358 'channel_is_verified': True,
6361 'params': {'extract_flat': True}
,
6363 'url': 'https://www.youtube.com/@3blue1brown/about',
6365 'id': 'UCYO_jab_esuFRV4b17AJtAw',
6366 'tags': ['Mathematics'],
6367 'title': '3Blue1Brown - About',
6368 'channel_follower_count': int,
6369 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
6370 'channel': '3Blue1Brown',
6372 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
6373 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
6374 'uploader_url': 'https://www.youtube.com/@3blue1brown',
6375 'uploader_id': '@3blue1brown',
6376 'uploader': '3Blue1Brown',
6377 'channel_is_verified': True,
6379 'playlist_count': 0,
6381 # Podcasts tab, with rich entry playlistRenderers
6382 'url': 'https://www.youtube.com/@99percentinvisiblepodcast/podcasts',
6384 'id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6385 'channel_id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6386 'uploader_url': 'https://www.youtube.com/@99percentinvisiblepodcast',
6387 'description': 'md5:3a0ed38f1ad42a68ef0428c04a15695c',
6388 'title': '99 Percent Invisible - Podcasts',
6389 'uploader': '99 Percent Invisible',
6390 'channel_follower_count': int,
6391 'channel_url': 'https://www.youtube.com/channel/UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6393 'channel': '99 Percent Invisible',
6394 'uploader_id': '@99percentinvisiblepodcast',
6396 'playlist_count': 1,
6398 # Releases tab, with rich entry playlistRenderers (same as Podcasts tab)
6399 'url': 'https://www.youtube.com/@AHimitsu/releases',
6401 'id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6402 'channel': 'A Himitsu',
6403 'uploader_url': 'https://www.youtube.com/@AHimitsu',
6404 'title': 'A Himitsu - Releases',
6405 'uploader_id': '@AHimitsu',
6406 'uploader': 'A Himitsu',
6407 'channel_id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6409 'description': 'I make music',
6410 'channel_url': 'https://www.youtube.com/channel/UCgFwu-j5-xNJml2FtTrrB3A',
6411 'channel_follower_count': int,
6412 'channel_is_verified': True,
6414 'playlist_mincount': 10,
6416 # Playlist with only shorts, shown as reel renderers
6417 # FIXME: future: YouTube currently doesn't give continuation for this,
6419 'url': 'https://www.youtube.com/playlist?list=UUxqPAgubo4coVn9Lx1FuKcg',
6421 'id': 'UUxqPAgubo4coVn9Lx1FuKcg',
6422 'channel_url': 'https://www.youtube.com/channel/UCxqPAgubo4coVn9Lx1FuKcg',
6424 'uploader_id': '@BangyShorts',
6426 'uploader_url': 'https://www.youtube.com/@BangyShorts',
6427 'channel_id': 'UCxqPAgubo4coVn9Lx1FuKcg',
6428 'channel': 'Bangy Shorts',
6429 'uploader': 'Bangy Shorts',
6431 'availability': 'public',
6432 'modified_date': '20230626',
6433 'title': 'Uploads from Bangy Shorts',
6435 'playlist_mincount': 100,
6436 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6440 def suitable(cls
, url
):
6441 return False if YoutubeIE
.suitable(url
) else super().suitable(url
)
6443 _URL_RE
= re
.compile(rf
'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
6445 def _get_url_mobj(self
, url
):
6446 mobj
= self
._URL
_RE
.match(url
).groupdict()
6447 mobj
.update((k
, '') for k
, v
in mobj
.items() if v
is None)
6450 def _extract_tab_id_and_name(self
, tab
, base_url
='https://www.youtube.com'):
6451 tab_name
= (tab
.get('title') or '').lower()
6452 tab_url
= urljoin(base_url
, traverse_obj(
6453 tab
, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
6455 tab_id
= (tab_url
and self
._get
_url
_mobj
(tab_url
)['tab'][1:]
6456 or traverse_obj(tab
, 'tabIdentifier', expected_type
=str))
6459 'TAB_ID_SPONSORSHIPS': 'membership',
6460 }.get(tab_id
, tab_id
), tab_name
6462 # Fallback to tab name if we cannot get the tab id.
6463 # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6464 # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6466 self
.write_debug(f
'Falling back to selected tab name: {tab_name}')
6470 }.get(tab_name
, tab_name
), tab_name
6472 def _has_tab(self
, tabs
, tab_id
):
6473 return any(self
._extract
_tab
_id
_and
_name
(tab
)[0] == tab_id
for tab
in tabs
)
6475 def _empty_playlist(self
, item_id
, data
):
6476 return self
.playlist_result([], item_id
, **self
._extract
_metadata
_from
_tabs
(item_id
, data
))
6478 @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6479 def _real_extract(self
, url
, smuggled_data
):
6480 item_id
= self
._match
_id
(url
)
6481 url
= urllib
.parse
.urlunparse(
6482 urllib
.parse
.urlparse(url
)._replace
(netloc
='www.youtube.com'))
6483 compat_opts
= self
.get_param('compat_opts', [])
6485 mobj
= self
._get
_url
_mobj
(url
)
6486 pre
, tab
, post
, is_channel
= mobj
['pre'], mobj
['tab'], mobj
['post'], not mobj
['not_channel']
6487 if is_channel
and smuggled_data
.get('is_music_url'):
6488 if item_id
[:2] == 'VL': # Youtube music VL channels have an equivalent playlist
6489 return self
.url_result(
6490 f
'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE
, item_id
[2:])
6491 elif item_id
[:2] == 'MP': # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6492 mdata
= self
._extract
_tab
_endpoint
(
6493 f
'https://music.youtube.com/channel/{item_id}', item_id
, default_client
='web_music')
6494 murl
= traverse_obj(mdata
, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6495 get_all
=False, expected_type
=str)
6497 raise ExtractorError('Failed to resolve album to playlist')
6498 return self
.url_result(murl
, YoutubeTabIE
)
6499 elif mobj
['channel_type'] == 'browse': # Youtube music /browse/ should be changed to /channel/
6500 return self
.url_result(
6501 f
'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE
, item_id
)
6503 original_tab_id
, display_id
= tab
[1:], f
'{item_id}{tab}'
6504 if is_channel
and not tab
and 'no-youtube-channel-redirect' not in compat_opts
:
6505 url
= f
'{pre}/videos{post}'
6506 if smuggled_data
.get('is_music_url'):
6507 self
.report_warning(f
'YouTube Music is not directly supported. Redirecting to {url}')
6509 # Handle both video/playlist URLs
6511 video_id
, playlist_id
= [traverse_obj(qs
, (key
, 0)) for key
in ('v', 'list')]
6512 if not video_id
and mobj
['not_channel'].startswith('watch'):
6514 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6515 raise ExtractorError('A video URL was given without video ID', expected
=True)
6516 # Common mistake: https://www.youtube.com/watch?list=playlist_id
6517 self
.report_warning(f
'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6518 return self
.url_result(
6519 f
'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE
, playlist_id
)
6521 if not self
._yes
_playlist
(playlist_id
, video_id
):
6522 return self
.url_result(
6523 f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6525 data
, ytcfg
= self
._extract
_data
(url
, display_id
)
6527 # YouTube may provide a non-standard redirect to the regional channel
6528 # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6529 # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6530 redirect_url
= traverse_obj(
6531 data
, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all
=False)
6532 if redirect_url
and 'no-youtube-channel-redirect' not in compat_opts
:
6533 redirect_url
= ''.join((urljoin('https://www.youtube.com', redirect_url
), tab
, post
))
6534 self
.to_screen(f
'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6535 return self
.url_result(redirect_url
, YoutubeTabIE
)
6537 tabs
, extra_tabs
= self
._extract
_tab
_renderers
(data
), []
6538 if is_channel
and tabs
and 'no-youtube-channel-redirect' not in compat_opts
:
6539 selected_tab
= self
._extract
_selected
_tab
(tabs
)
6540 selected_tab_id
, selected_tab_name
= self
._extract
_tab
_id
_and
_name
(selected_tab
, url
) # NB: Name may be translated
6541 self
.write_debug(f
'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6543 # /about is no longer a tab
6544 if original_tab_id
== 'about':
6545 return self
._empty
_playlist
(item_id
, data
)
6547 if not original_tab_id
and selected_tab_name
:
6548 self
.to_screen('Downloading all uploads of the channel. '
6549 'To download only the videos in a specific tab, pass the tab\'s URL')
6550 if self
._has
_tab
(tabs
, 'streams'):
6551 extra_tabs
.append(''.join((pre
, '/streams', post
)))
6552 if self
._has
_tab
(tabs
, 'shorts'):
6553 extra_tabs
.append(''.join((pre
, '/shorts', post
)))
6554 # XXX: Members-only tab should also be extracted
6556 if not extra_tabs
and selected_tab_id
!= 'videos':
6557 # Channel does not have streams, shorts or videos tabs
6558 if item_id
[:2] != 'UC':
6559 return self
._empty
_playlist
(item_id
, data
)
6561 # Topic channels don't have /videos. Use the equivalent playlist instead
6562 pl_id
= f
'UU{item_id[2:]}'
6563 pl_url
= f
'https://www.youtube.com/playlist?list={pl_id}'
6565 data
, ytcfg
= self
._extract
_data
(pl_url
, pl_id
, ytcfg
=ytcfg
, fatal
=True, webpage_fatal
=True)
6566 except ExtractorError
:
6567 return self
._empty
_playlist
(item_id
, data
)
6569 item_id
, url
= pl_id
, pl_url
6571 f
'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6573 elif extra_tabs
and selected_tab_id
!= 'videos':
6574 # When there are shorts/live tabs but not videos tab
6575 url
, data
= f
'{pre}{post}', None
6577 elif (original_tab_id
or 'videos') != selected_tab_id
:
6578 if original_tab_id
== 'live':
6579 # Live tab should have redirected to the video
6580 # Except in the case the channel has an actual live tab
6581 # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6582 raise UserNotLive(video_id
=item_id
)
6583 elif selected_tab_name
:
6584 raise ExtractorError(f
'This channel does not have a {original_tab_id} tab', expected
=True)
6586 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6587 url
= f
'{pre}{post}'
6589 # YouTube sometimes provides a button to reload playlist with unavailable videos.
6590 if 'no-youtube-unavailable-videos' not in compat_opts
:
6591 data
= self
._reload
_with
_unavailable
_videos
(display_id
, data
, ytcfg
) or data
6592 self
._extract
_and
_report
_alerts
(data
, only_once
=True)
6594 tabs
, entries
= self
._extract
_tab
_renderers
(data
), []
6596 entries
= [self
._extract
_from
_tabs
(item_id
, ytcfg
, data
, tabs
)]
6598 'extractor_key': YoutubeTabIE
.ie_key(),
6599 'extractor': YoutubeTabIE
.IE_NAME
,
6602 if self
.get_param('playlist_items') == '0':
6603 entries
.extend(self
.url_result(u
, YoutubeTabIE
) for u
in extra_tabs
)
6604 else: # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6605 entries
.extend(map(self
._real
_extract
, extra_tabs
))
6607 if len(entries
) == 1:
6610 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
6611 uploads_url
= 'the Uploads (UU) playlist URL'
6612 if try_get(metadata
, lambda x
: x
['channel_id'].startswith('UC')):
6613 uploads_url
= f
'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6615 'Downloading as multiple playlists, separated by tabs. '
6616 f
'To download as a single playlist instead, pass {uploads_url}')
6617 return self
.playlist_result(entries
, item_id
, **metadata
)
6620 playlist
= traverse_obj(
6621 data
, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type
=dict)
6623 return self
._extract
_from
_playlist
(item_id
, url
, data
, playlist
, ytcfg
)
6625 video_id
= traverse_obj(
6626 data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str) or video_id
6628 if tab
!= '/live': # live tab is expected to redirect to video
6629 self
.report_warning(f
'Unable to recognize playlist. Downloading just video {video_id}')
6630 return self
.url_result(f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6632 raise ExtractorError('Unable to recognize tab page')
6635 class YoutubePlaylistIE(InfoExtractor
):
6636 IE_DESC
= 'YouTube playlists'
6637 _VALID_URL
= r
'''(?x)(?:
6642 youtube(?:kids)?\.com|
6647 (?P<id>%(playlist_id)s)
6649 'playlist_id': YoutubeBaseInfoExtractor
._PLAYLIST
_ID
_RE
,
6650 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
6652 IE_NAME
= 'youtube:playlist'
6654 'note': 'issue #673',
6655 'url': 'PLBB231211A4F62143',
6657 'title': '[OLD]Team Fortress 2 (Class-based LP)',
6658 'id': 'PLBB231211A4F62143',
6659 'uploader': 'Wickman',
6660 'uploader_id': '@WickmanVT',
6661 'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6663 'uploader_url': 'https://www.youtube.com/@WickmanVT',
6664 'modified_date': r
're:\d{8}',
6665 'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6666 'channel': 'Wickman',
6668 'channel_url': 'https://www.youtube.com/channel/UCKSpbfbl5kRQpTdL7kMc-1Q',
6669 'availability': 'public',
6671 'playlist_mincount': 29,
6673 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6675 'title': 'YDL_safe_search',
6676 'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6678 'playlist_count': 2,
6679 'skip': 'This playlist is private',
6682 'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6683 'playlist_count': 4,
6686 'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6687 'uploader': 'milan',
6688 'uploader_id': '@milan5503',
6690 'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6692 'modified_date': '20140919',
6695 'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6696 'uploader_url': 'https://www.youtube.com/@milan5503',
6697 'availability': 'public',
6699 'expected_warnings': [r
'[Uu]navailable videos? (is|are|will be) hidden', 'Retrying', 'Giving up'],
6701 'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6702 'playlist_mincount': 455,
6704 'title': '2018 Chinese New Singles (11/6 updated)',
6705 'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6707 'uploader_id': '@music_king',
6708 'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6711 'channel_url': 'https://www.youtube.com/channel/UC21nz3_MesPLqtDqwdvnoxA',
6713 'uploader_url': 'https://www.youtube.com/@music_king',
6714 'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6715 'modified_date': r
're:\d{8}',
6716 'availability': 'public',
6718 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6720 'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6721 'only_matching': True,
6723 # music album playlist
6724 'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6725 'only_matching': True,
6729 def suitable(cls
, url
):
6730 if YoutubeTabIE
.suitable(url
):
6732 from ..utils
import parse_qs
6734 if qs
.get('v', [None])[0]:
6736 return super().suitable(url
)
6738 def _real_extract(self
, url
):
6739 playlist_id
= self
._match
_id
(url
)
6740 is_music_url
= YoutubeBaseInfoExtractor
.is_music_url(url
)
6741 url
= update_url_query(
6742 'https://www.youtube.com/playlist',
6743 parse_qs(url
) or {'list': playlist_id}
)
6745 url
= smuggle_url(url
, {'is_music_url': True}
)
6746 return self
.url_result(url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6749 class YoutubeYtBeIE(InfoExtractor
):
6750 IE_DESC
= 'youtu.be'
6751 _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}
6753 'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6755 'id': 'yeWKywCrFtk',
6757 'title': 'Small Scale Baler and Braiding Rugs',
6758 'uploader': 'Backus-Page House Museum',
6759 'uploader_id': '@backuspagemuseum',
6760 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/@backuspagemuseum',
6761 'upload_date': '20161008',
6762 'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6763 'categories': ['Nonprofits & Activism'],
6767 'playable_in_embed': True,
6768 'thumbnail': r
're:^https?://.*\.webp',
6769 'channel': 'Backus-Page House Museum',
6770 'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6771 'live_status': 'not_live',
6773 'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6774 'availability': 'public',
6776 'comment_count': int,
6777 'channel_follower_count': int
6781 'skip_download': True,
6784 'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6785 'only_matching': True,
6788 def _real_extract(self
, url
):
6789 mobj
= self
._match
_valid
_url
(url
)
6790 video_id
= mobj
.group('id')
6791 playlist_id
= mobj
.group('playlist_id')
6792 return self
.url_result(
6793 update_url_query('https://www.youtube.com/watch', {
6795 'list': playlist_id
,
6796 'feature': 'youtu.be',
6797 }), ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6800 class YoutubeLivestreamEmbedIE(InfoExtractor
):
6801 IE_DESC
= 'YouTube livestream embeds'
6802 _VALID_URL
= r
'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6804 'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6805 'only_matching': True,
6808 def _real_extract(self
, url
):
6809 channel_id
= self
._match
_id
(url
)
6810 return self
.url_result(
6811 f
'https://www.youtube.com/channel/{channel_id}/live',
6812 ie
=YoutubeTabIE
.ie_key(), video_id
=channel_id
)
6815 class YoutubeYtUserIE(InfoExtractor
):
6816 IE_DESC
= 'YouTube user videos; "ytuser:" prefix'
6817 IE_NAME
= 'youtube:user'
6818 _VALID_URL
= r
'ytuser:(?P<id>.+)'
6820 'url': 'ytuser:phihag',
6821 'only_matching': True,
6824 def _real_extract(self
, url
):
6825 user_id
= self
._match
_id
(url
)
6826 return self
.url_result(f
'https://www.youtube.com/user/{user_id}', YoutubeTabIE
, user_id
)
6829 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor
):
6830 IE_NAME
= 'youtube:favorites'
6831 IE_DESC
= 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6832 _VALID_URL
= r
':ytfav(?:ou?rite)?s?'
6833 _LOGIN_REQUIRED
= True
6836 'only_matching': True,
6838 'url': ':ytfavorites',
6839 'only_matching': True,
6842 def _real_extract(self
, url
):
6843 return self
.url_result(
6844 'https://www.youtube.com/playlist?list=LL',
6845 ie
=YoutubeTabIE
.ie_key())
6848 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor
):
6849 IE_NAME
= 'youtube:notif'
6850 IE_DESC
= 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6851 _VALID_URL
= r
':ytnotif(?:ication)?s?'
6852 _LOGIN_REQUIRED
= True
6855 'only_matching': True,
6857 'url': ':ytnotifications',
6858 'only_matching': True,
6861 def _extract_notification_menu(self
, response
, continuation_list
):
6862 notification_list
= traverse_obj(
6864 ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6865 ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6866 expected_type
=list) or []
6867 continuation_list
[0] = None
6868 for item
in notification_list
:
6869 entry
= self
._extract
_notification
_renderer
(item
.get('notificationRenderer'))
6872 continuation
= item
.get('continuationItemRenderer')
6874 continuation_list
[0] = continuation
6876 def _extract_notification_renderer(self
, notification
):
6877 video_id
= traverse_obj(
6878 notification
, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str)
6879 url
= f
'https://www.youtube.com/watch?v={video_id}'
6882 browse_ep
= traverse_obj(
6883 notification
, ('navigationEndpoint', 'browseEndpoint'), expected_type
=dict)
6884 channel_id
= self
.ucid_or_none(traverse_obj(browse_ep
, 'browseId', expected_type
=str))
6885 post_id
= self
._search
_regex
(
6886 r
'/post/(.+)', traverse_obj(browse_ep
, 'canonicalBaseUrl', expected_type
=str),
6887 'post id', default
=None)
6888 if not channel_id
or not post_id
:
6890 # The direct /post url redirects to this in the browser
6891 url
= f
'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
6893 channel
= traverse_obj(
6894 notification
, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
6896 notification_title
= self
._get
_text
(notification
, 'shortMessage')
6897 if notification_title
:
6898 notification_title
= notification_title
.replace('\xad', '') # remove soft hyphens
6899 # TODO: handle recommended videos
6900 title
= self
._search
_regex
(
6901 rf
'{re.escape(channel or "")}[^:]+: (.+)', notification_title
,
6902 'video title', default
=None)
6903 timestamp
= (self
._parse
_time
_text
(self
._get
_text
(notification
, 'sentTimeText'))
6904 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
6909 'ie_key': (YoutubeIE
if video_id
else YoutubeTabIE
).ie_key(),
6910 'video_id': video_id
,
6912 'channel_id': channel_id
,
6914 'uploader': channel
,
6915 'thumbnails': self
._extract
_thumbnails
(notification
, 'videoThumbnail'),
6916 'timestamp': timestamp
,
6919 def _notification_menu_entries(self
, ytcfg
):
6920 continuation_list
= [None]
6922 for page
in itertools
.count(1):
6923 ctoken
= traverse_obj(
6924 continuation_list
, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type
=str)
6925 response
= self
._extract
_response
(
6926 item_id
=f
'page {page}', query
={'ctoken': ctoken}
if ctoken
else {}, ytcfg
=ytcfg
,
6927 ep
='notification/get_notification_menu', check_get_keys
='actions',
6928 headers
=self
.generate_api_headers(ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(response
)))
6929 yield from self
._extract
_notification
_menu
(response
, continuation_list
)
6930 if not continuation_list
[0]:
6933 def _real_extract(self
, url
):
6934 display_id
= 'notifications'
6935 ytcfg
= self
._download
_ytcfg
('web', display_id
) if not self
.skip_webpage
else {}
6936 self
._report
_playlist
_authcheck
(ytcfg
)
6937 return self
.playlist_result(self
._notification
_menu
_entries
(ytcfg
), display_id
, display_id
)
6940 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6941 IE_DESC
= 'YouTube search'
6942 IE_NAME
= 'youtube:search'
6943 _SEARCH_KEY
= 'ytsearch'
6944 _SEARCH_PARAMS
= 'EgIQAQ%3D%3D' # Videos only
6946 'url': 'ytsearch5:youtube-dl test video',
6947 'playlist_count': 5,
6949 'id': 'youtube-dl test video',
6950 'title': 'youtube-dl test video',
6955 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6956 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ ':date'
6957 _SEARCH_KEY
= 'ytsearchdate'
6958 IE_DESC
= 'YouTube search, newest videos first'
6959 _SEARCH_PARAMS
= 'CAISAhAB' # Videos only, sorted by date
6961 'url': 'ytsearchdate5:youtube-dl test video',
6962 'playlist_count': 5,
6964 'id': 'youtube-dl test video',
6965 'title': 'youtube-dl test video',
6970 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor
):
6971 IE_DESC
= 'YouTube search URLs with sorting and filter support'
6972 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ '_url'
6973 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6975 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
6976 'playlist_mincount': 5,
6978 'id': 'youtube-dl test video',
6979 'title': 'youtube-dl test video',
6982 'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
6983 'playlist_mincount': 5,
6989 'url': 'https://www.youtube.com/results?search_query=%23cats',
6990 'playlist_mincount': 1,
6994 # The test suite does not have support for nested playlists
6996 # 'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
7002 'url': 'https://www.youtube.com/results?search_query=kurzgesagt&sp=EgIQAg%253D%253D',
7005 'title': 'kurzgesagt',
7010 'id': 'UCsXVk37bltHxD1rDPwtNM8Q',
7011 'url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
7012 'ie_key': 'YoutubeTab',
7013 'channel': 'Kurzgesagt – In a Nutshell',
7014 'description': 'md5:4ae48dfa9505ffc307dad26342d06bfc',
7015 'title': 'Kurzgesagt – In a Nutshell',
7016 'channel_id': 'UCsXVk37bltHxD1rDPwtNM8Q',
7017 # No longer available for search as it is set to the handle.
7018 # 'playlist_count': int,
7019 'channel_url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
7021 'uploader_id': '@kurzgesagt',
7022 'uploader_url': 'https://www.youtube.com/@kurzgesagt',
7023 'uploader': 'Kurzgesagt – In a Nutshell',
7024 'channel_is_verified': True,
7025 'channel_follower_count': int,
7028 'params': {'extract_flat': True, 'playlist_items': '1'}
,
7029 'playlist_mincount': 1,
7031 'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
7032 'only_matching': True,
7035 def _real_extract(self
, url
):
7037 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7038 return self
.playlist_result(self
._search
_results
(query
, qs
.get('sp', (None,))[0]), query
, query
)
7041 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor
):
7042 IE_DESC
= 'YouTube music search URLs with selectable sections, e.g. #songs'
7043 IE_NAME
= 'youtube:music:search_url'
7044 _VALID_URL
= r
'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
7046 'url': 'https://music.youtube.com/search?q=royalty+free+music',
7047 'playlist_count': 16,
7049 'id': 'royalty free music',
7050 'title': 'royalty free music',
7053 'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
7054 'playlist_mincount': 30,
7056 'id': 'royalty free music - songs',
7057 'title': 'royalty free music - songs',
7059 'params': {'extract_flat': 'in_playlist'}
7061 'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
7062 'playlist_mincount': 30,
7064 'id': 'royalty free music - community playlists',
7065 'title': 'royalty free music - community playlists',
7067 'params': {'extract_flat': 'in_playlist'}
7071 'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
7072 'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
7073 'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
7074 'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
7075 'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
7076 'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
7079 def _real_extract(self
, url
):
7081 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7082 params
= qs
.get('sp', (None,))[0]
7084 section
= next((k
for k
, v
in self
._SECTIONS
.items() if v
== params
), params
)
7086 section
= urllib
.parse
.unquote_plus((url
.split('#') + [''])[1]).lower()
7087 params
= self
._SECTIONS
.get(section
)
7090 title
= join_nonempty(query
, section
, delim
=' - ')
7091 return self
.playlist_result(self
._search
_results
(query
, params
, default_client
='web_music'), title
, title
)
7094 class YoutubeFeedsInfoExtractor(InfoExtractor
):
7096 Base class for feed extractors
7097 Subclasses must re-define the _FEED_NAME property.
7099 _LOGIN_REQUIRED
= True
7100 _FEED_NAME
= 'feeds'
7102 def _real_initialize(self
):
7103 YoutubeBaseInfoExtractor
._check
_login
_required
(self
)
7107 return f
'youtube:{self._FEED_NAME}'
7109 def _real_extract(self
, url
):
7110 return self
.url_result(
7111 f
'https://www.youtube.com/feed/{self._FEED_NAME}', ie
=YoutubeTabIE
.ie_key())
7114 class YoutubeWatchLaterIE(InfoExtractor
):
7115 IE_NAME
= 'youtube:watchlater'
7116 IE_DESC
= 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
7117 _VALID_URL
= r
':ytwatchlater'
7119 'url': ':ytwatchlater',
7120 'only_matching': True,
7123 def _real_extract(self
, url
):
7124 return self
.url_result(
7125 'https://www.youtube.com/playlist?list=WL', ie
=YoutubeTabIE
.ie_key())
7128 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor
):
7129 IE_DESC
= 'YouTube recommended videos; ":ytrec" keyword'
7130 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
7131 _FEED_NAME
= 'recommended'
7132 _LOGIN_REQUIRED
= False
7135 'only_matching': True,
7137 'url': ':ytrecommended',
7138 'only_matching': True,
7140 'url': 'https://youtube.com',
7141 'only_matching': True,
7145 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor
):
7146 IE_DESC
= 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
7147 _VALID_URL
= r
':ytsub(?:scription)?s?'
7148 _FEED_NAME
= 'subscriptions'
7151 'only_matching': True,
7153 'url': ':ytsubscriptions',
7154 'only_matching': True,
7158 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor
):
7159 IE_DESC
= 'Youtube watch history; ":ythis" keyword (requires cookies)'
7160 _VALID_URL
= r
':ythis(?:tory)?'
7161 _FEED_NAME
= 'history'
7163 'url': ':ythistory',
7164 'only_matching': True,
7168 class YoutubeShortsAudioPivotIE(InfoExtractor
):
7169 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
7170 IE_NAME
= 'youtube:shorts:pivot:audio'
7171 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
7173 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
7174 'only_matching': True,
7178 def _generate_audio_pivot_params(video_id
):
7180 Generates sfv_audio_pivot browse params for this video id
7182 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
7183 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
7185 def _real_extract(self
, url
):
7186 video_id
= self
._match
_id
(url
)
7187 return self
.url_result(
7188 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
7192 class YoutubeTruncatedURLIE(InfoExtractor
):
7193 IE_NAME
= 'youtube:truncated_url'
7194 IE_DESC
= False # Do not list
7195 _VALID_URL
= r
'''(?x)
7197 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
7200 annotation_id=annotation_[^&]+|
7206 attribution_link\?a=[^&]+
7212 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
7213 'only_matching': True,
7215 'url': 'https://www.youtube.com/watch?',
7216 'only_matching': True,
7218 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
7219 'only_matching': True,
7221 'url': 'https://www.youtube.com/watch?feature=foo',
7222 'only_matching': True,
7224 'url': 'https://www.youtube.com/watch?hl=en-GB',
7225 'only_matching': True,
7227 'url': 'https://www.youtube.com/watch?t=2372',
7228 'only_matching': True,
7231 def _real_extract(self
, url
):
7232 raise ExtractorError(
7233 'Did you forget to quote the URL? Remember that & is a meta '
7234 'character in most shells, so you want to put the URL in quotes, '
7236 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
7237 ' or simply youtube-dl BaW_jenozKc .',
7241 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
7242 IE_NAME
= 'youtube:clip'
7243 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7245 # FIXME: Other metadata should be extracted from the clip, not from the base video
7246 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7248 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7250 'section_start': 29.0,
7251 'section_end': 39.7,
7254 'availability': 'public',
7255 'categories': ['Gaming'],
7256 'channel': 'Scott The Woz',
7257 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7258 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7259 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7261 'playable_in_embed': True,
7263 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7264 'title': 'Mobile Games on Console - Scott The Woz',
7265 'upload_date': '20210920',
7266 'uploader': 'Scott The Woz',
7267 'uploader_id': '@ScottTheWoz',
7268 'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7270 'live_status': 'not_live',
7271 'channel_follower_count': int,
7272 'chapters': 'count:20',
7273 'comment_count': int,
7274 'heatmap': 'count:100',
7278 def _real_extract(self
, url
):
7279 clip_id
= self
._match
_id
(url
)
7280 _
, data
= self
._extract
_webpage
(url
, clip_id
)
7282 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7284 raise ExtractorError('Unable to find video ID')
7286 clip_data
= traverse_obj(data
, (
7287 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7288 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7289 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7290 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
7293 '_type': 'url_transparent',
7294 'url': f
'https://www.youtube.com/watch?v={video_id}',
7295 'ie_key': YoutubeIE
.ie_key(),
7297 'section_start': int(clip_data
['startTimeMs']) / 1000,
7298 'section_end': int(clip_data
['endTimeMs']) / 1000,
7302 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor
):
7303 IE_NAME
= 'youtube:consent'
7304 IE_DESC
= False # Do not list
7305 _VALID_URL
= r
'https?://consent\.youtube\.com/m\?'
7307 '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',
7309 'id': 'qVv6vCqciTM',
7312 'uploader_id': '@sana_natori',
7313 'comment_count': int,
7314 'chapters': 'count:13',
7315 'upload_date': '20221223',
7316 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7317 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7318 'uploader_url': 'https://www.youtube.com/@sana_natori',
7320 'release_date': '20221223',
7321 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7322 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7324 'playable_in_embed': True,
7326 'availability': 'public',
7327 'channel_follower_count': int,
7328 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7329 'categories': ['Entertainment'],
7330 'live_status': 'was_live',
7331 'release_timestamp': 1671793345,
7332 'channel': 'さなちゃんねる',
7333 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7334 'uploader': 'さなちゃんねる',
7335 'channel_is_verified': True,
7336 'heatmap': 'count:100',
7338 'add_ie': ['Youtube'],
7339 'params': {'skip_download': 'Youtube'}
,
7342 def _real_extract(self
, url
):
7343 redirect_url
= url_or_none(parse_qs(url
).get('continue', [None])[-1])
7344 if not redirect_url
:
7345 raise ExtractorError('Invalid cookie consent redirect URL', expected
=True)
7346 return self
.url_result(redirect_url
)
7349 class YoutubeTruncatedIDIE(InfoExtractor
):
7350 IE_NAME
= 'youtube:truncated_id'
7351 IE_DESC
= False # Do not list
7352 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7355 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7356 'only_matching': True,
7359 def _real_extract(self
, url
):
7360 video_id
= self
._match
_id
(url
)
7361 raise ExtractorError(
7362 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',