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': '17.31.35',
118 'androidSdkVersion': 30,
119 'userAgent': 'com.google.android.youtube/17.31.35 (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': '17.31.35',
131 'androidSdkVersion': 30,
132 'userAgent': 'com.google.android.youtube/17.31.35 (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': '17.33.2',
172 'deviceModel': 'iPhone14,3',
173 'userAgent': 'com.google.ios.youtube/17.33.2 (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': '17.33.2',
184 'deviceModel': 'iPhone14,3',
185 'userAgent': 'com.google.ios.youtube/17.33.2 (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\.)?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 for retry
in self
.RetryManager():
946 response
= self
._call
_api
(
947 ep
=ep
, fatal
=True, headers
=headers
,
948 video_id
=item_id
, query
=query
, note
=note
,
949 context
=self
._extract
_context
(ytcfg
, default_client
),
950 api_key
=self
._extract
_api
_key
(ytcfg
, default_client
),
951 api_hostname
=api_hostname
, default_client
=default_client
)
952 except ExtractorError
as e
:
953 if not isinstance(e
.cause
, network_exceptions
):
954 return self
._error
_or
_warning
(e
, fatal
=fatal
)
955 elif not isinstance(e
.cause
, HTTPError
):
959 first_bytes
= e
.cause
.response
.read(512)
960 if not is_html(first_bytes
):
963 self
._webpage
_read
_content
(e
.cause
.response
, None, item_id
, prefix
=first_bytes
) or '{}', item_id
, fatal
=False),
964 lambda x
: x
['error']['message'], str)
966 self
._report
_alerts
([('ERROR', yt_error
)], fatal
=False)
967 # Downloading page may result in intermittent 5xx HTTP error
968 # Sometimes a 404 is also recieved. See: https://github.com/ytdl-org/youtube-dl/issues/28289
969 # We also want to catch all other network exceptions since errors in later pages can be troublesome
970 # See https://github.com/yt-dlp/yt-dlp/issues/507#issuecomment-880188210
971 if e
.cause
.status
not in (403, 429):
974 return self
._error
_or
_warning
(e
, fatal
=fatal
)
977 self
._extract
_and
_report
_alerts
(response
, only_once
=True)
978 except ExtractorError
as e
:
979 # YouTube servers may return errors we want to retry on in a 200 OK response
980 # See: https://github.com/yt-dlp/yt-dlp/issues/839
981 if 'unknown error' in e
.msg
.lower():
984 return self
._error
_or
_warning
(e
, fatal
=fatal
)
985 # Youtube sometimes sends incomplete data
986 # See: https://github.com/ytdl-org/youtube-dl/issues/28194
987 if not traverse_obj(response
, *variadic(check_get_keys
)):
988 retry
.error
= ExtractorError('Incomplete data received', expected
=True)
994 def is_music_url(url
):
995 return re
.match(r
'(https?://)?music\.youtube\.com/', url
) is not None
997 def _extract_video(self
, renderer
):
998 video_id
= renderer
.get('videoId')
1000 reel_header_renderer
= traverse_obj(renderer
, (
1001 'navigationEndpoint', 'reelWatchEndpoint', 'overlay', 'reelPlayerOverlayRenderer',
1002 'reelPlayerHeaderSupportedRenderers', 'reelPlayerHeaderRenderer'))
1004 title
= self
._get
_text
(renderer
, 'title', 'headline') or self
._get
_text
(reel_header_renderer
, 'reelTitleText')
1005 description
= self
._get
_text
(renderer
, 'descriptionSnippet')
1007 duration
= int_or_none(renderer
.get('lengthSeconds'))
1008 if duration
is None:
1009 duration
= parse_duration(self
._get
_text
(
1010 renderer
, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
1011 if duration
is None:
1012 # XXX: should write a parser to be more general to support more cases (e.g. shorts in shorts tab)
1013 duration
= parse_duration(self
._search
_regex
(
1014 r
'(?i)(ago)(?!.*\1)\s+(?P<duration>[a-z0-9 ,]+?)(?:\s+[\d,]+\s+views)?(?:\s+-\s+play\s+short)?$',
1015 traverse_obj(renderer
, ('title', 'accessibility', 'accessibilityData', 'label'), default
='', expected_type
=str),
1016 video_id
, default
=None, group
='duration'))
1018 channel_id
= traverse_obj(
1019 renderer
, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'),
1020 expected_type
=str, get_all
=False)
1022 channel_id
= traverse_obj(reel_header_renderer
, ('channelNavigationEndpoint', 'browseEndpoint', 'browseId'))
1024 channel_id
= self
.ucid_or_none(channel_id
)
1026 overlay_style
= traverse_obj(
1027 renderer
, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'),
1028 get_all
=False, expected_type
=str)
1029 badges
= self
._extract
_badges
(traverse_obj(renderer
, 'badges'))
1030 owner_badges
= self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges'))
1031 navigation_url
= urljoin('https://www.youtube.com/', traverse_obj(
1032 renderer
, ('navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url'),
1033 expected_type
=str)) or ''
1034 url
= f
'https://www.youtube.com/watch?v={video_id}'
1035 if overlay_style
== 'SHORTS' or '/shorts/' in navigation_url
:
1036 url
= f
'https://www.youtube.com/shorts/{video_id}'
1038 time_text
= (self
._get
_text
(renderer
, 'publishedTimeText', 'videoInfo')
1039 or self
._get
_text
(reel_header_renderer
, 'timestampText') or '')
1040 scheduled_timestamp
= str_to_int(traverse_obj(renderer
, ('upcomingEventData', 'startTime'), get_all
=False))
1043 'is_upcoming' if scheduled_timestamp
is not None
1044 else 'was_live' if 'streamed' in time_text
.lower()
1045 else 'is_live' if overlay_style
== 'LIVE' or self
._has
_badge
(badges
, BadgeType
.LIVE_NOW
)
1048 # videoInfo is a string like '50K views • 10 years ago'.
1049 view_count_text
= self
._get
_text
(renderer
, 'viewCountText', 'shortViewCountText', 'videoInfo') or ''
1050 view_count
= (0 if 'no views' in view_count_text
.lower()
1051 else self
._get
_count
({'simpleText': view_count_text}
))
1052 view_count_field
= 'concurrent_view_count' if live_status
in ('is_live', 'is_upcoming') else 'view_count'
1054 channel
= (self
._get
_text
(renderer
, 'ownerText', 'shortBylineText')
1055 or self
._get
_text
(reel_header_renderer
, 'channelTitleText'))
1057 channel_handle
= traverse_obj(renderer
, (
1058 'shortBylineText', 'runs', ..., 'navigationEndpoint',
1059 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl'))),
1060 expected_type
=self
.handle_from_url
, get_all
=False)
1063 'ie_key': YoutubeIE
.ie_key(),
1067 'description': description
,
1068 'duration': duration
,
1069 'channel_id': channel_id
,
1071 'channel_url': f
'https://www.youtube.com/channel/{channel_id}' if channel_id
else None,
1072 'uploader': channel
,
1073 'uploader_id': channel_handle
,
1074 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
1075 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
1076 'timestamp': (self
._parse
_time
_text
(time_text
)
1077 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
1079 'release_timestamp': scheduled_timestamp
,
1081 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
1082 else self
._availability
(
1083 is_private
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
) or None,
1084 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
1085 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
1086 is_unlisted
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
) or None),
1087 view_count_field
: view_count
,
1088 'live_status': live_status
,
1089 'channel_is_verified': True if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
) else None
1093 class YoutubeIE(YoutubeBaseInfoExtractor
):
1095 _VALID_URL
= r
"""(?x)^
1097 (?:https?://|//) # http(s):// or protocol-independent URL
1098 (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
1099 (?:www\.)?deturl\.com/www\.youtube\.com|
1100 (?:www\.)?pwnyoutube\.com|
1101 (?:www\.)?hooktube\.com|
1102 (?:www\.)?yourepeat\.com|
1103 tube\.majestyc\.net|
1105 youtube\.googleapis\.com)/ # the various hostnames, with wildcard subdomains
1106 (?:.*?\#/)? # handle anchor (#/) redirect urls
1107 (?: # the various things that can precede the ID:
1108 (?:(?:v|embed|e|shorts|live)/(?!videoseries|live_stream)) # v/ or embed/ or e/ or shorts/
1109 |(?: # or the v= param in all its forms
1110 (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
1111 (?:\?|\#!?) # the params delimiter ? or # or #!
1112 (?:.*?[&;])?? # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&v=V36LpHqtcDY)
1117 youtu\.be| # just youtu.be/xxxx
1118 vid\.plus| # or vid.plus/xxxx
1119 zwearz\.com/watch| # or zwearz.com/watch/xxxx
1122 |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
1124 )? # all until now is optional -> you can pass the naked ID
1125 (?P<id>[0-9A-Za-z_-]{11}) # here is it! the YouTube video ID
1126 (?(1).+)? # if we found the ID, everything can follow
1128 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
1133 <(?:[0-9A-Za-z-]+?)?iframe[^>]+?src=|
1141 (?P
<url
>(?
:https?
:)?
//(?
:www\
.)?
youtube(?
:-nocookie
)?\
.com
/
1142 (?
:embed|v|p
)/[0-9A
-Za
-z_
-]{11}
.*?
)
1144 # https://wordpress.org/plugins/lazy-load-for-videos/
1146 <a\s
[^
>]*\bhref
="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"
1147 \s
[^
>]*\bclass
="[^"]*\blazy
-load
-youtube
''',
1149 _RETURN_TYPE = 'video' # XXX: How to handle multifeed?
1152 r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
1153 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$',
1154 r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
1157 '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1158 '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1159 '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
1160 '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
1161 '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
1162 '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1163 '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1164 '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1165 # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
1166 '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
1167 '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1168 '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1169 '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1170 '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1171 '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1172 '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1173 '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1174 '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1178 '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1179 '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1180 '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1181 '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1182 '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
1183 '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1184 '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1186 # Apple HTTP Live Streaming
1187 '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1188 '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1189 '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1190 '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1191 '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1192 '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1193 '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1194 '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
1197 '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
1198 '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
1199 '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1200 '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
1201 '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
1202 '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'}, # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
1203 '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
1204 '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1205 '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
1206 '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1207 '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1208 '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
1211 '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
1212 '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
1213 '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
1214 '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1215 '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1216 '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
1217 '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
1220 '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1221 '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1222 '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1223 '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1224 '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1225 '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1226 '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
1227 '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1228 '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1229 '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1230 '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1231 '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1232 '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1233 '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1234 '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1235 # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
1236 '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1237 '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1238 '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1239 '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1240 '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1241 '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1244 '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
1245 '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
1247 # Dash webm audio with opus inside
1248 '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
1249 '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
1250 '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
1253 '_rtmp': {'protocol': 'rtmp'},
1255 # av01 video only formats sometimes served with "unknown" codecs
1256 '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1257 '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1258 '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1259 '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1260 '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1261 '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1262 '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1263 '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1265 _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1272 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1274 'id': 'BaW_jenozKc',
1276 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1277 'channel': 'Philipp Hagemeister',
1278 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1279 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1280 'upload_date': '20121002',
1281 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1282 'categories': ['Science & Technology'],
1283 'tags': ['youtube-dl'],
1287 'availability': 'public',
1288 'playable_in_embed': True,
1289 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1290 'live_status': 'not_live',
1294 'comment_count': int,
1295 'channel_follower_count': int,
1296 'uploader': 'Philipp Hagemeister',
1297 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1298 'uploader_id': '@PhilippHagemeister',
1299 'heatmap': 'count:100',
1303 'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1304 'note': 'Embed-only video (#1746)',
1306 'id': 'yZIXLfi8CZQ',
1308 'upload_date': '20120608',
1309 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1310 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1313 'skip': 'Private video',
1316 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1317 'note': 'Use the first video ID in the URL',
1319 'id': 'BaW_jenozKc',
1321 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1322 'channel': 'Philipp Hagemeister',
1323 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1324 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1325 'upload_date': '20121002',
1326 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1327 'categories': ['Science & Technology'],
1328 'tags': ['youtube-dl'],
1332 'availability': 'public',
1333 'playable_in_embed': True,
1334 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1335 'live_status': 'not_live',
1337 'comment_count': int,
1338 'channel_follower_count': int,
1339 'uploader': 'Philipp Hagemeister',
1340 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1341 'uploader_id': '@PhilippHagemeister',
1342 'heatmap': 'count:100',
1345 'skip_download': True,
1349 'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1350 'note': '256k DASH audio (format 141) via DASH manifest',
1352 'id': 'a9LDPn-MO4I',
1354 'upload_date': '20121002',
1356 'title': 'UHDTV TEST 8K VIDEO.mp4'
1359 'youtube_include_dash_manifest': True,
1362 'skip': 'format 141 not served anymore',
1364 # DASH manifest with encrypted signature
1366 'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1368 'id': 'IB3lcPjvWLA',
1370 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1371 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1373 'upload_date': '20131011',
1376 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1377 'playable_in_embed': True,
1378 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1380 'track': 'The Spark',
1381 'live_status': 'not_live',
1382 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1383 'channel': 'Afrojack',
1385 'availability': 'public',
1386 'categories': ['Music'],
1388 'alt_title': 'The Spark',
1389 'channel_follower_count': int,
1390 'uploader': 'Afrojack',
1391 'uploader_url': 'https://www.youtube.com/@Afrojack',
1392 'uploader_id': '@Afrojack',
1395 'youtube_include_dash_manifest': True,
1396 'format': '141/bestaudio[ext=m4a]',
1399 # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1401 'note': 'Embed allowed age-gate video',
1402 'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1404 'id': 'HtVdAasjOgU',
1406 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1407 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1409 'upload_date': '20140605',
1411 'categories': ['Gaming'],
1412 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1413 'availability': 'needs_auth',
1414 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1416 'channel': 'The Witcher',
1417 'live_status': 'not_live',
1419 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1420 'playable_in_embed': True,
1422 'channel_follower_count': int,
1423 'uploader': 'The Witcher',
1424 'uploader_url': 'https://www.youtube.com/@thewitcher',
1425 'uploader_id': '@thewitcher',
1426 'comment_count': int,
1427 'channel_is_verified': True,
1428 'heatmap': 'count:100',
1432 'note': 'Age-gate video with embed allowed in public site',
1433 'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1435 'id': 'HsUATh_Nc2U',
1437 'title': 'Godzilla 2 (Official Video)',
1438 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1439 'upload_date': '20200408',
1441 'availability': 'needs_auth',
1442 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1443 'channel': 'FlyingKitty',
1444 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1446 'categories': ['Entertainment'],
1447 'live_status': 'not_live',
1448 'tags': ['Flyingkitty', 'godzilla 2'],
1449 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1452 'playable_in_embed': True,
1453 'channel_follower_count': int,
1454 'uploader': 'FlyingKitty',
1455 'uploader_url': 'https://www.youtube.com/@FlyingKitty900',
1456 'uploader_id': '@FlyingKitty900',
1457 'comment_count': int,
1458 'channel_is_verified': True,
1462 'note': 'Age-gate video embedable only with clientScreen=EMBED',
1463 'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1465 'id': 'Tq92D6wQ1mg',
1466 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1468 'upload_date': '20191228',
1469 'description': 'md5:17eccca93a786d51bc67646756894066',
1472 'availability': 'needs_auth',
1473 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1475 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1476 'channel': 'Projekt Melody',
1477 'live_status': 'not_live',
1478 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1479 'playable_in_embed': True,
1480 'categories': ['Entertainment'],
1482 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1483 'comment_count': int,
1484 'channel_follower_count': int,
1485 'uploader': 'Projekt Melody',
1486 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
1487 'uploader_id': '@ProjektMelody',
1491 'note': 'Non-Agegated non-embeddable video',
1492 'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1494 'id': 'MeJVWBSsPAY',
1496 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1497 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1498 'upload_date': '20130730',
1499 'track': 'Such mich find mich',
1501 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1503 'playable_in_embed': False,
1504 'creator': 'OOMPH!',
1505 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1507 'alt_title': 'Such mich find mich',
1509 'channel': 'Herr Lurik',
1510 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1511 'categories': ['Music'],
1512 'availability': 'public',
1513 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1514 'live_status': 'not_live',
1516 'channel_follower_count': int,
1517 'uploader': 'Herr Lurik',
1518 'uploader_url': 'https://www.youtube.com/@HerrLurik',
1519 'uploader_id': '@HerrLurik',
1523 'note': 'Non-bypassable age-gated video',
1524 'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1525 'only_matching': True,
1527 # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1528 # YouTube Red ad is not captured for creator
1530 'url': '__2ABJjxzNo',
1532 'id': '__2ABJjxzNo',
1535 'upload_date': '20100430',
1536 'creator': 'deadmau5',
1537 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1538 'title': 'Deadmau5 - Some Chords (HD)',
1539 'alt_title': 'Some Chords',
1540 'availability': 'public',
1542 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1544 'live_status': 'not_live',
1545 'channel': 'deadmau5',
1546 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1548 'track': 'Some Chords',
1549 'artist': 'deadmau5',
1550 'playable_in_embed': True,
1552 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1553 'categories': ['Music'],
1554 'album': 'Some Chords',
1555 'channel_follower_count': int,
1556 'uploader': 'deadmau5',
1557 'uploader_url': 'https://www.youtube.com/@deadmau5',
1558 'uploader_id': '@deadmau5',
1560 'expected_warnings': [
1561 'DASH manifest missing',
1564 # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1566 'url': 'lqQg6PlCWgI',
1568 'id': 'lqQg6PlCWgI',
1571 'upload_date': '20150827',
1572 'description': 'md5:04bbbf3ccceb6795947572ca36f45904',
1573 'title': 'Hockey - Women - GER-AUS - London 2012 Olympic Games',
1575 'release_timestamp': 1343767800,
1576 'playable_in_embed': True,
1577 'categories': ['Sports'],
1578 'release_date': '20120731',
1579 'channel': 'Olympics',
1580 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1581 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1582 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1584 'availability': 'public',
1585 'live_status': 'was_live',
1587 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1588 'channel_follower_count': int,
1589 'uploader': 'Olympics',
1590 'uploader_url': 'https://www.youtube.com/@Olympics',
1591 'uploader_id': '@Olympics',
1592 'channel_is_verified': True,
1595 'skip_download': 'requires avconv',
1600 'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1602 'id': '_b-2C3KPAM0',
1604 'stretched_ratio': 16 / 9.,
1606 'upload_date': '20110310',
1607 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1608 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1609 'playable_in_embed': True,
1613 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1614 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1615 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1617 'categories': ['People & Blogs'],
1619 'live_status': 'not_live',
1620 'availability': 'unlisted',
1621 'comment_count': int,
1622 'channel_follower_count': int,
1624 'uploader_url': 'https://www.youtube.com/@AllenMeow',
1625 'uploader_id': '@AllenMeow',
1628 # url_encoded_fmt_stream_map is empty string
1630 'url': 'qEJwOuvDf7I',
1632 'id': 'qEJwOuvDf7I',
1634 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1636 'upload_date': '20150404',
1639 'skip_download': 'requires avconv',
1641 'skip': 'This live event has ended.',
1643 # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1645 'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1647 'id': 'FIl7x6_3R5Y',
1649 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1650 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1652 'upload_date': '20150625',
1653 'formats': 'mincount:31',
1655 'skip': 'not actual anymore',
1657 # DASH manifest with segment_list
1659 'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1660 'md5': '8ce563a1d667b599d21064e982ab9e31',
1662 'id': 'CsmdDsKjzN8',
1664 'upload_date': '20150501', # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1665 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1666 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1669 'youtube_include_dash_manifest': True,
1670 'format': '135', # bestvideo
1672 'skip': 'This live event has ended.',
1675 # Multifeed videos (multiple cameras), URL can be of any Camera
1676 # TODO: fix multifeed titles
1677 'url': 'https://www.youtube.com/watch?v=zaPI8MvL8pg',
1679 'id': 'zaPI8MvL8pg',
1680 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04',
1681 'description': 'md5:563ccbc698b39298481ca3c571169519',
1685 'id': 'j5yGuxZ8lLU',
1687 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Chris)',
1688 'description': 'md5:563ccbc698b39298481ca3c571169519',
1690 'channel_follower_count': int,
1691 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1692 'availability': 'public',
1693 'playable_in_embed': True,
1694 'upload_date': '20131105',
1695 'categories': ['Gaming'],
1696 'live_status': 'was_live',
1698 'release_timestamp': 1383701910,
1699 'thumbnail': 'https://i.ytimg.com/vi/j5yGuxZ8lLU/maxresdefault.jpg',
1700 'comment_count': int,
1703 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1704 'channel': 'WiiLikeToPlay',
1706 'release_date': '20131106',
1707 'uploader': 'WiiLikeToPlay',
1708 'uploader_id': '@WLTP',
1709 'uploader_url': 'https://www.youtube.com/@WLTP',
1713 'id': 'zaPI8MvL8pg',
1715 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Tyson)',
1716 'availability': 'public',
1717 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1718 'channel': 'WiiLikeToPlay',
1719 'channel_follower_count': int,
1720 'description': 'md5:563ccbc698b39298481ca3c571169519',
1725 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1726 'release_timestamp': 1383701915,
1727 'comment_count': int,
1728 'upload_date': '20131105',
1729 'thumbnail': 'https://i.ytimg.com/vi/zaPI8MvL8pg/maxresdefault.jpg',
1730 'release_date': '20131106',
1731 'playable_in_embed': True,
1732 'live_status': 'was_live',
1733 'categories': ['Gaming'],
1735 'uploader': 'WiiLikeToPlay',
1736 'uploader_id': '@WLTP',
1737 'uploader_url': 'https://www.youtube.com/@WLTP',
1741 'id': 'R7r3vfO7Hao',
1743 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Spencer)',
1744 'thumbnail': 'https://i.ytimg.com/vi/R7r3vfO7Hao/maxresdefault.jpg',
1745 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1747 'availability': 'public',
1748 'playable_in_embed': True,
1749 'upload_date': '20131105',
1750 'description': 'md5:563ccbc698b39298481ca3c571169519',
1751 'channel_follower_count': int,
1753 'release_date': '20131106',
1754 'comment_count': int,
1755 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1756 'channel': 'WiiLikeToPlay',
1757 'categories': ['Gaming'],
1758 'release_timestamp': 1383701914,
1759 'live_status': 'was_live',
1763 'uploader': 'WiiLikeToPlay',
1764 'uploader_id': '@WLTP',
1765 'uploader_url': 'https://www.youtube.com/@WLTP',
1768 'params': {'skip_download': True},
1771 # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1772 'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1774 'id': 'gVfLd0zydlo',
1775 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1777 'playlist_count': 2,
1778 'skip': 'Not multifeed anymore',
1781 'url': 'https://vid.plus/FlRa-iH7PGw',
1782 'only_matching': True,
1785 'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1786 'only_matching': True,
1789 # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1790 # Also tests cut-off URL expansion in video description (see
1791 # https://github.com/ytdl-org/youtube-dl/issues/1892,
1792 # https://github.com/ytdl-org/youtube-dl/issues/8164)
1793 'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1795 'id': 'lsguqyKfVQg',
1797 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1798 'alt_title': 'Dark Walk',
1799 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1801 'upload_date': '20151119',
1802 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1803 'track': 'Dark Walk',
1804 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1805 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1806 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1807 'categories': ['Film & Animation'],
1809 'live_status': 'not_live',
1810 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1811 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1813 'availability': 'public',
1814 'channel': 'IronSoulElf',
1815 'playable_in_embed': True,
1818 'channel_follower_count': int
1821 'skip_download': True,
1825 # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1826 'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1827 'only_matching': True,
1830 # Video with yt:stretch=17:0
1831 'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1833 'id': 'Q39EVAstoRM',
1835 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1836 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1837 'upload_date': '20151107',
1840 'skip_download': True,
1842 'skip': 'This video does not exist.',
1845 # Video with incomplete 'yt:stretch=16:'
1846 'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1847 'only_matching': True,
1850 # Video licensed under Creative Commons
1851 'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1853 'id': 'M4gD1WSo5mA',
1855 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1856 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1858 'upload_date': '20150128',
1859 'license': 'Creative Commons Attribution license (reuse allowed)',
1860 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1861 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1864 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1865 'channel': 'The Berkman Klein Center for Internet & Society',
1866 'availability': 'public',
1868 'categories': ['Education'],
1869 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1870 'live_status': 'not_live',
1871 'playable_in_embed': True,
1872 'channel_follower_count': int,
1874 'uploader': 'The Berkman Klein Center for Internet & Society',
1875 'uploader_id': '@BKCHarvard',
1876 'uploader_url': 'https://www.youtube.com/@BKCHarvard',
1879 'skip_download': True,
1883 'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1885 'id': 'eQcmzGIKrzg',
1887 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1888 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1890 'upload_date': '20151120',
1891 'license': 'Creative Commons Attribution license (reuse allowed)',
1892 'playable_in_embed': True,
1895 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1897 'availability': 'public',
1898 'categories': ['News & Politics'],
1899 'channel': 'Bernie Sanders',
1900 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1902 'live_status': 'not_live',
1903 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1904 'comment_count': int,
1905 'channel_follower_count': int,
1907 'uploader': 'Bernie Sanders',
1908 'uploader_url': 'https://www.youtube.com/@BernieSanders',
1909 'uploader_id': '@BernieSanders',
1910 'channel_is_verified': True,
1911 'heatmap': 'count:100',
1914 'skip_download': True,
1918 'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;v=V36LpHqtcDY',
1919 'only_matching': True,
1922 # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1923 'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1924 'only_matching': True,
1927 # Rental video preview
1928 'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1930 'id': 'uGpuVWrhIzE',
1932 'title': 'Piku - Trailer',
1933 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1934 'upload_date': '20150811',
1935 'license': 'Standard YouTube License',
1938 'skip_download': True,
1940 'skip': 'This video is not available.',
1943 # YouTube Red video with episode data
1944 'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1946 'id': 'iqKdEhx-dD4',
1948 'title': 'Isolation - Mind Field (Ep 1)',
1949 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1951 'upload_date': '20170118',
1952 'series': 'Mind Field',
1954 'episode_number': 1,
1955 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1958 'availability': 'public',
1960 'channel': 'Vsauce',
1961 'episode': 'Episode 1',
1962 'categories': ['Entertainment'],
1963 'season': 'Season 1',
1964 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
1965 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
1967 'playable_in_embed': True,
1968 'live_status': 'not_live',
1969 'channel_follower_count': int,
1970 'uploader': 'Vsauce',
1971 'uploader_url': 'https://www.youtube.com/@Vsauce',
1972 'uploader_id': '@Vsauce',
1973 'comment_count': int,
1974 'channel_is_verified': True,
1977 'skip_download': True,
1979 'expected_warnings': [
1980 'Skipping DASH manifest',
1984 # The following content has been identified by the YouTube community
1985 # as inappropriate or offensive to some audiences.
1986 'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
1988 'id': '6SJNVb0GnPI',
1990 'title': 'Race Differences in Intelligence',
1991 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
1993 'upload_date': '20140124',
1996 'skip_download': True,
1998 'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
2002 'url': '1t24XAntNCY',
2003 'only_matching': True,
2006 # geo restricted to JP
2007 'url': 'sJL6WA-aGkQ',
2008 'only_matching': True,
2011 'url': 'https://invidio.us/watch?v=BaW_jenozKc',
2012 'only_matching': True,
2015 'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
2016 'only_matching': True,
2019 # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
2020 'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
2021 'only_matching': True,
2025 'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
2026 'only_matching': True,
2029 # Video with unsupported adaptive stream type formats
2030 'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
2032 'id': 'Z4Vy8R84T1U',
2034 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
2035 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
2037 'upload_date': '20130923',
2038 'formats': 'maxcount:10',
2041 'skip_download': True,
2042 'youtube_include_dash_manifest': False,
2044 'skip': 'not actual anymore',
2047 # Youtube Music Auto-generated description
2048 # TODO: fix metadata extraction
2049 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2051 'id': 'MgNrAu2pzNs',
2053 'title': 'Voyeur Girl',
2054 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
2055 'upload_date': '20190312',
2056 'artist': 'Stephen',
2057 'track': 'Voyeur Girl',
2058 'album': 'it\'s too much love to know my dear',
2059 'release_date': '20190313',
2060 'release_year': 2019,
2061 'alt_title': 'Voyeur Girl',
2063 'playable_in_embed': True,
2065 'categories': ['Music'],
2066 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
2067 'channel': 'Stephen', # TODO: should be "Stephen - Topic"
2068 'uploader': 'Stephen',
2069 'availability': 'public',
2070 'creator': 'Stephen',
2072 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
2074 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
2076 'live_status': 'not_live',
2077 'channel_follower_count': int
2080 'skip_download': True,
2084 'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
2085 'only_matching': True,
2088 # invalid -> valid video id redirection
2089 'url': 'DJztXj2GPfl',
2091 'id': 'DJztXj2GPfk',
2093 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
2094 'description': 'md5:bf577a41da97918e94fa9798d9228825',
2095 'upload_date': '20090125',
2096 'artist': 'Panjabi MC',
2097 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
2098 'album': 'Beware of the Boys (Mundian To Bach Ke)',
2101 'skip_download': True,
2103 'skip': 'Video unavailable',
2106 # empty description results in an empty string
2107 'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
2109 'id': 'x41yOUIvK2k',
2111 'title': 'IMG 3456',
2113 'upload_date': '20170613',
2115 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
2117 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
2119 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
2120 'availability': 'public',
2122 'categories': ['Pets & Animals'],
2124 'playable_in_embed': True,
2125 'live_status': 'not_live',
2126 'channel': 'l\'Or Vert asbl',
2127 'channel_follower_count': int,
2128 'uploader': 'l\'Or Vert asbl',
2129 'uploader_url': 'https://www.youtube.com/@ElevageOrVert',
2130 'uploader_id': '@ElevageOrVert',
2133 'skip_download': True,
2137 # with '};' inside yt initial data (see [1])
2138 # see [2] for an example with '};' inside ytInitialPlayerResponse
2139 # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
2140 # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
2141 'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
2143 'id': 'CHqg6qOn4no',
2145 'title': 'Part 77 Sort a list of simple types in c#',
2146 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
2147 'upload_date': '20130831',
2148 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
2150 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
2151 'live_status': 'not_live',
2152 'categories': ['Education'],
2153 'availability': 'public',
2154 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
2156 'playable_in_embed': True,
2160 'channel': 'kudvenkat',
2161 'comment_count': int,
2162 'channel_follower_count': int,
2164 'uploader': 'kudvenkat',
2165 'uploader_url': 'https://www.youtube.com/@Csharp-video-tutorialsBlogspot',
2166 'uploader_id': '@Csharp-video-tutorialsBlogspot',
2167 'channel_is_verified': True,
2168 'heatmap': 'count:100',
2171 'skip_download': True,
2175 # another example of '};' in ytInitialData
2176 'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
2177 'only_matching': True,
2180 'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
2181 'only_matching': True,
2184 # https://github.com/ytdl-org/youtube-dl/pull/28094
2185 'url': 'OtqTfy26tG0',
2187 'id': 'OtqTfy26tG0',
2189 'title': 'Burn Out',
2190 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
2191 'upload_date': '20141120',
2192 'artist': 'The Cinematic Orchestra',
2193 'track': 'Burn Out',
2194 'album': 'Every Day',
2196 'live_status': 'not_live',
2197 'alt_title': 'Burn Out',
2201 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2202 'creator': 'The Cinematic Orchestra',
2203 'channel': 'The Cinematic Orchestra',
2204 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
2205 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2206 'availability': 'public',
2207 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
2208 'categories': ['Music'],
2209 'playable_in_embed': True,
2210 'channel_follower_count': int,
2211 'uploader': 'The Cinematic Orchestra',
2212 'comment_count': int,
2215 'skip_download': True,
2219 # controversial video, only works with bpctr when authenticated with cookies
2220 'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
2221 'only_matching': True,
2224 # controversial video, requires bpctr/contentCheckOk
2225 'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
2227 'id': 'SZJvDhaSDnc',
2229 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
2230 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
2231 'upload_date': '20140716',
2232 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
2234 'categories': ['News & Politics'],
2236 'channel': 'CBS Mornings',
2237 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
2238 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
2240 'availability': 'needs_auth',
2241 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
2243 'live_status': 'not_live',
2244 'playable_in_embed': True,
2245 'channel_follower_count': int,
2246 'uploader': 'CBS Mornings',
2247 'uploader_url': 'https://www.youtube.com/@CBSMornings',
2248 'uploader_id': '@CBSMornings',
2249 'comment_count': int,
2250 'channel_is_verified': True,
2254 # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
2255 'url': 'cBvYw8_A0vQ',
2257 'id': 'cBvYw8_A0vQ',
2259 'title': '4K Ueno Okachimachi Street Scenes 上野御徒町歩き',
2260 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
2261 'upload_date': '20201120',
2263 'categories': ['Travel & Events'],
2264 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2266 'channel': 'Walk around Japan',
2267 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
2268 'thumbnail': 'https://i.ytimg.com/vi_webp/cBvYw8_A0vQ/hqdefault.webp',
2270 'availability': 'public',
2271 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2272 'live_status': 'not_live',
2273 'playable_in_embed': True,
2274 'channel_follower_count': int,
2275 'uploader': 'Walk around Japan',
2276 'uploader_url': 'https://www.youtube.com/@walkaroundjapan7124',
2277 'uploader_id': '@walkaroundjapan7124',
2280 'skip_download': True,
2283 # Has multiple audio streams
2284 'url': 'WaOKSUlf4TM',
2285 'only_matching': True
2287 # Requires Premium: has format 141 when requested using YTM url
2288 'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2289 'only_matching': True
2291 # multiple subtitles with same lang_code
2292 'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2293 'only_matching': True,
2295 # Force use android client fallback
2296 'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2298 'id': 'YOelRv7fMxY',
2299 'title': 'DIGGING A SECRET TUNNEL Part 1',
2301 'upload_date': '20210624',
2302 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2303 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2304 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2306 'categories': ['Entertainment'],
2308 'channel': 'colinfurze',
2309 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2310 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2312 'availability': 'public',
2314 'live_status': 'not_live',
2315 'playable_in_embed': True,
2316 'channel_follower_count': int,
2318 'uploader': 'colinfurze',
2319 'uploader_url': 'https://www.youtube.com/@colinfurze',
2320 'uploader_id': '@colinfurze',
2321 'comment_count': int,
2322 'channel_is_verified': True,
2323 'heatmap': 'count:100',
2326 'format': '17', # 3gp format available on android
2327 'extractor_args': {'youtube': {'player_client': ['android']}},
2331 # Skip download of additional client configs (remix client config in this case)
2332 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2333 'only_matching': True,
2335 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2339 'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2340 'only_matching': True,
2342 'note': 'Storyboards',
2343 'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2345 'id': '5KLPxDtMqe8',
2348 'title': 'Your Brain is Plastic',
2349 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2350 'upload_date': '20140324',
2352 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2353 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2355 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2356 'playable_in_embed': True,
2358 'availability': 'public',
2359 'channel': 'SciShow',
2360 'live_status': 'not_live',
2362 'categories': ['Education'],
2364 'channel_follower_count': int,
2366 'uploader': 'SciShow',
2367 'uploader_url': 'https://www.youtube.com/@SciShow',
2368 'uploader_id': '@SciShow',
2369 'comment_count': int,
2370 'channel_is_verified': True,
2371 'heatmap': 'count:100',
2372 }, 'params': {'format': 'mhtml', 'skip_download': True}
2374 # Ensure video upload_date is in UTC timezone (video was uploaded 1641170939)
2375 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2377 'id': '2NUZ8W2llS4',
2379 'title': 'The NP that test your phone performance 🙂',
2380 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2381 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2382 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2386 'categories': ['Gaming'],
2388 'playable_in_embed': True,
2389 'live_status': 'not_live',
2390 'upload_date': '20220103',
2392 'availability': 'public',
2393 'channel': 'Leon Nguyen',
2394 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2395 'comment_count': int,
2396 'channel_follower_count': int,
2397 'uploader': 'Leon Nguyen',
2398 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2399 'uploader_id': '@LeonNguyen',
2400 'heatmap': 'count:100',
2403 # Same video as above, but with --compat-opt no-youtube-prefer-utc-upload-date
2404 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2406 'id': '2NUZ8W2llS4',
2408 'title': 'The NP that test your phone performance 🙂',
2409 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2410 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2411 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2415 'categories': ['Gaming'],
2417 'playable_in_embed': True,
2418 'live_status': 'not_live',
2419 'upload_date': '20220102',
2421 'availability': 'public',
2422 'channel': 'Leon Nguyen',
2423 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2424 'comment_count': int,
2425 'channel_follower_count': int,
2426 'uploader': 'Leon Nguyen',
2427 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2428 'uploader_id': '@LeonNguyen',
2429 'heatmap': 'count:100',
2431 'params': {'compat_opts': ['no-youtube-prefer-utc-upload-date']}
2433 # date text is premiered video, ensure upload date in UTC (published 1641172509)
2434 'url': 'https://www.youtube.com/watch?v=mzZzzBU6lrM',
2436 'id': 'mzZzzBU6lrM',
2438 'title': 'I Met GeorgeNotFound In Real Life...',
2439 'description': 'md5:978296ec9783a031738b684d4ebf302d',
2440 'channel_id': 'UC_8NknAFiyhOUaZqHR3lq3Q',
2441 'channel_url': 'https://www.youtube.com/channel/UC_8NknAFiyhOUaZqHR3lq3Q',
2445 'categories': ['Entertainment'],
2447 'playable_in_embed': True,
2448 'live_status': 'not_live',
2449 'release_timestamp': 1641172509,
2450 'release_date': '20220103',
2451 'upload_date': '20220103',
2453 'availability': 'public',
2454 'channel': 'Quackity',
2455 'thumbnail': 'https://i.ytimg.com/vi/mzZzzBU6lrM/maxresdefault.jpg',
2456 'channel_follower_count': int,
2457 'uploader': 'Quackity',
2458 'uploader_id': '@Quackity',
2459 'uploader_url': 'https://www.youtube.com/@Quackity',
2460 'comment_count': int,
2461 'channel_is_verified': True,
2462 'heatmap': 'count:100',
2465 { # continuous livestream. Microformat upload date should be preferred.
2466 # Upload date was 2021-06-19 (not UTC), while stream start is 2021-11-27
2467 'url': 'https://www.youtube.com/watch?v=kgx4WGK0oNU',
2469 'id': 'kgx4WGK0oNU',
2470 '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}',
2472 'channel_id': 'UC84whx2xxsiA1gXHXXqKGOA',
2473 'availability': 'public',
2475 'release_timestamp': 1637975704,
2476 'upload_date': '20210619',
2477 'channel_url': 'https://www.youtube.com/channel/UC84whx2xxsiA1gXHXXqKGOA',
2478 'live_status': 'is_live',
2479 'thumbnail': 'https://i.ytimg.com/vi/kgx4WGK0oNU/maxresdefault.jpg',
2480 'channel': 'Abao in Tokyo',
2481 'channel_follower_count': int,
2482 'release_date': '20211127',
2484 'categories': ['People & Blogs'],
2487 'playable_in_embed': True,
2488 'description': 'md5:2ef1d002cad520f65825346e2084e49d',
2489 'concurrent_view_count': int,
2490 'uploader': 'Abao in Tokyo',
2491 'uploader_url': 'https://www.youtube.com/@abaointokyo',
2492 'uploader_id': '@abaointokyo',
2494 'params': {'skip_download': True}
2496 'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2498 'id': 'tjjjtzRLHvA',
2500 'title': 'ハッシュタグ無し };if window.ytcsi',
2501 'upload_date': '20220323',
2503 'availability': 'unlisted',
2504 'channel': 'Lesmiscore',
2505 'thumbnail': r're:^https?://.*\.jpg',
2507 'categories': ['Music'],
2510 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2511 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2512 'live_status': 'not_live',
2513 'playable_in_embed': True,
2514 'channel_follower_count': int,
2517 'uploader_id': '@lesmiscore',
2518 'uploader': 'Lesmiscore',
2519 'uploader_url': 'https://www.youtube.com/@lesmiscore',
2522 # Prefer primary title+description language metadata by default
2523 # Do not prefer translated description if primary is empty
2524 'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2526 'id': 'el3E4MbxRqQ',
2528 'title': 'dlp test video 2 - primary sv no desc',
2530 'channel': 'cole-dlp-test-acc',
2533 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2535 'playable_in_embed': True,
2536 'availability': 'unlisted',
2537 'thumbnail': r're:^https?://.*\.jpg',
2540 'live_status': 'not_live',
2541 'upload_date': '20220908',
2542 'categories': ['People & Blogs'],
2543 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2544 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2545 'uploader_id': '@coletdjnz',
2546 'uploader': 'cole-dlp-test-acc',
2548 'params': {'skip_download': True}
2550 # Extractor argument: prefer translated title+description
2551 'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2553 'id': 'gHKT4uU8Zng',
2555 'channel': 'cole-dlp-test-acc',
2558 'live_status': 'not_live',
2559 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2560 'upload_date': '20220728',
2562 'categories': ['People & Blogs'],
2563 'thumbnail': r're:^https?://.*\.jpg',
2564 'title': 'dlp test video title translated (fr)',
2565 'availability': 'public',
2567 'description': 'dlp test video description translated (fr)',
2568 'playable_in_embed': True,
2569 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2570 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2571 'uploader_id': '@coletdjnz',
2572 'uploader': 'cole-dlp-test-acc',
2574 'params': {'skip_download': True, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2575 'expected_warnings': [r'Preferring "fr" translated fields'],
2577 'note': '6 channel audio',
2578 'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2579 'only_matching': True,
2581 'note': 'Multiple HLS formats with same itag',
2582 'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2584 'id': 'kX3nB4PpJko',
2586 'categories': ['Entertainment'],
2587 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2588 'live_status': 'not_live',
2590 'channel_follower_count': int,
2591 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2592 'title': 'Last To Take Hand Off Jet, Keeps It!',
2593 'channel': 'MrBeast',
2594 'playable_in_embed': True,
2596 'upload_date': '20221112',
2597 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2599 'availability': 'public',
2600 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2603 'uploader': 'MrBeast',
2604 'uploader_url': 'https://www.youtube.com/@MrBeast',
2605 'uploader_id': '@MrBeast',
2606 'comment_count': int,
2607 'channel_is_verified': True,
2608 'heatmap': 'count:100',
2610 'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2612 'note': 'Audio formats with Dynamic Range Compression',
2613 'url': 'https://www.youtube.com/watch?v=Tq92D6wQ1mg',
2615 'id': 'Tq92D6wQ1mg',
2617 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
2618 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
2619 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
2620 'channel_follower_count': int,
2621 'description': 'md5:17eccca93a786d51bc67646756894066',
2622 'upload_date': '20191228',
2623 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
2624 'playable_in_embed': True,
2626 'categories': ['Entertainment'],
2627 'thumbnail': 'https://i.ytimg.com/vi/Tq92D6wQ1mg/sddefault.jpg',
2629 'channel': 'Projekt Melody',
2631 'availability': 'needs_auth',
2632 'comment_count': int,
2633 'live_status': 'not_live',
2635 'uploader': 'Projekt Melody',
2636 'uploader_id': '@ProjektMelody',
2637 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
2639 'params': {'extractor_args': {'youtube': {'player_client': ['tv_embedded']}}, 'format': '251-drc'},
2642 'url': 'https://www.youtube.com/live/qVv6vCqciTM',
2644 'id': 'qVv6vCqciTM',
2647 'comment_count': int,
2648 'chapters': 'count:13',
2649 'upload_date': '20221223',
2650 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
2651 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
2653 'release_date': '20221223',
2654 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
2655 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
2657 'playable_in_embed': True,
2659 'availability': 'public',
2660 'channel_follower_count': int,
2661 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
2662 'categories': ['Entertainment'],
2663 'live_status': 'was_live',
2664 'release_timestamp': 1671793345,
2665 'channel': 'さなちゃんねる',
2666 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
2667 'uploader': 'さなちゃんねる',
2668 'uploader_url': 'https://www.youtube.com/@sana_natori',
2669 'uploader_id': '@sana_natori',
2670 'channel_is_verified': True,
2671 'heatmap': 'count:100',
2675 # Fallbacks when webpage and web client is unavailable
2676 'url': 'https://www.youtube.com/watch?v=wSSmNUl9Snw',
2678 'id': 'wSSmNUl9Snw',
2680 # 'categories': ['Science & Technology'],
2682 'chapters': 'count:2',
2683 'channel': 'Scott Manley',
2686 # 'availability': 'public',
2687 'channel_follower_count': int,
2688 'live_status': 'not_live',
2689 'upload_date': '20170831',
2692 'uploader_url': 'https://www.youtube.com/@scottmanley',
2693 'description': 'md5:f4bed7b200404b72a394c2f97b782c02',
2694 'uploader': 'Scott Manley',
2695 'uploader_id': '@scottmanley',
2696 'title': 'The Computer Hack That Saved Apollo 14',
2697 'channel_id': 'UCxzC4EngIsMrPmbm6Nxvb-A',
2698 'thumbnail': r're:^https?://.*\.webp',
2699 'channel_url': 'https://www.youtube.com/channel/UCxzC4EngIsMrPmbm6Nxvb-A',
2700 'playable_in_embed': True,
2701 'comment_count': int,
2702 'channel_is_verified': True,
2703 'heatmap': 'count:100',
2706 'extractor_args': {'youtube': {'player_client': ['android'], 'player_skip': ['webpage']}},
2712 # YouTube <object> embed
2714 'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2715 'md5': '873c81d308b979f0e23ee7e620b312a3',
2717 'id': 'msN87y-iEx0',
2719 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2720 'upload_date': '20080526',
2721 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2723 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2724 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2725 'playable_in_embed': True,
2726 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2728 'comment_count': int,
2729 'channel': 'Christopher Sykes',
2730 'live_status': 'not_live',
2731 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2732 'availability': 'public',
2735 'categories': ['Science & Technology'],
2736 'channel_follower_count': int,
2737 'uploader': 'Christopher Sykes',
2738 'uploader_url': 'https://www.youtube.com/@ChristopherSykesDocumentaries',
2739 'uploader_id': '@ChristopherSykesDocumentaries',
2740 'heatmap': 'count:100',
2743 'skip_download': True,
2749 def suitable(cls, url):
2750 from ..utils import parse_qs
2753 if qs.get('list', [None])[0]:
2755 return super().suitable(url)
2757 def __init__(self, *args, **kwargs):
2758 super().__init__(*args, **kwargs)
2759 self._code_cache = {}
2760 self._player_cache = {}
2762 def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2763 lock = threading.Lock()
2764 start_time = time.time()
2765 formats = [f for f in formats if f.get('is_from_start')]
2767 def refetch_manifest(format_id, delay):
2768 nonlocal formats, start_time, is_live
2769 if time.time() <= start_time + delay:
2772 _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2773 video_details = traverse_obj(prs, (..., 'videoDetails'), expected_type=dict)
2774 microformats = traverse_obj(
2775 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2777 _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2778 is_live = live_status == 'is_live'
2779 start_time = time.time()
2781 def mpd_feed(format_id, delay):
2783 @returns (manifest_url, manifest_stream_number, is_live) or None
2785 for retry in self.RetryManager(fatal=False):
2787 refetch_manifest(format_id, delay)
2789 f = next((f for f in formats if f['format_id'] == format_id), None)
2792 retry.error = f'{video_id}: Video is no longer live'
2794 retry.error = f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}'
2796 return f['manifest_url'], f['manifest_stream_number'], is_live
2800 f['is_live'] = is_live
2801 gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2802 live_start_time, mpd_feed, not is_live and f.copy())
2804 f['fragments'] = gen
2805 f['protocol'] = 'http_dash_segments_generator'
2807 f['fragments'] = LazyList(gen({}))
2808 del f['is_from_start']
2810 def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2811 FETCH_SPAN, MAX_DURATION = 5, 432000
2813 mpd_url, stream_number, is_live = None, None, True
2816 download_start_time = ctx.get('start') or time.time()
2818 lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2819 if lack_early_segments:
2820 self.report_warning(bug_reports_message(
2821 'Starting download from the last 120 hours of the live stream since '
2822 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2823 lack_early_segments = True
2825 known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2826 fragments, fragment_base_url = None, None
2828 def _extract_sequence_from_mpd(refresh_sequence, immediate):
2829 nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2830 # Obtain from MPD's maximum seq value
2831 old_mpd_url = mpd_url
2832 last_error = ctx.pop('last_error', None)
2833 expire_fast = immediate or last_error and isinstance(last_error, HTTPError) and last_error.status == 403
2834 mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2835 or (mpd_url, stream_number, False))
2836 if not refresh_sequence:
2837 if expire_fast and not is_live:
2838 return False, last_seq
2839 elif old_mpd_url == mpd_url:
2840 return True, last_seq
2841 if manifestless_orig_fmt:
2842 fmt_info = manifestless_orig_fmt
2845 fmts, _ = self._extract_mpd_formats_and_subtitles(
2846 mpd_url, None, note=False, errnote=False, fatal=False)
2847 except ExtractorError:
2850 no_fragment_score += 2
2851 return False, last_seq
2852 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2853 fragments = fmt_info['fragments']
2854 fragment_base_url = fmt_info['fragment_base_url']
2855 assert fragment_base_url
2857 _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2858 return True, _last_seq
2860 self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2862 fetch_time = time.time()
2863 if no_fragment_score > 30:
2865 if last_segment_url:
2866 # Obtain from "X-Head-Seqnum" header value from each segment
2868 urlh = self._request_webpage(
2869 last_segment_url, None, note=False, errnote=False, fatal=False)
2870 except ExtractorError:
2872 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2873 if last_seq is None:
2874 no_fragment_score += 2
2875 last_segment_url = None
2878 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2879 no_fragment_score += 2
2880 if not should_continue:
2883 if known_idx > last_seq:
2884 last_segment_url = None
2889 if begin_index < 0 and known_idx < 0:
2890 # skip from the start when it's negative value
2891 known_idx = last_seq + begin_index
2892 if lack_early_segments:
2893 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2895 for idx in range(known_idx, last_seq):
2896 # do not update sequence here or you'll get skipped some part of it
2897 should_continue, _ = _extract_sequence_from_mpd(False, False)
2898 if not should_continue:
2900 raise ExtractorError('breaking out of outer loop')
2901 last_segment_url = urljoin(fragment_base_url, 'sq/%d' % idx)
2903 'url': last_segment_url,
2904 'fragment_count': last_seq,
2906 if known_idx == last_seq:
2907 no_fragment_score += 5
2909 no_fragment_score = 0
2910 known_idx = last_seq
2911 except ExtractorError:
2914 if manifestless_orig_fmt:
2915 # Stop at the first iteration if running for post-live manifestless;
2916 # fragment count no longer increase since it starts
2919 time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2921 def _extract_player_url(self, *ytcfgs, webpage=None):
2922 player_url = traverse_obj(
2923 ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2924 get_all=False, expected_type=str)
2927 return urljoin('https://www.youtube.com', player_url)
2929 def _download_player_url(self, video_id, fatal=False):
2930 res = self._download_webpage(
2931 'https://www.youtube.com/iframe_api',
2932 note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2934 player_version = self._search_regex(
2935 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2937 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2939 def _signature_cache_id(self, example_sig):
2940 """ Return a string representation of a signature """
2941 return '.'.join(str(len(part)) for part in example_sig.split('.'))
2944 def _extract_player_info(cls, player_url):
2945 for player_re in cls._PLAYER_INFO_RE:
2946 id_m = re.search(player_re, player_url)
2950 raise ExtractorError('Cannot identify player %r' % player_url)
2951 return id_m.group('id')
2953 def _load_player(self, video_id, player_url, fatal=True):
2954 player_id = self._extract_player_info(player_url)
2955 if player_id not in self._code_cache:
2956 code = self._download_webpage(
2957 player_url, video_id, fatal=fatal,
2958 note='Downloading player ' + player_id,
2959 errnote='Download of %s failed' % player_url)
2961 self._code_cache[player_id] = code
2962 return self._code_cache.get(player_id)
2964 def _extract_signature_function(self, video_id, player_url, example_sig):
2965 player_id = self._extract_player_info(player_url)
2967 # Read from filesystem cache
2968 func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2969 assert os.path.basename(func_id) == func_id
2971 self.write_debug(f'Extracting signature function {func_id}')
2972 cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
2975 code = self._load_player(video_id, player_url)
2977 res = self._parse_sig_js(code)
2978 test_string = ''.join(map(chr, range(len(example_sig))))
2979 cache_spec = [ord(c) for c in res(test_string)]
2980 self.cache.store('youtube-sigfuncs', func_id, cache_spec)
2982 return lambda s: ''.join(s[i] for i in cache_spec)
2984 def _print_sig_code(self, func, example_sig):
2985 if not self.get_param('youtube_print_sig_code'):
2988 def gen_sig_code(idxs):
2989 def _genslice(start, end, step):
2990 starts = '' if start == 0 else str(start)
2991 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
2992 steps = '' if step == 1 else (':%d' % step)
2993 return f's[{starts}{ends}{steps}]'
2996 # Quelch pyflakes warnings - start will be set when step is set
2997 start = '(Never used)'
2998 for i, prev in zip(idxs[1:], idxs[:-1]):
2999 if step is not None:
3000 if i - prev == step:
3002 yield _genslice(start, prev, step)
3005 if i - prev in [-1, 1]:
3010 yield 's[%d]' % prev
3014 yield _genslice(start, i, step)
3016 test_string = ''.join(map(chr, range(len(example_sig))))
3017 cache_res = func(test_string)
3018 cache_spec = [ord(c) for c in cache_res]
3019 expr_code = ' + '.join(gen_sig_code(cache_spec))
3020 signature_id_tuple = '(%s)' % (
3021 ', '.join(str(len(p)) for p in example_sig.split('.')))
3022 code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
3023 ' return %s\n') % (signature_id_tuple, expr_code)
3024 self.to_screen('Extracted signature function:\n' + code)
3026 def _parse_sig_js(self, jscode):
3027 funcname = self._search_regex(
3028 (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3029 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3030 r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
3031 r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
3032 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+\))?',
3033 r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
3035 r'("|\')signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3036 r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
3037 r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3038 r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3039 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3040 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
3041 jscode, 'Initial JS player signature function name', group='sig')
3043 jsi = JSInterpreter(jscode)
3044 initial_function = jsi.extract_function(funcname)
3045 return lambda s: initial_function([s])
3047 def _cached(self, func, *cache_id):
3048 def inner(*args, **kwargs):
3049 if cache_id not in self._player_cache:
3051 self._player_cache[cache_id] = func(*args, **kwargs)
3052 except ExtractorError as e:
3053 self._player_cache[cache_id] = e
3054 except Exception as e:
3055 self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
3057 ret = self._player_cache[cache_id]
3058 if isinstance(ret, Exception):
3063 def _decrypt_signature(self, s, video_id, player_url):
3064 """Turn the encrypted s field into a working signature"""
3065 extract_sig = self._cached(
3066 self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
3067 func = extract_sig(video_id, player_url, s)
3068 self._print_sig_code(func, s)
3071 def _decrypt_nsig(self, s, video_id, player_url):
3072 """Turn the encrypted n field into a working signature"""
3073 if player_url is None:
3074 raise ExtractorError('Cannot decrypt nsig without player_url')
3075 player_url = urljoin('https://www.youtube.com', player_url)
3078 jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
3079 except ExtractorError as e:
3080 raise ExtractorError('Unable to extract nsig function code', cause=e)
3081 if self.get_param('youtube_print_sig_code'):
3082 self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
3085 extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
3086 ret = extract_nsig(jsi, func_code)(s)
3087 except JSInterpreter.Exception as e:
3089 jsi = PhantomJSwrapper(self, timeout=5000)
3090 except ExtractorError:
3092 self.report_warning(
3093 f'Native nsig extraction failed: Trying with PhantomJS\n'
3094 f' n = {s} ; player = {player_url}', video_id)
3095 self.write_debug(e, only_once=True)
3097 args, func_body = func_code
3099 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
3100 video_id=video_id, note='Executing signature code').strip()
3102 self.write_debug(f'Decrypted nsig {s} => {ret}')
3105 def _extract_n_function_name(self, jscode):
3106 funcname, idx = self._search_regex(
3107 r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
3108 jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
3112 return json.loads(js_to_json(self._search_regex(
3113 rf'var {re.escape(funcname)}\s*=\s*(\[.+?\])\s*[,;]', jscode,
3114 f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
3116 def _extract_n_function_code(self, video_id, player_url):
3117 player_id = self._extract_player_info(player_url)
3118 func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
3119 jscode = func_code or self._load_player(video_id, player_url)
3120 jsi = JSInterpreter(jscode)
3123 return jsi, player_id, func_code
3125 func_name = self._extract_n_function_name(jscode)
3128 func_code = self._search_regex(
3129 r'''(?xs
)%s\s
*=\s
*function\s
*\
((?P
<var
>[\w$
]+)\
)\s
*
3130 # NB: The end of the regex is intentionally kept strict
3131 {(?P<code>.+?}\s
*return\
[\w$
]+.join\
(""\
))};''' % func_name,
3132 jscode, 'nsig function', group=('var', 'code'), default=None)
3134 func_code = ([func_code[0]], func_code[1])
3136 self.write_debug('Extracting nsig function with jsinterp')
3137 func_code = jsi.extract_function_code(func_name)
3139 self.cache.store('youtube-nsig', player_id, func_code)
3140 return jsi, player_id, func_code
3142 def _extract_n_function_from_code(self, jsi, func_code):
3143 func = jsi.extract_function_from_code(*func_code)
3145 def extract_nsig(s):
3148 except JSInterpreter.Exception:
3150 except Exception as e:
3151 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
3153 if ret.startswith('enhanced_except_'):
3154 raise JSInterpreter.Exception('Signature function returned an exception')
3159 def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3161 Extract signatureTimestamp (sts)
3162 Required to tell API what sig/player version is in use.
3165 if isinstance(ytcfg, dict):
3166 sts = int_or_none(ytcfg.get('STS'))
3169 # Attempt to extract from player
3170 if player_url is None:
3171 error_msg = 'Cannot extract signature timestamp without player_url.'
3173 raise ExtractorError(error_msg)
3174 self.report_warning(error_msg)
3176 code = self._load_player(video_id, player_url, fatal=fatal)
3178 sts = int_or_none(self._search_regex(
3179 r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3180 'JS player signature timestamp', group='sts', fatal=fatal))
3183 def _mark_watched(self, video_id, player_responses):
3184 for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3185 label = 'fully ' if is_full else ''
3186 url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3187 expected_type=url_or_none)
3189 self.report_warning(f'Unable to mark {label}watched')
3191 parsed_url = urllib.parse.urlparse(url)
3192 qs = urllib.parse.parse_qs(parsed_url.query)
3194 # cpn generation algorithm is reverse engineered from base.js.
3195 # In fact it works even with dummy cpn.
3196 CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3197 cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16))
3199 # # more consistent results setting it to right before the end
3200 video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3205 'cmt': video_length,
3206 'el': 'detailpage', # otherwise defaults to "shorts"
3210 # these seem to mark watchtime "history" in the real world
3211 # they're required, so send in a single value
3217 url = urllib.parse.urlunparse(
3218 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3220 self._download_webpage(
3221 url, video_id, f'Marking {label}watched',
3222 'Unable to mark watched', fatal=False)
3225 def _extract_from_webpage(cls, url, webpage):
3226 # Invidious Instances
3227 # https://github.com/yt-dlp/yt-dlp/issues/195
3228 # https://github.com/iv-org/invidious/pull/1730
3230 r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3233 yield cls.url_result(mobj.group('url'), cls)
3234 raise cls.StopExtraction()
3236 yield from super()._extract_from_webpage(url, webpage)
3238 # lazyYT YouTube embed
3239 for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3240 yield cls.url_result(unescapeHTML(id_), cls, id_)
3242 # Wordpress "YouTube Video Importer" plugin
3243 for m in re.findall(r'''(?x
)<div
[^
>]+
3244 class=(?P
<q1
>[\'"])[^\'"]*\byvii
_single
_video
_player
\b[^
\'"]*(?P=q1)[^>]+
3245 data-video_id=(?P<q2>[\'"])([^
\'"]+)(?P=q2)''', webpage):
3246 yield cls.url_result(m[-1], cls, m[-1])
3249 def extract_id(cls, url):
3250 video_id = cls.get_temp_id(url)
3252 raise ExtractorError(f'Invalid URL: {url}')
3255 def _extract_chapters_from_json(self, data, duration):
3256 chapter_list = traverse_obj(
3258 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3259 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters'
3260 ), expected_type=list)
3262 return self._extract_chapters_helper(
3264 start_function=lambda chapter: float_or_none(
3265 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3266 title_function=lambda chapter: traverse_obj(
3267 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3270 def _extract_chapters_from_engagement_panel(self, data, duration):
3271 content_list = traverse_obj(
3273 ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3275 chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3276 chapter_title = lambda chapter: self._get_text(chapter, 'title')
3278 return next(filter(None, (
3279 self._extract_chapters_helper(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3280 chapter_time, chapter_title, duration)
3281 for contents in content_list)), [])
3283 def _extract_heatmap_from_player_overlay(self, data):
3284 content_list = traverse_obj(data, (
3285 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer', 'decoratedPlayerBarRenderer', 'playerBar',
3286 'multiMarkersPlayerBarRenderer', 'markersMap', ..., 'value', 'heatmap', 'heatmapRenderer', 'heatMarkers', {list}))
3287 return next(filter(None, (
3288 traverse_obj(contents, (..., 'heatMarkerRenderer', {
3289 'start_time': ('timeRangeStartMillis', {functools.partial(float_or_none, scale=1000)}),
3290 'end_time': {lambda x: (x['timeRangeStartMillis'] + x['markerDurationMillis']) / 1000},
3291 'value': ('heatMarkerIntensityScoreNormalized', {float_or_none}),
3292 })) for contents in content_list)), None)
3294 def _extract_comment(self, comment_renderer, parent=None):
3295 comment_id = comment_renderer.get('commentId')
3301 'text': self._get_text(comment_renderer, 'contentText'),
3302 'like_count': self._get_count(comment_renderer, 'voteCount'),
3303 'author_id': traverse_obj(comment_renderer, ('authorEndpoint', 'browseEndpoint', 'browseId', {self.ucid_or_none})),
3304 'author': self._get_text(comment_renderer, 'authorText'),
3305 'author_thumbnail': traverse_obj(comment_renderer, ('authorThumbnail', 'thumbnails', -1, 'url', {url_or_none})),
3306 'parent': parent or 'root',
3309 # Timestamp is an estimate calculated from the current time and time_text
3310 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3311 timestamp = self._parse_time_text(time_text)
3314 # FIXME: non-standard, but we need a way of showing that it is an estimate.
3315 '_time_text': time_text,
3316 'timestamp': timestamp,
3319 info['author_url'] = urljoin(
3320 'https://www.youtube.com', traverse_obj(comment_renderer, ('authorEndpoint', (
3321 ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'))),
3322 expected_type=str, get_all=False))
3324 author_is_uploader = traverse_obj(comment_renderer, 'authorIsChannelOwner')
3325 if author_is_uploader is not None:
3326 info['author_is_uploader'] = author_is_uploader
3328 comment_abr = traverse_obj(
3329 comment_renderer, ('actionButtons', 'commentActionButtonsRenderer'), expected_type=dict)
3330 if comment_abr is not None:
3331 info['is_favorited'] = 'creatorHeart' in comment_abr
3333 badges = self._extract_badges([traverse_obj(comment_renderer, 'authorCommentBadge')])
3334 if self._has_badge(badges, BadgeType.VERIFIED):
3335 info['author_is_verified'] = True
3337 is_pinned = traverse_obj(comment_renderer, 'pinnedCommentBadge')
3339 info['is_pinned'] = True
3343 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3345 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3347 def extract_header(contents):
3348 _continuation = None
3349 for content in contents:
3350 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3351 expected_comment_count = self._get_count(
3352 comments_header_renderer, 'countText', 'commentsCount')
3354 if expected_comment_count is not None:
3355 tracker['est_total'] = expected_comment_count
3356 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3357 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3359 sort_menu_item = try_get(
3360 comments_header_renderer,
3361 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3362 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3364 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3365 if not _continuation:
3368 sort_text = str_or_none(sort_menu_item.get('title'))
3370 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3371 self.to_screen('Sorting comments by %s' % sort_text.lower())
3373 return _continuation
3375 def extract_thread(contents):
3377 tracker['current_page_thread'] = 0
3378 for content in contents:
3379 if not parent and tracker['total_parent_comments'] >= max_parents:
3381 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3382 comment_renderer = get_first(
3383 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3384 expected_type=dict, default={})
3386 comment = self._extract_comment(comment_renderer, parent)
3389 comment_id = comment['id']
3390 if comment.get('is_pinned'):
3391 tracker['pinned_comment_ids'].add(comment_id)
3392 # Sometimes YouTube may break and give us infinite looping comments.
3393 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3394 if comment_id in tracker['seen_comment_ids']:
3395 if comment_id in tracker['pinned_comment_ids'] and not comment.get('is_pinned'):
3396 # Pinned comments may appear a second time in newest first sort
3397 # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3399 self.report_warning(
3400 'Detected YouTube comments looping. Stopping comment extraction '
3401 f'{"for this thread" if parent else ""} as we probably cannot get any more.')
3404 tracker['seen_comment_ids'].add(comment['id'])
3406 tracker['running_total'] += 1
3407 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3410 # Attempt to get the replies
3411 comment_replies_renderer = try_get(
3412 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3414 if comment_replies_renderer:
3415 tracker['current_page_thread'] += 1
3416 comment_entries_iter = self._comment_entries(
3417 comment_replies_renderer, ytcfg, video_id,
3418 parent=comment.get('id'), tracker=tracker)
3419 yield from itertools.islice(comment_entries_iter, min(
3420 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3422 # Keeps track of counts across recursive calls
3427 current_page_thread=0,
3428 total_parent_comments=0,
3429 total_reply_comments=0,
3430 seen_comment_ids=set(),
3431 pinned_comment_ids=set()
3435 # YouTube comments have a max depth of 2
3436 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3438 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3439 'Set max replies in the max-comments extractor argument instead')
3440 if max_depth == 1 and parent:
3443 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
3444 lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
3446 continuation = self._extract_continuation(root_continuation_data)
3449 is_forced_continuation = False
3450 is_first_continuation = parent is None
3451 if is_first_continuation and not continuation:
3452 # Sometimes you can get comments by generating the continuation yourself,
3453 # even if YouTube initially reports them being disabled - e.g. stories comments.
3454 # Note: if the comment section is actually disabled, YouTube may return a response with
3455 # required check_get_keys missing. So we will disable that check initially in this case.
3456 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3457 is_forced_continuation = True
3459 continuation_items_path = (
3460 'onResponseReceivedEndpoints', ..., ('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems')
3461 for page_num in itertools.count(0):
3462 if not continuation:
3464 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3465 comment_prog_str = f"({tracker['running_total']}
/~{tracker['est_total']}
)"
3467 if is_first_continuation:
3468 note_prefix = 'Downloading comment section API JSON'
3470 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3471 tracker['current_page_thread'], comment_prog_str)
3473 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
3474 ' ' if parent else '', ' replies' if parent else '',
3475 page_num, comment_prog_str)
3477 # Do a deep check for incomplete data as sometimes YouTube may return no comments for a continuation
3478 # Ignore check if YouTube says the comment count is 0.
3479 check_get_keys = None
3480 if not is_forced_continuation and not (tracker['est_total'] == 0 and tracker['running_total'] == 0):
3481 check_get_keys = [[*continuation_items_path, ..., (
3482 'commentsHeaderRenderer' if is_first_continuation else ('commentThreadRenderer', 'commentRenderer'))]]
3484 response = self._extract_response(
3485 item_id=None, query=continuation,
3486 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3487 check_get_keys=check_get_keys)
3488 except ExtractorError as e:
3489 # Ignore incomplete data error for replies if retries didn't work.
3490 # This is to allow any other parent comments and comment threads to be downloaded.
3491 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3492 if 'incomplete data' in str(e).lower() and parent:
3493 if self.get_param('ignoreerrors') in (True, 'only_download'):
3494 self.report_warning(
3495 'Received incomplete data for a comment reply thread and retrying did not help. '
3496 'Ignoring to let other comments be downloaded. Pass --no-ignore-errors to not ignore.')
3499 raise ExtractorError(
3500 'Incomplete data received for comment reply thread. '
3501 'Pass --ignore-errors to ignore and allow rest of comments to download.',
3504 is_forced_continuation = False
3506 for continuation_items in traverse_obj(response, continuation_items_path, expected_type=list, default=[]):
3507 if is_first_continuation:
3508 continuation = extract_header(continuation_items)
3509 is_first_continuation = False
3514 for entry in extract_thread(continuation_items):
3518 continuation = self._extract_continuation({'contents': continuation_items})
3522 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3523 if message and not parent and tracker['running_total'] == 0:
3524 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3525 raise self.CommentsDisabled
3528 def _generate_comment_continuation(video_id):
3530 Generates initial comment section continuation token from given video id
3532 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3533 return base64.b64encode(token.encode()).decode()
3535 def _get_comments(self, ytcfg, video_id, contents, webpage):
3536 """Entry for comment extraction"""
3537 def _real_comment_extract(contents):
3539 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3540 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3541 yield from self._comment_entries(renderer, ytcfg, video_id)
3543 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3544 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3547 def _get_checkok_params():
3548 return {'contentCheckOk': True, 'racyCheckOk': True}
3551 def _generate_player_context(cls, sts=None):
3553 'html5Preference': 'HTML5_PREF_WANTS',
3556 context['signatureTimestamp'] = sts
3558 'playbackContext': {
3559 'contentPlaybackContext': context
3561 **cls._get_checkok_params()
3565 def _is_agegated(player_response):
3566 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3569 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3570 AGE_GATE_REASONS = (
3571 'confirm your age', 'age-restricted', 'inappropriate', # reason
3572 'age_verification_required', 'age_check_required', # status
3574 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3577 def _is_unplayable(player_response):
3578 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3580 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3582 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3583 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3584 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3585 headers = self.generate_api_headers(
3586 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3589 'videoId': video_id,
3591 if _split_innertube_client(client)[0] == 'android':
3592 yt_query['params'] = 'CgIQBg=='
3594 pp_arg = self._configuration_arg('player_params', [None], casesense=True)[0]
3596 yt_query['params'] = pp_arg
3598 yt_query.update(self._generate_player_context(sts))
3599 return self._extract_response(
3600 item_id=video_id, ep='player', query=yt_query,
3601 ytcfg=player_ytcfg, headers=headers, fatal=True,
3602 default_client=client,
3603 note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
3606 def _get_requested_clients(self, url, smuggled_data):
3607 requested_clients = []
3608 default = ['ios', 'android', 'web']
3609 allowed_clients = sorted(
3610 (client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'),
3611 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3612 for client in self._configuration_arg('player_client'):
3613 if client in allowed_clients:
3614 requested_clients.append(client)
3615 elif client == 'default':
3616 requested_clients.extend(default)
3617 elif client == 'all':
3618 requested_clients.extend(allowed_clients)
3620 self.report_warning(f'Skipping unsupported client {client}')
3621 if not requested_clients:
3622 requested_clients = default
3624 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3625 requested_clients.extend(
3626 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3628 return orderedSet(requested_clients)
3630 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3633 initial_pr = self._search_json(
3634 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3636 all_clients = set(clients)
3637 clients = clients[::-1]
3640 def append_client(*client_names):
3641 """ Append the first client name that exists but not already used """
3642 for client_name in client_names:
3643 actual_client = _split_innertube_client(client_name)[0]
3644 if actual_client in INNERTUBE_CLIENTS:
3645 if actual_client not in all_clients:
3646 clients.append(client_name)
3647 all_clients.add(actual_client)
3650 # Android player_response does not have microFormats which are needed for
3651 # extraction of some data. So we return the initial_pr with formats
3652 # stripped out even if not requested by the user
3653 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3655 pr = dict(initial_pr)
3656 pr['streamingData'] = None
3660 tried_iframe_fallback = False
3663 client, base_client, variant = _split_innertube_client(clients.pop())
3664 player_ytcfg = master_ytcfg if client == 'web' else {}
3665 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3666 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3668 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3669 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3670 if 'js' in self._configuration_arg('player_skip'):
3671 require_js_player = False
3674 if not player_url and not tried_iframe_fallback and require_js_player:
3675 player_url = self._download_player_url(video_id)
3676 tried_iframe_fallback = True
3679 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3680 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3681 except ExtractorError as e:
3683 self.report_warning(last_error)
3688 # YouTube may return a different video player response than expected.
3689 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3690 pr_video_id = traverse_obj(pr, ('videoDetails', 'videoId'))
3691 if pr_video_id and pr_video_id != video_id:
3692 self.report_warning(
3693 f'Skipping player response from {client} client (got player response for video "{pr_video_id}
" instead of "{video_id}
")' + bug_reports_message())
3695 # Save client name for introspection later
3696 name = short_client_name(client)
3697 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3698 sd[STREAMING_DATA_CLIENT_NAME] = name
3699 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3700 f[STREAMING_DATA_CLIENT_NAME] = name
3703 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3704 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3705 append_client(f'{base_client}_creator')
3706 elif self._is_agegated(pr):
3707 if variant == 'tv_embedded':
3708 append_client(f'{base_client}_embedded')
3710 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3715 self.report_warning(last_error)
3716 return prs, player_url
3718 def _needs_live_processing(self, live_status, duration):
3719 if (live_status == 'is_live' and self.get_param('live_from_start')
3720 or live_status == 'post_live' and (duration or 0) > 2 * 3600):
3723 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3724 CHUNK_SIZE = 10 << 20
3725 itags, stream_ids = collections.defaultdict(set), []
3726 itag_qualities, res_qualities = {}, {0: None}
3728 # Normally tiny is the smallest video-only formats. But
3729 # audio-only formats with unknown quality may get tagged as tiny
3731 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3732 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
3734 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3735 format_types = self._configuration_arg('formats')
3736 all_formats = 'duplicate' in format_types
3737 if self._configuration_arg('include_duplicate_formats'):
3739 self._downloader.deprecated_feature('[youtube] include_duplicate_formats extractor argument is deprecated. '
3740 'Use formats=duplicate extractor argument instead')
3742 def build_fragments(f):
3744 'url': update_url_query(f['url'], {
3745 'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}'
3747 } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3749 for fmt in streaming_formats:
3750 if fmt.get('targetDurationSec'):
3753 itag = str_or_none(fmt.get('itag'))
3754 audio_track = fmt.get('audioTrack') or {}
3755 stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3757 if stream_id in stream_ids:
3760 quality = fmt.get('quality')
3761 height = int_or_none(fmt.get('height'))
3762 if quality == 'tiny' or not quality:
3763 quality = fmt.get('audioQuality', '').lower() or quality
3764 # The 3gp format (17) in android client has a quality of "small
",
3765 # but is actually worse than other formats
3770 itag_qualities[itag] = quality
3772 res_qualities[height] = quality
3773 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3774 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3775 # number of fragment that would subsequently requested with (`&sq=N`)
3776 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3779 fmt_url = fmt.get('url')
3781 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3782 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3783 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3784 if not all((sc, fmt_url, player_url, encrypted_sig)):
3787 fmt_url += '&%s=%s' % (
3788 traverse_obj(sc, ('sp', -1)) or 'signature',
3789 self._decrypt_signature(encrypted_sig, video_id, player_url)
3791 except ExtractorError as e:
3792 self.report_warning('Signature extraction failed: Some formats may be missing',
3793 video_id=video_id, only_once=True)
3794 self.write_debug(e, only_once=True)
3797 query = parse_qs(fmt_url)
3801 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3802 fmt_url = update_url_query(fmt_url, {
3803 'n': decrypt_nsig(query['n'][0], video_id, player_url)
3805 except ExtractorError as e:
3807 if isinstance(e, JSInterpreter.Exception):
3808 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3809 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3811 self.report_warning(
3812 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3813 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3814 self.write_debug(e, only_once=True)
3816 self.report_warning(
3817 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3818 video_id=video_id, only_once=True)
3821 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3822 language_preference = (
3823 10 if audio_track.get('audioIsDefault') and 10
3824 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3826 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3827 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3828 # Make sure to avoid false positives with small duration differences.
3829 # E.g. __2ABJjxzNo, ySuUZEjARPY
3830 is_damaged = try_get(fmt, lambda x: float(x['approxDurationMs']) / duration < 500)
3832 self.report_warning(
3833 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3835 client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3836 name = fmt.get('qualityLabel') or quality.replace('audio_quality_', '') or ''
3837 fps = int_or_none(fmt.get('fps')) or 0
3839 'asr': int_or_none(fmt.get('audioSampleRate')),
3840 'filesize': int_or_none(fmt.get('contentLength')),
3841 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3842 'format_note': join_nonempty(
3843 join_nonempty(audio_track.get('displayName'),
3844 language_preference > 0 and ' (default)', delim=''),
3845 name, fmt.get('isDrc') and 'DRC',
3846 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3847 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3848 throttled and 'THROTTLED', is_damaged and 'DAMAGED',
3849 (self.get_param('verbose') or all_formats) and client_name,
3851 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3852 'source_preference': ((-10 if throttled else -5 if itag == '22' else -1)
3853 + (100 if 'Premium' in name else 0)),
3854 'fps': fps if fps > 1 else None, # For some formats, fps is wrongly returned as 1
3855 'audio_channels': fmt.get('audioChannels'),
3857 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3858 'has_drm': bool(fmt.get('drmFamilies')),
3861 'width': int_or_none(fmt.get('width')),
3862 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3863 'desc' if language_preference < -1 else '') or None,
3864 'language_preference': language_preference,
3865 # Strictly de-prioritize damaged and 3gp formats
3866 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3868 mime_mobj = re.match(
3869 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3871 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3872 dct.update(parse_codecs(mime_mobj.group(2)))
3874 itags[itag].add(('https
', dct.get('language
')))
3875 stream_ids.append(stream_id)
3876 single_stream = 'none
' in (dct.get('acodec
'), dct.get('vcodec
'))
3877 if single_stream and dct.get('ext
'):
3878 dct['container
'] = dct['ext
'] + '_dash
'
3880 if (all_formats or 'dashy
' in format_types) and dct['filesize
']:
3883 'format_id
': f'{dct["format_id"]}
-dashy
' if all_formats else dct['format_id
'],
3884 'protocol
': 'http_dash_segments
',
3885 'fragments
': build_fragments(dct),
3887 if all_formats or 'dashy
' not in format_types:
3888 dct['downloader_options
'] = {'http_chunk_size': CHUNK_SIZE}
3891 needs_live_processing = self._needs_live_processing(live_status, duration)
3892 skip_bad_formats = 'incomplete
' not in format_types
3893 if self._configuration_arg('include_incomplete_formats
'):
3894 skip_bad_formats = False
3895 self._downloader.deprecated_feature('[youtube
] include_incomplete_formats extractor argument
is deprecated
. '
3896 'Use formats
=incomplete extractor argument instead
')
3898 skip_manifests = set(self._configuration_arg('skip
'))
3899 if (not self.get_param('youtube_include_hls_manifest
', True)
3900 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3901 or needs_live_processing and skip_bad_formats):
3902 skip_manifests.add('hls
')
3904 if not self.get_param('youtube_include_dash_manifest
', True):
3905 skip_manifests.add('dash
')
3906 if self._configuration_arg('include_live_dash
'):
3907 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3908 'Use formats
=incomplete extractor argument instead
')
3909 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3910 skip_manifests.add('dash
')
3912 def process_manifest_format(f, proto, client_name, itag):
3913 key = (proto, f.get('language
'))
3914 if not all_formats and key in itags[itag]:
3916 itags[itag].add(key)
3918 if itag and all_formats:
3919 f['format_id
'] = f'{itag}
-{proto}
'
3920 elif any(p != proto for p, _ in itags[itag]):
3921 f['format_id
'] = f'{itag}
-{proto}
'
3923 f['format_id
'] = itag
3925 if f.get('source_preference
') is None:
3926 f['source_preference
'] = -1
3928 if itag in ('616', '235'):
3929 f['format_note
'] = join_nonempty(f.get('format_note
'), 'Premium
', delim=' ')
3930 f['source_preference
'] += 100
3932 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
3933 if f['quality
'] == -1 and f.get('height
'):
3934 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
3935 if self.get_param('verbose
') or all_formats:
3936 f['format_note
'] = join_nonempty(f.get('format_note
'), client_name, delim=', ')
3937 if f.get('fps
') and f['fps
'] <= 1:
3940 if proto == 'hls
' and f.get('has_drm
'):
3941 f['has_drm
'] = 'maybe
'
3942 f['source_preference
'] -= 5
3946 for sd in streaming_data:
3947 client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
3949 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
3950 if hls_manifest_url:
3951 fmts, subs = self._extract_m3u8_formats_and_subtitles(
3952 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
3953 subtitles = self._merge_subtitles(subs, subtitles)
3955 if process_manifest_format(f, 'hls
', client_name, self._search_regex(
3956 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
3959 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
3960 if dash_manifest_url:
3961 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
3962 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
3964 if process_manifest_format(f, 'dash
', client_name, f['format_id
']):
3965 f['filesize
'] = int_or_none(self._search_regex(
3966 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
3967 if needs_live_processing:
3968 f['is_from_start
'] = True
3973 def _extract_storyboard(self, player_responses, duration):
3975 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
3976 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
3980 for i, args in enumerate(spec):
3981 args = args.split('#')
3982 counts
= list(map(int_or_none
, args
[:5]))
3983 if len(args
) != 8 or not all(counts
):
3984 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
3986 width
, height
, frame_count
, cols
, rows
= counts
3989 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
3990 fragment_count
= frame_count
/ (cols
* rows
)
3991 fragment_duration
= duration
/ fragment_count
3993 'format_id': f
'sb{i}',
3994 'format_note': 'storyboard',
3996 'protocol': 'mhtml',
4002 'fps': frame_count
/ duration
,
4006 'url': url
.replace('$M', str(j
)),
4007 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
4008 } for j
in range(math
.ceil(fragment_count
))],
4011 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
4013 if 'webpage' not in self
._configuration
_arg
('player_skip'):
4014 query
= {'bpctr': '9999999999', 'has_verified': '1'}
4015 pp
= self
._configuration
_arg
('player_params', [None], casesense
=True)[0]
4018 webpage
= self
._download
_webpage
(
4019 webpage_url
, video_id
, fatal
=False, query
=query
)
4021 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
4023 player_responses
, player_url
= self
._extract
_player
_responses
(
4024 self
._get
_requested
_clients
(url
, smuggled_data
),
4025 video_id
, webpage
, master_ytcfg
, smuggled_data
)
4027 return webpage
, master_ytcfg
, player_responses
, player_url
4029 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
4030 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
4031 is_live
= get_first(video_details
, 'isLive')
4033 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
4034 live_content
= get_first(video_details
, 'isLiveContent')
4035 is_upcoming
= get_first(video_details
, 'isUpcoming')
4036 post_live
= get_first(video_details
, 'isPostLiveDvr')
4037 live_status
= ('post_live' if post_live
4038 else 'is_live' if is_live
4039 else 'is_upcoming' if is_upcoming
4040 else 'was_live' if live_content
4041 else 'not_live' if False in (is_live
, live_content
)
4043 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'))
4044 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
4045 if all(f
.get('has_drm') for f
in formats
):
4046 # If there are no formats that definitely don't have DRM, all have DRM
4050 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
4052 def _real_extract(self
, url
):
4053 url
, smuggled_data
= unsmuggle_url(url
, {})
4054 video_id
= self
._match
_id
(url
)
4056 base_url
= self
.http_scheme() + '//www.youtube.com/'
4057 webpage_url
= base_url
+ 'watch?v=' + video_id
4059 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
4061 playability_statuses
= traverse_obj(
4062 player_responses
, (..., 'playabilityStatus'), expected_type
=dict)
4064 trailer_video_id
= get_first(
4065 playability_statuses
,
4066 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
4068 if trailer_video_id
:
4069 return self
.url_result(
4070 trailer_video_id
, self
.ie_key(), trailer_video_id
)
4072 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
4073 if webpage
else (lambda x
: None))
4075 video_details
= traverse_obj(player_responses
, (..., 'videoDetails'), expected_type
=dict)
4076 microformats
= traverse_obj(
4077 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
4080 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
4081 video_title
= (self
._preferred
_lang
and translated_title
4082 or get_first(video_details
, 'title') # primary
4084 or search_meta(['og:title', 'twitter:title', 'title']))
4085 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
4086 original_description
= get_first(video_details
, 'shortDescription')
4087 video_description
= (
4088 self
._preferred
_lang
and translated_description
4089 # If original description is blank, it will be an empty string.
4090 # Do not prefer translated description in this case.
4091 or original_description
if original_description
is not None else translated_description
)
4093 multifeed_metadata_list
= get_first(
4095 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
4097 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
4098 if self
.get_param('noplaylist'):
4099 self
.to_screen('Downloading just video %s because of --no-playlist' % video_id
)
4103 for feed
in multifeed_metadata_list
.split(','):
4104 # Unquote should take place before split on comma (,) since textual
4105 # fields may contain comma as well (see
4106 # https://github.com/ytdl-org/youtube-dl/issues/8536)
4107 feed_data
= urllib
.parse
.parse_qs(
4108 urllib
.parse
.unquote_plus(feed
))
4110 def feed_entry(name
):
4112 feed_data
, lambda x
: x
[name
][0], str)
4114 feed_id
= feed_entry('id')
4117 feed_title
= feed_entry('title')
4120 title
+= ' (%s)' % feed_title
4122 '_type': 'url_transparent',
4123 'ie_key': 'Youtube',
4125 '%swatch?v=%s' % (base_url
, feed_data
['id'][0]),
4126 {'force_singlefeed': True}
),
4129 feed_ids
.append(feed_id
)
4131 'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
4132 % (', '.join(feed_ids
), video_id
))
4133 return self
.playlist_result(
4134 entries
, video_id
, video_title
, video_description
)
4136 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
4137 or int_or_none(get_first(microformats
, 'lengthSeconds'))
4138 or parse_duration(search_meta('duration')) or None)
4140 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
4141 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
4142 if live_status
== 'post_live':
4143 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
4146 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
4147 self
.report_drm(video_id
)
4149 playability_statuses
,
4150 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
4151 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
4152 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
4154 if subreason
== 'The uploader has not made this video available in your country.':
4155 countries
= get_first(microformats
, 'availableCountries')
4157 regions_allowed
= search_meta('regionsAllowed')
4158 countries
= regions_allowed
.split(',') if regions_allowed
else None
4159 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
4160 reason
+= f
'. {subreason}'
4162 self
.raise_no_formats(reason
, expected
=True)
4164 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
4165 if not keywords
and webpage
:
4167 unescapeHTML(m
.group('content'))
4168 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
4169 for keyword
in keywords
:
4170 if keyword
.startswith('yt:stretch='):
4171 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
4173 # NB: float is intentional for forcing float division
4174 w
, h
= (float(v
) for v
in mobj
.groups())
4178 if f
.get('vcodec') != 'none':
4179 f
['stretched_ratio'] = ratio
4181 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
4182 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
4185 'url': thumbnail_url
,
4187 original_thumbnails
= thumbnails
.copy()
4189 # The best resolution thumbnails sometimes does not appear in the webpage
4190 # See: https://github.com/yt-dlp/yt-dlp/issues/340
4191 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4193 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4194 # in resolution, these are not the custom thumbnail. So de-prioritize them
4195 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4196 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3'
4198 n_thumbnail_names
= len(thumbnail_names
)
4200 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4201 video_id
=video_id
, name
=name
, ext
=ext
,
4202 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
4203 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
4204 for thumb
in thumbnails
:
4205 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
4206 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
4207 self
._remove
_duplicate
_formats
(thumbnails
)
4208 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
4210 category
= get_first(microformats
, 'category') or search_meta('genre')
4211 channel_id
= self
.ucid_or_none(str_or_none(
4212 get_first(video_details
, 'channelId')
4213 or get_first(microformats
, 'externalChannelId')
4214 or search_meta('channelId')))
4215 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
4217 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
4218 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
4219 if not duration
and live_end_time
and live_start_time
:
4220 duration
= live_end_time
- live_start_time
4222 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
4224 def is_bad_format(fmt
):
4225 if needs_live_processing
and not fmt
.get('is_from_start'):
4227 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
4228 and fmt
.get('protocol') == 'http_dash_segments'):
4231 for fmt
in filter(is_bad_format
, formats
):
4232 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4233 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 2 hours)', delim
=' ')
4235 if needs_live_processing
:
4236 self
._prepare
_live
_from
_start
_formats
(
4237 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4239 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4241 channel_handle
= self
.handle_from_url(owner_profile_url
)
4245 'title': video_title
,
4247 'thumbnails': thumbnails
,
4248 # The best thumbnail that we are sure exists. Prevents unnecessary
4249 # URL checking if user don't care about getting the best possible thumbnail
4250 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4251 'description': video_description
,
4252 'channel_id': channel_id
,
4253 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None),
4254 'duration': duration
,
4255 'view_count': int_or_none(
4256 get_first((video_details
, microformats
), (..., 'viewCount'))
4257 or search_meta('interactionCount')),
4258 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4259 'age_limit': 18 if (
4260 get_first(microformats
, 'isFamilySafe') is False
4261 or search_meta('isFamilyFriendly') == 'false'
4262 or search_meta('og:restrictions:age') == '18+') else 0,
4263 'webpage_url': webpage_url
,
4264 'categories': [category
] if category
else None,
4266 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4267 'live_status': live_status
,
4268 'release_timestamp': live_start_time
,
4269 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4270 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto')
4274 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4276 def get_lang_code(track
):
4277 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4278 or track
.get('languageCode'))
4280 # Converted into dicts to remove duplicates
4282 get_lang_code(sub
): sub
4283 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...))}
4284 translation_languages
= {
4285 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4286 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...))}
4288 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4289 lang_subs
= container
.setdefault(lang_code
, [])
4290 for fmt
in self
._SUBTITLE
_FORMATS
:
4296 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4300 # NB: Constructing the full subtitle dictionary is slow
4301 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4302 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4303 for lang_code
, caption_track
in captions
.items():
4304 base_url
= caption_track
.get('baseUrl')
4305 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4308 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4309 if caption_track
.get('kind') != 'asr':
4313 subtitles
, base_url
, lang_code
, lang_name
, {})
4314 if not caption_track
.get('isTranslatable'):
4316 for trans_code
, trans_name
in translation_languages
.items():
4319 orig_trans_code
= trans_code
4320 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4321 if not get_translated_subs
:
4323 trans_code
+= f
'-{lang_code}'
4324 trans_name
+= format_field(lang_name
, None, ' from %s')
4325 if lang_code
== f
'a-{orig_trans_code}':
4326 # Set audio language based on original subtitles
4328 if f
.get('acodec') != 'none' and not f
.get('language'):
4329 f
['language'] = orig_trans_code
4330 # Add an "-orig" label to the original language so that it can be distinguished.
4331 # The subs are returned without "-orig" as well for compatibility
4333 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4334 # Setting tlang=lang returns damaged subtitles.
4335 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4336 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4338 info
['automatic_captions'] = automatic_captions
4339 info
['subtitles'] = subtitles
4341 parsed_url
= urllib
.parse
.urlparse(url
)
4342 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4343 query
= urllib
.parse
.parse_qs(component
)
4344 for k
, v
in query
.items():
4345 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4347 if d_k
not in info
and k
in s_ks
:
4348 info
[d_k
] = parse_duration(query
[k
][0])
4350 # Youtube Music Auto-generated description
4351 if (video_description
or '').strip().endswith('\nAuto-generated by YouTube.'):
4352 # XXX: Causes catastrophic backtracking if description has "·"
4353 # E.g. https://www.youtube.com/watch?v=DoPaAxMQoiI
4354 # Simulating atomic groups: (?P<a>[^xy]+)x => (?=(?P<a>[^xy]+))(?P=a)x
4355 # reduces it, but does not fully fix it. https://regex101.com/r/8Ssf2h/2
4358 (?=(?P<track>[^\n·]+))(?P=track)·
4359 (?=(?P<artist>[^\n]+))(?P=artist)\n+
4360 (?=(?P<album>[^\n]+))(?P=album)\n
4361 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4362 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4364 (?=(?P<clean_artist>[^\n]+))(?P=clean_artist)\n
4365 )?.+\nAuto-generated\ by\ YouTube\.\s*$
4366 ''', video_description
)
4368 release_year
= mobj
.group('release_year')
4369 release_date
= mobj
.group('release_date')
4371 release_date
= release_date
.replace('-', '')
4372 if not release_year
:
4373 release_year
= release_date
[:4]
4375 'album': mobj
.group('album'.strip()),
4376 'artist': mobj
.group('clean_artist') or ', '.join(a
.strip() for a
in mobj
.group('artist').split('·')),
4377 'track': mobj
.group('track').strip(),
4378 'release_date': release_date
,
4379 'release_year': int_or_none(release_year
),
4384 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4385 if not traverse_obj(initial_data
, 'contents'):
4386 self
.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4388 if not initial_data
:
4389 query
= {'videoId': video_id}
4390 query
.update(self
._get
_checkok
_params
())
4391 initial_data
= self
._extract
_response
(
4392 item_id
=video_id
, ep
='next', fatal
=False,
4393 ytcfg
=master_ytcfg
, query
=query
, check_get_keys
='contents',
4394 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4395 note
='Downloading initial data API JSON')
4397 info
['comment_count'] = traverse_obj(initial_data
, (
4398 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4399 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount'
4401 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4402 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo'
4403 ), expected_type
=self
._get
_count
, get_all
=False)
4405 try: # This will error if there is no livechat
4406 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4407 except (KeyError, IndexError, TypeError):
4410 info
.setdefault('subtitles', {})['live_chat'] = [{
4411 # url is needed to set cookies
4412 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4413 'video_id': video_id
,
4415 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4416 else 'youtube_live_chat_replay'),
4420 info
['chapters'] = (
4421 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4422 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4423 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4426 info
['heatmap'] = self
._extract
_heatmap
_from
_player
_overlay
(initial_data
)
4428 contents
= traverse_obj(
4429 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4430 expected_type
=list, default
=[])
4432 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4434 stl
= vpir
.get('superTitleLink')
4436 stl
= self
._get
_text
(stl
)
4439 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4440 info
['location'] = stl
4442 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4445 'series': mobj
.group(1),
4446 'season_number': int(mobj
.group(2)),
4447 'episode_number': int(mobj
.group(3)),
4449 for tlb
in (try_get(
4451 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4455 tlb
, ('toggleButtonRenderer', ...),
4456 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4458 for getter
, regex
in [(
4459 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4460 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4461 lambda x
: x
['accessibility'],
4462 lambda x
: x
['accessibilityData']['accessibilityData'],
4463 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4464 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4466 mobj
= re
.match(regex
, label
)
4468 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4470 sbr_tooltip
= try_get(
4471 vpir
, lambda x
: x
['sentimentBar']['sentimentBarRenderer']['tooltip'])
4473 like_count
, dislike_count
= sbr_tooltip
.split(' / ')
4475 'like_count': str_to_int(like_count
),
4476 'dislike_count': str_to_int(dislike_count
),
4478 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4480 vc
= self
._get
_count
(vcr
, 'viewCount')
4481 # Upcoming premieres with waiting count are treated as live here
4482 if vcr
.get('isLive'):
4483 info
['concurrent_view_count'] = vc
4484 elif info
.get('view_count') is None:
4485 info
['view_count'] = vc
4487 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4489 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4491 'channel': self
._get
_text
(vor
, 'title'),
4492 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4494 if not channel_handle
:
4495 channel_handle
= self
.handle_from_url(
4497 ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4498 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4499 {str}
), get_all
=False))
4503 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4505 multiple_songs
= False
4507 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4508 multiple_songs
= True
4511 mrr
= row
.get('metadataRowRenderer') or {}
4512 mrr_title
= mrr
.get('title')
4515 mrr_title
= self
._get
_text
(mrr
, 'title')
4516 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4517 if mrr_title
== 'License':
4518 info
['license'] = mrr_contents_text
4519 elif not multiple_songs
:
4520 if mrr_title
== 'Album':
4521 info
['album'] = mrr_contents_text
4522 elif mrr_title
== 'Artist':
4523 info
['artist'] = mrr_contents_text
4524 elif mrr_title
== 'Song':
4525 info
['track'] = mrr_contents_text
4526 owner_badges
= self
._extract
_badges
(traverse_obj(vsir
, ('owner', 'videoOwnerRenderer', 'badges')))
4527 if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
):
4528 info
['channel_is_verified'] = True
4531 'uploader': info
.get('channel'),
4532 'uploader_id': channel_handle
,
4533 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4535 # The upload date for scheduled, live and past live streams / premieres in microformats
4536 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4537 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4539 unified_strdate(get_first(microformats
, 'uploadDate'))
4540 or unified_strdate(search_meta('uploadDate')))
4541 if not upload_date
or (
4542 live_status
in ('not_live', None)
4543 and 'no-youtube-prefer-utc-upload-date' not in self
.get_param('compat_opts', [])
4545 upload_date
= strftime_or_none(
4546 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText'))) or upload_date
4547 info
['upload_date'] = upload_date
4549 for s_k
, d_k
in [('artist', 'creator'), ('track', 'alt_title')]:
4554 badges
= self
._extract
_badges
(traverse_obj(vpir
, 'badges'))
4556 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4557 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4559 info
['availability'] = (
4560 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4561 else self
._availability
(
4562 is_private
=is_private
,
4564 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4565 or False if initial_data
and is_private
is not None else None),
4566 needs_subscription
=(
4567 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4568 or False if initial_data
and is_private
is not None else None),
4569 needs_auth
=info
['age_limit'] >= 18,
4570 is_unlisted
=None if is_private
is None else (
4571 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4572 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4574 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4576 self
.mark_watched(video_id
, player_responses
)
4581 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4583 def passthrough_smuggled_data(func
):
4584 def _smuggle(info
, smuggled_data
):
4585 if info
.get('_type') not in ('url', 'url_transparent'):
4587 if smuggled_data
.get('is_music_url'):
4588 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4589 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4590 smuggled_data
.pop('is_music_url')
4591 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4593 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4596 @functools.wraps(func
)
4597 def wrapper(self
, url
):
4598 url
, smuggled_data
= unsmuggle_url(url
, {})
4599 if self
.is_music_url(url
):
4600 smuggled_data
['is_music_url'] = True
4601 info_dict
= func(self
, url
, smuggled_data
)
4603 _smuggle(info_dict
, smuggled_data
)
4604 if info_dict
.get('entries'):
4605 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4610 def _extract_basic_item_renderer(item
):
4611 # Modified from _extract_grid_item_renderer
4612 known_basic_renderers
= (
4613 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer'
4615 for key
, renderer
in item
.items():
4616 if not isinstance(renderer
, dict):
4618 elif key
in known_basic_renderers
:
4620 elif key
.startswith('grid') and key
.endswith('Renderer'):
4623 def _extract_channel_renderer(self
, renderer
):
4624 channel_id
= self
.ucid_or_none(renderer
['channelId'])
4625 title
= self
._get
_text
(renderer
, 'title')
4626 channel_url
= format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None)
4627 channel_handle
= self
.handle_from_url(
4628 traverse_obj(renderer
, (
4629 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4630 ('browseEndpoint', 'canonicalBaseUrl')),
4631 {str}
), get_all
=False))
4632 if not channel_handle
:
4633 # As of 2023-06-01, YouTube sets subscriberCountText to the handle in search
4634 channel_handle
= self
.handle_or_none(self
._get
_text
(renderer
, 'subscriberCountText'))
4639 'ie_key': YoutubeTabIE
.ie_key(),
4642 'channel_id': channel_id
,
4643 'channel_url': channel_url
,
4645 'uploader_id': channel_handle
,
4646 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4647 # See above. YouTube sets videoCountText to the subscriber text in search channel renderers.
4648 # However, in feed/channels this is set correctly to the subscriber count
4649 'channel_follower_count': traverse_obj(
4650 renderer
, 'subscriberCountText', 'videoCountText', expected_type
=self
._get
_count
),
4651 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
4653 # videoCountText may be the subscriber count
4654 self
._get
_count
(renderer
, 'videoCountText')
4655 if self
._get
_count
(renderer
, 'subscriberCountText') is not None else None),
4656 'description': self
._get
_text
(renderer
, 'descriptionSnippet'),
4657 'channel_is_verified': True if self
._has
_badge
(
4658 self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges')), BadgeType
.VERIFIED
) else None,
4661 def _grid_entries(self
, grid_renderer
):
4662 for item
in grid_renderer
['items']:
4663 if not isinstance(item
, dict):
4665 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4666 if not isinstance(renderer
, dict):
4668 title
= self
._get
_text
(renderer
, 'title')
4671 playlist_id
= renderer
.get('playlistId')
4673 yield self
.url_result(
4674 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4675 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4679 video_id
= renderer
.get('videoId')
4681 yield self
._extract
_video
(renderer
)
4684 channel_id
= renderer
.get('channelId')
4686 yield self
._extract
_channel
_renderer
(renderer
)
4688 # generic endpoint URL support
4689 ep_url
= urljoin('https://www.youtube.com/', try_get(
4690 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4693 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4694 if ie
.suitable(ep_url
):
4695 yield self
.url_result(
4696 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4699 def _music_reponsive_list_entry(self
, renderer
):
4700 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4702 title
= traverse_obj(renderer
, (
4703 'flexColumns', 0, 'musicResponsiveListItemFlexColumnRenderer',
4704 'text', 'runs', 0, 'text'))
4705 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4706 ie
=YoutubeIE
.ie_key(), video_id
=video_id
, title
=title
)
4707 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4709 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4711 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4712 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4713 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4714 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4715 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4717 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4718 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4720 def _shelf_entries_from_content(self
, shelf_renderer
):
4721 content
= shelf_renderer
.get('content')
4722 if not isinstance(content
, dict):
4724 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4726 # TODO: add support for nested playlists so each shelf is processed
4727 # as separate playlist
4728 # TODO: this includes only first N items
4729 yield from self
._grid
_entries
(renderer
)
4730 renderer
= content
.get('horizontalListRenderer')
4735 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4737 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4739 shelf_url
= urljoin('https://www.youtube.com', ep
)
4741 # Skipping links to another channels, note that checking for
4742 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4744 if skip_channels
and '/channels?' in shelf_url
:
4746 title
= self
._get
_text
(shelf_renderer
, 'title')
4747 yield self
.url_result(shelf_url
, video_title
=title
)
4748 # Shelf may not contain shelf URL, fallback to extraction from content
4749 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4751 def _playlist_entries(self
, video_list_renderer
):
4752 for content
in video_list_renderer
['contents']:
4753 if not isinstance(content
, dict):
4755 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4756 if not isinstance(renderer
, dict):
4758 video_id
= renderer
.get('videoId')
4761 yield self
._extract
_video
(renderer
)
4763 def _rich_entries(self
, rich_grid_renderer
):
4764 renderer
= traverse_obj(
4766 ('content', ('videoRenderer', 'reelItemRenderer', 'playlistRenderer')), get_all
=False) or {}
4767 video_id
= renderer
.get('videoId')
4769 yield self
._extract
_video
(renderer
)
4771 playlist_id
= renderer
.get('playlistId')
4773 yield self
.url_result(
4774 f
'https://www.youtube.com/playlist?list={playlist_id}',
4775 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4776 video_title
=self
._get
_text
(renderer
, 'title'))
4779 def _video_entry(self
, video_renderer
):
4780 video_id
= video_renderer
.get('videoId')
4782 return self
._extract
_video
(video_renderer
)
4784 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4785 url
= urljoin('https://youtube.com', traverse_obj(
4786 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4788 return self
.url_result(
4789 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4791 def _post_thread_entries(self
, post_thread_renderer
):
4792 post_renderer
= try_get(
4793 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4794 if not post_renderer
:
4797 video_renderer
= try_get(
4798 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4799 video_id
= video_renderer
.get('videoId')
4801 entry
= self
._extract
_video
(video_renderer
)
4804 # playlist attachment
4805 playlist_id
= try_get(
4806 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4808 yield self
.url_result(
4809 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4810 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4811 # inline video links
4812 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4814 if not isinstance(run
, dict):
4817 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4820 if not YoutubeIE
.suitable(ep_url
):
4822 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4823 if video_id
== ep_video_id
:
4825 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4827 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4828 contents
= post_thread_continuation
.get('contents')
4829 if not isinstance(contents
, list):
4831 for content
in contents
:
4832 renderer
= content
.get('backstagePostThreadRenderer')
4833 if isinstance(renderer
, dict):
4834 yield from self
._post
_thread
_entries
(renderer
)
4836 renderer
= content
.get('videoRenderer')
4837 if isinstance(renderer
, dict):
4838 yield self
._video
_entry
(renderer
)
4841 def _rich_grid_entries(self, contents):
4842 for content in contents:
4843 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4845 entry = self._video_entry(video_renderer)
4850 def _report_history_entries(self
, renderer
):
4851 for url
in traverse_obj(renderer
, (
4852 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4853 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4854 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4855 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4857 def _extract_entries(self
, parent_renderer
, continuation_list
):
4858 # continuation_list is modified in-place with continuation_list = [continuation_token]
4859 continuation_list
[:] = [None]
4860 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4861 for content
in contents
:
4862 if not isinstance(content
, dict):
4864 is_renderer
= traverse_obj(
4865 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4868 if content
.get('richItemRenderer'):
4869 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4871 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4872 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4873 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4874 yield from self
._report
_history
_entries
(table
)
4875 continuation_list
[0] = self
._extract
_continuation
(table
)
4878 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4879 for isr_content
in isr_contents
:
4880 if not isinstance(isr_content
, dict):
4884 'playlistVideoListRenderer': self
._playlist
_entries
,
4885 'gridRenderer': self
._grid
_entries
,
4886 'reelShelfRenderer': self
._grid
_entries
,
4887 'shelfRenderer': self
._shelf
_entries
,
4888 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4889 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4890 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4891 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4892 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4893 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)],
4894 'richGridRenderer': lambda x
: self
._extract
_entries
(x
, continuation_list
),
4896 for key
, renderer
in isr_content
.items():
4897 if key
not in known_renderers
:
4899 for entry
in known_renderers
[key
](renderer
):
4902 continuation_list
[0] = self
._extract
_continuation
(renderer
)
4905 if not continuation_list
[0]:
4906 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
4908 if not continuation_list
[0]:
4909 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4911 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
4912 continuation_list
= [None]
4913 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
4914 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
4918 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
4919 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
4920 yield from extract_entries(parent_renderer
)
4921 continuation
= continuation_list
[0]
4922 seen_continuations
= set()
4923 for page_num
in itertools
.count(1):
4924 if not continuation
:
4926 continuation_token
= continuation
.get('continuation')
4927 if continuation_token
is not None and continuation_token
in seen_continuations
:
4928 self
.write_debug('Detected YouTube feed looping - assuming end of feed.')
4930 seen_continuations
.add(continuation_token
)
4931 headers
= self
.generate_api_headers(
4932 ytcfg
=ytcfg
, account_syncid
=account_syncid
, visitor_data
=visitor_data
)
4933 response
= self
._extract
_response
(
4934 item_id
=f
'{item_id} page {page_num}',
4935 query
=continuation
, headers
=headers
, ytcfg
=ytcfg
,
4936 check_get_keys
=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4940 # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
4941 # See: https://github.com/ytdl-org/youtube-dl/issues/28702
4942 visitor_data
= self
._extract
_visitor
_data
(response
) or visitor_data
4945 'videoRenderer': (self
._grid
_entries
, 'items'), # for membership tab
4946 'gridPlaylistRenderer': (self
._grid
_entries
, 'items'),
4947 'gridVideoRenderer': (self
._grid
_entries
, 'items'),
4948 'gridChannelRenderer': (self
._grid
_entries
, 'items'),
4949 'playlistVideoRenderer': (self
._playlist
_entries
, 'contents'),
4950 'itemSectionRenderer': (extract_entries
, 'contents'), # for feeds
4951 'richItemRenderer': (extract_entries
, 'contents'), # for hashtag
4952 'backstagePostThreadRenderer': (self
._post
_thread
_continuation
_entries
, 'contents'),
4953 'reportHistoryTableRowRenderer': (self
._report
_history
_entries
, 'rows'),
4954 'playlistVideoListContinuation': (self
._playlist
_entries
, None),
4955 'gridContinuation': (self
._grid
_entries
, None),
4956 'itemSectionContinuation': (self
._post
_thread
_continuation
_entries
, None),
4957 'sectionListContinuation': (extract_entries
, None), # for feeds
4960 continuation_items
= traverse_obj(response
, (
4961 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
4962 'appendContinuationItemsAction', 'continuationItems'
4963 ), 'continuationContents', get_all
=False)
4964 continuation_item
= traverse_obj(continuation_items
, 0, None, expected_type
=dict, default
={})
4966 video_items_renderer
= None
4967 for key
in continuation_item
.keys():
4968 if key
not in known_renderers
:
4970 func
, parent_key
= known_renderers
[key
]
4971 video_items_renderer
= {parent_key: continuation_items}
if parent_key
else continuation_items
4972 continuation_list
= [None]
4973 yield from func(video_items_renderer
)
4974 continuation
= continuation_list
[0] or self
._extract
_continuation
(video_items_renderer
)
4976 if not video_items_renderer
:
4980 def _extract_selected_tab(tabs
, fatal
=True):
4981 for tab_renderer
in tabs
:
4982 if tab_renderer
.get('selected'):
4985 raise ExtractorError('Unable to find selected tab')
4988 def _extract_tab_renderers(response
):
4989 return traverse_obj(
4990 response
, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type
=dict)
4992 def _extract_from_tabs(self
, item_id
, ytcfg
, data
, tabs
):
4993 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
4995 selected_tab
= self
._extract
_selected
_tab
(tabs
)
4996 metadata
['title'] += format_field(selected_tab
, 'title', ' - %s')
4997 metadata
['title'] += format_field(selected_tab
, 'expandedText', ' - %s')
4999 return self
.playlist_result(
5001 selected_tab
, metadata
['id'], ytcfg
,
5002 self
._extract
_account
_syncid
(ytcfg
, data
),
5003 self
._extract
_visitor
_data
(data
, ytcfg
)),
5006 def _extract_metadata_from_tabs(self
, item_id
, data
):
5007 info
= {'id': item_id}
5009 metadata_renderer
= traverse_obj(data
, ('metadata', 'channelMetadataRenderer'), expected_type
=dict)
5010 if metadata_renderer
:
5011 channel_id
= traverse_obj(metadata_renderer
, ('externalId', {self.ucid_or_none}
),
5012 ('channelUrl', {self.ucid_from_url}
))
5014 'channel': metadata_renderer
.get('title'),
5015 'channel_id': channel_id
,
5017 if info
['channel_id']:
5018 info
['id'] = info
['channel_id']
5020 metadata_renderer
= traverse_obj(data
, ('metadata', 'playlistMetadataRenderer'), expected_type
=dict)
5022 # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
5023 # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
5024 def _get_uncropped(url
):
5025 return url_or_none((url
or '').split('=')[0] + '=s0')
5027 avatar_thumbnails
= self
._extract
_thumbnails
(metadata_renderer
, 'avatar')
5028 if avatar_thumbnails
:
5029 uncropped_avatar
= _get_uncropped(avatar_thumbnails
[0]['url'])
5030 if uncropped_avatar
:
5031 avatar_thumbnails
.append({
5032 'url': uncropped_avatar
,
5033 'id': 'avatar_uncropped',
5037 channel_banners
= self
._extract
_thumbnails
(
5038 data
, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
5039 for banner
in channel_banners
:
5040 banner
['preference'] = -10
5043 uncropped_banner
= _get_uncropped(channel_banners
[0]['url'])
5044 if uncropped_banner
:
5045 channel_banners
.append({
5046 'url': uncropped_banner
,
5047 'id': 'banner_uncropped',
5051 # Deprecated - remove primary_sidebar_renderer when layout discontinued
5052 primary_sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer')
5053 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer'), expected_type
=dict)
5055 primary_thumbnails
= self
._extract
_thumbnails
(
5056 primary_sidebar_renderer
, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
5057 playlist_thumbnails
= self
._extract
_thumbnails
(
5058 playlist_header_renderer
, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
5061 'title': (traverse_obj(metadata_renderer
, 'title')
5062 or self
._get
_text
(data
, ('header', 'hashtagHeaderRenderer', 'hashtag'))
5064 'availability': self
._extract
_availability
(data
),
5065 'channel_follower_count': self
._get
_count
(data
, ('header', ..., 'subscriberCountText')),
5066 'description': try_get(metadata_renderer
, lambda x
: x
.get('description', '')),
5067 'tags': try_get(metadata_renderer
or {}, lambda x
: x
.get('keywords', '').split()),
5068 'thumbnails': (primary_thumbnails
or playlist_thumbnails
) + avatar_thumbnails
+ channel_banners
,
5072 traverse_obj(metadata_renderer
, (('vanityChannelUrl', ('ownerUrls', ...)), {self.handle_from_url}
), get_all
=False)
5073 or traverse_obj(data
, ('header', ..., 'channelHandleText', {self.handle_or_none}
), get_all
=False))
5077 'uploader_id': channel_handle
,
5078 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
5081 channel_badges
= self
._extract
_badges
(traverse_obj(data
, ('header', ..., 'badges'), get_all
=False))
5082 if self
._has
_badge
(channel_badges
, BadgeType
.VERIFIED
):
5083 info
['channel_is_verified'] = True
5084 # Playlist stats is a text runs array containing [video count, view count, last updated].
5085 # last updated or (view count and last updated) may be missing.
5086 playlist_stats
= get_first(
5087 (primary_sidebar_renderer
, playlist_header_renderer
), (('stats', 'briefStats', 'numVideosText'), ))
5089 last_updated_unix
= self
._parse
_time
_text
(
5090 self
._get
_text
(playlist_stats
, 2) # deprecated, remove when old layout discontinued
5091 or self
._get
_text
(playlist_header_renderer
, ('byline', 1, 'playlistBylineRenderer', 'text')))
5092 info
['modified_date'] = strftime_or_none(last_updated_unix
)
5094 info
['view_count'] = self
._get
_count
(playlist_stats
, 1)
5095 if info
['view_count'] is None: # 0 is allowed
5096 info
['view_count'] = self
._get
_count
(playlist_header_renderer
, 'viewCountText')
5097 if info
['view_count'] is None:
5098 info
['view_count'] = self
._get
_count
(data
, (
5099 'contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., 'tabRenderer', 'content', 'sectionListRenderer',
5100 'contents', ..., 'itemSectionRenderer', 'contents', ..., 'channelAboutFullMetadataRenderer', 'viewCountText'))
5102 info
['playlist_count'] = self
._get
_count
(playlist_stats
, 0)
5103 if info
['playlist_count'] is None: # 0 is allowed
5104 info
['playlist_count'] = self
._get
_count
(playlist_header_renderer
, ('byline', 0, 'playlistBylineRenderer', 'text'))
5106 if not info
.get('channel_id'):
5107 owner
= traverse_obj(playlist_header_renderer
, 'ownerText')
5108 if not owner
: # Deprecated
5109 owner
= traverse_obj(
5110 self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarSecondaryInfoRenderer'),
5111 ('videoOwner', 'videoOwnerRenderer', 'title'))
5112 owner_text
= self
._get
_text
(owner
)
5113 browse_ep
= traverse_obj(owner
, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
5115 'channel': self
._search
_regex
(r
'^by (.+) and \d+ others?$', owner_text
, 'uploader', default
=owner_text
),
5116 'channel_id': self
.ucid_or_none(browse_ep
.get('browseId')),
5117 'uploader_id': self
.handle_from_url(urljoin('https://www.youtube.com', browse_ep
.get('canonicalBaseUrl')))
5121 'uploader': info
['channel'],
5122 'channel_url': format_field(info
.get('channel_id'), None, 'https://www.youtube.com/channel/%s', default
=None),
5123 'uploader_url': format_field(info
.get('uploader_id'), None, 'https://www.youtube.com/%s', default
=None),
5128 def _extract_inline_playlist(self
, playlist
, playlist_id
, data
, ytcfg
):
5129 first_id
= last_id
= response
= None
5130 for page_num
in itertools
.count(1):
5131 videos
= list(self
._playlist
_entries
(playlist
))
5134 start
= next((i
for i
, v
in enumerate(videos
) if v
['id'] == last_id
), -1) + 1
5135 if start
>= len(videos
):
5137 yield from videos
[start
:]
5138 first_id
= first_id
or videos
[0]['id']
5139 last_id
= videos
[-1]['id']
5140 watch_endpoint
= try_get(
5141 playlist
, lambda x
: x
['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
5142 headers
= self
.generate_api_headers(
5143 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5144 visitor_data
=self
._extract
_visitor
_data
(response
, data
, ytcfg
))
5146 'playlistId': playlist_id
,
5147 'videoId': watch_endpoint
.get('videoId') or last_id
,
5148 'index': watch_endpoint
.get('index') or len(videos
),
5149 'params': watch_endpoint
.get('params') or 'OAE%3D'
5151 response
= self
._extract
_response
(
5152 item_id
='%s page %d' % (playlist_id
, page_num
),
5153 query
=query
, ep
='next', headers
=headers
, ytcfg
=ytcfg
,
5154 check_get_keys
='contents'
5157 response
, lambda x
: x
['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
5159 def _extract_from_playlist(self
, item_id
, url
, data
, playlist
, ytcfg
):
5160 title
= playlist
.get('title') or try_get(
5161 data
, lambda x
: x
['titleText']['simpleText'], str)
5162 playlist_id
= playlist
.get('playlistId') or item_id
5164 # Delegating everything except mix playlists to regular tab-based playlist URL
5165 playlist_url
= urljoin(url
, try_get(
5166 playlist
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
5169 # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
5170 # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
5171 is_known_unviewable
= re
.fullmatch(r
'MLCT|RLTD[\w-]{22}', playlist_id
)
5173 if playlist_url
and playlist_url
!= url
and not is_known_unviewable
:
5174 return self
.url_result(
5175 playlist_url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
5178 return self
.playlist_result(
5179 self
._extract
_inline
_playlist
(playlist
, playlist_id
, data
, ytcfg
),
5180 playlist_id
=playlist_id
, playlist_title
=title
)
5182 def _extract_availability(self
, data
):
5184 Gets the availability of a given playlist/tab.
5185 Note: Unless YouTube tells us explicitly, we do not assume it is public
5186 @param data: response
5188 sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer') or {}
5189 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer')) or {}
5190 player_header_privacy
= playlist_header_renderer
.get('privacy')
5192 badges
= self
._extract
_badges
(traverse_obj(sidebar_renderer
, 'badges'))
5194 # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
5195 privacy_setting_icon
= get_first(
5196 (playlist_header_renderer
, sidebar_renderer
),
5197 ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
5198 lambda _
, v
: v
['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
5201 microformats_is_unlisted
= traverse_obj(
5202 data
, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type
=bool)
5206 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
5207 or player_header_privacy
== 'PUBLIC'
5208 or privacy_setting_icon
== 'PRIVACY_PUBLIC')
5209 else self
._availability
(
5211 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
5212 or player_header_privacy
== 'PRIVATE' if player_header_privacy
is not None
5213 else privacy_setting_icon
== 'PRIVACY_PRIVATE' if privacy_setting_icon
is not None else None),
5215 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
5216 or player_header_privacy
== 'UNLISTED' if player_header_privacy
is not None
5217 else privacy_setting_icon
== 'PRIVACY_UNLISTED' if privacy_setting_icon
is not None
5218 else microformats_is_unlisted
if microformats_is_unlisted
is not None else None),
5219 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
5220 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
5224 def _extract_sidebar_info_renderer(data
, info_renderer
, expected_type
=dict):
5225 sidebar_renderer
= try_get(
5226 data
, lambda x
: x
['sidebar']['playlistSidebarRenderer']['items'], list) or []
5227 for item
in sidebar_renderer
:
5228 renderer
= try_get(item
, lambda x
: x
[info_renderer
], expected_type
)
5232 def _reload_with_unavailable_videos(self
, item_id
, data
, ytcfg
):
5234 Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
5236 is_playlist
= bool(traverse_obj(
5237 data
, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
5240 headers
= self
.generate_api_headers(
5241 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5242 visitor_data
=self
._extract
_visitor
_data
(data
, ytcfg
))
5244 'params': 'wgYCCAA=',
5245 'browseId': f
'VL{item_id}'
5247 return self
._extract
_response
(
5248 item_id
=item_id
, headers
=headers
, query
=query
,
5249 check_get_keys
='contents', fatal
=False, ytcfg
=ytcfg
,
5250 note
='Redownloading playlist API JSON with unavailable videos')
5252 @functools.cached_property
5253 def skip_webpage(self
):
5254 return 'webpage' in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key())
5256 def _extract_webpage(self
, url
, item_id
, fatal
=True):
5257 webpage
, data
= None, None
5258 for retry
in self
.RetryManager(fatal
=fatal
):
5260 webpage
= self
._download
_webpage
(url
, item_id
, note
='Downloading webpage')
5261 data
= self
.extract_yt_initial_data(item_id
, webpage
or '', fatal
=fatal
) or {}
5262 except ExtractorError
as e
:
5263 if isinstance(e
.cause
, network_exceptions
):
5264 if not isinstance(e
.cause
, HTTPError
) or e
.cause
.status
not in (403, 429):
5267 self
._error
_or
_warning
(e
, fatal
=fatal
)
5271 self
._extract
_and
_report
_alerts
(data
)
5272 except ExtractorError
as e
:
5273 self
._error
_or
_warning
(e
, fatal
=fatal
)
5276 # Sometimes youtube returns a webpage with incomplete ytInitialData
5277 # See: https://github.com/yt-dlp/yt-dlp/issues/116
5278 if not traverse_obj(data
, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
5279 retry
.error
= ExtractorError('Incomplete yt initial data received')
5282 return webpage
, data
5284 def _report_playlist_authcheck(self
, ytcfg
, fatal
=True):
5285 """Use if failed to extract ytcfg (and data) from initial webpage"""
5286 if not ytcfg
and self
.is_authenticated
:
5287 msg
= 'Playlists that require authentication may not extract correctly without a successful webpage download'
5288 if 'authcheck' not in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key()) and fatal
:
5289 raise ExtractorError(
5290 f
'{msg}. If you are not downloading private content, or '
5291 'your cookies are only for the first account and channel,'
5292 ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
5294 self
.report_warning(msg
, only_once
=True)
5296 def _extract_data(self
, url
, item_id
, ytcfg
=None, fatal
=True, webpage_fatal
=False, default_client
='web'):
5298 if not self
.skip_webpage
:
5299 webpage
, data
= self
._extract
_webpage
(url
, item_id
, fatal
=webpage_fatal
)
5300 ytcfg
= ytcfg
or self
.extract_ytcfg(item_id
, webpage
)
5301 # Reject webpage data if redirected to home page without explicitly requesting
5302 selected_tab
= self
._extract
_selected
_tab
(self
._extract
_tab
_renderers
(data
), fatal
=False) or {}
5303 if (url
!= 'https://www.youtube.com/feed/recommended'
5304 and selected_tab
.get('tabIdentifier') == 'FEwhat_to_watch' # Home page
5305 and 'no-youtube-channel-redirect' not in self
.get_param('compat_opts', [])):
5306 msg
= 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
5308 raise ExtractorError(msg
, expected
=True)
5309 self
.report_warning(msg
, only_once
=True)
5311 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=fatal
)
5312 data
= self
._extract
_tab
_endpoint
(url
, item_id
, ytcfg
, fatal
=fatal
, default_client
=default_client
)
5315 def _extract_tab_endpoint(self
, url
, item_id
, ytcfg
=None, fatal
=True, default_client
='web'):
5316 headers
= self
.generate_api_headers(ytcfg
=ytcfg
, default_client
=default_client
)
5317 resolve_response
= self
._extract
_response
(
5318 item_id
=item_id
, query
={'url': url}
, check_get_keys
='endpoint', headers
=headers
, ytcfg
=ytcfg
, fatal
=fatal
,
5319 ep
='navigation/resolve_url', note
='Downloading API parameters API JSON', default_client
=default_client
)
5320 endpoints
= {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5321 for ep_key
, ep
in endpoints
.items():
5322 params
= try_get(resolve_response
, lambda x
: x
['endpoint'][ep_key
], dict)
5324 return self
._extract
_response
(
5325 item_id
=item_id
, query
=params
, ep
=ep
, headers
=headers
,
5326 ytcfg
=ytcfg
, fatal
=fatal
, default_client
=default_client
,
5327 check_get_keys
=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5328 err_note
= 'Failed to resolve url (does the playlist exist?)'
5330 raise ExtractorError(err_note
, expected
=True)
5331 self
.report_warning(err_note
, item_id
)
5333 _SEARCH_PARAMS
= None
5335 def _search_results(self
, query
, params
=NO_DEFAULT
, default_client
='web'):
5336 data
= {'query': query}
5337 if params
is NO_DEFAULT
:
5338 params
= self
._SEARCH
_PARAMS
5340 data
['params'] = params
5343 ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5344 ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5346 ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5347 ('continuationContents', ),
5349 display_id
= f
'query "{query}"'
5350 check_get_keys
= tuple({keys[0] for keys in content_keys}
)
5351 ytcfg
= self
._download
_ytcfg
(default_client
, display_id
) if not self
.skip_webpage
else {}
5352 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=False)
5354 continuation_list
= [None]
5356 for page_num
in itertools
.count(1):
5357 data
.update(continuation_list
[0] or {})
5358 headers
= self
.generate_api_headers(
5359 ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(search
), default_client
=default_client
)
5360 search
= self
._extract
_response
(
5361 item_id
=f
'{display_id} page {page_num}', ep
='search', query
=data
,
5362 default_client
=default_client
, check_get_keys
=check_get_keys
, ytcfg
=ytcfg
, headers
=headers
)
5363 slr_contents
= traverse_obj(search
, *content_keys
)
5364 yield from self
._extract
_entries
({'contents': list(variadic(slr_contents))}
, continuation_list
)
5365 if not continuation_list
[0]:
5369 class YoutubeTabIE(YoutubeTabBaseInfoExtractor
):
5370 IE_DESC
= 'YouTube Tabs'
5371 _VALID_URL
= r
'''(?x:
5373 (?!consent\.)(?:\w+\.)?
5375 youtube(?:kids)?\.com|
5379 (?P<channel_type>channel|c|user|browse)/|
5382 (?:playlist|watch)\?.*?\blist=
5384 (?!(?:%(reserved_names)s)\b) # Direct URLs
5388 'reserved_names': YoutubeBaseInfoExtractor
._RESERVED
_NAMES
,
5389 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
5391 IE_NAME
= 'youtube:tab'
5394 'note': 'playlists, multipage',
5395 'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5396 'playlist_mincount': 94,
5398 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5399 'title': 'Igor Kleiner - Playlists',
5400 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5401 'uploader': 'Igor Kleiner',
5402 'uploader_id': '@IgorDataScience',
5403 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5404 'channel': 'Igor Kleiner',
5405 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5406 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5407 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5408 'channel_follower_count': int
5411 'note': 'playlists, multipage, different order',
5412 'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5413 'playlist_mincount': 94,
5415 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5416 'title': 'Igor Kleiner - Playlists',
5417 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5418 'uploader': 'Igor Kleiner',
5419 'uploader_id': '@IgorDataScience',
5420 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5421 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5422 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5423 'channel': 'Igor Kleiner',
5424 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5425 'channel_follower_count': int
5428 'note': 'playlists, series',
5429 'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5430 'playlist_mincount': 5,
5432 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5433 'title': '3Blue1Brown - Playlists',
5434 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5435 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5436 'channel': '3Blue1Brown',
5437 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5438 'uploader_id': '@3blue1brown',
5439 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5440 'uploader': '3Blue1Brown',
5441 'tags': ['Mathematics'],
5442 'channel_follower_count': int,
5443 'channel_is_verified': True,
5446 'note': 'playlists, singlepage',
5447 'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5448 'playlist_mincount': 4,
5450 'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5451 'title': 'ThirstForScience - Playlists',
5452 'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5453 'uploader': 'ThirstForScience',
5454 'uploader_url': 'https://www.youtube.com/@ThirstForScience',
5455 'uploader_id': '@ThirstForScience',
5456 'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5457 'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5459 'channel': 'ThirstForScience',
5460 'channel_follower_count': int
5463 'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5464 'only_matching': True,
5466 'note': 'basic, single video playlist',
5467 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5469 'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5470 'title': 'youtube-dl public playlist',
5474 'modified_date': '20201130',
5475 'channel': 'Sergey M.',
5476 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5477 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5478 'availability': 'public',
5479 'uploader': 'Sergey M.',
5480 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5481 'uploader_id': '@sergeym.6173',
5483 'playlist_count': 1,
5485 'note': 'empty playlist',
5486 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5488 'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5489 'title': 'youtube-dl empty playlist',
5491 'channel': 'Sergey M.',
5493 'modified_date': '20160902',
5494 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5495 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5496 'availability': 'public',
5497 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5498 'uploader_id': '@sergeym.6173',
5499 'uploader': 'Sergey M.',
5501 'playlist_count': 0,
5504 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5506 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5507 'title': 'lex will - Home',
5508 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5509 'uploader': 'lex will',
5510 'uploader_id': '@lexwill718',
5511 'channel': 'lex will',
5512 'tags': ['bible', 'history', 'prophesy'],
5513 'uploader_url': 'https://www.youtube.com/@lexwill718',
5514 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5515 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5516 'channel_follower_count': int
5518 'playlist_mincount': 2,
5520 'note': 'Videos tab',
5521 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5523 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5524 'title': 'lex will - Videos',
5525 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5526 'uploader': 'lex will',
5527 'uploader_id': '@lexwill718',
5528 'tags': ['bible', 'history', 'prophesy'],
5529 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5530 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5531 'uploader_url': 'https://www.youtube.com/@lexwill718',
5532 'channel': 'lex will',
5533 'channel_follower_count': int
5535 'playlist_mincount': 975,
5537 'note': 'Videos tab, sorted by popular',
5538 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5540 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5541 'title': 'lex will - Videos',
5542 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5543 'uploader': 'lex will',
5544 'uploader_id': '@lexwill718',
5545 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5546 'uploader_url': 'https://www.youtube.com/@lexwill718',
5547 'channel': 'lex will',
5548 'tags': ['bible', 'history', 'prophesy'],
5549 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5550 'channel_follower_count': int
5552 'playlist_mincount': 199,
5554 'note': 'Playlists tab',
5555 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5557 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5558 'title': 'lex will - Playlists',
5559 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5560 'uploader': 'lex will',
5561 'uploader_id': '@lexwill718',
5562 'uploader_url': 'https://www.youtube.com/@lexwill718',
5563 'channel': 'lex will',
5564 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5565 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5566 'tags': ['bible', 'history', 'prophesy'],
5567 'channel_follower_count': int
5569 'playlist_mincount': 17,
5571 'note': 'Community tab',
5572 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5574 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5575 'title': 'lex will - Community',
5576 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5577 'channel': 'lex will',
5578 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5579 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5580 'tags': ['bible', 'history', 'prophesy'],
5581 'channel_follower_count': int,
5582 'uploader_url': 'https://www.youtube.com/@lexwill718',
5583 'uploader_id': '@lexwill718',
5584 'uploader': 'lex will',
5586 'playlist_mincount': 18,
5588 'note': 'Channels tab',
5589 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5591 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5592 'title': 'lex will - Channels',
5593 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5594 'channel': 'lex will',
5595 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5596 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5597 'tags': ['bible', 'history', 'prophesy'],
5598 'channel_follower_count': int,
5599 'uploader_url': 'https://www.youtube.com/@lexwill718',
5600 'uploader_id': '@lexwill718',
5601 'uploader': 'lex will',
5603 'playlist_mincount': 12,
5605 'note': 'Search tab',
5606 'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5607 'playlist_mincount': 40,
5609 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5610 'title': '3Blue1Brown - Search - linear algebra',
5611 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5612 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5613 'tags': ['Mathematics'],
5614 'channel': '3Blue1Brown',
5615 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5616 'channel_follower_count': int,
5617 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5618 'uploader_id': '@3blue1brown',
5619 'uploader': '3Blue1Brown',
5620 'channel_is_verified': True,
5623 'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5624 'only_matching': True,
5626 'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5627 'only_matching': True,
5629 'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5630 'only_matching': True,
5632 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5633 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5635 'title': '29C3: Not my department',
5636 'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5637 'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5640 'modified_date': '20150605',
5641 'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5642 'channel_url': 'https://www.youtube.com/channel/UCEPzS1rYsrkqzSLNp76nrcg',
5643 'channel': 'Christiaan008',
5644 'availability': 'public',
5645 'uploader_id': '@ChRiStIaAn008',
5646 'uploader': 'Christiaan008',
5647 'uploader_url': 'https://www.youtube.com/@ChRiStIaAn008',
5649 'playlist_count': 96,
5651 'note': 'Large playlist',
5652 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5654 'title': 'Uploads from Cauchemar',
5655 'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5656 'channel_url': 'https://www.youtube.com/channel/UCBABnxM4Ar9ten8Mdjj1j0Q',
5658 'modified_date': r
're:\d{8}',
5659 'channel': 'Cauchemar',
5662 'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5663 'availability': 'public',
5664 'uploader_id': '@Cauchemar89',
5665 'uploader': 'Cauchemar',
5666 'uploader_url': 'https://www.youtube.com/@Cauchemar89',
5668 'playlist_mincount': 1123,
5669 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5671 'note': 'even larger playlist, 8832 videos',
5672 'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5673 'only_matching': True,
5675 'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5676 'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5678 'title': 'Uploads from Interstellar Movie',
5679 'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5682 'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5683 'channel_url': 'https://www.youtube.com/channel/UCXw-G3eDE9trcvY2sBMM_aA',
5684 'channel': 'Interstellar Movie',
5686 'modified_date': r
're:\d{8}',
5687 'availability': 'public',
5688 'uploader_id': '@InterstellarMovie',
5689 'uploader': 'Interstellar Movie',
5690 'uploader_url': 'https://www.youtube.com/@InterstellarMovie',
5692 'playlist_mincount': 21,
5694 'note': 'Playlist with "show unavailable videos" button',
5695 'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5697 'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5698 'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5700 'channel': 'Phim Siêu Nhân Nhật Bản',
5703 'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5704 'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5705 'modified_date': r
're:\d{8}',
5706 'availability': 'public',
5707 'uploader_url': 'https://www.youtube.com/@phimsieunhannhatban',
5708 'uploader_id': '@phimsieunhannhatban',
5709 'uploader': 'Phim Siêu Nhân Nhật Bản',
5711 'playlist_mincount': 200,
5712 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5714 'note': 'Playlist with unavailable videos in page 7',
5715 'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5717 'title': 'Uploads from BlankTV',
5718 'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5719 'channel': 'BlankTV',
5720 'channel_url': 'https://www.youtube.com/channel/UC8l9frL61Yl5KFOl87nIm2w',
5721 'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5724 'modified_date': r
're:\d{8}',
5726 'availability': 'public',
5727 'uploader_id': '@blanktv',
5728 'uploader': 'BlankTV',
5729 'uploader_url': 'https://www.youtube.com/@blanktv',
5731 'playlist_mincount': 1000,
5732 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5734 'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5735 'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5737 'title': 'Data Analysis with Dr Mike Pound',
5738 'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5739 'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5742 'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5743 'channel_url': 'https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA',
5744 'channel': 'Computerphile',
5745 'availability': 'public',
5746 'modified_date': '20190712',
5747 'uploader_id': '@Computerphile',
5748 'uploader': 'Computerphile',
5749 'uploader_url': 'https://www.youtube.com/@Computerphile',
5751 'playlist_mincount': 11,
5753 'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5754 'only_matching': True,
5756 'note': 'Playlist URL that does not actually serve a playlist',
5757 'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5759 'id': 'FqZTN594JQw',
5761 'title': "Smiley's People 01 detective, Adventure Series, Action",
5762 'upload_date': '20150526',
5763 'license': 'Standard YouTube License',
5764 'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5765 'categories': ['People & Blogs'],
5771 'skip_download': True,
5773 'skip': 'This video is not available.',
5774 'add_ie': [YoutubeIE
.ie_key()],
5776 'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5777 'only_matching': True,
5779 'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5780 'only_matching': True,
5782 'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5784 'id': 'hGkQjiJLjWQ', # This will keep changing
5787 'upload_date': r
're:\d{8}',
5789 'categories': ['News & Politics'],
5792 'release_timestamp': int,
5793 'channel': 'Sky News',
5794 'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5797 'thumbnail': r
're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5798 'playable_in_embed': True,
5799 'release_date': r
're:\d+',
5800 'availability': 'public',
5801 'live_status': 'is_live',
5802 'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5803 'channel_follower_count': int,
5804 'concurrent_view_count': int,
5805 'uploader_url': 'https://www.youtube.com/@SkyNews',
5806 'uploader_id': '@SkyNews',
5807 'uploader': 'Sky News',
5808 'channel_is_verified': True,
5811 'skip_download': True,
5813 'expected_warnings': ['Ignoring subtitle tracks found in '],
5815 'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5817 'id': 'a48o2S1cPoo',
5819 'title': 'The Young Turks - Live Main Show',
5820 'upload_date': '20150715',
5821 'license': 'Standard YouTube License',
5822 'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5823 'categories': ['News & Politics'],
5824 'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5828 'skip_download': True,
5830 'only_matching': True,
5832 'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5833 'only_matching': True,
5835 'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5836 'only_matching': True,
5838 'note': 'A channel that is not live. Should raise error',
5839 'url': 'https://www.youtube.com/user/numberphile/live',
5840 'only_matching': True,
5842 'url': 'https://www.youtube.com/feed/trending',
5843 'only_matching': True,
5845 'url': 'https://www.youtube.com/feed/library',
5846 'only_matching': True,
5848 'url': 'https://www.youtube.com/feed/history',
5849 'only_matching': True,
5851 'url': 'https://www.youtube.com/feed/subscriptions',
5852 'only_matching': True,
5854 'url': 'https://www.youtube.com/feed/watch_later',
5855 'only_matching': True,
5857 'note': 'Recommended - redirects to home page.',
5858 'url': 'https://www.youtube.com/feed/recommended',
5859 'only_matching': True,
5861 'note': 'inline playlist with not always working continuations',
5862 'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5863 'only_matching': True,
5865 'url': 'https://www.youtube.com/course',
5866 'only_matching': True,
5868 'url': 'https://www.youtube.com/zsecurity',
5869 'only_matching': True,
5871 'url': 'http://www.youtube.com/NASAgovVideo/videos',
5872 'only_matching': True,
5874 'url': 'https://www.youtube.com/TheYoungTurks/live',
5875 'only_matching': True,
5877 'url': 'https://www.youtube.com/hashtag/cctv9',
5883 'playlist_mincount': 300, # not consistent but should be over 300
5885 'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
5886 'only_matching': True,
5888 'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
5889 'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5890 'only_matching': True
5892 'note': '/browse/ should redirect to /channel/',
5893 'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
5894 'only_matching': True
5896 'note': 'VLPL, should redirect to playlist?list=PL...',
5897 'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5899 'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5900 'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
5901 'title': 'NCS : All Releases 💿',
5902 'channel_url': 'https://www.youtube.com/channel/UC_aEa8K-EOJ3D6gOs7HcyNg',
5903 'modified_date': r
're:\d{8}',
5905 'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
5907 'channel': 'NoCopyrightSounds',
5908 'availability': 'public',
5909 'uploader_url': 'https://www.youtube.com/@NoCopyrightSounds',
5910 'uploader': 'NoCopyrightSounds',
5911 'uploader_id': '@NoCopyrightSounds',
5913 'playlist_mincount': 166,
5914 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden', 'YouTube Music is not directly supported'],
5916 # TODO: fix 'unviewable' issue with this playlist when reloading with unavailable videos
5917 'note': 'Topic, should redirect to playlist?list=UU...',
5918 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5920 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5921 'title': 'Uploads from Royalty Free Music - Topic',
5923 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5924 'channel': 'Royalty Free Music - Topic',
5926 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5927 'modified_date': r
're:\d{8}',
5929 'availability': 'public',
5930 'uploader': 'Royalty Free Music - Topic',
5932 'playlist_mincount': 101,
5933 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5935 # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
5936 # Treat as a general feed
5937 'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
5939 'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
5940 'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
5943 'playlist_mincount': 9,
5945 'note': 'Youtube music Album',
5946 'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
5948 'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
5949 'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
5953 'availability': 'unlisted',
5954 'modified_date': r
're:\d{8}',
5956 'playlist_count': 50,
5957 'expected_warnings': ['YouTube Music is not directly supported'],
5959 'note': 'unlisted single video playlist',
5960 'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5962 'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5963 'title': 'yt-dlp unlisted playlist test',
5964 'availability': 'unlisted',
5966 'modified_date': '20220418',
5967 'channel': 'colethedj',
5970 'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5971 'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5972 'uploader_url': 'https://www.youtube.com/@colethedj1894',
5973 'uploader_id': '@colethedj1894',
5974 'uploader': 'colethedj',
5978 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
5979 'id': 'BaW_jenozKc',
5981 'ie_key': 'Youtube',
5983 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
5984 'channel_url': 'https://www.youtube.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
5986 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc',
5987 'channel': 'Philipp Hagemeister',
5988 'uploader_id': '@PhilippHagemeister',
5989 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
5990 'uploader': 'Philipp Hagemeister',
5993 'playlist_count': 1,
5994 'params': {'extract_flat': True}
,
5996 'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
5997 'url': 'https://www.youtube.com/feed/recommended',
5999 'id': 'recommended',
6000 'title': 'recommended',
6003 'playlist_mincount': 50,
6005 'skip_download': True,
6006 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6009 'note': 'API Fallback: /videos tab, sorted by oldest first',
6010 'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
6012 'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6013 'title': 'Cody\'sLab - Videos',
6014 'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
6015 'channel': 'Cody\'sLab',
6016 'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6018 'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
6019 'channel_follower_count': int
6021 'playlist_mincount': 650,
6023 'skip_download': True,
6024 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6026 'skip': 'Query for sorting no longer works',
6028 'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
6029 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
6031 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
6032 'title': 'Uploads from Royalty Free Music - Topic',
6033 'modified_date': r
're:\d{8}',
6034 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
6036 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
6038 'channel': 'Royalty Free Music - Topic',
6040 'availability': 'public',
6041 'uploader': 'Royalty Free Music - Topic',
6043 'playlist_mincount': 101,
6045 'skip_download': True,
6046 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6048 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
6050 'note': 'non-standard redirect to regional channel',
6051 'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
6052 'only_matching': True
6054 'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
6055 'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6057 'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6058 'modified_date': '20220407',
6059 'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
6061 'availability': 'unlisted',
6062 'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
6063 'channel': 'pukkandan',
6064 'description': 'Test for collaborative playlist',
6065 'title': 'yt-dlp test - collaborative playlist',
6067 'uploader_url': 'https://www.youtube.com/@pukkandan',
6068 'uploader_id': '@pukkandan',
6069 'uploader': 'pukkandan',
6071 'playlist_mincount': 2
6073 'note': 'translated tab name',
6074 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
6076 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6078 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6079 'description': 'test description',
6080 'title': 'cole-dlp-test-acc - 再生リスト',
6081 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6082 'channel': 'cole-dlp-test-acc',
6083 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6084 'uploader_id': '@coletdjnz',
6085 'uploader': 'cole-dlp-test-acc',
6087 'playlist_mincount': 1,
6088 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6089 'expected_warnings': ['Preferring "ja"'],
6091 # XXX: this should really check flat playlist entries, but the test suite doesn't support that
6092 'note': 'preferred lang set with playlist with translated video titles',
6093 'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6095 'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6098 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6099 'channel': 'cole-dlp-test-acc',
6100 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6101 'description': 'test',
6102 'title': 'dlp test playlist',
6103 'availability': 'public',
6104 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6105 'uploader_id': '@coletdjnz',
6106 'uploader': 'cole-dlp-test-acc',
6108 'playlist_mincount': 1,
6109 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6110 'expected_warnings': ['Preferring "ja"'],
6112 # shorts audio pivot for 2GtVksBMYFM.
6113 'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
6115 'id': 'sfv_audio_pivot',
6116 'title': 'sfv_audio_pivot',
6119 'playlist_mincount': 50,
6122 # Channel with a real live tab (not to be mistaken with streams tab)
6123 # Do not treat like it should redirect to live stream
6124 'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
6126 'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
6127 'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
6130 'playlist_mincount': 20,
6132 # Tab name is not the same as tab id
6133 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
6135 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6136 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
6139 'playlist_mincount': 8,
6141 # Home tab id is literally home. Not to get mistaken with featured
6142 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
6144 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6145 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
6148 'playlist_mincount': 8,
6150 # Should get three playlists for videos, shorts and streams tabs
6151 'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6153 'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6154 'title': 'Polka Ch. 尾丸ポルカ',
6155 'channel_follower_count': int,
6156 'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6157 'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6158 'description': 'md5:e56b74b5bb7e9c701522162e9abfb822',
6159 'channel': 'Polka Ch. 尾丸ポルカ',
6161 'uploader_url': 'https://www.youtube.com/@OmaruPolka',
6162 'uploader': 'Polka Ch. 尾丸ポルカ',
6163 'uploader_id': '@OmaruPolka',
6165 'playlist_count': 3,
6167 # Shorts tab with channel with handle
6168 # TODO: fix channel description
6169 'url': 'https://www.youtube.com/@NotJustBikes/shorts',
6171 'id': 'UC0intLFzLaudFG-xAvUEO-A',
6172 'title': 'Not Just Bikes - Shorts',
6174 'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
6175 'description': 'md5:26bc55af26855a608a5cf89dfa595c8d',
6176 'channel_follower_count': int,
6177 'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
6178 'channel': 'Not Just Bikes',
6179 'uploader_url': 'https://www.youtube.com/@NotJustBikes',
6180 'uploader': 'Not Just Bikes',
6181 'uploader_id': '@NotJustBikes',
6183 'playlist_mincount': 10,
6186 'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
6188 'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6189 'title': '中村悠一 - Live',
6191 'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6192 'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
6194 'channel_follower_count': int,
6195 'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
6196 'uploader_url': 'https://www.youtube.com/@Yuichi-Nakamura',
6197 'uploader_id': '@Yuichi-Nakamura',
6200 'playlist_mincount': 60,
6202 # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
6203 # See test_youtube_lists
6204 'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
6205 'only_matching': True,
6207 # No uploads and no UCID given. Should fail with no uploads error
6208 # See test_youtube_lists
6209 'url': 'https://www.youtube.com/news',
6210 'only_matching': True
6212 # No videos tab but has a shorts tab
6213 'url': 'https://www.youtube.com/c/TKFShorts',
6215 'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6216 'title': 'Shorts Break - Shorts',
6218 'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6219 'channel': 'Shorts Break',
6220 'description': 'md5:6de33c5e7ba686e5f3efd4e19c7ef499',
6221 'channel_follower_count': int,
6222 'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
6223 'uploader_url': 'https://www.youtube.com/@ShortsBreak_Official',
6224 'uploader': 'Shorts Break',
6225 'uploader_id': '@ShortsBreak_Official',
6227 'playlist_mincount': 30,
6229 # Trending Now Tab. tab id is empty
6230 'url': 'https://www.youtube.com/feed/trending',
6233 'title': 'trending - Now',
6236 'playlist_mincount': 30,
6238 # Trending Gaming Tab. tab id is empty
6239 'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
6242 'title': 'trending - Gaming',
6245 'playlist_mincount': 30,
6247 # Shorts url result in shorts tab
6248 # TODO: Fix channel id extraction
6249 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
6251 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6252 'title': 'cole-dlp-test-acc - Shorts',
6253 'channel': 'cole-dlp-test-acc',
6254 'description': 'test description',
6255 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6256 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6258 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6259 'uploader_id': '@coletdjnz',
6260 'uploader': 'cole-dlp-test-acc',
6264 # Channel data is not currently available for short renderers (as of 2023-03-01)
6266 'ie_key': 'Youtube',
6267 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
6268 'id': 'sSM9J5YH_60',
6269 'title': 'SHORT short',
6274 'params': {'extract_flat': True}
,
6276 # Live video status should be extracted
6277 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
6279 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6280 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live', # TODO, should be Minecraft - Live or Minecraft - Topic - Live
6286 'ie_key': 'Youtube',
6287 'url': 'startswith:https://www.youtube.com/watch?v=',
6290 'live_status': 'is_live',
6293 'concurrent_view_count': int,
6296 'uploader_url': str,
6298 'channel_is_verified': bool, # this will keep changing
6301 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6302 'playlist_mincount': 1
6304 # Channel renderer metadata. Contains number of videos on the channel
6305 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/channels',
6307 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6308 'title': 'cole-dlp-test-acc - Channels',
6309 'channel': 'cole-dlp-test-acc',
6310 'description': 'test description',
6311 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6312 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6314 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6315 'uploader_id': '@coletdjnz',
6316 'uploader': 'cole-dlp-test-acc',
6321 'ie_key': 'YoutubeTab',
6322 'url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6323 'id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6324 'channel_id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6325 'title': 'PewDiePie',
6326 'channel': 'PewDiePie',
6327 'channel_url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6329 'channel_follower_count': int,
6330 'playlist_count': int,
6331 'uploader': 'PewDiePie',
6332 'uploader_url': 'https://www.youtube.com/@PewDiePie',
6333 'uploader_id': '@PewDiePie',
6334 'channel_is_verified': True,
6337 'params': {'extract_flat': True}
,
6339 'url': 'https://www.youtube.com/@3blue1brown/about',
6341 'id': 'UCYO_jab_esuFRV4b17AJtAw',
6342 'tags': ['Mathematics'],
6343 'title': '3Blue1Brown - About',
6344 'channel_follower_count': int,
6345 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
6346 'channel': '3Blue1Brown',
6348 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
6349 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
6350 'uploader_url': 'https://www.youtube.com/@3blue1brown',
6351 'uploader_id': '@3blue1brown',
6352 'uploader': '3Blue1Brown',
6353 'channel_is_verified': True,
6355 'playlist_count': 0,
6357 # Podcasts tab, with rich entry playlistRenderers
6358 'url': 'https://www.youtube.com/@99percentinvisiblepodcast/podcasts',
6360 'id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6361 'channel_id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6362 'uploader_url': 'https://www.youtube.com/@99percentinvisiblepodcast',
6363 'description': 'md5:3a0ed38f1ad42a68ef0428c04a15695c',
6364 'title': '99 Percent Invisible - Podcasts',
6365 'uploader': '99 Percent Invisible',
6366 'channel_follower_count': int,
6367 'channel_url': 'https://www.youtube.com/channel/UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6369 'channel': '99 Percent Invisible',
6370 'uploader_id': '@99percentinvisiblepodcast',
6372 'playlist_count': 1,
6374 # Releases tab, with rich entry playlistRenderers (same as Podcasts tab)
6375 'url': 'https://www.youtube.com/@AHimitsu/releases',
6377 'id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6378 'channel': 'A Himitsu',
6379 'uploader_url': 'https://www.youtube.com/@AHimitsu',
6380 'title': 'A Himitsu - Releases',
6381 'uploader_id': '@AHimitsu',
6382 'uploader': 'A Himitsu',
6383 'channel_id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6385 'description': 'I make music',
6386 'channel_url': 'https://www.youtube.com/channel/UCgFwu-j5-xNJml2FtTrrB3A',
6387 'channel_follower_count': int,
6388 'channel_is_verified': True,
6390 'playlist_mincount': 10,
6392 # Playlist with only shorts, shown as reel renderers
6393 # FIXME: future: YouTube currently doesn't give continuation for this,
6395 'url': 'https://www.youtube.com/playlist?list=UUxqPAgubo4coVn9Lx1FuKcg',
6397 'id': 'UUxqPAgubo4coVn9Lx1FuKcg',
6398 'channel_url': 'https://www.youtube.com/channel/UCxqPAgubo4coVn9Lx1FuKcg',
6400 'uploader_id': '@BangyShorts',
6402 'uploader_url': 'https://www.youtube.com/@BangyShorts',
6403 'channel_id': 'UCxqPAgubo4coVn9Lx1FuKcg',
6404 'channel': 'Bangy Shorts',
6405 'uploader': 'Bangy Shorts',
6407 'availability': 'public',
6408 'modified_date': '20230626',
6409 'title': 'Uploads from Bangy Shorts',
6411 'playlist_mincount': 100,
6412 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6416 def suitable(cls
, url
):
6417 return False if YoutubeIE
.suitable(url
) else super().suitable(url
)
6419 _URL_RE
= re
.compile(rf
'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
6421 def _get_url_mobj(self
, url
):
6422 mobj
= self
._URL
_RE
.match(url
).groupdict()
6423 mobj
.update((k
, '') for k
, v
in mobj
.items() if v
is None)
6426 def _extract_tab_id_and_name(self
, tab
, base_url
='https://www.youtube.com'):
6427 tab_name
= (tab
.get('title') or '').lower()
6428 tab_url
= urljoin(base_url
, traverse_obj(
6429 tab
, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
6431 tab_id
= (tab_url
and self
._get
_url
_mobj
(tab_url
)['tab'][1:]
6432 or traverse_obj(tab
, 'tabIdentifier', expected_type
=str))
6435 'TAB_ID_SPONSORSHIPS': 'membership',
6436 }.get(tab_id
, tab_id
), tab_name
6438 # Fallback to tab name if we cannot get the tab id.
6439 # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6440 # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6442 self
.write_debug(f
'Falling back to selected tab name: {tab_name}')
6446 }.get(tab_name
, tab_name
), tab_name
6448 def _has_tab(self
, tabs
, tab_id
):
6449 return any(self
._extract
_tab
_id
_and
_name
(tab
)[0] == tab_id
for tab
in tabs
)
6451 @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6452 def _real_extract(self
, url
, smuggled_data
):
6453 item_id
= self
._match
_id
(url
)
6454 url
= urllib
.parse
.urlunparse(
6455 urllib
.parse
.urlparse(url
)._replace
(netloc
='www.youtube.com'))
6456 compat_opts
= self
.get_param('compat_opts', [])
6458 mobj
= self
._get
_url
_mobj
(url
)
6459 pre
, tab
, post
, is_channel
= mobj
['pre'], mobj
['tab'], mobj
['post'], not mobj
['not_channel']
6460 if is_channel
and smuggled_data
.get('is_music_url'):
6461 if item_id
[:2] == 'VL': # Youtube music VL channels have an equivalent playlist
6462 return self
.url_result(
6463 f
'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE
, item_id
[2:])
6464 elif item_id
[:2] == 'MP': # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6465 mdata
= self
._extract
_tab
_endpoint
(
6466 f
'https://music.youtube.com/channel/{item_id}', item_id
, default_client
='web_music')
6467 murl
= traverse_obj(mdata
, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6468 get_all
=False, expected_type
=str)
6470 raise ExtractorError('Failed to resolve album to playlist')
6471 return self
.url_result(murl
, YoutubeTabIE
)
6472 elif mobj
['channel_type'] == 'browse': # Youtube music /browse/ should be changed to /channel/
6473 return self
.url_result(
6474 f
'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE
, item_id
)
6476 original_tab_id
, display_id
= tab
[1:], f
'{item_id}{tab}'
6477 if is_channel
and not tab
and 'no-youtube-channel-redirect' not in compat_opts
:
6478 url
= f
'{pre}/videos{post}'
6479 if smuggled_data
.get('is_music_url'):
6480 self
.report_warning(f
'YouTube Music is not directly supported. Redirecting to {url}')
6482 # Handle both video/playlist URLs
6484 video_id
, playlist_id
= [traverse_obj(qs
, (key
, 0)) for key
in ('v', 'list')]
6485 if not video_id
and mobj
['not_channel'].startswith('watch'):
6487 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6488 raise ExtractorError('A video URL was given without video ID', expected
=True)
6489 # Common mistake: https://www.youtube.com/watch?list=playlist_id
6490 self
.report_warning(f
'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6491 return self
.url_result(
6492 f
'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE
, playlist_id
)
6494 if not self
._yes
_playlist
(playlist_id
, video_id
):
6495 return self
.url_result(
6496 f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6498 data
, ytcfg
= self
._extract
_data
(url
, display_id
)
6500 # YouTube may provide a non-standard redirect to the regional channel
6501 # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6502 # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6503 redirect_url
= traverse_obj(
6504 data
, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all
=False)
6505 if redirect_url
and 'no-youtube-channel-redirect' not in compat_opts
:
6506 redirect_url
= ''.join((urljoin('https://www.youtube.com', redirect_url
), tab
, post
))
6507 self
.to_screen(f
'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6508 return self
.url_result(redirect_url
, YoutubeTabIE
)
6510 tabs
, extra_tabs
= self
._extract
_tab
_renderers
(data
), []
6511 if is_channel
and tabs
and 'no-youtube-channel-redirect' not in compat_opts
:
6512 selected_tab
= self
._extract
_selected
_tab
(tabs
)
6513 selected_tab_id
, selected_tab_name
= self
._extract
_tab
_id
_and
_name
(selected_tab
, url
) # NB: Name may be translated
6514 self
.write_debug(f
'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6516 if not original_tab_id
and selected_tab_name
:
6517 self
.to_screen('Downloading all uploads of the channel. '
6518 'To download only the videos in a specific tab, pass the tab\'s URL')
6519 if self
._has
_tab
(tabs
, 'streams'):
6520 extra_tabs
.append(''.join((pre
, '/streams', post
)))
6521 if self
._has
_tab
(tabs
, 'shorts'):
6522 extra_tabs
.append(''.join((pre
, '/shorts', post
)))
6523 # XXX: Members-only tab should also be extracted
6525 if not extra_tabs
and selected_tab_id
!= 'videos':
6526 # Channel does not have streams, shorts or videos tabs
6527 if item_id
[:2] != 'UC':
6528 raise ExtractorError('This channel has no uploads', expected
=True)
6530 # Topic channels don't have /videos. Use the equivalent playlist instead
6531 pl_id
= f
'UU{item_id[2:]}'
6532 pl_url
= f
'https://www.youtube.com/playlist?list={pl_id}'
6534 data
, ytcfg
= self
._extract
_data
(pl_url
, pl_id
, ytcfg
=ytcfg
, fatal
=True, webpage_fatal
=True)
6535 except ExtractorError
:
6536 raise ExtractorError('This channel has no uploads', expected
=True)
6538 item_id
, url
= pl_id
, pl_url
6540 f
'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6542 elif extra_tabs
and selected_tab_id
!= 'videos':
6543 # When there are shorts/live tabs but not videos tab
6544 url
, data
= f
'{pre}{post}', None
6546 elif (original_tab_id
or 'videos') != selected_tab_id
:
6547 if original_tab_id
== 'live':
6548 # Live tab should have redirected to the video
6549 # Except in the case the channel has an actual live tab
6550 # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6551 raise UserNotLive(video_id
=item_id
)
6552 elif selected_tab_name
:
6553 raise ExtractorError(f
'This channel does not have a {original_tab_id} tab', expected
=True)
6555 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6556 url
= f
'{pre}{post}'
6558 # YouTube sometimes provides a button to reload playlist with unavailable videos.
6559 if 'no-youtube-unavailable-videos' not in compat_opts
:
6560 data
= self
._reload
_with
_unavailable
_videos
(display_id
, data
, ytcfg
) or data
6561 self
._extract
_and
_report
_alerts
(data
, only_once
=True)
6563 tabs
, entries
= self
._extract
_tab
_renderers
(data
), []
6565 entries
= [self
._extract
_from
_tabs
(item_id
, ytcfg
, data
, tabs
)]
6567 'extractor_key': YoutubeTabIE
.ie_key(),
6568 'extractor': YoutubeTabIE
.IE_NAME
,
6571 if self
.get_param('playlist_items') == '0':
6572 entries
.extend(self
.url_result(u
, YoutubeTabIE
) for u
in extra_tabs
)
6573 else: # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6574 entries
.extend(map(self
._real
_extract
, extra_tabs
))
6576 if len(entries
) == 1:
6579 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
6580 uploads_url
= 'the Uploads (UU) playlist URL'
6581 if try_get(metadata
, lambda x
: x
['channel_id'].startswith('UC')):
6582 uploads_url
= f
'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6584 'Downloading as multiple playlists, separated by tabs. '
6585 f
'To download as a single playlist instead, pass {uploads_url}')
6586 return self
.playlist_result(entries
, item_id
, **metadata
)
6589 playlist
= traverse_obj(
6590 data
, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type
=dict)
6592 return self
._extract
_from
_playlist
(item_id
, url
, data
, playlist
, ytcfg
)
6594 video_id
= traverse_obj(
6595 data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str) or video_id
6597 if tab
!= '/live': # live tab is expected to redirect to video
6598 self
.report_warning(f
'Unable to recognize playlist. Downloading just video {video_id}')
6599 return self
.url_result(f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6601 raise ExtractorError('Unable to recognize tab page')
6604 class YoutubePlaylistIE(InfoExtractor
):
6605 IE_DESC
= 'YouTube playlists'
6606 _VALID_URL
= r
'''(?x)(?:
6611 youtube(?:kids)?\.com|
6616 (?P<id>%(playlist_id)s)
6618 'playlist_id': YoutubeBaseInfoExtractor
._PLAYLIST
_ID
_RE
,
6619 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
6621 IE_NAME
= 'youtube:playlist'
6623 'note': 'issue #673',
6624 'url': 'PLBB231211A4F62143',
6626 'title': '[OLD]Team Fortress 2 (Class-based LP)',
6627 'id': 'PLBB231211A4F62143',
6628 'uploader': 'Wickman',
6629 'uploader_id': '@WickmanVT',
6630 'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6632 'uploader_url': 'https://www.youtube.com/@WickmanVT',
6633 'modified_date': r
're:\d{8}',
6634 'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6635 'channel': 'Wickman',
6637 'channel_url': 'https://www.youtube.com/channel/UCKSpbfbl5kRQpTdL7kMc-1Q',
6638 'availability': 'public',
6640 'playlist_mincount': 29,
6642 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6644 'title': 'YDL_safe_search',
6645 'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6647 'playlist_count': 2,
6648 'skip': 'This playlist is private',
6651 'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6652 'playlist_count': 4,
6655 'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6656 'uploader': 'milan',
6657 'uploader_id': '@milan5503',
6659 'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6661 'modified_date': '20140919',
6664 'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6665 'uploader_url': 'https://www.youtube.com/@milan5503',
6666 'availability': 'public',
6668 'expected_warnings': [r
'[Uu]navailable videos? (is|are|will be) hidden'],
6670 'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6671 'playlist_mincount': 455,
6673 'title': '2018 Chinese New Singles (11/6 updated)',
6674 'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6676 'uploader_id': '@music_king',
6677 'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6680 'channel_url': 'https://www.youtube.com/channel/UC21nz3_MesPLqtDqwdvnoxA',
6682 'uploader_url': 'https://www.youtube.com/@music_king',
6683 'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6684 'modified_date': r
're:\d{8}',
6685 'availability': 'public',
6687 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6689 'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6690 'only_matching': True,
6692 # music album playlist
6693 'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6694 'only_matching': True,
6698 def suitable(cls
, url
):
6699 if YoutubeTabIE
.suitable(url
):
6701 from ..utils
import parse_qs
6703 if qs
.get('v', [None])[0]:
6705 return super().suitable(url
)
6707 def _real_extract(self
, url
):
6708 playlist_id
= self
._match
_id
(url
)
6709 is_music_url
= YoutubeBaseInfoExtractor
.is_music_url(url
)
6710 url
= update_url_query(
6711 'https://www.youtube.com/playlist',
6712 parse_qs(url
) or {'list': playlist_id}
)
6714 url
= smuggle_url(url
, {'is_music_url': True}
)
6715 return self
.url_result(url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6718 class YoutubeYtBeIE(InfoExtractor
):
6719 IE_DESC
= 'youtu.be'
6720 _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}
6722 'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6724 'id': 'yeWKywCrFtk',
6726 'title': 'Small Scale Baler and Braiding Rugs',
6727 'uploader': 'Backus-Page House Museum',
6728 'uploader_id': '@backuspagemuseum',
6729 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/@backuspagemuseum',
6730 'upload_date': '20161008',
6731 'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6732 'categories': ['Nonprofits & Activism'],
6736 'playable_in_embed': True,
6737 'thumbnail': r
're:^https?://.*\.webp',
6738 'channel': 'Backus-Page House Museum',
6739 'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6740 'live_status': 'not_live',
6742 'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6743 'availability': 'public',
6745 'comment_count': int,
6746 'channel_follower_count': int
6750 'skip_download': True,
6753 'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6754 'only_matching': True,
6757 def _real_extract(self
, url
):
6758 mobj
= self
._match
_valid
_url
(url
)
6759 video_id
= mobj
.group('id')
6760 playlist_id
= mobj
.group('playlist_id')
6761 return self
.url_result(
6762 update_url_query('https://www.youtube.com/watch', {
6764 'list': playlist_id
,
6765 'feature': 'youtu.be',
6766 }), ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6769 class YoutubeLivestreamEmbedIE(InfoExtractor
):
6770 IE_DESC
= 'YouTube livestream embeds'
6771 _VALID_URL
= r
'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6773 'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6774 'only_matching': True,
6777 def _real_extract(self
, url
):
6778 channel_id
= self
._match
_id
(url
)
6779 return self
.url_result(
6780 f
'https://www.youtube.com/channel/{channel_id}/live',
6781 ie
=YoutubeTabIE
.ie_key(), video_id
=channel_id
)
6784 class YoutubeYtUserIE(InfoExtractor
):
6785 IE_DESC
= 'YouTube user videos; "ytuser:" prefix'
6786 IE_NAME
= 'youtube:user'
6787 _VALID_URL
= r
'ytuser:(?P<id>.+)'
6789 'url': 'ytuser:phihag',
6790 'only_matching': True,
6793 def _real_extract(self
, url
):
6794 user_id
= self
._match
_id
(url
)
6795 return self
.url_result(f
'https://www.youtube.com/user/{user_id}', YoutubeTabIE
, user_id
)
6798 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor
):
6799 IE_NAME
= 'youtube:favorites'
6800 IE_DESC
= 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6801 _VALID_URL
= r
':ytfav(?:ou?rite)?s?'
6802 _LOGIN_REQUIRED
= True
6805 'only_matching': True,
6807 'url': ':ytfavorites',
6808 'only_matching': True,
6811 def _real_extract(self
, url
):
6812 return self
.url_result(
6813 'https://www.youtube.com/playlist?list=LL',
6814 ie
=YoutubeTabIE
.ie_key())
6817 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor
):
6818 IE_NAME
= 'youtube:notif'
6819 IE_DESC
= 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6820 _VALID_URL
= r
':ytnotif(?:ication)?s?'
6821 _LOGIN_REQUIRED
= True
6824 'only_matching': True,
6826 'url': ':ytnotifications',
6827 'only_matching': True,
6830 def _extract_notification_menu(self
, response
, continuation_list
):
6831 notification_list
= traverse_obj(
6833 ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6834 ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6835 expected_type
=list) or []
6836 continuation_list
[0] = None
6837 for item
in notification_list
:
6838 entry
= self
._extract
_notification
_renderer
(item
.get('notificationRenderer'))
6841 continuation
= item
.get('continuationItemRenderer')
6843 continuation_list
[0] = continuation
6845 def _extract_notification_renderer(self
, notification
):
6846 video_id
= traverse_obj(
6847 notification
, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str)
6848 url
= f
'https://www.youtube.com/watch?v={video_id}'
6851 browse_ep
= traverse_obj(
6852 notification
, ('navigationEndpoint', 'browseEndpoint'), expected_type
=dict)
6853 channel_id
= self
.ucid_or_none(traverse_obj(browse_ep
, 'browseId', expected_type
=str))
6854 post_id
= self
._search
_regex
(
6855 r
'/post/(.+)', traverse_obj(browse_ep
, 'canonicalBaseUrl', expected_type
=str),
6856 'post id', default
=None)
6857 if not channel_id
or not post_id
:
6859 # The direct /post url redirects to this in the browser
6860 url
= f
'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
6862 channel
= traverse_obj(
6863 notification
, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
6865 notification_title
= self
._get
_text
(notification
, 'shortMessage')
6866 if notification_title
:
6867 notification_title
= notification_title
.replace('\xad', '') # remove soft hyphens
6868 # TODO: handle recommended videos
6869 title
= self
._search
_regex
(
6870 rf
'{re.escape(channel or "")}[^:]+: (.+)', notification_title
,
6871 'video title', default
=None)
6872 timestamp
= (self
._parse
_time
_text
(self
._get
_text
(notification
, 'sentTimeText'))
6873 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
6878 'ie_key': (YoutubeIE
if video_id
else YoutubeTabIE
).ie_key(),
6879 'video_id': video_id
,
6881 'channel_id': channel_id
,
6883 'uploader': channel
,
6884 'thumbnails': self
._extract
_thumbnails
(notification
, 'videoThumbnail'),
6885 'timestamp': timestamp
,
6888 def _notification_menu_entries(self
, ytcfg
):
6889 continuation_list
= [None]
6891 for page
in itertools
.count(1):
6892 ctoken
= traverse_obj(
6893 continuation_list
, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type
=str)
6894 response
= self
._extract
_response
(
6895 item_id
=f
'page {page}', query
={'ctoken': ctoken}
if ctoken
else {}, ytcfg
=ytcfg
,
6896 ep
='notification/get_notification_menu', check_get_keys
='actions',
6897 headers
=self
.generate_api_headers(ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(response
)))
6898 yield from self
._extract
_notification
_menu
(response
, continuation_list
)
6899 if not continuation_list
[0]:
6902 def _real_extract(self
, url
):
6903 display_id
= 'notifications'
6904 ytcfg
= self
._download
_ytcfg
('web', display_id
) if not self
.skip_webpage
else {}
6905 self
._report
_playlist
_authcheck
(ytcfg
)
6906 return self
.playlist_result(self
._notification
_menu
_entries
(ytcfg
), display_id
, display_id
)
6909 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6910 IE_DESC
= 'YouTube search'
6911 IE_NAME
= 'youtube:search'
6912 _SEARCH_KEY
= 'ytsearch'
6913 _SEARCH_PARAMS
= 'EgIQAQ%3D%3D' # Videos only
6915 'url': 'ytsearch5:youtube-dl test video',
6916 'playlist_count': 5,
6918 'id': 'youtube-dl test video',
6919 'title': 'youtube-dl test video',
6924 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6925 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ ':date'
6926 _SEARCH_KEY
= 'ytsearchdate'
6927 IE_DESC
= 'YouTube search, newest videos first'
6928 _SEARCH_PARAMS
= 'CAISAhAB' # Videos only, sorted by date
6930 'url': 'ytsearchdate5:youtube-dl test video',
6931 'playlist_count': 5,
6933 'id': 'youtube-dl test video',
6934 'title': 'youtube-dl test video',
6939 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor
):
6940 IE_DESC
= 'YouTube search URLs with sorting and filter support'
6941 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ '_url'
6942 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6944 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
6945 'playlist_mincount': 5,
6947 'id': 'youtube-dl test video',
6948 'title': 'youtube-dl test video',
6951 'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
6952 'playlist_mincount': 5,
6958 'url': 'https://www.youtube.com/results?search_query=%23cats',
6959 'playlist_mincount': 1,
6963 # The test suite does not have support for nested playlists
6965 # 'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
6971 'url': 'https://www.youtube.com/results?search_query=kurzgesagt&sp=EgIQAg%253D%253D',
6974 'title': 'kurzgesagt',
6979 'id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6980 'url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6981 'ie_key': 'YoutubeTab',
6982 'channel': 'Kurzgesagt – In a Nutshell',
6983 'description': 'md5:4ae48dfa9505ffc307dad26342d06bfc',
6984 'title': 'Kurzgesagt – In a Nutshell',
6985 'channel_id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6986 # No longer available for search as it is set to the handle.
6987 # 'playlist_count': int,
6988 'channel_url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6990 'uploader_id': '@kurzgesagt',
6991 'uploader_url': 'https://www.youtube.com/@kurzgesagt',
6992 'uploader': 'Kurzgesagt – In a Nutshell',
6993 'channel_is_verified': True,
6994 'channel_follower_count': int,
6997 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6998 'playlist_mincount': 1,
7000 'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
7001 'only_matching': True,
7004 def _real_extract(self
, url
):
7006 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7007 return self
.playlist_result(self
._search
_results
(query
, qs
.get('sp', (None,))[0]), query
, query
)
7010 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor
):
7011 IE_DESC
= 'YouTube music search URLs with selectable sections, e.g. #songs'
7012 IE_NAME
= 'youtube:music:search_url'
7013 _VALID_URL
= r
'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
7015 'url': 'https://music.youtube.com/search?q=royalty+free+music',
7016 'playlist_count': 16,
7018 'id': 'royalty free music',
7019 'title': 'royalty free music',
7022 'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
7023 'playlist_mincount': 30,
7025 'id': 'royalty free music - songs',
7026 'title': 'royalty free music - songs',
7028 'params': {'extract_flat': 'in_playlist'}
7030 'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
7031 'playlist_mincount': 30,
7033 'id': 'royalty free music - community playlists',
7034 'title': 'royalty free music - community playlists',
7036 'params': {'extract_flat': 'in_playlist'}
7040 'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
7041 'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
7042 'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
7043 'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
7044 'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
7045 'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
7048 def _real_extract(self
, url
):
7050 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7051 params
= qs
.get('sp', (None,))[0]
7053 section
= next((k
for k
, v
in self
._SECTIONS
.items() if v
== params
), params
)
7055 section
= urllib
.parse
.unquote_plus((url
.split('#') + [''])[1]).lower()
7056 params
= self
._SECTIONS
.get(section
)
7059 title
= join_nonempty(query
, section
, delim
=' - ')
7060 return self
.playlist_result(self
._search
_results
(query
, params
, default_client
='web_music'), title
, title
)
7063 class YoutubeFeedsInfoExtractor(InfoExtractor
):
7065 Base class for feed extractors
7066 Subclasses must re-define the _FEED_NAME property.
7068 _LOGIN_REQUIRED
= True
7069 _FEED_NAME
= 'feeds'
7071 def _real_initialize(self
):
7072 YoutubeBaseInfoExtractor
._check
_login
_required
(self
)
7076 return f
'youtube:{self._FEED_NAME}'
7078 def _real_extract(self
, url
):
7079 return self
.url_result(
7080 f
'https://www.youtube.com/feed/{self._FEED_NAME}', ie
=YoutubeTabIE
.ie_key())
7083 class YoutubeWatchLaterIE(InfoExtractor
):
7084 IE_NAME
= 'youtube:watchlater'
7085 IE_DESC
= 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
7086 _VALID_URL
= r
':ytwatchlater'
7088 'url': ':ytwatchlater',
7089 'only_matching': True,
7092 def _real_extract(self
, url
):
7093 return self
.url_result(
7094 'https://www.youtube.com/playlist?list=WL', ie
=YoutubeTabIE
.ie_key())
7097 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor
):
7098 IE_DESC
= 'YouTube recommended videos; ":ytrec" keyword'
7099 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
7100 _FEED_NAME
= 'recommended'
7101 _LOGIN_REQUIRED
= False
7104 'only_matching': True,
7106 'url': ':ytrecommended',
7107 'only_matching': True,
7109 'url': 'https://youtube.com',
7110 'only_matching': True,
7114 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor
):
7115 IE_DESC
= 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
7116 _VALID_URL
= r
':ytsub(?:scription)?s?'
7117 _FEED_NAME
= 'subscriptions'
7120 'only_matching': True,
7122 'url': ':ytsubscriptions',
7123 'only_matching': True,
7127 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor
):
7128 IE_DESC
= 'Youtube watch history; ":ythis" keyword (requires cookies)'
7129 _VALID_URL
= r
':ythis(?:tory)?'
7130 _FEED_NAME
= 'history'
7132 'url': ':ythistory',
7133 'only_matching': True,
7137 class YoutubeShortsAudioPivotIE(InfoExtractor
):
7138 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
7139 IE_NAME
= 'youtube:shorts:pivot:audio'
7140 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
7142 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
7143 'only_matching': True,
7147 def _generate_audio_pivot_params(video_id
):
7149 Generates sfv_audio_pivot browse params for this video id
7151 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
7152 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
7154 def _real_extract(self
, url
):
7155 video_id
= self
._match
_id
(url
)
7156 return self
.url_result(
7157 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
7161 class YoutubeTruncatedURLIE(InfoExtractor
):
7162 IE_NAME
= 'youtube:truncated_url'
7163 IE_DESC
= False # Do not list
7164 _VALID_URL
= r
'''(?x)
7166 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
7169 annotation_id=annotation_[^&]+|
7175 attribution_link\?a=[^&]+
7181 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
7182 'only_matching': True,
7184 'url': 'https://www.youtube.com/watch?',
7185 'only_matching': True,
7187 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
7188 'only_matching': True,
7190 'url': 'https://www.youtube.com/watch?feature=foo',
7191 'only_matching': True,
7193 'url': 'https://www.youtube.com/watch?hl=en-GB',
7194 'only_matching': True,
7196 'url': 'https://www.youtube.com/watch?t=2372',
7197 'only_matching': True,
7200 def _real_extract(self
, url
):
7201 raise ExtractorError(
7202 'Did you forget to quote the URL? Remember that & is a meta '
7203 'character in most shells, so you want to put the URL in quotes, '
7205 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
7206 ' or simply youtube-dl BaW_jenozKc .',
7210 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
7211 IE_NAME
= 'youtube:clip'
7212 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7214 # FIXME: Other metadata should be extracted from the clip, not from the base video
7215 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7217 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7219 'section_start': 29.0,
7220 'section_end': 39.7,
7223 'availability': 'public',
7224 'categories': ['Gaming'],
7225 'channel': 'Scott The Woz',
7226 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7227 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7228 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7230 'playable_in_embed': True,
7232 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7233 'title': 'Mobile Games on Console - Scott The Woz',
7234 'upload_date': '20210920',
7235 'uploader': 'Scott The Woz',
7236 'uploader_id': '@ScottTheWoz',
7237 'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7239 'live_status': 'not_live',
7240 'channel_follower_count': int,
7241 'chapters': 'count:20',
7242 'comment_count': int,
7243 'heatmap': 'count:100',
7247 def _real_extract(self
, url
):
7248 clip_id
= self
._match
_id
(url
)
7249 _
, data
= self
._extract
_webpage
(url
, clip_id
)
7251 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7253 raise ExtractorError('Unable to find video ID')
7255 clip_data
= traverse_obj(data
, (
7256 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7257 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7258 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7259 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
7262 '_type': 'url_transparent',
7263 'url': f
'https://www.youtube.com/watch?v={video_id}',
7264 'ie_key': YoutubeIE
.ie_key(),
7266 'section_start': int(clip_data
['startTimeMs']) / 1000,
7267 'section_end': int(clip_data
['endTimeMs']) / 1000,
7271 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor
):
7272 IE_NAME
= 'youtube:consent'
7273 IE_DESC
= False # Do not list
7274 _VALID_URL
= r
'https?://consent\.youtube\.com/m\?'
7276 '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',
7278 'id': 'qVv6vCqciTM',
7281 'uploader_id': '@sana_natori',
7282 'comment_count': int,
7283 'chapters': 'count:13',
7284 'upload_date': '20221223',
7285 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7286 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7287 'uploader_url': 'https://www.youtube.com/@sana_natori',
7289 'release_date': '20221223',
7290 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7291 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7293 'playable_in_embed': True,
7295 'availability': 'public',
7296 'channel_follower_count': int,
7297 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7298 'categories': ['Entertainment'],
7299 'live_status': 'was_live',
7300 'release_timestamp': 1671793345,
7301 'channel': 'さなちゃんねる',
7302 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7303 'uploader': 'さなちゃんねる',
7304 'channel_is_verified': True,
7305 'heatmap': 'count:100',
7307 'add_ie': ['Youtube'],
7308 'params': {'skip_download': 'Youtube'}
,
7311 def _real_extract(self
, url
):
7312 redirect_url
= url_or_none(parse_qs(url
).get('continue', [None])[-1])
7313 if not redirect_url
:
7314 raise ExtractorError('Invalid cookie consent redirect URL', expected
=True)
7315 return self
.url_result(redirect_url
)
7318 class YoutubeTruncatedIDIE(InfoExtractor
):
7319 IE_NAME
= 'youtube:truncated_id'
7320 IE_DESC
= False # Do not list
7321 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7324 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7325 'only_matching': True,
7328 def _real_extract(self
, url
):
7329 video_id
= self
._match
_id
(url
)
7330 raise ExtractorError(
7331 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',