21 from .common
import InfoExtractor
, SearchInfoExtractor
22 from .openload
import PhantomJSwrapper
23 from ..compat
import functools
24 from ..jsinterp
import JSInterpreter
70 STREAMING_DATA_CLIENT_NAME
= '__yt_dlp_client'
71 # any clients starting with _ cannot be explicitly requested by the user
74 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
75 'INNERTUBE_CONTEXT': {
78 'clientVersion': '2.20220801.00.00',
81 'INNERTUBE_CONTEXT_CLIENT_NAME': 1
84 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
85 'INNERTUBE_CONTEXT': {
87 'clientName': 'WEB_EMBEDDED_PLAYER',
88 'clientVersion': '1.20220731.00.00',
91 'INNERTUBE_CONTEXT_CLIENT_NAME': 56
94 'INNERTUBE_API_KEY': 'AIzaSyC9XL3ZjWddXya6X74dJoCTL-WEYFDNX30',
95 'INNERTUBE_HOST': 'music.youtube.com',
96 'INNERTUBE_CONTEXT': {
98 'clientName': 'WEB_REMIX',
99 'clientVersion': '1.20220727.01.00',
102 'INNERTUBE_CONTEXT_CLIENT_NAME': 67,
105 'INNERTUBE_API_KEY': 'AIzaSyBUPetSUmoZL-OhlxA7wSac5XinrygCqMo',
106 'INNERTUBE_CONTEXT': {
108 'clientName': 'WEB_CREATOR',
109 'clientVersion': '1.20220726.00.00',
112 'INNERTUBE_CONTEXT_CLIENT_NAME': 62,
115 'INNERTUBE_API_KEY': 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w',
116 'INNERTUBE_CONTEXT': {
118 'clientName': 'ANDROID',
119 'clientVersion': '17.31.35',
120 'androidSdkVersion': 30,
121 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
124 'INNERTUBE_CONTEXT_CLIENT_NAME': 3,
125 'REQUIRE_JS_PLAYER': False
127 'android_embedded': {
128 'INNERTUBE_API_KEY': 'AIzaSyCjc_pVEDi4qsv5MtC2dMXzpIaDoRFLsxw',
129 'INNERTUBE_CONTEXT': {
131 'clientName': 'ANDROID_EMBEDDED_PLAYER',
132 'clientVersion': '17.31.35',
133 'androidSdkVersion': 30,
134 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
137 'INNERTUBE_CONTEXT_CLIENT_NAME': 55,
138 'REQUIRE_JS_PLAYER': False
141 'INNERTUBE_API_KEY': 'AIzaSyAOghZGza2MQSZkY_zfZ370N-PUdXEo8AI',
142 'INNERTUBE_CONTEXT': {
144 'clientName': 'ANDROID_MUSIC',
145 'clientVersion': '5.16.51',
146 'androidSdkVersion': 30,
147 'userAgent': 'com.google.android.apps.youtube.music/5.16.51 (Linux; U; Android 11) gzip'
150 'INNERTUBE_CONTEXT_CLIENT_NAME': 21,
151 'REQUIRE_JS_PLAYER': False
154 'INNERTUBE_API_KEY': 'AIzaSyD_qjV8zaaUMehtLkrKFgVeSX_Iqbtyws8',
155 'INNERTUBE_CONTEXT': {
157 'clientName': 'ANDROID_CREATOR',
158 'clientVersion': '22.30.100',
159 'androidSdkVersion': 30,
160 'userAgent': 'com.google.android.apps.youtube.creator/22.30.100 (Linux; U; Android 11) gzip'
163 'INNERTUBE_CONTEXT_CLIENT_NAME': 14,
164 'REQUIRE_JS_PLAYER': False
166 # iOS clients have HLS live streams. Setting device model to get 60fps formats.
167 # See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/680#issuecomment-1002724558
169 'INNERTUBE_API_KEY': 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc',
170 'INNERTUBE_CONTEXT': {
173 'clientVersion': '17.33.2',
174 'deviceModel': 'iPhone14,3',
175 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
178 'INNERTUBE_CONTEXT_CLIENT_NAME': 5,
179 'REQUIRE_JS_PLAYER': False
182 'INNERTUBE_CONTEXT': {
184 'clientName': 'IOS_MESSAGES_EXTENSION',
185 'clientVersion': '17.33.2',
186 'deviceModel': 'iPhone14,3',
187 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
190 'INNERTUBE_CONTEXT_CLIENT_NAME': 66,
191 'REQUIRE_JS_PLAYER': False
194 'INNERTUBE_API_KEY': 'AIzaSyBAETezhkwP0ZWA02RsqT1zu78Fpt0bC_s',
195 'INNERTUBE_CONTEXT': {
197 'clientName': 'IOS_MUSIC',
198 'clientVersion': '5.21',
199 'deviceModel': 'iPhone14,3',
200 'userAgent': 'com.google.ios.youtubemusic/5.21 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
203 'INNERTUBE_CONTEXT_CLIENT_NAME': 26,
204 'REQUIRE_JS_PLAYER': False
207 'INNERTUBE_CONTEXT': {
209 'clientName': 'IOS_CREATOR',
210 'clientVersion': '22.33.101',
211 'deviceModel': 'iPhone14,3',
212 'userAgent': 'com.google.ios.ytcreator/22.33.101 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
215 'INNERTUBE_CONTEXT_CLIENT_NAME': 15,
216 'REQUIRE_JS_PLAYER': False
218 # mweb has 'ultralow' formats
219 # See: https://github.com/yt-dlp/yt-dlp/pull/557
221 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
222 'INNERTUBE_CONTEXT': {
224 'clientName': 'MWEB',
225 'clientVersion': '2.20220801.00.00',
228 'INNERTUBE_CONTEXT_CLIENT_NAME': 2
230 # This client can access age restricted videos (unless the uploader has disabled the 'allow embedding' option)
231 # See: https://github.com/zerodytrash/YouTube-Internal-Clients
233 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
234 'INNERTUBE_CONTEXT': {
236 'clientName': 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
237 'clientVersion': '2.0',
240 'INNERTUBE_CONTEXT_CLIENT_NAME': 85
245 def _split_innertube_client(client_name
):
246 variant
, *base
= client_name
.rsplit('.', 1)
248 return variant
, base
[0], variant
249 base
, *variant
= client_name
.split('_', 1)
250 return client_name
, base
, variant
[0] if variant
else None
253 def short_client_name(client_name
):
254 main
, *parts
= _split_innertube_client(client_name
)[0].replace('embedscreen', 'e_s').split('_')
255 return join_nonempty(main
[:4], ''.join(x
[0] for x
in parts
)).upper()
258 def build_innertube_clients():
260 'embedUrl': 'https://www.youtube.com/', # Can be any valid URL
262 BASE_CLIENTS
= ('android', 'web', 'tv', 'ios', 'mweb')
263 priority
= qualities(BASE_CLIENTS
[::-1])
265 for client
, ytcfg
in tuple(INNERTUBE_CLIENTS
.items()):
266 ytcfg
.setdefault('INNERTUBE_API_KEY', 'AIzaSyDCU8hByM-4DrUqRUYnGn-3llEO78bcxq8')
267 ytcfg
.setdefault('INNERTUBE_HOST', 'www.youtube.com')
268 ytcfg
.setdefault('REQUIRE_JS_PLAYER', True)
269 ytcfg
['INNERTUBE_CONTEXT']['client'].setdefault('hl', 'en')
271 _
, base_client
, variant
= _split_innertube_client(client
)
272 ytcfg
['priority'] = 10 * priority(base_client
)
275 INNERTUBE_CLIENTS
[f
'{client}_embedscreen'] = embedscreen
= copy
.deepcopy(ytcfg
)
276 embedscreen
['INNERTUBE_CONTEXT']['client']['clientScreen'] = 'EMBED'
277 embedscreen
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
278 embedscreen
['priority'] -= 3
279 elif variant
== 'embedded':
280 ytcfg
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
281 ytcfg
['priority'] -= 2
283 ytcfg
['priority'] -= 3
286 build_innertube_clients()
289 class BadgeType(enum
.Enum
):
290 AVAILABILITY_UNLISTED
= enum
.auto()
291 AVAILABILITY_PRIVATE
= enum
.auto()
292 AVAILABILITY_PUBLIC
= enum
.auto()
293 AVAILABILITY_PREMIUM
= enum
.auto()
294 AVAILABILITY_SUBSCRIPTION
= enum
.auto()
295 LIVE_NOW
= enum
.auto()
298 class YoutubeBaseInfoExtractor(InfoExtractor
):
299 """Provide base functions for Youtube extractors"""
302 r
'channel|c|user|playlist|watch|w|v|embed|e|live|watch_popup|clip|'
303 r
'shorts|movies|results|search|shared|hashtag|trending|explore|feed|feeds|'
304 r
'browse|oembed|get_video_info|iframe_api|s/player|source|'
305 r
'storefront|oops|index|account|t/terms|about|upload|signin|logout')
307 _PLAYLIST_ID_RE
= r
'(?:(?:PL|LL|EC|UU|FL|RD|UL|TL|PU|OLAK5uy_)[0-9A-Za-z-_]{10,}|RDMM|WL|LL|LM)'
309 # _NETRC_MACHINE = 'youtube'
311 # If True it will raise an error if no login info is provided
312 _LOGIN_REQUIRED
= False
315 # invidious-redirect websites
316 r
'(?:www\.)?redirect\.invidious\.io',
317 r
'(?:(?:www|dev)\.)?invidio\.us',
318 # Invidious instances taken from https://github.com/iv-org/documentation/blob/master/docs/instances.md
319 r
'(?:www\.)?invidious\.pussthecat\.org',
320 r
'(?:www\.)?invidious\.zee\.li',
321 r
'(?:www\.)?invidious\.ethibox\.fr',
322 r
'(?:www\.)?iv\.ggtyler\.dev',
323 r
'(?:www\.)?inv\.vern\.i2p',
324 r
'(?:www\.)?am74vkcrjp2d5v36lcdqgsj2m6x36tbrkhsruoegwfcizzabnfgf5zyd\.onion',
325 r
'(?:www\.)?inv\.riverside\.rocks',
326 r
'(?:www\.)?invidious\.silur\.me',
327 r
'(?:www\.)?inv\.bp\.projectsegfau\.lt',
328 r
'(?:www\.)?invidious\.g4c3eya4clenolymqbpgwz3q3tawoxw56yhzk4vugqrl6dtu3ejvhjid\.onion',
329 r
'(?:www\.)?invidious\.slipfox\.xyz',
330 r
'(?:www\.)?invidious\.esmail5pdn24shtvieloeedh7ehz3nrwcdivnfhfcedl7gf4kwddhkqd\.onion',
331 r
'(?:www\.)?inv\.vernccvbvyi5qhfzyqengccj7lkove6bjot2xhh5kajhwvidqafczrad\.onion',
332 r
'(?:www\.)?invidious\.tiekoetter\.com',
333 r
'(?:www\.)?iv\.odysfvr23q5wgt7i456o5t3trw2cw5dgn56vbjfbq2m7xsc5vqbqpcyd\.onion',
334 r
'(?:www\.)?invidious\.nerdvpn\.de',
335 r
'(?:www\.)?invidious\.weblibre\.org',
336 r
'(?:www\.)?inv\.odyssey346\.dev',
337 r
'(?:www\.)?invidious\.dhusch\.de',
338 r
'(?:www\.)?iv\.melmac\.space',
339 r
'(?:www\.)?watch\.thekitty\.zone',
340 r
'(?:www\.)?invidious\.privacydev\.net',
341 r
'(?:www\.)?ng27owmagn5amdm7l5s3rsqxwscl5ynppnis5dqcasogkyxcfqn7psid\.onion',
342 r
'(?:www\.)?invidious\.drivet\.xyz',
343 r
'(?:www\.)?vid\.priv\.au',
344 r
'(?:www\.)?euxxcnhsynwmfidvhjf6uzptsmh4dipkmgdmcmxxuo7tunp3ad2jrwyd\.onion',
345 r
'(?:www\.)?inv\.vern\.cc',
346 r
'(?:www\.)?invidious\.esmailelbob\.xyz',
347 r
'(?:www\.)?invidious\.sethforprivacy\.com',
348 r
'(?:www\.)?yt\.oelrichsgarcia\.de',
349 r
'(?:www\.)?yt\.artemislena\.eu',
350 r
'(?:www\.)?invidious\.flokinet\.to',
351 r
'(?:www\.)?invidious\.baczek\.me',
352 r
'(?:www\.)?y\.com\.sb',
353 r
'(?:www\.)?invidious\.epicsite\.xyz',
354 r
'(?:www\.)?invidious\.lidarshield\.cloud',
355 r
'(?:www\.)?yt\.funami\.tech',
356 r
'(?:www\.)?invidious\.3o7z6yfxhbw7n3za4rss6l434kmv55cgw2vuziwuigpwegswvwzqipyd\.onion',
357 r
'(?:www\.)?osbivz6guyeahrwp2lnwyjk2xos342h4ocsxyqrlaopqjuhwn2djiiyd\.onion',
358 r
'(?:www\.)?u2cvlit75owumwpy4dj2hsmvkq7nvrclkpht7xgyye2pyoxhpmclkrad\.onion',
359 # youtube-dl invidious instances list
360 r
'(?:(?:www|no)\.)?invidiou\.sh',
361 r
'(?:(?:www|fi)\.)?invidious\.snopyta\.org',
362 r
'(?:www\.)?invidious\.kabi\.tk',
363 r
'(?:www\.)?invidious\.mastodon\.host',
364 r
'(?:www\.)?invidious\.zapashcanon\.fr',
365 r
'(?:www\.)?(?:invidious(?:-us)?|piped)\.kavin\.rocks',
366 r
'(?:www\.)?invidious\.tinfoil-hat\.net',
367 r
'(?:www\.)?invidious\.himiko\.cloud',
368 r
'(?:www\.)?invidious\.reallyancient\.tech',
369 r
'(?:www\.)?invidious\.tube',
370 r
'(?:www\.)?invidiou\.site',
371 r
'(?:www\.)?invidious\.site',
372 r
'(?:www\.)?invidious\.xyz',
373 r
'(?:www\.)?invidious\.nixnet\.xyz',
374 r
'(?:www\.)?invidious\.048596\.xyz',
375 r
'(?:www\.)?invidious\.drycat\.fr',
376 r
'(?:www\.)?inv\.skyn3t\.in',
377 r
'(?:www\.)?tube\.poal\.co',
378 r
'(?:www\.)?tube\.connect\.cafe',
379 r
'(?:www\.)?vid\.wxzm\.sx',
380 r
'(?:www\.)?vid\.mint\.lgbt',
381 r
'(?:www\.)?vid\.puffyan\.us',
382 r
'(?:www\.)?yewtu\.be',
383 r
'(?:www\.)?yt\.elukerio\.org',
384 r
'(?:www\.)?yt\.lelux\.fi',
385 r
'(?:www\.)?invidious\.ggc-project\.de',
386 r
'(?:www\.)?yt\.maisputain\.ovh',
387 r
'(?:www\.)?ytprivate\.com',
388 r
'(?:www\.)?invidious\.13ad\.de',
389 r
'(?:www\.)?invidious\.toot\.koeln',
390 r
'(?:www\.)?invidious\.fdn\.fr',
391 r
'(?:www\.)?watch\.nettohikari\.com',
392 r
'(?:www\.)?invidious\.namazso\.eu',
393 r
'(?:www\.)?invidious\.silkky\.cloud',
394 r
'(?:www\.)?invidious\.exonip\.de',
395 r
'(?:www\.)?invidious\.riverside\.rocks',
396 r
'(?:www\.)?invidious\.blamefran\.net',
397 r
'(?:www\.)?invidious\.moomoo\.de',
398 r
'(?:www\.)?ytb\.trom\.tf',
399 r
'(?:www\.)?yt\.cyberhost\.uk',
400 r
'(?:www\.)?kgg2m7yk5aybusll\.onion',
401 r
'(?:www\.)?qklhadlycap4cnod\.onion',
402 r
'(?:www\.)?axqzx4s6s54s32yentfqojs3x5i7faxza6xo3ehd4bzzsg2ii4fv2iid\.onion',
403 r
'(?:www\.)?c7hqkpkpemu6e7emz5b4vyz7idjgdvgaaa3dyimmeojqbgpea3xqjoid\.onion',
404 r
'(?:www\.)?fz253lmuao3strwbfbmx46yu7acac2jz27iwtorgmbqlkurlclmancad\.onion',
405 r
'(?:www\.)?invidious\.l4qlywnpwqsluw65ts7md3khrivpirse744un3x7mlskqauz5pyuzgqd\.onion',
406 r
'(?:www\.)?owxfohz4kjyv25fvlqilyxast7inivgiktls3th44jhk3ej3i7ya\.b32\.i2p',
407 r
'(?:www\.)?4l2dgddgsrkf2ous66i6seeyi6etzfgrue332grh2n7madpwopotugyd\.onion',
408 r
'(?:www\.)?w6ijuptxiku4xpnnaetxvnkc5vqcdu7mgns2u77qefoixi63vbvnpnqd\.onion',
409 r
'(?:www\.)?kbjggqkzv65ivcqj6bumvp337z6264huv5kpkwuv6gu5yjiskvan7fad\.onion',
410 r
'(?:www\.)?grwp24hodrefzvjjuccrkw3mjq4tzhaaq32amf33dzpmuxe7ilepcmad\.onion',
411 r
'(?:www\.)?hpniueoejy4opn7bc4ftgazyqjoeqwlvh2uiku2xqku6zpoa4bf5ruid\.onion',
412 # piped instances from https://github.com/TeamPiped/Piped/wiki/Instances
413 r
'(?:www\.)?piped\.kavin\.rocks',
414 r
'(?:www\.)?piped\.tokhmi\.xyz',
415 r
'(?:www\.)?piped\.syncpundit\.io',
416 r
'(?:www\.)?piped\.mha\.fi',
417 r
'(?:www\.)?watch\.whatever\.social',
418 r
'(?:www\.)?piped\.garudalinux\.org',
419 r
'(?:www\.)?piped\.rivo\.lol',
420 r
'(?:www\.)?piped-libre\.kavin\.rocks',
421 r
'(?:www\.)?yt\.jae\.fi',
422 r
'(?:www\.)?piped\.mint\.lgbt',
424 r
'(?:www\.)?piped\.esmailelbob\.xyz',
425 r
'(?:www\.)?piped\.projectsegfau\.lt',
426 r
'(?:www\.)?piped\.privacydev\.net',
427 r
'(?:www\.)?piped\.palveluntarjoaja\.eu',
428 r
'(?:www\.)?piped\.smnz\.de',
429 r
'(?:www\.)?piped\.adminforge\.de',
430 r
'(?:www\.)?watch\.whatevertinfoil\.de',
431 r
'(?:www\.)?piped\.qdi\.fi',
432 r
'(?:www\.)?piped\.video',
433 r
'(?:www\.)?piped\.aeong\.one',
434 r
'(?:www\.)?piped\.moomoo\.me',
435 r
'(?:www\.)?piped\.chauvet\.pro',
436 r
'(?:www\.)?watch\.leptons\.xyz',
437 r
'(?:www\.)?pd\.vern\.cc',
438 r
'(?:www\.)?piped\.hostux\.net',
439 r
'(?:www\.)?piped\.lunar\.icu',
440 # Hyperpipe instances from https://hyperpipe.codeberg.page/
441 r
'(?:www\.)?hyperpipe\.surge\.sh',
442 r
'(?:www\.)?hyperpipe\.esmailelbob\.xyz',
443 r
'(?:www\.)?listen\.whatever\.social',
444 r
'(?:www\.)?music\.adminforge\.de',
447 # extracted from account/account_menu ep
448 # XXX: These are the supported YouTube UI and API languages,
449 # which is slightly different from languages supported for translation in YouTube studio
450 _SUPPORTED_LANG_CODES
= [
451 'af', 'az', 'id', 'ms', 'bs', 'ca', 'cs', 'da', 'de', 'et', 'en-IN', 'en-GB', 'en', 'es',
452 'es-419', 'es-US', 'eu', 'fil', 'fr', 'fr-CA', 'gl', 'hr', 'zu', 'is', 'it', 'sw', 'lv',
453 'lt', 'hu', 'nl', 'no', 'uz', 'pl', 'pt-PT', 'pt', 'ro', 'sq', 'sk', 'sl', 'sr-Latn', 'fi',
454 'sv', 'vi', 'tr', 'be', 'bg', 'ky', 'kk', 'mk', 'mn', 'ru', 'sr', 'uk', 'el', 'hy', 'iw',
455 'ur', 'ar', 'fa', 'ne', 'mr', 'hi', 'as', 'bn', 'pa', 'gu', 'or', 'ta', 'te', 'kn', 'ml',
456 'si', 'th', 'lo', 'my', 'ka', 'am', 'km', 'zh-CN', 'zh-TW', 'zh-HK', 'ja', 'ko'
459 _IGNORED_WARNINGS
= {'Unavailable videos will be hidden during playback'}
461 _YT_HANDLE_RE
= r
'@[\w.-]{3,30}' # https://support.google.com/youtube/answer/11585688?hl=en
462 _YT_CHANNEL_UCID_RE
= r
'UC[\w-]{22}'
464 def ucid_or_none(self
, ucid
):
465 return self
._search
_regex
(rf
'^({self._YT_CHANNEL_UCID_RE})$', ucid
, 'UC-id', default
=None)
467 def handle_or_none(self
, handle
):
468 return self
._search
_regex
(rf
'^({self._YT_HANDLE_RE})$', handle
, '@-handle', default
=None)
470 def handle_from_url(self
, url
):
471 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_HANDLE_RE})',
472 url
, 'channel handle', default
=None)
474 def ucid_from_url(self
, url
):
475 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_CHANNEL_UCID_RE})',
476 url
, 'channel id', default
=None)
478 @functools.cached_property
479 def _preferred_lang(self
):
481 Returns a language code supported by YouTube for the user preferred language.
482 Returns None if no preferred language set.
484 preferred_lang
= self
._configuration
_arg
('lang', ie_key
='Youtube', casesense
=True, default
=[''])[0]
485 if not preferred_lang
:
487 if preferred_lang
not in self
._SUPPORTED
_LANG
_CODES
:
488 raise ExtractorError(
489 f
'Unsupported language code: {preferred_lang}. Supported language codes (case-sensitive): {join_nonempty(*self._SUPPORTED_LANG_CODES, delim=", ")}.',
491 elif preferred_lang
!= 'en':
493 f
'Preferring "{preferred_lang}" translated fields. Note that some metadata extraction may fail or be incorrect.')
494 return preferred_lang
496 def _initialize_consent(self
):
497 cookies
= self
._get
_cookies
('https://www.youtube.com/')
498 if cookies
.get('__Secure-3PSID'):
501 consent
= cookies
.get('CONSENT')
503 if 'YES' in consent
.value
:
505 consent_id
= self
._search
_regex
(
506 r
'PENDING\+(\d+)', consent
.value
, 'consent', default
=None)
508 consent_id
= random
.randint(100, 999)
509 self
._set
_cookie
('.youtube.com', 'CONSENT', 'YES+cb.20210328-17-p0.en+FX+%s' % consent_id
)
511 def _initialize_pref(self
):
512 cookies
= self
._get
_cookies
('https://www.youtube.com/')
513 pref_cookie
= cookies
.get('PREF')
517 pref
= dict(urllib
.parse
.parse_qsl(pref_cookie
.value
))
519 self
.report_warning('Failed to parse user PREF cookie' + bug_reports_message())
520 pref
.update({'hl': self._preferred_lang or 'en', 'tz': 'UTC'}
)
521 self
._set
_cookie
('.youtube.com', name
='PREF', value
=urllib
.parse
.urlencode(pref
))
523 def _real_initialize(self
):
524 self
._initialize
_pref
()
525 self
._initialize
_consent
()
526 self
._check
_login
_required
()
528 def _check_login_required(self
):
529 if self
._LOGIN
_REQUIRED
and not self
._cookies
_passed
:
530 self
.raise_login_required('Login details are needed to download this content', method
='cookies')
532 _YT_INITIAL_DATA_RE
= r
'(?:window\s*\[\s*["\']ytInitialData
["\']\s*\]|ytInitialData)\s*='
533 _YT_INITIAL_PLAYER_RESPONSE_RE = r'ytInitialPlayerResponse\s*='
535 def _get_default_ytcfg(self, client='web'):
536 return copy.deepcopy(INNERTUBE_CLIENTS[client])
538 def _get_innertube_host(self, client='web'):
539 return INNERTUBE_CLIENTS[client]['INNERTUBE_HOST']
541 def _ytcfg_get_safe(self, ytcfg, getter, expected_type=None, default_client='web'):
542 # try_get but with fallback to default ytcfg client values when present
543 _func = lambda y: try_get(y, getter, expected_type)
544 return _func(ytcfg) or _func(self._get_default_ytcfg(default_client))
546 def _extract_client_name(self, ytcfg, default_client='web'):
547 return self._ytcfg_get_safe(
548 ytcfg, (lambda x: x['INNERTUBE_CLIENT_NAME'],
549 lambda x: x['INNERTUBE_CONTEXT']['client']['clientName']), str, default_client)
551 def _extract_client_version(self, ytcfg, default_client='web'):
552 return self._ytcfg_get_safe(
553 ytcfg, (lambda x: x['INNERTUBE_CLIENT_VERSION'],
554 lambda x: x['INNERTUBE_CONTEXT']['client']['clientVersion']), str, default_client)
556 def _select_api_hostname(self, req_api_hostname, default_client=None):
557 return (self._configuration_arg('innertube_host', [''], ie_key=YoutubeIE.ie_key())[0]
558 or req_api_hostname or self._get_innertube_host(default_client or 'web'))
560 def _extract_api_key(self, ytcfg=None, default_client='web'):
561 return self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_API_KEY'], str, default_client)
563 def _extract_context(self, ytcfg=None, default_client='web'):
565 (ytcfg, self._get_default_ytcfg(default_client)), 'INNERTUBE_CONTEXT', expected_type=dict)
566 # Enforce language and tz for extraction
567 client_context = traverse_obj(context, 'client', expected_type=dict, default={})
568 client_context.update({'hl': self._preferred_lang or 'en', 'timeZone': 'UTC', 'utcOffsetMinutes': 0})
573 def _generate_sapisidhash_header(self, origin='https://www.youtube.com'):
574 time_now = round(time.time())
575 if self._SAPISID is None:
576 yt_cookies = self._get_cookies('https://www.youtube.com')
577 # Sometimes SAPISID cookie isn't present but __Secure-3PAPISID is.
578 # See: https://github.com/yt-dlp/yt-dlp/issues/393
579 sapisid_cookie = dict_get(
580 yt_cookies, ('__Secure-3PAPISID', 'SAPISID'))
581 if sapisid_cookie and sapisid_cookie.value:
582 self._SAPISID = sapisid_cookie.value
583 self.write_debug('Extracted SAPISID cookie')
584 # SAPISID cookie is required if not already present
585 if not yt_cookies.get('SAPISID'):
586 self.write_debug('Copying __Secure-3PAPISID cookie to SAPISID cookie')
588 '.youtube.com', 'SAPISID', self._SAPISID, secure=True, expire_time=time_now + 3600)
590 self._SAPISID = False
591 if not self._SAPISID:
593 # SAPISIDHASH algorithm from https://stackoverflow.com/a/32065323
594 sapisidhash = hashlib.sha1(
595 f'{time_now} {self._SAPISID} {origin}'.encode()).hexdigest()
596 return f'SAPISIDHASH {time_now}_{sapisidhash}'
598 def _call_api(self, ep, query, video_id, fatal=True, headers=None,
599 note='Downloading API JSON', errnote='Unable to download API page',
600 context=None, api_key=None, api_hostname=None, default_client='web'):
602 data = {'context': context} if context else {'context': self._extract_context(default_client=default_client)}
604 real_headers = self.generate_api_headers(default_client=default_client)
605 real_headers.update({'content-type': 'application/json'})
607 real_headers.update(headers)
608 api_key = (self._configuration_arg('innertube_key', [''], ie_key=YoutubeIE.ie_key(), casesense=True)[0]
609 or api_key or self._extract_api_key(default_client=default_client))
610 return self._download_json(
611 f'https://{self._select_api_hostname(api_hostname, default_client)}/youtubei/v1/{ep}',
612 video_id=video_id, fatal=fatal, note=note, errnote=errnote,
613 data=json.dumps(data).encode('utf8'), headers=real_headers,
614 query={'key': api_key, 'prettyPrint': 'false'})
616 def extract_yt_initial_data(self, item_id, webpage, fatal=True):
617 return self._search_json(self._YT_INITIAL_DATA_RE, webpage, 'yt initial data', item_id, fatal=fatal)
620 def _extract_session_index(*data):
622 Index of current account in account list.
623 See: https://github.com/yt-dlp/yt-dlp/pull/519
626 session_index = int_or_none(try_get(ytcfg, lambda x: x['SESSION_INDEX']))
627 if session_index is not None:
631 def _extract_identity_token(self, ytcfg=None, webpage=None):
633 token = try_get(ytcfg, lambda x: x['ID_TOKEN'], str)
637 return self._search_regex(
638 r'\bID_TOKEN["\']\s
*:\s
*["\'](.+?)["\']', webpage,
639 'identity token
', default=None, fatal=False)
642 def _extract_account_syncid(*args):
644 Extract syncId required to download private playlists of secondary channels
645 @params response and/or ytcfg
648 # ytcfg includes channel_syncid if on secondary channel
649 delegated_sid = try_get(data, lambda x: x['DELEGATED_SESSION_ID
'], str)
653 data, (lambda x: x['responseContext
']['mainAppWebResponseContext
']['datasyncId
'],
654 lambda x: x['DATASYNC_ID
']), str) or '').split('||
')
655 if len(sync_ids) >= 2 and sync_ids[1]:
656 # datasyncid is of the form "channel_syncid||user_syncid" for secondary channel
657 # and just "user_syncid||" for primary channel. We only want the channel_syncid
661 def _extract_visitor_data(*args):
663 Extracts visitorData from an API response or ytcfg
664 Appears to be used to track session state
667 args, [('VISITOR_DATA
', ('INNERTUBE_CONTEXT
', 'client
', 'visitorData
'), ('responseContext
', 'visitorData
'))],
670 @functools.cached_property
671 def is_authenticated(self):
672 return bool(self._generate_sapisidhash_header())
674 def extract_ytcfg(self, video_id, webpage):
677 return self._parse_json(
679 r'ytcfg\
.set\s
*\
(\s
*({.+?}
)\s
*\
)\s
*;', webpage, 'ytcfg
',
680 default='{}'), video_id, fatal=False) or {}
682 def generate_api_headers(
683 self
, *, ytcfg
=None, account_syncid
=None, session_index
=None,
684 visitor_data
=None, identity_token
=None, api_hostname
=None, default_client
='web'):
686 origin
= 'https://' + (self
._select
_api
_hostname
(api_hostname
, default_client
))
688 'X-YouTube-Client-Name': str(
689 self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT_CLIENT_NAME'], default_client
=default_client
)),
690 'X-YouTube-Client-Version': self
._extract
_client
_version
(ytcfg
, default_client
),
692 'X-Youtube-Identity-Token': identity_token
or self
._extract
_identity
_token
(ytcfg
),
693 'X-Goog-PageId': account_syncid
or self
._extract
_account
_syncid
(ytcfg
),
694 'X-Goog-Visitor-Id': visitor_data
or self
._extract
_visitor
_data
(ytcfg
),
695 'User-Agent': self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT']['client']['userAgent'], default_client
=default_client
)
697 if session_index
is None:
698 session_index
= self
._extract
_session
_index
(ytcfg
)
699 if account_syncid
or session_index
is not None:
700 headers
['X-Goog-AuthUser'] = session_index
if session_index
is not None else 0
702 auth
= self
._generate
_sapisidhash
_header
(origin
)
704 headers
['Authorization'] = auth
705 headers
['X-Origin'] = origin
706 return filter_dict(headers
)
708 def _download_ytcfg(self
, client
, video_id
):
710 'web': 'https://www.youtube.com',
711 'web_music': 'https://music.youtube.com',
712 'web_embedded': f
'https://www.youtube.com/embed/{video_id}?html5=1'
716 webpage
= self
._download
_webpage
(
717 url
, video_id
, fatal
=False, note
=f
'Downloading {client.replace("_", " ").strip()} client config')
718 return self
.extract_ytcfg(video_id
, webpage
) or {}
721 def _build_api_continuation_query(continuation
, ctp
=None):
723 'continuation': continuation
725 # TODO: Inconsistency with clickTrackingParams.
726 # Currently we have a fixed ctp contained within context (from ytcfg)
727 # and a ctp in root query for continuation.
729 query
['clickTracking'] = {'clickTrackingParams': ctp}
733 def _extract_next_continuation_data(cls
, renderer
):
734 next_continuation
= try_get(
735 renderer
, (lambda x
: x
['continuations'][0]['nextContinuationData'],
736 lambda x
: x
['continuation']['reloadContinuationData']), dict)
737 if not next_continuation
:
739 continuation
= next_continuation
.get('continuation')
742 ctp
= next_continuation
.get('clickTrackingParams')
743 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
746 def _extract_continuation_ep_data(cls
, continuation_ep
: dict):
747 if isinstance(continuation_ep
, dict):
748 continuation
= try_get(
749 continuation_ep
, lambda x
: x
['continuationCommand']['token'], str)
752 ctp
= continuation_ep
.get('clickTrackingParams')
753 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
756 def _extract_continuation(cls
, renderer
):
757 next_continuation
= cls
._extract
_next
_continuation
_data
(renderer
)
758 if next_continuation
:
759 return next_continuation
761 return traverse_obj(renderer
, (
762 ('contents', 'items', 'rows'), ..., 'continuationItemRenderer',
763 ('continuationEndpoint', ('button', 'buttonRenderer', 'command'))
764 ), get_all
=False, expected_type
=cls
._extract
_continuation
_ep
_data
)
767 def _extract_alerts(cls
, data
):
768 for alert_dict
in try_get(data
, lambda x
: x
['alerts'], list) or []:
769 if not isinstance(alert_dict
, dict):
771 for alert
in alert_dict
.values():
772 alert_type
= alert
.get('type')
775 message
= cls
._get
_text
(alert
, 'text')
777 yield alert_type
, message
779 def _report_alerts(self
, alerts
, expected
=True, fatal
=True, only_once
=False):
780 errors
, warnings
= [], []
781 for alert_type
, alert_message
in alerts
:
782 if alert_type
.lower() == 'error' and fatal
:
783 errors
.append([alert_type
, alert_message
])
784 elif alert_message
not in self
._IGNORED
_WARNINGS
:
785 warnings
.append([alert_type
, alert_message
])
787 for alert_type
, alert_message
in (warnings
+ errors
[:-1]):
788 self
.report_warning(f
'YouTube said: {alert_type} - {alert_message}', only_once
=only_once
)
790 raise ExtractorError('YouTube said: %s' % errors
[-1][1], expected
=expected
)
792 def _extract_and_report_alerts(self
, data
, *args
, **kwargs
):
793 return self
._report
_alerts
(self
._extract
_alerts
(data
), *args
, **kwargs
)
795 def _extract_badges(self
, renderer
: dict):
797 'PRIVACY_UNLISTED': BadgeType
.AVAILABILITY_UNLISTED
,
798 'PRIVACY_PRIVATE': BadgeType
.AVAILABILITY_PRIVATE
,
799 'PRIVACY_PUBLIC': BadgeType
.AVAILABILITY_PUBLIC
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
809 'unlisted': BadgeType
.AVAILABILITY_UNLISTED
,
810 'private': BadgeType
.AVAILABILITY_PRIVATE
,
811 'members only': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
812 'live': BadgeType
.LIVE_NOW
,
813 'premium': BadgeType
.AVAILABILITY_PREMIUM
817 for badge
in traverse_obj(renderer
, ('badges', ..., 'metadataBadgeRenderer')):
819 privacy_icon_map
.get(traverse_obj(badge
, ('icon', 'iconType'), expected_type
=str))
820 or badge_style_map
.get(traverse_obj(badge
, 'style'))
823 badges
.append({'type': badge_type}
)
826 # fallback, won't work in some languages
827 label
= traverse_obj(badge
, 'label', expected_type
=str, default
='')
828 for match
, label_badge_type
in label_map
.items():
829 if match
in label
.lower():
830 badges
.append({'type': badge_type}
)
836 def _has_badge(badges
, badge_type
):
837 return bool(traverse_obj(badges
, lambda _
, v
: v
['type'] == badge_type
))
840 def _get_text(data
, *path_list
, max_runs
=None):
841 for path
in path_list
or [None]:
845 obj
= traverse_obj(data
, path
, default
=[])
846 if not any(key
is ... or isinstance(key
, (list, tuple)) for key
in variadic(path
)):
849 text
= try_get(item
, lambda x
: x
['simpleText'], str)
852 runs
= try_get(item
, lambda x
: x
['runs'], list) or []
853 if not runs
and isinstance(item
, list):
856 runs
= runs
[:min(len(runs
), max_runs
or len(runs
))]
857 text
= ''.join(traverse_obj(runs
, (..., 'text'), expected_type
=str))
861 def _get_count(self
, data
, *path_list
):
862 count_text
= self
._get
_text
(data
, *path_list
) or ''
863 count
= parse_count(count_text
)
866 self
._search
_regex
(r
'^([\d,]+)', re
.sub(r
'\s', '', count_text
), 'count', default
=None))
870 def _extract_thumbnails(data
, *path_list
):
872 Extract thumbnails from thumbnails dict
873 @param path_list: path list to level that contains 'thumbnails' key
876 for path
in path_list
or [()]:
877 for thumbnail
in traverse_obj(data
, (*variadic(path
), 'thumbnails', ...)):
878 thumbnail_url
= url_or_none(thumbnail
.get('url'))
879 if not thumbnail_url
:
881 # Sometimes youtube gives a wrong thumbnail URL. See:
882 # https://github.com/yt-dlp/yt-dlp/issues/233
883 # https://github.com/ytdl-org/youtube-dl/issues/28023
884 if 'maxresdefault' in thumbnail_url
:
885 thumbnail_url
= thumbnail_url
.split('?')[0]
887 'url': thumbnail_url
,
888 'height': int_or_none(thumbnail
.get('height')),
889 'width': int_or_none(thumbnail
.get('width')),
894 def extract_relative_time(relative_time_text
):
896 Extracts a relative time from string and converts to dt object
897 e.g. 'streamed 6 days ago', '5 seconds ago (edited)', 'updated today'
899 mobj
= re
.search(r
'(?P<start>today|yesterday|now)|(?P<time>\d+)\s*(?P<unit>microsecond|second|minute|hour|day|week|month|year)s?\s*ago', relative_time_text
)
901 start
= mobj
.group('start')
903 return datetime_from_str(start
)
905 return datetime_from_str('now-%s%s' % (mobj
.group('time'), mobj
.group('unit')))
909 def _parse_time_text(self
, text
):
912 dt
= self
.extract_relative_time(text
)
914 if isinstance(dt
, datetime
.datetime
):
915 timestamp
= calendar
.timegm(dt
.timetuple())
917 if timestamp
is None:
919 unified_timestamp(text
) or unified_timestamp(
921 (r
'([a-z]+\s*\d{1,2},?\s*20\d{2})', r
'(?:.+|^)(?:live|premieres|ed|ing)(?:\s*(?:on|for))?\s*(.+\d)'),
922 text
.lower(), 'time text', default
=None)))
924 if text
and timestamp
is None and self
._preferred
_lang
in (None, 'en'):
926 f
'Cannot parse localized time text "{text}"', only_once
=True)
929 def _extract_response(self
, item_id
, query
, note
='Downloading API JSON', headers
=None,
930 ytcfg
=None, check_get_keys
=None, ep
='browse', fatal
=True, api_hostname
=None,
931 default_client
='web'):
932 for retry
in self
.RetryManager():
934 response
= self
._call
_api
(
935 ep
=ep
, fatal
=True, headers
=headers
,
936 video_id
=item_id
, query
=query
, note
=note
,
937 context
=self
._extract
_context
(ytcfg
, default_client
),
938 api_key
=self
._extract
_api
_key
(ytcfg
, default_client
),
939 api_hostname
=api_hostname
, default_client
=default_client
)
940 except ExtractorError
as e
:
941 if not isinstance(e
.cause
, network_exceptions
):
942 return self
._error
_or
_warning
(e
, fatal
=fatal
)
943 elif not isinstance(e
.cause
, urllib
.error
.HTTPError
):
947 first_bytes
= e
.cause
.read(512)
948 if not is_html(first_bytes
):
951 self
._webpage
_read
_content
(e
.cause
, None, item_id
, prefix
=first_bytes
) or '{}', item_id
, fatal
=False),
952 lambda x
: x
['error']['message'], str)
954 self
._report
_alerts
([('ERROR', yt_error
)], fatal
=False)
955 # Downloading page may result in intermittent 5xx HTTP error
956 # Sometimes a 404 is also recieved. See: https://github.com/ytdl-org/youtube-dl/issues/28289
957 # We also want to catch all other network exceptions since errors in later pages can be troublesome
958 # See https://github.com/yt-dlp/yt-dlp/issues/507#issuecomment-880188210
959 if e
.cause
.code
not in (403, 429):
962 return self
._error
_or
_warning
(e
, fatal
=fatal
)
965 self
._extract
_and
_report
_alerts
(response
, only_once
=True)
966 except ExtractorError
as e
:
967 # YouTube servers may return errors we want to retry on in a 200 OK response
968 # See: https://github.com/yt-dlp/yt-dlp/issues/839
969 if 'unknown error' in e
.msg
.lower():
972 return self
._error
_or
_warning
(e
, fatal
=fatal
)
973 # Youtube sometimes sends incomplete data
974 # See: https://github.com/ytdl-org/youtube-dl/issues/28194
975 if not traverse_obj(response
, *variadic(check_get_keys
)):
976 retry
.error
= ExtractorError('Incomplete data received', expected
=True)
982 def is_music_url(url
):
983 return re
.match(r
'(https?://)?music\.youtube\.com/', url
) is not None
985 def _extract_video(self
, renderer
):
986 video_id
= renderer
.get('videoId')
988 reel_header_renderer
= traverse_obj(renderer
, (
989 'navigationEndpoint', 'reelWatchEndpoint', 'overlay', 'reelPlayerOverlayRenderer',
990 'reelPlayerHeaderSupportedRenderers', 'reelPlayerHeaderRenderer'))
992 title
= self
._get
_text
(renderer
, 'title', 'headline') or self
._get
_text
(reel_header_renderer
, 'reelTitleText')
993 description
= self
._get
_text
(renderer
, 'descriptionSnippet')
995 duration
= int_or_none(renderer
.get('lengthSeconds'))
997 duration
= parse_duration(self
._get
_text
(
998 renderer
, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
1000 # XXX: should write a parser to be more general to support more cases (e.g. shorts in shorts tab)
1001 duration
= parse_duration(self
._search
_regex
(
1002 r
'(?i)(ago)(?!.*\1)\s+(?P<duration>[a-z0-9 ,]+?)(?:\s+[\d,]+\s+views)?(?:\s+-\s+play\s+short)?$',
1003 traverse_obj(renderer
, ('title', 'accessibility', 'accessibilityData', 'label'), default
='', expected_type
=str),
1004 video_id
, default
=None, group
='duration'))
1006 channel_id
= traverse_obj(
1007 renderer
, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'),
1008 expected_type
=str, get_all
=False)
1010 channel_id
= traverse_obj(reel_header_renderer
, ('channelNavigationEndpoint', 'browseEndpoint', 'browseId'))
1012 channel_id
= self
.ucid_or_none(channel_id
)
1014 overlay_style
= traverse_obj(
1015 renderer
, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'),
1016 get_all
=False, expected_type
=str)
1017 badges
= self
._extract
_badges
(renderer
)
1019 navigation_url
= urljoin('https://www.youtube.com/', traverse_obj(
1020 renderer
, ('navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url'),
1021 expected_type
=str)) or ''
1022 url
= f
'https://www.youtube.com/watch?v={video_id}'
1023 if overlay_style
== 'SHORTS' or '/shorts/' in navigation_url
:
1024 url
= f
'https://www.youtube.com/shorts/{video_id}'
1026 time_text
= (self
._get
_text
(renderer
, 'publishedTimeText', 'videoInfo')
1027 or self
._get
_text
(reel_header_renderer
, 'timestampText') or '')
1028 scheduled_timestamp
= str_to_int(traverse_obj(renderer
, ('upcomingEventData', 'startTime'), get_all
=False))
1031 'is_upcoming' if scheduled_timestamp
is not None
1032 else 'was_live' if 'streamed' in time_text
.lower()
1033 else 'is_live' if overlay_style
== 'LIVE' or self
._has
_badge
(badges
, BadgeType
.LIVE_NOW
)
1036 # videoInfo is a string like '50K views • 10 years ago'.
1037 view_count_text
= self
._get
_text
(renderer
, 'viewCountText', 'shortViewCountText', 'videoInfo') or ''
1038 view_count
= (0 if 'no views' in view_count_text
.lower()
1039 else self
._get
_count
({'simpleText': view_count_text}
))
1040 view_count_field
= 'concurrent_view_count' if live_status
in ('is_live', 'is_upcoming') else 'view_count'
1044 'ie_key': YoutubeIE
.ie_key(),
1048 'description': description
,
1049 'duration': duration
,
1050 'channel_id': channel_id
,
1051 'channel': (self
._get
_text
(renderer
, 'ownerText', 'shortBylineText')
1052 or self
._get
_text
(reel_header_renderer
, 'channelTitleText')),
1053 'channel_url': f
'https://www.youtube.com/channel/{channel_id}' if channel_id
else None,
1054 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
1055 'timestamp': (self
._parse
_time
_text
(time_text
)
1056 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
1058 'release_timestamp': scheduled_timestamp
,
1060 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
1061 else self
._availability
(
1062 is_private
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
) or None,
1063 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
1064 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
1065 is_unlisted
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
) or None),
1066 view_count_field
: view_count
,
1067 'live_status': live_status
1071 class YoutubeIE(YoutubeBaseInfoExtractor
):
1073 _VALID_URL
= r
"""(?x)^
1075 (?:https?://|//) # http(s):// or protocol-independent URL
1076 (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
1077 (?:www\.)?deturl\.com/www\.youtube\.com|
1078 (?:www\.)?pwnyoutube\.com|
1079 (?:www\.)?hooktube\.com|
1080 (?:www\.)?yourepeat\.com|
1081 tube\.majestyc\.net|
1083 youtube\.googleapis\.com)/ # the various hostnames, with wildcard subdomains
1084 (?:.*?\#/)? # handle anchor (#/) redirect urls
1085 (?: # the various things that can precede the ID:
1086 (?:(?:v|embed|e|shorts|live)/(?!videoseries|live_stream)) # v/ or embed/ or e/ or shorts/
1087 |(?: # or the v= param in all its forms
1088 (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
1089 (?:\?|\#!?) # the params delimiter ? or # or #!
1090 (?:.*?[&;])?? # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&v=V36LpHqtcDY)
1095 youtu\.be| # just youtu.be/xxxx
1096 vid\.plus| # or vid.plus/xxxx
1097 zwearz\.com/watch| # or zwearz.com/watch/xxxx
1100 |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
1102 )? # all until now is optional -> you can pass the naked ID
1103 (?P<id>[0-9A-Za-z_-]{11}) # here is it! the YouTube video ID
1104 (?(1).+)? # if we found the ID, everything can follow
1106 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
1111 <(?:[0-9A-Za-z-]+?)?iframe[^>]+?src=|
1119 (?P
<url
>(?
:https?
:)?
//(?
:www\
.)?
youtube(?
:-nocookie
)?\
.com
/
1120 (?
:embed|v|p
)/[0-9A
-Za
-z_
-]{11}
.*?
)
1122 # https://wordpress.org/plugins/lazy-load-for-videos/
1124 <a\s
[^
>]*\bhref
="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"
1125 \s
[^
>]*\bclass
="[^"]*\blazy
-load
-youtube
''',
1127 _RETURN_TYPE = 'video' # XXX: How to handle multifeed?
1130 r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
1131 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$',
1132 r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
1135 '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1136 '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1137 '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
1138 '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
1139 '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
1140 '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1141 '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1142 '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1143 # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
1144 '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
1145 '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1146 '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1147 '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1148 '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1149 '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1150 '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1151 '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1152 '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1156 '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1157 '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1158 '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1159 '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1160 '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
1161 '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1162 '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1164 # Apple HTTP Live Streaming
1165 '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1166 '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1167 '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1168 '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1169 '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1170 '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1171 '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1172 '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
1175 '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
1176 '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
1177 '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1178 '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
1179 '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
1180 '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'}, # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
1181 '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
1182 '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1183 '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
1184 '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1185 '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1186 '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
1189 '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
1190 '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
1191 '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
1192 '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1193 '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1194 '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
1195 '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
1198 '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1199 '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1200 '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1201 '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1202 '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1203 '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1204 '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
1205 '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1206 '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1207 '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1208 '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1209 '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1210 '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1211 '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1212 '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1213 # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
1214 '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1215 '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1216 '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1217 '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1218 '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1219 '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1222 '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
1223 '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
1225 # Dash webm audio with opus inside
1226 '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
1227 '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
1228 '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
1231 '_rtmp': {'protocol': 'rtmp'},
1233 # av01 video only formats sometimes served with "unknown" codecs
1234 '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1235 '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1236 '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1237 '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1238 '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1239 '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1240 '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1241 '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1243 _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1250 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1252 'id': 'BaW_jenozKc',
1254 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1255 'channel': 'Philipp Hagemeister',
1256 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1257 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1258 'upload_date': '20121002',
1259 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1260 'categories': ['Science & Technology'],
1261 'tags': ['youtube-dl'],
1265 'availability': 'public',
1266 'playable_in_embed': True,
1267 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1268 'live_status': 'not_live',
1272 'comment_count': int,
1273 'channel_follower_count': int,
1274 'uploader': 'Philipp Hagemeister',
1275 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1276 'uploader_id': '@PhilippHagemeister',
1280 'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1281 'note': 'Embed-only video (#1746)',
1283 'id': 'yZIXLfi8CZQ',
1285 'upload_date': '20120608',
1286 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1287 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1290 'skip': 'Private video',
1293 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1294 'note': 'Use the first video ID in the URL',
1296 'id': 'BaW_jenozKc',
1298 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1299 'channel': 'Philipp Hagemeister',
1300 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1301 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1302 'upload_date': '20121002',
1303 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1304 'categories': ['Science & Technology'],
1305 'tags': ['youtube-dl'],
1309 'availability': 'public',
1310 'playable_in_embed': True,
1311 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1312 'live_status': 'not_live',
1314 'comment_count': int,
1315 'channel_follower_count': int,
1316 'uploader': 'Philipp Hagemeister',
1317 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1318 'uploader_id': '@PhilippHagemeister',
1321 'skip_download': True,
1325 'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1326 'note': '256k DASH audio (format 141) via DASH manifest',
1328 'id': 'a9LDPn-MO4I',
1330 'upload_date': '20121002',
1332 'title': 'UHDTV TEST 8K VIDEO.mp4'
1335 'youtube_include_dash_manifest': True,
1338 'skip': 'format 141 not served anymore',
1340 # DASH manifest with encrypted signature
1342 'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1344 'id': 'IB3lcPjvWLA',
1346 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1347 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1349 'upload_date': '20131011',
1352 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1353 'playable_in_embed': True,
1354 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1356 'track': 'The Spark',
1357 'live_status': 'not_live',
1358 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1359 'channel': 'Afrojack',
1361 'availability': 'public',
1362 'categories': ['Music'],
1364 'alt_title': 'The Spark',
1365 'channel_follower_count': int,
1366 'uploader': 'Afrojack',
1367 'uploader_url': 'https://www.youtube.com/@Afrojack',
1368 'uploader_id': '@Afrojack',
1371 'youtube_include_dash_manifest': True,
1372 'format': '141/bestaudio[ext=m4a]',
1375 # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1377 'note': 'Embed allowed age-gate video',
1378 'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1380 'id': 'HtVdAasjOgU',
1382 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1383 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1385 'upload_date': '20140605',
1387 'categories': ['Gaming'],
1388 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1389 'availability': 'needs_auth',
1390 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1392 'channel': 'The Witcher',
1393 'live_status': 'not_live',
1395 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1396 'playable_in_embed': True,
1398 'channel_follower_count': int,
1399 'uploader': 'The Witcher',
1400 'uploader_url': 'https://www.youtube.com/@thewitcher',
1401 'uploader_id': '@thewitcher',
1405 'note': 'Age-gate video with embed allowed in public site',
1406 'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1408 'id': 'HsUATh_Nc2U',
1410 'title': 'Godzilla 2 (Official Video)',
1411 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1412 'upload_date': '20200408',
1414 'availability': 'needs_auth',
1415 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1416 'channel': 'FlyingKitty',
1417 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1419 'categories': ['Entertainment'],
1420 'live_status': 'not_live',
1421 'tags': ['Flyingkitty', 'godzilla 2'],
1422 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1425 'playable_in_embed': True,
1426 'channel_follower_count': int,
1427 'uploader': 'FlyingKitty',
1428 'uploader_url': 'https://www.youtube.com/@FlyingKitty900',
1429 'uploader_id': '@FlyingKitty900',
1433 'note': 'Age-gate video embedable only with clientScreen=EMBED',
1434 'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1436 'id': 'Tq92D6wQ1mg',
1437 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1439 'upload_date': '20191228',
1440 'description': 'md5:17eccca93a786d51bc67646756894066',
1443 'availability': 'needs_auth',
1444 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1446 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1447 'channel': 'Projekt Melody',
1448 'live_status': 'not_live',
1449 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1450 'playable_in_embed': True,
1451 'categories': ['Entertainment'],
1453 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1454 'comment_count': int,
1455 'channel_follower_count': int,
1456 'uploader': 'Projekt Melody',
1457 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
1458 'uploader_id': '@ProjektMelody',
1462 'note': 'Non-Agegated non-embeddable video',
1463 'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1465 'id': 'MeJVWBSsPAY',
1467 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1468 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1469 'upload_date': '20130730',
1470 'track': 'Such mich find mich',
1472 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1474 'playable_in_embed': False,
1475 'creator': 'OOMPH!',
1476 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1478 'alt_title': 'Such mich find mich',
1480 'channel': 'Herr Lurik',
1481 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1482 'categories': ['Music'],
1483 'availability': 'public',
1484 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1485 'live_status': 'not_live',
1487 'channel_follower_count': int,
1488 'uploader': 'Herr Lurik',
1489 'uploader_url': 'https://www.youtube.com/@HerrLurik',
1490 'uploader_id': '@HerrLurik',
1494 'note': 'Non-bypassable age-gated video',
1495 'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1496 'only_matching': True,
1498 # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1499 # YouTube Red ad is not captured for creator
1501 'url': '__2ABJjxzNo',
1503 'id': '__2ABJjxzNo',
1506 'upload_date': '20100430',
1507 'creator': 'deadmau5',
1508 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1509 'title': 'Deadmau5 - Some Chords (HD)',
1510 'alt_title': 'Some Chords',
1511 'availability': 'public',
1513 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1515 'live_status': 'not_live',
1516 'channel': 'deadmau5',
1517 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1519 'track': 'Some Chords',
1520 'artist': 'deadmau5',
1521 'playable_in_embed': True,
1523 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1524 'categories': ['Music'],
1525 'album': 'Some Chords',
1526 'channel_follower_count': int,
1527 'uploader': 'deadmau5',
1528 'uploader_url': 'https://www.youtube.com/@deadmau5',
1529 'uploader_id': '@deadmau5',
1531 'expected_warnings': [
1532 'DASH manifest missing',
1535 # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1537 'url': 'lqQg6PlCWgI',
1539 'id': 'lqQg6PlCWgI',
1542 'upload_date': '20150827',
1543 'description': 'md5:04bbbf3ccceb6795947572ca36f45904',
1544 'title': 'Hockey - Women - GER-AUS - London 2012 Olympic Games',
1546 'release_timestamp': 1343767800,
1547 'playable_in_embed': True,
1548 'categories': ['Sports'],
1549 'release_date': '20120731',
1550 'channel': 'Olympics',
1551 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1552 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1553 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1555 'availability': 'public',
1556 'live_status': 'was_live',
1558 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1559 'channel_follower_count': int,
1560 'uploader': 'Olympics',
1561 'uploader_url': 'https://www.youtube.com/@Olympics',
1562 'uploader_id': '@Olympics',
1565 'skip_download': 'requires avconv',
1570 'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1572 'id': '_b-2C3KPAM0',
1574 'stretched_ratio': 16 / 9.,
1576 'upload_date': '20110310',
1577 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1578 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1579 'playable_in_embed': True,
1583 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1584 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1585 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1587 'categories': ['People & Blogs'],
1589 'live_status': 'not_live',
1590 'availability': 'unlisted',
1591 'comment_count': int,
1592 'channel_follower_count': int,
1594 'uploader_url': 'https://www.youtube.com/@AllenMeow',
1595 'uploader_id': '@AllenMeow',
1598 # url_encoded_fmt_stream_map is empty string
1600 'url': 'qEJwOuvDf7I',
1602 'id': 'qEJwOuvDf7I',
1604 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1606 'upload_date': '20150404',
1609 'skip_download': 'requires avconv',
1611 'skip': 'This live event has ended.',
1613 # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1615 'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1617 'id': 'FIl7x6_3R5Y',
1619 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1620 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1622 'upload_date': '20150625',
1623 'formats': 'mincount:31',
1625 'skip': 'not actual anymore',
1627 # DASH manifest with segment_list
1629 'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1630 'md5': '8ce563a1d667b599d21064e982ab9e31',
1632 'id': 'CsmdDsKjzN8',
1634 'upload_date': '20150501', # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1635 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1636 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1639 'youtube_include_dash_manifest': True,
1640 'format': '135', # bestvideo
1642 'skip': 'This live event has ended.',
1645 # Multifeed videos (multiple cameras), URL can be of any Camera
1646 # TODO: fix multifeed titles
1647 'url': 'https://www.youtube.com/watch?v=zaPI8MvL8pg',
1649 'id': 'zaPI8MvL8pg',
1650 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04',
1651 'description': 'md5:563ccbc698b39298481ca3c571169519',
1655 'id': 'j5yGuxZ8lLU',
1657 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Chris)',
1658 'description': 'md5:563ccbc698b39298481ca3c571169519',
1660 'channel_follower_count': int,
1661 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1662 'availability': 'public',
1663 'playable_in_embed': True,
1664 'upload_date': '20131105',
1665 'categories': ['Gaming'],
1666 'live_status': 'was_live',
1668 'release_timestamp': 1383701910,
1669 'thumbnail': 'https://i.ytimg.com/vi/j5yGuxZ8lLU/maxresdefault.jpg',
1670 'comment_count': int,
1673 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1674 'channel': 'WiiLikeToPlay',
1676 'release_date': '20131106',
1677 'uploader': 'WiiLikeToPlay',
1678 'uploader_id': '@WLTP',
1679 'uploader_url': 'https://www.youtube.com/@WLTP',
1683 'id': 'zaPI8MvL8pg',
1685 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Tyson)',
1686 'availability': 'public',
1687 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1688 'channel': 'WiiLikeToPlay',
1689 'channel_follower_count': int,
1690 'description': 'md5:563ccbc698b39298481ca3c571169519',
1695 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1696 'release_timestamp': 1383701915,
1697 'comment_count': int,
1698 'upload_date': '20131105',
1699 'thumbnail': 'https://i.ytimg.com/vi/zaPI8MvL8pg/maxresdefault.jpg',
1700 'release_date': '20131106',
1701 'playable_in_embed': True,
1702 'live_status': 'was_live',
1703 'categories': ['Gaming'],
1705 'uploader': 'WiiLikeToPlay',
1706 'uploader_id': '@WLTP',
1707 'uploader_url': 'https://www.youtube.com/@WLTP',
1711 'id': 'R7r3vfO7Hao',
1713 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Spencer)',
1714 'thumbnail': 'https://i.ytimg.com/vi/R7r3vfO7Hao/maxresdefault.jpg',
1715 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1717 'availability': 'public',
1718 'playable_in_embed': True,
1719 'upload_date': '20131105',
1720 'description': 'md5:563ccbc698b39298481ca3c571169519',
1721 'channel_follower_count': int,
1723 'release_date': '20131106',
1724 'comment_count': int,
1725 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1726 'channel': 'WiiLikeToPlay',
1727 'categories': ['Gaming'],
1728 'release_timestamp': 1383701914,
1729 'live_status': 'was_live',
1733 'uploader': 'WiiLikeToPlay',
1734 'uploader_id': '@WLTP',
1735 'uploader_url': 'https://www.youtube.com/@WLTP',
1738 'params': {'skip_download': True},
1741 # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1742 'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1744 'id': 'gVfLd0zydlo',
1745 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1747 'playlist_count': 2,
1748 'skip': 'Not multifeed anymore',
1751 'url': 'https://vid.plus/FlRa-iH7PGw',
1752 'only_matching': True,
1755 'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1756 'only_matching': True,
1759 # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1760 # Also tests cut-off URL expansion in video description (see
1761 # https://github.com/ytdl-org/youtube-dl/issues/1892,
1762 # https://github.com/ytdl-org/youtube-dl/issues/8164)
1763 'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1765 'id': 'lsguqyKfVQg',
1767 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1768 'alt_title': 'Dark Walk',
1769 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1771 'upload_date': '20151119',
1772 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1773 'track': 'Dark Walk',
1774 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1775 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1776 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1777 'categories': ['Film & Animation'],
1779 'live_status': 'not_live',
1780 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1781 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1783 'availability': 'public',
1784 'channel': 'IronSoulElf',
1785 'playable_in_embed': True,
1788 'channel_follower_count': int
1791 'skip_download': True,
1795 # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1796 'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1797 'only_matching': True,
1800 # Video with yt:stretch=17:0
1801 'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1803 'id': 'Q39EVAstoRM',
1805 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1806 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1807 'upload_date': '20151107',
1810 'skip_download': True,
1812 'skip': 'This video does not exist.',
1815 # Video with incomplete 'yt:stretch=16:'
1816 'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1817 'only_matching': True,
1820 # Video licensed under Creative Commons
1821 'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1823 'id': 'M4gD1WSo5mA',
1825 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1826 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1828 'upload_date': '20150128',
1829 'license': 'Creative Commons Attribution license (reuse allowed)',
1830 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1831 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1834 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1835 'channel': 'The Berkman Klein Center for Internet & Society',
1836 'availability': 'public',
1838 'categories': ['Education'],
1839 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1840 'live_status': 'not_live',
1841 'playable_in_embed': True,
1842 'channel_follower_count': int,
1844 'uploader': 'The Berkman Klein Center for Internet & Society',
1845 'uploader_id': '@BKCHarvard',
1846 'uploader_url': 'https://www.youtube.com/@BKCHarvard',
1849 'skip_download': True,
1853 'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1855 'id': 'eQcmzGIKrzg',
1857 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1858 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1860 'upload_date': '20151120',
1861 'license': 'Creative Commons Attribution license (reuse allowed)',
1862 'playable_in_embed': True,
1865 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1867 'availability': 'public',
1868 'categories': ['News & Politics'],
1869 'channel': 'Bernie Sanders',
1870 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1872 'live_status': 'not_live',
1873 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1874 'comment_count': int,
1875 'channel_follower_count': int,
1877 'uploader': 'Bernie Sanders',
1878 'uploader_url': 'https://www.youtube.com/@BernieSanders',
1879 'uploader_id': '@BernieSanders',
1882 'skip_download': True,
1886 'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;v=V36LpHqtcDY',
1887 'only_matching': True,
1890 # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1891 'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1892 'only_matching': True,
1895 # Rental video preview
1896 'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1898 'id': 'uGpuVWrhIzE',
1900 'title': 'Piku - Trailer',
1901 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1902 'upload_date': '20150811',
1903 'license': 'Standard YouTube License',
1906 'skip_download': True,
1908 'skip': 'This video is not available.',
1911 # YouTube Red video with episode data
1912 'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1914 'id': 'iqKdEhx-dD4',
1916 'title': 'Isolation - Mind Field (Ep 1)',
1917 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1919 'upload_date': '20170118',
1920 'series': 'Mind Field',
1922 'episode_number': 1,
1923 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1926 'availability': 'public',
1928 'channel': 'Vsauce',
1929 'episode': 'Episode 1',
1930 'categories': ['Entertainment'],
1931 'season': 'Season 1',
1932 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
1933 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
1935 'playable_in_embed': True,
1936 'live_status': 'not_live',
1937 'channel_follower_count': int,
1938 'uploader': 'Vsauce',
1939 'uploader_url': 'https://www.youtube.com/@Vsauce',
1940 'uploader_id': '@Vsauce',
1943 'skip_download': True,
1945 'expected_warnings': [
1946 'Skipping DASH manifest',
1950 # The following content has been identified by the YouTube community
1951 # as inappropriate or offensive to some audiences.
1952 'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
1954 'id': '6SJNVb0GnPI',
1956 'title': 'Race Differences in Intelligence',
1957 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
1959 'upload_date': '20140124',
1962 'skip_download': True,
1964 'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
1968 'url': '1t24XAntNCY',
1969 'only_matching': True,
1972 # geo restricted to JP
1973 'url': 'sJL6WA-aGkQ',
1974 'only_matching': True,
1977 'url': 'https://invidio.us/watch?v=BaW_jenozKc',
1978 'only_matching': True,
1981 'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
1982 'only_matching': True,
1985 # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
1986 'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
1987 'only_matching': True,
1991 'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
1992 'only_matching': True,
1995 # Video with unsupported adaptive stream type formats
1996 'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
1998 'id': 'Z4Vy8R84T1U',
2000 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
2001 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
2003 'upload_date': '20130923',
2004 'formats': 'maxcount:10',
2007 'skip_download': True,
2008 'youtube_include_dash_manifest': False,
2010 'skip': 'not actual anymore',
2013 # Youtube Music Auto-generated description
2014 # TODO: fix metadata extraction
2015 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2017 'id': 'MgNrAu2pzNs',
2019 'title': 'Voyeur Girl',
2020 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
2021 'upload_date': '20190312',
2022 'artist': 'Stephen',
2023 'track': 'Voyeur Girl',
2024 'album': 'it\'s too much love to know my dear',
2025 'release_date': '20190313',
2026 'release_year': 2019,
2027 'alt_title': 'Voyeur Girl',
2029 'playable_in_embed': True,
2031 'categories': ['Music'],
2032 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
2033 'channel': 'Stephen', # TODO: should be "Stephen - Topic"
2034 'uploader': 'Stephen',
2035 'availability': 'public',
2036 'creator': 'Stephen',
2038 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
2040 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
2042 'live_status': 'not_live',
2043 'channel_follower_count': int
2046 'skip_download': True,
2050 'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
2051 'only_matching': True,
2054 # invalid -> valid video id redirection
2055 'url': 'DJztXj2GPfl',
2057 'id': 'DJztXj2GPfk',
2059 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
2060 'description': 'md5:bf577a41da97918e94fa9798d9228825',
2061 'upload_date': '20090125',
2062 'artist': 'Panjabi MC',
2063 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
2064 'album': 'Beware of the Boys (Mundian To Bach Ke)',
2067 'skip_download': True,
2069 'skip': 'Video unavailable',
2072 # empty description results in an empty string
2073 'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
2075 'id': 'x41yOUIvK2k',
2077 'title': 'IMG 3456',
2079 'upload_date': '20170613',
2081 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
2083 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
2085 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
2086 'availability': 'public',
2088 'categories': ['Pets & Animals'],
2090 'playable_in_embed': True,
2091 'live_status': 'not_live',
2092 'channel': 'l\'Or Vert asbl',
2093 'channel_follower_count': int,
2094 'uploader': 'l\'Or Vert asbl',
2095 'uploader_url': 'https://www.youtube.com/@ElevageOrVert',
2096 'uploader_id': '@ElevageOrVert',
2099 'skip_download': True,
2103 # with '};' inside yt initial data (see [1])
2104 # see [2] for an example with '};' inside ytInitialPlayerResponse
2105 # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
2106 # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
2107 'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
2109 'id': 'CHqg6qOn4no',
2111 'title': 'Part 77 Sort a list of simple types in c#',
2112 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
2113 'upload_date': '20130831',
2114 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
2116 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
2117 'live_status': 'not_live',
2118 'categories': ['Education'],
2119 'availability': 'public',
2120 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
2122 'playable_in_embed': True,
2126 'channel': 'kudvenkat',
2127 'comment_count': int,
2128 'channel_follower_count': int,
2130 'uploader': 'kudvenkat',
2131 'uploader_url': 'https://www.youtube.com/@Csharp-video-tutorialsBlogspot',
2132 'uploader_id': '@Csharp-video-tutorialsBlogspot',
2135 'skip_download': True,
2139 # another example of '};' in ytInitialData
2140 'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
2141 'only_matching': True,
2144 'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
2145 'only_matching': True,
2148 # https://github.com/ytdl-org/youtube-dl/pull/28094
2149 'url': 'OtqTfy26tG0',
2151 'id': 'OtqTfy26tG0',
2153 'title': 'Burn Out',
2154 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
2155 'upload_date': '20141120',
2156 'artist': 'The Cinematic Orchestra',
2157 'track': 'Burn Out',
2158 'album': 'Every Day',
2160 'live_status': 'not_live',
2161 'alt_title': 'Burn Out',
2165 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2166 'creator': 'The Cinematic Orchestra',
2167 'channel': 'The Cinematic Orchestra',
2168 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
2169 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2170 'availability': 'public',
2171 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
2172 'categories': ['Music'],
2173 'playable_in_embed': True,
2174 'channel_follower_count': int,
2175 'uploader': 'The Cinematic Orchestra',
2176 'comment_count': int,
2179 'skip_download': True,
2183 # controversial video, only works with bpctr when authenticated with cookies
2184 'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
2185 'only_matching': True,
2188 # controversial video, requires bpctr/contentCheckOk
2189 'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
2191 'id': 'SZJvDhaSDnc',
2193 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
2194 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
2195 'upload_date': '20140716',
2196 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
2198 'categories': ['News & Politics'],
2200 'channel': 'CBS Mornings',
2201 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
2202 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
2204 'availability': 'needs_auth',
2205 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
2207 'live_status': 'not_live',
2208 'playable_in_embed': True,
2209 'channel_follower_count': int,
2210 'uploader': 'CBS Mornings',
2211 'uploader_url': 'https://www.youtube.com/@CBSMornings',
2212 'uploader_id': '@CBSMornings',
2216 # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
2217 'url': 'cBvYw8_A0vQ',
2219 'id': 'cBvYw8_A0vQ',
2221 'title': '4K Ueno Okachimachi Street Scenes 上野御徒町歩き',
2222 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
2223 'upload_date': '20201120',
2225 'categories': ['Travel & Events'],
2226 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2228 'channel': 'Walk around Japan',
2229 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
2230 'thumbnail': 'https://i.ytimg.com/vi_webp/cBvYw8_A0vQ/hqdefault.webp',
2232 'availability': 'public',
2233 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2234 'live_status': 'not_live',
2235 'playable_in_embed': True,
2236 'channel_follower_count': int,
2237 'uploader': 'Walk around Japan',
2238 'uploader_url': 'https://www.youtube.com/@walkaroundjapan7124',
2239 'uploader_id': '@walkaroundjapan7124',
2242 'skip_download': True,
2245 # Has multiple audio streams
2246 'url': 'WaOKSUlf4TM',
2247 'only_matching': True
2249 # Requires Premium: has format 141 when requested using YTM url
2250 'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2251 'only_matching': True
2253 # multiple subtitles with same lang_code
2254 'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2255 'only_matching': True,
2257 # Force use android client fallback
2258 'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2260 'id': 'YOelRv7fMxY',
2261 'title': 'DIGGING A SECRET TUNNEL Part 1',
2263 'upload_date': '20210624',
2264 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2265 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2266 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2268 'categories': ['Entertainment'],
2270 'channel': 'colinfurze',
2271 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2272 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2274 'availability': 'public',
2276 'live_status': 'not_live',
2277 'playable_in_embed': True,
2278 'channel_follower_count': int,
2280 'uploader': 'colinfurze',
2281 'uploader_url': 'https://www.youtube.com/@colinfurze',
2282 'uploader_id': '@colinfurze',
2285 'format': '17', # 3gp format available on android
2286 'extractor_args': {'youtube': {'player_client': ['android']}},
2290 # Skip download of additional client configs (remix client config in this case)
2291 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2292 'only_matching': True,
2294 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2298 'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2299 'only_matching': True,
2301 'note': 'Storyboards',
2302 'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2304 'id': '5KLPxDtMqe8',
2307 'title': 'Your Brain is Plastic',
2308 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2309 'upload_date': '20140324',
2311 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2312 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2314 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2315 'playable_in_embed': True,
2317 'availability': 'public',
2318 'channel': 'SciShow',
2319 'live_status': 'not_live',
2321 'categories': ['Education'],
2323 'channel_follower_count': int,
2325 'uploader': 'SciShow',
2326 'uploader_url': 'https://www.youtube.com/@SciShow',
2327 'uploader_id': '@SciShow',
2328 }, 'params': {'format': 'mhtml', 'skip_download': True}
2330 # Ensure video upload_date is in UTC timezone (video was uploaded 1641170939)
2331 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2333 'id': '2NUZ8W2llS4',
2335 'title': 'The NP that test your phone performance 🙂',
2336 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2337 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2338 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2342 'categories': ['Gaming'],
2344 'playable_in_embed': True,
2345 'live_status': 'not_live',
2346 'upload_date': '20220103',
2348 'availability': 'public',
2349 'channel': 'Leon Nguyen',
2350 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2351 'comment_count': int,
2352 'channel_follower_count': int,
2353 'uploader': 'Leon Nguyen',
2354 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2355 'uploader_id': '@LeonNguyen',
2358 # Same video as above, but with --compat-opt no-youtube-prefer-utc-upload-date
2359 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2361 'id': '2NUZ8W2llS4',
2363 'title': 'The NP that test your phone performance 🙂',
2364 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2365 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2366 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2370 'categories': ['Gaming'],
2372 'playable_in_embed': True,
2373 'live_status': 'not_live',
2374 'upload_date': '20220102',
2376 'availability': 'public',
2377 'channel': 'Leon Nguyen',
2378 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2379 'comment_count': int,
2380 'channel_follower_count': int,
2381 'uploader': 'Leon Nguyen',
2382 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2383 'uploader_id': '@LeonNguyen',
2385 'params': {'compat_opts': ['no-youtube-prefer-utc-upload-date']}
2387 # date text is premiered video, ensure upload date in UTC (published 1641172509)
2388 'url': 'https://www.youtube.com/watch?v=mzZzzBU6lrM',
2390 'id': 'mzZzzBU6lrM',
2392 'title': 'I Met GeorgeNotFound In Real Life...',
2393 'description': 'md5:978296ec9783a031738b684d4ebf302d',
2394 'channel_id': 'UC_8NknAFiyhOUaZqHR3lq3Q',
2395 'channel_url': 'https://www.youtube.com/channel/UC_8NknAFiyhOUaZqHR3lq3Q',
2399 'categories': ['Entertainment'],
2401 'playable_in_embed': True,
2402 'live_status': 'not_live',
2403 'release_timestamp': 1641172509,
2404 'release_date': '20220103',
2405 'upload_date': '20220103',
2407 'availability': 'public',
2408 'channel': 'Quackity',
2409 'thumbnail': 'https://i.ytimg.com/vi/mzZzzBU6lrM/maxresdefault.jpg',
2410 'channel_follower_count': int,
2411 'uploader': 'Quackity',
2412 'uploader_id': '@Quackity',
2413 'uploader_url': 'https://www.youtube.com/@Quackity',
2416 { # continuous livestream. Microformat upload date should be preferred.
2417 # Upload date was 2021-06-19 (not UTC), while stream start is 2021-11-27
2418 'url': 'https://www.youtube.com/watch?v=kgx4WGK0oNU',
2420 'id': 'kgx4WGK0oNU',
2421 '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}',
2423 'channel_id': 'UC84whx2xxsiA1gXHXXqKGOA',
2424 'availability': 'public',
2426 'release_timestamp': 1637975704,
2427 'upload_date': '20210619',
2428 'channel_url': 'https://www.youtube.com/channel/UC84whx2xxsiA1gXHXXqKGOA',
2429 'live_status': 'is_live',
2430 'thumbnail': 'https://i.ytimg.com/vi/kgx4WGK0oNU/maxresdefault.jpg',
2431 'channel': 'Abao in Tokyo',
2432 'channel_follower_count': int,
2433 'release_date': '20211127',
2435 'categories': ['People & Blogs'],
2438 'playable_in_embed': True,
2439 'description': 'md5:2ef1d002cad520f65825346e2084e49d',
2440 'concurrent_view_count': int,
2441 'uploader': 'Abao in Tokyo',
2442 'uploader_url': 'https://www.youtube.com/@abaointokyo',
2443 'uploader_id': '@abaointokyo',
2445 'params': {'skip_download': True}
2447 # Story. Requires specific player params to work.
2448 'url': 'https://www.youtube.com/watch?v=vv8qTUWmulI',
2450 'id': 'vv8qTUWmulI',
2452 'availability': 'unlisted',
2454 'channel_id': 'UCzIZ8HrzDgc-pNQDUG6avBA',
2455 'upload_date': '20220526',
2456 'categories': ['Education'],
2458 'channel': 'IT\'S HISTORY',
2461 'playable_in_embed': True,
2463 'live_status': 'not_live',
2465 'thumbnail': 'https://i.ytimg.com/vi_webp/vv8qTUWmulI/maxresdefault.webp',
2466 'channel_url': 'https://www.youtube.com/channel/UCzIZ8HrzDgc-pNQDUG6avBA',
2468 'skip': 'stories get removed after some period of time',
2470 'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2472 'id': 'tjjjtzRLHvA',
2474 'title': 'ハッシュタグ無し };if window.ytcsi',
2475 'upload_date': '20220323',
2477 'availability': 'unlisted',
2478 'channel': 'Lesmiscore',
2479 'thumbnail': r're:^https?://.*\.jpg',
2481 'categories': ['Music'],
2484 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2485 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2486 'live_status': 'not_live',
2487 'playable_in_embed': True,
2488 'channel_follower_count': int,
2491 'uploader_id': '@lesmiscore',
2492 'uploader': 'Lesmiscore',
2493 'uploader_url': 'https://www.youtube.com/@lesmiscore',
2496 # Prefer primary title+description language metadata by default
2497 # Do not prefer translated description if primary is empty
2498 'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2500 'id': 'el3E4MbxRqQ',
2502 'title': 'dlp test video 2 - primary sv no desc',
2504 'channel': 'cole-dlp-test-acc',
2507 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2509 'playable_in_embed': True,
2510 'availability': 'unlisted',
2511 'thumbnail': r're:^https?://.*\.jpg',
2514 'live_status': 'not_live',
2515 'upload_date': '20220908',
2516 'categories': ['People & Blogs'],
2517 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2518 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2519 'uploader_id': '@coletdjnz',
2520 'uploader': 'cole-dlp-test-acc',
2522 'params': {'skip_download': True}
2524 # Extractor argument: prefer translated title+description
2525 'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2527 'id': 'gHKT4uU8Zng',
2529 'channel': 'cole-dlp-test-acc',
2532 'live_status': 'not_live',
2533 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2534 'upload_date': '20220728',
2536 'categories': ['People & Blogs'],
2537 'thumbnail': r're:^https?://.*\.jpg',
2538 'title': 'dlp test video title translated (fr)',
2539 'availability': 'public',
2541 'description': 'dlp test video description translated (fr)',
2542 'playable_in_embed': True,
2543 'channel_url': 'https://www.youtube.com/channel/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, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2549 'expected_warnings': [r'Preferring "fr" translated fields'],
2551 'note': '6 channel audio',
2552 'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2553 'only_matching': True,
2555 'note': 'Multiple HLS formats with same itag',
2556 'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2558 'id': 'kX3nB4PpJko',
2560 'categories': ['Entertainment'],
2561 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2562 'live_status': 'not_live',
2564 'channel_follower_count': int,
2565 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2566 'title': 'Last To Take Hand Off Jet, Keeps It!',
2567 'channel': 'MrBeast',
2568 'playable_in_embed': True,
2570 'upload_date': '20221112',
2571 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2573 'availability': 'public',
2574 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2577 'uploader': 'MrBeast',
2578 'uploader_url': 'https://www.youtube.com/@MrBeast',
2579 'uploader_id': '@MrBeast',
2581 'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2583 'note': 'Audio formats with Dynamic Range Compression',
2584 'url': 'https://www.youtube.com/watch?v=Tq92D6wQ1mg',
2586 'id': 'Tq92D6wQ1mg',
2588 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
2589 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
2590 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
2591 'channel_follower_count': int,
2592 'description': 'md5:17eccca93a786d51bc67646756894066',
2593 'upload_date': '20191228',
2594 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
2595 'playable_in_embed': True,
2597 'categories': ['Entertainment'],
2598 'thumbnail': 'https://i.ytimg.com/vi/Tq92D6wQ1mg/sddefault.jpg',
2600 'channel': 'Projekt Melody',
2602 'availability': 'needs_auth',
2603 'comment_count': int,
2604 'live_status': 'not_live',
2606 'uploader': 'Projekt Melody',
2607 'uploader_id': '@ProjektMelody',
2608 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
2610 'params': {'extractor_args': {'youtube': {'player_client': ['tv_embedded']}}, 'format': '251-drc'},
2613 'url': 'https://www.youtube.com/live/qVv6vCqciTM',
2615 'id': 'qVv6vCqciTM',
2618 'comment_count': int,
2619 'chapters': 'count:13',
2620 'upload_date': '20221223',
2621 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
2622 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
2624 'release_date': '20221223',
2625 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
2626 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
2628 'playable_in_embed': True,
2630 'availability': 'public',
2631 'channel_follower_count': int,
2632 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
2633 'categories': ['Entertainment'],
2634 'live_status': 'was_live',
2635 'release_timestamp': 1671793345,
2636 'channel': 'さなちゃんねる',
2637 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
2638 'uploader': 'さなちゃんねる',
2639 'uploader_url': 'https://www.youtube.com/@sana_natori',
2640 'uploader_id': '@sana_natori',
2644 # Fallbacks when webpage and web client is unavailable
2645 'url': 'https://www.youtube.com/watch?v=wSSmNUl9Snw',
2647 'id': 'wSSmNUl9Snw',
2649 # 'categories': ['Science & Technology'],
2651 'chapters': 'count:2',
2652 'channel': 'Scott Manley',
2655 # 'availability': 'public',
2656 'channel_follower_count': int,
2657 'live_status': 'not_live',
2658 'upload_date': '20170831',
2661 'uploader_url': 'https://www.youtube.com/@scottmanley',
2662 'description': 'md5:f4bed7b200404b72a394c2f97b782c02',
2663 'uploader': 'Scott Manley',
2664 'uploader_id': '@scottmanley',
2665 'title': 'The Computer Hack That Saved Apollo 14',
2666 'channel_id': 'UCxzC4EngIsMrPmbm6Nxvb-A',
2667 'thumbnail': r're:^https?://.*\.webp',
2668 'channel_url': 'https://www.youtube.com/channel/UCxzC4EngIsMrPmbm6Nxvb-A',
2669 'playable_in_embed': True,
2672 'extractor_args': {'youtube': {'player_client': ['android'], 'player_skip': ['webpage']}},
2678 # YouTube <object> embed
2680 'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2681 'md5': '873c81d308b979f0e23ee7e620b312a3',
2683 'id': 'msN87y-iEx0',
2685 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2686 'upload_date': '20080526',
2687 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2689 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2690 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2691 'playable_in_embed': True,
2692 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2694 'comment_count': int,
2695 'channel': 'Christopher Sykes',
2696 'live_status': 'not_live',
2697 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2698 'availability': 'public',
2701 'categories': ['Science & Technology'],
2702 'channel_follower_count': int,
2703 'uploader': 'Christopher Sykes',
2704 'uploader_url': 'https://www.youtube.com/@ChristopherSykesDocumentaries',
2705 'uploader_id': '@ChristopherSykesDocumentaries',
2708 'skip_download': True,
2714 def suitable(cls, url):
2715 from ..utils import parse_qs
2718 if qs.get('list', [None])[0]:
2720 return super().suitable(url)
2722 def __init__(self, *args, **kwargs):
2723 super().__init__(*args, **kwargs)
2724 self._code_cache = {}
2725 self._player_cache = {}
2727 def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2728 lock = threading.Lock()
2729 start_time = time.time()
2730 formats = [f for f in formats if f.get('is_from_start')]
2732 def refetch_manifest(format_id, delay):
2733 nonlocal formats, start_time, is_live
2734 if time.time() <= start_time + delay:
2737 _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2738 video_details = traverse_obj(prs, (..., 'videoDetails'), expected_type=dict)
2739 microformats = traverse_obj(
2740 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2742 _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2743 is_live = live_status == 'is_live'
2744 start_time = time.time()
2746 def mpd_feed(format_id, delay):
2748 @returns (manifest_url, manifest_stream_number, is_live) or None
2750 for retry in self.RetryManager(fatal=False):
2752 refetch_manifest(format_id, delay)
2754 f = next((f for f in formats if f['format_id'] == format_id), None)
2757 retry.error = f'{video_id}: Video is no longer live'
2759 retry.error = f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}'
2761 return f['manifest_url'], f['manifest_stream_number'], is_live
2765 f['is_live'] = is_live
2766 gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2767 live_start_time, mpd_feed, not is_live and f.copy())
2769 f['fragments'] = gen
2770 f['protocol'] = 'http_dash_segments_generator'
2772 f['fragments'] = LazyList(gen({}))
2773 del f['is_from_start']
2775 def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2776 FETCH_SPAN, MAX_DURATION = 5, 432000
2778 mpd_url, stream_number, is_live = None, None, True
2781 download_start_time = ctx.get('start') or time.time()
2783 lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2784 if lack_early_segments:
2785 self.report_warning(bug_reports_message(
2786 'Starting download from the last 120 hours of the live stream since '
2787 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2788 lack_early_segments = True
2790 known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2791 fragments, fragment_base_url = None, None
2793 def _extract_sequence_from_mpd(refresh_sequence, immediate):
2794 nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2795 # Obtain from MPD's maximum seq value
2796 old_mpd_url = mpd_url
2797 last_error = ctx.pop('last_error', None)
2798 expire_fast = immediate or last_error and isinstance(last_error, urllib.error.HTTPError) and last_error.code == 403
2799 mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2800 or (mpd_url, stream_number, False))
2801 if not refresh_sequence:
2802 if expire_fast and not is_live:
2803 return False, last_seq
2804 elif old_mpd_url == mpd_url:
2805 return True, last_seq
2806 if manifestless_orig_fmt:
2807 fmt_info = manifestless_orig_fmt
2810 fmts, _ = self._extract_mpd_formats_and_subtitles(
2811 mpd_url, None, note=False, errnote=False, fatal=False)
2812 except ExtractorError:
2815 no_fragment_score += 2
2816 return False, last_seq
2817 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2818 fragments = fmt_info['fragments']
2819 fragment_base_url = fmt_info['fragment_base_url']
2820 assert fragment_base_url
2822 _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2823 return True, _last_seq
2825 self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2827 fetch_time = time.time()
2828 if no_fragment_score > 30:
2830 if last_segment_url:
2831 # Obtain from "X-Head-Seqnum" header value from each segment
2833 urlh = self._request_webpage(
2834 last_segment_url, None, note=False, errnote=False, fatal=False)
2835 except ExtractorError:
2837 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2838 if last_seq is None:
2839 no_fragment_score += 2
2840 last_segment_url = None
2843 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2844 no_fragment_score += 2
2845 if not should_continue:
2848 if known_idx > last_seq:
2849 last_segment_url = None
2854 if begin_index < 0 and known_idx < 0:
2855 # skip from the start when it's negative value
2856 known_idx = last_seq + begin_index
2857 if lack_early_segments:
2858 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2860 for idx in range(known_idx, last_seq):
2861 # do not update sequence here or you'll get skipped some part of it
2862 should_continue, _ = _extract_sequence_from_mpd(False, False)
2863 if not should_continue:
2865 raise ExtractorError('breaking out of outer loop')
2866 last_segment_url = urljoin(fragment_base_url, 'sq/%d' % idx)
2868 'url': last_segment_url,
2869 'fragment_count': last_seq,
2871 if known_idx == last_seq:
2872 no_fragment_score += 5
2874 no_fragment_score = 0
2875 known_idx = last_seq
2876 except ExtractorError:
2879 if manifestless_orig_fmt:
2880 # Stop at the first iteration if running for post-live manifestless;
2881 # fragment count no longer increase since it starts
2884 time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2886 def _extract_player_url(self, *ytcfgs, webpage=None):
2887 player_url = traverse_obj(
2888 ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2889 get_all=False, expected_type=str)
2892 return urljoin('https://www.youtube.com', player_url)
2894 def _download_player_url(self, video_id, fatal=False):
2895 res = self._download_webpage(
2896 'https://www.youtube.com/iframe_api',
2897 note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2899 player_version = self._search_regex(
2900 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2902 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2904 def _signature_cache_id(self, example_sig):
2905 """ Return a string representation of a signature """
2906 return '.'.join(str(len(part)) for part in example_sig.split('.'))
2909 def _extract_player_info(cls, player_url):
2910 for player_re in cls._PLAYER_INFO_RE:
2911 id_m = re.search(player_re, player_url)
2915 raise ExtractorError('Cannot identify player %r' % player_url)
2916 return id_m.group('id')
2918 def _load_player(self, video_id, player_url, fatal=True):
2919 player_id = self._extract_player_info(player_url)
2920 if player_id not in self._code_cache:
2921 code = self._download_webpage(
2922 player_url, video_id, fatal=fatal,
2923 note='Downloading player ' + player_id,
2924 errnote='Download of %s failed' % player_url)
2926 self._code_cache[player_id] = code
2927 return self._code_cache.get(player_id)
2929 def _extract_signature_function(self, video_id, player_url, example_sig):
2930 player_id = self._extract_player_info(player_url)
2932 # Read from filesystem cache
2933 func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2934 assert os.path.basename(func_id) == func_id
2936 self.write_debug(f'Extracting signature function {func_id}')
2937 cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
2940 code = self._load_player(video_id, player_url)
2942 res = self._parse_sig_js(code)
2943 test_string = ''.join(map(chr, range(len(example_sig))))
2944 cache_spec = [ord(c) for c in res(test_string)]
2945 self.cache.store('youtube-sigfuncs', func_id, cache_spec)
2947 return lambda s: ''.join(s[i] for i in cache_spec)
2949 def _print_sig_code(self, func, example_sig):
2950 if not self.get_param('youtube_print_sig_code'):
2953 def gen_sig_code(idxs):
2954 def _genslice(start, end, step):
2955 starts = '' if start == 0 else str(start)
2956 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
2957 steps = '' if step == 1 else (':%d' % step)
2958 return f's[{starts}{ends}{steps}]'
2961 # Quelch pyflakes warnings - start will be set when step is set
2962 start = '(Never used)'
2963 for i, prev in zip(idxs[1:], idxs[:-1]):
2964 if step is not None:
2965 if i - prev == step:
2967 yield _genslice(start, prev, step)
2970 if i - prev in [-1, 1]:
2975 yield 's[%d]' % prev
2979 yield _genslice(start, i, step)
2981 test_string = ''.join(map(chr, range(len(example_sig))))
2982 cache_res = func(test_string)
2983 cache_spec = [ord(c) for c in cache_res]
2984 expr_code = ' + '.join(gen_sig_code(cache_spec))
2985 signature_id_tuple = '(%s)' % (
2986 ', '.join(str(len(p)) for p in example_sig.split('.')))
2987 code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
2988 ' return %s\n') % (signature_id_tuple, expr_code)
2989 self.to_screen('Extracted signature function:\n' + code)
2991 def _parse_sig_js(self, jscode):
2992 funcname = self._search_regex(
2993 (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2994 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2995 r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
2996 r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
2997 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+\)',
2998 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*\)',
2999 r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
3001 r'(["\'])signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3002 r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
3003 r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3004 r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3005 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3006 r'\bc\s*&&\s*a\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3007 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3008 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
3009 jscode, 'Initial JS player signature function name', group='sig')
3011 jsi = JSInterpreter(jscode)
3012 initial_function = jsi.extract_function(funcname)
3013 return lambda s: initial_function([s])
3015 def _cached(self, func, *cache_id):
3016 def inner(*args, **kwargs):
3017 if cache_id not in self._player_cache:
3019 self._player_cache[cache_id] = func(*args, **kwargs)
3020 except ExtractorError as e:
3021 self._player_cache[cache_id] = e
3022 except Exception as e:
3023 self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
3025 ret = self._player_cache[cache_id]
3026 if isinstance(ret, Exception):
3031 def _decrypt_signature(self, s, video_id, player_url):
3032 """Turn the encrypted s field into a working signature"""
3033 extract_sig = self._cached(
3034 self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
3035 func = extract_sig(video_id, player_url, s)
3036 self._print_sig_code(func, s)
3039 def _decrypt_nsig(self, s, video_id, player_url):
3040 """Turn the encrypted n field into a working signature"""
3041 if player_url is None:
3042 raise ExtractorError('Cannot decrypt nsig without player_url')
3043 player_url = urljoin('https://www.youtube.com', player_url)
3046 jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
3047 except ExtractorError as e:
3048 raise ExtractorError('Unable to extract nsig function code', cause=e)
3049 if self.get_param('youtube_print_sig_code'):
3050 self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
3053 extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
3054 ret = extract_nsig(jsi, func_code)(s)
3055 except JSInterpreter.Exception as e:
3057 jsi = PhantomJSwrapper(self, timeout=5000)
3058 except ExtractorError:
3060 self.report_warning(
3061 f'Native nsig extraction failed: Trying with PhantomJS\n'
3062 f' n = {s} ; player = {player_url}', video_id)
3063 self.write_debug(e, only_once=True)
3065 args, func_body = func_code
3067 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
3068 video_id=video_id, note='Executing signature code').strip()
3070 self.write_debug(f'Decrypted nsig {s} => {ret}')
3073 def _extract_n_function_name(self, jscode):
3074 funcname, idx = self._search_regex(
3075 r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
3076 jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
3080 return json.loads(js_to_json(self._search_regex(
3081 rf'var {re.escape(funcname)}\s*=\s*(\[.+?\]);', jscode,
3082 f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
3084 def _extract_n_function_code(self, video_id, player_url):
3085 player_id = self._extract_player_info(player_url)
3086 func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
3087 jscode = func_code or self._load_player(video_id, player_url)
3088 jsi = JSInterpreter(jscode)
3091 return jsi, player_id, func_code
3093 func_name = self._extract_n_function_name(jscode)
3096 func_code = self._search_regex(
3097 r'''(?xs
)%s\s
*=\s
*function\s
*\
((?P
<var
>[\w$
]+)\
)\s
*
3098 # NB: The end of the regex is intentionally kept strict
3099 {(?P<code>.+?}\s
*return\
[\w$
]+.join\
(""\
))};''' % func_name,
3100 jscode, 'nsig function', group=('var', 'code'), default=None)
3102 func_code = ([func_code[0]], func_code[1])
3104 self.write_debug('Extracting nsig function with jsinterp')
3105 func_code = jsi.extract_function_code(func_name)
3107 self.cache.store('youtube-nsig', player_id, func_code)
3108 return jsi, player_id, func_code
3110 def _extract_n_function_from_code(self, jsi, func_code):
3111 func = jsi.extract_function_from_code(*func_code)
3113 def extract_nsig(s):
3116 except JSInterpreter.Exception:
3118 except Exception as e:
3119 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
3121 if ret.startswith('enhanced_except_'):
3122 raise JSInterpreter.Exception('Signature function returned an exception')
3127 def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3129 Extract signatureTimestamp (sts)
3130 Required to tell API what sig/player version is in use.
3133 if isinstance(ytcfg, dict):
3134 sts = int_or_none(ytcfg.get('STS'))
3137 # Attempt to extract from player
3138 if player_url is None:
3139 error_msg = 'Cannot extract signature timestamp without player_url.'
3141 raise ExtractorError(error_msg)
3142 self.report_warning(error_msg)
3144 code = self._load_player(video_id, player_url, fatal=fatal)
3146 sts = int_or_none(self._search_regex(
3147 r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3148 'JS player signature timestamp', group='sts', fatal=fatal))
3151 def _mark_watched(self, video_id, player_responses):
3152 for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3153 label = 'fully ' if is_full else ''
3154 url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3155 expected_type=url_or_none)
3157 self.report_warning(f'Unable to mark {label}watched')
3159 parsed_url = urllib.parse.urlparse(url)
3160 qs = urllib.parse.parse_qs(parsed_url.query)
3162 # cpn generation algorithm is reverse engineered from base.js.
3163 # In fact it works even with dummy cpn.
3164 CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3165 cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16))
3167 # # more consistent results setting it to right before the end
3168 video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3173 'cmt': video_length,
3174 'el': 'detailpage', # otherwise defaults to "shorts"
3178 # these seem to mark watchtime "history" in the real world
3179 # they're required, so send in a single value
3185 url = urllib.parse.urlunparse(
3186 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3188 self._download_webpage(
3189 url, video_id, f'Marking {label}watched',
3190 'Unable to mark watched', fatal=False)
3193 def _extract_from_webpage(cls, url, webpage):
3194 # Invidious Instances
3195 # https://github.com/yt-dlp/yt-dlp/issues/195
3196 # https://github.com/iv-org/invidious/pull/1730
3198 r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3201 yield cls.url_result(mobj.group('url'), cls)
3202 raise cls.StopExtraction()
3204 yield from super()._extract_from_webpage(url, webpage)
3206 # lazyYT YouTube embed
3207 for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3208 yield cls.url_result(unescapeHTML(id_), cls, id_)
3210 # Wordpress "YouTube Video Importer" plugin
3211 for m in re.findall(r'''(?x
)<div
[^
>]+
3212 class=(?P
<q1
>[\'"])[^\'"]*\byvii
_single
_video
_player
\b[^
\'"]*(?P=q1)[^>]+
3213 data-video_id=(?P<q2>[\'"])([^
\'"]+)(?P=q2)''', webpage):
3214 yield cls.url_result(m[-1], cls, m[-1])
3217 def extract_id(cls, url):
3218 video_id = cls.get_temp_id(url)
3220 raise ExtractorError(f'Invalid URL: {url}')
3223 def _extract_chapters_from_json(self, data, duration):
3224 chapter_list = traverse_obj(
3226 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3227 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters'
3228 ), expected_type=list)
3230 return self._extract_chapters_helper(
3232 start_function=lambda chapter: float_or_none(
3233 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3234 title_function=lambda chapter: traverse_obj(
3235 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3238 def _extract_chapters_from_engagement_panel(self, data, duration):
3239 content_list = traverse_obj(
3241 ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3243 chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3244 chapter_title = lambda chapter: self._get_text(chapter, 'title')
3246 return next(filter(None, (
3247 self._extract_chapters_helper(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3248 chapter_time, chapter_title, duration)
3249 for contents in content_list)), [])
3251 def _extract_comment(self, comment_renderer, parent=None):
3252 comment_id = comment_renderer.get('commentId')
3256 text = self._get_text(comment_renderer, 'contentText')
3258 # Timestamp is an estimate calculated from the current time and time_text
3259 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3260 timestamp = self._parse_time_text(time_text)
3262 author = self._get_text(comment_renderer, 'authorText')
3263 author_id = try_get(comment_renderer,
3264 lambda x: x['authorEndpoint']['browseEndpoint']['browseId'], str)
3266 votes = parse_count(try_get(comment_renderer, (lambda x: x['voteCount']['simpleText'],
3267 lambda x: x['likeCount']), str)) or 0
3268 author_thumbnail = try_get(comment_renderer,
3269 lambda x: x['authorThumbnail']['thumbnails'][-1]['url'], str)
3271 author_is_uploader = try_get(comment_renderer, lambda x: x['authorIsChannelOwner'], bool)
3272 is_favorited = 'creatorHeart' in (try_get(
3273 comment_renderer, lambda x: x['actionButtons']['commentActionButtonsRenderer'], dict) or {})
3277 'timestamp': timestamp,
3278 'time_text': time_text,
3279 'like_count': votes,
3280 'is_favorited': is_favorited,
3282 'author_id': author_id,
3283 'author_thumbnail': author_thumbnail,
3284 'author_is_uploader': author_is_uploader,
3285 'parent': parent or 'root'
3288 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3290 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3292 def extract_header(contents):
3293 _continuation = None
3294 for content in contents:
3295 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3296 expected_comment_count = self._get_count(
3297 comments_header_renderer, 'countText', 'commentsCount')
3299 if expected_comment_count:
3300 tracker['est_total'] = expected_comment_count
3301 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3302 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3304 sort_menu_item = try_get(
3305 comments_header_renderer,
3306 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3307 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3309 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3310 if not _continuation:
3313 sort_text = str_or_none(sort_menu_item.get('title'))
3315 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3316 self.to_screen('Sorting comments by %s' % sort_text.lower())
3318 return _continuation
3320 def extract_thread(contents):
3322 tracker['current_page_thread'] = 0
3323 for content in contents:
3324 if not parent and tracker['total_parent_comments'] >= max_parents:
3326 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3327 comment_renderer = get_first(
3328 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3329 expected_type=dict, default={})
3331 comment = self._extract_comment(comment_renderer, parent)
3334 is_pinned = bool(traverse_obj(comment_renderer, 'pinnedCommentBadge'))
3335 comment_id = comment['id']
3337 tracker['pinned_comment_ids'].add(comment_id)
3338 # Sometimes YouTube may break and give us infinite looping comments.
3339 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3340 if comment_id in tracker['seen_comment_ids']:
3341 if comment_id in tracker['pinned_comment_ids'] and not is_pinned:
3342 # Pinned comments may appear a second time in newest first sort
3343 # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3345 self.report_warning('Detected YouTube comments looping. Stopping comment extraction as we probably cannot get any more.')
3348 tracker['seen_comment_ids'].add(comment['id'])
3350 tracker['running_total'] += 1
3351 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3354 # Attempt to get the replies
3355 comment_replies_renderer = try_get(
3356 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3358 if comment_replies_renderer:
3359 tracker['current_page_thread'] += 1
3360 comment_entries_iter = self._comment_entries(
3361 comment_replies_renderer, ytcfg, video_id,
3362 parent=comment.get('id'), tracker=tracker)
3363 yield from itertools.islice(comment_entries_iter, min(
3364 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3366 # Keeps track of counts across recursive calls
3371 current_page_thread=0,
3372 total_parent_comments=0,
3373 total_reply_comments=0,
3374 seen_comment_ids=set(),
3375 pinned_comment_ids=set()
3379 # YouTube comments have a max depth of 2
3380 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3382 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3383 'Set max replies in the max-comments extractor argument instead')
3384 if max_depth == 1 and parent:
3387 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
3388 lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
3390 continuation = self._extract_continuation(root_continuation_data)
3393 is_forced_continuation = False
3394 is_first_continuation = parent is None
3395 if is_first_continuation and not continuation:
3396 # Sometimes you can get comments by generating the continuation yourself,
3397 # even if YouTube initially reports them being disabled - e.g. stories comments.
3398 # Note: if the comment section is actually disabled, YouTube may return a response with
3399 # required check_get_keys missing. So we will disable that check initially in this case.
3400 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3401 is_forced_continuation = True
3403 for page_num in itertools.count(0):
3404 if not continuation:
3406 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3407 comment_prog_str = f"({tracker['running_total']}
/{tracker['est_total']}
)"
3409 if is_first_continuation:
3410 note_prefix = 'Downloading comment section API JSON'
3412 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3413 tracker['current_page_thread'], comment_prog_str)
3415 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
3416 ' ' if parent else '', ' replies' if parent else '',
3417 page_num, comment_prog_str)
3419 response = self._extract_response(
3420 item_id=None, query=continuation,
3421 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3422 check_get_keys='onResponseReceivedEndpoints' if not is_forced_continuation else None)
3423 except ExtractorError as e:
3424 # Ignore incomplete data error for replies if retries didn't work.
3425 # This is to allow any other parent comments and comment threads to be downloaded.
3426 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3427 if 'incomplete data' in str(e).lower() and parent and self.get_param('ignoreerrors') is True:
3428 self.report_warning(
3429 'Received incomplete data for a comment reply thread and retrying did not help. '
3430 'Ignoring to let other comments be downloaded.')
3433 is_forced_continuation = False
3434 continuation_contents = traverse_obj(
3435 response, 'onResponseReceivedEndpoints', expected_type=list, default=[])
3438 for continuation_section in continuation_contents:
3439 continuation_items = traverse_obj(
3440 continuation_section,
3441 (('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems'),
3442 get_all=False, expected_type=list) or []
3443 if is_first_continuation:
3444 continuation = extract_header(continuation_items)
3445 is_first_continuation = False
3450 for entry in extract_thread(continuation_items):
3454 continuation = self._extract_continuation({'contents': continuation_items})
3458 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3459 if message and not parent and tracker['running_total'] == 0:
3460 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3461 raise self.CommentsDisabled
3464 def _generate_comment_continuation(video_id):
3466 Generates initial comment section continuation token from given video id
3468 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3469 return base64.b64encode(token.encode()).decode()
3471 def _get_comments(self, ytcfg, video_id, contents, webpage):
3472 """Entry for comment extraction"""
3473 def _real_comment_extract(contents):
3475 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3476 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3477 yield from self._comment_entries(renderer, ytcfg, video_id)
3479 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3480 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3483 def _get_checkok_params():
3484 return {'contentCheckOk': True, 'racyCheckOk': True}
3487 def _generate_player_context(cls, sts=None):
3489 'html5Preference': 'HTML5_PREF_WANTS',
3492 context['signatureTimestamp'] = sts
3494 'playbackContext': {
3495 'contentPlaybackContext': context
3497 **cls._get_checkok_params()
3501 def _is_agegated(player_response):
3502 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3505 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3506 AGE_GATE_REASONS = (
3507 'confirm your age', 'age-restricted', 'inappropriate', # reason
3508 'age_verification_required', 'age_check_required', # status
3510 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3513 def _is_unplayable(player_response):
3514 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3516 _STORY_PLAYER_PARAMS = '8AEB'
3518 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3520 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3521 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3522 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3523 headers = self.generate_api_headers(
3524 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3527 'videoId': video_id,
3529 if smuggled_data.get('is_story') or _split_innertube_client(client)[0] == 'android':
3530 yt_query['params'] = self._STORY_PLAYER_PARAMS
3532 yt_query.update(self._generate_player_context(sts))
3533 return self._extract_response(
3534 item_id=video_id, ep='player', query=yt_query,
3535 ytcfg=player_ytcfg, headers=headers, fatal=True,
3536 default_client=client,
3537 note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
3540 def _get_requested_clients(self, url, smuggled_data):
3541 requested_clients = []
3542 default = ['android', 'web']
3543 allowed_clients = sorted(
3544 (client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'),
3545 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3546 for client in self._configuration_arg('player_client'):
3547 if client in allowed_clients:
3548 requested_clients.append(client)
3549 elif client == 'default':
3550 requested_clients.extend(default)
3551 elif client == 'all':
3552 requested_clients.extend(allowed_clients)
3554 self.report_warning(f'Skipping unsupported client {client}')
3555 if not requested_clients:
3556 requested_clients = default
3558 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3559 requested_clients.extend(
3560 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3562 return orderedSet(requested_clients)
3564 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3567 initial_pr = self._search_json(
3568 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3570 all_clients = set(clients)
3571 clients = clients[::-1]
3574 def append_client(*client_names):
3575 """ Append the first client name that exists but not already used """
3576 for client_name in client_names:
3577 actual_client = _split_innertube_client(client_name)[0]
3578 if actual_client in INNERTUBE_CLIENTS:
3579 if actual_client not in all_clients:
3580 clients.append(client_name)
3581 all_clients.add(actual_client)
3584 # Android player_response does not have microFormats which are needed for
3585 # extraction of some data. So we return the initial_pr with formats
3586 # stripped out even if not requested by the user
3587 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3589 pr = dict(initial_pr)
3590 pr['streamingData'] = None
3594 tried_iframe_fallback = False
3597 client, base_client, variant = _split_innertube_client(clients.pop())
3598 player_ytcfg = master_ytcfg if client == 'web' else {}
3599 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3600 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3602 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3603 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3604 if 'js' in self._configuration_arg('player_skip'):
3605 require_js_player = False
3608 if not player_url and not tried_iframe_fallback and require_js_player:
3609 player_url = self._download_player_url(video_id)
3610 tried_iframe_fallback = True
3613 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3614 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3615 except ExtractorError as e:
3617 self.report_warning(last_error)
3622 # YouTube may return a different video player response than expected.
3623 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3624 pr_video_id = traverse_obj(pr, ('videoDetails', 'videoId'))
3625 if pr_video_id and pr_video_id != video_id:
3626 self.report_warning(
3627 f'Skipping player response from {client} client (got player response for video "{pr_video_id}
" instead of "{video_id}
")' + bug_reports_message())
3629 # Save client name for introspection later
3630 name = short_client_name(client)
3631 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3632 sd[STREAMING_DATA_CLIENT_NAME] = name
3633 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3634 f[STREAMING_DATA_CLIENT_NAME] = name
3637 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3638 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3639 append_client(f'{base_client}_creator')
3640 elif self._is_agegated(pr):
3641 if variant == 'tv_embedded':
3642 append_client(f'{base_client}_embedded')
3644 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3649 self.report_warning(last_error)
3650 return prs, player_url
3652 def _needs_live_processing(self, live_status, duration):
3653 if (live_status == 'is_live' and self.get_param('live_from_start')
3654 or live_status == 'post_live' and (duration or 0) > 4 * 3600):
3657 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3658 CHUNK_SIZE = 10 << 20
3659 itags, stream_ids = collections.defaultdict(set), []
3660 itag_qualities, res_qualities = {}, {0: None}
3662 # Normally tiny is the smallest video-only formats. But
3663 # audio-only formats with unknown quality may get tagged as tiny
3665 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3666 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
3668 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3669 all_formats = self._configuration_arg('include_duplicate_formats')
3671 def build_fragments(f):
3673 'url': update_url_query(f['url'], {
3674 'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}'
3676 } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3678 for fmt in streaming_formats:
3679 if fmt.get('targetDurationSec'):
3682 itag = str_or_none(fmt.get('itag'))
3683 audio_track = fmt.get('audioTrack') or {}
3684 stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3686 if stream_id in stream_ids:
3689 quality = fmt.get('quality')
3690 height = int_or_none(fmt.get('height'))
3691 if quality == 'tiny' or not quality:
3692 quality = fmt.get('audioQuality', '').lower() or quality
3693 # The 3gp format (17) in android client has a quality of "small
",
3694 # but is actually worse than other formats
3699 itag_qualities[itag] = quality
3701 res_qualities[height] = quality
3702 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3703 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3704 # number of fragment that would subsequently requested with (`&sq=N`)
3705 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3708 fmt_url = fmt.get('url')
3710 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3711 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3712 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3713 if not all((sc, fmt_url, player_url, encrypted_sig)):
3716 fmt_url += '&%s=%s' % (
3717 traverse_obj(sc, ('sp', -1)) or 'signature',
3718 self._decrypt_signature(encrypted_sig, video_id, player_url)
3720 except ExtractorError as e:
3721 self.report_warning('Signature extraction failed: Some formats may be missing',
3722 video_id=video_id, only_once=True)
3723 self.write_debug(e, only_once=True)
3726 query = parse_qs(fmt_url)
3730 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3731 fmt_url = update_url_query(fmt_url, {
3732 'n': decrypt_nsig(query['n'][0], video_id, player_url)
3734 except ExtractorError as e:
3736 if isinstance(e, JSInterpreter.Exception):
3737 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3738 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3740 self.report_warning(
3741 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3742 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3743 self.write_debug(e, only_once=True)
3745 self.report_warning(
3746 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3747 video_id=video_id, only_once=True)
3750 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3751 language_preference = (
3752 10 if audio_track.get('audioIsDefault') and 10
3753 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3755 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3756 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3757 # Make sure to avoid false positives with small duration differences.
3758 # E.g. __2ABJjxzNo, ySuUZEjARPY
3759 is_damaged = try_get(fmt, lambda x: float(x['approxDurationMs']) / duration < 500)
3761 self.report_warning(
3762 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3764 client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3766 'asr': int_or_none(fmt.get('audioSampleRate')),
3767 'filesize': int_or_none(fmt.get('contentLength')),
3768 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3769 'format_note': join_nonempty(
3770 join_nonempty(audio_track.get('displayName'),
3771 language_preference > 0 and ' (default)', delim=''),
3772 fmt.get('qualityLabel') or quality.replace('audio_quality_', ''),
3773 fmt.get('isDrc') and 'DRC',
3774 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3775 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3776 throttled and 'THROTTLED', is_damaged and 'DAMAGED',
3777 (self.get_param('verbose') or all_formats) and client_name,
3779 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3780 'source_preference': -10 if throttled else -5 if itag == '22' else -1,
3781 'fps': int_or_none(fmt.get('fps')) or None,
3782 'audio_channels': fmt.get('audioChannels'),
3784 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3785 'has_drm': bool(fmt.get('drmFamilies')),
3788 'width': int_or_none(fmt.get('width')),
3789 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3790 'desc' if language_preference < -1 else '') or None,
3791 'language_preference': language_preference,
3792 # Strictly de-prioritize damaged and 3gp formats
3793 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3795 mime_mobj = re.match(
3796 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3798 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3799 dct.update(parse_codecs(mime_mobj.group(2)))
3801 itags[itag].add(('https
', dct.get('language
')))
3802 stream_ids.append(stream_id)
3803 single_stream = 'none
' in (dct.get('acodec
'), dct.get('vcodec
'))
3804 if single_stream and dct.get('ext
'):
3805 dct['container
'] = dct['ext
'] + '_dash
'
3807 if all_formats and dct['filesize
']:
3810 'format_id
': f'{dct["format_id"]}
-dashy
' if all_formats else dct['format_id
'],
3811 'protocol
': 'http_dash_segments
',
3812 'fragments
': build_fragments(dct),
3814 dct['downloader_options
'] = {'http_chunk_size': CHUNK_SIZE}
3817 needs_live_processing = self._needs_live_processing(live_status, duration)
3818 skip_bad_formats = not self._configuration_arg('include_incomplete_formats
')
3820 skip_manifests = set(self._configuration_arg('skip
'))
3821 if (not self.get_param('youtube_include_hls_manifest
', True)
3822 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3823 or needs_live_processing and skip_bad_formats):
3824 skip_manifests.add('hls
')
3826 if not self.get_param('youtube_include_dash_manifest
', True):
3827 skip_manifests.add('dash
')
3828 if self._configuration_arg('include_live_dash
'):
3829 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3830 'Use include_incomplete_formats extractor argument instead
')
3831 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3832 skip_manifests.add('dash
')
3834 def process_manifest_format(f, proto, client_name, itag):
3835 key = (proto, f.get('language
'))
3836 if not all_formats and key in itags[itag]:
3838 itags[itag].add(key)
3840 if itag and all_formats:
3841 f['format_id
'] = f'{itag}
-{proto}
'
3842 elif any(p != proto for p, _ in itags[itag]):
3843 f['format_id
'] = f'{itag}
-{proto}
'
3845 f['format_id
'] = itag
3847 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
3848 if f['quality
'] == -1 and f.get('height
'):
3849 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
3850 if self.get_param('verbose
'):
3851 f['format_note
'] = join_nonempty(f.get('format_note
'), client_name, delim=', ')
3855 for sd in streaming_data:
3856 client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
3858 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
3859 if hls_manifest_url:
3860 fmts, subs = self._extract_m3u8_formats_and_subtitles(
3861 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
3862 subtitles = self._merge_subtitles(subs, subtitles)
3864 if process_manifest_format(f, 'hls
', client_name, self._search_regex(
3865 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
3868 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
3869 if dash_manifest_url:
3870 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
3871 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
3873 if process_manifest_format(f, 'dash
', client_name, f['format_id
']):
3874 f['filesize
'] = int_or_none(self._search_regex(
3875 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
3876 if needs_live_processing:
3877 f['is_from_start
'] = True
3882 def _extract_storyboard(self, player_responses, duration):
3884 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
3885 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
3889 for i, args in enumerate(spec):
3890 args = args.split('#')
3891 counts
= list(map(int_or_none
, args
[:5]))
3892 if len(args
) != 8 or not all(counts
):
3893 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
3895 width
, height
, frame_count
, cols
, rows
= counts
3898 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
3899 fragment_count
= frame_count
/ (cols
* rows
)
3900 fragment_duration
= duration
/ fragment_count
3902 'format_id': f
'sb{i}',
3903 'format_note': 'storyboard',
3905 'protocol': 'mhtml',
3911 'fps': frame_count
/ duration
,
3915 'url': url
.replace('$M', str(j
)),
3916 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
3917 } for j
in range(math
.ceil(fragment_count
))],
3920 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
3922 if 'webpage' not in self
._configuration
_arg
('player_skip'):
3923 query
= {'bpctr': '9999999999', 'has_verified': '1'}
3924 if smuggled_data
.get('is_story'):
3925 query
['pp'] = self
._STORY
_PLAYER
_PARAMS
3926 webpage
= self
._download
_webpage
(
3927 webpage_url
, video_id
, fatal
=False, query
=query
)
3929 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
3931 player_responses
, player_url
= self
._extract
_player
_responses
(
3932 self
._get
_requested
_clients
(url
, smuggled_data
),
3933 video_id
, webpage
, master_ytcfg
, smuggled_data
)
3935 return webpage
, master_ytcfg
, player_responses
, player_url
3937 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
3938 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
3939 is_live
= get_first(video_details
, 'isLive')
3941 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
3942 live_content
= get_first(video_details
, 'isLiveContent')
3943 is_upcoming
= get_first(video_details
, 'isUpcoming')
3944 post_live
= get_first(video_details
, 'isPostLiveDvr')
3945 live_status
= ('post_live' if post_live
3946 else 'is_live' if is_live
3947 else 'is_upcoming' if is_upcoming
3948 else 'was_live' if live_content
3949 else 'not_live' if False in (is_live
, live_content
)
3951 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'))
3952 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
3954 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
3956 def _real_extract(self
, url
):
3957 url
, smuggled_data
= unsmuggle_url(url
, {})
3958 video_id
= self
._match
_id
(url
)
3960 base_url
= self
.http_scheme() + '//www.youtube.com/'
3961 webpage_url
= base_url
+ 'watch?v=' + video_id
3963 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
3965 playability_statuses
= traverse_obj(
3966 player_responses
, (..., 'playabilityStatus'), expected_type
=dict)
3968 trailer_video_id
= get_first(
3969 playability_statuses
,
3970 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
3972 if trailer_video_id
:
3973 return self
.url_result(
3974 trailer_video_id
, self
.ie_key(), trailer_video_id
)
3976 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
3977 if webpage
else (lambda x
: None))
3979 video_details
= traverse_obj(player_responses
, (..., 'videoDetails'), expected_type
=dict)
3980 microformats
= traverse_obj(
3981 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
3984 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
3985 video_title
= (self
._preferred
_lang
and translated_title
3986 or get_first(video_details
, 'title') # primary
3988 or search_meta(['og:title', 'twitter:title', 'title']))
3989 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
3990 original_description
= get_first(video_details
, 'shortDescription')
3991 video_description
= (
3992 self
._preferred
_lang
and translated_description
3993 # If original description is blank, it will be an empty string.
3994 # Do not prefer translated description in this case.
3995 or original_description
if original_description
is not None else translated_description
)
3997 multifeed_metadata_list
= get_first(
3999 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
4001 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
4002 if self
.get_param('noplaylist'):
4003 self
.to_screen('Downloading just video %s because of --no-playlist' % video_id
)
4007 for feed
in multifeed_metadata_list
.split(','):
4008 # Unquote should take place before split on comma (,) since textual
4009 # fields may contain comma as well (see
4010 # https://github.com/ytdl-org/youtube-dl/issues/8536)
4011 feed_data
= urllib
.parse
.parse_qs(
4012 urllib
.parse
.unquote_plus(feed
))
4014 def feed_entry(name
):
4016 feed_data
, lambda x
: x
[name
][0], str)
4018 feed_id
= feed_entry('id')
4021 feed_title
= feed_entry('title')
4024 title
+= ' (%s)' % feed_title
4026 '_type': 'url_transparent',
4027 'ie_key': 'Youtube',
4029 '%swatch?v=%s' % (base_url
, feed_data
['id'][0]),
4030 {'force_singlefeed': True}
),
4033 feed_ids
.append(feed_id
)
4035 'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
4036 % (', '.join(feed_ids
), video_id
))
4037 return self
.playlist_result(
4038 entries
, video_id
, video_title
, video_description
)
4040 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
4041 or int_or_none(get_first(microformats
, 'lengthSeconds'))
4042 or parse_duration(search_meta('duration')) or None)
4044 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
4045 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
4046 if live_status
== 'post_live':
4047 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
4050 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
4051 self
.report_drm(video_id
)
4053 playability_statuses
,
4054 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
4055 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
4056 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
4058 if subreason
== 'The uploader has not made this video available in your country.':
4059 countries
= get_first(microformats
, 'availableCountries')
4061 regions_allowed
= search_meta('regionsAllowed')
4062 countries
= regions_allowed
.split(',') if regions_allowed
else None
4063 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
4064 reason
+= f
'. {subreason}'
4066 self
.raise_no_formats(reason
, expected
=True)
4068 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
4069 if not keywords
and webpage
:
4071 unescapeHTML(m
.group('content'))
4072 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
4073 for keyword
in keywords
:
4074 if keyword
.startswith('yt:stretch='):
4075 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
4077 # NB: float is intentional for forcing float division
4078 w
, h
= (float(v
) for v
in mobj
.groups())
4082 if f
.get('vcodec') != 'none':
4083 f
['stretched_ratio'] = ratio
4085 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
4086 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
4089 'url': thumbnail_url
,
4091 original_thumbnails
= thumbnails
.copy()
4093 # The best resolution thumbnails sometimes does not appear in the webpage
4094 # See: https://github.com/yt-dlp/yt-dlp/issues/340
4095 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4097 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4098 # in resolution, these are not the custom thumbnail. So de-prioritize them
4099 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4100 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3'
4102 n_thumbnail_names
= len(thumbnail_names
)
4104 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4105 video_id
=video_id
, name
=name
, ext
=ext
,
4106 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
4107 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
4108 for thumb
in thumbnails
:
4109 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
4110 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
4111 self
._remove
_duplicate
_formats
(thumbnails
)
4112 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
4114 category
= get_first(microformats
, 'category') or search_meta('genre')
4115 channel_id
= self
.ucid_or_none(str_or_none(
4116 get_first(video_details
, 'channelId')
4117 or get_first(microformats
, 'externalChannelId')
4118 or search_meta('channelId')))
4119 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
4121 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
4122 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
4123 if not duration
and live_end_time
and live_start_time
:
4124 duration
= live_end_time
- live_start_time
4126 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
4128 def is_bad_format(fmt
):
4129 if needs_live_processing
and not fmt
.get('is_from_start'):
4131 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
4132 and fmt
.get('protocol') == 'http_dash_segments'):
4135 for fmt
in filter(is_bad_format
, formats
):
4136 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4137 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 4 hours)', delim
=' ')
4139 if needs_live_processing
:
4140 self
._prepare
_live
_from
_start
_formats
(
4141 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4143 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4145 channel_handle
= self
.handle_from_url(owner_profile_url
)
4149 'title': video_title
,
4151 'thumbnails': thumbnails
,
4152 # The best thumbnail that we are sure exists. Prevents unnecessary
4153 # URL checking if user don't care about getting the best possible thumbnail
4154 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4155 'description': video_description
,
4156 'channel_id': channel_id
,
4157 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None),
4158 'duration': duration
,
4159 'view_count': int_or_none(
4160 get_first((video_details
, microformats
), (..., 'viewCount'))
4161 or search_meta('interactionCount')),
4162 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4163 'age_limit': 18 if (
4164 get_first(microformats
, 'isFamilySafe') is False
4165 or search_meta('isFamilyFriendly') == 'false'
4166 or search_meta('og:restrictions:age') == '18+') else 0,
4167 'webpage_url': webpage_url
,
4168 'categories': [category
] if category
else None,
4170 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4171 'live_status': live_status
,
4172 'release_timestamp': live_start_time
,
4173 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4174 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto')
4178 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4180 def get_lang_code(track
):
4181 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4182 or track
.get('languageCode'))
4184 # Converted into dicts to remove duplicates
4186 get_lang_code(sub
): sub
4187 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...))}
4188 translation_languages
= {
4189 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4190 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...))}
4192 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4193 lang_subs
= container
.setdefault(lang_code
, [])
4194 for fmt
in self
._SUBTITLE
_FORMATS
:
4200 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4204 # NB: Constructing the full subtitle dictionary is slow
4205 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4206 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4207 for lang_code
, caption_track
in captions
.items():
4208 base_url
= caption_track
.get('baseUrl')
4209 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4212 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4213 if caption_track
.get('kind') != 'asr':
4217 subtitles
, base_url
, lang_code
, lang_name
, {})
4218 if not caption_track
.get('isTranslatable'):
4220 for trans_code
, trans_name
in translation_languages
.items():
4223 orig_trans_code
= trans_code
4224 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4225 if not get_translated_subs
:
4227 trans_code
+= f
'-{lang_code}'
4228 trans_name
+= format_field(lang_name
, None, ' from %s')
4229 # Add an "-orig" label to the original language so that it can be distinguished.
4230 # The subs are returned without "-orig" as well for compatibility
4231 if lang_code
== f
'a-{orig_trans_code}':
4233 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4234 # Setting tlang=lang returns damaged subtitles.
4235 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4236 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4238 info
['automatic_captions'] = automatic_captions
4239 info
['subtitles'] = subtitles
4241 parsed_url
= urllib
.parse
.urlparse(url
)
4242 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4243 query
= urllib
.parse
.parse_qs(component
)
4244 for k
, v
in query
.items():
4245 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4247 if d_k
not in info
and k
in s_ks
:
4248 info
[d_k
] = parse_duration(query
[k
][0])
4250 # Youtube Music Auto-generated description
4251 if video_description
:
4254 (?P<track>[^·\n]+)·(?P<artist>[^\n]+)\n+
4256 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4257 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4258 (.+?\nArtist\s*:\s*(?P<clean_artist>[^\n]+))?
4259 .+\nAuto-generated\ by\ YouTube\.\s*$
4260 ''', video_description
)
4262 release_year
= mobj
.group('release_year')
4263 release_date
= mobj
.group('release_date')
4265 release_date
= release_date
.replace('-', '')
4266 if not release_year
:
4267 release_year
= release_date
[:4]
4269 'album': mobj
.group('album'.strip()),
4270 'artist': mobj
.group('clean_artist') or ', '.join(a
.strip() for a
in mobj
.group('artist').split('·')),
4271 'track': mobj
.group('track').strip(),
4272 'release_date': release_date
,
4273 'release_year': int_or_none(release_year
),
4278 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4279 if not traverse_obj(initial_data
, 'contents'):
4280 self
.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4282 if not initial_data
:
4283 query
= {'videoId': video_id}
4284 query
.update(self
._get
_checkok
_params
())
4285 initial_data
= self
._extract
_response
(
4286 item_id
=video_id
, ep
='next', fatal
=False,
4287 ytcfg
=master_ytcfg
, query
=query
, check_get_keys
='contents',
4288 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4289 note
='Downloading initial data API JSON')
4291 info
['comment_count'] = traverse_obj(initial_data
, (
4292 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4293 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount'
4295 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4296 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo'
4297 ), expected_type
=self
._get
_count
, get_all
=False)
4299 try: # This will error if there is no livechat
4300 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4301 except (KeyError, IndexError, TypeError):
4304 info
.setdefault('subtitles', {})['live_chat'] = [{
4305 # url is needed to set cookies
4306 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4307 'video_id': video_id
,
4309 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4310 else 'youtube_live_chat_replay'),
4314 info
['chapters'] = (
4315 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4316 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4317 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4320 contents
= traverse_obj(
4321 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4322 expected_type
=list, default
=[])
4324 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4326 stl
= vpir
.get('superTitleLink')
4328 stl
= self
._get
_text
(stl
)
4331 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4332 info
['location'] = stl
4334 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4337 'series': mobj
.group(1),
4338 'season_number': int(mobj
.group(2)),
4339 'episode_number': int(mobj
.group(3)),
4341 for tlb
in (try_get(
4343 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4347 tlb
, ('toggleButtonRenderer', ...),
4348 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4350 for getter
, regex
in [(
4351 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4352 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4353 lambda x
: x
['accessibility'],
4354 lambda x
: x
['accessibilityData']['accessibilityData'],
4355 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4356 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4358 mobj
= re
.match(regex
, label
)
4360 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4362 sbr_tooltip
= try_get(
4363 vpir
, lambda x
: x
['sentimentBar']['sentimentBarRenderer']['tooltip'])
4365 like_count
, dislike_count
= sbr_tooltip
.split(' / ')
4367 'like_count': str_to_int(like_count
),
4368 'dislike_count': str_to_int(dislike_count
),
4370 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4372 vc
= self
._get
_count
(vcr
, 'viewCount')
4373 # Upcoming premieres with waiting count are treated as live here
4374 if vcr
.get('isLive'):
4375 info
['concurrent_view_count'] = vc
4376 elif info
.get('view_count') is None:
4377 info
['view_count'] = vc
4379 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4381 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4383 'channel': self
._get
_text
(vor
, 'title'),
4384 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4386 if not channel_handle
:
4387 channel_handle
= self
.handle_from_url(
4389 ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4390 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4391 {str}
), get_all
=False))
4395 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4397 multiple_songs
= False
4399 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4400 multiple_songs
= True
4403 mrr
= row
.get('metadataRowRenderer') or {}
4404 mrr_title
= mrr
.get('title')
4407 mrr_title
= self
._get
_text
(mrr
, 'title')
4408 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4409 if mrr_title
== 'License':
4410 info
['license'] = mrr_contents_text
4411 elif not multiple_songs
:
4412 if mrr_title
== 'Album':
4413 info
['album'] = mrr_contents_text
4414 elif mrr_title
== 'Artist':
4415 info
['artist'] = mrr_contents_text
4416 elif mrr_title
== 'Song':
4417 info
['track'] = mrr_contents_text
4420 'uploader': info
.get('channel'),
4421 'uploader_id': channel_handle
,
4422 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4424 # The upload date for scheduled, live and past live streams / premieres in microformats
4425 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4426 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4428 unified_strdate(get_first(microformats
, 'uploadDate'))
4429 or unified_strdate(search_meta('uploadDate')))
4430 if not upload_date
or (
4431 live_status
in ('not_live', None)
4432 and 'no-youtube-prefer-utc-upload-date' not in self
.get_param('compat_opts', [])
4434 upload_date
= strftime_or_none(
4435 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText')), '%Y%m%d') or upload_date
4436 info
['upload_date'] = upload_date
4438 for s_k
, d_k
in [('artist', 'creator'), ('track', 'alt_title')]:
4443 badges
= self
._extract
_badges
(traverse_obj(contents
, (..., 'videoPrimaryInfoRenderer'), get_all
=False))
4445 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4446 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4448 info
['availability'] = (
4449 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4450 else self
._availability
(
4451 is_private
=is_private
,
4453 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4454 or False if initial_data
and is_private
is not None else None),
4455 needs_subscription
=(
4456 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4457 or False if initial_data
and is_private
is not None else None),
4458 needs_auth
=info
['age_limit'] >= 18,
4459 is_unlisted
=None if is_private
is None else (
4460 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4461 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4463 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4465 self
.mark_watched(video_id
, player_responses
)
4470 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4472 def passthrough_smuggled_data(func
):
4473 def _smuggle(info
, smuggled_data
):
4474 if info
.get('_type') not in ('url', 'url_transparent'):
4476 if smuggled_data
.get('is_music_url'):
4477 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4478 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4479 smuggled_data
.pop('is_music_url')
4480 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4482 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4485 @functools.wraps(func
)
4486 def wrapper(self
, url
):
4487 url
, smuggled_data
= unsmuggle_url(url
, {})
4488 if self
.is_music_url(url
):
4489 smuggled_data
['is_music_url'] = True
4490 info_dict
= func(self
, url
, smuggled_data
)
4492 _smuggle(info_dict
, smuggled_data
)
4493 if info_dict
.get('entries'):
4494 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4499 def _extract_basic_item_renderer(item
):
4500 # Modified from _extract_grid_item_renderer
4501 known_basic_renderers
= (
4502 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer'
4504 for key
, renderer
in item
.items():
4505 if not isinstance(renderer
, dict):
4507 elif key
in known_basic_renderers
:
4509 elif key
.startswith('grid') and key
.endswith('Renderer'):
4512 def _extract_channel_renderer(self
, renderer
):
4513 channel_id
= self
.ucid_or_none(renderer
['channelId'])
4514 title
= self
._get
_text
(renderer
, 'title')
4515 channel_url
= format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None)
4516 # As of 2023-03-01 YouTube doesn't use the channel handles on these renderers yet.
4517 # However we can expect them to change that in the future.
4518 channel_handle
= self
.handle_from_url(
4519 traverse_obj(renderer
, (
4520 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4521 ('browseEndpoint', 'canonicalBaseUrl')),
4522 {str}
), get_all
=False))
4527 'ie_key': YoutubeTabIE
.ie_key(),
4530 'channel_id': channel_id
,
4531 'channel_url': channel_url
,
4533 'uploader_id': channel_handle
,
4534 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4535 'channel_follower_count': self
._get
_count
(renderer
, 'subscriberCountText'),
4536 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
4537 'playlist_count': self
._get
_count
(renderer
, 'videoCountText'),
4538 'description': self
._get
_text
(renderer
, 'descriptionSnippet'),
4541 def _grid_entries(self
, grid_renderer
):
4542 for item
in grid_renderer
['items']:
4543 if not isinstance(item
, dict):
4545 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4546 if not isinstance(renderer
, dict):
4548 title
= self
._get
_text
(renderer
, 'title')
4551 playlist_id
= renderer
.get('playlistId')
4553 yield self
.url_result(
4554 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4555 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4559 video_id
= renderer
.get('videoId')
4561 yield self
._extract
_video
(renderer
)
4564 channel_id
= renderer
.get('channelId')
4566 yield self
._extract
_channel
_renderer
(renderer
)
4568 # generic endpoint URL support
4569 ep_url
= urljoin('https://www.youtube.com/', try_get(
4570 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4573 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4574 if ie
.suitable(ep_url
):
4575 yield self
.url_result(
4576 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4579 def _music_reponsive_list_entry(self
, renderer
):
4580 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4582 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4583 ie
=YoutubeIE
.ie_key(), video_id
=video_id
)
4584 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4586 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4588 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4589 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4590 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4591 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4592 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4594 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4595 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4597 def _shelf_entries_from_content(self
, shelf_renderer
):
4598 content
= shelf_renderer
.get('content')
4599 if not isinstance(content
, dict):
4601 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4603 # TODO: add support for nested playlists so each shelf is processed
4604 # as separate playlist
4605 # TODO: this includes only first N items
4606 yield from self
._grid
_entries
(renderer
)
4607 renderer
= content
.get('horizontalListRenderer')
4612 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4614 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4616 shelf_url
= urljoin('https://www.youtube.com', ep
)
4618 # Skipping links to another channels, note that checking for
4619 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4621 if skip_channels
and '/channels?' in shelf_url
:
4623 title
= self
._get
_text
(shelf_renderer
, 'title')
4624 yield self
.url_result(shelf_url
, video_title
=title
)
4625 # Shelf may not contain shelf URL, fallback to extraction from content
4626 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4628 def _playlist_entries(self
, video_list_renderer
):
4629 for content
in video_list_renderer
['contents']:
4630 if not isinstance(content
, dict):
4632 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4633 if not isinstance(renderer
, dict):
4635 video_id
= renderer
.get('videoId')
4638 yield self
._extract
_video
(renderer
)
4640 def _rich_entries(self
, rich_grid_renderer
):
4641 renderer
= traverse_obj(
4642 rich_grid_renderer
, ('content', ('videoRenderer', 'reelItemRenderer')), get_all
=False) or {}
4643 video_id
= renderer
.get('videoId')
4646 yield self
._extract
_video
(renderer
)
4648 def _video_entry(self
, video_renderer
):
4649 video_id
= video_renderer
.get('videoId')
4651 return self
._extract
_video
(video_renderer
)
4653 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4654 url
= urljoin('https://youtube.com', traverse_obj(
4655 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4657 return self
.url_result(
4658 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4660 def _post_thread_entries(self
, post_thread_renderer
):
4661 post_renderer
= try_get(
4662 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4663 if not post_renderer
:
4666 video_renderer
= try_get(
4667 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4668 video_id
= video_renderer
.get('videoId')
4670 entry
= self
._extract
_video
(video_renderer
)
4673 # playlist attachment
4674 playlist_id
= try_get(
4675 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4677 yield self
.url_result(
4678 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4679 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4680 # inline video links
4681 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4683 if not isinstance(run
, dict):
4686 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4689 if not YoutubeIE
.suitable(ep_url
):
4691 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4692 if video_id
== ep_video_id
:
4694 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4696 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4697 contents
= post_thread_continuation
.get('contents')
4698 if not isinstance(contents
, list):
4700 for content
in contents
:
4701 renderer
= content
.get('backstagePostThreadRenderer')
4702 if isinstance(renderer
, dict):
4703 yield from self
._post
_thread
_entries
(renderer
)
4705 renderer
= content
.get('videoRenderer')
4706 if isinstance(renderer
, dict):
4707 yield self
._video
_entry
(renderer
)
4710 def _rich_grid_entries(self, contents):
4711 for content in contents:
4712 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4714 entry = self._video_entry(video_renderer)
4719 def _report_history_entries(self
, renderer
):
4720 for url
in traverse_obj(renderer
, (
4721 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4722 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4723 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4724 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4726 def _extract_entries(self
, parent_renderer
, continuation_list
):
4727 # continuation_list is modified in-place with continuation_list = [continuation_token]
4728 continuation_list
[:] = [None]
4729 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4730 for content
in contents
:
4731 if not isinstance(content
, dict):
4733 is_renderer
= traverse_obj(
4734 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4737 if content
.get('richItemRenderer'):
4738 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4740 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4741 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4742 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4743 yield from self
._report
_history
_entries
(table
)
4744 continuation_list
[0] = self
._extract
_continuation
(table
)
4747 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4748 for isr_content
in isr_contents
:
4749 if not isinstance(isr_content
, dict):
4753 'playlistVideoListRenderer': self
._playlist
_entries
,
4754 'gridRenderer': self
._grid
_entries
,
4755 'reelShelfRenderer': self
._grid
_entries
,
4756 'shelfRenderer': self
._shelf
_entries
,
4757 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4758 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4759 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4760 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4761 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4762 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)]
4764 for key
, renderer
in isr_content
.items():
4765 if key
not in known_renderers
:
4767 for entry
in known_renderers
[key
](renderer
):
4770 continuation_list
[0] = self
._extract
_continuation
(renderer
)
4773 if not continuation_list
[0]:
4774 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
4776 if not continuation_list
[0]:
4777 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4779 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
4780 continuation_list
= [None]
4781 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
4782 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
4786 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
4787 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
4788 yield from extract_entries(parent_renderer
)
4789 continuation
= continuation_list
[0]
4791 for page_num
in itertools
.count(1):
4792 if not continuation
:
4794 headers
= self
.generate_api_headers(
4795 ytcfg
=ytcfg
, account_syncid
=account_syncid
, visitor_data
=visitor_data
)
4796 response
= self
._extract
_response
(
4797 item_id
=f
'{item_id} page {page_num}',
4798 query
=continuation
, headers
=headers
, ytcfg
=ytcfg
,
4799 check_get_keys
=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4803 # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
4804 # See: https://github.com/ytdl-org/youtube-dl/issues/28702
4805 visitor_data
= self
._extract
_visitor
_data
(response
) or visitor_data
4808 'videoRenderer': (self
._grid
_entries
, 'items'), # for membership tab
4809 'gridPlaylistRenderer': (self
._grid
_entries
, 'items'),
4810 'gridVideoRenderer': (self
._grid
_entries
, 'items'),
4811 'gridChannelRenderer': (self
._grid
_entries
, 'items'),
4812 'playlistVideoRenderer': (self
._playlist
_entries
, 'contents'),
4813 'itemSectionRenderer': (extract_entries
, 'contents'), # for feeds
4814 'richItemRenderer': (extract_entries
, 'contents'), # for hashtag
4815 'backstagePostThreadRenderer': (self
._post
_thread
_continuation
_entries
, 'contents'),
4816 'reportHistoryTableRowRenderer': (self
._report
_history
_entries
, 'rows'),
4817 'playlistVideoListContinuation': (self
._playlist
_entries
, None),
4818 'gridContinuation': (self
._grid
_entries
, None),
4819 'itemSectionContinuation': (self
._post
_thread
_continuation
_entries
, None),
4820 'sectionListContinuation': (extract_entries
, None), # for feeds
4823 continuation_items
= traverse_obj(response
, (
4824 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
4825 'appendContinuationItemsAction', 'continuationItems'
4826 ), 'continuationContents', get_all
=False)
4827 continuation_item
= traverse_obj(continuation_items
, 0, None, expected_type
=dict, default
={})
4829 video_items_renderer
= None
4830 for key
in continuation_item
.keys():
4831 if key
not in known_renderers
:
4833 func
, parent_key
= known_renderers
[key
]
4834 video_items_renderer
= {parent_key: continuation_items}
if parent_key
else continuation_items
4835 continuation_list
= [None]
4836 yield from func(video_items_renderer
)
4837 continuation
= continuation_list
[0] or self
._extract
_continuation
(video_items_renderer
)
4839 if not video_items_renderer
:
4843 def _extract_selected_tab(tabs
, fatal
=True):
4844 for tab_renderer
in tabs
:
4845 if tab_renderer
.get('selected'):
4848 raise ExtractorError('Unable to find selected tab')
4851 def _extract_tab_renderers(response
):
4852 return traverse_obj(
4853 response
, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type
=dict)
4855 def _extract_from_tabs(self
, item_id
, ytcfg
, data
, tabs
):
4856 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
4858 selected_tab
= self
._extract
_selected
_tab
(tabs
)
4859 metadata
['title'] += format_field(selected_tab
, 'title', ' - %s')
4860 metadata
['title'] += format_field(selected_tab
, 'expandedText', ' - %s')
4862 return self
.playlist_result(
4864 selected_tab
, metadata
['id'], ytcfg
,
4865 self
._extract
_account
_syncid
(ytcfg
, data
),
4866 self
._extract
_visitor
_data
(data
, ytcfg
)),
4869 def _extract_metadata_from_tabs(self
, item_id
, data
):
4870 info
= {'id': item_id}
4872 metadata_renderer
= traverse_obj(data
, ('metadata', 'channelMetadataRenderer'), expected_type
=dict)
4873 if metadata_renderer
:
4874 channel_id
= traverse_obj(metadata_renderer
, ('externalId', {self.ucid_or_none}
),
4875 ('channelUrl', {self.ucid_from_url}
))
4877 'channel': metadata_renderer
.get('title'),
4878 'channel_id': channel_id
,
4880 if info
['channel_id']:
4881 info
['id'] = info
['channel_id']
4883 metadata_renderer
= traverse_obj(data
, ('metadata', 'playlistMetadataRenderer'), expected_type
=dict)
4885 # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
4886 # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
4887 def _get_uncropped(url
):
4888 return url_or_none((url
or '').split('=')[0] + '=s0')
4890 avatar_thumbnails
= self
._extract
_thumbnails
(metadata_renderer
, 'avatar')
4891 if avatar_thumbnails
:
4892 uncropped_avatar
= _get_uncropped(avatar_thumbnails
[0]['url'])
4893 if uncropped_avatar
:
4894 avatar_thumbnails
.append({
4895 'url': uncropped_avatar
,
4896 'id': 'avatar_uncropped',
4900 channel_banners
= self
._extract
_thumbnails
(
4901 data
, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
4902 for banner
in channel_banners
:
4903 banner
['preference'] = -10
4906 uncropped_banner
= _get_uncropped(channel_banners
[0]['url'])
4907 if uncropped_banner
:
4908 channel_banners
.append({
4909 'url': uncropped_banner
,
4910 'id': 'banner_uncropped',
4914 # Deprecated - remove primary_sidebar_renderer when layout discontinued
4915 primary_sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer')
4916 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer'), expected_type
=dict)
4918 primary_thumbnails
= self
._extract
_thumbnails
(
4919 primary_sidebar_renderer
, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
4920 playlist_thumbnails
= self
._extract
_thumbnails
(
4921 playlist_header_renderer
, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
4924 'title': (traverse_obj(metadata_renderer
, 'title')
4925 or self
._get
_text
(data
, ('header', 'hashtagHeaderRenderer', 'hashtag'))
4927 'availability': self
._extract
_availability
(data
),
4928 'channel_follower_count': self
._get
_count
(data
, ('header', ..., 'subscriberCountText')),
4929 'description': try_get(metadata_renderer
, lambda x
: x
.get('description', '')),
4930 'tags': try_get(metadata_renderer
or {}, lambda x
: x
.get('keywords', '').split()),
4931 'thumbnails': (primary_thumbnails
or playlist_thumbnails
) + avatar_thumbnails
+ channel_banners
,
4935 traverse_obj(metadata_renderer
, (('vanityChannelUrl', ('ownerUrls', ...)), {self.handle_from_url}
), get_all
=False)
4936 or traverse_obj(data
, ('header', ..., 'channelHandleText', {self.handle_or_none}
), get_all
=False))
4940 'uploader_id': channel_handle
,
4941 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4943 # Playlist stats is a text runs array containing [video count, view count, last updated].
4944 # last updated or (view count and last updated) may be missing.
4945 playlist_stats
= get_first(
4946 (primary_sidebar_renderer
, playlist_header_renderer
), (('stats', 'briefStats', 'numVideosText'), ))
4948 last_updated_unix
= self
._parse
_time
_text
(
4949 self
._get
_text
(playlist_stats
, 2) # deprecated, remove when old layout discontinued
4950 or self
._get
_text
(playlist_header_renderer
, ('byline', 1, 'playlistBylineRenderer', 'text')))
4951 info
['modified_date'] = strftime_or_none(last_updated_unix
, '%Y%m%d')
4953 info
['view_count'] = self
._get
_count
(playlist_stats
, 1)
4954 if info
['view_count'] is None: # 0 is allowed
4955 info
['view_count'] = self
._get
_count
(playlist_header_renderer
, 'viewCountText')
4956 if info
['view_count'] is None:
4957 info
['view_count'] = self
._get
_count
(data
, (
4958 'contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., 'tabRenderer', 'content', 'sectionListRenderer',
4959 'contents', ..., 'itemSectionRenderer', 'contents', ..., 'channelAboutFullMetadataRenderer', 'viewCountText'))
4961 info
['playlist_count'] = self
._get
_count
(playlist_stats
, 0)
4962 if info
['playlist_count'] is None: # 0 is allowed
4963 info
['playlist_count'] = self
._get
_count
(playlist_header_renderer
, ('byline', 0, 'playlistBylineRenderer', 'text'))
4965 if not info
.get('channel_id'):
4966 owner
= traverse_obj(playlist_header_renderer
, 'ownerText')
4967 if not owner
: # Deprecated
4968 owner
= traverse_obj(
4969 self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarSecondaryInfoRenderer'),
4970 ('videoOwner', 'videoOwnerRenderer', 'title'))
4971 owner_text
= self
._get
_text
(owner
)
4972 browse_ep
= traverse_obj(owner
, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
4974 'channel': self
._search
_regex
(r
'^by (.+) and \d+ others?$', owner_text
, 'uploader', default
=owner_text
),
4975 'channel_id': self
.ucid_or_none(browse_ep
.get('browseId')),
4976 'uploader_id': self
.handle_from_url(urljoin('https://www.youtube.com', browse_ep
.get('canonicalBaseUrl')))
4980 'uploader': info
['channel'],
4981 'channel_url': format_field(info
.get('channel_id'), None, 'https://www.youtube.com/channel/%s', default
=None),
4982 'uploader_url': format_field(info
.get('uploader_id'), None, 'https://www.youtube.com/%s', default
=None),
4987 def _extract_inline_playlist(self
, playlist
, playlist_id
, data
, ytcfg
):
4988 first_id
= last_id
= response
= None
4989 for page_num
in itertools
.count(1):
4990 videos
= list(self
._playlist
_entries
(playlist
))
4993 start
= next((i
for i
, v
in enumerate(videos
) if v
['id'] == last_id
), -1) + 1
4994 if start
>= len(videos
):
4996 yield from videos
[start
:]
4997 first_id
= first_id
or videos
[0]['id']
4998 last_id
= videos
[-1]['id']
4999 watch_endpoint
= try_get(
5000 playlist
, lambda x
: x
['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
5001 headers
= self
.generate_api_headers(
5002 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5003 visitor_data
=self
._extract
_visitor
_data
(response
, data
, ytcfg
))
5005 'playlistId': playlist_id
,
5006 'videoId': watch_endpoint
.get('videoId') or last_id
,
5007 'index': watch_endpoint
.get('index') or len(videos
),
5008 'params': watch_endpoint
.get('params') or 'OAE%3D'
5010 response
= self
._extract
_response
(
5011 item_id
='%s page %d' % (playlist_id
, page_num
),
5012 query
=query
, ep
='next', headers
=headers
, ytcfg
=ytcfg
,
5013 check_get_keys
='contents'
5016 response
, lambda x
: x
['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
5018 def _extract_from_playlist(self
, item_id
, url
, data
, playlist
, ytcfg
):
5019 title
= playlist
.get('title') or try_get(
5020 data
, lambda x
: x
['titleText']['simpleText'], str)
5021 playlist_id
= playlist
.get('playlistId') or item_id
5023 # Delegating everything except mix playlists to regular tab-based playlist URL
5024 playlist_url
= urljoin(url
, try_get(
5025 playlist
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
5028 # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
5029 # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
5030 is_known_unviewable
= re
.fullmatch(r
'MLCT|RLTD[\w-]{22}', playlist_id
)
5032 if playlist_url
and playlist_url
!= url
and not is_known_unviewable
:
5033 return self
.url_result(
5034 playlist_url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
5037 return self
.playlist_result(
5038 self
._extract
_inline
_playlist
(playlist
, playlist_id
, data
, ytcfg
),
5039 playlist_id
=playlist_id
, playlist_title
=title
)
5041 def _extract_availability(self
, data
):
5043 Gets the availability of a given playlist/tab.
5044 Note: Unless YouTube tells us explicitly, we do not assume it is public
5045 @param data: response
5047 sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer') or {}
5048 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer')) or {}
5049 player_header_privacy
= playlist_header_renderer
.get('privacy')
5051 badges
= self
._extract
_badges
(sidebar_renderer
)
5053 # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
5054 privacy_setting_icon
= get_first(
5055 (playlist_header_renderer
, sidebar_renderer
),
5056 ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
5057 lambda _
, v
: v
['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
5060 microformats_is_unlisted
= traverse_obj(
5061 data
, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type
=bool)
5065 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
5066 or player_header_privacy
== 'PUBLIC'
5067 or privacy_setting_icon
== 'PRIVACY_PUBLIC')
5068 else self
._availability
(
5070 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
5071 or player_header_privacy
== 'PRIVATE' if player_header_privacy
is not None
5072 else privacy_setting_icon
== 'PRIVACY_PRIVATE' if privacy_setting_icon
is not None else None),
5074 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
5075 or player_header_privacy
== 'UNLISTED' if player_header_privacy
is not None
5076 else privacy_setting_icon
== 'PRIVACY_UNLISTED' if privacy_setting_icon
is not None
5077 else microformats_is_unlisted
if microformats_is_unlisted
is not None else None),
5078 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
5079 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
5083 def _extract_sidebar_info_renderer(data
, info_renderer
, expected_type
=dict):
5084 sidebar_renderer
= try_get(
5085 data
, lambda x
: x
['sidebar']['playlistSidebarRenderer']['items'], list) or []
5086 for item
in sidebar_renderer
:
5087 renderer
= try_get(item
, lambda x
: x
[info_renderer
], expected_type
)
5091 def _reload_with_unavailable_videos(self
, item_id
, data
, ytcfg
):
5093 Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
5095 is_playlist
= bool(traverse_obj(
5096 data
, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
5099 headers
= self
.generate_api_headers(
5100 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5101 visitor_data
=self
._extract
_visitor
_data
(data
, ytcfg
))
5103 'params': 'wgYCCAA=',
5104 'browseId': f
'VL{item_id}'
5106 return self
._extract
_response
(
5107 item_id
=item_id
, headers
=headers
, query
=query
,
5108 check_get_keys
='contents', fatal
=False, ytcfg
=ytcfg
,
5109 note
='Redownloading playlist API JSON with unavailable videos')
5111 @functools.cached_property
5112 def skip_webpage(self
):
5113 return 'webpage' in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key())
5115 def _extract_webpage(self
, url
, item_id
, fatal
=True):
5116 webpage
, data
= None, None
5117 for retry
in self
.RetryManager(fatal
=fatal
):
5119 webpage
= self
._download
_webpage
(url
, item_id
, note
='Downloading webpage')
5120 data
= self
.extract_yt_initial_data(item_id
, webpage
or '', fatal
=fatal
) or {}
5121 except ExtractorError
as e
:
5122 if isinstance(e
.cause
, network_exceptions
):
5123 if not isinstance(e
.cause
, urllib
.error
.HTTPError
) or e
.cause
.code
not in (403, 429):
5126 self
._error
_or
_warning
(e
, fatal
=fatal
)
5130 self
._extract
_and
_report
_alerts
(data
)
5131 except ExtractorError
as e
:
5132 self
._error
_or
_warning
(e
, fatal
=fatal
)
5135 # Sometimes youtube returns a webpage with incomplete ytInitialData
5136 # See: https://github.com/yt-dlp/yt-dlp/issues/116
5137 if not traverse_obj(data
, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
5138 retry
.error
= ExtractorError('Incomplete yt initial data received')
5141 return webpage
, data
5143 def _report_playlist_authcheck(self
, ytcfg
, fatal
=True):
5144 """Use if failed to extract ytcfg (and data) from initial webpage"""
5145 if not ytcfg
and self
.is_authenticated
:
5146 msg
= 'Playlists that require authentication may not extract correctly without a successful webpage download'
5147 if 'authcheck' not in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key()) and fatal
:
5148 raise ExtractorError(
5149 f
'{msg}. If you are not downloading private content, or '
5150 'your cookies are only for the first account and channel,'
5151 ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
5153 self
.report_warning(msg
, only_once
=True)
5155 def _extract_data(self
, url
, item_id
, ytcfg
=None, fatal
=True, webpage_fatal
=False, default_client
='web'):
5157 if not self
.skip_webpage
:
5158 webpage
, data
= self
._extract
_webpage
(url
, item_id
, fatal
=webpage_fatal
)
5159 ytcfg
= ytcfg
or self
.extract_ytcfg(item_id
, webpage
)
5160 # Reject webpage data if redirected to home page without explicitly requesting
5161 selected_tab
= self
._extract
_selected
_tab
(self
._extract
_tab
_renderers
(data
), fatal
=False) or {}
5162 if (url
!= 'https://www.youtube.com/feed/recommended'
5163 and selected_tab
.get('tabIdentifier') == 'FEwhat_to_watch' # Home page
5164 and 'no-youtube-channel-redirect' not in self
.get_param('compat_opts', [])):
5165 msg
= 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
5167 raise ExtractorError(msg
, expected
=True)
5168 self
.report_warning(msg
, only_once
=True)
5170 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=fatal
)
5171 data
= self
._extract
_tab
_endpoint
(url
, item_id
, ytcfg
, fatal
=fatal
, default_client
=default_client
)
5174 def _extract_tab_endpoint(self
, url
, item_id
, ytcfg
=None, fatal
=True, default_client
='web'):
5175 headers
= self
.generate_api_headers(ytcfg
=ytcfg
, default_client
=default_client
)
5176 resolve_response
= self
._extract
_response
(
5177 item_id
=item_id
, query
={'url': url}
, check_get_keys
='endpoint', headers
=headers
, ytcfg
=ytcfg
, fatal
=fatal
,
5178 ep
='navigation/resolve_url', note
='Downloading API parameters API JSON', default_client
=default_client
)
5179 endpoints
= {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5180 for ep_key
, ep
in endpoints
.items():
5181 params
= try_get(resolve_response
, lambda x
: x
['endpoint'][ep_key
], dict)
5183 return self
._extract
_response
(
5184 item_id
=item_id
, query
=params
, ep
=ep
, headers
=headers
,
5185 ytcfg
=ytcfg
, fatal
=fatal
, default_client
=default_client
,
5186 check_get_keys
=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5187 err_note
= 'Failed to resolve url (does the playlist exist?)'
5189 raise ExtractorError(err_note
, expected
=True)
5190 self
.report_warning(err_note
, item_id
)
5192 _SEARCH_PARAMS
= None
5194 def _search_results(self
, query
, params
=NO_DEFAULT
, default_client
='web'):
5195 data
= {'query': query}
5196 if params
is NO_DEFAULT
:
5197 params
= self
._SEARCH
_PARAMS
5199 data
['params'] = params
5202 ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5203 ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5205 ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5206 ('continuationContents', ),
5208 display_id
= f
'query "{query}"'
5209 check_get_keys
= tuple({keys[0] for keys in content_keys}
)
5210 ytcfg
= self
._download
_ytcfg
(default_client
, display_id
) if not self
.skip_webpage
else {}
5211 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=False)
5213 continuation_list
= [None]
5215 for page_num
in itertools
.count(1):
5216 data
.update(continuation_list
[0] or {})
5217 headers
= self
.generate_api_headers(
5218 ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(search
), default_client
=default_client
)
5219 search
= self
._extract
_response
(
5220 item_id
=f
'{display_id} page {page_num}', ep
='search', query
=data
,
5221 default_client
=default_client
, check_get_keys
=check_get_keys
, ytcfg
=ytcfg
, headers
=headers
)
5222 slr_contents
= traverse_obj(search
, *content_keys
)
5223 yield from self
._extract
_entries
({'contents': list(variadic(slr_contents))}
, continuation_list
)
5224 if not continuation_list
[0]:
5228 class YoutubeTabIE(YoutubeTabBaseInfoExtractor
):
5229 IE_DESC
= 'YouTube Tabs'
5230 _VALID_URL
= r
'''(?x:
5232 (?!consent\.)(?:\w+\.)?
5234 youtube(?:kids)?\.com|
5238 (?P<channel_type>channel|c|user|browse)/|
5241 (?:playlist|watch)\?.*?\blist=
5243 (?!(?:%(reserved_names)s)\b) # Direct URLs
5247 'reserved_names': YoutubeBaseInfoExtractor
._RESERVED
_NAMES
,
5248 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
5250 IE_NAME
= 'youtube:tab'
5253 'note': 'playlists, multipage',
5254 'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5255 'playlist_mincount': 94,
5257 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5258 'title': 'Igor Kleiner - Playlists',
5259 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5260 'uploader': 'Igor Kleiner',
5261 'uploader_id': '@IgorDataScience',
5262 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5263 'channel': 'Igor Kleiner',
5264 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5265 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5266 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5267 'channel_follower_count': int
5270 'note': 'playlists, multipage, different order',
5271 'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5272 'playlist_mincount': 94,
5274 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5275 'title': 'Igor Kleiner - Playlists',
5276 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5277 'uploader': 'Igor Kleiner',
5278 'uploader_id': '@IgorDataScience',
5279 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5280 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5281 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5282 'channel': 'Igor Kleiner',
5283 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5284 'channel_follower_count': int
5287 'note': 'playlists, series',
5288 'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5289 'playlist_mincount': 5,
5291 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5292 'title': '3Blue1Brown - Playlists',
5293 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5294 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5295 'channel': '3Blue1Brown',
5296 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5297 'uploader_id': '@3blue1brown',
5298 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5299 'uploader': '3Blue1Brown',
5300 'tags': ['Mathematics'],
5301 'channel_follower_count': int
5304 'note': 'playlists, singlepage',
5305 'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5306 'playlist_mincount': 4,
5308 'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5309 'title': 'ThirstForScience - Playlists',
5310 'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5311 'uploader': 'ThirstForScience',
5312 'uploader_url': 'https://www.youtube.com/@ThirstForScience',
5313 'uploader_id': '@ThirstForScience',
5314 'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5315 'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5317 'channel': 'ThirstForScience',
5318 'channel_follower_count': int
5321 'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5322 'only_matching': True,
5324 'note': 'basic, single video playlist',
5325 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5327 'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5328 'title': 'youtube-dl public playlist',
5332 'modified_date': '20201130',
5333 'channel': 'Sergey M.',
5334 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5335 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5336 'availability': 'public',
5337 'uploader': 'Sergey M.',
5338 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5339 'uploader_id': '@sergeym.6173',
5341 'playlist_count': 1,
5343 'note': 'empty playlist',
5344 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5346 'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5347 'title': 'youtube-dl empty playlist',
5349 'channel': 'Sergey M.',
5351 'modified_date': '20160902',
5352 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5353 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5354 'availability': 'public',
5355 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5356 'uploader_id': '@sergeym.6173',
5357 'uploader': 'Sergey M.',
5359 'playlist_count': 0,
5362 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5364 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5365 'title': 'lex will - Home',
5366 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5367 'uploader': 'lex will',
5368 'uploader_id': '@lexwill718',
5369 'channel': 'lex will',
5370 'tags': ['bible', 'history', 'prophesy'],
5371 'uploader_url': 'https://www.youtube.com/@lexwill718',
5372 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5373 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5374 'channel_follower_count': int
5376 'playlist_mincount': 2,
5378 'note': 'Videos tab',
5379 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5381 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5382 'title': 'lex will - Videos',
5383 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5384 'uploader': 'lex will',
5385 'uploader_id': '@lexwill718',
5386 'tags': ['bible', 'history', 'prophesy'],
5387 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5388 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5389 'uploader_url': 'https://www.youtube.com/@lexwill718',
5390 'channel': 'lex will',
5391 'channel_follower_count': int
5393 'playlist_mincount': 975,
5395 'note': 'Videos tab, sorted by popular',
5396 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5398 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5399 'title': 'lex will - Videos',
5400 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5401 'uploader': 'lex will',
5402 'uploader_id': '@lexwill718',
5403 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5404 'uploader_url': 'https://www.youtube.com/@lexwill718',
5405 'channel': 'lex will',
5406 'tags': ['bible', 'history', 'prophesy'],
5407 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5408 'channel_follower_count': int
5410 'playlist_mincount': 199,
5412 'note': 'Playlists tab',
5413 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5415 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5416 'title': 'lex will - Playlists',
5417 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5418 'uploader': 'lex will',
5419 'uploader_id': '@lexwill718',
5420 'uploader_url': 'https://www.youtube.com/@lexwill718',
5421 'channel': 'lex will',
5422 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5423 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5424 'tags': ['bible', 'history', 'prophesy'],
5425 'channel_follower_count': int
5427 'playlist_mincount': 17,
5429 'note': 'Community tab',
5430 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5432 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5433 'title': 'lex will - Community',
5434 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5435 'channel': 'lex will',
5436 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5437 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5438 'tags': ['bible', 'history', 'prophesy'],
5439 'channel_follower_count': int,
5440 'uploader_url': 'https://www.youtube.com/@lexwill718',
5441 'uploader_id': '@lexwill718',
5442 'uploader': 'lex will',
5444 'playlist_mincount': 18,
5446 'note': 'Channels tab',
5447 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5449 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5450 'title': 'lex will - Channels',
5451 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5452 'channel': 'lex will',
5453 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5454 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5455 'tags': ['bible', 'history', 'prophesy'],
5456 'channel_follower_count': int,
5457 'uploader_url': 'https://www.youtube.com/@lexwill718',
5458 'uploader_id': '@lexwill718',
5459 'uploader': 'lex will',
5461 'playlist_mincount': 12,
5463 'note': 'Search tab',
5464 'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5465 'playlist_mincount': 40,
5467 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5468 'title': '3Blue1Brown - Search - linear algebra',
5469 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5470 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5471 'tags': ['Mathematics'],
5472 'channel': '3Blue1Brown',
5473 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5474 'channel_follower_count': int,
5475 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5476 'uploader_id': '@3blue1brown',
5477 'uploader': '3Blue1Brown',
5480 'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5481 'only_matching': True,
5483 'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5484 'only_matching': True,
5486 'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5487 'only_matching': True,
5489 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5490 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5492 'title': '29C3: Not my department',
5493 'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5494 'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5497 'modified_date': '20150605',
5498 'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5499 'channel_url': 'https://www.youtube.com/channel/UCEPzS1rYsrkqzSLNp76nrcg',
5500 'channel': 'Christiaan008',
5501 'availability': 'public',
5502 'uploader_id': '@ChRiStIaAn008',
5503 'uploader': 'Christiaan008',
5504 'uploader_url': 'https://www.youtube.com/@ChRiStIaAn008',
5506 'playlist_count': 96,
5508 'note': 'Large playlist',
5509 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5511 'title': 'Uploads from Cauchemar',
5512 'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5513 'channel_url': 'https://www.youtube.com/channel/UCBABnxM4Ar9ten8Mdjj1j0Q',
5515 'modified_date': r
're:\d{8}',
5516 'channel': 'Cauchemar',
5519 'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5520 'availability': 'public',
5521 'uploader_id': '@Cauchemar89',
5522 'uploader': 'Cauchemar',
5523 'uploader_url': 'https://www.youtube.com/@Cauchemar89',
5525 'playlist_mincount': 1123,
5526 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5528 'note': 'even larger playlist, 8832 videos',
5529 'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5530 'only_matching': True,
5532 'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5533 'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5535 'title': 'Uploads from Interstellar Movie',
5536 'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5539 'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5540 'channel_url': 'https://www.youtube.com/channel/UCXw-G3eDE9trcvY2sBMM_aA',
5541 'channel': 'Interstellar Movie',
5543 'modified_date': r
're:\d{8}',
5544 'availability': 'public',
5545 'uploader_id': '@InterstellarMovie',
5546 'uploader': 'Interstellar Movie',
5547 'uploader_url': 'https://www.youtube.com/@InterstellarMovie',
5549 'playlist_mincount': 21,
5551 'note': 'Playlist with "show unavailable videos" button',
5552 'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5554 'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5555 'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5557 'channel': 'Phim Siêu Nhân Nhật Bản',
5560 'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5561 'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5562 'modified_date': r
're:\d{8}',
5563 'availability': 'public',
5564 'uploader_url': 'https://www.youtube.com/@phimsieunhannhatban',
5565 'uploader_id': '@phimsieunhannhatban',
5566 'uploader': 'Phim Siêu Nhân Nhật Bản',
5568 'playlist_mincount': 200,
5569 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5571 'note': 'Playlist with unavailable videos in page 7',
5572 'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5574 'title': 'Uploads from BlankTV',
5575 'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5576 'channel': 'BlankTV',
5577 'channel_url': 'https://www.youtube.com/channel/UC8l9frL61Yl5KFOl87nIm2w',
5578 'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5581 'modified_date': r
're:\d{8}',
5583 'availability': 'public',
5584 'uploader_id': '@blanktv',
5585 'uploader': 'BlankTV',
5586 'uploader_url': 'https://www.youtube.com/@blanktv',
5588 'playlist_mincount': 1000,
5589 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5591 'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5592 'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5594 'title': 'Data Analysis with Dr Mike Pound',
5595 'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5596 'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5599 'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5600 'channel_url': 'https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA',
5601 'channel': 'Computerphile',
5602 'availability': 'public',
5603 'modified_date': '20190712',
5604 'uploader_id': '@Computerphile',
5605 'uploader': 'Computerphile',
5606 'uploader_url': 'https://www.youtube.com/@Computerphile',
5608 'playlist_mincount': 11,
5610 'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5611 'only_matching': True,
5613 'note': 'Playlist URL that does not actually serve a playlist',
5614 'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5616 'id': 'FqZTN594JQw',
5618 'title': "Smiley's People 01 detective, Adventure Series, Action",
5619 'upload_date': '20150526',
5620 'license': 'Standard YouTube License',
5621 'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5622 'categories': ['People & Blogs'],
5628 'skip_download': True,
5630 'skip': 'This video is not available.',
5631 'add_ie': [YoutubeIE
.ie_key()],
5633 'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5634 'only_matching': True,
5636 'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5637 'only_matching': True,
5639 'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5641 'id': 'AlTsmyW4auo', # This will keep changing
5644 'upload_date': r
're:\d{8}',
5646 'categories': ['News & Politics'],
5649 'release_timestamp': int,
5650 'channel': 'Sky News',
5651 'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5654 'thumbnail': r
're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5655 'playable_in_embed': True,
5656 'release_date': r
're:\d+',
5657 'availability': 'public',
5658 'live_status': 'is_live',
5659 'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5660 'channel_follower_count': int,
5661 'concurrent_view_count': int,
5662 'uploader_url': 'https://www.youtube.com/@SkyNews',
5663 'uploader_id': '@SkyNews',
5664 'uploader': 'Sky News',
5667 'skip_download': True,
5669 'expected_warnings': ['Ignoring subtitle tracks found in '],
5671 'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5673 'id': 'a48o2S1cPoo',
5675 'title': 'The Young Turks - Live Main Show',
5676 'upload_date': '20150715',
5677 'license': 'Standard YouTube License',
5678 'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5679 'categories': ['News & Politics'],
5680 'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5684 'skip_download': True,
5686 'only_matching': True,
5688 'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5689 'only_matching': True,
5691 'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5692 'only_matching': True,
5694 'note': 'A channel that is not live. Should raise error',
5695 'url': 'https://www.youtube.com/user/numberphile/live',
5696 'only_matching': True,
5698 'url': 'https://www.youtube.com/feed/trending',
5699 'only_matching': True,
5701 'url': 'https://www.youtube.com/feed/library',
5702 'only_matching': True,
5704 'url': 'https://www.youtube.com/feed/history',
5705 'only_matching': True,
5707 'url': 'https://www.youtube.com/feed/subscriptions',
5708 'only_matching': True,
5710 'url': 'https://www.youtube.com/feed/watch_later',
5711 'only_matching': True,
5713 'note': 'Recommended - redirects to home page.',
5714 'url': 'https://www.youtube.com/feed/recommended',
5715 'only_matching': True,
5717 'note': 'inline playlist with not always working continuations',
5718 'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5719 'only_matching': True,
5721 'url': 'https://www.youtube.com/course',
5722 'only_matching': True,
5724 'url': 'https://www.youtube.com/zsecurity',
5725 'only_matching': True,
5727 'url': 'http://www.youtube.com/NASAgovVideo/videos',
5728 'only_matching': True,
5730 'url': 'https://www.youtube.com/TheYoungTurks/live',
5731 'only_matching': True,
5733 'url': 'https://www.youtube.com/hashtag/cctv9',
5739 'playlist_mincount': 300, # not consistent but should be over 300
5741 'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
5742 'only_matching': True,
5744 'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
5745 'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5746 'only_matching': True
5748 'note': '/browse/ should redirect to /channel/',
5749 'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
5750 'only_matching': True
5752 'note': 'VLPL, should redirect to playlist?list=PL...',
5753 'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5755 'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5756 'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
5757 'title': 'NCS : All Releases 💿',
5758 'channel_url': 'https://www.youtube.com/channel/UC_aEa8K-EOJ3D6gOs7HcyNg',
5759 'modified_date': r
're:\d{8}',
5761 'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
5763 'channel': 'NoCopyrightSounds',
5764 'availability': 'public',
5765 'uploader_url': 'https://www.youtube.com/@NoCopyrightSounds',
5766 'uploader': 'NoCopyrightSounds',
5767 'uploader_id': '@NoCopyrightSounds',
5769 'playlist_mincount': 166,
5770 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden', 'YouTube Music is not directly supported'],
5772 # TODO: fix 'unviewable' issue with this playlist when reloading with unavailable videos
5773 'note': 'Topic, should redirect to playlist?list=UU...',
5774 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5776 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5777 'title': 'Uploads from Royalty Free Music - Topic',
5779 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5780 'channel': 'Royalty Free Music - Topic',
5782 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5783 'modified_date': r
're:\d{8}',
5785 'availability': 'public',
5786 'uploader': 'Royalty Free Music - Topic',
5788 'playlist_mincount': 101,
5789 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5791 # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
5792 # Treat as a general feed
5793 'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
5795 'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
5796 'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
5799 'playlist_mincount': 9,
5801 'note': 'Youtube music Album',
5802 'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
5804 'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
5805 'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
5809 'availability': 'unlisted',
5810 'modified_date': r
're:\d{8}',
5812 'playlist_count': 50,
5813 'expected_warnings': ['YouTube Music is not directly supported'],
5815 'note': 'unlisted single video playlist',
5816 'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5818 'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5819 'title': 'yt-dlp unlisted playlist test',
5820 'availability': 'unlisted',
5822 'modified_date': '20220418',
5823 'channel': 'colethedj',
5826 'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5827 'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5828 'uploader_url': 'https://www.youtube.com/@colethedj1894',
5829 'uploader_id': '@colethedj1894',
5830 'uploader': 'colethedj',
5832 'playlist_count': 1,
5834 'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
5835 'url': 'https://www.youtube.com/feed/recommended',
5837 'id': 'recommended',
5838 'title': 'recommended',
5841 'playlist_mincount': 50,
5843 'skip_download': True,
5844 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5847 'note': 'API Fallback: /videos tab, sorted by oldest first',
5848 'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
5850 'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5851 'title': 'Cody\'sLab - Videos',
5852 'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
5853 'channel': 'Cody\'sLab',
5854 'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5856 'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
5857 'channel_follower_count': int
5859 'playlist_mincount': 650,
5861 'skip_download': True,
5862 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5864 'skip': 'Query for sorting no longer works',
5866 'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
5867 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5869 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5870 'title': 'Uploads from Royalty Free Music - Topic',
5871 'modified_date': r
're:\d{8}',
5872 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5874 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5876 'channel': 'Royalty Free Music - Topic',
5878 'availability': 'public',
5879 'uploader': 'Royalty Free Music - Topic',
5881 'playlist_mincount': 101,
5883 'skip_download': True,
5884 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5886 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5888 'note': 'non-standard redirect to regional channel',
5889 'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
5890 'only_matching': True
5892 'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
5893 'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
5895 'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
5896 'modified_date': '20220407',
5897 'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
5899 'availability': 'unlisted',
5900 'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
5901 'channel': 'pukkandan',
5902 'description': 'Test for collaborative playlist',
5903 'title': 'yt-dlp test - collaborative playlist',
5905 'uploader_url': 'https://www.youtube.com/@pukkandan',
5906 'uploader_id': '@pukkandan',
5907 'uploader': 'pukkandan',
5909 'playlist_mincount': 2
5911 'note': 'translated tab name',
5912 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
5914 'id': 'UCiu-3thuViMebBjw_5nWYrA',
5916 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
5917 'description': 'test description',
5918 'title': 'cole-dlp-test-acc - 再生リスト',
5919 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
5920 'channel': 'cole-dlp-test-acc',
5921 'uploader_url': 'https://www.youtube.com/@coletdjnz',
5922 'uploader_id': '@coletdjnz',
5923 'uploader': 'cole-dlp-test-acc',
5925 'playlist_mincount': 1,
5926 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
5927 'expected_warnings': ['Preferring "ja"'],
5929 # XXX: this should really check flat playlist entries, but the test suite doesn't support that
5930 'note': 'preferred lang set with playlist with translated video titles',
5931 'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
5933 'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
5936 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
5937 'channel': 'cole-dlp-test-acc',
5938 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
5939 'description': 'test',
5940 'title': 'dlp test playlist',
5941 'availability': 'public',
5942 'uploader_url': 'https://www.youtube.com/@coletdjnz',
5943 'uploader_id': '@coletdjnz',
5944 'uploader': 'cole-dlp-test-acc',
5946 'playlist_mincount': 1,
5947 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
5948 'expected_warnings': ['Preferring "ja"'],
5950 # shorts audio pivot for 2GtVksBMYFM.
5951 'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
5953 'id': 'sfv_audio_pivot',
5954 'title': 'sfv_audio_pivot',
5957 'playlist_mincount': 50,
5960 # Channel with a real live tab (not to be mistaken with streams tab)
5961 # Do not treat like it should redirect to live stream
5962 'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
5964 'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
5965 'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
5968 'playlist_mincount': 20,
5970 # Tab name is not the same as tab id
5971 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
5973 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
5974 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
5977 'playlist_mincount': 8,
5979 # Home tab id is literally home. Not to get mistaken with featured
5980 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
5982 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
5983 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
5986 'playlist_mincount': 8,
5988 # Should get three playlists for videos, shorts and streams tabs
5989 'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
5991 'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
5992 'title': 'Polka Ch. 尾丸ポルカ',
5993 'channel_follower_count': int,
5994 'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
5995 'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
5996 'description': 'md5:e56b74b5bb7e9c701522162e9abfb822',
5997 'channel': 'Polka Ch. 尾丸ポルカ',
5999 'uploader_url': 'https://www.youtube.com/@OmaruPolka',
6000 'uploader': 'Polka Ch. 尾丸ポルカ',
6001 'uploader_id': '@OmaruPolka',
6003 'playlist_count': 3,
6005 # Shorts tab with channel with handle
6006 # TODO: fix channel description
6007 'url': 'https://www.youtube.com/@NotJustBikes/shorts',
6009 'id': 'UC0intLFzLaudFG-xAvUEO-A',
6010 'title': 'Not Just Bikes - Shorts',
6012 'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
6013 'description': 'md5:26bc55af26855a608a5cf89dfa595c8d',
6014 'channel_follower_count': int,
6015 'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
6016 'channel': 'Not Just Bikes',
6017 'uploader_url': 'https://www.youtube.com/@NotJustBikes',
6018 'uploader': 'Not Just Bikes',
6019 'uploader_id': '@NotJustBikes',
6021 'playlist_mincount': 10,
6024 'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
6026 'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6027 'title': '中村悠一 - Live',
6029 'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6030 'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
6032 'channel_follower_count': int,
6033 'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
6034 'uploader_url': 'https://www.youtube.com/@Yuichi-Nakamura',
6035 'uploader_id': '@Yuichi-Nakamura',
6038 'playlist_mincount': 60,
6040 # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
6041 # See test_youtube_lists
6042 'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
6043 'only_matching': True,
6045 # No uploads and no UCID given. Should fail with no uploads error
6046 # See test_youtube_lists
6047 'url': 'https://www.youtube.com/news',
6048 'only_matching': True
6050 # No videos tab but has a shorts tab
6051 'url': 'https://www.youtube.com/c/TKFShorts',
6053 'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6054 'title': 'Shorts Break - Shorts',
6056 'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6057 'channel': 'Shorts Break',
6058 'description': 'md5:6de33c5e7ba686e5f3efd4e19c7ef499',
6059 'channel_follower_count': int,
6060 'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
6061 'uploader_url': 'https://www.youtube.com/@ShortsBreak_Official',
6062 'uploader': 'Shorts Break',
6063 'uploader_id': '@ShortsBreak_Official',
6065 'playlist_mincount': 30,
6067 # Trending Now Tab. tab id is empty
6068 'url': 'https://www.youtube.com/feed/trending',
6071 'title': 'trending - Now',
6074 'playlist_mincount': 30,
6076 # Trending Gaming Tab. tab id is empty
6077 'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
6080 'title': 'trending - Gaming',
6083 'playlist_mincount': 30,
6085 # Shorts url result in shorts tab
6086 # TODO: Fix channel id extraction
6087 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
6089 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6090 'title': 'cole-dlp-test-acc - Shorts',
6091 'channel': 'cole-dlp-test-acc',
6092 'description': 'test description',
6093 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6094 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6096 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6097 'uploader_id': '@coletdjnz',
6098 'uploader': 'cole-dlp-test-acc',
6102 # Channel data is not currently available for short renderers (as of 2023-03-01)
6104 'ie_key': 'Youtube',
6105 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
6106 'id': 'sSM9J5YH_60',
6107 'title': 'SHORT short',
6112 'params': {'extract_flat': True}
,
6114 # Live video status should be extracted
6115 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
6117 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6118 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live', # TODO, should be Minecraft - Live or Minecraft - Topic - Live
6124 'ie_key': 'Youtube',
6125 'url': 'startswith:https://www.youtube.com/watch?v=',
6128 'live_status': 'is_live',
6131 'concurrent_view_count': int,
6135 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6136 'playlist_mincount': 1
6138 # Channel renderer metadata. Contains number of videos on the channel
6139 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/channels',
6141 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6142 'title': 'cole-dlp-test-acc - Channels',
6143 'channel': 'cole-dlp-test-acc',
6144 'description': 'test description',
6145 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6146 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6148 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6149 'uploader_id': '@coletdjnz',
6150 'uploader': 'cole-dlp-test-acc',
6155 'ie_key': 'YoutubeTab',
6156 'url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6157 'id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6158 'channel_id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6159 'title': 'PewDiePie',
6160 'channel': 'PewDiePie',
6161 'channel_url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6163 'channel_follower_count': int,
6164 'playlist_count': int,
6165 'uploader': 'PewDiePie',
6166 'uploader_url': 'https://www.youtube.com/@PewDiePie',
6167 'uploader_id': '@PewDiePie',
6170 'params': {'extract_flat': True}
,
6172 'url': 'https://www.youtube.com/@3blue1brown/about',
6174 'id': 'UCYO_jab_esuFRV4b17AJtAw',
6175 'tags': ['Mathematics'],
6176 'title': '3Blue1Brown - About',
6177 'channel_follower_count': int,
6178 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
6179 'channel': '3Blue1Brown',
6181 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
6182 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
6183 'uploader_url': 'https://www.youtube.com/@3blue1brown',
6184 'uploader_id': '@3blue1brown',
6185 'uploader': '3Blue1Brown',
6187 'playlist_count': 0,
6191 def suitable(cls
, url
):
6192 return False if YoutubeIE
.suitable(url
) else super().suitable(url
)
6194 _URL_RE
= re
.compile(rf
'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
6196 def _get_url_mobj(self
, url
):
6197 mobj
= self
._URL
_RE
.match(url
).groupdict()
6198 mobj
.update((k
, '') for k
, v
in mobj
.items() if v
is None)
6201 def _extract_tab_id_and_name(self
, tab
, base_url
='https://www.youtube.com'):
6202 tab_name
= (tab
.get('title') or '').lower()
6203 tab_url
= urljoin(base_url
, traverse_obj(
6204 tab
, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
6206 tab_id
= (tab_url
and self
._get
_url
_mobj
(tab_url
)['tab'][1:]
6207 or traverse_obj(tab
, 'tabIdentifier', expected_type
=str))
6210 'TAB_ID_SPONSORSHIPS': 'membership',
6211 }.get(tab_id
, tab_id
), tab_name
6213 # Fallback to tab name if we cannot get the tab id.
6214 # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6215 # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6217 self
.write_debug(f
'Falling back to selected tab name: {tab_name}')
6221 }.get(tab_name
, tab_name
), tab_name
6223 def _has_tab(self
, tabs
, tab_id
):
6224 return any(self
._extract
_tab
_id
_and
_name
(tab
)[0] == tab_id
for tab
in tabs
)
6226 @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6227 def _real_extract(self
, url
, smuggled_data
):
6228 item_id
= self
._match
_id
(url
)
6229 url
= urllib
.parse
.urlunparse(
6230 urllib
.parse
.urlparse(url
)._replace
(netloc
='www.youtube.com'))
6231 compat_opts
= self
.get_param('compat_opts', [])
6233 mobj
= self
._get
_url
_mobj
(url
)
6234 pre
, tab
, post
, is_channel
= mobj
['pre'], mobj
['tab'], mobj
['post'], not mobj
['not_channel']
6235 if is_channel
and smuggled_data
.get('is_music_url'):
6236 if item_id
[:2] == 'VL': # Youtube music VL channels have an equivalent playlist
6237 return self
.url_result(
6238 f
'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE
, item_id
[2:])
6239 elif item_id
[:2] == 'MP': # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6240 mdata
= self
._extract
_tab
_endpoint
(
6241 f
'https://music.youtube.com/channel/{item_id}', item_id
, default_client
='web_music')
6242 murl
= traverse_obj(mdata
, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6243 get_all
=False, expected_type
=str)
6245 raise ExtractorError('Failed to resolve album to playlist')
6246 return self
.url_result(murl
, YoutubeTabIE
)
6247 elif mobj
['channel_type'] == 'browse': # Youtube music /browse/ should be changed to /channel/
6248 return self
.url_result(
6249 f
'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE
, item_id
)
6251 original_tab_id
, display_id
= tab
[1:], f
'{item_id}{tab}'
6252 if is_channel
and not tab
and 'no-youtube-channel-redirect' not in compat_opts
:
6253 url
= f
'{pre}/videos{post}'
6254 if smuggled_data
.get('is_music_url'):
6255 self
.report_warning(f
'YouTube Music is not directly supported. Redirecting to {url}')
6257 # Handle both video/playlist URLs
6259 video_id
, playlist_id
= [traverse_obj(qs
, (key
, 0)) for key
in ('v', 'list')]
6260 if not video_id
and mobj
['not_channel'].startswith('watch'):
6262 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6263 raise ExtractorError('A video URL was given without video ID', expected
=True)
6264 # Common mistake: https://www.youtube.com/watch?list=playlist_id
6265 self
.report_warning(f
'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6266 return self
.url_result(
6267 f
'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE
, playlist_id
)
6269 if not self
._yes
_playlist
(playlist_id
, video_id
):
6270 return self
.url_result(
6271 f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6273 data
, ytcfg
= self
._extract
_data
(url
, display_id
)
6275 # YouTube may provide a non-standard redirect to the regional channel
6276 # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6277 # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6278 redirect_url
= traverse_obj(
6279 data
, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all
=False)
6280 if redirect_url
and 'no-youtube-channel-redirect' not in compat_opts
:
6281 redirect_url
= ''.join((urljoin('https://www.youtube.com', redirect_url
), tab
, post
))
6282 self
.to_screen(f
'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6283 return self
.url_result(redirect_url
, YoutubeTabIE
)
6285 tabs
, extra_tabs
= self
._extract
_tab
_renderers
(data
), []
6286 if is_channel
and tabs
and 'no-youtube-channel-redirect' not in compat_opts
:
6287 selected_tab
= self
._extract
_selected
_tab
(tabs
)
6288 selected_tab_id
, selected_tab_name
= self
._extract
_tab
_id
_and
_name
(selected_tab
, url
) # NB: Name may be translated
6289 self
.write_debug(f
'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6291 if not original_tab_id
and selected_tab_name
:
6292 self
.to_screen('Downloading all uploads of the channel. '
6293 'To download only the videos in a specific tab, pass the tab\'s URL')
6294 if self
._has
_tab
(tabs
, 'streams'):
6295 extra_tabs
.append(''.join((pre
, '/streams', post
)))
6296 if self
._has
_tab
(tabs
, 'shorts'):
6297 extra_tabs
.append(''.join((pre
, '/shorts', post
)))
6298 # XXX: Members-only tab should also be extracted
6300 if not extra_tabs
and selected_tab_id
!= 'videos':
6301 # Channel does not have streams, shorts or videos tabs
6302 if item_id
[:2] != 'UC':
6303 raise ExtractorError('This channel has no uploads', expected
=True)
6305 # Topic channels don't have /videos. Use the equivalent playlist instead
6306 pl_id
= f
'UU{item_id[2:]}'
6307 pl_url
= f
'https://www.youtube.com/playlist?list={pl_id}'
6309 data
, ytcfg
= self
._extract
_data
(pl_url
, pl_id
, ytcfg
=ytcfg
, fatal
=True, webpage_fatal
=True)
6310 except ExtractorError
:
6311 raise ExtractorError('This channel has no uploads', expected
=True)
6313 item_id
, url
= pl_id
, pl_url
6315 f
'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6317 elif extra_tabs
and selected_tab_id
!= 'videos':
6318 # When there are shorts/live tabs but not videos tab
6319 url
, data
= f
'{pre}{post}', None
6321 elif (original_tab_id
or 'videos') != selected_tab_id
:
6322 if original_tab_id
== 'live':
6323 # Live tab should have redirected to the video
6324 # Except in the case the channel has an actual live tab
6325 # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6326 raise UserNotLive(video_id
=item_id
)
6327 elif selected_tab_name
:
6328 raise ExtractorError(f
'This channel does not have a {original_tab_id} tab', expected
=True)
6330 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6331 url
= f
'{pre}{post}'
6333 # YouTube sometimes provides a button to reload playlist with unavailable videos.
6334 if 'no-youtube-unavailable-videos' not in compat_opts
:
6335 data
= self
._reload
_with
_unavailable
_videos
(display_id
, data
, ytcfg
) or data
6336 self
._extract
_and
_report
_alerts
(data
, only_once
=True)
6338 tabs
, entries
= self
._extract
_tab
_renderers
(data
), []
6340 entries
= [self
._extract
_from
_tabs
(item_id
, ytcfg
, data
, tabs
)]
6342 'extractor_key': YoutubeTabIE
.ie_key(),
6343 'extractor': YoutubeTabIE
.IE_NAME
,
6346 if self
.get_param('playlist_items') == '0':
6347 entries
.extend(self
.url_result(u
, YoutubeTabIE
) for u
in extra_tabs
)
6348 else: # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6349 entries
.extend(map(self
._real
_extract
, extra_tabs
))
6351 if len(entries
) == 1:
6354 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
6355 uploads_url
= 'the Uploads (UU) playlist URL'
6356 if try_get(metadata
, lambda x
: x
['channel_id'].startswith('UC')):
6357 uploads_url
= f
'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6359 'Downloading as multiple playlists, separated by tabs. '
6360 f
'To download as a single playlist instead, pass {uploads_url}')
6361 return self
.playlist_result(entries
, item_id
, **metadata
)
6364 playlist
= traverse_obj(
6365 data
, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type
=dict)
6367 return self
._extract
_from
_playlist
(item_id
, url
, data
, playlist
, ytcfg
)
6369 video_id
= traverse_obj(
6370 data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str) or video_id
6372 if tab
!= '/live': # live tab is expected to redirect to video
6373 self
.report_warning(f
'Unable to recognize playlist. Downloading just video {video_id}')
6374 return self
.url_result(f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6376 raise ExtractorError('Unable to recognize tab page')
6379 class YoutubePlaylistIE(InfoExtractor
):
6380 IE_DESC
= 'YouTube playlists'
6381 _VALID_URL
= r
'''(?x)(?:
6386 youtube(?:kids)?\.com|
6391 (?P<id>%(playlist_id)s)
6393 'playlist_id': YoutubeBaseInfoExtractor
._PLAYLIST
_ID
_RE
,
6394 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
6396 IE_NAME
= 'youtube:playlist'
6398 'note': 'issue #673',
6399 'url': 'PLBB231211A4F62143',
6401 'title': '[OLD]Team Fortress 2 (Class-based LP)',
6402 'id': 'PLBB231211A4F62143',
6403 'uploader': 'Wickman',
6404 'uploader_id': '@WickmanVT',
6405 'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6407 'uploader_url': 'https://www.youtube.com/@WickmanVT',
6408 'modified_date': r
're:\d{8}',
6409 'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6410 'channel': 'Wickman',
6412 'channel_url': 'https://www.youtube.com/channel/UCKSpbfbl5kRQpTdL7kMc-1Q',
6413 'availability': 'public',
6415 'playlist_mincount': 29,
6417 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6419 'title': 'YDL_safe_search',
6420 'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6422 'playlist_count': 2,
6423 'skip': 'This playlist is private',
6426 'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6427 'playlist_count': 4,
6430 'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6431 'uploader': 'milan',
6432 'uploader_id': '@milan5503',
6434 'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6436 'modified_date': '20140919',
6439 'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6440 'uploader_url': 'https://www.youtube.com/@milan5503',
6441 'availability': 'public',
6443 'expected_warnings': [r
'[Uu]navailable videos? (is|are|will be) hidden'],
6445 'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6446 'playlist_mincount': 455,
6448 'title': '2018 Chinese New Singles (11/6 updated)',
6449 'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6451 'uploader_id': '@music_king',
6452 'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6455 'channel_url': 'https://www.youtube.com/channel/UC21nz3_MesPLqtDqwdvnoxA',
6457 'uploader_url': 'https://www.youtube.com/@music_king',
6458 'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6459 'modified_date': r
're:\d{8}',
6460 'availability': 'public',
6462 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6464 'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6465 'only_matching': True,
6467 # music album playlist
6468 'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6469 'only_matching': True,
6473 def suitable(cls
, url
):
6474 if YoutubeTabIE
.suitable(url
):
6476 from ..utils
import parse_qs
6478 if qs
.get('v', [None])[0]:
6480 return super().suitable(url
)
6482 def _real_extract(self
, url
):
6483 playlist_id
= self
._match
_id
(url
)
6484 is_music_url
= YoutubeBaseInfoExtractor
.is_music_url(url
)
6485 url
= update_url_query(
6486 'https://www.youtube.com/playlist',
6487 parse_qs(url
) or {'list': playlist_id}
)
6489 url
= smuggle_url(url
, {'is_music_url': True}
)
6490 return self
.url_result(url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6493 class YoutubeYtBeIE(InfoExtractor
):
6494 IE_DESC
= 'youtu.be'
6495 _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}
6497 'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6499 'id': 'yeWKywCrFtk',
6501 'title': 'Small Scale Baler and Braiding Rugs',
6502 'uploader': 'Backus-Page House Museum',
6503 'uploader_id': '@backuspagemuseum',
6504 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/@backuspagemuseum',
6505 'upload_date': '20161008',
6506 'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6507 'categories': ['Nonprofits & Activism'],
6511 'playable_in_embed': True,
6512 'thumbnail': r
're:^https?://.*\.webp',
6513 'channel': 'Backus-Page House Museum',
6514 'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6515 'live_status': 'not_live',
6517 'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6518 'availability': 'public',
6520 'comment_count': int,
6521 'channel_follower_count': int
6525 'skip_download': True,
6528 'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6529 'only_matching': True,
6532 def _real_extract(self
, url
):
6533 mobj
= self
._match
_valid
_url
(url
)
6534 video_id
= mobj
.group('id')
6535 playlist_id
= mobj
.group('playlist_id')
6536 return self
.url_result(
6537 update_url_query('https://www.youtube.com/watch', {
6539 'list': playlist_id
,
6540 'feature': 'youtu.be',
6541 }), ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6544 class YoutubeLivestreamEmbedIE(InfoExtractor
):
6545 IE_DESC
= 'YouTube livestream embeds'
6546 _VALID_URL
= r
'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6548 'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6549 'only_matching': True,
6552 def _real_extract(self
, url
):
6553 channel_id
= self
._match
_id
(url
)
6554 return self
.url_result(
6555 f
'https://www.youtube.com/channel/{channel_id}/live',
6556 ie
=YoutubeTabIE
.ie_key(), video_id
=channel_id
)
6559 class YoutubeYtUserIE(InfoExtractor
):
6560 IE_DESC
= 'YouTube user videos; "ytuser:" prefix'
6561 IE_NAME
= 'youtube:user'
6562 _VALID_URL
= r
'ytuser:(?P<id>.+)'
6564 'url': 'ytuser:phihag',
6565 'only_matching': True,
6568 def _real_extract(self
, url
):
6569 user_id
= self
._match
_id
(url
)
6570 return self
.url_result(f
'https://www.youtube.com/user/{user_id}', YoutubeTabIE
, user_id
)
6573 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor
):
6574 IE_NAME
= 'youtube:favorites'
6575 IE_DESC
= 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6576 _VALID_URL
= r
':ytfav(?:ou?rite)?s?'
6577 _LOGIN_REQUIRED
= True
6580 'only_matching': True,
6582 'url': ':ytfavorites',
6583 'only_matching': True,
6586 def _real_extract(self
, url
):
6587 return self
.url_result(
6588 'https://www.youtube.com/playlist?list=LL',
6589 ie
=YoutubeTabIE
.ie_key())
6592 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor
):
6593 IE_NAME
= 'youtube:notif'
6594 IE_DESC
= 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6595 _VALID_URL
= r
':ytnotif(?:ication)?s?'
6596 _LOGIN_REQUIRED
= True
6599 'only_matching': True,
6601 'url': ':ytnotifications',
6602 'only_matching': True,
6605 def _extract_notification_menu(self
, response
, continuation_list
):
6606 notification_list
= traverse_obj(
6608 ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6609 ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6610 expected_type
=list) or []
6611 continuation_list
[0] = None
6612 for item
in notification_list
:
6613 entry
= self
._extract
_notification
_renderer
(item
.get('notificationRenderer'))
6616 continuation
= item
.get('continuationItemRenderer')
6618 continuation_list
[0] = continuation
6620 def _extract_notification_renderer(self
, notification
):
6621 video_id
= traverse_obj(
6622 notification
, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str)
6623 url
= f
'https://www.youtube.com/watch?v={video_id}'
6626 browse_ep
= traverse_obj(
6627 notification
, ('navigationEndpoint', 'browseEndpoint'), expected_type
=dict)
6628 channel_id
= self
.ucid_or_none(traverse_obj(browse_ep
, 'browseId', expected_type
=str))
6629 post_id
= self
._search
_regex
(
6630 r
'/post/(.+)', traverse_obj(browse_ep
, 'canonicalBaseUrl', expected_type
=str),
6631 'post id', default
=None)
6632 if not channel_id
or not post_id
:
6634 # The direct /post url redirects to this in the browser
6635 url
= f
'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
6637 channel
= traverse_obj(
6638 notification
, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
6640 notification_title
= self
._get
_text
(notification
, 'shortMessage')
6641 if notification_title
:
6642 notification_title
= notification_title
.replace('\xad', '') # remove soft hyphens
6643 # TODO: handle recommended videos
6644 title
= self
._search
_regex
(
6645 rf
'{re.escape(channel or "")}[^:]+: (.+)', notification_title
,
6646 'video title', default
=None)
6647 timestamp
= (self
._parse
_time
_text
(self
._get
_text
(notification
, 'sentTimeText'))
6648 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
6653 'ie_key': (YoutubeIE
if video_id
else YoutubeTabIE
).ie_key(),
6654 'video_id': video_id
,
6656 'channel_id': channel_id
,
6658 'uploader': channel
,
6659 'thumbnails': self
._extract
_thumbnails
(notification
, 'videoThumbnail'),
6660 'timestamp': timestamp
,
6663 def _notification_menu_entries(self
, ytcfg
):
6664 continuation_list
= [None]
6666 for page
in itertools
.count(1):
6667 ctoken
= traverse_obj(
6668 continuation_list
, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type
=str)
6669 response
= self
._extract
_response
(
6670 item_id
=f
'page {page}', query
={'ctoken': ctoken}
if ctoken
else {}, ytcfg
=ytcfg
,
6671 ep
='notification/get_notification_menu', check_get_keys
='actions',
6672 headers
=self
.generate_api_headers(ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(response
)))
6673 yield from self
._extract
_notification
_menu
(response
, continuation_list
)
6674 if not continuation_list
[0]:
6677 def _real_extract(self
, url
):
6678 display_id
= 'notifications'
6679 ytcfg
= self
._download
_ytcfg
('web', display_id
) if not self
.skip_webpage
else {}
6680 self
._report
_playlist
_authcheck
(ytcfg
)
6681 return self
.playlist_result(self
._notification
_menu
_entries
(ytcfg
), display_id
, display_id
)
6684 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6685 IE_DESC
= 'YouTube search'
6686 IE_NAME
= 'youtube:search'
6687 _SEARCH_KEY
= 'ytsearch'
6688 _SEARCH_PARAMS
= 'EgIQAQ%3D%3D' # Videos only
6690 'url': 'ytsearch5:youtube-dl test video',
6691 'playlist_count': 5,
6693 'id': 'youtube-dl test video',
6694 'title': 'youtube-dl test video',
6699 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6700 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ ':date'
6701 _SEARCH_KEY
= 'ytsearchdate'
6702 IE_DESC
= 'YouTube search, newest videos first'
6703 _SEARCH_PARAMS
= 'CAISAhAB' # Videos only, sorted by date
6705 'url': 'ytsearchdate5:youtube-dl test video',
6706 'playlist_count': 5,
6708 'id': 'youtube-dl test video',
6709 'title': 'youtube-dl test video',
6714 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor
):
6715 IE_DESC
= 'YouTube search URLs with sorting and filter support'
6716 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ '_url'
6717 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6719 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
6720 'playlist_mincount': 5,
6722 'id': 'youtube-dl test video',
6723 'title': 'youtube-dl test video',
6726 'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
6727 'playlist_mincount': 5,
6733 'url': 'https://www.youtube.com/results?search_query=%23cats',
6734 'playlist_mincount': 1,
6738 # The test suite does not have support for nested playlists
6740 # 'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
6746 'url': 'https://www.youtube.com/results?search_query=kurzgesagt&sp=EgIQAg%253D%253D',
6749 'title': 'kurzgesagt',
6754 'id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6755 'url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6756 'ie_key': 'YoutubeTab',
6757 'channel': 'Kurzgesagt – In a Nutshell',
6758 'description': 'md5:4ae48dfa9505ffc307dad26342d06bfc',
6759 'title': 'Kurzgesagt – In a Nutshell',
6760 'channel_id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6761 'playlist_count': int, # XXX: should have a way of saying > 1
6762 'channel_url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6764 'uploader_id': '@kurzgesagt',
6765 'uploader_url': 'https://www.youtube.com/@kurzgesagt',
6766 'uploader': 'Kurzgesagt – In a Nutshell',
6769 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6770 'playlist_mincount': 1,
6772 'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
6773 'only_matching': True,
6776 def _real_extract(self
, url
):
6778 query
= (qs
.get('search_query') or qs
.get('q'))[0]
6779 return self
.playlist_result(self
._search
_results
(query
, qs
.get('sp', (None,))[0]), query
, query
)
6782 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor
):
6783 IE_DESC
= 'YouTube music search URLs with selectable sections, e.g. #songs'
6784 IE_NAME
= 'youtube:music:search_url'
6785 _VALID_URL
= r
'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6787 'url': 'https://music.youtube.com/search?q=royalty+free+music',
6788 'playlist_count': 16,
6790 'id': 'royalty free music',
6791 'title': 'royalty free music',
6794 'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
6795 'playlist_mincount': 30,
6797 'id': 'royalty free music - songs',
6798 'title': 'royalty free music - songs',
6800 'params': {'extract_flat': 'in_playlist'}
6802 'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
6803 'playlist_mincount': 30,
6805 'id': 'royalty free music - community playlists',
6806 'title': 'royalty free music - community playlists',
6808 'params': {'extract_flat': 'in_playlist'}
6812 'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
6813 'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
6814 'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
6815 'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
6816 'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
6817 'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
6820 def _real_extract(self
, url
):
6822 query
= (qs
.get('search_query') or qs
.get('q'))[0]
6823 params
= qs
.get('sp', (None,))[0]
6825 section
= next((k
for k
, v
in self
._SECTIONS
.items() if v
== params
), params
)
6827 section
= urllib
.parse
.unquote_plus((url
.split('#') + [''])[1]).lower()
6828 params
= self
._SECTIONS
.get(section
)
6831 title
= join_nonempty(query
, section
, delim
=' - ')
6832 return self
.playlist_result(self
._search
_results
(query
, params
, default_client
='web_music'), title
, title
)
6835 class YoutubeFeedsInfoExtractor(InfoExtractor
):
6837 Base class for feed extractors
6838 Subclasses must re-define the _FEED_NAME property.
6840 _LOGIN_REQUIRED
= True
6841 _FEED_NAME
= 'feeds'
6843 def _real_initialize(self
):
6844 YoutubeBaseInfoExtractor
._check
_login
_required
(self
)
6848 return f
'youtube:{self._FEED_NAME}'
6850 def _real_extract(self
, url
):
6851 return self
.url_result(
6852 f
'https://www.youtube.com/feed/{self._FEED_NAME}', ie
=YoutubeTabIE
.ie_key())
6855 class YoutubeWatchLaterIE(InfoExtractor
):
6856 IE_NAME
= 'youtube:watchlater'
6857 IE_DESC
= 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
6858 _VALID_URL
= r
':ytwatchlater'
6860 'url': ':ytwatchlater',
6861 'only_matching': True,
6864 def _real_extract(self
, url
):
6865 return self
.url_result(
6866 'https://www.youtube.com/playlist?list=WL', ie
=YoutubeTabIE
.ie_key())
6869 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor
):
6870 IE_DESC
= 'YouTube recommended videos; ":ytrec" keyword'
6871 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
6872 _FEED_NAME
= 'recommended'
6873 _LOGIN_REQUIRED
= False
6876 'only_matching': True,
6878 'url': ':ytrecommended',
6879 'only_matching': True,
6881 'url': 'https://youtube.com',
6882 'only_matching': True,
6886 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor
):
6887 IE_DESC
= 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
6888 _VALID_URL
= r
':ytsub(?:scription)?s?'
6889 _FEED_NAME
= 'subscriptions'
6892 'only_matching': True,
6894 'url': ':ytsubscriptions',
6895 'only_matching': True,
6899 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor
):
6900 IE_DESC
= 'Youtube watch history; ":ythis" keyword (requires cookies)'
6901 _VALID_URL
= r
':ythis(?:tory)?'
6902 _FEED_NAME
= 'history'
6904 'url': ':ythistory',
6905 'only_matching': True,
6909 class YoutubeStoriesIE(InfoExtractor
):
6910 IE_DESC
= 'YouTube channel stories; "ytstories:" prefix'
6911 IE_NAME
= 'youtube:stories'
6912 _VALID_URL
= r
'ytstories:UC(?P<id>[A-Za-z0-9_-]{21}[AQgw])$'
6914 'url': 'ytstories:UCwFCb4jeqaKWnciAYM-ZVHg',
6915 'only_matching': True,
6918 def _real_extract(self
, url
):
6919 playlist_id
= f
'RLTD{self._match_id(url)}'
6920 return self
.url_result(
6921 smuggle_url(f
'https://www.youtube.com/playlist?list={playlist_id}&playnext=1', {'is_story': True}
),
6922 ie
=YoutubeTabIE
, video_id
=playlist_id
)
6925 class YoutubeShortsAudioPivotIE(InfoExtractor
):
6926 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
6927 IE_NAME
= 'youtube:shorts:pivot:audio'
6928 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
6930 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
6931 'only_matching': True,
6935 def _generate_audio_pivot_params(video_id
):
6937 Generates sfv_audio_pivot browse params for this video id
6939 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
6940 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
6942 def _real_extract(self
, url
):
6943 video_id
= self
._match
_id
(url
)
6944 return self
.url_result(
6945 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
6949 class YoutubeTruncatedURLIE(InfoExtractor
):
6950 IE_NAME
= 'youtube:truncated_url'
6951 IE_DESC
= False # Do not list
6952 _VALID_URL
= r
'''(?x)
6954 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
6957 annotation_id=annotation_[^&]+|
6963 attribution_link\?a=[^&]+
6969 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
6970 'only_matching': True,
6972 'url': 'https://www.youtube.com/watch?',
6973 'only_matching': True,
6975 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
6976 'only_matching': True,
6978 'url': 'https://www.youtube.com/watch?feature=foo',
6979 'only_matching': True,
6981 'url': 'https://www.youtube.com/watch?hl=en-GB',
6982 'only_matching': True,
6984 'url': 'https://www.youtube.com/watch?t=2372',
6985 'only_matching': True,
6988 def _real_extract(self
, url
):
6989 raise ExtractorError(
6990 'Did you forget to quote the URL? Remember that & is a meta '
6991 'character in most shells, so you want to put the URL in quotes, '
6993 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
6994 ' or simply youtube-dl BaW_jenozKc .',
6998 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
6999 IE_NAME
= 'youtube:clip'
7000 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7002 # FIXME: Other metadata should be extracted from the clip, not from the base video
7003 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7005 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7007 'section_start': 29.0,
7008 'section_end': 39.7,
7011 'availability': 'public',
7012 'categories': ['Gaming'],
7013 'channel': 'Scott The Woz',
7014 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7015 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7016 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7018 'playable_in_embed': True,
7020 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7021 'title': 'Mobile Games on Console - Scott The Woz',
7022 'upload_date': '20210920',
7023 'uploader': 'Scott The Woz',
7024 'uploader_id': '@ScottTheWoz',
7025 'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7027 'live_status': 'not_live',
7028 'channel_follower_count': int,
7029 'chapters': 'count:20',
7033 def _real_extract(self
, url
):
7034 clip_id
= self
._match
_id
(url
)
7035 _
, data
= self
._extract
_webpage
(url
, clip_id
)
7037 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7039 raise ExtractorError('Unable to find video ID')
7041 clip_data
= traverse_obj(data
, (
7042 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7043 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7044 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7045 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
7048 '_type': 'url_transparent',
7049 'url': f
'https://www.youtube.com/watch?v={video_id}',
7050 'ie_key': YoutubeIE
.ie_key(),
7052 'section_start': int(clip_data
['startTimeMs']) / 1000,
7053 'section_end': int(clip_data
['endTimeMs']) / 1000,
7057 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor
):
7058 IE_NAME
= 'youtube:consent'
7059 IE_DESC
= False # Do not list
7060 _VALID_URL
= r
'https?://consent\.youtube\.com/m\?'
7062 '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',
7064 'id': 'qVv6vCqciTM',
7067 'uploader_id': '@sana_natori',
7068 'comment_count': int,
7069 'chapters': 'count:13',
7070 'upload_date': '20221223',
7071 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7072 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7073 'uploader_url': 'https://www.youtube.com/@sana_natori',
7075 'release_date': '20221223',
7076 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7077 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7079 'playable_in_embed': True,
7081 'availability': 'public',
7082 'channel_follower_count': int,
7083 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7084 'categories': ['Entertainment'],
7085 'live_status': 'was_live',
7086 'release_timestamp': 1671793345,
7087 'channel': 'さなちゃんねる',
7088 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7089 'uploader': 'さなちゃんねる',
7091 'add_ie': ['Youtube'],
7092 'params': {'skip_download': 'Youtube'}
,
7095 def _real_extract(self
, url
):
7096 redirect_url
= url_or_none(parse_qs(url
).get('continue', [None])[-1])
7097 if not redirect_url
:
7098 raise ExtractorError('Invalid cookie consent redirect URL', expected
=True)
7099 return self
.url_result(redirect_url
)
7102 class YoutubeTruncatedIDIE(InfoExtractor
):
7103 IE_NAME
= 'youtube:truncated_id'
7104 IE_DESC
= False # Do not list
7105 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7108 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7109 'only_matching': True,
7112 def _real_extract(self
, url
):
7113 video_id
= self
._match
_id
(url
)
7114 raise ExtractorError(
7115 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',