21 from .common
import InfoExtractor
, SearchInfoExtractor
22 from .openload
import PhantomJSwrapper
23 from ..compat
import functools
24 from ..jsinterp
import JSInterpreter
69 STREAMING_DATA_CLIENT_NAME
= '__yt_dlp_client'
70 # any clients starting with _ cannot be explicitly requested by the user
73 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
74 'INNERTUBE_CONTEXT': {
77 'clientVersion': '2.20220801.00.00',
80 'INNERTUBE_CONTEXT_CLIENT_NAME': 1
83 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
84 'INNERTUBE_CONTEXT': {
86 'clientName': 'WEB_EMBEDDED_PLAYER',
87 'clientVersion': '1.20220731.00.00',
90 'INNERTUBE_CONTEXT_CLIENT_NAME': 56
93 'INNERTUBE_API_KEY': 'AIzaSyC9XL3ZjWddXya6X74dJoCTL-WEYFDNX30',
94 'INNERTUBE_HOST': 'music.youtube.com',
95 'INNERTUBE_CONTEXT': {
97 'clientName': 'WEB_REMIX',
98 'clientVersion': '1.20220727.01.00',
101 'INNERTUBE_CONTEXT_CLIENT_NAME': 67,
104 'INNERTUBE_API_KEY': 'AIzaSyBUPetSUmoZL-OhlxA7wSac5XinrygCqMo',
105 'INNERTUBE_CONTEXT': {
107 'clientName': 'WEB_CREATOR',
108 'clientVersion': '1.20220726.00.00',
111 'INNERTUBE_CONTEXT_CLIENT_NAME': 62,
114 'INNERTUBE_API_KEY': 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w',
115 'INNERTUBE_CONTEXT': {
117 'clientName': 'ANDROID',
118 'clientVersion': '17.31.35',
119 'androidSdkVersion': 30,
120 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
123 'INNERTUBE_CONTEXT_CLIENT_NAME': 3,
124 'REQUIRE_JS_PLAYER': False
126 'android_embedded': {
127 'INNERTUBE_API_KEY': 'AIzaSyCjc_pVEDi4qsv5MtC2dMXzpIaDoRFLsxw',
128 'INNERTUBE_CONTEXT': {
130 'clientName': 'ANDROID_EMBEDDED_PLAYER',
131 'clientVersion': '17.31.35',
132 'androidSdkVersion': 30,
133 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
136 'INNERTUBE_CONTEXT_CLIENT_NAME': 55,
137 'REQUIRE_JS_PLAYER': False
140 'INNERTUBE_API_KEY': 'AIzaSyAOghZGza2MQSZkY_zfZ370N-PUdXEo8AI',
141 'INNERTUBE_CONTEXT': {
143 'clientName': 'ANDROID_MUSIC',
144 'clientVersion': '5.16.51',
145 'androidSdkVersion': 30,
146 'userAgent': 'com.google.android.apps.youtube.music/5.16.51 (Linux; U; Android 11) gzip'
149 'INNERTUBE_CONTEXT_CLIENT_NAME': 21,
150 'REQUIRE_JS_PLAYER': False
153 'INNERTUBE_API_KEY': 'AIzaSyD_qjV8zaaUMehtLkrKFgVeSX_Iqbtyws8',
154 'INNERTUBE_CONTEXT': {
156 'clientName': 'ANDROID_CREATOR',
157 'clientVersion': '22.30.100',
158 'androidSdkVersion': 30,
159 'userAgent': 'com.google.android.apps.youtube.creator/22.30.100 (Linux; U; Android 11) gzip'
162 'INNERTUBE_CONTEXT_CLIENT_NAME': 14,
163 'REQUIRE_JS_PLAYER': False
165 # iOS clients have HLS live streams. Setting device model to get 60fps formats.
166 # See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/680#issuecomment-1002724558
168 'INNERTUBE_API_KEY': 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc',
169 'INNERTUBE_CONTEXT': {
172 'clientVersion': '17.33.2',
173 'deviceModel': 'iPhone14,3',
174 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
177 'INNERTUBE_CONTEXT_CLIENT_NAME': 5,
178 'REQUIRE_JS_PLAYER': False
181 'INNERTUBE_CONTEXT': {
183 'clientName': 'IOS_MESSAGES_EXTENSION',
184 'clientVersion': '17.33.2',
185 'deviceModel': 'iPhone14,3',
186 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
189 'INNERTUBE_CONTEXT_CLIENT_NAME': 66,
190 'REQUIRE_JS_PLAYER': False
193 'INNERTUBE_API_KEY': 'AIzaSyBAETezhkwP0ZWA02RsqT1zu78Fpt0bC_s',
194 'INNERTUBE_CONTEXT': {
196 'clientName': 'IOS_MUSIC',
197 'clientVersion': '5.21',
198 'deviceModel': 'iPhone14,3',
199 'userAgent': 'com.google.ios.youtubemusic/5.21 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
202 'INNERTUBE_CONTEXT_CLIENT_NAME': 26,
203 'REQUIRE_JS_PLAYER': False
206 'INNERTUBE_CONTEXT': {
208 'clientName': 'IOS_CREATOR',
209 'clientVersion': '22.33.101',
210 'deviceModel': 'iPhone14,3',
211 'userAgent': 'com.google.ios.ytcreator/22.33.101 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
214 'INNERTUBE_CONTEXT_CLIENT_NAME': 15,
215 'REQUIRE_JS_PLAYER': False
217 # mweb has 'ultralow' formats
218 # See: https://github.com/yt-dlp/yt-dlp/pull/557
220 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
221 'INNERTUBE_CONTEXT': {
223 'clientName': 'MWEB',
224 'clientVersion': '2.20220801.00.00',
227 'INNERTUBE_CONTEXT_CLIENT_NAME': 2
229 # This client can access age restricted videos (unless the uploader has disabled the 'allow embedding' option)
230 # See: https://github.com/zerodytrash/YouTube-Internal-Clients
232 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
233 'INNERTUBE_CONTEXT': {
235 'clientName': 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
236 'clientVersion': '2.0',
239 'INNERTUBE_CONTEXT_CLIENT_NAME': 85
244 def _split_innertube_client(client_name
):
245 variant
, *base
= client_name
.rsplit('.', 1)
247 return variant
, base
[0], variant
248 base
, *variant
= client_name
.split('_', 1)
249 return client_name
, base
, variant
[0] if variant
else None
252 def short_client_name(client_name
):
253 main
, *parts
= _split_innertube_client(client_name
)[0].replace('embedscreen', 'e_s').split('_')
254 return join_nonempty(main
[:4], ''.join(x
[0] for x
in parts
)).upper()
257 def build_innertube_clients():
259 'embedUrl': 'https://www.youtube.com/', # Can be any valid URL
261 BASE_CLIENTS
= ('ios', 'android', 'web', 'tv', 'mweb')
262 priority
= qualities(BASE_CLIENTS
[::-1])
264 for client
, ytcfg
in tuple(INNERTUBE_CLIENTS
.items()):
265 ytcfg
.setdefault('INNERTUBE_API_KEY', 'AIzaSyDCU8hByM-4DrUqRUYnGn-3llEO78bcxq8')
266 ytcfg
.setdefault('INNERTUBE_HOST', 'www.youtube.com')
267 ytcfg
.setdefault('REQUIRE_JS_PLAYER', True)
268 ytcfg
['INNERTUBE_CONTEXT']['client'].setdefault('hl', 'en')
270 _
, base_client
, variant
= _split_innertube_client(client
)
271 ytcfg
['priority'] = 10 * priority(base_client
)
274 INNERTUBE_CLIENTS
[f
'{client}_embedscreen'] = embedscreen
= copy
.deepcopy(ytcfg
)
275 embedscreen
['INNERTUBE_CONTEXT']['client']['clientScreen'] = 'EMBED'
276 embedscreen
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
277 embedscreen
['priority'] -= 3
278 elif variant
== 'embedded':
279 ytcfg
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
280 ytcfg
['priority'] -= 2
282 ytcfg
['priority'] -= 3
285 build_innertube_clients()
288 class BadgeType(enum
.Enum
):
289 AVAILABILITY_UNLISTED
= enum
.auto()
290 AVAILABILITY_PRIVATE
= enum
.auto()
291 AVAILABILITY_PUBLIC
= enum
.auto()
292 AVAILABILITY_PREMIUM
= enum
.auto()
293 AVAILABILITY_SUBSCRIPTION
= enum
.auto()
294 LIVE_NOW
= enum
.auto()
295 VERIFIED
= 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
, badge_list
: list):
797 Extract known BadgeType's from a list of badge renderers.
798 @returns [{'type': BadgeType}]
801 'PRIVACY_UNLISTED': BadgeType
.AVAILABILITY_UNLISTED
,
802 'PRIVACY_PRIVATE': BadgeType
.AVAILABILITY_PRIVATE
,
803 'PRIVACY_PUBLIC': BadgeType
.AVAILABILITY_PUBLIC
,
804 'CHECK_CIRCLE_THICK': BadgeType
.VERIFIED
,
805 'OFFICIAL_ARTIST_BADGE': BadgeType
.VERIFIED
,
806 'CHECK': BadgeType
.VERIFIED
,
810 'BADGE_STYLE_TYPE_MEMBERS_ONLY': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
811 'BADGE_STYLE_TYPE_PREMIUM': BadgeType
.AVAILABILITY_PREMIUM
,
812 'BADGE_STYLE_TYPE_LIVE_NOW': BadgeType
.LIVE_NOW
,
813 'BADGE_STYLE_TYPE_VERIFIED': BadgeType
.VERIFIED
,
814 'BADGE_STYLE_TYPE_VERIFIED_ARTIST': BadgeType
.VERIFIED
,
818 'unlisted': BadgeType
.AVAILABILITY_UNLISTED
,
819 'private': BadgeType
.AVAILABILITY_PRIVATE
,
820 'members only': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
821 'live': BadgeType
.LIVE_NOW
,
822 'premium': BadgeType
.AVAILABILITY_PREMIUM
,
823 'verified': BadgeType
.VERIFIED
,
824 'official artist channel': BadgeType
.VERIFIED
,
828 for badge
in traverse_obj(badge_list
, (..., lambda key
, _
: re
.search(r
'[bB]adgeRenderer$', key
))):
830 icon_type_map
.get(traverse_obj(badge
, ('icon', 'iconType'), expected_type
=str))
831 or badge_style_map
.get(traverse_obj(badge
, 'style'))
834 badges
.append({'type': badge_type}
)
837 # fallback, won't work in some languages
838 label
= traverse_obj(
839 badge
, 'label', ('accessibilityData', 'label'), 'tooltip', 'iconTooltip', get_all
=False, expected_type
=str, default
='')
840 for match
, label_badge_type
in label_map
.items():
841 if match
in label
.lower():
842 badges
.append({'type': label_badge_type}
)
848 def _has_badge(badges
, badge_type
):
849 return bool(traverse_obj(badges
, lambda _
, v
: v
['type'] == badge_type
))
852 def _get_text(data
, *path_list
, max_runs
=None):
853 for path
in path_list
or [None]:
857 obj
= traverse_obj(data
, path
, default
=[])
858 if not any(key
is ... or isinstance(key
, (list, tuple)) for key
in variadic(path
)):
861 text
= try_get(item
, lambda x
: x
['simpleText'], str)
864 runs
= try_get(item
, lambda x
: x
['runs'], list) or []
865 if not runs
and isinstance(item
, list):
868 runs
= runs
[:min(len(runs
), max_runs
or len(runs
))]
869 text
= ''.join(traverse_obj(runs
, (..., 'text'), expected_type
=str))
873 def _get_count(self
, data
, *path_list
):
874 count_text
= self
._get
_text
(data
, *path_list
) or ''
875 count
= parse_count(count_text
)
878 self
._search
_regex
(r
'^([\d,]+)', re
.sub(r
'\s', '', count_text
), 'count', default
=None))
882 def _extract_thumbnails(data
, *path_list
):
884 Extract thumbnails from thumbnails dict
885 @param path_list: path list to level that contains 'thumbnails' key
888 for path
in path_list
or [()]:
889 for thumbnail
in traverse_obj(data
, (*variadic(path
), 'thumbnails', ...)):
890 thumbnail_url
= url_or_none(thumbnail
.get('url'))
891 if not thumbnail_url
:
893 # Sometimes youtube gives a wrong thumbnail URL. See:
894 # https://github.com/yt-dlp/yt-dlp/issues/233
895 # https://github.com/ytdl-org/youtube-dl/issues/28023
896 if 'maxresdefault' in thumbnail_url
:
897 thumbnail_url
= thumbnail_url
.split('?')[0]
899 'url': thumbnail_url
,
900 'height': int_or_none(thumbnail
.get('height')),
901 'width': int_or_none(thumbnail
.get('width')),
906 def extract_relative_time(relative_time_text
):
908 Extracts a relative time from string and converts to dt object
909 e.g. 'streamed 6 days ago', '5 seconds ago (edited)', 'updated today', '8 yr ago'
912 # XXX: this could be moved to a general function in utils.py
913 # The relative time text strings are roughly the same as what
914 # Javascript's Intl.RelativeTimeFormat function generates.
915 # See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
917 r
'(?P<start>today|yesterday|now)|(?P<time>\d+)\s*(?P<unit>sec(?:ond)?|s|min(?:ute)?|h(?:our|r)?|d(?:ay)?|w(?:eek|k)?|mo(?:nth)?|y(?:ear|r)?)s?\s*ago',
920 start
= mobj
.group('start')
922 return datetime_from_str(start
)
924 return datetime_from_str('now-%s%s' % (mobj
.group('time'), mobj
.group('unit')))
928 def _parse_time_text(self
, text
):
931 dt
= self
.extract_relative_time(text
)
933 if isinstance(dt
, datetime
.datetime
):
934 timestamp
= calendar
.timegm(dt
.timetuple())
936 if timestamp
is None:
938 unified_timestamp(text
) or unified_timestamp(
940 (r
'([a-z]+\s*\d{1,2},?\s*20\d{2})', r
'(?:.+|^)(?:live|premieres|ed|ing)(?:\s*(?:on|for))?\s*(.+\d)'),
941 text
.lower(), 'time text', default
=None)))
943 if text
and timestamp
is None and self
._preferred
_lang
in (None, 'en'):
945 f
'Cannot parse localized time text "{text}"', only_once
=True)
948 def _extract_response(self
, item_id
, query
, note
='Downloading API JSON', headers
=None,
949 ytcfg
=None, check_get_keys
=None, ep
='browse', fatal
=True, api_hostname
=None,
950 default_client
='web'):
951 for retry
in self
.RetryManager():
953 response
= self
._call
_api
(
954 ep
=ep
, fatal
=True, headers
=headers
,
955 video_id
=item_id
, query
=query
, note
=note
,
956 context
=self
._extract
_context
(ytcfg
, default_client
),
957 api_key
=self
._extract
_api
_key
(ytcfg
, default_client
),
958 api_hostname
=api_hostname
, default_client
=default_client
)
959 except ExtractorError
as e
:
960 if not isinstance(e
.cause
, network_exceptions
):
961 return self
._error
_or
_warning
(e
, fatal
=fatal
)
962 elif not isinstance(e
.cause
, urllib
.error
.HTTPError
):
966 first_bytes
= e
.cause
.read(512)
967 if not is_html(first_bytes
):
970 self
._webpage
_read
_content
(e
.cause
, None, item_id
, prefix
=first_bytes
) or '{}', item_id
, fatal
=False),
971 lambda x
: x
['error']['message'], str)
973 self
._report
_alerts
([('ERROR', yt_error
)], fatal
=False)
974 # Downloading page may result in intermittent 5xx HTTP error
975 # Sometimes a 404 is also recieved. See: https://github.com/ytdl-org/youtube-dl/issues/28289
976 # We also want to catch all other network exceptions since errors in later pages can be troublesome
977 # See https://github.com/yt-dlp/yt-dlp/issues/507#issuecomment-880188210
978 if e
.cause
.code
not in (403, 429):
981 return self
._error
_or
_warning
(e
, fatal
=fatal
)
984 self
._extract
_and
_report
_alerts
(response
, only_once
=True)
985 except ExtractorError
as e
:
986 # YouTube servers may return errors we want to retry on in a 200 OK response
987 # See: https://github.com/yt-dlp/yt-dlp/issues/839
988 if 'unknown error' in e
.msg
.lower():
991 return self
._error
_or
_warning
(e
, fatal
=fatal
)
992 # Youtube sometimes sends incomplete data
993 # See: https://github.com/ytdl-org/youtube-dl/issues/28194
994 if not traverse_obj(response
, *variadic(check_get_keys
)):
995 retry
.error
= ExtractorError('Incomplete data received', expected
=True)
1001 def is_music_url(url
):
1002 return re
.match(r
'(https?://)?music\.youtube\.com/', url
) is not None
1004 def _extract_video(self
, renderer
):
1005 video_id
= renderer
.get('videoId')
1007 reel_header_renderer
= traverse_obj(renderer
, (
1008 'navigationEndpoint', 'reelWatchEndpoint', 'overlay', 'reelPlayerOverlayRenderer',
1009 'reelPlayerHeaderSupportedRenderers', 'reelPlayerHeaderRenderer'))
1011 title
= self
._get
_text
(renderer
, 'title', 'headline') or self
._get
_text
(reel_header_renderer
, 'reelTitleText')
1012 description
= self
._get
_text
(renderer
, 'descriptionSnippet')
1014 duration
= int_or_none(renderer
.get('lengthSeconds'))
1015 if duration
is None:
1016 duration
= parse_duration(self
._get
_text
(
1017 renderer
, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
1018 if duration
is None:
1019 # XXX: should write a parser to be more general to support more cases (e.g. shorts in shorts tab)
1020 duration
= parse_duration(self
._search
_regex
(
1021 r
'(?i)(ago)(?!.*\1)\s+(?P<duration>[a-z0-9 ,]+?)(?:\s+[\d,]+\s+views)?(?:\s+-\s+play\s+short)?$',
1022 traverse_obj(renderer
, ('title', 'accessibility', 'accessibilityData', 'label'), default
='', expected_type
=str),
1023 video_id
, default
=None, group
='duration'))
1025 channel_id
= traverse_obj(
1026 renderer
, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'),
1027 expected_type
=str, get_all
=False)
1029 channel_id
= traverse_obj(reel_header_renderer
, ('channelNavigationEndpoint', 'browseEndpoint', 'browseId'))
1031 channel_id
= self
.ucid_or_none(channel_id
)
1033 overlay_style
= traverse_obj(
1034 renderer
, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'),
1035 get_all
=False, expected_type
=str)
1036 badges
= self
._extract
_badges
(traverse_obj(renderer
, 'badges'))
1037 owner_badges
= self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges'))
1038 navigation_url
= urljoin('https://www.youtube.com/', traverse_obj(
1039 renderer
, ('navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url'),
1040 expected_type
=str)) or ''
1041 url
= f
'https://www.youtube.com/watch?v={video_id}'
1042 if overlay_style
== 'SHORTS' or '/shorts/' in navigation_url
:
1043 url
= f
'https://www.youtube.com/shorts/{video_id}'
1045 time_text
= (self
._get
_text
(renderer
, 'publishedTimeText', 'videoInfo')
1046 or self
._get
_text
(reel_header_renderer
, 'timestampText') or '')
1047 scheduled_timestamp
= str_to_int(traverse_obj(renderer
, ('upcomingEventData', 'startTime'), get_all
=False))
1050 'is_upcoming' if scheduled_timestamp
is not None
1051 else 'was_live' if 'streamed' in time_text
.lower()
1052 else 'is_live' if overlay_style
== 'LIVE' or self
._has
_badge
(badges
, BadgeType
.LIVE_NOW
)
1055 # videoInfo is a string like '50K views • 10 years ago'.
1056 view_count_text
= self
._get
_text
(renderer
, 'viewCountText', 'shortViewCountText', 'videoInfo') or ''
1057 view_count
= (0 if 'no views' in view_count_text
.lower()
1058 else self
._get
_count
({'simpleText': view_count_text}
))
1059 view_count_field
= 'concurrent_view_count' if live_status
in ('is_live', 'is_upcoming') else 'view_count'
1061 channel
= (self
._get
_text
(renderer
, 'ownerText', 'shortBylineText')
1062 or self
._get
_text
(reel_header_renderer
, 'channelTitleText'))
1064 channel_handle
= traverse_obj(renderer
, (
1065 'shortBylineText', 'runs', ..., 'navigationEndpoint',
1066 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl'))),
1067 expected_type
=self
.handle_from_url
, get_all
=False)
1070 'ie_key': YoutubeIE
.ie_key(),
1074 'description': description
,
1075 'duration': duration
,
1076 'channel_id': channel_id
,
1078 'channel_url': f
'https://www.youtube.com/channel/{channel_id}' if channel_id
else None,
1079 'uploader': channel
,
1080 'uploader_id': channel_handle
,
1081 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
1082 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
1083 'timestamp': (self
._parse
_time
_text
(time_text
)
1084 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
1086 'release_timestamp': scheduled_timestamp
,
1088 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
1089 else self
._availability
(
1090 is_private
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
) or None,
1091 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
1092 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
1093 is_unlisted
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
) or None),
1094 view_count_field
: view_count
,
1095 'live_status': live_status
,
1096 'channel_is_verified': True if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
) else None
1100 class YoutubeIE(YoutubeBaseInfoExtractor
):
1102 _VALID_URL
= r
"""(?x)^
1104 (?:https?://|//) # http(s):// or protocol-independent URL
1105 (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
1106 (?:www\.)?deturl\.com/www\.youtube\.com|
1107 (?:www\.)?pwnyoutube\.com|
1108 (?:www\.)?hooktube\.com|
1109 (?:www\.)?yourepeat\.com|
1110 tube\.majestyc\.net|
1112 youtube\.googleapis\.com)/ # the various hostnames, with wildcard subdomains
1113 (?:.*?\#/)? # handle anchor (#/) redirect urls
1114 (?: # the various things that can precede the ID:
1115 (?:(?:v|embed|e|shorts|live)/(?!videoseries|live_stream)) # v/ or embed/ or e/ or shorts/
1116 |(?: # or the v= param in all its forms
1117 (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
1118 (?:\?|\#!?) # the params delimiter ? or # or #!
1119 (?:.*?[&;])?? # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&v=V36LpHqtcDY)
1124 youtu\.be| # just youtu.be/xxxx
1125 vid\.plus| # or vid.plus/xxxx
1126 zwearz\.com/watch| # or zwearz.com/watch/xxxx
1129 |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
1131 )? # all until now is optional -> you can pass the naked ID
1132 (?P<id>[0-9A-Za-z_-]{11}) # here is it! the YouTube video ID
1133 (?(1).+)? # if we found the ID, everything can follow
1135 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
1140 <(?:[0-9A-Za-z-]+?)?iframe[^>]+?src=|
1148 (?P
<url
>(?
:https?
:)?
//(?
:www\
.)?
youtube(?
:-nocookie
)?\
.com
/
1149 (?
:embed|v|p
)/[0-9A
-Za
-z_
-]{11}
.*?
)
1151 # https://wordpress.org/plugins/lazy-load-for-videos/
1153 <a\s
[^
>]*\bhref
="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"
1154 \s
[^
>]*\bclass
="[^"]*\blazy
-load
-youtube
''',
1156 _RETURN_TYPE = 'video' # XXX: How to handle multifeed?
1159 r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
1160 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$',
1161 r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
1164 '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1165 '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1166 '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
1167 '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
1168 '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
1169 '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1170 '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1171 '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1172 # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
1173 '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
1174 '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1175 '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1176 '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1177 '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1178 '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1179 '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1180 '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1181 '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1185 '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1186 '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1187 '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1188 '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1189 '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
1190 '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1191 '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1193 # Apple HTTP Live Streaming
1194 '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1195 '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1196 '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1197 '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1198 '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1199 '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1200 '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1201 '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
1204 '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
1205 '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
1206 '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1207 '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
1208 '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
1209 '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'}, # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
1210 '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
1211 '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1212 '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
1213 '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1214 '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1215 '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
1218 '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
1219 '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
1220 '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
1221 '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1222 '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1223 '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
1224 '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
1227 '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1228 '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1229 '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1230 '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1231 '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1232 '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1233 '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
1234 '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1235 '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1236 '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1237 '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1238 '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1239 '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1240 '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1241 '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1242 # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
1243 '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1244 '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1245 '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1246 '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1247 '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1248 '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1251 '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
1252 '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
1254 # Dash webm audio with opus inside
1255 '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
1256 '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
1257 '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
1260 '_rtmp': {'protocol': 'rtmp'},
1262 # av01 video only formats sometimes served with "unknown" codecs
1263 '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1264 '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1265 '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1266 '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1267 '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1268 '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1269 '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1270 '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1272 _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1279 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1281 'id': 'BaW_jenozKc',
1283 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1284 'channel': 'Philipp Hagemeister',
1285 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1286 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1287 'upload_date': '20121002',
1288 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1289 'categories': ['Science & Technology'],
1290 'tags': ['youtube-dl'],
1294 'availability': 'public',
1295 'playable_in_embed': True,
1296 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1297 'live_status': 'not_live',
1301 'comment_count': int,
1302 'channel_follower_count': int,
1303 'uploader': 'Philipp Hagemeister',
1304 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1305 'uploader_id': '@PhilippHagemeister',
1306 'heatmap': 'count:100',
1310 'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1311 'note': 'Embed-only video (#1746)',
1313 'id': 'yZIXLfi8CZQ',
1315 'upload_date': '20120608',
1316 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1317 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1320 'skip': 'Private video',
1323 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1324 'note': 'Use the first video ID in the URL',
1326 'id': 'BaW_jenozKc',
1328 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1329 'channel': 'Philipp Hagemeister',
1330 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1331 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1332 'upload_date': '20121002',
1333 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1334 'categories': ['Science & Technology'],
1335 'tags': ['youtube-dl'],
1339 'availability': 'public',
1340 'playable_in_embed': True,
1341 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1342 'live_status': 'not_live',
1344 'comment_count': int,
1345 'channel_follower_count': int,
1346 'uploader': 'Philipp Hagemeister',
1347 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1348 'uploader_id': '@PhilippHagemeister',
1349 'heatmap': 'count:100',
1352 'skip_download': True,
1356 'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1357 'note': '256k DASH audio (format 141) via DASH manifest',
1359 'id': 'a9LDPn-MO4I',
1361 'upload_date': '20121002',
1363 'title': 'UHDTV TEST 8K VIDEO.mp4'
1366 'youtube_include_dash_manifest': True,
1369 'skip': 'format 141 not served anymore',
1371 # DASH manifest with encrypted signature
1373 'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1375 'id': 'IB3lcPjvWLA',
1377 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1378 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1380 'upload_date': '20131011',
1383 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1384 'playable_in_embed': True,
1385 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1387 'track': 'The Spark',
1388 'live_status': 'not_live',
1389 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1390 'channel': 'Afrojack',
1392 'availability': 'public',
1393 'categories': ['Music'],
1395 'alt_title': 'The Spark',
1396 'channel_follower_count': int,
1397 'uploader': 'Afrojack',
1398 'uploader_url': 'https://www.youtube.com/@Afrojack',
1399 'uploader_id': '@Afrojack',
1402 'youtube_include_dash_manifest': True,
1403 'format': '141/bestaudio[ext=m4a]',
1406 # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1408 'note': 'Embed allowed age-gate video',
1409 'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1411 'id': 'HtVdAasjOgU',
1413 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1414 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1416 'upload_date': '20140605',
1418 'categories': ['Gaming'],
1419 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1420 'availability': 'needs_auth',
1421 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1423 'channel': 'The Witcher',
1424 'live_status': 'not_live',
1426 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1427 'playable_in_embed': True,
1429 'channel_follower_count': int,
1430 'uploader': 'The Witcher',
1431 'uploader_url': 'https://www.youtube.com/@thewitcher',
1432 'uploader_id': '@thewitcher',
1433 'comment_count': int,
1434 'channel_is_verified': True,
1435 'heatmap': 'count:100',
1439 'note': 'Age-gate video with embed allowed in public site',
1440 'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1442 'id': 'HsUATh_Nc2U',
1444 'title': 'Godzilla 2 (Official Video)',
1445 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1446 'upload_date': '20200408',
1448 'availability': 'needs_auth',
1449 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1450 'channel': 'FlyingKitty',
1451 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1453 'categories': ['Entertainment'],
1454 'live_status': 'not_live',
1455 'tags': ['Flyingkitty', 'godzilla 2'],
1456 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1459 'playable_in_embed': True,
1460 'channel_follower_count': int,
1461 'uploader': 'FlyingKitty',
1462 'uploader_url': 'https://www.youtube.com/@FlyingKitty900',
1463 'uploader_id': '@FlyingKitty900',
1464 'comment_count': int,
1465 'channel_is_verified': True,
1469 'note': 'Age-gate video embedable only with clientScreen=EMBED',
1470 'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1472 'id': 'Tq92D6wQ1mg',
1473 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1475 'upload_date': '20191228',
1476 'description': 'md5:17eccca93a786d51bc67646756894066',
1479 'availability': 'needs_auth',
1480 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1482 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1483 'channel': 'Projekt Melody',
1484 'live_status': 'not_live',
1485 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1486 'playable_in_embed': True,
1487 'categories': ['Entertainment'],
1489 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1490 'comment_count': int,
1491 'channel_follower_count': int,
1492 'uploader': 'Projekt Melody',
1493 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
1494 'uploader_id': '@ProjektMelody',
1498 'note': 'Non-Agegated non-embeddable video',
1499 'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1501 'id': 'MeJVWBSsPAY',
1503 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1504 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1505 'upload_date': '20130730',
1506 'track': 'Such mich find mich',
1508 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1510 'playable_in_embed': False,
1511 'creator': 'OOMPH!',
1512 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1514 'alt_title': 'Such mich find mich',
1516 'channel': 'Herr Lurik',
1517 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1518 'categories': ['Music'],
1519 'availability': 'public',
1520 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1521 'live_status': 'not_live',
1523 'channel_follower_count': int,
1524 'uploader': 'Herr Lurik',
1525 'uploader_url': 'https://www.youtube.com/@HerrLurik',
1526 'uploader_id': '@HerrLurik',
1530 'note': 'Non-bypassable age-gated video',
1531 'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1532 'only_matching': True,
1534 # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1535 # YouTube Red ad is not captured for creator
1537 'url': '__2ABJjxzNo',
1539 'id': '__2ABJjxzNo',
1542 'upload_date': '20100430',
1543 'creator': 'deadmau5',
1544 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1545 'title': 'Deadmau5 - Some Chords (HD)',
1546 'alt_title': 'Some Chords',
1547 'availability': 'public',
1549 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1551 'live_status': 'not_live',
1552 'channel': 'deadmau5',
1553 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1555 'track': 'Some Chords',
1556 'artist': 'deadmau5',
1557 'playable_in_embed': True,
1559 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1560 'categories': ['Music'],
1561 'album': 'Some Chords',
1562 'channel_follower_count': int,
1563 'uploader': 'deadmau5',
1564 'uploader_url': 'https://www.youtube.com/@deadmau5',
1565 'uploader_id': '@deadmau5',
1567 'expected_warnings': [
1568 'DASH manifest missing',
1571 # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1573 'url': 'lqQg6PlCWgI',
1575 'id': 'lqQg6PlCWgI',
1578 'upload_date': '20150827',
1579 'description': 'md5:04bbbf3ccceb6795947572ca36f45904',
1580 'title': 'Hockey - Women - GER-AUS - London 2012 Olympic Games',
1582 'release_timestamp': 1343767800,
1583 'playable_in_embed': True,
1584 'categories': ['Sports'],
1585 'release_date': '20120731',
1586 'channel': 'Olympics',
1587 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1588 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1589 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1591 'availability': 'public',
1592 'live_status': 'was_live',
1594 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1595 'channel_follower_count': int,
1596 'uploader': 'Olympics',
1597 'uploader_url': 'https://www.youtube.com/@Olympics',
1598 'uploader_id': '@Olympics',
1599 'channel_is_verified': True,
1602 'skip_download': 'requires avconv',
1607 'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1609 'id': '_b-2C3KPAM0',
1611 'stretched_ratio': 16 / 9.,
1613 'upload_date': '20110310',
1614 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1615 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1616 'playable_in_embed': True,
1620 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1621 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1622 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1624 'categories': ['People & Blogs'],
1626 'live_status': 'not_live',
1627 'availability': 'unlisted',
1628 'comment_count': int,
1629 'channel_follower_count': int,
1631 'uploader_url': 'https://www.youtube.com/@AllenMeow',
1632 'uploader_id': '@AllenMeow',
1635 # url_encoded_fmt_stream_map is empty string
1637 'url': 'qEJwOuvDf7I',
1639 'id': 'qEJwOuvDf7I',
1641 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1643 'upload_date': '20150404',
1646 'skip_download': 'requires avconv',
1648 'skip': 'This live event has ended.',
1650 # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1652 'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1654 'id': 'FIl7x6_3R5Y',
1656 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1657 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1659 'upload_date': '20150625',
1660 'formats': 'mincount:31',
1662 'skip': 'not actual anymore',
1664 # DASH manifest with segment_list
1666 'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1667 'md5': '8ce563a1d667b599d21064e982ab9e31',
1669 'id': 'CsmdDsKjzN8',
1671 'upload_date': '20150501', # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1672 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1673 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1676 'youtube_include_dash_manifest': True,
1677 'format': '135', # bestvideo
1679 'skip': 'This live event has ended.',
1682 # Multifeed videos (multiple cameras), URL can be of any Camera
1683 # TODO: fix multifeed titles
1684 'url': 'https://www.youtube.com/watch?v=zaPI8MvL8pg',
1686 'id': 'zaPI8MvL8pg',
1687 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04',
1688 'description': 'md5:563ccbc698b39298481ca3c571169519',
1692 'id': 'j5yGuxZ8lLU',
1694 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Chris)',
1695 'description': 'md5:563ccbc698b39298481ca3c571169519',
1697 'channel_follower_count': int,
1698 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1699 'availability': 'public',
1700 'playable_in_embed': True,
1701 'upload_date': '20131105',
1702 'categories': ['Gaming'],
1703 'live_status': 'was_live',
1705 'release_timestamp': 1383701910,
1706 'thumbnail': 'https://i.ytimg.com/vi/j5yGuxZ8lLU/maxresdefault.jpg',
1707 'comment_count': int,
1710 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1711 'channel': 'WiiLikeToPlay',
1713 'release_date': '20131106',
1714 'uploader': 'WiiLikeToPlay',
1715 'uploader_id': '@WLTP',
1716 'uploader_url': 'https://www.youtube.com/@WLTP',
1720 'id': 'zaPI8MvL8pg',
1722 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Tyson)',
1723 'availability': 'public',
1724 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1725 'channel': 'WiiLikeToPlay',
1726 'channel_follower_count': int,
1727 'description': 'md5:563ccbc698b39298481ca3c571169519',
1732 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1733 'release_timestamp': 1383701915,
1734 'comment_count': int,
1735 'upload_date': '20131105',
1736 'thumbnail': 'https://i.ytimg.com/vi/zaPI8MvL8pg/maxresdefault.jpg',
1737 'release_date': '20131106',
1738 'playable_in_embed': True,
1739 'live_status': 'was_live',
1740 'categories': ['Gaming'],
1742 'uploader': 'WiiLikeToPlay',
1743 'uploader_id': '@WLTP',
1744 'uploader_url': 'https://www.youtube.com/@WLTP',
1748 'id': 'R7r3vfO7Hao',
1750 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Spencer)',
1751 'thumbnail': 'https://i.ytimg.com/vi/R7r3vfO7Hao/maxresdefault.jpg',
1752 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1754 'availability': 'public',
1755 'playable_in_embed': True,
1756 'upload_date': '20131105',
1757 'description': 'md5:563ccbc698b39298481ca3c571169519',
1758 'channel_follower_count': int,
1760 'release_date': '20131106',
1761 'comment_count': int,
1762 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1763 'channel': 'WiiLikeToPlay',
1764 'categories': ['Gaming'],
1765 'release_timestamp': 1383701914,
1766 'live_status': 'was_live',
1770 'uploader': 'WiiLikeToPlay',
1771 'uploader_id': '@WLTP',
1772 'uploader_url': 'https://www.youtube.com/@WLTP',
1775 'params': {'skip_download': True},
1778 # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1779 'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1781 'id': 'gVfLd0zydlo',
1782 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1784 'playlist_count': 2,
1785 'skip': 'Not multifeed anymore',
1788 'url': 'https://vid.plus/FlRa-iH7PGw',
1789 'only_matching': True,
1792 'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1793 'only_matching': True,
1796 # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1797 # Also tests cut-off URL expansion in video description (see
1798 # https://github.com/ytdl-org/youtube-dl/issues/1892,
1799 # https://github.com/ytdl-org/youtube-dl/issues/8164)
1800 'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1802 'id': 'lsguqyKfVQg',
1804 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1805 'alt_title': 'Dark Walk',
1806 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1808 'upload_date': '20151119',
1809 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1810 'track': 'Dark Walk',
1811 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1812 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1813 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1814 'categories': ['Film & Animation'],
1816 'live_status': 'not_live',
1817 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1818 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1820 'availability': 'public',
1821 'channel': 'IronSoulElf',
1822 'playable_in_embed': True,
1825 'channel_follower_count': int
1828 'skip_download': True,
1832 # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1833 'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1834 'only_matching': True,
1837 # Video with yt:stretch=17:0
1838 'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1840 'id': 'Q39EVAstoRM',
1842 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1843 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1844 'upload_date': '20151107',
1847 'skip_download': True,
1849 'skip': 'This video does not exist.',
1852 # Video with incomplete 'yt:stretch=16:'
1853 'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1854 'only_matching': True,
1857 # Video licensed under Creative Commons
1858 'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1860 'id': 'M4gD1WSo5mA',
1862 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1863 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1865 'upload_date': '20150128',
1866 'license': 'Creative Commons Attribution license (reuse allowed)',
1867 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1868 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1871 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1872 'channel': 'The Berkman Klein Center for Internet & Society',
1873 'availability': 'public',
1875 'categories': ['Education'],
1876 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1877 'live_status': 'not_live',
1878 'playable_in_embed': True,
1879 'channel_follower_count': int,
1881 'uploader': 'The Berkman Klein Center for Internet & Society',
1882 'uploader_id': '@BKCHarvard',
1883 'uploader_url': 'https://www.youtube.com/@BKCHarvard',
1886 'skip_download': True,
1890 'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1892 'id': 'eQcmzGIKrzg',
1894 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1895 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1897 'upload_date': '20151120',
1898 'license': 'Creative Commons Attribution license (reuse allowed)',
1899 'playable_in_embed': True,
1902 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1904 'availability': 'public',
1905 'categories': ['News & Politics'],
1906 'channel': 'Bernie Sanders',
1907 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1909 'live_status': 'not_live',
1910 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1911 'comment_count': int,
1912 'channel_follower_count': int,
1914 'uploader': 'Bernie Sanders',
1915 'uploader_url': 'https://www.youtube.com/@BernieSanders',
1916 'uploader_id': '@BernieSanders',
1917 'channel_is_verified': True,
1918 'heatmap': 'count:100',
1921 'skip_download': True,
1925 'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;v=V36LpHqtcDY',
1926 'only_matching': True,
1929 # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1930 'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1931 'only_matching': True,
1934 # Rental video preview
1935 'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1937 'id': 'uGpuVWrhIzE',
1939 'title': 'Piku - Trailer',
1940 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1941 'upload_date': '20150811',
1942 'license': 'Standard YouTube License',
1945 'skip_download': True,
1947 'skip': 'This video is not available.',
1950 # YouTube Red video with episode data
1951 'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1953 'id': 'iqKdEhx-dD4',
1955 'title': 'Isolation - Mind Field (Ep 1)',
1956 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1958 'upload_date': '20170118',
1959 'series': 'Mind Field',
1961 'episode_number': 1,
1962 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1965 'availability': 'public',
1967 'channel': 'Vsauce',
1968 'episode': 'Episode 1',
1969 'categories': ['Entertainment'],
1970 'season': 'Season 1',
1971 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
1972 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
1974 'playable_in_embed': True,
1975 'live_status': 'not_live',
1976 'channel_follower_count': int,
1977 'uploader': 'Vsauce',
1978 'uploader_url': 'https://www.youtube.com/@Vsauce',
1979 'uploader_id': '@Vsauce',
1980 'comment_count': int,
1981 'channel_is_verified': True,
1984 'skip_download': True,
1986 'expected_warnings': [
1987 'Skipping DASH manifest',
1991 # The following content has been identified by the YouTube community
1992 # as inappropriate or offensive to some audiences.
1993 'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
1995 'id': '6SJNVb0GnPI',
1997 'title': 'Race Differences in Intelligence',
1998 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
2000 'upload_date': '20140124',
2003 'skip_download': True,
2005 'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
2009 'url': '1t24XAntNCY',
2010 'only_matching': True,
2013 # geo restricted to JP
2014 'url': 'sJL6WA-aGkQ',
2015 'only_matching': True,
2018 'url': 'https://invidio.us/watch?v=BaW_jenozKc',
2019 'only_matching': True,
2022 'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
2023 'only_matching': True,
2026 # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
2027 'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
2028 'only_matching': True,
2032 'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
2033 'only_matching': True,
2036 # Video with unsupported adaptive stream type formats
2037 'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
2039 'id': 'Z4Vy8R84T1U',
2041 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
2042 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
2044 'upload_date': '20130923',
2045 'formats': 'maxcount:10',
2048 'skip_download': True,
2049 'youtube_include_dash_manifest': False,
2051 'skip': 'not actual anymore',
2054 # Youtube Music Auto-generated description
2055 # TODO: fix metadata extraction
2056 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2058 'id': 'MgNrAu2pzNs',
2060 'title': 'Voyeur Girl',
2061 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
2062 'upload_date': '20190312',
2063 'artist': 'Stephen',
2064 'track': 'Voyeur Girl',
2065 'album': 'it\'s too much love to know my dear',
2066 'release_date': '20190313',
2067 'release_year': 2019,
2068 'alt_title': 'Voyeur Girl',
2070 'playable_in_embed': True,
2072 'categories': ['Music'],
2073 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
2074 'channel': 'Stephen', # TODO: should be "Stephen - Topic"
2075 'uploader': 'Stephen',
2076 'availability': 'public',
2077 'creator': 'Stephen',
2079 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
2081 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
2083 'live_status': 'not_live',
2084 'channel_follower_count': int
2087 'skip_download': True,
2091 'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
2092 'only_matching': True,
2095 # invalid -> valid video id redirection
2096 'url': 'DJztXj2GPfl',
2098 'id': 'DJztXj2GPfk',
2100 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
2101 'description': 'md5:bf577a41da97918e94fa9798d9228825',
2102 'upload_date': '20090125',
2103 'artist': 'Panjabi MC',
2104 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
2105 'album': 'Beware of the Boys (Mundian To Bach Ke)',
2108 'skip_download': True,
2110 'skip': 'Video unavailable',
2113 # empty description results in an empty string
2114 'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
2116 'id': 'x41yOUIvK2k',
2118 'title': 'IMG 3456',
2120 'upload_date': '20170613',
2122 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
2124 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
2126 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
2127 'availability': 'public',
2129 'categories': ['Pets & Animals'],
2131 'playable_in_embed': True,
2132 'live_status': 'not_live',
2133 'channel': 'l\'Or Vert asbl',
2134 'channel_follower_count': int,
2135 'uploader': 'l\'Or Vert asbl',
2136 'uploader_url': 'https://www.youtube.com/@ElevageOrVert',
2137 'uploader_id': '@ElevageOrVert',
2140 'skip_download': True,
2144 # with '};' inside yt initial data (see [1])
2145 # see [2] for an example with '};' inside ytInitialPlayerResponse
2146 # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
2147 # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
2148 'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
2150 'id': 'CHqg6qOn4no',
2152 'title': 'Part 77 Sort a list of simple types in c#',
2153 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
2154 'upload_date': '20130831',
2155 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
2157 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
2158 'live_status': 'not_live',
2159 'categories': ['Education'],
2160 'availability': 'public',
2161 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
2163 'playable_in_embed': True,
2167 'channel': 'kudvenkat',
2168 'comment_count': int,
2169 'channel_follower_count': int,
2171 'uploader': 'kudvenkat',
2172 'uploader_url': 'https://www.youtube.com/@Csharp-video-tutorialsBlogspot',
2173 'uploader_id': '@Csharp-video-tutorialsBlogspot',
2174 'channel_is_verified': True,
2175 'heatmap': 'count:100',
2178 'skip_download': True,
2182 # another example of '};' in ytInitialData
2183 'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
2184 'only_matching': True,
2187 'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
2188 'only_matching': True,
2191 # https://github.com/ytdl-org/youtube-dl/pull/28094
2192 'url': 'OtqTfy26tG0',
2194 'id': 'OtqTfy26tG0',
2196 'title': 'Burn Out',
2197 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
2198 'upload_date': '20141120',
2199 'artist': 'The Cinematic Orchestra',
2200 'track': 'Burn Out',
2201 'album': 'Every Day',
2203 'live_status': 'not_live',
2204 'alt_title': 'Burn Out',
2208 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2209 'creator': 'The Cinematic Orchestra',
2210 'channel': 'The Cinematic Orchestra',
2211 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
2212 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2213 'availability': 'public',
2214 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
2215 'categories': ['Music'],
2216 'playable_in_embed': True,
2217 'channel_follower_count': int,
2218 'uploader': 'The Cinematic Orchestra',
2219 'comment_count': int,
2222 'skip_download': True,
2226 # controversial video, only works with bpctr when authenticated with cookies
2227 'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
2228 'only_matching': True,
2231 # controversial video, requires bpctr/contentCheckOk
2232 'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
2234 'id': 'SZJvDhaSDnc',
2236 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
2237 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
2238 'upload_date': '20140716',
2239 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
2241 'categories': ['News & Politics'],
2243 'channel': 'CBS Mornings',
2244 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
2245 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
2247 'availability': 'needs_auth',
2248 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
2250 'live_status': 'not_live',
2251 'playable_in_embed': True,
2252 'channel_follower_count': int,
2253 'uploader': 'CBS Mornings',
2254 'uploader_url': 'https://www.youtube.com/@CBSMornings',
2255 'uploader_id': '@CBSMornings',
2256 'comment_count': int,
2257 'channel_is_verified': True,
2261 # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
2262 'url': 'cBvYw8_A0vQ',
2264 'id': 'cBvYw8_A0vQ',
2266 'title': '4K Ueno Okachimachi Street Scenes 上野御徒町歩き',
2267 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
2268 'upload_date': '20201120',
2270 'categories': ['Travel & Events'],
2271 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2273 'channel': 'Walk around Japan',
2274 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
2275 'thumbnail': 'https://i.ytimg.com/vi_webp/cBvYw8_A0vQ/hqdefault.webp',
2277 'availability': 'public',
2278 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2279 'live_status': 'not_live',
2280 'playable_in_embed': True,
2281 'channel_follower_count': int,
2282 'uploader': 'Walk around Japan',
2283 'uploader_url': 'https://www.youtube.com/@walkaroundjapan7124',
2284 'uploader_id': '@walkaroundjapan7124',
2287 'skip_download': True,
2290 # Has multiple audio streams
2291 'url': 'WaOKSUlf4TM',
2292 'only_matching': True
2294 # Requires Premium: has format 141 when requested using YTM url
2295 'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2296 'only_matching': True
2298 # multiple subtitles with same lang_code
2299 'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2300 'only_matching': True,
2302 # Force use android client fallback
2303 'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2305 'id': 'YOelRv7fMxY',
2306 'title': 'DIGGING A SECRET TUNNEL Part 1',
2308 'upload_date': '20210624',
2309 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2310 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2311 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2313 'categories': ['Entertainment'],
2315 'channel': 'colinfurze',
2316 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2317 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2319 'availability': 'public',
2321 'live_status': 'not_live',
2322 'playable_in_embed': True,
2323 'channel_follower_count': int,
2325 'uploader': 'colinfurze',
2326 'uploader_url': 'https://www.youtube.com/@colinfurze',
2327 'uploader_id': '@colinfurze',
2328 'comment_count': int,
2329 'channel_is_verified': True,
2330 'heatmap': 'count:100',
2333 'format': '17', # 3gp format available on android
2334 'extractor_args': {'youtube': {'player_client': ['android']}},
2338 # Skip download of additional client configs (remix client config in this case)
2339 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2340 'only_matching': True,
2342 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2346 'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2347 'only_matching': True,
2349 'note': 'Storyboards',
2350 'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2352 'id': '5KLPxDtMqe8',
2355 'title': 'Your Brain is Plastic',
2356 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2357 'upload_date': '20140324',
2359 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2360 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2362 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2363 'playable_in_embed': True,
2365 'availability': 'public',
2366 'channel': 'SciShow',
2367 'live_status': 'not_live',
2369 'categories': ['Education'],
2371 'channel_follower_count': int,
2373 'uploader': 'SciShow',
2374 'uploader_url': 'https://www.youtube.com/@SciShow',
2375 'uploader_id': '@SciShow',
2376 'comment_count': int,
2377 'channel_is_verified': True,
2378 'heatmap': 'count:100',
2379 }, 'params': {'format': 'mhtml', 'skip_download': True}
2381 # Ensure video upload_date is in UTC timezone (video was uploaded 1641170939)
2382 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2384 'id': '2NUZ8W2llS4',
2386 'title': 'The NP that test your phone performance 🙂',
2387 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2388 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2389 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2393 'categories': ['Gaming'],
2395 'playable_in_embed': True,
2396 'live_status': 'not_live',
2397 'upload_date': '20220103',
2399 'availability': 'public',
2400 'channel': 'Leon Nguyen',
2401 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2402 'comment_count': int,
2403 'channel_follower_count': int,
2404 'uploader': 'Leon Nguyen',
2405 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2406 'uploader_id': '@LeonNguyen',
2407 'heatmap': 'count:100',
2410 # Same video as above, but with --compat-opt no-youtube-prefer-utc-upload-date
2411 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2413 'id': '2NUZ8W2llS4',
2415 'title': 'The NP that test your phone performance 🙂',
2416 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2417 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2418 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2422 'categories': ['Gaming'],
2424 'playable_in_embed': True,
2425 'live_status': 'not_live',
2426 'upload_date': '20220102',
2428 'availability': 'public',
2429 'channel': 'Leon Nguyen',
2430 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2431 'comment_count': int,
2432 'channel_follower_count': int,
2433 'uploader': 'Leon Nguyen',
2434 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2435 'uploader_id': '@LeonNguyen',
2436 'heatmap': 'count:100',
2438 'params': {'compat_opts': ['no-youtube-prefer-utc-upload-date']}
2440 # date text is premiered video, ensure upload date in UTC (published 1641172509)
2441 'url': 'https://www.youtube.com/watch?v=mzZzzBU6lrM',
2443 'id': 'mzZzzBU6lrM',
2445 'title': 'I Met GeorgeNotFound In Real Life...',
2446 'description': 'md5:978296ec9783a031738b684d4ebf302d',
2447 'channel_id': 'UC_8NknAFiyhOUaZqHR3lq3Q',
2448 'channel_url': 'https://www.youtube.com/channel/UC_8NknAFiyhOUaZqHR3lq3Q',
2452 'categories': ['Entertainment'],
2454 'playable_in_embed': True,
2455 'live_status': 'not_live',
2456 'release_timestamp': 1641172509,
2457 'release_date': '20220103',
2458 'upload_date': '20220103',
2460 'availability': 'public',
2461 'channel': 'Quackity',
2462 'thumbnail': 'https://i.ytimg.com/vi/mzZzzBU6lrM/maxresdefault.jpg',
2463 'channel_follower_count': int,
2464 'uploader': 'Quackity',
2465 'uploader_id': '@Quackity',
2466 'uploader_url': 'https://www.youtube.com/@Quackity',
2467 'comment_count': int,
2468 'channel_is_verified': True,
2469 'heatmap': 'count:100',
2472 { # continuous livestream. Microformat upload date should be preferred.
2473 # Upload date was 2021-06-19 (not UTC), while stream start is 2021-11-27
2474 'url': 'https://www.youtube.com/watch?v=kgx4WGK0oNU',
2476 'id': 'kgx4WGK0oNU',
2477 '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}',
2479 'channel_id': 'UC84whx2xxsiA1gXHXXqKGOA',
2480 'availability': 'public',
2482 'release_timestamp': 1637975704,
2483 'upload_date': '20210619',
2484 'channel_url': 'https://www.youtube.com/channel/UC84whx2xxsiA1gXHXXqKGOA',
2485 'live_status': 'is_live',
2486 'thumbnail': 'https://i.ytimg.com/vi/kgx4WGK0oNU/maxresdefault.jpg',
2487 'channel': 'Abao in Tokyo',
2488 'channel_follower_count': int,
2489 'release_date': '20211127',
2491 'categories': ['People & Blogs'],
2494 'playable_in_embed': True,
2495 'description': 'md5:2ef1d002cad520f65825346e2084e49d',
2496 'concurrent_view_count': int,
2497 'uploader': 'Abao in Tokyo',
2498 'uploader_url': 'https://www.youtube.com/@abaointokyo',
2499 'uploader_id': '@abaointokyo',
2501 'params': {'skip_download': True}
2503 'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2505 'id': 'tjjjtzRLHvA',
2507 'title': 'ハッシュタグ無し };if window.ytcsi',
2508 'upload_date': '20220323',
2510 'availability': 'unlisted',
2511 'channel': 'Lesmiscore',
2512 'thumbnail': r're:^https?://.*\.jpg',
2514 'categories': ['Music'],
2517 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2518 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2519 'live_status': 'not_live',
2520 'playable_in_embed': True,
2521 'channel_follower_count': int,
2524 'uploader_id': '@lesmiscore',
2525 'uploader': 'Lesmiscore',
2526 'uploader_url': 'https://www.youtube.com/@lesmiscore',
2529 # Prefer primary title+description language metadata by default
2530 # Do not prefer translated description if primary is empty
2531 'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2533 'id': 'el3E4MbxRqQ',
2535 'title': 'dlp test video 2 - primary sv no desc',
2537 'channel': 'cole-dlp-test-acc',
2540 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2542 'playable_in_embed': True,
2543 'availability': 'unlisted',
2544 'thumbnail': r're:^https?://.*\.jpg',
2547 'live_status': 'not_live',
2548 'upload_date': '20220908',
2549 'categories': ['People & Blogs'],
2550 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2551 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2552 'uploader_id': '@coletdjnz',
2553 'uploader': 'cole-dlp-test-acc',
2555 'params': {'skip_download': True}
2557 # Extractor argument: prefer translated title+description
2558 'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2560 'id': 'gHKT4uU8Zng',
2562 'channel': 'cole-dlp-test-acc',
2565 'live_status': 'not_live',
2566 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2567 'upload_date': '20220728',
2569 'categories': ['People & Blogs'],
2570 'thumbnail': r're:^https?://.*\.jpg',
2571 'title': 'dlp test video title translated (fr)',
2572 'availability': 'public',
2574 'description': 'dlp test video description translated (fr)',
2575 'playable_in_embed': True,
2576 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2577 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2578 'uploader_id': '@coletdjnz',
2579 'uploader': 'cole-dlp-test-acc',
2581 'params': {'skip_download': True, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2582 'expected_warnings': [r'Preferring "fr" translated fields'],
2584 'note': '6 channel audio',
2585 'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2586 'only_matching': True,
2588 'note': 'Multiple HLS formats with same itag',
2589 'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2591 'id': 'kX3nB4PpJko',
2593 'categories': ['Entertainment'],
2594 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2595 'live_status': 'not_live',
2597 'channel_follower_count': int,
2598 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2599 'title': 'Last To Take Hand Off Jet, Keeps It!',
2600 'channel': 'MrBeast',
2601 'playable_in_embed': True,
2603 'upload_date': '20221112',
2604 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2606 'availability': 'public',
2607 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2610 'uploader': 'MrBeast',
2611 'uploader_url': 'https://www.youtube.com/@MrBeast',
2612 'uploader_id': '@MrBeast',
2613 'comment_count': int,
2614 'channel_is_verified': True,
2615 'heatmap': 'count:100',
2617 'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2619 'note': 'Audio formats with Dynamic Range Compression',
2620 'url': 'https://www.youtube.com/watch?v=Tq92D6wQ1mg',
2622 'id': 'Tq92D6wQ1mg',
2624 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
2625 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
2626 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
2627 'channel_follower_count': int,
2628 'description': 'md5:17eccca93a786d51bc67646756894066',
2629 'upload_date': '20191228',
2630 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
2631 'playable_in_embed': True,
2633 'categories': ['Entertainment'],
2634 'thumbnail': 'https://i.ytimg.com/vi/Tq92D6wQ1mg/sddefault.jpg',
2636 'channel': 'Projekt Melody',
2638 'availability': 'needs_auth',
2639 'comment_count': int,
2640 'live_status': 'not_live',
2642 'uploader': 'Projekt Melody',
2643 'uploader_id': '@ProjektMelody',
2644 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
2646 'params': {'extractor_args': {'youtube': {'player_client': ['tv_embedded']}}, 'format': '251-drc'},
2649 'url': 'https://www.youtube.com/live/qVv6vCqciTM',
2651 'id': 'qVv6vCqciTM',
2654 'comment_count': int,
2655 'chapters': 'count:13',
2656 'upload_date': '20221223',
2657 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
2658 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
2660 'release_date': '20221223',
2661 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
2662 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
2664 'playable_in_embed': True,
2666 'availability': 'public',
2667 'channel_follower_count': int,
2668 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
2669 'categories': ['Entertainment'],
2670 'live_status': 'was_live',
2671 'release_timestamp': 1671793345,
2672 'channel': 'さなちゃんねる',
2673 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
2674 'uploader': 'さなちゃんねる',
2675 'uploader_url': 'https://www.youtube.com/@sana_natori',
2676 'uploader_id': '@sana_natori',
2677 'channel_is_verified': True,
2678 'heatmap': 'count:100',
2682 # Fallbacks when webpage and web client is unavailable
2683 'url': 'https://www.youtube.com/watch?v=wSSmNUl9Snw',
2685 'id': 'wSSmNUl9Snw',
2687 # 'categories': ['Science & Technology'],
2689 'chapters': 'count:2',
2690 'channel': 'Scott Manley',
2693 # 'availability': 'public',
2694 'channel_follower_count': int,
2695 'live_status': 'not_live',
2696 'upload_date': '20170831',
2699 'uploader_url': 'https://www.youtube.com/@scottmanley',
2700 'description': 'md5:f4bed7b200404b72a394c2f97b782c02',
2701 'uploader': 'Scott Manley',
2702 'uploader_id': '@scottmanley',
2703 'title': 'The Computer Hack That Saved Apollo 14',
2704 'channel_id': 'UCxzC4EngIsMrPmbm6Nxvb-A',
2705 'thumbnail': r're:^https?://.*\.webp',
2706 'channel_url': 'https://www.youtube.com/channel/UCxzC4EngIsMrPmbm6Nxvb-A',
2707 'playable_in_embed': True,
2708 'comment_count': int,
2709 'channel_is_verified': True,
2710 'heatmap': 'count:100',
2713 'extractor_args': {'youtube': {'player_client': ['android'], 'player_skip': ['webpage']}},
2719 # YouTube <object> embed
2721 'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2722 'md5': '873c81d308b979f0e23ee7e620b312a3',
2724 'id': 'msN87y-iEx0',
2726 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2727 'upload_date': '20080526',
2728 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2730 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2731 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2732 'playable_in_embed': True,
2733 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2735 'comment_count': int,
2736 'channel': 'Christopher Sykes',
2737 'live_status': 'not_live',
2738 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2739 'availability': 'public',
2742 'categories': ['Science & Technology'],
2743 'channel_follower_count': int,
2744 'uploader': 'Christopher Sykes',
2745 'uploader_url': 'https://www.youtube.com/@ChristopherSykesDocumentaries',
2746 'uploader_id': '@ChristopherSykesDocumentaries',
2747 'heatmap': 'count:100',
2750 'skip_download': True,
2756 def suitable(cls, url):
2757 from ..utils import parse_qs
2760 if qs.get('list', [None])[0]:
2762 return super().suitable(url)
2764 def __init__(self, *args, **kwargs):
2765 super().__init__(*args, **kwargs)
2766 self._code_cache = {}
2767 self._player_cache = {}
2769 def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2770 lock = threading.Lock()
2771 start_time = time.time()
2772 formats = [f for f in formats if f.get('is_from_start')]
2774 def refetch_manifest(format_id, delay):
2775 nonlocal formats, start_time, is_live
2776 if time.time() <= start_time + delay:
2779 _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2780 video_details = traverse_obj(prs, (..., 'videoDetails'), expected_type=dict)
2781 microformats = traverse_obj(
2782 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2784 _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2785 is_live = live_status == 'is_live'
2786 start_time = time.time()
2788 def mpd_feed(format_id, delay):
2790 @returns (manifest_url, manifest_stream_number, is_live) or None
2792 for retry in self.RetryManager(fatal=False):
2794 refetch_manifest(format_id, delay)
2796 f = next((f for f in formats if f['format_id'] == format_id), None)
2799 retry.error = f'{video_id}: Video is no longer live'
2801 retry.error = f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}'
2803 return f['manifest_url'], f['manifest_stream_number'], is_live
2807 f['is_live'] = is_live
2808 gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2809 live_start_time, mpd_feed, not is_live and f.copy())
2811 f['fragments'] = gen
2812 f['protocol'] = 'http_dash_segments_generator'
2814 f['fragments'] = LazyList(gen({}))
2815 del f['is_from_start']
2817 def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2818 FETCH_SPAN, MAX_DURATION = 5, 432000
2820 mpd_url, stream_number, is_live = None, None, True
2823 download_start_time = ctx.get('start') or time.time()
2825 lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2826 if lack_early_segments:
2827 self.report_warning(bug_reports_message(
2828 'Starting download from the last 120 hours of the live stream since '
2829 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2830 lack_early_segments = True
2832 known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2833 fragments, fragment_base_url = None, None
2835 def _extract_sequence_from_mpd(refresh_sequence, immediate):
2836 nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2837 # Obtain from MPD's maximum seq value
2838 old_mpd_url = mpd_url
2839 last_error = ctx.pop('last_error', None)
2840 expire_fast = immediate or last_error and isinstance(last_error, urllib.error.HTTPError) and last_error.code == 403
2841 mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2842 or (mpd_url, stream_number, False))
2843 if not refresh_sequence:
2844 if expire_fast and not is_live:
2845 return False, last_seq
2846 elif old_mpd_url == mpd_url:
2847 return True, last_seq
2848 if manifestless_orig_fmt:
2849 fmt_info = manifestless_orig_fmt
2852 fmts, _ = self._extract_mpd_formats_and_subtitles(
2853 mpd_url, None, note=False, errnote=False, fatal=False)
2854 except ExtractorError:
2857 no_fragment_score += 2
2858 return False, last_seq
2859 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2860 fragments = fmt_info['fragments']
2861 fragment_base_url = fmt_info['fragment_base_url']
2862 assert fragment_base_url
2864 _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2865 return True, _last_seq
2867 self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2869 fetch_time = time.time()
2870 if no_fragment_score > 30:
2872 if last_segment_url:
2873 # Obtain from "X-Head-Seqnum" header value from each segment
2875 urlh = self._request_webpage(
2876 last_segment_url, None, note=False, errnote=False, fatal=False)
2877 except ExtractorError:
2879 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2880 if last_seq is None:
2881 no_fragment_score += 2
2882 last_segment_url = None
2885 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2886 no_fragment_score += 2
2887 if not should_continue:
2890 if known_idx > last_seq:
2891 last_segment_url = None
2896 if begin_index < 0 and known_idx < 0:
2897 # skip from the start when it's negative value
2898 known_idx = last_seq + begin_index
2899 if lack_early_segments:
2900 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2902 for idx in range(known_idx, last_seq):
2903 # do not update sequence here or you'll get skipped some part of it
2904 should_continue, _ = _extract_sequence_from_mpd(False, False)
2905 if not should_continue:
2907 raise ExtractorError('breaking out of outer loop')
2908 last_segment_url = urljoin(fragment_base_url, 'sq/%d' % idx)
2910 'url': last_segment_url,
2911 'fragment_count': last_seq,
2913 if known_idx == last_seq:
2914 no_fragment_score += 5
2916 no_fragment_score = 0
2917 known_idx = last_seq
2918 except ExtractorError:
2921 if manifestless_orig_fmt:
2922 # Stop at the first iteration if running for post-live manifestless;
2923 # fragment count no longer increase since it starts
2926 time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2928 def _extract_player_url(self, *ytcfgs, webpage=None):
2929 player_url = traverse_obj(
2930 ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2931 get_all=False, expected_type=str)
2934 return urljoin('https://www.youtube.com', player_url)
2936 def _download_player_url(self, video_id, fatal=False):
2937 res = self._download_webpage(
2938 'https://www.youtube.com/iframe_api',
2939 note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2941 player_version = self._search_regex(
2942 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2944 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2946 def _signature_cache_id(self, example_sig):
2947 """ Return a string representation of a signature """
2948 return '.'.join(str(len(part)) for part in example_sig.split('.'))
2951 def _extract_player_info(cls, player_url):
2952 for player_re in cls._PLAYER_INFO_RE:
2953 id_m = re.search(player_re, player_url)
2957 raise ExtractorError('Cannot identify player %r' % player_url)
2958 return id_m.group('id')
2960 def _load_player(self, video_id, player_url, fatal=True):
2961 player_id = self._extract_player_info(player_url)
2962 if player_id not in self._code_cache:
2963 code = self._download_webpage(
2964 player_url, video_id, fatal=fatal,
2965 note='Downloading player ' + player_id,
2966 errnote='Download of %s failed' % player_url)
2968 self._code_cache[player_id] = code
2969 return self._code_cache.get(player_id)
2971 def _extract_signature_function(self, video_id, player_url, example_sig):
2972 player_id = self._extract_player_info(player_url)
2974 # Read from filesystem cache
2975 func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2976 assert os.path.basename(func_id) == func_id
2978 self.write_debug(f'Extracting signature function {func_id}')
2979 cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
2982 code = self._load_player(video_id, player_url)
2984 res = self._parse_sig_js(code)
2985 test_string = ''.join(map(chr, range(len(example_sig))))
2986 cache_spec = [ord(c) for c in res(test_string)]
2987 self.cache.store('youtube-sigfuncs', func_id, cache_spec)
2989 return lambda s: ''.join(s[i] for i in cache_spec)
2991 def _print_sig_code(self, func, example_sig):
2992 if not self.get_param('youtube_print_sig_code'):
2995 def gen_sig_code(idxs):
2996 def _genslice(start, end, step):
2997 starts = '' if start == 0 else str(start)
2998 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
2999 steps = '' if step == 1 else (':%d' % step)
3000 return f's[{starts}{ends}{steps}]'
3003 # Quelch pyflakes warnings - start will be set when step is set
3004 start = '(Never used)'
3005 for i, prev in zip(idxs[1:], idxs[:-1]):
3006 if step is not None:
3007 if i - prev == step:
3009 yield _genslice(start, prev, step)
3012 if i - prev in [-1, 1]:
3017 yield 's[%d]' % prev
3021 yield _genslice(start, i, step)
3023 test_string = ''.join(map(chr, range(len(example_sig))))
3024 cache_res = func(test_string)
3025 cache_spec = [ord(c) for c in cache_res]
3026 expr_code = ' + '.join(gen_sig_code(cache_spec))
3027 signature_id_tuple = '(%s)' % (
3028 ', '.join(str(len(p)) for p in example_sig.split('.')))
3029 code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
3030 ' return %s\n') % (signature_id_tuple, expr_code)
3031 self.to_screen('Extracted signature function:\n' + code)
3033 def _parse_sig_js(self, jscode):
3034 funcname = self._search_regex(
3035 (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3036 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3037 r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
3038 r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
3039 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+\))?',
3040 r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
3042 r'("|\')signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3043 r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
3044 r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3045 r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3046 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3047 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
3048 jscode, 'Initial JS player signature function name', group='sig')
3050 jsi = JSInterpreter(jscode)
3051 initial_function = jsi.extract_function(funcname)
3052 return lambda s: initial_function([s])
3054 def _cached(self, func, *cache_id):
3055 def inner(*args, **kwargs):
3056 if cache_id not in self._player_cache:
3058 self._player_cache[cache_id] = func(*args, **kwargs)
3059 except ExtractorError as e:
3060 self._player_cache[cache_id] = e
3061 except Exception as e:
3062 self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
3064 ret = self._player_cache[cache_id]
3065 if isinstance(ret, Exception):
3070 def _decrypt_signature(self, s, video_id, player_url):
3071 """Turn the encrypted s field into a working signature"""
3072 extract_sig = self._cached(
3073 self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
3074 func = extract_sig(video_id, player_url, s)
3075 self._print_sig_code(func, s)
3078 def _decrypt_nsig(self, s, video_id, player_url):
3079 """Turn the encrypted n field into a working signature"""
3080 if player_url is None:
3081 raise ExtractorError('Cannot decrypt nsig without player_url')
3082 player_url = urljoin('https://www.youtube.com', player_url)
3085 jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
3086 except ExtractorError as e:
3087 raise ExtractorError('Unable to extract nsig function code', cause=e)
3088 if self.get_param('youtube_print_sig_code'):
3089 self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
3092 extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
3093 ret = extract_nsig(jsi, func_code)(s)
3094 except JSInterpreter.Exception as e:
3096 jsi = PhantomJSwrapper(self, timeout=5000)
3097 except ExtractorError:
3099 self.report_warning(
3100 f'Native nsig extraction failed: Trying with PhantomJS\n'
3101 f' n = {s} ; player = {player_url}', video_id)
3102 self.write_debug(e, only_once=True)
3104 args, func_body = func_code
3106 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
3107 video_id=video_id, note='Executing signature code').strip()
3109 self.write_debug(f'Decrypted nsig {s} => {ret}')
3112 def _extract_n_function_name(self, jscode):
3113 funcname, idx = self._search_regex(
3114 r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
3115 jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
3119 return json.loads(js_to_json(self._search_regex(
3120 rf'var {re.escape(funcname)}\s*=\s*(\[.+?\])\s*[,;]', jscode,
3121 f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
3123 def _extract_n_function_code(self, video_id, player_url):
3124 player_id = self._extract_player_info(player_url)
3125 func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
3126 jscode = func_code or self._load_player(video_id, player_url)
3127 jsi = JSInterpreter(jscode)
3130 return jsi, player_id, func_code
3132 func_name = self._extract_n_function_name(jscode)
3135 func_code = self._search_regex(
3136 r'''(?xs
)%s\s
*=\s
*function\s
*\
((?P
<var
>[\w$
]+)\
)\s
*
3137 # NB: The end of the regex is intentionally kept strict
3138 {(?P<code>.+?}\s
*return\
[\w$
]+.join\
(""\
))};''' % func_name,
3139 jscode, 'nsig function', group=('var', 'code'), default=None)
3141 func_code = ([func_code[0]], func_code[1])
3143 self.write_debug('Extracting nsig function with jsinterp')
3144 func_code = jsi.extract_function_code(func_name)
3146 self.cache.store('youtube-nsig', player_id, func_code)
3147 return jsi, player_id, func_code
3149 def _extract_n_function_from_code(self, jsi, func_code):
3150 func = jsi.extract_function_from_code(*func_code)
3152 def extract_nsig(s):
3155 except JSInterpreter.Exception:
3157 except Exception as e:
3158 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
3160 if ret.startswith('enhanced_except_'):
3161 raise JSInterpreter.Exception('Signature function returned an exception')
3166 def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3168 Extract signatureTimestamp (sts)
3169 Required to tell API what sig/player version is in use.
3172 if isinstance(ytcfg, dict):
3173 sts = int_or_none(ytcfg.get('STS'))
3176 # Attempt to extract from player
3177 if player_url is None:
3178 error_msg = 'Cannot extract signature timestamp without player_url.'
3180 raise ExtractorError(error_msg)
3181 self.report_warning(error_msg)
3183 code = self._load_player(video_id, player_url, fatal=fatal)
3185 sts = int_or_none(self._search_regex(
3186 r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3187 'JS player signature timestamp', group='sts', fatal=fatal))
3190 def _mark_watched(self, video_id, player_responses):
3191 for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3192 label = 'fully ' if is_full else ''
3193 url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3194 expected_type=url_or_none)
3196 self.report_warning(f'Unable to mark {label}watched')
3198 parsed_url = urllib.parse.urlparse(url)
3199 qs = urllib.parse.parse_qs(parsed_url.query)
3201 # cpn generation algorithm is reverse engineered from base.js.
3202 # In fact it works even with dummy cpn.
3203 CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3204 cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16))
3206 # # more consistent results setting it to right before the end
3207 video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3212 'cmt': video_length,
3213 'el': 'detailpage', # otherwise defaults to "shorts"
3217 # these seem to mark watchtime "history" in the real world
3218 # they're required, so send in a single value
3224 url = urllib.parse.urlunparse(
3225 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3227 self._download_webpage(
3228 url, video_id, f'Marking {label}watched',
3229 'Unable to mark watched', fatal=False)
3232 def _extract_from_webpage(cls, url, webpage):
3233 # Invidious Instances
3234 # https://github.com/yt-dlp/yt-dlp/issues/195
3235 # https://github.com/iv-org/invidious/pull/1730
3237 r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3240 yield cls.url_result(mobj.group('url'), cls)
3241 raise cls.StopExtraction()
3243 yield from super()._extract_from_webpage(url, webpage)
3245 # lazyYT YouTube embed
3246 for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3247 yield cls.url_result(unescapeHTML(id_), cls, id_)
3249 # Wordpress "YouTube Video Importer" plugin
3250 for m in re.findall(r'''(?x
)<div
[^
>]+
3251 class=(?P
<q1
>[\'"])[^\'"]*\byvii
_single
_video
_player
\b[^
\'"]*(?P=q1)[^>]+
3252 data-video_id=(?P<q2>[\'"])([^
\'"]+)(?P=q2)''', webpage):
3253 yield cls.url_result(m[-1], cls, m[-1])
3256 def extract_id(cls, url):
3257 video_id = cls.get_temp_id(url)
3259 raise ExtractorError(f'Invalid URL: {url}')
3262 def _extract_chapters_from_json(self, data, duration):
3263 chapter_list = traverse_obj(
3265 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3266 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters'
3267 ), expected_type=list)
3269 return self._extract_chapters_helper(
3271 start_function=lambda chapter: float_or_none(
3272 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3273 title_function=lambda chapter: traverse_obj(
3274 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3277 def _extract_chapters_from_engagement_panel(self, data, duration):
3278 content_list = traverse_obj(
3280 ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3282 chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3283 chapter_title = lambda chapter: self._get_text(chapter, 'title')
3285 return next(filter(None, (
3286 self._extract_chapters_helper(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3287 chapter_time, chapter_title, duration)
3288 for contents in content_list)), [])
3290 def _extract_heatmap_from_player_overlay(self, data):
3291 content_list = traverse_obj(data, (
3292 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer', 'decoratedPlayerBarRenderer', 'playerBar',
3293 'multiMarkersPlayerBarRenderer', 'markersMap', ..., 'value', 'heatmap', 'heatmapRenderer', 'heatMarkers', {list}))
3294 return next(filter(None, (
3295 traverse_obj(contents, (..., 'heatMarkerRenderer', {
3296 'start_time': ('timeRangeStartMillis', {functools.partial(float_or_none, scale=1000)}),
3297 'end_time': {lambda x: (x['timeRangeStartMillis'] + x['markerDurationMillis']) / 1000},
3298 'value': ('heatMarkerIntensityScoreNormalized', {float_or_none}),
3299 })) for contents in content_list)), None)
3301 def _extract_comment(self, comment_renderer, parent=None):
3302 comment_id = comment_renderer.get('commentId')
3308 'text': self._get_text(comment_renderer, 'contentText'),
3309 'like_count': self._get_count(comment_renderer, 'voteCount'),
3310 'author_id': traverse_obj(comment_renderer, ('authorEndpoint', 'browseEndpoint', 'browseId', {self.ucid_or_none})),
3311 'author': self._get_text(comment_renderer, 'authorText'),
3312 'author_thumbnail': traverse_obj(comment_renderer, ('authorThumbnail', 'thumbnails', -1, 'url', {url_or_none})),
3313 'parent': parent or 'root',
3316 # Timestamp is an estimate calculated from the current time and time_text
3317 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3318 timestamp = self._parse_time_text(time_text)
3321 # FIXME: non-standard, but we need a way of showing that it is an estimate.
3322 '_time_text': time_text,
3323 'timestamp': timestamp,
3326 info['author_url'] = urljoin(
3327 'https://www.youtube.com', traverse_obj(comment_renderer, ('authorEndpoint', (
3328 ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'))),
3329 expected_type=str, get_all=False))
3331 author_is_uploader = traverse_obj(comment_renderer, 'authorIsChannelOwner')
3332 if author_is_uploader is not None:
3333 info['author_is_uploader'] = author_is_uploader
3335 comment_abr = traverse_obj(
3336 comment_renderer, ('actionButtons', 'commentActionButtonsRenderer'), expected_type=dict)
3337 if comment_abr is not None:
3338 info['is_favorited'] = 'creatorHeart' in comment_abr
3340 badges = self._extract_badges([traverse_obj(comment_renderer, 'authorCommentBadge')])
3341 if self._has_badge(badges, BadgeType.VERIFIED):
3342 info['author_is_verified'] = True
3344 is_pinned = traverse_obj(comment_renderer, 'pinnedCommentBadge')
3346 info['is_pinned'] = True
3350 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3352 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3354 def extract_header(contents):
3355 _continuation = None
3356 for content in contents:
3357 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3358 expected_comment_count = self._get_count(
3359 comments_header_renderer, 'countText', 'commentsCount')
3361 if expected_comment_count is not None:
3362 tracker['est_total'] = expected_comment_count
3363 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3364 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3366 sort_menu_item = try_get(
3367 comments_header_renderer,
3368 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3369 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3371 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3372 if not _continuation:
3375 sort_text = str_or_none(sort_menu_item.get('title'))
3377 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3378 self.to_screen('Sorting comments by %s' % sort_text.lower())
3380 return _continuation
3382 def extract_thread(contents):
3384 tracker['current_page_thread'] = 0
3385 for content in contents:
3386 if not parent and tracker['total_parent_comments'] >= max_parents:
3388 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3389 comment_renderer = get_first(
3390 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3391 expected_type=dict, default={})
3393 comment = self._extract_comment(comment_renderer, parent)
3396 comment_id = comment['id']
3397 if comment.get('is_pinned'):
3398 tracker['pinned_comment_ids'].add(comment_id)
3399 # Sometimes YouTube may break and give us infinite looping comments.
3400 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3401 if comment_id in tracker['seen_comment_ids']:
3402 if comment_id in tracker['pinned_comment_ids'] and not comment.get('is_pinned'):
3403 # Pinned comments may appear a second time in newest first sort
3404 # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3406 self.report_warning(
3407 'Detected YouTube comments looping. Stopping comment extraction '
3408 f'{"for this thread" if parent else ""} as we probably cannot get any more.')
3411 tracker['seen_comment_ids'].add(comment['id'])
3413 tracker['running_total'] += 1
3414 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3417 # Attempt to get the replies
3418 comment_replies_renderer = try_get(
3419 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3421 if comment_replies_renderer:
3422 tracker['current_page_thread'] += 1
3423 comment_entries_iter = self._comment_entries(
3424 comment_replies_renderer, ytcfg, video_id,
3425 parent=comment.get('id'), tracker=tracker)
3426 yield from itertools.islice(comment_entries_iter, min(
3427 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3429 # Keeps track of counts across recursive calls
3434 current_page_thread=0,
3435 total_parent_comments=0,
3436 total_reply_comments=0,
3437 seen_comment_ids=set(),
3438 pinned_comment_ids=set()
3442 # YouTube comments have a max depth of 2
3443 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3445 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3446 'Set max replies in the max-comments extractor argument instead')
3447 if max_depth == 1 and parent:
3450 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
3451 lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
3453 continuation = self._extract_continuation(root_continuation_data)
3456 is_forced_continuation = False
3457 is_first_continuation = parent is None
3458 if is_first_continuation and not continuation:
3459 # Sometimes you can get comments by generating the continuation yourself,
3460 # even if YouTube initially reports them being disabled - e.g. stories comments.
3461 # Note: if the comment section is actually disabled, YouTube may return a response with
3462 # required check_get_keys missing. So we will disable that check initially in this case.
3463 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3464 is_forced_continuation = True
3466 continuation_items_path = (
3467 'onResponseReceivedEndpoints', ..., ('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems')
3468 for page_num in itertools.count(0):
3469 if not continuation:
3471 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3472 comment_prog_str = f"({tracker['running_total']}
/~{tracker['est_total']}
)"
3474 if is_first_continuation:
3475 note_prefix = 'Downloading comment section API JSON'
3477 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3478 tracker['current_page_thread'], comment_prog_str)
3480 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
3481 ' ' if parent else '', ' replies' if parent else '',
3482 page_num, comment_prog_str)
3484 # Do a deep check for incomplete data as sometimes YouTube may return no comments for a continuation
3485 # Ignore check if YouTube says the comment count is 0.
3486 check_get_keys = None
3487 if not is_forced_continuation and not (tracker['est_total'] == 0 and tracker['running_total'] == 0):
3488 check_get_keys = [[*continuation_items_path, ..., (
3489 'commentsHeaderRenderer' if is_first_continuation else ('commentThreadRenderer', 'commentRenderer'))]]
3491 response = self._extract_response(
3492 item_id=None, query=continuation,
3493 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3494 check_get_keys=check_get_keys)
3495 except ExtractorError as e:
3496 # Ignore incomplete data error for replies if retries didn't work.
3497 # This is to allow any other parent comments and comment threads to be downloaded.
3498 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3499 if 'incomplete data' in str(e).lower() and parent:
3500 if self.get_param('ignoreerrors') in (True, 'only_download'):
3501 self.report_warning(
3502 'Received incomplete data for a comment reply thread and retrying did not help. '
3503 'Ignoring to let other comments be downloaded. Pass --no-ignore-errors to not ignore.')
3506 raise ExtractorError(
3507 'Incomplete data received for comment reply thread. '
3508 'Pass --ignore-errors to ignore and allow rest of comments to download.',
3511 is_forced_continuation = False
3513 for continuation_items in traverse_obj(response, continuation_items_path, expected_type=list, default=[]):
3514 if is_first_continuation:
3515 continuation = extract_header(continuation_items)
3516 is_first_continuation = False
3521 for entry in extract_thread(continuation_items):
3525 continuation = self._extract_continuation({'contents': continuation_items})
3529 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3530 if message and not parent and tracker['running_total'] == 0:
3531 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3532 raise self.CommentsDisabled
3535 def _generate_comment_continuation(video_id):
3537 Generates initial comment section continuation token from given video id
3539 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3540 return base64.b64encode(token.encode()).decode()
3542 def _get_comments(self, ytcfg, video_id, contents, webpage):
3543 """Entry for comment extraction"""
3544 def _real_comment_extract(contents):
3546 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3547 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3548 yield from self._comment_entries(renderer, ytcfg, video_id)
3550 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3551 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3554 def _get_checkok_params():
3555 return {'contentCheckOk': True, 'racyCheckOk': True}
3558 def _generate_player_context(cls, sts=None):
3560 'html5Preference': 'HTML5_PREF_WANTS',
3563 context['signatureTimestamp'] = sts
3565 'playbackContext': {
3566 'contentPlaybackContext': context
3568 **cls._get_checkok_params()
3572 def _is_agegated(player_response):
3573 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3576 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3577 AGE_GATE_REASONS = (
3578 'confirm your age', 'age-restricted', 'inappropriate', # reason
3579 'age_verification_required', 'age_check_required', # status
3581 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3584 def _is_unplayable(player_response):
3585 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3587 _PLAYER_PARAMS = 'CgIQBg=='
3589 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3591 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3592 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3593 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3594 headers = self.generate_api_headers(
3595 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3598 'videoId': video_id,
3600 if _split_innertube_client(client)[0] == 'android':
3601 yt_query['params'] = self._PLAYER_PARAMS
3603 yt_query.update(self._generate_player_context(sts))
3604 return self._extract_response(
3605 item_id=video_id, ep='player', query=yt_query,
3606 ytcfg=player_ytcfg, headers=headers, fatal=True,
3607 default_client=client,
3608 note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
3611 def _get_requested_clients(self, url, smuggled_data):
3612 requested_clients = []
3613 default = ['ios', 'android', 'web']
3614 allowed_clients = sorted(
3615 (client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'),
3616 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3617 for client in self._configuration_arg('player_client'):
3618 if client in allowed_clients:
3619 requested_clients.append(client)
3620 elif client == 'default':
3621 requested_clients.extend(default)
3622 elif client == 'all':
3623 requested_clients.extend(allowed_clients)
3625 self.report_warning(f'Skipping unsupported client {client}')
3626 if not requested_clients:
3627 requested_clients = default
3629 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3630 requested_clients.extend(
3631 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3633 return orderedSet(requested_clients)
3635 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3638 initial_pr = self._search_json(
3639 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3641 all_clients = set(clients)
3642 clients = clients[::-1]
3645 def append_client(*client_names):
3646 """ Append the first client name that exists but not already used """
3647 for client_name in client_names:
3648 actual_client = _split_innertube_client(client_name)[0]
3649 if actual_client in INNERTUBE_CLIENTS:
3650 if actual_client not in all_clients:
3651 clients.append(client_name)
3652 all_clients.add(actual_client)
3655 # Android player_response does not have microFormats which are needed for
3656 # extraction of some data. So we return the initial_pr with formats
3657 # stripped out even if not requested by the user
3658 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3660 pr = dict(initial_pr)
3661 pr['streamingData'] = None
3665 tried_iframe_fallback = False
3668 client, base_client, variant = _split_innertube_client(clients.pop())
3669 player_ytcfg = master_ytcfg if client == 'web' else {}
3670 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3671 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3673 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3674 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3675 if 'js' in self._configuration_arg('player_skip'):
3676 require_js_player = False
3679 if not player_url and not tried_iframe_fallback and require_js_player:
3680 player_url = self._download_player_url(video_id)
3681 tried_iframe_fallback = True
3684 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3685 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3686 except ExtractorError as e:
3688 self.report_warning(last_error)
3693 # YouTube may return a different video player response than expected.
3694 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3695 pr_video_id = traverse_obj(pr, ('videoDetails', 'videoId'))
3696 if pr_video_id and pr_video_id != video_id:
3697 self.report_warning(
3698 f'Skipping player response from {client} client (got player response for video "{pr_video_id}
" instead of "{video_id}
")' + bug_reports_message())
3700 # Save client name for introspection later
3701 name = short_client_name(client)
3702 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3703 sd[STREAMING_DATA_CLIENT_NAME] = name
3704 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3705 f[STREAMING_DATA_CLIENT_NAME] = name
3708 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3709 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3710 append_client(f'{base_client}_creator')
3711 elif self._is_agegated(pr):
3712 if variant == 'tv_embedded':
3713 append_client(f'{base_client}_embedded')
3715 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3720 self.report_warning(last_error)
3721 return prs, player_url
3723 def _needs_live_processing(self, live_status, duration):
3724 if (live_status == 'is_live' and self.get_param('live_from_start')
3725 or live_status == 'post_live' and (duration or 0) > 2 * 3600):
3728 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3729 CHUNK_SIZE = 10 << 20
3730 itags, stream_ids = collections.defaultdict(set), []
3731 itag_qualities, res_qualities = {}, {0: None}
3733 # Normally tiny is the smallest video-only formats. But
3734 # audio-only formats with unknown quality may get tagged as tiny
3736 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3737 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
3739 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3740 format_types = self._configuration_arg('formats')
3741 all_formats = 'duplicate' in format_types
3742 if self._configuration_arg('include_duplicate_formats'):
3744 self._downloader.deprecated_feature('[youtube] include_duplicate_formats extractor argument is deprecated. '
3745 'Use formats=duplicate extractor argument instead')
3747 def build_fragments(f):
3749 'url': update_url_query(f['url'], {
3750 'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}'
3752 } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3754 for fmt in streaming_formats:
3755 if fmt.get('targetDurationSec'):
3758 itag = str_or_none(fmt.get('itag'))
3759 audio_track = fmt.get('audioTrack') or {}
3760 stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3762 if stream_id in stream_ids:
3765 quality = fmt.get('quality')
3766 height = int_or_none(fmt.get('height'))
3767 if quality == 'tiny' or not quality:
3768 quality = fmt.get('audioQuality', '').lower() or quality
3769 # The 3gp format (17) in android client has a quality of "small
",
3770 # but is actually worse than other formats
3775 itag_qualities[itag] = quality
3777 res_qualities[height] = quality
3778 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3779 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3780 # number of fragment that would subsequently requested with (`&sq=N`)
3781 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3784 fmt_url = fmt.get('url')
3786 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3787 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3788 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3789 if not all((sc, fmt_url, player_url, encrypted_sig)):
3792 fmt_url += '&%s=%s' % (
3793 traverse_obj(sc, ('sp', -1)) or 'signature',
3794 self._decrypt_signature(encrypted_sig, video_id, player_url)
3796 except ExtractorError as e:
3797 self.report_warning('Signature extraction failed: Some formats may be missing',
3798 video_id=video_id, only_once=True)
3799 self.write_debug(e, only_once=True)
3802 query = parse_qs(fmt_url)
3806 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3807 fmt_url = update_url_query(fmt_url, {
3808 'n': decrypt_nsig(query['n'][0], video_id, player_url)
3810 except ExtractorError as e:
3812 if isinstance(e, JSInterpreter.Exception):
3813 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3814 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3816 self.report_warning(
3817 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3818 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3819 self.write_debug(e, only_once=True)
3821 self.report_warning(
3822 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3823 video_id=video_id, only_once=True)
3826 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3827 language_preference = (
3828 10 if audio_track.get('audioIsDefault') and 10
3829 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3831 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3832 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3833 # Make sure to avoid false positives with small duration differences.
3834 # E.g. __2ABJjxzNo, ySuUZEjARPY
3835 is_damaged = try_get(fmt, lambda x: float(x['approxDurationMs']) / duration < 500)
3837 self.report_warning(
3838 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3840 client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3841 name = fmt.get('qualityLabel') or quality.replace('audio_quality_', '') or ''
3842 fps = int_or_none(fmt.get('fps')) or 0
3844 'asr': int_or_none(fmt.get('audioSampleRate')),
3845 'filesize': int_or_none(fmt.get('contentLength')),
3846 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3847 'format_note': join_nonempty(
3848 join_nonempty(audio_track.get('displayName'),
3849 language_preference > 0 and ' (default)', delim=''),
3850 name, fmt.get('isDrc') and 'DRC',
3851 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3852 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3853 throttled and 'THROTTLED', is_damaged and 'DAMAGED',
3854 (self.get_param('verbose') or all_formats) and client_name,
3856 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3857 'source_preference': ((-10 if throttled else -5 if itag == '22' else -1)
3858 + (100 if 'Premium' in name else 0)),
3859 'fps': fps if fps > 1 else None, # For some formats, fps is wrongly returned as 1
3860 'audio_channels': fmt.get('audioChannels'),
3862 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3863 'has_drm': bool(fmt.get('drmFamilies')),
3866 'width': int_or_none(fmt.get('width')),
3867 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3868 'desc' if language_preference < -1 else '') or None,
3869 'language_preference': language_preference,
3870 # Strictly de-prioritize damaged and 3gp formats
3871 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3873 mime_mobj = re.match(
3874 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3876 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3877 dct.update(parse_codecs(mime_mobj.group(2)))
3879 itags[itag].add(('https
', dct.get('language
')))
3880 stream_ids.append(stream_id)
3881 single_stream = 'none
' in (dct.get('acodec
'), dct.get('vcodec
'))
3882 if single_stream and dct.get('ext
'):
3883 dct['container
'] = dct['ext
'] + '_dash
'
3885 if (all_formats or 'dashy
' in format_types) and dct['filesize
']:
3888 'format_id
': f'{dct["format_id"]}
-dashy
' if all_formats else dct['format_id
'],
3889 'protocol
': 'http_dash_segments
',
3890 'fragments
': build_fragments(dct),
3892 if all_formats or 'dashy
' not in format_types:
3893 dct['downloader_options
'] = {'http_chunk_size': CHUNK_SIZE}
3896 needs_live_processing = self._needs_live_processing(live_status, duration)
3897 skip_bad_formats = 'incomplete
' not in format_types
3898 if self._configuration_arg('include_incomplete_formats
'):
3899 skip_bad_formats = False
3900 self._downloader.deprecated_feature('[youtube
] include_incomplete_formats extractor argument
is deprecated
. '
3901 'Use formats
=incomplete extractor argument instead
')
3903 skip_manifests = set(self._configuration_arg('skip
'))
3904 if (not self.get_param('youtube_include_hls_manifest
', True)
3905 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3906 or needs_live_processing and skip_bad_formats):
3907 skip_manifests.add('hls
')
3909 if not self.get_param('youtube_include_dash_manifest
', True):
3910 skip_manifests.add('dash
')
3911 if self._configuration_arg('include_live_dash
'):
3912 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3913 'Use formats
=incomplete extractor argument instead
')
3914 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3915 skip_manifests.add('dash
')
3917 def process_manifest_format(f, proto, client_name, itag):
3918 key = (proto, f.get('language
'))
3919 if not all_formats and key in itags[itag]:
3921 itags[itag].add(key)
3923 if itag and all_formats:
3924 f['format_id
'] = f'{itag}
-{proto}
'
3925 elif any(p != proto for p, _ in itags[itag]):
3926 f['format_id
'] = f'{itag}
-{proto}
'
3928 f['format_id
'] = itag
3930 if f.get('source_preference
') is None:
3931 f['source_preference
'] = -1
3933 if itag in ('616', '235'):
3934 f['format_note
'] = join_nonempty(f.get('format_note
'), 'Premium
', delim=' ')
3935 f['source_preference
'] += 100
3937 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
3938 if f['quality
'] == -1 and f.get('height
'):
3939 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
3940 if self.get_param('verbose
') or all_formats:
3941 f['format_note
'] = join_nonempty(f.get('format_note
'), client_name, delim=', ')
3942 if f.get('fps
') and f['fps
'] <= 1:
3945 if proto == 'hls
' and f.get('has_drm
'):
3946 f['has_drm
'] = 'maybe
'
3947 f['source_preference
'] -= 5
3951 for sd in streaming_data:
3952 client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
3954 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
3955 if hls_manifest_url:
3956 fmts, subs = self._extract_m3u8_formats_and_subtitles(
3957 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
3958 subtitles = self._merge_subtitles(subs, subtitles)
3960 if process_manifest_format(f, 'hls
', client_name, self._search_regex(
3961 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
3964 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
3965 if dash_manifest_url:
3966 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
3967 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
3969 if process_manifest_format(f, 'dash
', client_name, f['format_id
']):
3970 f['filesize
'] = int_or_none(self._search_regex(
3971 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
3972 if needs_live_processing:
3973 f['is_from_start
'] = True
3978 def _extract_storyboard(self, player_responses, duration):
3980 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
3981 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
3985 for i, args in enumerate(spec):
3986 args = args.split('#')
3987 counts
= list(map(int_or_none
, args
[:5]))
3988 if len(args
) != 8 or not all(counts
):
3989 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
3991 width
, height
, frame_count
, cols
, rows
= counts
3994 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
3995 fragment_count
= frame_count
/ (cols
* rows
)
3996 fragment_duration
= duration
/ fragment_count
3998 'format_id': f
'sb{i}',
3999 'format_note': 'storyboard',
4001 'protocol': 'mhtml',
4007 'fps': frame_count
/ duration
,
4011 'url': url
.replace('$M', str(j
)),
4012 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
4013 } for j
in range(math
.ceil(fragment_count
))],
4016 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
4018 if 'webpage' not in self
._configuration
_arg
('player_skip'):
4019 query
= {'bpctr': '9999999999', 'has_verified': '1'}
4020 webpage
= self
._download
_webpage
(
4021 webpage_url
, video_id
, fatal
=False, query
=query
)
4023 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
4025 player_responses
, player_url
= self
._extract
_player
_responses
(
4026 self
._get
_requested
_clients
(url
, smuggled_data
),
4027 video_id
, webpage
, master_ytcfg
, smuggled_data
)
4029 return webpage
, master_ytcfg
, player_responses
, player_url
4031 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
4032 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
4033 is_live
= get_first(video_details
, 'isLive')
4035 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
4036 live_content
= get_first(video_details
, 'isLiveContent')
4037 is_upcoming
= get_first(video_details
, 'isUpcoming')
4038 post_live
= get_first(video_details
, 'isPostLiveDvr')
4039 live_status
= ('post_live' if post_live
4040 else 'is_live' if is_live
4041 else 'is_upcoming' if is_upcoming
4042 else 'was_live' if live_content
4043 else 'not_live' if False in (is_live
, live_content
)
4045 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'))
4046 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
4047 if all(f
.get('has_drm') for f
in formats
):
4048 # If there are no formats that definitely don't have DRM, all have DRM
4052 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
4054 def _real_extract(self
, url
):
4055 url
, smuggled_data
= unsmuggle_url(url
, {})
4056 video_id
= self
._match
_id
(url
)
4058 base_url
= self
.http_scheme() + '//www.youtube.com/'
4059 webpage_url
= base_url
+ 'watch?v=' + video_id
4061 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
4063 playability_statuses
= traverse_obj(
4064 player_responses
, (..., 'playabilityStatus'), expected_type
=dict)
4066 trailer_video_id
= get_first(
4067 playability_statuses
,
4068 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
4070 if trailer_video_id
:
4071 return self
.url_result(
4072 trailer_video_id
, self
.ie_key(), trailer_video_id
)
4074 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
4075 if webpage
else (lambda x
: None))
4077 video_details
= traverse_obj(player_responses
, (..., 'videoDetails'), expected_type
=dict)
4078 microformats
= traverse_obj(
4079 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
4082 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
4083 video_title
= (self
._preferred
_lang
and translated_title
4084 or get_first(video_details
, 'title') # primary
4086 or search_meta(['og:title', 'twitter:title', 'title']))
4087 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
4088 original_description
= get_first(video_details
, 'shortDescription')
4089 video_description
= (
4090 self
._preferred
_lang
and translated_description
4091 # If original description is blank, it will be an empty string.
4092 # Do not prefer translated description in this case.
4093 or original_description
if original_description
is not None else translated_description
)
4095 multifeed_metadata_list
= get_first(
4097 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
4099 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
4100 if self
.get_param('noplaylist'):
4101 self
.to_screen('Downloading just video %s because of --no-playlist' % video_id
)
4105 for feed
in multifeed_metadata_list
.split(','):
4106 # Unquote should take place before split on comma (,) since textual
4107 # fields may contain comma as well (see
4108 # https://github.com/ytdl-org/youtube-dl/issues/8536)
4109 feed_data
= urllib
.parse
.parse_qs(
4110 urllib
.parse
.unquote_plus(feed
))
4112 def feed_entry(name
):
4114 feed_data
, lambda x
: x
[name
][0], str)
4116 feed_id
= feed_entry('id')
4119 feed_title
= feed_entry('title')
4122 title
+= ' (%s)' % feed_title
4124 '_type': 'url_transparent',
4125 'ie_key': 'Youtube',
4127 '%swatch?v=%s' % (base_url
, feed_data
['id'][0]),
4128 {'force_singlefeed': True}
),
4131 feed_ids
.append(feed_id
)
4133 'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
4134 % (', '.join(feed_ids
), video_id
))
4135 return self
.playlist_result(
4136 entries
, video_id
, video_title
, video_description
)
4138 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
4139 or int_or_none(get_first(microformats
, 'lengthSeconds'))
4140 or parse_duration(search_meta('duration')) or None)
4142 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
4143 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
4144 if live_status
== 'post_live':
4145 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
4148 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
4149 self
.report_drm(video_id
)
4151 playability_statuses
,
4152 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
4153 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
4154 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
4156 if subreason
== 'The uploader has not made this video available in your country.':
4157 countries
= get_first(microformats
, 'availableCountries')
4159 regions_allowed
= search_meta('regionsAllowed')
4160 countries
= regions_allowed
.split(',') if regions_allowed
else None
4161 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
4162 reason
+= f
'. {subreason}'
4164 self
.raise_no_formats(reason
, expected
=True)
4166 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
4167 if not keywords
and webpage
:
4169 unescapeHTML(m
.group('content'))
4170 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
4171 for keyword
in keywords
:
4172 if keyword
.startswith('yt:stretch='):
4173 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
4175 # NB: float is intentional for forcing float division
4176 w
, h
= (float(v
) for v
in mobj
.groups())
4180 if f
.get('vcodec') != 'none':
4181 f
['stretched_ratio'] = ratio
4183 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
4184 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
4187 'url': thumbnail_url
,
4189 original_thumbnails
= thumbnails
.copy()
4191 # The best resolution thumbnails sometimes does not appear in the webpage
4192 # See: https://github.com/yt-dlp/yt-dlp/issues/340
4193 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4195 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4196 # in resolution, these are not the custom thumbnail. So de-prioritize them
4197 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4198 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3'
4200 n_thumbnail_names
= len(thumbnail_names
)
4202 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4203 video_id
=video_id
, name
=name
, ext
=ext
,
4204 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
4205 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
4206 for thumb
in thumbnails
:
4207 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
4208 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
4209 self
._remove
_duplicate
_formats
(thumbnails
)
4210 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
4212 category
= get_first(microformats
, 'category') or search_meta('genre')
4213 channel_id
= self
.ucid_or_none(str_or_none(
4214 get_first(video_details
, 'channelId')
4215 or get_first(microformats
, 'externalChannelId')
4216 or search_meta('channelId')))
4217 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
4219 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
4220 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
4221 if not duration
and live_end_time
and live_start_time
:
4222 duration
= live_end_time
- live_start_time
4224 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
4226 def is_bad_format(fmt
):
4227 if needs_live_processing
and not fmt
.get('is_from_start'):
4229 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
4230 and fmt
.get('protocol') == 'http_dash_segments'):
4233 for fmt
in filter(is_bad_format
, formats
):
4234 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4235 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 2 hours)', delim
=' ')
4237 if needs_live_processing
:
4238 self
._prepare
_live
_from
_start
_formats
(
4239 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4241 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4243 channel_handle
= self
.handle_from_url(owner_profile_url
)
4247 'title': video_title
,
4249 'thumbnails': thumbnails
,
4250 # The best thumbnail that we are sure exists. Prevents unnecessary
4251 # URL checking if user don't care about getting the best possible thumbnail
4252 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4253 'description': video_description
,
4254 'channel_id': channel_id
,
4255 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None),
4256 'duration': duration
,
4257 'view_count': int_or_none(
4258 get_first((video_details
, microformats
), (..., 'viewCount'))
4259 or search_meta('interactionCount')),
4260 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4261 'age_limit': 18 if (
4262 get_first(microformats
, 'isFamilySafe') is False
4263 or search_meta('isFamilyFriendly') == 'false'
4264 or search_meta('og:restrictions:age') == '18+') else 0,
4265 'webpage_url': webpage_url
,
4266 'categories': [category
] if category
else None,
4268 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4269 'live_status': live_status
,
4270 'release_timestamp': live_start_time
,
4271 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4272 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto')
4276 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4278 def get_lang_code(track
):
4279 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4280 or track
.get('languageCode'))
4282 # Converted into dicts to remove duplicates
4284 get_lang_code(sub
): sub
4285 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...))}
4286 translation_languages
= {
4287 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4288 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...))}
4290 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4291 lang_subs
= container
.setdefault(lang_code
, [])
4292 for fmt
in self
._SUBTITLE
_FORMATS
:
4298 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4302 # NB: Constructing the full subtitle dictionary is slow
4303 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4304 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4305 for lang_code
, caption_track
in captions
.items():
4306 base_url
= caption_track
.get('baseUrl')
4307 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4310 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4311 if caption_track
.get('kind') != 'asr':
4315 subtitles
, base_url
, lang_code
, lang_name
, {})
4316 if not caption_track
.get('isTranslatable'):
4318 for trans_code
, trans_name
in translation_languages
.items():
4321 orig_trans_code
= trans_code
4322 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4323 if not get_translated_subs
:
4325 trans_code
+= f
'-{lang_code}'
4326 trans_name
+= format_field(lang_name
, None, ' from %s')
4327 if lang_code
== f
'a-{orig_trans_code}':
4328 # Set audio language based on original subtitles
4330 if f
.get('acodec') != 'none' and not f
.get('language'):
4331 f
['language'] = orig_trans_code
4332 # Add an "-orig" label to the original language so that it can be distinguished.
4333 # The subs are returned without "-orig" as well for compatibility
4335 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4336 # Setting tlang=lang returns damaged subtitles.
4337 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4338 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4340 info
['automatic_captions'] = automatic_captions
4341 info
['subtitles'] = subtitles
4343 parsed_url
= urllib
.parse
.urlparse(url
)
4344 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4345 query
= urllib
.parse
.parse_qs(component
)
4346 for k
, v
in query
.items():
4347 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4349 if d_k
not in info
and k
in s_ks
:
4350 info
[d_k
] = parse_duration(query
[k
][0])
4352 # Youtube Music Auto-generated description
4353 if (video_description
or '').strip().endswith('\nAuto-generated by YouTube.'):
4354 # XXX: Causes catastrophic backtracking if description has "·"
4355 # E.g. https://www.youtube.com/watch?v=DoPaAxMQoiI
4356 # Simulating atomic groups: (?P<a>[^xy]+)x => (?=(?P<a>[^xy]+))(?P=a)x
4357 # reduces it, but does not fully fix it. https://regex101.com/r/8Ssf2h/2
4360 (?=(?P<track>[^\n·]+))(?P=track)·
4361 (?=(?P<artist>[^\n]+))(?P=artist)\n+
4362 (?=(?P<album>[^\n]+))(?P=album)\n
4363 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4364 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4366 (?=(?P<clean_artist>[^\n]+))(?P=clean_artist)\n
4367 )?.+\nAuto-generated\ by\ YouTube\.\s*$
4368 ''', video_description
)
4370 release_year
= mobj
.group('release_year')
4371 release_date
= mobj
.group('release_date')
4373 release_date
= release_date
.replace('-', '')
4374 if not release_year
:
4375 release_year
= release_date
[:4]
4377 'album': mobj
.group('album'.strip()),
4378 'artist': mobj
.group('clean_artist') or ', '.join(a
.strip() for a
in mobj
.group('artist').split('·')),
4379 'track': mobj
.group('track').strip(),
4380 'release_date': release_date
,
4381 'release_year': int_or_none(release_year
),
4386 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4387 if not traverse_obj(initial_data
, 'contents'):
4388 self
.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4390 if not initial_data
:
4391 query
= {'videoId': video_id}
4392 query
.update(self
._get
_checkok
_params
())
4393 initial_data
= self
._extract
_response
(
4394 item_id
=video_id
, ep
='next', fatal
=False,
4395 ytcfg
=master_ytcfg
, query
=query
, check_get_keys
='contents',
4396 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4397 note
='Downloading initial data API JSON')
4399 info
['comment_count'] = traverse_obj(initial_data
, (
4400 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4401 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount'
4403 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4404 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo'
4405 ), expected_type
=self
._get
_count
, get_all
=False)
4407 try: # This will error if there is no livechat
4408 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4409 except (KeyError, IndexError, TypeError):
4412 info
.setdefault('subtitles', {})['live_chat'] = [{
4413 # url is needed to set cookies
4414 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4415 'video_id': video_id
,
4417 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4418 else 'youtube_live_chat_replay'),
4422 info
['chapters'] = (
4423 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4424 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4425 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4428 info
['heatmap'] = self
._extract
_heatmap
_from
_player
_overlay
(initial_data
)
4430 contents
= traverse_obj(
4431 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4432 expected_type
=list, default
=[])
4434 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4436 stl
= vpir
.get('superTitleLink')
4438 stl
= self
._get
_text
(stl
)
4441 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4442 info
['location'] = stl
4444 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4447 'series': mobj
.group(1),
4448 'season_number': int(mobj
.group(2)),
4449 'episode_number': int(mobj
.group(3)),
4451 for tlb
in (try_get(
4453 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4457 tlb
, ('toggleButtonRenderer', ...),
4458 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4460 for getter
, regex
in [(
4461 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4462 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4463 lambda x
: x
['accessibility'],
4464 lambda x
: x
['accessibilityData']['accessibilityData'],
4465 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4466 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4468 mobj
= re
.match(regex
, label
)
4470 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4472 sbr_tooltip
= try_get(
4473 vpir
, lambda x
: x
['sentimentBar']['sentimentBarRenderer']['tooltip'])
4475 like_count
, dislike_count
= sbr_tooltip
.split(' / ')
4477 'like_count': str_to_int(like_count
),
4478 'dislike_count': str_to_int(dislike_count
),
4480 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4482 vc
= self
._get
_count
(vcr
, 'viewCount')
4483 # Upcoming premieres with waiting count are treated as live here
4484 if vcr
.get('isLive'):
4485 info
['concurrent_view_count'] = vc
4486 elif info
.get('view_count') is None:
4487 info
['view_count'] = vc
4489 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4491 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4493 'channel': self
._get
_text
(vor
, 'title'),
4494 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4496 if not channel_handle
:
4497 channel_handle
= self
.handle_from_url(
4499 ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4500 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4501 {str}
), get_all
=False))
4505 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4507 multiple_songs
= False
4509 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4510 multiple_songs
= True
4513 mrr
= row
.get('metadataRowRenderer') or {}
4514 mrr_title
= mrr
.get('title')
4517 mrr_title
= self
._get
_text
(mrr
, 'title')
4518 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4519 if mrr_title
== 'License':
4520 info
['license'] = mrr_contents_text
4521 elif not multiple_songs
:
4522 if mrr_title
== 'Album':
4523 info
['album'] = mrr_contents_text
4524 elif mrr_title
== 'Artist':
4525 info
['artist'] = mrr_contents_text
4526 elif mrr_title
== 'Song':
4527 info
['track'] = mrr_contents_text
4528 owner_badges
= self
._extract
_badges
(traverse_obj(vsir
, ('owner', 'videoOwnerRenderer', 'badges')))
4529 if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
):
4530 info
['channel_is_verified'] = True
4533 'uploader': info
.get('channel'),
4534 'uploader_id': channel_handle
,
4535 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4537 # The upload date for scheduled, live and past live streams / premieres in microformats
4538 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4539 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4541 unified_strdate(get_first(microformats
, 'uploadDate'))
4542 or unified_strdate(search_meta('uploadDate')))
4543 if not upload_date
or (
4544 live_status
in ('not_live', None)
4545 and 'no-youtube-prefer-utc-upload-date' not in self
.get_param('compat_opts', [])
4547 upload_date
= strftime_or_none(
4548 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText'))) or upload_date
4549 info
['upload_date'] = upload_date
4551 for s_k
, d_k
in [('artist', 'creator'), ('track', 'alt_title')]:
4556 badges
= self
._extract
_badges
(traverse_obj(vpir
, 'badges'))
4558 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4559 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4561 info
['availability'] = (
4562 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4563 else self
._availability
(
4564 is_private
=is_private
,
4566 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4567 or False if initial_data
and is_private
is not None else None),
4568 needs_subscription
=(
4569 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4570 or False if initial_data
and is_private
is not None else None),
4571 needs_auth
=info
['age_limit'] >= 18,
4572 is_unlisted
=None if is_private
is None else (
4573 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4574 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4576 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4578 self
.mark_watched(video_id
, player_responses
)
4583 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4585 def passthrough_smuggled_data(func
):
4586 def _smuggle(info
, smuggled_data
):
4587 if info
.get('_type') not in ('url', 'url_transparent'):
4589 if smuggled_data
.get('is_music_url'):
4590 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4591 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4592 smuggled_data
.pop('is_music_url')
4593 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4595 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4598 @functools.wraps(func
)
4599 def wrapper(self
, url
):
4600 url
, smuggled_data
= unsmuggle_url(url
, {})
4601 if self
.is_music_url(url
):
4602 smuggled_data
['is_music_url'] = True
4603 info_dict
= func(self
, url
, smuggled_data
)
4605 _smuggle(info_dict
, smuggled_data
)
4606 if info_dict
.get('entries'):
4607 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4612 def _extract_basic_item_renderer(item
):
4613 # Modified from _extract_grid_item_renderer
4614 known_basic_renderers
= (
4615 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer'
4617 for key
, renderer
in item
.items():
4618 if not isinstance(renderer
, dict):
4620 elif key
in known_basic_renderers
:
4622 elif key
.startswith('grid') and key
.endswith('Renderer'):
4625 def _extract_channel_renderer(self
, renderer
):
4626 channel_id
= self
.ucid_or_none(renderer
['channelId'])
4627 title
= self
._get
_text
(renderer
, 'title')
4628 channel_url
= format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None)
4629 channel_handle
= self
.handle_from_url(
4630 traverse_obj(renderer
, (
4631 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4632 ('browseEndpoint', 'canonicalBaseUrl')),
4633 {str}
), get_all
=False))
4634 if not channel_handle
:
4635 # As of 2023-06-01, YouTube sets subscriberCountText to the handle in search
4636 channel_handle
= self
.handle_or_none(self
._get
_text
(renderer
, 'subscriberCountText'))
4641 'ie_key': YoutubeTabIE
.ie_key(),
4644 'channel_id': channel_id
,
4645 'channel_url': channel_url
,
4647 'uploader_id': channel_handle
,
4648 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4649 # See above. YouTube sets videoCountText to the subscriber text in search channel renderers.
4650 # However, in feed/channels this is set correctly to the subscriber count
4651 'channel_follower_count': traverse_obj(
4652 renderer
, 'subscriberCountText', 'videoCountText', expected_type
=self
._get
_count
),
4653 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
4655 # videoCountText may be the subscriber count
4656 self
._get
_count
(renderer
, 'videoCountText')
4657 if self
._get
_count
(renderer
, 'subscriberCountText') is not None else None),
4658 'description': self
._get
_text
(renderer
, 'descriptionSnippet'),
4659 'channel_is_verified': True if self
._has
_badge
(
4660 self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges')), BadgeType
.VERIFIED
) else None,
4663 def _grid_entries(self
, grid_renderer
):
4664 for item
in grid_renderer
['items']:
4665 if not isinstance(item
, dict):
4667 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4668 if not isinstance(renderer
, dict):
4670 title
= self
._get
_text
(renderer
, 'title')
4673 playlist_id
= renderer
.get('playlistId')
4675 yield self
.url_result(
4676 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4677 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4681 video_id
= renderer
.get('videoId')
4683 yield self
._extract
_video
(renderer
)
4686 channel_id
= renderer
.get('channelId')
4688 yield self
._extract
_channel
_renderer
(renderer
)
4690 # generic endpoint URL support
4691 ep_url
= urljoin('https://www.youtube.com/', try_get(
4692 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4695 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4696 if ie
.suitable(ep_url
):
4697 yield self
.url_result(
4698 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4701 def _music_reponsive_list_entry(self
, renderer
):
4702 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4704 title
= traverse_obj(renderer
, (
4705 'flexColumns', 0, 'musicResponsiveListItemFlexColumnRenderer',
4706 'text', 'runs', 0, 'text'))
4707 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4708 ie
=YoutubeIE
.ie_key(), video_id
=video_id
, title
=title
)
4709 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4711 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4713 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4714 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4715 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4716 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4717 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4719 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4720 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4722 def _shelf_entries_from_content(self
, shelf_renderer
):
4723 content
= shelf_renderer
.get('content')
4724 if not isinstance(content
, dict):
4726 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4728 # TODO: add support for nested playlists so each shelf is processed
4729 # as separate playlist
4730 # TODO: this includes only first N items
4731 yield from self
._grid
_entries
(renderer
)
4732 renderer
= content
.get('horizontalListRenderer')
4737 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4739 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4741 shelf_url
= urljoin('https://www.youtube.com', ep
)
4743 # Skipping links to another channels, note that checking for
4744 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4746 if skip_channels
and '/channels?' in shelf_url
:
4748 title
= self
._get
_text
(shelf_renderer
, 'title')
4749 yield self
.url_result(shelf_url
, video_title
=title
)
4750 # Shelf may not contain shelf URL, fallback to extraction from content
4751 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4753 def _playlist_entries(self
, video_list_renderer
):
4754 for content
in video_list_renderer
['contents']:
4755 if not isinstance(content
, dict):
4757 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4758 if not isinstance(renderer
, dict):
4760 video_id
= renderer
.get('videoId')
4763 yield self
._extract
_video
(renderer
)
4765 def _rich_entries(self
, rich_grid_renderer
):
4766 renderer
= traverse_obj(
4768 ('content', ('videoRenderer', 'reelItemRenderer', 'playlistRenderer')), get_all
=False) or {}
4769 video_id
= renderer
.get('videoId')
4771 yield self
._extract
_video
(renderer
)
4773 playlist_id
= renderer
.get('playlistId')
4775 yield self
.url_result(
4776 f
'https://www.youtube.com/playlist?list={playlist_id}',
4777 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4778 video_title
=self
._get
_text
(renderer
, 'title'))
4781 def _video_entry(self
, video_renderer
):
4782 video_id
= video_renderer
.get('videoId')
4784 return self
._extract
_video
(video_renderer
)
4786 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4787 url
= urljoin('https://youtube.com', traverse_obj(
4788 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4790 return self
.url_result(
4791 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4793 def _post_thread_entries(self
, post_thread_renderer
):
4794 post_renderer
= try_get(
4795 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4796 if not post_renderer
:
4799 video_renderer
= try_get(
4800 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4801 video_id
= video_renderer
.get('videoId')
4803 entry
= self
._extract
_video
(video_renderer
)
4806 # playlist attachment
4807 playlist_id
= try_get(
4808 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4810 yield self
.url_result(
4811 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4812 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4813 # inline video links
4814 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4816 if not isinstance(run
, dict):
4819 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4822 if not YoutubeIE
.suitable(ep_url
):
4824 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4825 if video_id
== ep_video_id
:
4827 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4829 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4830 contents
= post_thread_continuation
.get('contents')
4831 if not isinstance(contents
, list):
4833 for content
in contents
:
4834 renderer
= content
.get('backstagePostThreadRenderer')
4835 if isinstance(renderer
, dict):
4836 yield from self
._post
_thread
_entries
(renderer
)
4838 renderer
= content
.get('videoRenderer')
4839 if isinstance(renderer
, dict):
4840 yield self
._video
_entry
(renderer
)
4843 def _rich_grid_entries(self, contents):
4844 for content in contents:
4845 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4847 entry = self._video_entry(video_renderer)
4852 def _report_history_entries(self
, renderer
):
4853 for url
in traverse_obj(renderer
, (
4854 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4855 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4856 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4857 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4859 def _extract_entries(self
, parent_renderer
, continuation_list
):
4860 # continuation_list is modified in-place with continuation_list = [continuation_token]
4861 continuation_list
[:] = [None]
4862 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4863 for content
in contents
:
4864 if not isinstance(content
, dict):
4866 is_renderer
= traverse_obj(
4867 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4870 if content
.get('richItemRenderer'):
4871 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4873 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4874 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4875 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4876 yield from self
._report
_history
_entries
(table
)
4877 continuation_list
[0] = self
._extract
_continuation
(table
)
4880 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4881 for isr_content
in isr_contents
:
4882 if not isinstance(isr_content
, dict):
4886 'playlistVideoListRenderer': self
._playlist
_entries
,
4887 'gridRenderer': self
._grid
_entries
,
4888 'reelShelfRenderer': self
._grid
_entries
,
4889 'shelfRenderer': self
._shelf
_entries
,
4890 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4891 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4892 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4893 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4894 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4895 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)],
4896 'richGridRenderer': lambda x
: self
._extract
_entries
(x
, continuation_list
),
4898 for key
, renderer
in isr_content
.items():
4899 if key
not in known_renderers
:
4901 for entry
in known_renderers
[key
](renderer
):
4904 continuation_list
[0] = self
._extract
_continuation
(renderer
)
4907 if not continuation_list
[0]:
4908 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
4910 if not continuation_list
[0]:
4911 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4913 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
4914 continuation_list
= [None]
4915 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
4916 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
4920 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
4921 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
4922 yield from extract_entries(parent_renderer
)
4923 continuation
= continuation_list
[0]
4925 for page_num
in itertools
.count(1):
4926 if not continuation
:
4928 headers
= self
.generate_api_headers(
4929 ytcfg
=ytcfg
, account_syncid
=account_syncid
, visitor_data
=visitor_data
)
4930 response
= self
._extract
_response
(
4931 item_id
=f
'{item_id} page {page_num}',
4932 query
=continuation
, headers
=headers
, ytcfg
=ytcfg
,
4933 check_get_keys
=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4937 # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
4938 # See: https://github.com/ytdl-org/youtube-dl/issues/28702
4939 visitor_data
= self
._extract
_visitor
_data
(response
) or visitor_data
4942 'videoRenderer': (self
._grid
_entries
, 'items'), # for membership tab
4943 'gridPlaylistRenderer': (self
._grid
_entries
, 'items'),
4944 'gridVideoRenderer': (self
._grid
_entries
, 'items'),
4945 'gridChannelRenderer': (self
._grid
_entries
, 'items'),
4946 'playlistVideoRenderer': (self
._playlist
_entries
, 'contents'),
4947 'itemSectionRenderer': (extract_entries
, 'contents'), # for feeds
4948 'richItemRenderer': (extract_entries
, 'contents'), # for hashtag
4949 'backstagePostThreadRenderer': (self
._post
_thread
_continuation
_entries
, 'contents'),
4950 'reportHistoryTableRowRenderer': (self
._report
_history
_entries
, 'rows'),
4951 'playlistVideoListContinuation': (self
._playlist
_entries
, None),
4952 'gridContinuation': (self
._grid
_entries
, None),
4953 'itemSectionContinuation': (self
._post
_thread
_continuation
_entries
, None),
4954 'sectionListContinuation': (extract_entries
, None), # for feeds
4957 continuation_items
= traverse_obj(response
, (
4958 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
4959 'appendContinuationItemsAction', 'continuationItems'
4960 ), 'continuationContents', get_all
=False)
4961 continuation_item
= traverse_obj(continuation_items
, 0, None, expected_type
=dict, default
={})
4963 video_items_renderer
= None
4964 for key
in continuation_item
.keys():
4965 if key
not in known_renderers
:
4967 func
, parent_key
= known_renderers
[key
]
4968 video_items_renderer
= {parent_key: continuation_items}
if parent_key
else continuation_items
4969 continuation_list
= [None]
4970 yield from func(video_items_renderer
)
4971 continuation
= continuation_list
[0] or self
._extract
_continuation
(video_items_renderer
)
4973 if not video_items_renderer
:
4977 def _extract_selected_tab(tabs
, fatal
=True):
4978 for tab_renderer
in tabs
:
4979 if tab_renderer
.get('selected'):
4982 raise ExtractorError('Unable to find selected tab')
4985 def _extract_tab_renderers(response
):
4986 return traverse_obj(
4987 response
, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type
=dict)
4989 def _extract_from_tabs(self
, item_id
, ytcfg
, data
, tabs
):
4990 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
4992 selected_tab
= self
._extract
_selected
_tab
(tabs
)
4993 metadata
['title'] += format_field(selected_tab
, 'title', ' - %s')
4994 metadata
['title'] += format_field(selected_tab
, 'expandedText', ' - %s')
4996 return self
.playlist_result(
4998 selected_tab
, metadata
['id'], ytcfg
,
4999 self
._extract
_account
_syncid
(ytcfg
, data
),
5000 self
._extract
_visitor
_data
(data
, ytcfg
)),
5003 def _extract_metadata_from_tabs(self
, item_id
, data
):
5004 info
= {'id': item_id}
5006 metadata_renderer
= traverse_obj(data
, ('metadata', 'channelMetadataRenderer'), expected_type
=dict)
5007 if metadata_renderer
:
5008 channel_id
= traverse_obj(metadata_renderer
, ('externalId', {self.ucid_or_none}
),
5009 ('channelUrl', {self.ucid_from_url}
))
5011 'channel': metadata_renderer
.get('title'),
5012 'channel_id': channel_id
,
5014 if info
['channel_id']:
5015 info
['id'] = info
['channel_id']
5017 metadata_renderer
= traverse_obj(data
, ('metadata', 'playlistMetadataRenderer'), expected_type
=dict)
5019 # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
5020 # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
5021 def _get_uncropped(url
):
5022 return url_or_none((url
or '').split('=')[0] + '=s0')
5024 avatar_thumbnails
= self
._extract
_thumbnails
(metadata_renderer
, 'avatar')
5025 if avatar_thumbnails
:
5026 uncropped_avatar
= _get_uncropped(avatar_thumbnails
[0]['url'])
5027 if uncropped_avatar
:
5028 avatar_thumbnails
.append({
5029 'url': uncropped_avatar
,
5030 'id': 'avatar_uncropped',
5034 channel_banners
= self
._extract
_thumbnails
(
5035 data
, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
5036 for banner
in channel_banners
:
5037 banner
['preference'] = -10
5040 uncropped_banner
= _get_uncropped(channel_banners
[0]['url'])
5041 if uncropped_banner
:
5042 channel_banners
.append({
5043 'url': uncropped_banner
,
5044 'id': 'banner_uncropped',
5048 # Deprecated - remove primary_sidebar_renderer when layout discontinued
5049 primary_sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer')
5050 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer'), expected_type
=dict)
5052 primary_thumbnails
= self
._extract
_thumbnails
(
5053 primary_sidebar_renderer
, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
5054 playlist_thumbnails
= self
._extract
_thumbnails
(
5055 playlist_header_renderer
, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
5058 'title': (traverse_obj(metadata_renderer
, 'title')
5059 or self
._get
_text
(data
, ('header', 'hashtagHeaderRenderer', 'hashtag'))
5061 'availability': self
._extract
_availability
(data
),
5062 'channel_follower_count': self
._get
_count
(data
, ('header', ..., 'subscriberCountText')),
5063 'description': try_get(metadata_renderer
, lambda x
: x
.get('description', '')),
5064 'tags': try_get(metadata_renderer
or {}, lambda x
: x
.get('keywords', '').split()),
5065 'thumbnails': (primary_thumbnails
or playlist_thumbnails
) + avatar_thumbnails
+ channel_banners
,
5069 traverse_obj(metadata_renderer
, (('vanityChannelUrl', ('ownerUrls', ...)), {self.handle_from_url}
), get_all
=False)
5070 or traverse_obj(data
, ('header', ..., 'channelHandleText', {self.handle_or_none}
), get_all
=False))
5074 'uploader_id': channel_handle
,
5075 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
5078 channel_badges
= self
._extract
_badges
(traverse_obj(data
, ('header', ..., 'badges'), get_all
=False))
5079 if self
._has
_badge
(channel_badges
, BadgeType
.VERIFIED
):
5080 info
['channel_is_verified'] = True
5081 # Playlist stats is a text runs array containing [video count, view count, last updated].
5082 # last updated or (view count and last updated) may be missing.
5083 playlist_stats
= get_first(
5084 (primary_sidebar_renderer
, playlist_header_renderer
), (('stats', 'briefStats', 'numVideosText'), ))
5086 last_updated_unix
= self
._parse
_time
_text
(
5087 self
._get
_text
(playlist_stats
, 2) # deprecated, remove when old layout discontinued
5088 or self
._get
_text
(playlist_header_renderer
, ('byline', 1, 'playlistBylineRenderer', 'text')))
5089 info
['modified_date'] = strftime_or_none(last_updated_unix
)
5091 info
['view_count'] = self
._get
_count
(playlist_stats
, 1)
5092 if info
['view_count'] is None: # 0 is allowed
5093 info
['view_count'] = self
._get
_count
(playlist_header_renderer
, 'viewCountText')
5094 if info
['view_count'] is None:
5095 info
['view_count'] = self
._get
_count
(data
, (
5096 'contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., 'tabRenderer', 'content', 'sectionListRenderer',
5097 'contents', ..., 'itemSectionRenderer', 'contents', ..., 'channelAboutFullMetadataRenderer', 'viewCountText'))
5099 info
['playlist_count'] = self
._get
_count
(playlist_stats
, 0)
5100 if info
['playlist_count'] is None: # 0 is allowed
5101 info
['playlist_count'] = self
._get
_count
(playlist_header_renderer
, ('byline', 0, 'playlistBylineRenderer', 'text'))
5103 if not info
.get('channel_id'):
5104 owner
= traverse_obj(playlist_header_renderer
, 'ownerText')
5105 if not owner
: # Deprecated
5106 owner
= traverse_obj(
5107 self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarSecondaryInfoRenderer'),
5108 ('videoOwner', 'videoOwnerRenderer', 'title'))
5109 owner_text
= self
._get
_text
(owner
)
5110 browse_ep
= traverse_obj(owner
, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
5112 'channel': self
._search
_regex
(r
'^by (.+) and \d+ others?$', owner_text
, 'uploader', default
=owner_text
),
5113 'channel_id': self
.ucid_or_none(browse_ep
.get('browseId')),
5114 'uploader_id': self
.handle_from_url(urljoin('https://www.youtube.com', browse_ep
.get('canonicalBaseUrl')))
5118 'uploader': info
['channel'],
5119 'channel_url': format_field(info
.get('channel_id'), None, 'https://www.youtube.com/channel/%s', default
=None),
5120 'uploader_url': format_field(info
.get('uploader_id'), None, 'https://www.youtube.com/%s', default
=None),
5125 def _extract_inline_playlist(self
, playlist
, playlist_id
, data
, ytcfg
):
5126 first_id
= last_id
= response
= None
5127 for page_num
in itertools
.count(1):
5128 videos
= list(self
._playlist
_entries
(playlist
))
5131 start
= next((i
for i
, v
in enumerate(videos
) if v
['id'] == last_id
), -1) + 1
5132 if start
>= len(videos
):
5134 yield from videos
[start
:]
5135 first_id
= first_id
or videos
[0]['id']
5136 last_id
= videos
[-1]['id']
5137 watch_endpoint
= try_get(
5138 playlist
, lambda x
: x
['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
5139 headers
= self
.generate_api_headers(
5140 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5141 visitor_data
=self
._extract
_visitor
_data
(response
, data
, ytcfg
))
5143 'playlistId': playlist_id
,
5144 'videoId': watch_endpoint
.get('videoId') or last_id
,
5145 'index': watch_endpoint
.get('index') or len(videos
),
5146 'params': watch_endpoint
.get('params') or 'OAE%3D'
5148 response
= self
._extract
_response
(
5149 item_id
='%s page %d' % (playlist_id
, page_num
),
5150 query
=query
, ep
='next', headers
=headers
, ytcfg
=ytcfg
,
5151 check_get_keys
='contents'
5154 response
, lambda x
: x
['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
5156 def _extract_from_playlist(self
, item_id
, url
, data
, playlist
, ytcfg
):
5157 title
= playlist
.get('title') or try_get(
5158 data
, lambda x
: x
['titleText']['simpleText'], str)
5159 playlist_id
= playlist
.get('playlistId') or item_id
5161 # Delegating everything except mix playlists to regular tab-based playlist URL
5162 playlist_url
= urljoin(url
, try_get(
5163 playlist
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
5166 # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
5167 # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
5168 is_known_unviewable
= re
.fullmatch(r
'MLCT|RLTD[\w-]{22}', playlist_id
)
5170 if playlist_url
and playlist_url
!= url
and not is_known_unviewable
:
5171 return self
.url_result(
5172 playlist_url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
5175 return self
.playlist_result(
5176 self
._extract
_inline
_playlist
(playlist
, playlist_id
, data
, ytcfg
),
5177 playlist_id
=playlist_id
, playlist_title
=title
)
5179 def _extract_availability(self
, data
):
5181 Gets the availability of a given playlist/tab.
5182 Note: Unless YouTube tells us explicitly, we do not assume it is public
5183 @param data: response
5185 sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer') or {}
5186 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer')) or {}
5187 player_header_privacy
= playlist_header_renderer
.get('privacy')
5189 badges
= self
._extract
_badges
(traverse_obj(sidebar_renderer
, 'badges'))
5191 # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
5192 privacy_setting_icon
= get_first(
5193 (playlist_header_renderer
, sidebar_renderer
),
5194 ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
5195 lambda _
, v
: v
['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
5198 microformats_is_unlisted
= traverse_obj(
5199 data
, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type
=bool)
5203 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
5204 or player_header_privacy
== 'PUBLIC'
5205 or privacy_setting_icon
== 'PRIVACY_PUBLIC')
5206 else self
._availability
(
5208 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
5209 or player_header_privacy
== 'PRIVATE' if player_header_privacy
is not None
5210 else privacy_setting_icon
== 'PRIVACY_PRIVATE' if privacy_setting_icon
is not None else None),
5212 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
5213 or player_header_privacy
== 'UNLISTED' if player_header_privacy
is not None
5214 else privacy_setting_icon
== 'PRIVACY_UNLISTED' if privacy_setting_icon
is not None
5215 else microformats_is_unlisted
if microformats_is_unlisted
is not None else None),
5216 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
5217 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
5221 def _extract_sidebar_info_renderer(data
, info_renderer
, expected_type
=dict):
5222 sidebar_renderer
= try_get(
5223 data
, lambda x
: x
['sidebar']['playlistSidebarRenderer']['items'], list) or []
5224 for item
in sidebar_renderer
:
5225 renderer
= try_get(item
, lambda x
: x
[info_renderer
], expected_type
)
5229 def _reload_with_unavailable_videos(self
, item_id
, data
, ytcfg
):
5231 Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
5233 is_playlist
= bool(traverse_obj(
5234 data
, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
5237 headers
= self
.generate_api_headers(
5238 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5239 visitor_data
=self
._extract
_visitor
_data
(data
, ytcfg
))
5241 'params': 'wgYCCAA=',
5242 'browseId': f
'VL{item_id}'
5244 return self
._extract
_response
(
5245 item_id
=item_id
, headers
=headers
, query
=query
,
5246 check_get_keys
='contents', fatal
=False, ytcfg
=ytcfg
,
5247 note
='Redownloading playlist API JSON with unavailable videos')
5249 @functools.cached_property
5250 def skip_webpage(self
):
5251 return 'webpage' in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key())
5253 def _extract_webpage(self
, url
, item_id
, fatal
=True):
5254 webpage
, data
= None, None
5255 for retry
in self
.RetryManager(fatal
=fatal
):
5257 webpage
= self
._download
_webpage
(url
, item_id
, note
='Downloading webpage')
5258 data
= self
.extract_yt_initial_data(item_id
, webpage
or '', fatal
=fatal
) or {}
5259 except ExtractorError
as e
:
5260 if isinstance(e
.cause
, network_exceptions
):
5261 if not isinstance(e
.cause
, urllib
.error
.HTTPError
) or e
.cause
.code
not in (403, 429):
5264 self
._error
_or
_warning
(e
, fatal
=fatal
)
5268 self
._extract
_and
_report
_alerts
(data
)
5269 except ExtractorError
as e
:
5270 self
._error
_or
_warning
(e
, fatal
=fatal
)
5273 # Sometimes youtube returns a webpage with incomplete ytInitialData
5274 # See: https://github.com/yt-dlp/yt-dlp/issues/116
5275 if not traverse_obj(data
, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
5276 retry
.error
= ExtractorError('Incomplete yt initial data received')
5279 return webpage
, data
5281 def _report_playlist_authcheck(self
, ytcfg
, fatal
=True):
5282 """Use if failed to extract ytcfg (and data) from initial webpage"""
5283 if not ytcfg
and self
.is_authenticated
:
5284 msg
= 'Playlists that require authentication may not extract correctly without a successful webpage download'
5285 if 'authcheck' not in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key()) and fatal
:
5286 raise ExtractorError(
5287 f
'{msg}. If you are not downloading private content, or '
5288 'your cookies are only for the first account and channel,'
5289 ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
5291 self
.report_warning(msg
, only_once
=True)
5293 def _extract_data(self
, url
, item_id
, ytcfg
=None, fatal
=True, webpage_fatal
=False, default_client
='web'):
5295 if not self
.skip_webpage
:
5296 webpage
, data
= self
._extract
_webpage
(url
, item_id
, fatal
=webpage_fatal
)
5297 ytcfg
= ytcfg
or self
.extract_ytcfg(item_id
, webpage
)
5298 # Reject webpage data if redirected to home page without explicitly requesting
5299 selected_tab
= self
._extract
_selected
_tab
(self
._extract
_tab
_renderers
(data
), fatal
=False) or {}
5300 if (url
!= 'https://www.youtube.com/feed/recommended'
5301 and selected_tab
.get('tabIdentifier') == 'FEwhat_to_watch' # Home page
5302 and 'no-youtube-channel-redirect' not in self
.get_param('compat_opts', [])):
5303 msg
= 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
5305 raise ExtractorError(msg
, expected
=True)
5306 self
.report_warning(msg
, only_once
=True)
5308 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=fatal
)
5309 data
= self
._extract
_tab
_endpoint
(url
, item_id
, ytcfg
, fatal
=fatal
, default_client
=default_client
)
5312 def _extract_tab_endpoint(self
, url
, item_id
, ytcfg
=None, fatal
=True, default_client
='web'):
5313 headers
= self
.generate_api_headers(ytcfg
=ytcfg
, default_client
=default_client
)
5314 resolve_response
= self
._extract
_response
(
5315 item_id
=item_id
, query
={'url': url}
, check_get_keys
='endpoint', headers
=headers
, ytcfg
=ytcfg
, fatal
=fatal
,
5316 ep
='navigation/resolve_url', note
='Downloading API parameters API JSON', default_client
=default_client
)
5317 endpoints
= {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5318 for ep_key
, ep
in endpoints
.items():
5319 params
= try_get(resolve_response
, lambda x
: x
['endpoint'][ep_key
], dict)
5321 return self
._extract
_response
(
5322 item_id
=item_id
, query
=params
, ep
=ep
, headers
=headers
,
5323 ytcfg
=ytcfg
, fatal
=fatal
, default_client
=default_client
,
5324 check_get_keys
=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5325 err_note
= 'Failed to resolve url (does the playlist exist?)'
5327 raise ExtractorError(err_note
, expected
=True)
5328 self
.report_warning(err_note
, item_id
)
5330 _SEARCH_PARAMS
= None
5332 def _search_results(self
, query
, params
=NO_DEFAULT
, default_client
='web'):
5333 data
= {'query': query}
5334 if params
is NO_DEFAULT
:
5335 params
= self
._SEARCH
_PARAMS
5337 data
['params'] = params
5340 ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5341 ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5343 ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5344 ('continuationContents', ),
5346 display_id
= f
'query "{query}"'
5347 check_get_keys
= tuple({keys[0] for keys in content_keys}
)
5348 ytcfg
= self
._download
_ytcfg
(default_client
, display_id
) if not self
.skip_webpage
else {}
5349 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=False)
5351 continuation_list
= [None]
5353 for page_num
in itertools
.count(1):
5354 data
.update(continuation_list
[0] or {})
5355 headers
= self
.generate_api_headers(
5356 ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(search
), default_client
=default_client
)
5357 search
= self
._extract
_response
(
5358 item_id
=f
'{display_id} page {page_num}', ep
='search', query
=data
,
5359 default_client
=default_client
, check_get_keys
=check_get_keys
, ytcfg
=ytcfg
, headers
=headers
)
5360 slr_contents
= traverse_obj(search
, *content_keys
)
5361 yield from self
._extract
_entries
({'contents': list(variadic(slr_contents))}
, continuation_list
)
5362 if not continuation_list
[0]:
5366 class YoutubeTabIE(YoutubeTabBaseInfoExtractor
):
5367 IE_DESC
= 'YouTube Tabs'
5368 _VALID_URL
= r
'''(?x:
5370 (?!consent\.)(?:\w+\.)?
5372 youtube(?:kids)?\.com|
5376 (?P<channel_type>channel|c|user|browse)/|
5379 (?:playlist|watch)\?.*?\blist=
5381 (?!(?:%(reserved_names)s)\b) # Direct URLs
5385 'reserved_names': YoutubeBaseInfoExtractor
._RESERVED
_NAMES
,
5386 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
5388 IE_NAME
= 'youtube:tab'
5391 'note': 'playlists, multipage',
5392 'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5393 'playlist_mincount': 94,
5395 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5396 'title': 'Igor Kleiner - Playlists',
5397 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5398 'uploader': 'Igor Kleiner',
5399 'uploader_id': '@IgorDataScience',
5400 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5401 'channel': 'Igor Kleiner',
5402 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5403 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5404 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5405 'channel_follower_count': int
5408 'note': 'playlists, multipage, different order',
5409 'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5410 'playlist_mincount': 94,
5412 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5413 'title': 'Igor Kleiner - Playlists',
5414 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5415 'uploader': 'Igor Kleiner',
5416 'uploader_id': '@IgorDataScience',
5417 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5418 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5419 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5420 'channel': 'Igor Kleiner',
5421 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5422 'channel_follower_count': int
5425 'note': 'playlists, series',
5426 'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5427 'playlist_mincount': 5,
5429 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5430 'title': '3Blue1Brown - Playlists',
5431 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5432 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5433 'channel': '3Blue1Brown',
5434 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5435 'uploader_id': '@3blue1brown',
5436 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5437 'uploader': '3Blue1Brown',
5438 'tags': ['Mathematics'],
5439 'channel_follower_count': int,
5440 'channel_is_verified': True,
5443 'note': 'playlists, singlepage',
5444 'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5445 'playlist_mincount': 4,
5447 'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5448 'title': 'ThirstForScience - Playlists',
5449 'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5450 'uploader': 'ThirstForScience',
5451 'uploader_url': 'https://www.youtube.com/@ThirstForScience',
5452 'uploader_id': '@ThirstForScience',
5453 'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5454 'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5456 'channel': 'ThirstForScience',
5457 'channel_follower_count': int
5460 'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5461 'only_matching': True,
5463 'note': 'basic, single video playlist',
5464 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5466 'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5467 'title': 'youtube-dl public playlist',
5471 'modified_date': '20201130',
5472 'channel': 'Sergey M.',
5473 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5474 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5475 'availability': 'public',
5476 'uploader': 'Sergey M.',
5477 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5478 'uploader_id': '@sergeym.6173',
5480 'playlist_count': 1,
5482 'note': 'empty playlist',
5483 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5485 'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5486 'title': 'youtube-dl empty playlist',
5488 'channel': 'Sergey M.',
5490 'modified_date': '20160902',
5491 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5492 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5493 'availability': 'public',
5494 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5495 'uploader_id': '@sergeym.6173',
5496 'uploader': 'Sergey M.',
5498 'playlist_count': 0,
5501 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5503 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5504 'title': 'lex will - Home',
5505 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5506 'uploader': 'lex will',
5507 'uploader_id': '@lexwill718',
5508 'channel': 'lex will',
5509 'tags': ['bible', 'history', 'prophesy'],
5510 'uploader_url': 'https://www.youtube.com/@lexwill718',
5511 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5512 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5513 'channel_follower_count': int
5515 'playlist_mincount': 2,
5517 'note': 'Videos tab',
5518 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5520 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5521 'title': 'lex will - Videos',
5522 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5523 'uploader': 'lex will',
5524 'uploader_id': '@lexwill718',
5525 'tags': ['bible', 'history', 'prophesy'],
5526 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5527 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5528 'uploader_url': 'https://www.youtube.com/@lexwill718',
5529 'channel': 'lex will',
5530 'channel_follower_count': int
5532 'playlist_mincount': 975,
5534 'note': 'Videos tab, sorted by popular',
5535 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5537 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5538 'title': 'lex will - Videos',
5539 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5540 'uploader': 'lex will',
5541 'uploader_id': '@lexwill718',
5542 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5543 'uploader_url': 'https://www.youtube.com/@lexwill718',
5544 'channel': 'lex will',
5545 'tags': ['bible', 'history', 'prophesy'],
5546 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5547 'channel_follower_count': int
5549 'playlist_mincount': 199,
5551 'note': 'Playlists tab',
5552 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5554 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5555 'title': 'lex will - Playlists',
5556 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5557 'uploader': 'lex will',
5558 'uploader_id': '@lexwill718',
5559 'uploader_url': 'https://www.youtube.com/@lexwill718',
5560 'channel': 'lex will',
5561 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5562 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5563 'tags': ['bible', 'history', 'prophesy'],
5564 'channel_follower_count': int
5566 'playlist_mincount': 17,
5568 'note': 'Community tab',
5569 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5571 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5572 'title': 'lex will - Community',
5573 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5574 'channel': 'lex will',
5575 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5576 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5577 'tags': ['bible', 'history', 'prophesy'],
5578 'channel_follower_count': int,
5579 'uploader_url': 'https://www.youtube.com/@lexwill718',
5580 'uploader_id': '@lexwill718',
5581 'uploader': 'lex will',
5583 'playlist_mincount': 18,
5585 'note': 'Channels tab',
5586 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5588 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5589 'title': 'lex will - Channels',
5590 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5591 'channel': 'lex will',
5592 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5593 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5594 'tags': ['bible', 'history', 'prophesy'],
5595 'channel_follower_count': int,
5596 'uploader_url': 'https://www.youtube.com/@lexwill718',
5597 'uploader_id': '@lexwill718',
5598 'uploader': 'lex will',
5600 'playlist_mincount': 12,
5602 'note': 'Search tab',
5603 'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5604 'playlist_mincount': 40,
5606 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5607 'title': '3Blue1Brown - Search - linear algebra',
5608 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5609 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5610 'tags': ['Mathematics'],
5611 'channel': '3Blue1Brown',
5612 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5613 'channel_follower_count': int,
5614 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5615 'uploader_id': '@3blue1brown',
5616 'uploader': '3Blue1Brown',
5617 'channel_is_verified': True,
5620 'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5621 'only_matching': True,
5623 'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5624 'only_matching': True,
5626 'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5627 'only_matching': True,
5629 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5630 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5632 'title': '29C3: Not my department',
5633 'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5634 'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5637 'modified_date': '20150605',
5638 'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5639 'channel_url': 'https://www.youtube.com/channel/UCEPzS1rYsrkqzSLNp76nrcg',
5640 'channel': 'Christiaan008',
5641 'availability': 'public',
5642 'uploader_id': '@ChRiStIaAn008',
5643 'uploader': 'Christiaan008',
5644 'uploader_url': 'https://www.youtube.com/@ChRiStIaAn008',
5646 'playlist_count': 96,
5648 'note': 'Large playlist',
5649 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5651 'title': 'Uploads from Cauchemar',
5652 'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5653 'channel_url': 'https://www.youtube.com/channel/UCBABnxM4Ar9ten8Mdjj1j0Q',
5655 'modified_date': r
're:\d{8}',
5656 'channel': 'Cauchemar',
5659 'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5660 'availability': 'public',
5661 'uploader_id': '@Cauchemar89',
5662 'uploader': 'Cauchemar',
5663 'uploader_url': 'https://www.youtube.com/@Cauchemar89',
5665 'playlist_mincount': 1123,
5666 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5668 'note': 'even larger playlist, 8832 videos',
5669 'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5670 'only_matching': True,
5672 'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5673 'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5675 'title': 'Uploads from Interstellar Movie',
5676 'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5679 'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5680 'channel_url': 'https://www.youtube.com/channel/UCXw-G3eDE9trcvY2sBMM_aA',
5681 'channel': 'Interstellar Movie',
5683 'modified_date': r
're:\d{8}',
5684 'availability': 'public',
5685 'uploader_id': '@InterstellarMovie',
5686 'uploader': 'Interstellar Movie',
5687 'uploader_url': 'https://www.youtube.com/@InterstellarMovie',
5689 'playlist_mincount': 21,
5691 'note': 'Playlist with "show unavailable videos" button',
5692 'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5694 'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5695 'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5697 'channel': 'Phim Siêu Nhân Nhật Bản',
5700 'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5701 'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5702 'modified_date': r
're:\d{8}',
5703 'availability': 'public',
5704 'uploader_url': 'https://www.youtube.com/@phimsieunhannhatban',
5705 'uploader_id': '@phimsieunhannhatban',
5706 'uploader': 'Phim Siêu Nhân Nhật Bản',
5708 'playlist_mincount': 200,
5709 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5711 'note': 'Playlist with unavailable videos in page 7',
5712 'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5714 'title': 'Uploads from BlankTV',
5715 'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5716 'channel': 'BlankTV',
5717 'channel_url': 'https://www.youtube.com/channel/UC8l9frL61Yl5KFOl87nIm2w',
5718 'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5721 'modified_date': r
're:\d{8}',
5723 'availability': 'public',
5724 'uploader_id': '@blanktv',
5725 'uploader': 'BlankTV',
5726 'uploader_url': 'https://www.youtube.com/@blanktv',
5728 'playlist_mincount': 1000,
5729 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5731 'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5732 'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5734 'title': 'Data Analysis with Dr Mike Pound',
5735 'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5736 'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5739 'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5740 'channel_url': 'https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA',
5741 'channel': 'Computerphile',
5742 'availability': 'public',
5743 'modified_date': '20190712',
5744 'uploader_id': '@Computerphile',
5745 'uploader': 'Computerphile',
5746 'uploader_url': 'https://www.youtube.com/@Computerphile',
5748 'playlist_mincount': 11,
5750 'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5751 'only_matching': True,
5753 'note': 'Playlist URL that does not actually serve a playlist',
5754 'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5756 'id': 'FqZTN594JQw',
5758 'title': "Smiley's People 01 detective, Adventure Series, Action",
5759 'upload_date': '20150526',
5760 'license': 'Standard YouTube License',
5761 'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5762 'categories': ['People & Blogs'],
5768 'skip_download': True,
5770 'skip': 'This video is not available.',
5771 'add_ie': [YoutubeIE
.ie_key()],
5773 'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5774 'only_matching': True,
5776 'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5777 'only_matching': True,
5779 'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5781 'id': 'hGkQjiJLjWQ', # This will keep changing
5784 'upload_date': r
're:\d{8}',
5786 'categories': ['News & Politics'],
5789 'release_timestamp': int,
5790 'channel': 'Sky News',
5791 'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5794 'thumbnail': r
're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5795 'playable_in_embed': True,
5796 'release_date': r
're:\d+',
5797 'availability': 'public',
5798 'live_status': 'is_live',
5799 'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5800 'channel_follower_count': int,
5801 'concurrent_view_count': int,
5802 'uploader_url': 'https://www.youtube.com/@SkyNews',
5803 'uploader_id': '@SkyNews',
5804 'uploader': 'Sky News',
5805 'channel_is_verified': True,
5808 'skip_download': True,
5810 'expected_warnings': ['Ignoring subtitle tracks found in '],
5812 'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5814 'id': 'a48o2S1cPoo',
5816 'title': 'The Young Turks - Live Main Show',
5817 'upload_date': '20150715',
5818 'license': 'Standard YouTube License',
5819 'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5820 'categories': ['News & Politics'],
5821 'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5825 'skip_download': True,
5827 'only_matching': True,
5829 'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5830 'only_matching': True,
5832 'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5833 'only_matching': True,
5835 'note': 'A channel that is not live. Should raise error',
5836 'url': 'https://www.youtube.com/user/numberphile/live',
5837 'only_matching': True,
5839 'url': 'https://www.youtube.com/feed/trending',
5840 'only_matching': True,
5842 'url': 'https://www.youtube.com/feed/library',
5843 'only_matching': True,
5845 'url': 'https://www.youtube.com/feed/history',
5846 'only_matching': True,
5848 'url': 'https://www.youtube.com/feed/subscriptions',
5849 'only_matching': True,
5851 'url': 'https://www.youtube.com/feed/watch_later',
5852 'only_matching': True,
5854 'note': 'Recommended - redirects to home page.',
5855 'url': 'https://www.youtube.com/feed/recommended',
5856 'only_matching': True,
5858 'note': 'inline playlist with not always working continuations',
5859 'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5860 'only_matching': True,
5862 'url': 'https://www.youtube.com/course',
5863 'only_matching': True,
5865 'url': 'https://www.youtube.com/zsecurity',
5866 'only_matching': True,
5868 'url': 'http://www.youtube.com/NASAgovVideo/videos',
5869 'only_matching': True,
5871 'url': 'https://www.youtube.com/TheYoungTurks/live',
5872 'only_matching': True,
5874 'url': 'https://www.youtube.com/hashtag/cctv9',
5880 'playlist_mincount': 300, # not consistent but should be over 300
5882 'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
5883 'only_matching': True,
5885 'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
5886 'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5887 'only_matching': True
5889 'note': '/browse/ should redirect to /channel/',
5890 'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
5891 'only_matching': True
5893 'note': 'VLPL, should redirect to playlist?list=PL...',
5894 'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5896 'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5897 'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
5898 'title': 'NCS : All Releases 💿',
5899 'channel_url': 'https://www.youtube.com/channel/UC_aEa8K-EOJ3D6gOs7HcyNg',
5900 'modified_date': r
're:\d{8}',
5902 'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
5904 'channel': 'NoCopyrightSounds',
5905 'availability': 'public',
5906 'uploader_url': 'https://www.youtube.com/@NoCopyrightSounds',
5907 'uploader': 'NoCopyrightSounds',
5908 'uploader_id': '@NoCopyrightSounds',
5910 'playlist_mincount': 166,
5911 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden', 'YouTube Music is not directly supported'],
5913 # TODO: fix 'unviewable' issue with this playlist when reloading with unavailable videos
5914 'note': 'Topic, should redirect to playlist?list=UU...',
5915 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5917 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5918 'title': 'Uploads from Royalty Free Music - Topic',
5920 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5921 'channel': 'Royalty Free Music - Topic',
5923 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5924 'modified_date': r
're:\d{8}',
5926 'availability': 'public',
5927 'uploader': 'Royalty Free Music - Topic',
5929 'playlist_mincount': 101,
5930 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5932 # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
5933 # Treat as a general feed
5934 'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
5936 'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
5937 'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
5940 'playlist_mincount': 9,
5942 'note': 'Youtube music Album',
5943 'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
5945 'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
5946 'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
5950 'availability': 'unlisted',
5951 'modified_date': r
're:\d{8}',
5953 'playlist_count': 50,
5954 'expected_warnings': ['YouTube Music is not directly supported'],
5956 'note': 'unlisted single video playlist',
5957 'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5959 'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5960 'title': 'yt-dlp unlisted playlist test',
5961 'availability': 'unlisted',
5963 'modified_date': '20220418',
5964 'channel': 'colethedj',
5967 'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5968 'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5969 'uploader_url': 'https://www.youtube.com/@colethedj1894',
5970 'uploader_id': '@colethedj1894',
5971 'uploader': 'colethedj',
5975 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
5976 'id': 'BaW_jenozKc',
5978 'ie_key': 'Youtube',
5980 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
5981 'channel_url': 'https://www.youtube.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
5983 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc',
5984 'channel': 'Philipp Hagemeister',
5985 'uploader_id': '@PhilippHagemeister',
5986 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
5987 'uploader': 'Philipp Hagemeister',
5990 'playlist_count': 1,
5991 'params': {'extract_flat': True}
,
5993 'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
5994 'url': 'https://www.youtube.com/feed/recommended',
5996 'id': 'recommended',
5997 'title': 'recommended',
6000 'playlist_mincount': 50,
6002 'skip_download': True,
6003 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6006 'note': 'API Fallback: /videos tab, sorted by oldest first',
6007 'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
6009 'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6010 'title': 'Cody\'sLab - Videos',
6011 'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
6012 'channel': 'Cody\'sLab',
6013 'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6015 'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
6016 'channel_follower_count': int
6018 'playlist_mincount': 650,
6020 'skip_download': True,
6021 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6023 'skip': 'Query for sorting no longer works',
6025 'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
6026 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
6028 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
6029 'title': 'Uploads from Royalty Free Music - Topic',
6030 'modified_date': r
're:\d{8}',
6031 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
6033 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
6035 'channel': 'Royalty Free Music - Topic',
6037 'availability': 'public',
6038 'uploader': 'Royalty Free Music - Topic',
6040 'playlist_mincount': 101,
6042 'skip_download': True,
6043 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6045 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
6047 'note': 'non-standard redirect to regional channel',
6048 'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
6049 'only_matching': True
6051 'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
6052 'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6054 'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6055 'modified_date': '20220407',
6056 'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
6058 'availability': 'unlisted',
6059 'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
6060 'channel': 'pukkandan',
6061 'description': 'Test for collaborative playlist',
6062 'title': 'yt-dlp test - collaborative playlist',
6064 'uploader_url': 'https://www.youtube.com/@pukkandan',
6065 'uploader_id': '@pukkandan',
6066 'uploader': 'pukkandan',
6068 'playlist_mincount': 2
6070 'note': 'translated tab name',
6071 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
6073 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6075 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6076 'description': 'test description',
6077 'title': 'cole-dlp-test-acc - 再生リスト',
6078 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6079 'channel': 'cole-dlp-test-acc',
6080 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6081 'uploader_id': '@coletdjnz',
6082 'uploader': 'cole-dlp-test-acc',
6084 'playlist_mincount': 1,
6085 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6086 'expected_warnings': ['Preferring "ja"'],
6088 # XXX: this should really check flat playlist entries, but the test suite doesn't support that
6089 'note': 'preferred lang set with playlist with translated video titles',
6090 'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6092 'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6095 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6096 'channel': 'cole-dlp-test-acc',
6097 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6098 'description': 'test',
6099 'title': 'dlp test playlist',
6100 'availability': 'public',
6101 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6102 'uploader_id': '@coletdjnz',
6103 'uploader': 'cole-dlp-test-acc',
6105 'playlist_mincount': 1,
6106 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6107 'expected_warnings': ['Preferring "ja"'],
6109 # shorts audio pivot for 2GtVksBMYFM.
6110 'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
6112 'id': 'sfv_audio_pivot',
6113 'title': 'sfv_audio_pivot',
6116 'playlist_mincount': 50,
6119 # Channel with a real live tab (not to be mistaken with streams tab)
6120 # Do not treat like it should redirect to live stream
6121 'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
6123 'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
6124 'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
6127 'playlist_mincount': 20,
6129 # Tab name is not the same as tab id
6130 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
6132 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6133 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
6136 'playlist_mincount': 8,
6138 # Home tab id is literally home. Not to get mistaken with featured
6139 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
6141 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6142 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
6145 'playlist_mincount': 8,
6147 # Should get three playlists for videos, shorts and streams tabs
6148 'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6150 'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6151 'title': 'Polka Ch. 尾丸ポルカ',
6152 'channel_follower_count': int,
6153 'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6154 'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6155 'description': 'md5:e56b74b5bb7e9c701522162e9abfb822',
6156 'channel': 'Polka Ch. 尾丸ポルカ',
6158 'uploader_url': 'https://www.youtube.com/@OmaruPolka',
6159 'uploader': 'Polka Ch. 尾丸ポルカ',
6160 'uploader_id': '@OmaruPolka',
6162 'playlist_count': 3,
6164 # Shorts tab with channel with handle
6165 # TODO: fix channel description
6166 'url': 'https://www.youtube.com/@NotJustBikes/shorts',
6168 'id': 'UC0intLFzLaudFG-xAvUEO-A',
6169 'title': 'Not Just Bikes - Shorts',
6171 'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
6172 'description': 'md5:26bc55af26855a608a5cf89dfa595c8d',
6173 'channel_follower_count': int,
6174 'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
6175 'channel': 'Not Just Bikes',
6176 'uploader_url': 'https://www.youtube.com/@NotJustBikes',
6177 'uploader': 'Not Just Bikes',
6178 'uploader_id': '@NotJustBikes',
6180 'playlist_mincount': 10,
6183 'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
6185 'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6186 'title': '中村悠一 - Live',
6188 'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6189 'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
6191 'channel_follower_count': int,
6192 'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
6193 'uploader_url': 'https://www.youtube.com/@Yuichi-Nakamura',
6194 'uploader_id': '@Yuichi-Nakamura',
6197 'playlist_mincount': 60,
6199 # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
6200 # See test_youtube_lists
6201 'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
6202 'only_matching': True,
6204 # No uploads and no UCID given. Should fail with no uploads error
6205 # See test_youtube_lists
6206 'url': 'https://www.youtube.com/news',
6207 'only_matching': True
6209 # No videos tab but has a shorts tab
6210 'url': 'https://www.youtube.com/c/TKFShorts',
6212 'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6213 'title': 'Shorts Break - Shorts',
6215 'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6216 'channel': 'Shorts Break',
6217 'description': 'md5:6de33c5e7ba686e5f3efd4e19c7ef499',
6218 'channel_follower_count': int,
6219 'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
6220 'uploader_url': 'https://www.youtube.com/@ShortsBreak_Official',
6221 'uploader': 'Shorts Break',
6222 'uploader_id': '@ShortsBreak_Official',
6224 'playlist_mincount': 30,
6226 # Trending Now Tab. tab id is empty
6227 'url': 'https://www.youtube.com/feed/trending',
6230 'title': 'trending - Now',
6233 'playlist_mincount': 30,
6235 # Trending Gaming Tab. tab id is empty
6236 'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
6239 'title': 'trending - Gaming',
6242 'playlist_mincount': 30,
6244 # Shorts url result in shorts tab
6245 # TODO: Fix channel id extraction
6246 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
6248 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6249 'title': 'cole-dlp-test-acc - Shorts',
6250 'channel': 'cole-dlp-test-acc',
6251 'description': 'test description',
6252 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6253 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6255 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6256 'uploader_id': '@coletdjnz',
6257 'uploader': 'cole-dlp-test-acc',
6261 # Channel data is not currently available for short renderers (as of 2023-03-01)
6263 'ie_key': 'Youtube',
6264 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
6265 'id': 'sSM9J5YH_60',
6266 'title': 'SHORT short',
6271 'params': {'extract_flat': True}
,
6273 # Live video status should be extracted
6274 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
6276 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6277 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live', # TODO, should be Minecraft - Live or Minecraft - Topic - Live
6283 'ie_key': 'Youtube',
6284 'url': 'startswith:https://www.youtube.com/watch?v=',
6287 'live_status': 'is_live',
6290 'concurrent_view_count': int,
6293 'uploader_url': str,
6295 'channel_is_verified': bool, # this will keep changing
6298 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6299 'playlist_mincount': 1
6301 # Channel renderer metadata. Contains number of videos on the channel
6302 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/channels',
6304 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6305 'title': 'cole-dlp-test-acc - Channels',
6306 'channel': 'cole-dlp-test-acc',
6307 'description': 'test description',
6308 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6309 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6311 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6312 'uploader_id': '@coletdjnz',
6313 'uploader': 'cole-dlp-test-acc',
6318 'ie_key': 'YoutubeTab',
6319 'url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6320 'id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6321 'channel_id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6322 'title': 'PewDiePie',
6323 'channel': 'PewDiePie',
6324 'channel_url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6326 'channel_follower_count': int,
6327 'playlist_count': int,
6328 'uploader': 'PewDiePie',
6329 'uploader_url': 'https://www.youtube.com/@PewDiePie',
6330 'uploader_id': '@PewDiePie',
6331 'channel_is_verified': True,
6334 'params': {'extract_flat': True}
,
6336 'url': 'https://www.youtube.com/@3blue1brown/about',
6338 'id': 'UCYO_jab_esuFRV4b17AJtAw',
6339 'tags': ['Mathematics'],
6340 'title': '3Blue1Brown - About',
6341 'channel_follower_count': int,
6342 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
6343 'channel': '3Blue1Brown',
6345 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
6346 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
6347 'uploader_url': 'https://www.youtube.com/@3blue1brown',
6348 'uploader_id': '@3blue1brown',
6349 'uploader': '3Blue1Brown',
6350 'channel_is_verified': True,
6352 'playlist_count': 0,
6354 # Podcasts tab, with rich entry playlistRenderers
6355 'url': 'https://www.youtube.com/@99percentinvisiblepodcast/podcasts',
6357 'id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6358 'channel_id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6359 'uploader_url': 'https://www.youtube.com/@99percentinvisiblepodcast',
6360 'description': 'md5:3a0ed38f1ad42a68ef0428c04a15695c',
6361 'title': '99 Percent Invisible - Podcasts',
6362 'uploader': '99 Percent Invisible',
6363 'channel_follower_count': int,
6364 'channel_url': 'https://www.youtube.com/channel/UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6366 'channel': '99 Percent Invisible',
6367 'uploader_id': '@99percentinvisiblepodcast',
6369 'playlist_count': 1,
6371 # Releases tab, with rich entry playlistRenderers (same as Podcasts tab)
6372 'url': 'https://www.youtube.com/@AHimitsu/releases',
6374 'id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6375 'channel': 'A Himitsu',
6376 'uploader_url': 'https://www.youtube.com/@AHimitsu',
6377 'title': 'A Himitsu - Releases',
6378 'uploader_id': '@AHimitsu',
6379 'uploader': 'A Himitsu',
6380 'channel_id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6382 'description': 'I make music',
6383 'channel_url': 'https://www.youtube.com/channel/UCgFwu-j5-xNJml2FtTrrB3A',
6384 'channel_follower_count': int,
6385 'channel_is_verified': True,
6387 'playlist_mincount': 10,
6389 # Playlist with only shorts, shown as reel renderers
6390 # FIXME: future: YouTube currently doesn't give continuation for this,
6392 'url': 'https://www.youtube.com/playlist?list=UUxqPAgubo4coVn9Lx1FuKcg',
6394 'id': 'UUxqPAgubo4coVn9Lx1FuKcg',
6395 'channel_url': 'https://www.youtube.com/channel/UCxqPAgubo4coVn9Lx1FuKcg',
6397 'uploader_id': '@BangyShorts',
6399 'uploader_url': 'https://www.youtube.com/@BangyShorts',
6400 'channel_id': 'UCxqPAgubo4coVn9Lx1FuKcg',
6401 'channel': 'Bangy Shorts',
6402 'uploader': 'Bangy Shorts',
6404 'availability': 'public',
6405 'modified_date': '20230626',
6406 'title': 'Uploads from Bangy Shorts',
6408 'playlist_mincount': 100,
6409 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6413 def suitable(cls
, url
):
6414 return False if YoutubeIE
.suitable(url
) else super().suitable(url
)
6416 _URL_RE
= re
.compile(rf
'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
6418 def _get_url_mobj(self
, url
):
6419 mobj
= self
._URL
_RE
.match(url
).groupdict()
6420 mobj
.update((k
, '') for k
, v
in mobj
.items() if v
is None)
6423 def _extract_tab_id_and_name(self
, tab
, base_url
='https://www.youtube.com'):
6424 tab_name
= (tab
.get('title') or '').lower()
6425 tab_url
= urljoin(base_url
, traverse_obj(
6426 tab
, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
6428 tab_id
= (tab_url
and self
._get
_url
_mobj
(tab_url
)['tab'][1:]
6429 or traverse_obj(tab
, 'tabIdentifier', expected_type
=str))
6432 'TAB_ID_SPONSORSHIPS': 'membership',
6433 }.get(tab_id
, tab_id
), tab_name
6435 # Fallback to tab name if we cannot get the tab id.
6436 # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6437 # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6439 self
.write_debug(f
'Falling back to selected tab name: {tab_name}')
6443 }.get(tab_name
, tab_name
), tab_name
6445 def _has_tab(self
, tabs
, tab_id
):
6446 return any(self
._extract
_tab
_id
_and
_name
(tab
)[0] == tab_id
for tab
in tabs
)
6448 @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6449 def _real_extract(self
, url
, smuggled_data
):
6450 item_id
= self
._match
_id
(url
)
6451 url
= urllib
.parse
.urlunparse(
6452 urllib
.parse
.urlparse(url
)._replace
(netloc
='www.youtube.com'))
6453 compat_opts
= self
.get_param('compat_opts', [])
6455 mobj
= self
._get
_url
_mobj
(url
)
6456 pre
, tab
, post
, is_channel
= mobj
['pre'], mobj
['tab'], mobj
['post'], not mobj
['not_channel']
6457 if is_channel
and smuggled_data
.get('is_music_url'):
6458 if item_id
[:2] == 'VL': # Youtube music VL channels have an equivalent playlist
6459 return self
.url_result(
6460 f
'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE
, item_id
[2:])
6461 elif item_id
[:2] == 'MP': # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6462 mdata
= self
._extract
_tab
_endpoint
(
6463 f
'https://music.youtube.com/channel/{item_id}', item_id
, default_client
='web_music')
6464 murl
= traverse_obj(mdata
, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6465 get_all
=False, expected_type
=str)
6467 raise ExtractorError('Failed to resolve album to playlist')
6468 return self
.url_result(murl
, YoutubeTabIE
)
6469 elif mobj
['channel_type'] == 'browse': # Youtube music /browse/ should be changed to /channel/
6470 return self
.url_result(
6471 f
'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE
, item_id
)
6473 original_tab_id
, display_id
= tab
[1:], f
'{item_id}{tab}'
6474 if is_channel
and not tab
and 'no-youtube-channel-redirect' not in compat_opts
:
6475 url
= f
'{pre}/videos{post}'
6476 if smuggled_data
.get('is_music_url'):
6477 self
.report_warning(f
'YouTube Music is not directly supported. Redirecting to {url}')
6479 # Handle both video/playlist URLs
6481 video_id
, playlist_id
= [traverse_obj(qs
, (key
, 0)) for key
in ('v', 'list')]
6482 if not video_id
and mobj
['not_channel'].startswith('watch'):
6484 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6485 raise ExtractorError('A video URL was given without video ID', expected
=True)
6486 # Common mistake: https://www.youtube.com/watch?list=playlist_id
6487 self
.report_warning(f
'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6488 return self
.url_result(
6489 f
'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE
, playlist_id
)
6491 if not self
._yes
_playlist
(playlist_id
, video_id
):
6492 return self
.url_result(
6493 f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6495 data
, ytcfg
= self
._extract
_data
(url
, display_id
)
6497 # YouTube may provide a non-standard redirect to the regional channel
6498 # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6499 # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6500 redirect_url
= traverse_obj(
6501 data
, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all
=False)
6502 if redirect_url
and 'no-youtube-channel-redirect' not in compat_opts
:
6503 redirect_url
= ''.join((urljoin('https://www.youtube.com', redirect_url
), tab
, post
))
6504 self
.to_screen(f
'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6505 return self
.url_result(redirect_url
, YoutubeTabIE
)
6507 tabs
, extra_tabs
= self
._extract
_tab
_renderers
(data
), []
6508 if is_channel
and tabs
and 'no-youtube-channel-redirect' not in compat_opts
:
6509 selected_tab
= self
._extract
_selected
_tab
(tabs
)
6510 selected_tab_id
, selected_tab_name
= self
._extract
_tab
_id
_and
_name
(selected_tab
, url
) # NB: Name may be translated
6511 self
.write_debug(f
'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6513 if not original_tab_id
and selected_tab_name
:
6514 self
.to_screen('Downloading all uploads of the channel. '
6515 'To download only the videos in a specific tab, pass the tab\'s URL')
6516 if self
._has
_tab
(tabs
, 'streams'):
6517 extra_tabs
.append(''.join((pre
, '/streams', post
)))
6518 if self
._has
_tab
(tabs
, 'shorts'):
6519 extra_tabs
.append(''.join((pre
, '/shorts', post
)))
6520 # XXX: Members-only tab should also be extracted
6522 if not extra_tabs
and selected_tab_id
!= 'videos':
6523 # Channel does not have streams, shorts or videos tabs
6524 if item_id
[:2] != 'UC':
6525 raise ExtractorError('This channel has no uploads', expected
=True)
6527 # Topic channels don't have /videos. Use the equivalent playlist instead
6528 pl_id
= f
'UU{item_id[2:]}'
6529 pl_url
= f
'https://www.youtube.com/playlist?list={pl_id}'
6531 data
, ytcfg
= self
._extract
_data
(pl_url
, pl_id
, ytcfg
=ytcfg
, fatal
=True, webpage_fatal
=True)
6532 except ExtractorError
:
6533 raise ExtractorError('This channel has no uploads', expected
=True)
6535 item_id
, url
= pl_id
, pl_url
6537 f
'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6539 elif extra_tabs
and selected_tab_id
!= 'videos':
6540 # When there are shorts/live tabs but not videos tab
6541 url
, data
= f
'{pre}{post}', None
6543 elif (original_tab_id
or 'videos') != selected_tab_id
:
6544 if original_tab_id
== 'live':
6545 # Live tab should have redirected to the video
6546 # Except in the case the channel has an actual live tab
6547 # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6548 raise UserNotLive(video_id
=item_id
)
6549 elif selected_tab_name
:
6550 raise ExtractorError(f
'This channel does not have a {original_tab_id} tab', expected
=True)
6552 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6553 url
= f
'{pre}{post}'
6555 # YouTube sometimes provides a button to reload playlist with unavailable videos.
6556 if 'no-youtube-unavailable-videos' not in compat_opts
:
6557 data
= self
._reload
_with
_unavailable
_videos
(display_id
, data
, ytcfg
) or data
6558 self
._extract
_and
_report
_alerts
(data
, only_once
=True)
6560 tabs
, entries
= self
._extract
_tab
_renderers
(data
), []
6562 entries
= [self
._extract
_from
_tabs
(item_id
, ytcfg
, data
, tabs
)]
6564 'extractor_key': YoutubeTabIE
.ie_key(),
6565 'extractor': YoutubeTabIE
.IE_NAME
,
6568 if self
.get_param('playlist_items') == '0':
6569 entries
.extend(self
.url_result(u
, YoutubeTabIE
) for u
in extra_tabs
)
6570 else: # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6571 entries
.extend(map(self
._real
_extract
, extra_tabs
))
6573 if len(entries
) == 1:
6576 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
6577 uploads_url
= 'the Uploads (UU) playlist URL'
6578 if try_get(metadata
, lambda x
: x
['channel_id'].startswith('UC')):
6579 uploads_url
= f
'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6581 'Downloading as multiple playlists, separated by tabs. '
6582 f
'To download as a single playlist instead, pass {uploads_url}')
6583 return self
.playlist_result(entries
, item_id
, **metadata
)
6586 playlist
= traverse_obj(
6587 data
, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type
=dict)
6589 return self
._extract
_from
_playlist
(item_id
, url
, data
, playlist
, ytcfg
)
6591 video_id
= traverse_obj(
6592 data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str) or video_id
6594 if tab
!= '/live': # live tab is expected to redirect to video
6595 self
.report_warning(f
'Unable to recognize playlist. Downloading just video {video_id}')
6596 return self
.url_result(f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6598 raise ExtractorError('Unable to recognize tab page')
6601 class YoutubePlaylistIE(InfoExtractor
):
6602 IE_DESC
= 'YouTube playlists'
6603 _VALID_URL
= r
'''(?x)(?:
6608 youtube(?:kids)?\.com|
6613 (?P<id>%(playlist_id)s)
6615 'playlist_id': YoutubeBaseInfoExtractor
._PLAYLIST
_ID
_RE
,
6616 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
6618 IE_NAME
= 'youtube:playlist'
6620 'note': 'issue #673',
6621 'url': 'PLBB231211A4F62143',
6623 'title': '[OLD]Team Fortress 2 (Class-based LP)',
6624 'id': 'PLBB231211A4F62143',
6625 'uploader': 'Wickman',
6626 'uploader_id': '@WickmanVT',
6627 'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6629 'uploader_url': 'https://www.youtube.com/@WickmanVT',
6630 'modified_date': r
're:\d{8}',
6631 'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6632 'channel': 'Wickman',
6634 'channel_url': 'https://www.youtube.com/channel/UCKSpbfbl5kRQpTdL7kMc-1Q',
6635 'availability': 'public',
6637 'playlist_mincount': 29,
6639 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6641 'title': 'YDL_safe_search',
6642 'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6644 'playlist_count': 2,
6645 'skip': 'This playlist is private',
6648 'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6649 'playlist_count': 4,
6652 'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6653 'uploader': 'milan',
6654 'uploader_id': '@milan5503',
6656 'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6658 'modified_date': '20140919',
6661 'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6662 'uploader_url': 'https://www.youtube.com/@milan5503',
6663 'availability': 'public',
6665 'expected_warnings': [r
'[Uu]navailable videos? (is|are|will be) hidden'],
6667 'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6668 'playlist_mincount': 455,
6670 'title': '2018 Chinese New Singles (11/6 updated)',
6671 'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6673 'uploader_id': '@music_king',
6674 'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6677 'channel_url': 'https://www.youtube.com/channel/UC21nz3_MesPLqtDqwdvnoxA',
6679 'uploader_url': 'https://www.youtube.com/@music_king',
6680 'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6681 'modified_date': r
're:\d{8}',
6682 'availability': 'public',
6684 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6686 'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6687 'only_matching': True,
6689 # music album playlist
6690 'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6691 'only_matching': True,
6695 def suitable(cls
, url
):
6696 if YoutubeTabIE
.suitable(url
):
6698 from ..utils
import parse_qs
6700 if qs
.get('v', [None])[0]:
6702 return super().suitable(url
)
6704 def _real_extract(self
, url
):
6705 playlist_id
= self
._match
_id
(url
)
6706 is_music_url
= YoutubeBaseInfoExtractor
.is_music_url(url
)
6707 url
= update_url_query(
6708 'https://www.youtube.com/playlist',
6709 parse_qs(url
) or {'list': playlist_id}
)
6711 url
= smuggle_url(url
, {'is_music_url': True}
)
6712 return self
.url_result(url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6715 class YoutubeYtBeIE(InfoExtractor
):
6716 IE_DESC
= 'youtu.be'
6717 _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}
6719 'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6721 'id': 'yeWKywCrFtk',
6723 'title': 'Small Scale Baler and Braiding Rugs',
6724 'uploader': 'Backus-Page House Museum',
6725 'uploader_id': '@backuspagemuseum',
6726 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/@backuspagemuseum',
6727 'upload_date': '20161008',
6728 'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6729 'categories': ['Nonprofits & Activism'],
6733 'playable_in_embed': True,
6734 'thumbnail': r
're:^https?://.*\.webp',
6735 'channel': 'Backus-Page House Museum',
6736 'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6737 'live_status': 'not_live',
6739 'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6740 'availability': 'public',
6742 'comment_count': int,
6743 'channel_follower_count': int
6747 'skip_download': True,
6750 'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6751 'only_matching': True,
6754 def _real_extract(self
, url
):
6755 mobj
= self
._match
_valid
_url
(url
)
6756 video_id
= mobj
.group('id')
6757 playlist_id
= mobj
.group('playlist_id')
6758 return self
.url_result(
6759 update_url_query('https://www.youtube.com/watch', {
6761 'list': playlist_id
,
6762 'feature': 'youtu.be',
6763 }), ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6766 class YoutubeLivestreamEmbedIE(InfoExtractor
):
6767 IE_DESC
= 'YouTube livestream embeds'
6768 _VALID_URL
= r
'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6770 'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6771 'only_matching': True,
6774 def _real_extract(self
, url
):
6775 channel_id
= self
._match
_id
(url
)
6776 return self
.url_result(
6777 f
'https://www.youtube.com/channel/{channel_id}/live',
6778 ie
=YoutubeTabIE
.ie_key(), video_id
=channel_id
)
6781 class YoutubeYtUserIE(InfoExtractor
):
6782 IE_DESC
= 'YouTube user videos; "ytuser:" prefix'
6783 IE_NAME
= 'youtube:user'
6784 _VALID_URL
= r
'ytuser:(?P<id>.+)'
6786 'url': 'ytuser:phihag',
6787 'only_matching': True,
6790 def _real_extract(self
, url
):
6791 user_id
= self
._match
_id
(url
)
6792 return self
.url_result(f
'https://www.youtube.com/user/{user_id}', YoutubeTabIE
, user_id
)
6795 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor
):
6796 IE_NAME
= 'youtube:favorites'
6797 IE_DESC
= 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6798 _VALID_URL
= r
':ytfav(?:ou?rite)?s?'
6799 _LOGIN_REQUIRED
= True
6802 'only_matching': True,
6804 'url': ':ytfavorites',
6805 'only_matching': True,
6808 def _real_extract(self
, url
):
6809 return self
.url_result(
6810 'https://www.youtube.com/playlist?list=LL',
6811 ie
=YoutubeTabIE
.ie_key())
6814 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor
):
6815 IE_NAME
= 'youtube:notif'
6816 IE_DESC
= 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6817 _VALID_URL
= r
':ytnotif(?:ication)?s?'
6818 _LOGIN_REQUIRED
= True
6821 'only_matching': True,
6823 'url': ':ytnotifications',
6824 'only_matching': True,
6827 def _extract_notification_menu(self
, response
, continuation_list
):
6828 notification_list
= traverse_obj(
6830 ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6831 ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6832 expected_type
=list) or []
6833 continuation_list
[0] = None
6834 for item
in notification_list
:
6835 entry
= self
._extract
_notification
_renderer
(item
.get('notificationRenderer'))
6838 continuation
= item
.get('continuationItemRenderer')
6840 continuation_list
[0] = continuation
6842 def _extract_notification_renderer(self
, notification
):
6843 video_id
= traverse_obj(
6844 notification
, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str)
6845 url
= f
'https://www.youtube.com/watch?v={video_id}'
6848 browse_ep
= traverse_obj(
6849 notification
, ('navigationEndpoint', 'browseEndpoint'), expected_type
=dict)
6850 channel_id
= self
.ucid_or_none(traverse_obj(browse_ep
, 'browseId', expected_type
=str))
6851 post_id
= self
._search
_regex
(
6852 r
'/post/(.+)', traverse_obj(browse_ep
, 'canonicalBaseUrl', expected_type
=str),
6853 'post id', default
=None)
6854 if not channel_id
or not post_id
:
6856 # The direct /post url redirects to this in the browser
6857 url
= f
'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
6859 channel
= traverse_obj(
6860 notification
, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
6862 notification_title
= self
._get
_text
(notification
, 'shortMessage')
6863 if notification_title
:
6864 notification_title
= notification_title
.replace('\xad', '') # remove soft hyphens
6865 # TODO: handle recommended videos
6866 title
= self
._search
_regex
(
6867 rf
'{re.escape(channel or "")}[^:]+: (.+)', notification_title
,
6868 'video title', default
=None)
6869 timestamp
= (self
._parse
_time
_text
(self
._get
_text
(notification
, 'sentTimeText'))
6870 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
6875 'ie_key': (YoutubeIE
if video_id
else YoutubeTabIE
).ie_key(),
6876 'video_id': video_id
,
6878 'channel_id': channel_id
,
6880 'uploader': channel
,
6881 'thumbnails': self
._extract
_thumbnails
(notification
, 'videoThumbnail'),
6882 'timestamp': timestamp
,
6885 def _notification_menu_entries(self
, ytcfg
):
6886 continuation_list
= [None]
6888 for page
in itertools
.count(1):
6889 ctoken
= traverse_obj(
6890 continuation_list
, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type
=str)
6891 response
= self
._extract
_response
(
6892 item_id
=f
'page {page}', query
={'ctoken': ctoken}
if ctoken
else {}, ytcfg
=ytcfg
,
6893 ep
='notification/get_notification_menu', check_get_keys
='actions',
6894 headers
=self
.generate_api_headers(ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(response
)))
6895 yield from self
._extract
_notification
_menu
(response
, continuation_list
)
6896 if not continuation_list
[0]:
6899 def _real_extract(self
, url
):
6900 display_id
= 'notifications'
6901 ytcfg
= self
._download
_ytcfg
('web', display_id
) if not self
.skip_webpage
else {}
6902 self
._report
_playlist
_authcheck
(ytcfg
)
6903 return self
.playlist_result(self
._notification
_menu
_entries
(ytcfg
), display_id
, display_id
)
6906 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6907 IE_DESC
= 'YouTube search'
6908 IE_NAME
= 'youtube:search'
6909 _SEARCH_KEY
= 'ytsearch'
6910 _SEARCH_PARAMS
= 'EgIQAQ%3D%3D' # Videos only
6912 'url': 'ytsearch5:youtube-dl test video',
6913 'playlist_count': 5,
6915 'id': 'youtube-dl test video',
6916 'title': 'youtube-dl test video',
6921 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6922 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ ':date'
6923 _SEARCH_KEY
= 'ytsearchdate'
6924 IE_DESC
= 'YouTube search, newest videos first'
6925 _SEARCH_PARAMS
= 'CAISAhAB' # Videos only, sorted by date
6927 'url': 'ytsearchdate5:youtube-dl test video',
6928 'playlist_count': 5,
6930 'id': 'youtube-dl test video',
6931 'title': 'youtube-dl test video',
6936 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor
):
6937 IE_DESC
= 'YouTube search URLs with sorting and filter support'
6938 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ '_url'
6939 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6941 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
6942 'playlist_mincount': 5,
6944 'id': 'youtube-dl test video',
6945 'title': 'youtube-dl test video',
6948 'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
6949 'playlist_mincount': 5,
6955 'url': 'https://www.youtube.com/results?search_query=%23cats',
6956 'playlist_mincount': 1,
6960 # The test suite does not have support for nested playlists
6962 # 'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
6968 'url': 'https://www.youtube.com/results?search_query=kurzgesagt&sp=EgIQAg%253D%253D',
6971 'title': 'kurzgesagt',
6976 'id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6977 'url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6978 'ie_key': 'YoutubeTab',
6979 'channel': 'Kurzgesagt – In a Nutshell',
6980 'description': 'md5:4ae48dfa9505ffc307dad26342d06bfc',
6981 'title': 'Kurzgesagt – In a Nutshell',
6982 'channel_id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6983 # No longer available for search as it is set to the handle.
6984 # 'playlist_count': int,
6985 'channel_url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6987 'uploader_id': '@kurzgesagt',
6988 'uploader_url': 'https://www.youtube.com/@kurzgesagt',
6989 'uploader': 'Kurzgesagt – In a Nutshell',
6990 'channel_is_verified': True,
6991 'channel_follower_count': int,
6994 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6995 'playlist_mincount': 1,
6997 'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
6998 'only_matching': True,
7001 def _real_extract(self
, url
):
7003 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7004 return self
.playlist_result(self
._search
_results
(query
, qs
.get('sp', (None,))[0]), query
, query
)
7007 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor
):
7008 IE_DESC
= 'YouTube music search URLs with selectable sections, e.g. #songs'
7009 IE_NAME
= 'youtube:music:search_url'
7010 _VALID_URL
= r
'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
7012 'url': 'https://music.youtube.com/search?q=royalty+free+music',
7013 'playlist_count': 16,
7015 'id': 'royalty free music',
7016 'title': 'royalty free music',
7019 'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
7020 'playlist_mincount': 30,
7022 'id': 'royalty free music - songs',
7023 'title': 'royalty free music - songs',
7025 'params': {'extract_flat': 'in_playlist'}
7027 'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
7028 'playlist_mincount': 30,
7030 'id': 'royalty free music - community playlists',
7031 'title': 'royalty free music - community playlists',
7033 'params': {'extract_flat': 'in_playlist'}
7037 'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
7038 'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
7039 'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
7040 'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
7041 'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
7042 'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
7045 def _real_extract(self
, url
):
7047 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7048 params
= qs
.get('sp', (None,))[0]
7050 section
= next((k
for k
, v
in self
._SECTIONS
.items() if v
== params
), params
)
7052 section
= urllib
.parse
.unquote_plus((url
.split('#') + [''])[1]).lower()
7053 params
= self
._SECTIONS
.get(section
)
7056 title
= join_nonempty(query
, section
, delim
=' - ')
7057 return self
.playlist_result(self
._search
_results
(query
, params
, default_client
='web_music'), title
, title
)
7060 class YoutubeFeedsInfoExtractor(InfoExtractor
):
7062 Base class for feed extractors
7063 Subclasses must re-define the _FEED_NAME property.
7065 _LOGIN_REQUIRED
= True
7066 _FEED_NAME
= 'feeds'
7068 def _real_initialize(self
):
7069 YoutubeBaseInfoExtractor
._check
_login
_required
(self
)
7073 return f
'youtube:{self._FEED_NAME}'
7075 def _real_extract(self
, url
):
7076 return self
.url_result(
7077 f
'https://www.youtube.com/feed/{self._FEED_NAME}', ie
=YoutubeTabIE
.ie_key())
7080 class YoutubeWatchLaterIE(InfoExtractor
):
7081 IE_NAME
= 'youtube:watchlater'
7082 IE_DESC
= 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
7083 _VALID_URL
= r
':ytwatchlater'
7085 'url': ':ytwatchlater',
7086 'only_matching': True,
7089 def _real_extract(self
, url
):
7090 return self
.url_result(
7091 'https://www.youtube.com/playlist?list=WL', ie
=YoutubeTabIE
.ie_key())
7094 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor
):
7095 IE_DESC
= 'YouTube recommended videos; ":ytrec" keyword'
7096 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
7097 _FEED_NAME
= 'recommended'
7098 _LOGIN_REQUIRED
= False
7101 'only_matching': True,
7103 'url': ':ytrecommended',
7104 'only_matching': True,
7106 'url': 'https://youtube.com',
7107 'only_matching': True,
7111 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor
):
7112 IE_DESC
= 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
7113 _VALID_URL
= r
':ytsub(?:scription)?s?'
7114 _FEED_NAME
= 'subscriptions'
7117 'only_matching': True,
7119 'url': ':ytsubscriptions',
7120 'only_matching': True,
7124 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor
):
7125 IE_DESC
= 'Youtube watch history; ":ythis" keyword (requires cookies)'
7126 _VALID_URL
= r
':ythis(?:tory)?'
7127 _FEED_NAME
= 'history'
7129 'url': ':ythistory',
7130 'only_matching': True,
7134 class YoutubeShortsAudioPivotIE(InfoExtractor
):
7135 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
7136 IE_NAME
= 'youtube:shorts:pivot:audio'
7137 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
7139 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
7140 'only_matching': True,
7144 def _generate_audio_pivot_params(video_id
):
7146 Generates sfv_audio_pivot browse params for this video id
7148 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
7149 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
7151 def _real_extract(self
, url
):
7152 video_id
= self
._match
_id
(url
)
7153 return self
.url_result(
7154 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
7158 class YoutubeTruncatedURLIE(InfoExtractor
):
7159 IE_NAME
= 'youtube:truncated_url'
7160 IE_DESC
= False # Do not list
7161 _VALID_URL
= r
'''(?x)
7163 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
7166 annotation_id=annotation_[^&]+|
7172 attribution_link\?a=[^&]+
7178 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
7179 'only_matching': True,
7181 'url': 'https://www.youtube.com/watch?',
7182 'only_matching': True,
7184 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
7185 'only_matching': True,
7187 'url': 'https://www.youtube.com/watch?feature=foo',
7188 'only_matching': True,
7190 'url': 'https://www.youtube.com/watch?hl=en-GB',
7191 'only_matching': True,
7193 'url': 'https://www.youtube.com/watch?t=2372',
7194 'only_matching': True,
7197 def _real_extract(self
, url
):
7198 raise ExtractorError(
7199 'Did you forget to quote the URL? Remember that & is a meta '
7200 'character in most shells, so you want to put the URL in quotes, '
7202 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
7203 ' or simply youtube-dl BaW_jenozKc .',
7207 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
7208 IE_NAME
= 'youtube:clip'
7209 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7211 # FIXME: Other metadata should be extracted from the clip, not from the base video
7212 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7214 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7216 'section_start': 29.0,
7217 'section_end': 39.7,
7220 'availability': 'public',
7221 'categories': ['Gaming'],
7222 'channel': 'Scott The Woz',
7223 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7224 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7225 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7227 'playable_in_embed': True,
7229 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7230 'title': 'Mobile Games on Console - Scott The Woz',
7231 'upload_date': '20210920',
7232 'uploader': 'Scott The Woz',
7233 'uploader_id': '@ScottTheWoz',
7234 'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7236 'live_status': 'not_live',
7237 'channel_follower_count': int,
7238 'chapters': 'count:20',
7239 'comment_count': int,
7240 'heatmap': 'count:100',
7244 def _real_extract(self
, url
):
7245 clip_id
= self
._match
_id
(url
)
7246 _
, data
= self
._extract
_webpage
(url
, clip_id
)
7248 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7250 raise ExtractorError('Unable to find video ID')
7252 clip_data
= traverse_obj(data
, (
7253 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7254 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7255 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7256 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
7259 '_type': 'url_transparent',
7260 'url': f
'https://www.youtube.com/watch?v={video_id}',
7261 'ie_key': YoutubeIE
.ie_key(),
7263 'section_start': int(clip_data
['startTimeMs']) / 1000,
7264 'section_end': int(clip_data
['endTimeMs']) / 1000,
7268 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor
):
7269 IE_NAME
= 'youtube:consent'
7270 IE_DESC
= False # Do not list
7271 _VALID_URL
= r
'https?://consent\.youtube\.com/m\?'
7273 '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',
7275 'id': 'qVv6vCqciTM',
7278 'uploader_id': '@sana_natori',
7279 'comment_count': int,
7280 'chapters': 'count:13',
7281 'upload_date': '20221223',
7282 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7283 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7284 'uploader_url': 'https://www.youtube.com/@sana_natori',
7286 'release_date': '20221223',
7287 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7288 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7290 'playable_in_embed': True,
7292 'availability': 'public',
7293 'channel_follower_count': int,
7294 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7295 'categories': ['Entertainment'],
7296 'live_status': 'was_live',
7297 'release_timestamp': 1671793345,
7298 'channel': 'さなちゃんねる',
7299 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7300 'uploader': 'さなちゃんねる',
7301 'channel_is_verified': True,
7302 'heatmap': 'count:100',
7304 'add_ie': ['Youtube'],
7305 'params': {'skip_download': 'Youtube'}
,
7308 def _real_extract(self
, url
):
7309 redirect_url
= url_or_none(parse_qs(url
).get('continue', [None])[-1])
7310 if not redirect_url
:
7311 raise ExtractorError('Invalid cookie consent redirect URL', expected
=True)
7312 return self
.url_result(redirect_url
)
7315 class YoutubeTruncatedIDIE(InfoExtractor
):
7316 IE_NAME
= 'youtube:truncated_id'
7317 IE_DESC
= False # Do not list
7318 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7321 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7322 'only_matching': True,
7325 def _real_extract(self
, url
):
7326 video_id
= self
._match
_id
(url
)
7327 raise ExtractorError(
7328 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',