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 # Story. Requires specific player params to work.
2504 'url': 'https://www.youtube.com/watch?v=vv8qTUWmulI',
2506 'id': 'vv8qTUWmulI',
2508 'availability': 'unlisted',
2510 'channel_id': 'UCzIZ8HrzDgc-pNQDUG6avBA',
2511 'upload_date': '20220526',
2512 'categories': ['Education'],
2514 'channel': 'IT\'S HISTORY',
2517 'playable_in_embed': True,
2519 'live_status': 'not_live',
2521 'thumbnail': 'https://i.ytimg.com/vi_webp/vv8qTUWmulI/maxresdefault.webp',
2522 'channel_url': 'https://www.youtube.com/channel/UCzIZ8HrzDgc-pNQDUG6avBA',
2524 'skip': 'stories get removed after some period of time',
2526 'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2528 'id': 'tjjjtzRLHvA',
2530 'title': 'ハッシュタグ無し };if window.ytcsi',
2531 'upload_date': '20220323',
2533 'availability': 'unlisted',
2534 'channel': 'Lesmiscore',
2535 'thumbnail': r're:^https?://.*\.jpg',
2537 'categories': ['Music'],
2540 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2541 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2542 'live_status': 'not_live',
2543 'playable_in_embed': True,
2544 'channel_follower_count': int,
2547 'uploader_id': '@lesmiscore',
2548 'uploader': 'Lesmiscore',
2549 'uploader_url': 'https://www.youtube.com/@lesmiscore',
2552 # Prefer primary title+description language metadata by default
2553 # Do not prefer translated description if primary is empty
2554 'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2556 'id': 'el3E4MbxRqQ',
2558 'title': 'dlp test video 2 - primary sv no desc',
2560 'channel': 'cole-dlp-test-acc',
2563 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2565 'playable_in_embed': True,
2566 'availability': 'unlisted',
2567 'thumbnail': r're:^https?://.*\.jpg',
2570 'live_status': 'not_live',
2571 'upload_date': '20220908',
2572 'categories': ['People & Blogs'],
2573 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2574 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2575 'uploader_id': '@coletdjnz',
2576 'uploader': 'cole-dlp-test-acc',
2578 'params': {'skip_download': True}
2580 # Extractor argument: prefer translated title+description
2581 'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2583 'id': 'gHKT4uU8Zng',
2585 'channel': 'cole-dlp-test-acc',
2588 'live_status': 'not_live',
2589 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2590 'upload_date': '20220728',
2592 'categories': ['People & Blogs'],
2593 'thumbnail': r're:^https?://.*\.jpg',
2594 'title': 'dlp test video title translated (fr)',
2595 'availability': 'public',
2597 'description': 'dlp test video description translated (fr)',
2598 'playable_in_embed': True,
2599 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2600 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2601 'uploader_id': '@coletdjnz',
2602 'uploader': 'cole-dlp-test-acc',
2604 'params': {'skip_download': True, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2605 'expected_warnings': [r'Preferring "fr" translated fields'],
2607 'note': '6 channel audio',
2608 'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2609 'only_matching': True,
2611 'note': 'Multiple HLS formats with same itag',
2612 'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2614 'id': 'kX3nB4PpJko',
2616 'categories': ['Entertainment'],
2617 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2618 'live_status': 'not_live',
2620 'channel_follower_count': int,
2621 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2622 'title': 'Last To Take Hand Off Jet, Keeps It!',
2623 'channel': 'MrBeast',
2624 'playable_in_embed': True,
2626 'upload_date': '20221112',
2627 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2629 'availability': 'public',
2630 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2633 'uploader': 'MrBeast',
2634 'uploader_url': 'https://www.youtube.com/@MrBeast',
2635 'uploader_id': '@MrBeast',
2636 'comment_count': int,
2637 'channel_is_verified': True,
2638 'heatmap': 'count:100',
2640 'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2642 'note': 'Audio formats with Dynamic Range Compression',
2643 'url': 'https://www.youtube.com/watch?v=Tq92D6wQ1mg',
2645 'id': 'Tq92D6wQ1mg',
2647 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
2648 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
2649 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
2650 'channel_follower_count': int,
2651 'description': 'md5:17eccca93a786d51bc67646756894066',
2652 'upload_date': '20191228',
2653 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
2654 'playable_in_embed': True,
2656 'categories': ['Entertainment'],
2657 'thumbnail': 'https://i.ytimg.com/vi/Tq92D6wQ1mg/sddefault.jpg',
2659 'channel': 'Projekt Melody',
2661 'availability': 'needs_auth',
2662 'comment_count': int,
2663 'live_status': 'not_live',
2665 'uploader': 'Projekt Melody',
2666 'uploader_id': '@ProjektMelody',
2667 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
2669 'params': {'extractor_args': {'youtube': {'player_client': ['tv_embedded']}}, 'format': '251-drc'},
2672 'url': 'https://www.youtube.com/live/qVv6vCqciTM',
2674 'id': 'qVv6vCqciTM',
2677 'comment_count': int,
2678 'chapters': 'count:13',
2679 'upload_date': '20221223',
2680 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
2681 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
2683 'release_date': '20221223',
2684 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
2685 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
2687 'playable_in_embed': True,
2689 'availability': 'public',
2690 'channel_follower_count': int,
2691 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
2692 'categories': ['Entertainment'],
2693 'live_status': 'was_live',
2694 'release_timestamp': 1671793345,
2695 'channel': 'さなちゃんねる',
2696 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
2697 'uploader': 'さなちゃんねる',
2698 'uploader_url': 'https://www.youtube.com/@sana_natori',
2699 'uploader_id': '@sana_natori',
2700 'channel_is_verified': True,
2701 'heatmap': 'count:100',
2705 # Fallbacks when webpage and web client is unavailable
2706 'url': 'https://www.youtube.com/watch?v=wSSmNUl9Snw',
2708 'id': 'wSSmNUl9Snw',
2710 # 'categories': ['Science & Technology'],
2712 'chapters': 'count:2',
2713 'channel': 'Scott Manley',
2716 # 'availability': 'public',
2717 'channel_follower_count': int,
2718 'live_status': 'not_live',
2719 'upload_date': '20170831',
2722 'uploader_url': 'https://www.youtube.com/@scottmanley',
2723 'description': 'md5:f4bed7b200404b72a394c2f97b782c02',
2724 'uploader': 'Scott Manley',
2725 'uploader_id': '@scottmanley',
2726 'title': 'The Computer Hack That Saved Apollo 14',
2727 'channel_id': 'UCxzC4EngIsMrPmbm6Nxvb-A',
2728 'thumbnail': r're:^https?://.*\.webp',
2729 'channel_url': 'https://www.youtube.com/channel/UCxzC4EngIsMrPmbm6Nxvb-A',
2730 'playable_in_embed': True,
2731 'comment_count': int,
2732 'channel_is_verified': True,
2733 'heatmap': 'count:100',
2736 'extractor_args': {'youtube': {'player_client': ['android'], 'player_skip': ['webpage']}},
2742 # YouTube <object> embed
2744 'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2745 'md5': '873c81d308b979f0e23ee7e620b312a3',
2747 'id': 'msN87y-iEx0',
2749 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2750 'upload_date': '20080526',
2751 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2753 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2754 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2755 'playable_in_embed': True,
2756 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2758 'comment_count': int,
2759 'channel': 'Christopher Sykes',
2760 'live_status': 'not_live',
2761 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2762 'availability': 'public',
2765 'categories': ['Science & Technology'],
2766 'channel_follower_count': int,
2767 'uploader': 'Christopher Sykes',
2768 'uploader_url': 'https://www.youtube.com/@ChristopherSykesDocumentaries',
2769 'uploader_id': '@ChristopherSykesDocumentaries',
2770 'heatmap': 'count:100',
2773 'skip_download': True,
2779 def suitable(cls, url):
2780 from ..utils import parse_qs
2783 if qs.get('list', [None])[0]:
2785 return super().suitable(url)
2787 def __init__(self, *args, **kwargs):
2788 super().__init__(*args, **kwargs)
2789 self._code_cache = {}
2790 self._player_cache = {}
2792 def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2793 lock = threading.Lock()
2794 start_time = time.time()
2795 formats = [f for f in formats if f.get('is_from_start')]
2797 def refetch_manifest(format_id, delay):
2798 nonlocal formats, start_time, is_live
2799 if time.time() <= start_time + delay:
2802 _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2803 video_details = traverse_obj(prs, (..., 'videoDetails'), expected_type=dict)
2804 microformats = traverse_obj(
2805 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2807 _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2808 is_live = live_status == 'is_live'
2809 start_time = time.time()
2811 def mpd_feed(format_id, delay):
2813 @returns (manifest_url, manifest_stream_number, is_live) or None
2815 for retry in self.RetryManager(fatal=False):
2817 refetch_manifest(format_id, delay)
2819 f = next((f for f in formats if f['format_id'] == format_id), None)
2822 retry.error = f'{video_id}: Video is no longer live'
2824 retry.error = f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}'
2826 return f['manifest_url'], f['manifest_stream_number'], is_live
2830 f['is_live'] = is_live
2831 gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2832 live_start_time, mpd_feed, not is_live and f.copy())
2834 f['fragments'] = gen
2835 f['protocol'] = 'http_dash_segments_generator'
2837 f['fragments'] = LazyList(gen({}))
2838 del f['is_from_start']
2840 def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2841 FETCH_SPAN, MAX_DURATION = 5, 432000
2843 mpd_url, stream_number, is_live = None, None, True
2846 download_start_time = ctx.get('start') or time.time()
2848 lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2849 if lack_early_segments:
2850 self.report_warning(bug_reports_message(
2851 'Starting download from the last 120 hours of the live stream since '
2852 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2853 lack_early_segments = True
2855 known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2856 fragments, fragment_base_url = None, None
2858 def _extract_sequence_from_mpd(refresh_sequence, immediate):
2859 nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2860 # Obtain from MPD's maximum seq value
2861 old_mpd_url = mpd_url
2862 last_error = ctx.pop('last_error', None)
2863 expire_fast = immediate or last_error and isinstance(last_error, urllib.error.HTTPError) and last_error.code == 403
2864 mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2865 or (mpd_url, stream_number, False))
2866 if not refresh_sequence:
2867 if expire_fast and not is_live:
2868 return False, last_seq
2869 elif old_mpd_url == mpd_url:
2870 return True, last_seq
2871 if manifestless_orig_fmt:
2872 fmt_info = manifestless_orig_fmt
2875 fmts, _ = self._extract_mpd_formats_and_subtitles(
2876 mpd_url, None, note=False, errnote=False, fatal=False)
2877 except ExtractorError:
2880 no_fragment_score += 2
2881 return False, last_seq
2882 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2883 fragments = fmt_info['fragments']
2884 fragment_base_url = fmt_info['fragment_base_url']
2885 assert fragment_base_url
2887 _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2888 return True, _last_seq
2890 self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2892 fetch_time = time.time()
2893 if no_fragment_score > 30:
2895 if last_segment_url:
2896 # Obtain from "X-Head-Seqnum" header value from each segment
2898 urlh = self._request_webpage(
2899 last_segment_url, None, note=False, errnote=False, fatal=False)
2900 except ExtractorError:
2902 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2903 if last_seq is None:
2904 no_fragment_score += 2
2905 last_segment_url = None
2908 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2909 no_fragment_score += 2
2910 if not should_continue:
2913 if known_idx > last_seq:
2914 last_segment_url = None
2919 if begin_index < 0 and known_idx < 0:
2920 # skip from the start when it's negative value
2921 known_idx = last_seq + begin_index
2922 if lack_early_segments:
2923 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2925 for idx in range(known_idx, last_seq):
2926 # do not update sequence here or you'll get skipped some part of it
2927 should_continue, _ = _extract_sequence_from_mpd(False, False)
2928 if not should_continue:
2930 raise ExtractorError('breaking out of outer loop')
2931 last_segment_url = urljoin(fragment_base_url, 'sq/%d' % idx)
2933 'url': last_segment_url,
2934 'fragment_count': last_seq,
2936 if known_idx == last_seq:
2937 no_fragment_score += 5
2939 no_fragment_score = 0
2940 known_idx = last_seq
2941 except ExtractorError:
2944 if manifestless_orig_fmt:
2945 # Stop at the first iteration if running for post-live manifestless;
2946 # fragment count no longer increase since it starts
2949 time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2951 def _extract_player_url(self, *ytcfgs, webpage=None):
2952 player_url = traverse_obj(
2953 ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2954 get_all=False, expected_type=str)
2957 return urljoin('https://www.youtube.com', player_url)
2959 def _download_player_url(self, video_id, fatal=False):
2960 res = self._download_webpage(
2961 'https://www.youtube.com/iframe_api',
2962 note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2964 player_version = self._search_regex(
2965 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2967 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2969 def _signature_cache_id(self, example_sig):
2970 """ Return a string representation of a signature """
2971 return '.'.join(str(len(part)) for part in example_sig.split('.'))
2974 def _extract_player_info(cls, player_url):
2975 for player_re in cls._PLAYER_INFO_RE:
2976 id_m = re.search(player_re, player_url)
2980 raise ExtractorError('Cannot identify player %r' % player_url)
2981 return id_m.group('id')
2983 def _load_player(self, video_id, player_url, fatal=True):
2984 player_id = self._extract_player_info(player_url)
2985 if player_id not in self._code_cache:
2986 code = self._download_webpage(
2987 player_url, video_id, fatal=fatal,
2988 note='Downloading player ' + player_id,
2989 errnote='Download of %s failed' % player_url)
2991 self._code_cache[player_id] = code
2992 return self._code_cache.get(player_id)
2994 def _extract_signature_function(self, video_id, player_url, example_sig):
2995 player_id = self._extract_player_info(player_url)
2997 # Read from filesystem cache
2998 func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2999 assert os.path.basename(func_id) == func_id
3001 self.write_debug(f'Extracting signature function {func_id}')
3002 cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
3005 code = self._load_player(video_id, player_url)
3007 res = self._parse_sig_js(code)
3008 test_string = ''.join(map(chr, range(len(example_sig))))
3009 cache_spec = [ord(c) for c in res(test_string)]
3010 self.cache.store('youtube-sigfuncs', func_id, cache_spec)
3012 return lambda s: ''.join(s[i] for i in cache_spec)
3014 def _print_sig_code(self, func, example_sig):
3015 if not self.get_param('youtube_print_sig_code'):
3018 def gen_sig_code(idxs):
3019 def _genslice(start, end, step):
3020 starts = '' if start == 0 else str(start)
3021 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
3022 steps = '' if step == 1 else (':%d' % step)
3023 return f's[{starts}{ends}{steps}]'
3026 # Quelch pyflakes warnings - start will be set when step is set
3027 start = '(Never used)'
3028 for i, prev in zip(idxs[1:], idxs[:-1]):
3029 if step is not None:
3030 if i - prev == step:
3032 yield _genslice(start, prev, step)
3035 if i - prev in [-1, 1]:
3040 yield 's[%d]' % prev
3044 yield _genslice(start, i, step)
3046 test_string = ''.join(map(chr, range(len(example_sig))))
3047 cache_res = func(test_string)
3048 cache_spec = [ord(c) for c in cache_res]
3049 expr_code = ' + '.join(gen_sig_code(cache_spec))
3050 signature_id_tuple = '(%s)' % (
3051 ', '.join(str(len(p)) for p in example_sig.split('.')))
3052 code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
3053 ' return %s\n') % (signature_id_tuple, expr_code)
3054 self.to_screen('Extracted signature function:\n' + code)
3056 def _parse_sig_js(self, jscode):
3057 funcname = self._search_regex(
3058 (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3059 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3060 r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
3061 r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
3062 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+\))?',
3063 r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
3065 r'("|\')signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3066 r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
3067 r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3068 r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3069 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3070 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
3071 jscode, 'Initial JS player signature function name', group='sig')
3073 jsi = JSInterpreter(jscode)
3074 initial_function = jsi.extract_function(funcname)
3075 return lambda s: initial_function([s])
3077 def _cached(self, func, *cache_id):
3078 def inner(*args, **kwargs):
3079 if cache_id not in self._player_cache:
3081 self._player_cache[cache_id] = func(*args, **kwargs)
3082 except ExtractorError as e:
3083 self._player_cache[cache_id] = e
3084 except Exception as e:
3085 self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
3087 ret = self._player_cache[cache_id]
3088 if isinstance(ret, Exception):
3093 def _decrypt_signature(self, s, video_id, player_url):
3094 """Turn the encrypted s field into a working signature"""
3095 extract_sig = self._cached(
3096 self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
3097 func = extract_sig(video_id, player_url, s)
3098 self._print_sig_code(func, s)
3101 def _decrypt_nsig(self, s, video_id, player_url):
3102 """Turn the encrypted n field into a working signature"""
3103 if player_url is None:
3104 raise ExtractorError('Cannot decrypt nsig without player_url')
3105 player_url = urljoin('https://www.youtube.com', player_url)
3108 jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
3109 except ExtractorError as e:
3110 raise ExtractorError('Unable to extract nsig function code', cause=e)
3111 if self.get_param('youtube_print_sig_code'):
3112 self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
3115 extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
3116 ret = extract_nsig(jsi, func_code)(s)
3117 except JSInterpreter.Exception as e:
3119 jsi = PhantomJSwrapper(self, timeout=5000)
3120 except ExtractorError:
3122 self.report_warning(
3123 f'Native nsig extraction failed: Trying with PhantomJS\n'
3124 f' n = {s} ; player = {player_url}', video_id)
3125 self.write_debug(e, only_once=True)
3127 args, func_body = func_code
3129 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
3130 video_id=video_id, note='Executing signature code').strip()
3132 self.write_debug(f'Decrypted nsig {s} => {ret}')
3135 def _extract_n_function_name(self, jscode):
3136 funcname, idx = self._search_regex(
3137 r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
3138 jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
3142 return json.loads(js_to_json(self._search_regex(
3143 rf'var {re.escape(funcname)}\s*=\s*(\[.+?\])[,;]', jscode,
3144 f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
3146 def _extract_n_function_code(self, video_id, player_url):
3147 player_id = self._extract_player_info(player_url)
3148 func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
3149 jscode = func_code or self._load_player(video_id, player_url)
3150 jsi = JSInterpreter(jscode)
3153 return jsi, player_id, func_code
3155 func_name = self._extract_n_function_name(jscode)
3158 func_code = self._search_regex(
3159 r'''(?xs
)%s\s
*=\s
*function\s
*\
((?P
<var
>[\w$
]+)\
)\s
*
3160 # NB: The end of the regex is intentionally kept strict
3161 {(?P<code>.+?}\s
*return\
[\w$
]+.join\
(""\
))};''' % func_name,
3162 jscode, 'nsig function', group=('var', 'code'), default=None)
3164 func_code = ([func_code[0]], func_code[1])
3166 self.write_debug('Extracting nsig function with jsinterp')
3167 func_code = jsi.extract_function_code(func_name)
3169 self.cache.store('youtube-nsig', player_id, func_code)
3170 return jsi, player_id, func_code
3172 def _extract_n_function_from_code(self, jsi, func_code):
3173 func = jsi.extract_function_from_code(*func_code)
3175 def extract_nsig(s):
3178 except JSInterpreter.Exception:
3180 except Exception as e:
3181 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
3183 if ret.startswith('enhanced_except_'):
3184 raise JSInterpreter.Exception('Signature function returned an exception')
3189 def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3191 Extract signatureTimestamp (sts)
3192 Required to tell API what sig/player version is in use.
3195 if isinstance(ytcfg, dict):
3196 sts = int_or_none(ytcfg.get('STS'))
3199 # Attempt to extract from player
3200 if player_url is None:
3201 error_msg = 'Cannot extract signature timestamp without player_url.'
3203 raise ExtractorError(error_msg)
3204 self.report_warning(error_msg)
3206 code = self._load_player(video_id, player_url, fatal=fatal)
3208 sts = int_or_none(self._search_regex(
3209 r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3210 'JS player signature timestamp', group='sts', fatal=fatal))
3213 def _mark_watched(self, video_id, player_responses):
3214 for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3215 label = 'fully ' if is_full else ''
3216 url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3217 expected_type=url_or_none)
3219 self.report_warning(f'Unable to mark {label}watched')
3221 parsed_url = urllib.parse.urlparse(url)
3222 qs = urllib.parse.parse_qs(parsed_url.query)
3224 # cpn generation algorithm is reverse engineered from base.js.
3225 # In fact it works even with dummy cpn.
3226 CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3227 cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16))
3229 # # more consistent results setting it to right before the end
3230 video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3235 'cmt': video_length,
3236 'el': 'detailpage', # otherwise defaults to "shorts"
3240 # these seem to mark watchtime "history" in the real world
3241 # they're required, so send in a single value
3247 url = urllib.parse.urlunparse(
3248 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3250 self._download_webpage(
3251 url, video_id, f'Marking {label}watched',
3252 'Unable to mark watched', fatal=False)
3255 def _extract_from_webpage(cls, url, webpage):
3256 # Invidious Instances
3257 # https://github.com/yt-dlp/yt-dlp/issues/195
3258 # https://github.com/iv-org/invidious/pull/1730
3260 r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3263 yield cls.url_result(mobj.group('url'), cls)
3264 raise cls.StopExtraction()
3266 yield from super()._extract_from_webpage(url, webpage)
3268 # lazyYT YouTube embed
3269 for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3270 yield cls.url_result(unescapeHTML(id_), cls, id_)
3272 # Wordpress "YouTube Video Importer" plugin
3273 for m in re.findall(r'''(?x
)<div
[^
>]+
3274 class=(?P
<q1
>[\'"])[^\'"]*\byvii
_single
_video
_player
\b[^
\'"]*(?P=q1)[^>]+
3275 data-video_id=(?P<q2>[\'"])([^
\'"]+)(?P=q2)''', webpage):
3276 yield cls.url_result(m[-1], cls, m[-1])
3279 def extract_id(cls, url):
3280 video_id = cls.get_temp_id(url)
3282 raise ExtractorError(f'Invalid URL: {url}')
3285 def _extract_chapters_from_json(self, data, duration):
3286 chapter_list = traverse_obj(
3288 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3289 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters'
3290 ), expected_type=list)
3292 return self._extract_chapters_helper(
3294 start_function=lambda chapter: float_or_none(
3295 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3296 title_function=lambda chapter: traverse_obj(
3297 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3300 def _extract_chapters_from_engagement_panel(self, data, duration):
3301 content_list = traverse_obj(
3303 ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3305 chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3306 chapter_title = lambda chapter: self._get_text(chapter, 'title')
3308 return next(filter(None, (
3309 self._extract_chapters_helper(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3310 chapter_time, chapter_title, duration)
3311 for contents in content_list)), [])
3313 def _extract_heatmap_from_player_overlay(self, data):
3314 content_list = traverse_obj(data, (
3315 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer', 'decoratedPlayerBarRenderer', 'playerBar',
3316 'multiMarkersPlayerBarRenderer', 'markersMap', ..., 'value', 'heatmap', 'heatmapRenderer', 'heatMarkers', {list}))
3317 return next(filter(None, (
3318 traverse_obj(contents, (..., 'heatMarkerRenderer', {
3319 'start_time': ('timeRangeStartMillis', {functools.partial(float_or_none, scale=1000)}),
3320 'end_time': {lambda x: (x['timeRangeStartMillis'] + x['markerDurationMillis']) / 1000},
3321 'value': ('heatMarkerIntensityScoreNormalized', {float_or_none}),
3322 })) for contents in content_list)), None)
3324 def _extract_comment(self, comment_renderer, parent=None):
3325 comment_id = comment_renderer.get('commentId')
3331 'text': self._get_text(comment_renderer, 'contentText'),
3332 'like_count': self._get_count(comment_renderer, 'voteCount'),
3333 'author_id': traverse_obj(comment_renderer, ('authorEndpoint', 'browseEndpoint', 'browseId', {self.ucid_or_none})),
3334 'author': self._get_text(comment_renderer, 'authorText'),
3335 'author_thumbnail': traverse_obj(comment_renderer, ('authorThumbnail', 'thumbnails', -1, 'url', {url_or_none})),
3336 'parent': parent or 'root',
3339 # Timestamp is an estimate calculated from the current time and time_text
3340 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3341 timestamp = self._parse_time_text(time_text)
3344 # FIXME: non-standard, but we need a way of showing that it is an estimate.
3345 '_time_text': time_text,
3346 'timestamp': timestamp,
3349 info['author_url'] = urljoin(
3350 'https://www.youtube.com', traverse_obj(comment_renderer, ('authorEndpoint', (
3351 ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'))),
3352 expected_type=str, get_all=False))
3354 author_is_uploader = traverse_obj(comment_renderer, 'authorIsChannelOwner')
3355 if author_is_uploader is not None:
3356 info['author_is_uploader'] = author_is_uploader
3358 comment_abr = traverse_obj(
3359 comment_renderer, ('actionButtons', 'commentActionButtonsRenderer'), expected_type=dict)
3360 if comment_abr is not None:
3361 info['is_favorited'] = 'creatorHeart' in comment_abr
3363 badges = self._extract_badges([traverse_obj(comment_renderer, 'authorCommentBadge')])
3364 if self._has_badge(badges, BadgeType.VERIFIED):
3365 info['author_is_verified'] = True
3367 is_pinned = traverse_obj(comment_renderer, 'pinnedCommentBadge')
3369 info['is_pinned'] = True
3373 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3375 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3377 def extract_header(contents):
3378 _continuation = None
3379 for content in contents:
3380 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3381 expected_comment_count = self._get_count(
3382 comments_header_renderer, 'countText', 'commentsCount')
3384 if expected_comment_count is not None:
3385 tracker['est_total'] = expected_comment_count
3386 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3387 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3389 sort_menu_item = try_get(
3390 comments_header_renderer,
3391 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3392 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3394 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3395 if not _continuation:
3398 sort_text = str_or_none(sort_menu_item.get('title'))
3400 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3401 self.to_screen('Sorting comments by %s' % sort_text.lower())
3403 return _continuation
3405 def extract_thread(contents):
3407 tracker['current_page_thread'] = 0
3408 for content in contents:
3409 if not parent and tracker['total_parent_comments'] >= max_parents:
3411 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3412 comment_renderer = get_first(
3413 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3414 expected_type=dict, default={})
3416 comment = self._extract_comment(comment_renderer, parent)
3419 comment_id = comment['id']
3420 if comment.get('is_pinned'):
3421 tracker['pinned_comment_ids'].add(comment_id)
3422 # Sometimes YouTube may break and give us infinite looping comments.
3423 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3424 if comment_id in tracker['seen_comment_ids']:
3425 if comment_id in tracker['pinned_comment_ids'] and not comment.get('is_pinned'):
3426 # Pinned comments may appear a second time in newest first sort
3427 # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3429 self.report_warning(
3430 'Detected YouTube comments looping. Stopping comment extraction '
3431 f'{"for this thread" if parent else ""} as we probably cannot get any more.')
3434 tracker['seen_comment_ids'].add(comment['id'])
3436 tracker['running_total'] += 1
3437 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3440 # Attempt to get the replies
3441 comment_replies_renderer = try_get(
3442 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3444 if comment_replies_renderer:
3445 tracker['current_page_thread'] += 1
3446 comment_entries_iter = self._comment_entries(
3447 comment_replies_renderer, ytcfg, video_id,
3448 parent=comment.get('id'), tracker=tracker)
3449 yield from itertools.islice(comment_entries_iter, min(
3450 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3452 # Keeps track of counts across recursive calls
3457 current_page_thread=0,
3458 total_parent_comments=0,
3459 total_reply_comments=0,
3460 seen_comment_ids=set(),
3461 pinned_comment_ids=set()
3465 # YouTube comments have a max depth of 2
3466 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3468 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3469 'Set max replies in the max-comments extractor argument instead')
3470 if max_depth == 1 and parent:
3473 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
3474 lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
3476 continuation = self._extract_continuation(root_continuation_data)
3479 is_forced_continuation = False
3480 is_first_continuation = parent is None
3481 if is_first_continuation and not continuation:
3482 # Sometimes you can get comments by generating the continuation yourself,
3483 # even if YouTube initially reports them being disabled - e.g. stories comments.
3484 # Note: if the comment section is actually disabled, YouTube may return a response with
3485 # required check_get_keys missing. So we will disable that check initially in this case.
3486 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3487 is_forced_continuation = True
3489 continuation_items_path = (
3490 'onResponseReceivedEndpoints', ..., ('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems')
3491 for page_num in itertools.count(0):
3492 if not continuation:
3494 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3495 comment_prog_str = f"({tracker['running_total']}
/~{tracker['est_total']}
)"
3497 if is_first_continuation:
3498 note_prefix = 'Downloading comment section API JSON'
3500 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3501 tracker['current_page_thread'], comment_prog_str)
3503 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
3504 ' ' if parent else '', ' replies' if parent else '',
3505 page_num, comment_prog_str)
3507 # Do a deep check for incomplete data as sometimes YouTube may return no comments for a continuation
3508 # Ignore check if YouTube says the comment count is 0.
3509 check_get_keys = None
3510 if not is_forced_continuation and not (tracker['est_total'] == 0 and tracker['running_total'] == 0):
3511 check_get_keys = [[*continuation_items_path, ..., (
3512 'commentsHeaderRenderer' if is_first_continuation else ('commentThreadRenderer', 'commentRenderer'))]]
3514 response = self._extract_response(
3515 item_id=None, query=continuation,
3516 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3517 check_get_keys=check_get_keys)
3518 except ExtractorError as e:
3519 # Ignore incomplete data error for replies if retries didn't work.
3520 # This is to allow any other parent comments and comment threads to be downloaded.
3521 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3522 if 'incomplete data' in str(e).lower() and parent:
3523 if self.get_param('ignoreerrors') in (True, 'only_download'):
3524 self.report_warning(
3525 'Received incomplete data for a comment reply thread and retrying did not help. '
3526 'Ignoring to let other comments be downloaded. Pass --no-ignore-errors to not ignore.')
3529 raise ExtractorError(
3530 'Incomplete data received for comment reply thread. '
3531 'Pass --ignore-errors to ignore and allow rest of comments to download.',
3534 is_forced_continuation = False
3536 for continuation_items in traverse_obj(response, continuation_items_path, expected_type=list, default=[]):
3537 if is_first_continuation:
3538 continuation = extract_header(continuation_items)
3539 is_first_continuation = False
3544 for entry in extract_thread(continuation_items):
3548 continuation = self._extract_continuation({'contents': continuation_items})
3552 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3553 if message and not parent and tracker['running_total'] == 0:
3554 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3555 raise self.CommentsDisabled
3558 def _generate_comment_continuation(video_id):
3560 Generates initial comment section continuation token from given video id
3562 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3563 return base64.b64encode(token.encode()).decode()
3565 def _get_comments(self, ytcfg, video_id, contents, webpage):
3566 """Entry for comment extraction"""
3567 def _real_comment_extract(contents):
3569 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3570 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3571 yield from self._comment_entries(renderer, ytcfg, video_id)
3573 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3574 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3577 def _get_checkok_params():
3578 return {'contentCheckOk': True, 'racyCheckOk': True}
3581 def _generate_player_context(cls, sts=None):
3583 'html5Preference': 'HTML5_PREF_WANTS',
3586 context['signatureTimestamp'] = sts
3588 'playbackContext': {
3589 'contentPlaybackContext': context
3591 **cls._get_checkok_params()
3595 def _is_agegated(player_response):
3596 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3599 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3600 AGE_GATE_REASONS = (
3601 'confirm your age', 'age-restricted', 'inappropriate', # reason
3602 'age_verification_required', 'age_check_required', # status
3604 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3607 def _is_unplayable(player_response):
3608 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3610 _PLAYER_PARAMS = 'CgIQBg=='
3612 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3614 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3615 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3616 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3617 headers = self.generate_api_headers(
3618 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3621 'videoId': video_id,
3623 if smuggled_data.get('is_story') or _split_innertube_client(client)[0] == 'android':
3624 yt_query['params'] = self._PLAYER_PARAMS
3626 yt_query.update(self._generate_player_context(sts))
3627 return self._extract_response(
3628 item_id=video_id, ep='player', query=yt_query,
3629 ytcfg=player_ytcfg, headers=headers, fatal=True,
3630 default_client=client,
3631 note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
3634 def _get_requested_clients(self, url, smuggled_data):
3635 requested_clients = []
3636 default = ['ios', 'android', 'web']
3637 allowed_clients = sorted(
3638 (client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'),
3639 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3640 for client in self._configuration_arg('player_client'):
3641 if client in allowed_clients:
3642 requested_clients.append(client)
3643 elif client == 'default':
3644 requested_clients.extend(default)
3645 elif client == 'all':
3646 requested_clients.extend(allowed_clients)
3648 self.report_warning(f'Skipping unsupported client {client}')
3649 if not requested_clients:
3650 requested_clients = default
3652 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3653 requested_clients.extend(
3654 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3656 return orderedSet(requested_clients)
3658 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3661 initial_pr = self._search_json(
3662 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3664 all_clients = set(clients)
3665 clients = clients[::-1]
3668 def append_client(*client_names):
3669 """ Append the first client name that exists but not already used """
3670 for client_name in client_names:
3671 actual_client = _split_innertube_client(client_name)[0]
3672 if actual_client in INNERTUBE_CLIENTS:
3673 if actual_client not in all_clients:
3674 clients.append(client_name)
3675 all_clients.add(actual_client)
3678 # Android player_response does not have microFormats which are needed for
3679 # extraction of some data. So we return the initial_pr with formats
3680 # stripped out even if not requested by the user
3681 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3683 pr = dict(initial_pr)
3684 pr['streamingData'] = None
3688 tried_iframe_fallback = False
3691 client, base_client, variant = _split_innertube_client(clients.pop())
3692 player_ytcfg = master_ytcfg if client == 'web' else {}
3693 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3694 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3696 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3697 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3698 if 'js' in self._configuration_arg('player_skip'):
3699 require_js_player = False
3702 if not player_url and not tried_iframe_fallback and require_js_player:
3703 player_url = self._download_player_url(video_id)
3704 tried_iframe_fallback = True
3707 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3708 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3709 except ExtractorError as e:
3711 self.report_warning(last_error)
3716 # YouTube may return a different video player response than expected.
3717 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3718 pr_video_id = traverse_obj(pr, ('videoDetails', 'videoId'))
3719 if pr_video_id and pr_video_id != video_id:
3720 self.report_warning(
3721 f'Skipping player response from {client} client (got player response for video "{pr_video_id}
" instead of "{video_id}
")' + bug_reports_message())
3723 # Save client name for introspection later
3724 name = short_client_name(client)
3725 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3726 sd[STREAMING_DATA_CLIENT_NAME] = name
3727 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3728 f[STREAMING_DATA_CLIENT_NAME] = name
3731 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3732 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3733 append_client(f'{base_client}_creator')
3734 elif self._is_agegated(pr):
3735 if variant == 'tv_embedded':
3736 append_client(f'{base_client}_embedded')
3738 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3743 self.report_warning(last_error)
3744 return prs, player_url
3746 def _needs_live_processing(self, live_status, duration):
3747 if (live_status == 'is_live' and self.get_param('live_from_start')
3748 or live_status == 'post_live' and (duration or 0) > 2 * 3600):
3751 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3752 CHUNK_SIZE = 10 << 20
3753 itags, stream_ids = collections.defaultdict(set), []
3754 itag_qualities, res_qualities = {}, {0: None}
3756 # Normally tiny is the smallest video-only formats. But
3757 # audio-only formats with unknown quality may get tagged as tiny
3759 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3760 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
3762 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3763 format_types = self._configuration_arg('formats')
3764 all_formats = 'duplicate' in format_types
3765 if self._configuration_arg('include_duplicate_formats'):
3767 self._downloader.deprecated_feature('[youtube] include_duplicate_formats extractor argument is deprecated. '
3768 'Use formats=duplicate extractor argument instead')
3770 def build_fragments(f):
3772 'url': update_url_query(f['url'], {
3773 'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}'
3775 } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3777 for fmt in streaming_formats:
3778 if fmt.get('targetDurationSec'):
3781 itag = str_or_none(fmt.get('itag'))
3782 audio_track = fmt.get('audioTrack') or {}
3783 stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3785 if stream_id in stream_ids:
3788 quality = fmt.get('quality')
3789 height = int_or_none(fmt.get('height'))
3790 if quality == 'tiny' or not quality:
3791 quality = fmt.get('audioQuality', '').lower() or quality
3792 # The 3gp format (17) in android client has a quality of "small
",
3793 # but is actually worse than other formats
3798 itag_qualities[itag] = quality
3800 res_qualities[height] = quality
3801 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3802 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3803 # number of fragment that would subsequently requested with (`&sq=N`)
3804 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3807 fmt_url = fmt.get('url')
3809 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3810 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3811 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3812 if not all((sc, fmt_url, player_url, encrypted_sig)):
3815 fmt_url += '&%s=%s' % (
3816 traverse_obj(sc, ('sp', -1)) or 'signature',
3817 self._decrypt_signature(encrypted_sig, video_id, player_url)
3819 except ExtractorError as e:
3820 self.report_warning('Signature extraction failed: Some formats may be missing',
3821 video_id=video_id, only_once=True)
3822 self.write_debug(e, only_once=True)
3825 query = parse_qs(fmt_url)
3829 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3830 fmt_url = update_url_query(fmt_url, {
3831 'n': decrypt_nsig(query['n'][0], video_id, player_url)
3833 except ExtractorError as e:
3835 if isinstance(e, JSInterpreter.Exception):
3836 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3837 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3839 self.report_warning(
3840 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3841 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3842 self.write_debug(e, only_once=True)
3844 self.report_warning(
3845 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3846 video_id=video_id, only_once=True)
3849 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3850 language_preference = (
3851 10 if audio_track.get('audioIsDefault') and 10
3852 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3854 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3855 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3856 # Make sure to avoid false positives with small duration differences.
3857 # E.g. __2ABJjxzNo, ySuUZEjARPY
3858 is_damaged = try_get(fmt, lambda x: float(x['approxDurationMs']) / duration < 500)
3860 self.report_warning(
3861 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3863 client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3864 name = fmt.get('qualityLabel') or quality.replace('audio_quality_', '') or ''
3865 fps = int_or_none(fmt.get('fps')) or 0
3867 'asr': int_or_none(fmt.get('audioSampleRate')),
3868 'filesize': int_or_none(fmt.get('contentLength')),
3869 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3870 'format_note': join_nonempty(
3871 join_nonempty(audio_track.get('displayName'),
3872 language_preference > 0 and ' (default)', delim=''),
3873 name, fmt.get('isDrc') and 'DRC',
3874 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3875 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3876 throttled and 'THROTTLED', is_damaged and 'DAMAGED',
3877 (self.get_param('verbose') or all_formats) and client_name,
3879 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3880 'source_preference': ((-10 if throttled else -5 if itag == '22' else -1)
3881 + (100 if 'Premium' in name else 0)),
3882 'fps': fps if fps > 1 else None, # For some formats, fps is wrongly returned as 1
3883 'audio_channels': fmt.get('audioChannels'),
3885 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3886 'has_drm': bool(fmt.get('drmFamilies')),
3889 'width': int_or_none(fmt.get('width')),
3890 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3891 'desc' if language_preference < -1 else '') or None,
3892 'language_preference': language_preference,
3893 # Strictly de-prioritize damaged and 3gp formats
3894 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3896 mime_mobj = re.match(
3897 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3899 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3900 dct.update(parse_codecs(mime_mobj.group(2)))
3902 itags[itag].add(('https
', dct.get('language
')))
3903 stream_ids.append(stream_id)
3904 single_stream = 'none
' in (dct.get('acodec
'), dct.get('vcodec
'))
3905 if single_stream and dct.get('ext
'):
3906 dct['container
'] = dct['ext
'] + '_dash
'
3908 if (all_formats or 'dashy
' in format_types) and dct['filesize
']:
3911 'format_id
': f'{dct["format_id"]}
-dashy
' if all_formats else dct['format_id
'],
3912 'protocol
': 'http_dash_segments
',
3913 'fragments
': build_fragments(dct),
3915 if all_formats or 'dashy
' not in format_types:
3916 dct['downloader_options
'] = {'http_chunk_size': CHUNK_SIZE}
3919 needs_live_processing = self._needs_live_processing(live_status, duration)
3920 skip_bad_formats = 'incomplete
' not in format_types
3921 if self._configuration_arg('include_incomplete_formats
'):
3922 skip_bad_formats = False
3923 self._downloader.deprecated_feature('[youtube
] include_incomplete_formats extractor argument
is deprecated
. '
3924 'Use formats
=incomplete extractor argument instead
')
3926 skip_manifests = set(self._configuration_arg('skip
'))
3927 if (not self.get_param('youtube_include_hls_manifest
', True)
3928 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3929 or needs_live_processing and skip_bad_formats):
3930 skip_manifests.add('hls
')
3932 if not self.get_param('youtube_include_dash_manifest
', True):
3933 skip_manifests.add('dash
')
3934 if self._configuration_arg('include_live_dash
'):
3935 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3936 'Use formats
=incomplete extractor argument instead
')
3937 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3938 skip_manifests.add('dash
')
3940 def process_manifest_format(f, proto, client_name, itag):
3941 key = (proto, f.get('language
'))
3942 if not all_formats and key in itags[itag]:
3944 itags[itag].add(key)
3946 if itag and all_formats:
3947 f['format_id
'] = f'{itag}
-{proto}
'
3948 elif any(p != proto for p, _ in itags[itag]):
3949 f['format_id
'] = f'{itag}
-{proto}
'
3951 f['format_id
'] = itag
3953 if itag in ('616', '235'):
3954 f['format_note
'] = join_nonempty(f.get('format_note
'), 'Premium
', delim=' ')
3955 f['source_preference
'] = (f.get('source_preference
') or -1) + 100
3957 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
3958 if f['quality
'] == -1 and f.get('height
'):
3959 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
3960 if self.get_param('verbose
') or all_formats:
3961 f['format_note
'] = join_nonempty(f.get('format_note
'), client_name, delim=', ')
3962 if f.get('fps
') and f['fps
'] <= 1:
3967 for sd in streaming_data:
3968 client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
3970 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
3971 if hls_manifest_url:
3972 fmts, subs = self._extract_m3u8_formats_and_subtitles(
3973 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
3974 subtitles = self._merge_subtitles(subs, subtitles)
3976 if process_manifest_format(f, 'hls
', client_name, self._search_regex(
3977 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
3980 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
3981 if dash_manifest_url:
3982 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
3983 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
3985 if process_manifest_format(f, 'dash
', client_name, f['format_id
']):
3986 f['filesize
'] = int_or_none(self._search_regex(
3987 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
3988 if needs_live_processing:
3989 f['is_from_start
'] = True
3994 def _extract_storyboard(self, player_responses, duration):
3996 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
3997 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
4001 for i, args in enumerate(spec):
4002 args = args.split('#')
4003 counts
= list(map(int_or_none
, args
[:5]))
4004 if len(args
) != 8 or not all(counts
):
4005 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
4007 width
, height
, frame_count
, cols
, rows
= counts
4010 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
4011 fragment_count
= frame_count
/ (cols
* rows
)
4012 fragment_duration
= duration
/ fragment_count
4014 'format_id': f
'sb{i}',
4015 'format_note': 'storyboard',
4017 'protocol': 'mhtml',
4023 'fps': frame_count
/ duration
,
4027 'url': url
.replace('$M', str(j
)),
4028 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
4029 } for j
in range(math
.ceil(fragment_count
))],
4032 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
4034 if 'webpage' not in self
._configuration
_arg
('player_skip'):
4035 query
= {'bpctr': '9999999999', 'has_verified': '1'}
4036 if smuggled_data
.get('is_story'): # XXX: Deprecated
4037 query
['pp'] = self
._PLAYER
_PARAMS
4038 webpage
= self
._download
_webpage
(
4039 webpage_url
, video_id
, fatal
=False, query
=query
)
4041 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
4043 player_responses
, player_url
= self
._extract
_player
_responses
(
4044 self
._get
_requested
_clients
(url
, smuggled_data
),
4045 video_id
, webpage
, master_ytcfg
, smuggled_data
)
4047 return webpage
, master_ytcfg
, player_responses
, player_url
4049 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
4050 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
4051 is_live
= get_first(video_details
, 'isLive')
4053 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
4054 live_content
= get_first(video_details
, 'isLiveContent')
4055 is_upcoming
= get_first(video_details
, 'isUpcoming')
4056 post_live
= get_first(video_details
, 'isPostLiveDvr')
4057 live_status
= ('post_live' if post_live
4058 else 'is_live' if is_live
4059 else 'is_upcoming' if is_upcoming
4060 else 'was_live' if live_content
4061 else 'not_live' if False in (is_live
, live_content
)
4063 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'))
4064 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
4066 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
4068 def _real_extract(self
, url
):
4069 url
, smuggled_data
= unsmuggle_url(url
, {})
4070 video_id
= self
._match
_id
(url
)
4072 base_url
= self
.http_scheme() + '//www.youtube.com/'
4073 webpage_url
= base_url
+ 'watch?v=' + video_id
4075 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
4077 playability_statuses
= traverse_obj(
4078 player_responses
, (..., 'playabilityStatus'), expected_type
=dict)
4080 trailer_video_id
= get_first(
4081 playability_statuses
,
4082 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
4084 if trailer_video_id
:
4085 return self
.url_result(
4086 trailer_video_id
, self
.ie_key(), trailer_video_id
)
4088 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
4089 if webpage
else (lambda x
: None))
4091 video_details
= traverse_obj(player_responses
, (..., 'videoDetails'), expected_type
=dict)
4092 microformats
= traverse_obj(
4093 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
4096 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
4097 video_title
= (self
._preferred
_lang
and translated_title
4098 or get_first(video_details
, 'title') # primary
4100 or search_meta(['og:title', 'twitter:title', 'title']))
4101 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
4102 original_description
= get_first(video_details
, 'shortDescription')
4103 video_description
= (
4104 self
._preferred
_lang
and translated_description
4105 # If original description is blank, it will be an empty string.
4106 # Do not prefer translated description in this case.
4107 or original_description
if original_description
is not None else translated_description
)
4109 multifeed_metadata_list
= get_first(
4111 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
4113 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
4114 if self
.get_param('noplaylist'):
4115 self
.to_screen('Downloading just video %s because of --no-playlist' % video_id
)
4119 for feed
in multifeed_metadata_list
.split(','):
4120 # Unquote should take place before split on comma (,) since textual
4121 # fields may contain comma as well (see
4122 # https://github.com/ytdl-org/youtube-dl/issues/8536)
4123 feed_data
= urllib
.parse
.parse_qs(
4124 urllib
.parse
.unquote_plus(feed
))
4126 def feed_entry(name
):
4128 feed_data
, lambda x
: x
[name
][0], str)
4130 feed_id
= feed_entry('id')
4133 feed_title
= feed_entry('title')
4136 title
+= ' (%s)' % feed_title
4138 '_type': 'url_transparent',
4139 'ie_key': 'Youtube',
4141 '%swatch?v=%s' % (base_url
, feed_data
['id'][0]),
4142 {'force_singlefeed': True}
),
4145 feed_ids
.append(feed_id
)
4147 'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
4148 % (', '.join(feed_ids
), video_id
))
4149 return self
.playlist_result(
4150 entries
, video_id
, video_title
, video_description
)
4152 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
4153 or int_or_none(get_first(microformats
, 'lengthSeconds'))
4154 or parse_duration(search_meta('duration')) or None)
4156 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
4157 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
4158 if live_status
== 'post_live':
4159 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
4162 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
4163 self
.report_drm(video_id
)
4165 playability_statuses
,
4166 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
4167 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
4168 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
4170 if subreason
== 'The uploader has not made this video available in your country.':
4171 countries
= get_first(microformats
, 'availableCountries')
4173 regions_allowed
= search_meta('regionsAllowed')
4174 countries
= regions_allowed
.split(',') if regions_allowed
else None
4175 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
4176 reason
+= f
'. {subreason}'
4178 self
.raise_no_formats(reason
, expected
=True)
4180 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
4181 if not keywords
and webpage
:
4183 unescapeHTML(m
.group('content'))
4184 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
4185 for keyword
in keywords
:
4186 if keyword
.startswith('yt:stretch='):
4187 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
4189 # NB: float is intentional for forcing float division
4190 w
, h
= (float(v
) for v
in mobj
.groups())
4194 if f
.get('vcodec') != 'none':
4195 f
['stretched_ratio'] = ratio
4197 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
4198 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
4201 'url': thumbnail_url
,
4203 original_thumbnails
= thumbnails
.copy()
4205 # The best resolution thumbnails sometimes does not appear in the webpage
4206 # See: https://github.com/yt-dlp/yt-dlp/issues/340
4207 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4209 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4210 # in resolution, these are not the custom thumbnail. So de-prioritize them
4211 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4212 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3'
4214 n_thumbnail_names
= len(thumbnail_names
)
4216 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4217 video_id
=video_id
, name
=name
, ext
=ext
,
4218 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
4219 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
4220 for thumb
in thumbnails
:
4221 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
4222 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
4223 self
._remove
_duplicate
_formats
(thumbnails
)
4224 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
4226 category
= get_first(microformats
, 'category') or search_meta('genre')
4227 channel_id
= self
.ucid_or_none(str_or_none(
4228 get_first(video_details
, 'channelId')
4229 or get_first(microformats
, 'externalChannelId')
4230 or search_meta('channelId')))
4231 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
4233 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
4234 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
4235 if not duration
and live_end_time
and live_start_time
:
4236 duration
= live_end_time
- live_start_time
4238 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
4240 def is_bad_format(fmt
):
4241 if needs_live_processing
and not fmt
.get('is_from_start'):
4243 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
4244 and fmt
.get('protocol') == 'http_dash_segments'):
4247 for fmt
in filter(is_bad_format
, formats
):
4248 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4249 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 2 hours)', delim
=' ')
4251 if needs_live_processing
:
4252 self
._prepare
_live
_from
_start
_formats
(
4253 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4255 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4257 channel_handle
= self
.handle_from_url(owner_profile_url
)
4261 'title': video_title
,
4263 'thumbnails': thumbnails
,
4264 # The best thumbnail that we are sure exists. Prevents unnecessary
4265 # URL checking if user don't care about getting the best possible thumbnail
4266 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4267 'description': video_description
,
4268 'channel_id': channel_id
,
4269 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None),
4270 'duration': duration
,
4271 'view_count': int_or_none(
4272 get_first((video_details
, microformats
), (..., 'viewCount'))
4273 or search_meta('interactionCount')),
4274 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4275 'age_limit': 18 if (
4276 get_first(microformats
, 'isFamilySafe') is False
4277 or search_meta('isFamilyFriendly') == 'false'
4278 or search_meta('og:restrictions:age') == '18+') else 0,
4279 'webpage_url': webpage_url
,
4280 'categories': [category
] if category
else None,
4282 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4283 'live_status': live_status
,
4284 'release_timestamp': live_start_time
,
4285 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4286 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto')
4290 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4292 def get_lang_code(track
):
4293 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4294 or track
.get('languageCode'))
4296 # Converted into dicts to remove duplicates
4298 get_lang_code(sub
): sub
4299 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...))}
4300 translation_languages
= {
4301 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4302 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...))}
4304 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4305 lang_subs
= container
.setdefault(lang_code
, [])
4306 for fmt
in self
._SUBTITLE
_FORMATS
:
4312 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4316 # NB: Constructing the full subtitle dictionary is slow
4317 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4318 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4319 for lang_code
, caption_track
in captions
.items():
4320 base_url
= caption_track
.get('baseUrl')
4321 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4324 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4325 if caption_track
.get('kind') != 'asr':
4329 subtitles
, base_url
, lang_code
, lang_name
, {})
4330 if not caption_track
.get('isTranslatable'):
4332 for trans_code
, trans_name
in translation_languages
.items():
4335 orig_trans_code
= trans_code
4336 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4337 if not get_translated_subs
:
4339 trans_code
+= f
'-{lang_code}'
4340 trans_name
+= format_field(lang_name
, None, ' from %s')
4341 if lang_code
== f
'a-{orig_trans_code}':
4342 # Set audio language based on original subtitles
4344 if f
.get('acodec') != 'none' and not f
.get('language'):
4345 f
['language'] = orig_trans_code
4346 # Add an "-orig" label to the original language so that it can be distinguished.
4347 # The subs are returned without "-orig" as well for compatibility
4349 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4350 # Setting tlang=lang returns damaged subtitles.
4351 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4352 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4354 info
['automatic_captions'] = automatic_captions
4355 info
['subtitles'] = subtitles
4357 parsed_url
= urllib
.parse
.urlparse(url
)
4358 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4359 query
= urllib
.parse
.parse_qs(component
)
4360 for k
, v
in query
.items():
4361 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4363 if d_k
not in info
and k
in s_ks
:
4364 info
[d_k
] = parse_duration(query
[k
][0])
4366 # Youtube Music Auto-generated description
4367 if (video_description
or '').strip().endswith('\nAuto-generated by YouTube.'):
4368 # XXX: Causes catastrophic backtracking if description has "·"
4369 # E.g. https://www.youtube.com/watch?v=DoPaAxMQoiI
4370 # Simulating atomic groups: (?P<a>[^xy]+)x => (?=(?P<a>[^xy]+))(?P=a)x
4371 # reduces it, but does not fully fix it. https://regex101.com/r/8Ssf2h/2
4374 (?=(?P<track>[^\n·]+))(?P=track)·
4375 (?=(?P<artist>[^\n]+))(?P=artist)\n+
4376 (?=(?P<album>[^\n]+))(?P=album)\n
4377 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4378 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4380 (?=(?P<clean_artist>[^\n]+))(?P=clean_artist)\n
4381 )?.+\nAuto-generated\ by\ YouTube\.\s*$
4382 ''', video_description
)
4384 release_year
= mobj
.group('release_year')
4385 release_date
= mobj
.group('release_date')
4387 release_date
= release_date
.replace('-', '')
4388 if not release_year
:
4389 release_year
= release_date
[:4]
4391 'album': mobj
.group('album'.strip()),
4392 'artist': mobj
.group('clean_artist') or ', '.join(a
.strip() for a
in mobj
.group('artist').split('·')),
4393 'track': mobj
.group('track').strip(),
4394 'release_date': release_date
,
4395 'release_year': int_or_none(release_year
),
4400 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4401 if not traverse_obj(initial_data
, 'contents'):
4402 self
.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4404 if not initial_data
:
4405 query
= {'videoId': video_id}
4406 query
.update(self
._get
_checkok
_params
())
4407 initial_data
= self
._extract
_response
(
4408 item_id
=video_id
, ep
='next', fatal
=False,
4409 ytcfg
=master_ytcfg
, query
=query
, check_get_keys
='contents',
4410 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4411 note
='Downloading initial data API JSON')
4413 info
['comment_count'] = traverse_obj(initial_data
, (
4414 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4415 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount'
4417 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4418 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo'
4419 ), expected_type
=self
._get
_count
, get_all
=False)
4421 try: # This will error if there is no livechat
4422 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4423 except (KeyError, IndexError, TypeError):
4426 info
.setdefault('subtitles', {})['live_chat'] = [{
4427 # url is needed to set cookies
4428 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4429 'video_id': video_id
,
4431 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4432 else 'youtube_live_chat_replay'),
4436 info
['chapters'] = (
4437 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4438 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4439 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4442 info
['heatmap'] = self
._extract
_heatmap
_from
_player
_overlay
(initial_data
)
4444 contents
= traverse_obj(
4445 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4446 expected_type
=list, default
=[])
4448 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4450 stl
= vpir
.get('superTitleLink')
4452 stl
= self
._get
_text
(stl
)
4455 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4456 info
['location'] = stl
4458 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4461 'series': mobj
.group(1),
4462 'season_number': int(mobj
.group(2)),
4463 'episode_number': int(mobj
.group(3)),
4465 for tlb
in (try_get(
4467 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4471 tlb
, ('toggleButtonRenderer', ...),
4472 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4474 for getter
, regex
in [(
4475 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4476 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4477 lambda x
: x
['accessibility'],
4478 lambda x
: x
['accessibilityData']['accessibilityData'],
4479 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4480 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4482 mobj
= re
.match(regex
, label
)
4484 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4486 sbr_tooltip
= try_get(
4487 vpir
, lambda x
: x
['sentimentBar']['sentimentBarRenderer']['tooltip'])
4489 like_count
, dislike_count
= sbr_tooltip
.split(' / ')
4491 'like_count': str_to_int(like_count
),
4492 'dislike_count': str_to_int(dislike_count
),
4494 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4496 vc
= self
._get
_count
(vcr
, 'viewCount')
4497 # Upcoming premieres with waiting count are treated as live here
4498 if vcr
.get('isLive'):
4499 info
['concurrent_view_count'] = vc
4500 elif info
.get('view_count') is None:
4501 info
['view_count'] = vc
4503 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4505 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4507 'channel': self
._get
_text
(vor
, 'title'),
4508 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4510 if not channel_handle
:
4511 channel_handle
= self
.handle_from_url(
4513 ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4514 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4515 {str}
), get_all
=False))
4519 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4521 multiple_songs
= False
4523 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4524 multiple_songs
= True
4527 mrr
= row
.get('metadataRowRenderer') or {}
4528 mrr_title
= mrr
.get('title')
4531 mrr_title
= self
._get
_text
(mrr
, 'title')
4532 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4533 if mrr_title
== 'License':
4534 info
['license'] = mrr_contents_text
4535 elif not multiple_songs
:
4536 if mrr_title
== 'Album':
4537 info
['album'] = mrr_contents_text
4538 elif mrr_title
== 'Artist':
4539 info
['artist'] = mrr_contents_text
4540 elif mrr_title
== 'Song':
4541 info
['track'] = mrr_contents_text
4542 owner_badges
= self
._extract
_badges
(traverse_obj(vsir
, ('owner', 'videoOwnerRenderer', 'badges')))
4543 if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
):
4544 info
['channel_is_verified'] = True
4547 'uploader': info
.get('channel'),
4548 'uploader_id': channel_handle
,
4549 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4551 # The upload date for scheduled, live and past live streams / premieres in microformats
4552 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4553 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4555 unified_strdate(get_first(microformats
, 'uploadDate'))
4556 or unified_strdate(search_meta('uploadDate')))
4557 if not upload_date
or (
4558 live_status
in ('not_live', None)
4559 and 'no-youtube-prefer-utc-upload-date' not in self
.get_param('compat_opts', [])
4561 upload_date
= strftime_or_none(
4562 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText'))) or upload_date
4563 info
['upload_date'] = upload_date
4565 for s_k
, d_k
in [('artist', 'creator'), ('track', 'alt_title')]:
4570 badges
= self
._extract
_badges
(traverse_obj(vpir
, 'badges'))
4572 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4573 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4575 info
['availability'] = (
4576 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4577 else self
._availability
(
4578 is_private
=is_private
,
4580 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4581 or False if initial_data
and is_private
is not None else None),
4582 needs_subscription
=(
4583 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4584 or False if initial_data
and is_private
is not None else None),
4585 needs_auth
=info
['age_limit'] >= 18,
4586 is_unlisted
=None if is_private
is None else (
4587 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4588 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4590 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4592 self
.mark_watched(video_id
, player_responses
)
4597 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4599 def passthrough_smuggled_data(func
):
4600 def _smuggle(info
, smuggled_data
):
4601 if info
.get('_type') not in ('url', 'url_transparent'):
4603 if smuggled_data
.get('is_music_url'):
4604 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4605 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4606 smuggled_data
.pop('is_music_url')
4607 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4609 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4612 @functools.wraps(func
)
4613 def wrapper(self
, url
):
4614 url
, smuggled_data
= unsmuggle_url(url
, {})
4615 if self
.is_music_url(url
):
4616 smuggled_data
['is_music_url'] = True
4617 info_dict
= func(self
, url
, smuggled_data
)
4619 _smuggle(info_dict
, smuggled_data
)
4620 if info_dict
.get('entries'):
4621 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4626 def _extract_basic_item_renderer(item
):
4627 # Modified from _extract_grid_item_renderer
4628 known_basic_renderers
= (
4629 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer'
4631 for key
, renderer
in item
.items():
4632 if not isinstance(renderer
, dict):
4634 elif key
in known_basic_renderers
:
4636 elif key
.startswith('grid') and key
.endswith('Renderer'):
4639 def _extract_channel_renderer(self
, renderer
):
4640 channel_id
= self
.ucid_or_none(renderer
['channelId'])
4641 title
= self
._get
_text
(renderer
, 'title')
4642 channel_url
= format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None)
4643 channel_handle
= self
.handle_from_url(
4644 traverse_obj(renderer
, (
4645 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4646 ('browseEndpoint', 'canonicalBaseUrl')),
4647 {str}
), get_all
=False))
4648 if not channel_handle
:
4649 # As of 2023-06-01, YouTube sets subscriberCountText to the handle in search
4650 channel_handle
= self
.handle_or_none(self
._get
_text
(renderer
, 'subscriberCountText'))
4655 'ie_key': YoutubeTabIE
.ie_key(),
4658 'channel_id': channel_id
,
4659 'channel_url': channel_url
,
4661 'uploader_id': channel_handle
,
4662 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4663 # See above. YouTube sets videoCountText to the subscriber text in search channel renderers.
4664 # However, in feed/channels this is set correctly to the subscriber count
4665 'channel_follower_count': traverse_obj(
4666 renderer
, 'subscriberCountText', 'videoCountText', expected_type
=self
._get
_count
),
4667 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
4669 # videoCountText may be the subscriber count
4670 self
._get
_count
(renderer
, 'videoCountText')
4671 if self
._get
_count
(renderer
, 'subscriberCountText') is not None else None),
4672 'description': self
._get
_text
(renderer
, 'descriptionSnippet'),
4673 'channel_is_verified': True if self
._has
_badge
(
4674 self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges')), BadgeType
.VERIFIED
) else None,
4677 def _grid_entries(self
, grid_renderer
):
4678 for item
in grid_renderer
['items']:
4679 if not isinstance(item
, dict):
4681 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4682 if not isinstance(renderer
, dict):
4684 title
= self
._get
_text
(renderer
, 'title')
4687 playlist_id
= renderer
.get('playlistId')
4689 yield self
.url_result(
4690 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4691 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4695 video_id
= renderer
.get('videoId')
4697 yield self
._extract
_video
(renderer
)
4700 channel_id
= renderer
.get('channelId')
4702 yield self
._extract
_channel
_renderer
(renderer
)
4704 # generic endpoint URL support
4705 ep_url
= urljoin('https://www.youtube.com/', try_get(
4706 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4709 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4710 if ie
.suitable(ep_url
):
4711 yield self
.url_result(
4712 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4715 def _music_reponsive_list_entry(self
, renderer
):
4716 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4718 title
= traverse_obj(renderer
, (
4719 'flexColumns', 0, 'musicResponsiveListItemFlexColumnRenderer',
4720 'text', 'runs', 0, 'text'))
4721 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4722 ie
=YoutubeIE
.ie_key(), video_id
=video_id
, title
=title
)
4723 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4725 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4727 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4728 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4729 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4730 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4731 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4733 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4734 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4736 def _shelf_entries_from_content(self
, shelf_renderer
):
4737 content
= shelf_renderer
.get('content')
4738 if not isinstance(content
, dict):
4740 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4742 # TODO: add support for nested playlists so each shelf is processed
4743 # as separate playlist
4744 # TODO: this includes only first N items
4745 yield from self
._grid
_entries
(renderer
)
4746 renderer
= content
.get('horizontalListRenderer')
4751 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4753 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4755 shelf_url
= urljoin('https://www.youtube.com', ep
)
4757 # Skipping links to another channels, note that checking for
4758 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4760 if skip_channels
and '/channels?' in shelf_url
:
4762 title
= self
._get
_text
(shelf_renderer
, 'title')
4763 yield self
.url_result(shelf_url
, video_title
=title
)
4764 # Shelf may not contain shelf URL, fallback to extraction from content
4765 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4767 def _playlist_entries(self
, video_list_renderer
):
4768 for content
in video_list_renderer
['contents']:
4769 if not isinstance(content
, dict):
4771 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4772 if not isinstance(renderer
, dict):
4774 video_id
= renderer
.get('videoId')
4777 yield self
._extract
_video
(renderer
)
4779 def _rich_entries(self
, rich_grid_renderer
):
4780 renderer
= traverse_obj(
4782 ('content', ('videoRenderer', 'reelItemRenderer', 'playlistRenderer')), get_all
=False) or {}
4783 video_id
= renderer
.get('videoId')
4785 yield self
._extract
_video
(renderer
)
4787 playlist_id
= renderer
.get('playlistId')
4789 yield self
.url_result(
4790 f
'https://www.youtube.com/playlist?list={playlist_id}',
4791 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4792 video_title
=self
._get
_text
(renderer
, 'title'))
4795 def _video_entry(self
, video_renderer
):
4796 video_id
= video_renderer
.get('videoId')
4798 return self
._extract
_video
(video_renderer
)
4800 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4801 url
= urljoin('https://youtube.com', traverse_obj(
4802 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4804 return self
.url_result(
4805 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4807 def _post_thread_entries(self
, post_thread_renderer
):
4808 post_renderer
= try_get(
4809 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4810 if not post_renderer
:
4813 video_renderer
= try_get(
4814 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4815 video_id
= video_renderer
.get('videoId')
4817 entry
= self
._extract
_video
(video_renderer
)
4820 # playlist attachment
4821 playlist_id
= try_get(
4822 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4824 yield self
.url_result(
4825 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4826 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4827 # inline video links
4828 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4830 if not isinstance(run
, dict):
4833 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4836 if not YoutubeIE
.suitable(ep_url
):
4838 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4839 if video_id
== ep_video_id
:
4841 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4843 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4844 contents
= post_thread_continuation
.get('contents')
4845 if not isinstance(contents
, list):
4847 for content
in contents
:
4848 renderer
= content
.get('backstagePostThreadRenderer')
4849 if isinstance(renderer
, dict):
4850 yield from self
._post
_thread
_entries
(renderer
)
4852 renderer
= content
.get('videoRenderer')
4853 if isinstance(renderer
, dict):
4854 yield self
._video
_entry
(renderer
)
4857 def _rich_grid_entries(self, contents):
4858 for content in contents:
4859 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4861 entry = self._video_entry(video_renderer)
4866 def _report_history_entries(self
, renderer
):
4867 for url
in traverse_obj(renderer
, (
4868 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4869 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4870 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4871 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4873 def _extract_entries(self
, parent_renderer
, continuation_list
):
4874 # continuation_list is modified in-place with continuation_list = [continuation_token]
4875 continuation_list
[:] = [None]
4876 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4877 for content
in contents
:
4878 if not isinstance(content
, dict):
4880 is_renderer
= traverse_obj(
4881 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4884 if content
.get('richItemRenderer'):
4885 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4887 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4888 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4889 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4890 yield from self
._report
_history
_entries
(table
)
4891 continuation_list
[0] = self
._extract
_continuation
(table
)
4894 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4895 for isr_content
in isr_contents
:
4896 if not isinstance(isr_content
, dict):
4900 'playlistVideoListRenderer': self
._playlist
_entries
,
4901 'gridRenderer': self
._grid
_entries
,
4902 'reelShelfRenderer': self
._grid
_entries
,
4903 'shelfRenderer': self
._shelf
_entries
,
4904 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4905 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4906 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4907 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4908 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4909 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)],
4910 'richGridRenderer': lambda x
: self
._extract
_entries
(x
, continuation_list
),
4912 for key
, renderer
in isr_content
.items():
4913 if key
not in known_renderers
:
4915 for entry
in known_renderers
[key
](renderer
):
4918 continuation_list
[0] = self
._extract
_continuation
(renderer
)
4921 if not continuation_list
[0]:
4922 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
4924 if not continuation_list
[0]:
4925 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4927 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
4928 continuation_list
= [None]
4929 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
4930 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
4934 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
4935 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
4936 yield from extract_entries(parent_renderer
)
4937 continuation
= continuation_list
[0]
4939 for page_num
in itertools
.count(1):
4940 if not continuation
:
4942 headers
= self
.generate_api_headers(
4943 ytcfg
=ytcfg
, account_syncid
=account_syncid
, visitor_data
=visitor_data
)
4944 response
= self
._extract
_response
(
4945 item_id
=f
'{item_id} page {page_num}',
4946 query
=continuation
, headers
=headers
, ytcfg
=ytcfg
,
4947 check_get_keys
=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4951 # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
4952 # See: https://github.com/ytdl-org/youtube-dl/issues/28702
4953 visitor_data
= self
._extract
_visitor
_data
(response
) or visitor_data
4956 'videoRenderer': (self
._grid
_entries
, 'items'), # for membership tab
4957 'gridPlaylistRenderer': (self
._grid
_entries
, 'items'),
4958 'gridVideoRenderer': (self
._grid
_entries
, 'items'),
4959 'gridChannelRenderer': (self
._grid
_entries
, 'items'),
4960 'playlistVideoRenderer': (self
._playlist
_entries
, 'contents'),
4961 'itemSectionRenderer': (extract_entries
, 'contents'), # for feeds
4962 'richItemRenderer': (extract_entries
, 'contents'), # for hashtag
4963 'backstagePostThreadRenderer': (self
._post
_thread
_continuation
_entries
, 'contents'),
4964 'reportHistoryTableRowRenderer': (self
._report
_history
_entries
, 'rows'),
4965 'playlistVideoListContinuation': (self
._playlist
_entries
, None),
4966 'gridContinuation': (self
._grid
_entries
, None),
4967 'itemSectionContinuation': (self
._post
_thread
_continuation
_entries
, None),
4968 'sectionListContinuation': (extract_entries
, None), # for feeds
4971 continuation_items
= traverse_obj(response
, (
4972 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
4973 'appendContinuationItemsAction', 'continuationItems'
4974 ), 'continuationContents', get_all
=False)
4975 continuation_item
= traverse_obj(continuation_items
, 0, None, expected_type
=dict, default
={})
4977 video_items_renderer
= None
4978 for key
in continuation_item
.keys():
4979 if key
not in known_renderers
:
4981 func
, parent_key
= known_renderers
[key
]
4982 video_items_renderer
= {parent_key: continuation_items}
if parent_key
else continuation_items
4983 continuation_list
= [None]
4984 yield from func(video_items_renderer
)
4985 continuation
= continuation_list
[0] or self
._extract
_continuation
(video_items_renderer
)
4987 if not video_items_renderer
:
4991 def _extract_selected_tab(tabs
, fatal
=True):
4992 for tab_renderer
in tabs
:
4993 if tab_renderer
.get('selected'):
4996 raise ExtractorError('Unable to find selected tab')
4999 def _extract_tab_renderers(response
):
5000 return traverse_obj(
5001 response
, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type
=dict)
5003 def _extract_from_tabs(self
, item_id
, ytcfg
, data
, tabs
):
5004 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
5006 selected_tab
= self
._extract
_selected
_tab
(tabs
)
5007 metadata
['title'] += format_field(selected_tab
, 'title', ' - %s')
5008 metadata
['title'] += format_field(selected_tab
, 'expandedText', ' - %s')
5010 return self
.playlist_result(
5012 selected_tab
, metadata
['id'], ytcfg
,
5013 self
._extract
_account
_syncid
(ytcfg
, data
),
5014 self
._extract
_visitor
_data
(data
, ytcfg
)),
5017 def _extract_metadata_from_tabs(self
, item_id
, data
):
5018 info
= {'id': item_id}
5020 metadata_renderer
= traverse_obj(data
, ('metadata', 'channelMetadataRenderer'), expected_type
=dict)
5021 if metadata_renderer
:
5022 channel_id
= traverse_obj(metadata_renderer
, ('externalId', {self.ucid_or_none}
),
5023 ('channelUrl', {self.ucid_from_url}
))
5025 'channel': metadata_renderer
.get('title'),
5026 'channel_id': channel_id
,
5028 if info
['channel_id']:
5029 info
['id'] = info
['channel_id']
5031 metadata_renderer
= traverse_obj(data
, ('metadata', 'playlistMetadataRenderer'), expected_type
=dict)
5033 # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
5034 # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
5035 def _get_uncropped(url
):
5036 return url_or_none((url
or '').split('=')[0] + '=s0')
5038 avatar_thumbnails
= self
._extract
_thumbnails
(metadata_renderer
, 'avatar')
5039 if avatar_thumbnails
:
5040 uncropped_avatar
= _get_uncropped(avatar_thumbnails
[0]['url'])
5041 if uncropped_avatar
:
5042 avatar_thumbnails
.append({
5043 'url': uncropped_avatar
,
5044 'id': 'avatar_uncropped',
5048 channel_banners
= self
._extract
_thumbnails
(
5049 data
, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
5050 for banner
in channel_banners
:
5051 banner
['preference'] = -10
5054 uncropped_banner
= _get_uncropped(channel_banners
[0]['url'])
5055 if uncropped_banner
:
5056 channel_banners
.append({
5057 'url': uncropped_banner
,
5058 'id': 'banner_uncropped',
5062 # Deprecated - remove primary_sidebar_renderer when layout discontinued
5063 primary_sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer')
5064 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer'), expected_type
=dict)
5066 primary_thumbnails
= self
._extract
_thumbnails
(
5067 primary_sidebar_renderer
, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
5068 playlist_thumbnails
= self
._extract
_thumbnails
(
5069 playlist_header_renderer
, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
5072 'title': (traverse_obj(metadata_renderer
, 'title')
5073 or self
._get
_text
(data
, ('header', 'hashtagHeaderRenderer', 'hashtag'))
5075 'availability': self
._extract
_availability
(data
),
5076 'channel_follower_count': self
._get
_count
(data
, ('header', ..., 'subscriberCountText')),
5077 'description': try_get(metadata_renderer
, lambda x
: x
.get('description', '')),
5078 'tags': try_get(metadata_renderer
or {}, lambda x
: x
.get('keywords', '').split()),
5079 'thumbnails': (primary_thumbnails
or playlist_thumbnails
) + avatar_thumbnails
+ channel_banners
,
5083 traverse_obj(metadata_renderer
, (('vanityChannelUrl', ('ownerUrls', ...)), {self.handle_from_url}
), get_all
=False)
5084 or traverse_obj(data
, ('header', ..., 'channelHandleText', {self.handle_or_none}
), get_all
=False))
5088 'uploader_id': channel_handle
,
5089 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
5092 channel_badges
= self
._extract
_badges
(traverse_obj(data
, ('header', ..., 'badges'), get_all
=False))
5093 if self
._has
_badge
(channel_badges
, BadgeType
.VERIFIED
):
5094 info
['channel_is_verified'] = True
5095 # Playlist stats is a text runs array containing [video count, view count, last updated].
5096 # last updated or (view count and last updated) may be missing.
5097 playlist_stats
= get_first(
5098 (primary_sidebar_renderer
, playlist_header_renderer
), (('stats', 'briefStats', 'numVideosText'), ))
5100 last_updated_unix
= self
._parse
_time
_text
(
5101 self
._get
_text
(playlist_stats
, 2) # deprecated, remove when old layout discontinued
5102 or self
._get
_text
(playlist_header_renderer
, ('byline', 1, 'playlistBylineRenderer', 'text')))
5103 info
['modified_date'] = strftime_or_none(last_updated_unix
)
5105 info
['view_count'] = self
._get
_count
(playlist_stats
, 1)
5106 if info
['view_count'] is None: # 0 is allowed
5107 info
['view_count'] = self
._get
_count
(playlist_header_renderer
, 'viewCountText')
5108 if info
['view_count'] is None:
5109 info
['view_count'] = self
._get
_count
(data
, (
5110 'contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., 'tabRenderer', 'content', 'sectionListRenderer',
5111 'contents', ..., 'itemSectionRenderer', 'contents', ..., 'channelAboutFullMetadataRenderer', 'viewCountText'))
5113 info
['playlist_count'] = self
._get
_count
(playlist_stats
, 0)
5114 if info
['playlist_count'] is None: # 0 is allowed
5115 info
['playlist_count'] = self
._get
_count
(playlist_header_renderer
, ('byline', 0, 'playlistBylineRenderer', 'text'))
5117 if not info
.get('channel_id'):
5118 owner
= traverse_obj(playlist_header_renderer
, 'ownerText')
5119 if not owner
: # Deprecated
5120 owner
= traverse_obj(
5121 self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarSecondaryInfoRenderer'),
5122 ('videoOwner', 'videoOwnerRenderer', 'title'))
5123 owner_text
= self
._get
_text
(owner
)
5124 browse_ep
= traverse_obj(owner
, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
5126 'channel': self
._search
_regex
(r
'^by (.+) and \d+ others?$', owner_text
, 'uploader', default
=owner_text
),
5127 'channel_id': self
.ucid_or_none(browse_ep
.get('browseId')),
5128 'uploader_id': self
.handle_from_url(urljoin('https://www.youtube.com', browse_ep
.get('canonicalBaseUrl')))
5132 'uploader': info
['channel'],
5133 'channel_url': format_field(info
.get('channel_id'), None, 'https://www.youtube.com/channel/%s', default
=None),
5134 'uploader_url': format_field(info
.get('uploader_id'), None, 'https://www.youtube.com/%s', default
=None),
5139 def _extract_inline_playlist(self
, playlist
, playlist_id
, data
, ytcfg
):
5140 first_id
= last_id
= response
= None
5141 for page_num
in itertools
.count(1):
5142 videos
= list(self
._playlist
_entries
(playlist
))
5145 start
= next((i
for i
, v
in enumerate(videos
) if v
['id'] == last_id
), -1) + 1
5146 if start
>= len(videos
):
5148 yield from videos
[start
:]
5149 first_id
= first_id
or videos
[0]['id']
5150 last_id
= videos
[-1]['id']
5151 watch_endpoint
= try_get(
5152 playlist
, lambda x
: x
['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
5153 headers
= self
.generate_api_headers(
5154 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5155 visitor_data
=self
._extract
_visitor
_data
(response
, data
, ytcfg
))
5157 'playlistId': playlist_id
,
5158 'videoId': watch_endpoint
.get('videoId') or last_id
,
5159 'index': watch_endpoint
.get('index') or len(videos
),
5160 'params': watch_endpoint
.get('params') or 'OAE%3D'
5162 response
= self
._extract
_response
(
5163 item_id
='%s page %d' % (playlist_id
, page_num
),
5164 query
=query
, ep
='next', headers
=headers
, ytcfg
=ytcfg
,
5165 check_get_keys
='contents'
5168 response
, lambda x
: x
['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
5170 def _extract_from_playlist(self
, item_id
, url
, data
, playlist
, ytcfg
):
5171 title
= playlist
.get('title') or try_get(
5172 data
, lambda x
: x
['titleText']['simpleText'], str)
5173 playlist_id
= playlist
.get('playlistId') or item_id
5175 # Delegating everything except mix playlists to regular tab-based playlist URL
5176 playlist_url
= urljoin(url
, try_get(
5177 playlist
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
5180 # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
5181 # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
5182 is_known_unviewable
= re
.fullmatch(r
'MLCT|RLTD[\w-]{22}', playlist_id
)
5184 if playlist_url
and playlist_url
!= url
and not is_known_unviewable
:
5185 return self
.url_result(
5186 playlist_url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
5189 return self
.playlist_result(
5190 self
._extract
_inline
_playlist
(playlist
, playlist_id
, data
, ytcfg
),
5191 playlist_id
=playlist_id
, playlist_title
=title
)
5193 def _extract_availability(self
, data
):
5195 Gets the availability of a given playlist/tab.
5196 Note: Unless YouTube tells us explicitly, we do not assume it is public
5197 @param data: response
5199 sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer') or {}
5200 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer')) or {}
5201 player_header_privacy
= playlist_header_renderer
.get('privacy')
5203 badges
= self
._extract
_badges
(traverse_obj(sidebar_renderer
, 'badges'))
5205 # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
5206 privacy_setting_icon
= get_first(
5207 (playlist_header_renderer
, sidebar_renderer
),
5208 ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
5209 lambda _
, v
: v
['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
5212 microformats_is_unlisted
= traverse_obj(
5213 data
, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type
=bool)
5217 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
5218 or player_header_privacy
== 'PUBLIC'
5219 or privacy_setting_icon
== 'PRIVACY_PUBLIC')
5220 else self
._availability
(
5222 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
5223 or player_header_privacy
== 'PRIVATE' if player_header_privacy
is not None
5224 else privacy_setting_icon
== 'PRIVACY_PRIVATE' if privacy_setting_icon
is not None else None),
5226 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
5227 or player_header_privacy
== 'UNLISTED' if player_header_privacy
is not None
5228 else privacy_setting_icon
== 'PRIVACY_UNLISTED' if privacy_setting_icon
is not None
5229 else microformats_is_unlisted
if microformats_is_unlisted
is not None else None),
5230 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
5231 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
5235 def _extract_sidebar_info_renderer(data
, info_renderer
, expected_type
=dict):
5236 sidebar_renderer
= try_get(
5237 data
, lambda x
: x
['sidebar']['playlistSidebarRenderer']['items'], list) or []
5238 for item
in sidebar_renderer
:
5239 renderer
= try_get(item
, lambda x
: x
[info_renderer
], expected_type
)
5243 def _reload_with_unavailable_videos(self
, item_id
, data
, ytcfg
):
5245 Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
5247 is_playlist
= bool(traverse_obj(
5248 data
, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
5251 headers
= self
.generate_api_headers(
5252 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5253 visitor_data
=self
._extract
_visitor
_data
(data
, ytcfg
))
5255 'params': 'wgYCCAA=',
5256 'browseId': f
'VL{item_id}'
5258 return self
._extract
_response
(
5259 item_id
=item_id
, headers
=headers
, query
=query
,
5260 check_get_keys
='contents', fatal
=False, ytcfg
=ytcfg
,
5261 note
='Redownloading playlist API JSON with unavailable videos')
5263 @functools.cached_property
5264 def skip_webpage(self
):
5265 return 'webpage' in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key())
5267 def _extract_webpage(self
, url
, item_id
, fatal
=True):
5268 webpage
, data
= None, None
5269 for retry
in self
.RetryManager(fatal
=fatal
):
5271 webpage
= self
._download
_webpage
(url
, item_id
, note
='Downloading webpage')
5272 data
= self
.extract_yt_initial_data(item_id
, webpage
or '', fatal
=fatal
) or {}
5273 except ExtractorError
as e
:
5274 if isinstance(e
.cause
, network_exceptions
):
5275 if not isinstance(e
.cause
, urllib
.error
.HTTPError
) or e
.cause
.code
not in (403, 429):
5278 self
._error
_or
_warning
(e
, fatal
=fatal
)
5282 self
._extract
_and
_report
_alerts
(data
)
5283 except ExtractorError
as e
:
5284 self
._error
_or
_warning
(e
, fatal
=fatal
)
5287 # Sometimes youtube returns a webpage with incomplete ytInitialData
5288 # See: https://github.com/yt-dlp/yt-dlp/issues/116
5289 if not traverse_obj(data
, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
5290 retry
.error
= ExtractorError('Incomplete yt initial data received')
5293 return webpage
, data
5295 def _report_playlist_authcheck(self
, ytcfg
, fatal
=True):
5296 """Use if failed to extract ytcfg (and data) from initial webpage"""
5297 if not ytcfg
and self
.is_authenticated
:
5298 msg
= 'Playlists that require authentication may not extract correctly without a successful webpage download'
5299 if 'authcheck' not in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key()) and fatal
:
5300 raise ExtractorError(
5301 f
'{msg}. If you are not downloading private content, or '
5302 'your cookies are only for the first account and channel,'
5303 ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
5305 self
.report_warning(msg
, only_once
=True)
5307 def _extract_data(self
, url
, item_id
, ytcfg
=None, fatal
=True, webpage_fatal
=False, default_client
='web'):
5309 if not self
.skip_webpage
:
5310 webpage
, data
= self
._extract
_webpage
(url
, item_id
, fatal
=webpage_fatal
)
5311 ytcfg
= ytcfg
or self
.extract_ytcfg(item_id
, webpage
)
5312 # Reject webpage data if redirected to home page without explicitly requesting
5313 selected_tab
= self
._extract
_selected
_tab
(self
._extract
_tab
_renderers
(data
), fatal
=False) or {}
5314 if (url
!= 'https://www.youtube.com/feed/recommended'
5315 and selected_tab
.get('tabIdentifier') == 'FEwhat_to_watch' # Home page
5316 and 'no-youtube-channel-redirect' not in self
.get_param('compat_opts', [])):
5317 msg
= 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
5319 raise ExtractorError(msg
, expected
=True)
5320 self
.report_warning(msg
, only_once
=True)
5322 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=fatal
)
5323 data
= self
._extract
_tab
_endpoint
(url
, item_id
, ytcfg
, fatal
=fatal
, default_client
=default_client
)
5326 def _extract_tab_endpoint(self
, url
, item_id
, ytcfg
=None, fatal
=True, default_client
='web'):
5327 headers
= self
.generate_api_headers(ytcfg
=ytcfg
, default_client
=default_client
)
5328 resolve_response
= self
._extract
_response
(
5329 item_id
=item_id
, query
={'url': url}
, check_get_keys
='endpoint', headers
=headers
, ytcfg
=ytcfg
, fatal
=fatal
,
5330 ep
='navigation/resolve_url', note
='Downloading API parameters API JSON', default_client
=default_client
)
5331 endpoints
= {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5332 for ep_key
, ep
in endpoints
.items():
5333 params
= try_get(resolve_response
, lambda x
: x
['endpoint'][ep_key
], dict)
5335 return self
._extract
_response
(
5336 item_id
=item_id
, query
=params
, ep
=ep
, headers
=headers
,
5337 ytcfg
=ytcfg
, fatal
=fatal
, default_client
=default_client
,
5338 check_get_keys
=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5339 err_note
= 'Failed to resolve url (does the playlist exist?)'
5341 raise ExtractorError(err_note
, expected
=True)
5342 self
.report_warning(err_note
, item_id
)
5344 _SEARCH_PARAMS
= None
5346 def _search_results(self
, query
, params
=NO_DEFAULT
, default_client
='web'):
5347 data
= {'query': query}
5348 if params
is NO_DEFAULT
:
5349 params
= self
._SEARCH
_PARAMS
5351 data
['params'] = params
5354 ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5355 ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5357 ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5358 ('continuationContents', ),
5360 display_id
= f
'query "{query}"'
5361 check_get_keys
= tuple({keys[0] for keys in content_keys}
)
5362 ytcfg
= self
._download
_ytcfg
(default_client
, display_id
) if not self
.skip_webpage
else {}
5363 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=False)
5365 continuation_list
= [None]
5367 for page_num
in itertools
.count(1):
5368 data
.update(continuation_list
[0] or {})
5369 headers
= self
.generate_api_headers(
5370 ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(search
), default_client
=default_client
)
5371 search
= self
._extract
_response
(
5372 item_id
=f
'{display_id} page {page_num}', ep
='search', query
=data
,
5373 default_client
=default_client
, check_get_keys
=check_get_keys
, ytcfg
=ytcfg
, headers
=headers
)
5374 slr_contents
= traverse_obj(search
, *content_keys
)
5375 yield from self
._extract
_entries
({'contents': list(variadic(slr_contents))}
, continuation_list
)
5376 if not continuation_list
[0]:
5380 class YoutubeTabIE(YoutubeTabBaseInfoExtractor
):
5381 IE_DESC
= 'YouTube Tabs'
5382 _VALID_URL
= r
'''(?x:
5384 (?!consent\.)(?:\w+\.)?
5386 youtube(?:kids)?\.com|
5390 (?P<channel_type>channel|c|user|browse)/|
5393 (?:playlist|watch)\?.*?\blist=
5395 (?!(?:%(reserved_names)s)\b) # Direct URLs
5399 'reserved_names': YoutubeBaseInfoExtractor
._RESERVED
_NAMES
,
5400 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
5402 IE_NAME
= 'youtube:tab'
5405 'note': 'playlists, multipage',
5406 'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5407 'playlist_mincount': 94,
5409 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5410 'title': 'Igor Kleiner - Playlists',
5411 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5412 'uploader': 'Igor Kleiner',
5413 'uploader_id': '@IgorDataScience',
5414 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5415 'channel': 'Igor Kleiner',
5416 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5417 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5418 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5419 'channel_follower_count': int
5422 'note': 'playlists, multipage, different order',
5423 'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5424 'playlist_mincount': 94,
5426 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5427 'title': 'Igor Kleiner - Playlists',
5428 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5429 'uploader': 'Igor Kleiner',
5430 'uploader_id': '@IgorDataScience',
5431 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5432 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5433 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5434 'channel': 'Igor Kleiner',
5435 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5436 'channel_follower_count': int
5439 'note': 'playlists, series',
5440 'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5441 'playlist_mincount': 5,
5443 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5444 'title': '3Blue1Brown - Playlists',
5445 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5446 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5447 'channel': '3Blue1Brown',
5448 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5449 'uploader_id': '@3blue1brown',
5450 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5451 'uploader': '3Blue1Brown',
5452 'tags': ['Mathematics'],
5453 'channel_follower_count': int,
5454 'channel_is_verified': True,
5457 'note': 'playlists, singlepage',
5458 'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5459 'playlist_mincount': 4,
5461 'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5462 'title': 'ThirstForScience - Playlists',
5463 'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5464 'uploader': 'ThirstForScience',
5465 'uploader_url': 'https://www.youtube.com/@ThirstForScience',
5466 'uploader_id': '@ThirstForScience',
5467 'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5468 'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5470 'channel': 'ThirstForScience',
5471 'channel_follower_count': int
5474 'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5475 'only_matching': True,
5477 'note': 'basic, single video playlist',
5478 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5480 'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5481 'title': 'youtube-dl public playlist',
5485 'modified_date': '20201130',
5486 'channel': 'Sergey M.',
5487 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5488 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5489 'availability': 'public',
5490 'uploader': 'Sergey M.',
5491 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5492 'uploader_id': '@sergeym.6173',
5494 'playlist_count': 1,
5496 'note': 'empty playlist',
5497 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5499 'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5500 'title': 'youtube-dl empty playlist',
5502 'channel': 'Sergey M.',
5504 'modified_date': '20160902',
5505 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5506 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5507 'availability': 'public',
5508 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5509 'uploader_id': '@sergeym.6173',
5510 'uploader': 'Sergey M.',
5512 'playlist_count': 0,
5515 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5517 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5518 'title': 'lex will - Home',
5519 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5520 'uploader': 'lex will',
5521 'uploader_id': '@lexwill718',
5522 'channel': 'lex will',
5523 'tags': ['bible', 'history', 'prophesy'],
5524 'uploader_url': 'https://www.youtube.com/@lexwill718',
5525 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5526 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5527 'channel_follower_count': int
5529 'playlist_mincount': 2,
5531 'note': 'Videos tab',
5532 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5534 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5535 'title': 'lex will - Videos',
5536 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5537 'uploader': 'lex will',
5538 'uploader_id': '@lexwill718',
5539 'tags': ['bible', 'history', 'prophesy'],
5540 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5541 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5542 'uploader_url': 'https://www.youtube.com/@lexwill718',
5543 'channel': 'lex will',
5544 'channel_follower_count': int
5546 'playlist_mincount': 975,
5548 'note': 'Videos tab, sorted by popular',
5549 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5551 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5552 'title': 'lex will - Videos',
5553 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5554 'uploader': 'lex will',
5555 'uploader_id': '@lexwill718',
5556 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5557 'uploader_url': 'https://www.youtube.com/@lexwill718',
5558 'channel': 'lex will',
5559 'tags': ['bible', 'history', 'prophesy'],
5560 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5561 'channel_follower_count': int
5563 'playlist_mincount': 199,
5565 'note': 'Playlists tab',
5566 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5568 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5569 'title': 'lex will - Playlists',
5570 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5571 'uploader': 'lex will',
5572 'uploader_id': '@lexwill718',
5573 'uploader_url': 'https://www.youtube.com/@lexwill718',
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
5580 'playlist_mincount': 17,
5582 'note': 'Community tab',
5583 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5585 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5586 'title': 'lex will - Community',
5587 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5588 'channel': 'lex will',
5589 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5590 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5591 'tags': ['bible', 'history', 'prophesy'],
5592 'channel_follower_count': int,
5593 'uploader_url': 'https://www.youtube.com/@lexwill718',
5594 'uploader_id': '@lexwill718',
5595 'uploader': 'lex will',
5597 'playlist_mincount': 18,
5599 'note': 'Channels tab',
5600 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5602 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5603 'title': 'lex will - Channels',
5604 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5605 'channel': 'lex will',
5606 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5607 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5608 'tags': ['bible', 'history', 'prophesy'],
5609 'channel_follower_count': int,
5610 'uploader_url': 'https://www.youtube.com/@lexwill718',
5611 'uploader_id': '@lexwill718',
5612 'uploader': 'lex will',
5614 'playlist_mincount': 12,
5616 'note': 'Search tab',
5617 'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5618 'playlist_mincount': 40,
5620 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5621 'title': '3Blue1Brown - Search - linear algebra',
5622 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5623 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5624 'tags': ['Mathematics'],
5625 'channel': '3Blue1Brown',
5626 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5627 'channel_follower_count': int,
5628 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5629 'uploader_id': '@3blue1brown',
5630 'uploader': '3Blue1Brown',
5631 'channel_is_verified': True,
5634 'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5635 'only_matching': True,
5637 'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5638 'only_matching': True,
5640 'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5641 'only_matching': True,
5643 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5644 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5646 'title': '29C3: Not my department',
5647 'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5648 'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5651 'modified_date': '20150605',
5652 'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5653 'channel_url': 'https://www.youtube.com/channel/UCEPzS1rYsrkqzSLNp76nrcg',
5654 'channel': 'Christiaan008',
5655 'availability': 'public',
5656 'uploader_id': '@ChRiStIaAn008',
5657 'uploader': 'Christiaan008',
5658 'uploader_url': 'https://www.youtube.com/@ChRiStIaAn008',
5660 'playlist_count': 96,
5662 'note': 'Large playlist',
5663 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5665 'title': 'Uploads from Cauchemar',
5666 'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5667 'channel_url': 'https://www.youtube.com/channel/UCBABnxM4Ar9ten8Mdjj1j0Q',
5669 'modified_date': r
're:\d{8}',
5670 'channel': 'Cauchemar',
5673 'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5674 'availability': 'public',
5675 'uploader_id': '@Cauchemar89',
5676 'uploader': 'Cauchemar',
5677 'uploader_url': 'https://www.youtube.com/@Cauchemar89',
5679 'playlist_mincount': 1123,
5680 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5682 'note': 'even larger playlist, 8832 videos',
5683 'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5684 'only_matching': True,
5686 'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5687 'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5689 'title': 'Uploads from Interstellar Movie',
5690 'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5693 'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5694 'channel_url': 'https://www.youtube.com/channel/UCXw-G3eDE9trcvY2sBMM_aA',
5695 'channel': 'Interstellar Movie',
5697 'modified_date': r
're:\d{8}',
5698 'availability': 'public',
5699 'uploader_id': '@InterstellarMovie',
5700 'uploader': 'Interstellar Movie',
5701 'uploader_url': 'https://www.youtube.com/@InterstellarMovie',
5703 'playlist_mincount': 21,
5705 'note': 'Playlist with "show unavailable videos" button',
5706 'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5708 'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5709 'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5711 'channel': 'Phim Siêu Nhân Nhật Bản',
5714 'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5715 'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5716 'modified_date': r
're:\d{8}',
5717 'availability': 'public',
5718 'uploader_url': 'https://www.youtube.com/@phimsieunhannhatban',
5719 'uploader_id': '@phimsieunhannhatban',
5720 'uploader': 'Phim Siêu Nhân Nhật Bản',
5722 'playlist_mincount': 200,
5723 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5725 'note': 'Playlist with unavailable videos in page 7',
5726 'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5728 'title': 'Uploads from BlankTV',
5729 'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5730 'channel': 'BlankTV',
5731 'channel_url': 'https://www.youtube.com/channel/UC8l9frL61Yl5KFOl87nIm2w',
5732 'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5735 'modified_date': r
're:\d{8}',
5737 'availability': 'public',
5738 'uploader_id': '@blanktv',
5739 'uploader': 'BlankTV',
5740 'uploader_url': 'https://www.youtube.com/@blanktv',
5742 'playlist_mincount': 1000,
5743 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5745 'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5746 'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5748 'title': 'Data Analysis with Dr Mike Pound',
5749 'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5750 'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5753 'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5754 'channel_url': 'https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA',
5755 'channel': 'Computerphile',
5756 'availability': 'public',
5757 'modified_date': '20190712',
5758 'uploader_id': '@Computerphile',
5759 'uploader': 'Computerphile',
5760 'uploader_url': 'https://www.youtube.com/@Computerphile',
5762 'playlist_mincount': 11,
5764 'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5765 'only_matching': True,
5767 'note': 'Playlist URL that does not actually serve a playlist',
5768 'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5770 'id': 'FqZTN594JQw',
5772 'title': "Smiley's People 01 detective, Adventure Series, Action",
5773 'upload_date': '20150526',
5774 'license': 'Standard YouTube License',
5775 'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5776 'categories': ['People & Blogs'],
5782 'skip_download': True,
5784 'skip': 'This video is not available.',
5785 'add_ie': [YoutubeIE
.ie_key()],
5787 'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5788 'only_matching': True,
5790 'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5791 'only_matching': True,
5793 'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5795 'id': 'hGkQjiJLjWQ', # This will keep changing
5798 'upload_date': r
're:\d{8}',
5800 'categories': ['News & Politics'],
5803 'release_timestamp': int,
5804 'channel': 'Sky News',
5805 'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5808 'thumbnail': r
're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5809 'playable_in_embed': True,
5810 'release_date': r
're:\d+',
5811 'availability': 'public',
5812 'live_status': 'is_live',
5813 'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5814 'channel_follower_count': int,
5815 'concurrent_view_count': int,
5816 'uploader_url': 'https://www.youtube.com/@SkyNews',
5817 'uploader_id': '@SkyNews',
5818 'uploader': 'Sky News',
5819 'channel_is_verified': True,
5822 'skip_download': True,
5824 'expected_warnings': ['Ignoring subtitle tracks found in '],
5826 'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5828 'id': 'a48o2S1cPoo',
5830 'title': 'The Young Turks - Live Main Show',
5831 'upload_date': '20150715',
5832 'license': 'Standard YouTube License',
5833 'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5834 'categories': ['News & Politics'],
5835 'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5839 'skip_download': True,
5841 'only_matching': True,
5843 'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5844 'only_matching': True,
5846 'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5847 'only_matching': True,
5849 'note': 'A channel that is not live. Should raise error',
5850 'url': 'https://www.youtube.com/user/numberphile/live',
5851 'only_matching': True,
5853 'url': 'https://www.youtube.com/feed/trending',
5854 'only_matching': True,
5856 'url': 'https://www.youtube.com/feed/library',
5857 'only_matching': True,
5859 'url': 'https://www.youtube.com/feed/history',
5860 'only_matching': True,
5862 'url': 'https://www.youtube.com/feed/subscriptions',
5863 'only_matching': True,
5865 'url': 'https://www.youtube.com/feed/watch_later',
5866 'only_matching': True,
5868 'note': 'Recommended - redirects to home page.',
5869 'url': 'https://www.youtube.com/feed/recommended',
5870 'only_matching': True,
5872 'note': 'inline playlist with not always working continuations',
5873 'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5874 'only_matching': True,
5876 'url': 'https://www.youtube.com/course',
5877 'only_matching': True,
5879 'url': 'https://www.youtube.com/zsecurity',
5880 'only_matching': True,
5882 'url': 'http://www.youtube.com/NASAgovVideo/videos',
5883 'only_matching': True,
5885 'url': 'https://www.youtube.com/TheYoungTurks/live',
5886 'only_matching': True,
5888 'url': 'https://www.youtube.com/hashtag/cctv9',
5894 'playlist_mincount': 300, # not consistent but should be over 300
5896 'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
5897 'only_matching': True,
5899 'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
5900 'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5901 'only_matching': True
5903 'note': '/browse/ should redirect to /channel/',
5904 'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
5905 'only_matching': True
5907 'note': 'VLPL, should redirect to playlist?list=PL...',
5908 'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5910 'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5911 'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
5912 'title': 'NCS : All Releases 💿',
5913 'channel_url': 'https://www.youtube.com/channel/UC_aEa8K-EOJ3D6gOs7HcyNg',
5914 'modified_date': r
're:\d{8}',
5916 'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
5918 'channel': 'NoCopyrightSounds',
5919 'availability': 'public',
5920 'uploader_url': 'https://www.youtube.com/@NoCopyrightSounds',
5921 'uploader': 'NoCopyrightSounds',
5922 'uploader_id': '@NoCopyrightSounds',
5924 'playlist_mincount': 166,
5925 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden', 'YouTube Music is not directly supported'],
5927 # TODO: fix 'unviewable' issue with this playlist when reloading with unavailable videos
5928 'note': 'Topic, should redirect to playlist?list=UU...',
5929 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5931 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5932 'title': 'Uploads from Royalty Free Music - Topic',
5934 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5935 'channel': 'Royalty Free Music - Topic',
5937 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5938 'modified_date': r
're:\d{8}',
5940 'availability': 'public',
5941 'uploader': 'Royalty Free Music - Topic',
5943 'playlist_mincount': 101,
5944 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5946 # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
5947 # Treat as a general feed
5948 'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
5950 'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
5951 'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
5954 'playlist_mincount': 9,
5956 'note': 'Youtube music Album',
5957 'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
5959 'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
5960 'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
5964 'availability': 'unlisted',
5965 'modified_date': r
're:\d{8}',
5967 'playlist_count': 50,
5968 'expected_warnings': ['YouTube Music is not directly supported'],
5970 'note': 'unlisted single video playlist',
5971 'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5973 'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5974 'title': 'yt-dlp unlisted playlist test',
5975 'availability': 'unlisted',
5977 'modified_date': '20220418',
5978 'channel': 'colethedj',
5981 'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5982 'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5983 'uploader_url': 'https://www.youtube.com/@colethedj1894',
5984 'uploader_id': '@colethedj1894',
5985 'uploader': 'colethedj',
5989 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
5990 'id': 'BaW_jenozKc',
5992 'ie_key': 'Youtube',
5994 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
5995 'channel_url': 'https://www.youtube.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
5997 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc',
5998 'channel': 'Philipp Hagemeister',
5999 'uploader_id': '@PhilippHagemeister',
6000 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
6001 'uploader': 'Philipp Hagemeister',
6004 'playlist_count': 1,
6005 'params': {'extract_flat': True}
,
6007 'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
6008 'url': 'https://www.youtube.com/feed/recommended',
6010 'id': 'recommended',
6011 'title': 'recommended',
6014 'playlist_mincount': 50,
6016 'skip_download': True,
6017 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6020 'note': 'API Fallback: /videos tab, sorted by oldest first',
6021 'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
6023 'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6024 'title': 'Cody\'sLab - Videos',
6025 'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
6026 'channel': 'Cody\'sLab',
6027 'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6029 'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
6030 'channel_follower_count': int
6032 'playlist_mincount': 650,
6034 'skip_download': True,
6035 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6037 'skip': 'Query for sorting no longer works',
6039 'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
6040 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
6042 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
6043 'title': 'Uploads from Royalty Free Music - Topic',
6044 'modified_date': r
're:\d{8}',
6045 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
6047 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
6049 'channel': 'Royalty Free Music - Topic',
6051 'availability': 'public',
6052 'uploader': 'Royalty Free Music - Topic',
6054 'playlist_mincount': 101,
6056 'skip_download': True,
6057 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6059 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
6061 'note': 'non-standard redirect to regional channel',
6062 'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
6063 'only_matching': True
6065 'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
6066 'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6068 'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6069 'modified_date': '20220407',
6070 'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
6072 'availability': 'unlisted',
6073 'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
6074 'channel': 'pukkandan',
6075 'description': 'Test for collaborative playlist',
6076 'title': 'yt-dlp test - collaborative playlist',
6078 'uploader_url': 'https://www.youtube.com/@pukkandan',
6079 'uploader_id': '@pukkandan',
6080 'uploader': 'pukkandan',
6082 'playlist_mincount': 2
6084 'note': 'translated tab name',
6085 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
6087 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6089 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6090 'description': 'test description',
6091 'title': 'cole-dlp-test-acc - 再生リスト',
6092 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6093 'channel': 'cole-dlp-test-acc',
6094 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6095 'uploader_id': '@coletdjnz',
6096 'uploader': 'cole-dlp-test-acc',
6098 'playlist_mincount': 1,
6099 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6100 'expected_warnings': ['Preferring "ja"'],
6102 # XXX: this should really check flat playlist entries, but the test suite doesn't support that
6103 'note': 'preferred lang set with playlist with translated video titles',
6104 'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6106 'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6109 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6110 'channel': 'cole-dlp-test-acc',
6111 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6112 'description': 'test',
6113 'title': 'dlp test playlist',
6114 'availability': 'public',
6115 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6116 'uploader_id': '@coletdjnz',
6117 'uploader': 'cole-dlp-test-acc',
6119 'playlist_mincount': 1,
6120 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6121 'expected_warnings': ['Preferring "ja"'],
6123 # shorts audio pivot for 2GtVksBMYFM.
6124 'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
6126 'id': 'sfv_audio_pivot',
6127 'title': 'sfv_audio_pivot',
6130 'playlist_mincount': 50,
6133 # Channel with a real live tab (not to be mistaken with streams tab)
6134 # Do not treat like it should redirect to live stream
6135 'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
6137 'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
6138 'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
6141 'playlist_mincount': 20,
6143 # Tab name is not the same as tab id
6144 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
6146 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6147 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
6150 'playlist_mincount': 8,
6152 # Home tab id is literally home. Not to get mistaken with featured
6153 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
6155 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6156 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
6159 'playlist_mincount': 8,
6161 # Should get three playlists for videos, shorts and streams tabs
6162 'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6164 'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6165 'title': 'Polka Ch. 尾丸ポルカ',
6166 'channel_follower_count': int,
6167 'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6168 'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6169 'description': 'md5:e56b74b5bb7e9c701522162e9abfb822',
6170 'channel': 'Polka Ch. 尾丸ポルカ',
6172 'uploader_url': 'https://www.youtube.com/@OmaruPolka',
6173 'uploader': 'Polka Ch. 尾丸ポルカ',
6174 'uploader_id': '@OmaruPolka',
6176 'playlist_count': 3,
6178 # Shorts tab with channel with handle
6179 # TODO: fix channel description
6180 'url': 'https://www.youtube.com/@NotJustBikes/shorts',
6182 'id': 'UC0intLFzLaudFG-xAvUEO-A',
6183 'title': 'Not Just Bikes - Shorts',
6185 'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
6186 'description': 'md5:26bc55af26855a608a5cf89dfa595c8d',
6187 'channel_follower_count': int,
6188 'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
6189 'channel': 'Not Just Bikes',
6190 'uploader_url': 'https://www.youtube.com/@NotJustBikes',
6191 'uploader': 'Not Just Bikes',
6192 'uploader_id': '@NotJustBikes',
6194 'playlist_mincount': 10,
6197 'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
6199 'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6200 'title': '中村悠一 - Live',
6202 'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6203 'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
6205 'channel_follower_count': int,
6206 'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
6207 'uploader_url': 'https://www.youtube.com/@Yuichi-Nakamura',
6208 'uploader_id': '@Yuichi-Nakamura',
6211 'playlist_mincount': 60,
6213 # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
6214 # See test_youtube_lists
6215 'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
6216 'only_matching': True,
6218 # No uploads and no UCID given. Should fail with no uploads error
6219 # See test_youtube_lists
6220 'url': 'https://www.youtube.com/news',
6221 'only_matching': True
6223 # No videos tab but has a shorts tab
6224 'url': 'https://www.youtube.com/c/TKFShorts',
6226 'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6227 'title': 'Shorts Break - Shorts',
6229 'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6230 'channel': 'Shorts Break',
6231 'description': 'md5:6de33c5e7ba686e5f3efd4e19c7ef499',
6232 'channel_follower_count': int,
6233 'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
6234 'uploader_url': 'https://www.youtube.com/@ShortsBreak_Official',
6235 'uploader': 'Shorts Break',
6236 'uploader_id': '@ShortsBreak_Official',
6238 'playlist_mincount': 30,
6240 # Trending Now Tab. tab id is empty
6241 'url': 'https://www.youtube.com/feed/trending',
6244 'title': 'trending - Now',
6247 'playlist_mincount': 30,
6249 # Trending Gaming Tab. tab id is empty
6250 'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
6253 'title': 'trending - Gaming',
6256 'playlist_mincount': 30,
6258 # Shorts url result in shorts tab
6259 # TODO: Fix channel id extraction
6260 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
6262 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6263 'title': 'cole-dlp-test-acc - Shorts',
6264 'channel': 'cole-dlp-test-acc',
6265 'description': 'test description',
6266 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6267 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6269 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6270 'uploader_id': '@coletdjnz',
6271 'uploader': 'cole-dlp-test-acc',
6275 # Channel data is not currently available for short renderers (as of 2023-03-01)
6277 'ie_key': 'Youtube',
6278 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
6279 'id': 'sSM9J5YH_60',
6280 'title': 'SHORT short',
6285 'params': {'extract_flat': True}
,
6287 # Live video status should be extracted
6288 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
6290 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6291 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live', # TODO, should be Minecraft - Live or Minecraft - Topic - Live
6297 'ie_key': 'Youtube',
6298 'url': 'startswith:https://www.youtube.com/watch?v=',
6301 'live_status': 'is_live',
6304 'concurrent_view_count': int,
6307 'uploader_url': str,
6309 'channel_is_verified': bool, # this will keep changing
6312 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6313 'playlist_mincount': 1
6315 # Channel renderer metadata. Contains number of videos on the channel
6316 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/channels',
6318 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6319 'title': 'cole-dlp-test-acc - Channels',
6320 'channel': 'cole-dlp-test-acc',
6321 'description': 'test description',
6322 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6323 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6325 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6326 'uploader_id': '@coletdjnz',
6327 'uploader': 'cole-dlp-test-acc',
6332 'ie_key': 'YoutubeTab',
6333 'url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6334 'id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6335 'channel_id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6336 'title': 'PewDiePie',
6337 'channel': 'PewDiePie',
6338 'channel_url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6340 'channel_follower_count': int,
6341 'playlist_count': int,
6342 'uploader': 'PewDiePie',
6343 'uploader_url': 'https://www.youtube.com/@PewDiePie',
6344 'uploader_id': '@PewDiePie',
6345 'channel_is_verified': True,
6348 'params': {'extract_flat': True}
,
6350 'url': 'https://www.youtube.com/@3blue1brown/about',
6352 'id': 'UCYO_jab_esuFRV4b17AJtAw',
6353 'tags': ['Mathematics'],
6354 'title': '3Blue1Brown - About',
6355 'channel_follower_count': int,
6356 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
6357 'channel': '3Blue1Brown',
6359 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
6360 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
6361 'uploader_url': 'https://www.youtube.com/@3blue1brown',
6362 'uploader_id': '@3blue1brown',
6363 'uploader': '3Blue1Brown',
6364 'channel_is_verified': True,
6366 'playlist_count': 0,
6368 # Podcasts tab, with rich entry playlistRenderers
6369 'url': 'https://www.youtube.com/@99percentinvisiblepodcast/podcasts',
6371 'id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6372 'channel_id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6373 'uploader_url': 'https://www.youtube.com/@99percentinvisiblepodcast',
6374 'description': 'md5:3a0ed38f1ad42a68ef0428c04a15695c',
6375 'title': '99 Percent Invisible - Podcasts',
6376 'uploader': '99 Percent Invisible',
6377 'channel_follower_count': int,
6378 'channel_url': 'https://www.youtube.com/channel/UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6380 'channel': '99 Percent Invisible',
6381 'uploader_id': '@99percentinvisiblepodcast',
6383 'playlist_count': 1,
6385 # Releases tab, with rich entry playlistRenderers (same as Podcasts tab)
6386 'url': 'https://www.youtube.com/@AHimitsu/releases',
6388 'id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6389 'channel': 'A Himitsu',
6390 'uploader_url': 'https://www.youtube.com/@AHimitsu',
6391 'title': 'A Himitsu - Releases',
6392 'uploader_id': '@AHimitsu',
6393 'uploader': 'A Himitsu',
6394 'channel_id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6396 'description': 'I make music',
6397 'channel_url': 'https://www.youtube.com/channel/UCgFwu-j5-xNJml2FtTrrB3A',
6398 'channel_follower_count': int,
6399 'channel_is_verified': True,
6401 'playlist_mincount': 10,
6403 # Playlist with only shorts, shown as reel renderers
6404 # FIXME: future: YouTube currently doesn't give continuation for this,
6406 'url': 'https://www.youtube.com/playlist?list=UUxqPAgubo4coVn9Lx1FuKcg',
6408 'id': 'UUxqPAgubo4coVn9Lx1FuKcg',
6409 'channel_url': 'https://www.youtube.com/channel/UCxqPAgubo4coVn9Lx1FuKcg',
6411 'uploader_id': '@BangyShorts',
6413 'uploader_url': 'https://www.youtube.com/@BangyShorts',
6414 'channel_id': 'UCxqPAgubo4coVn9Lx1FuKcg',
6415 'channel': 'Bangy Shorts',
6416 'uploader': 'Bangy Shorts',
6418 'availability': 'public',
6419 'modified_date': '20230626',
6420 'title': 'Uploads from Bangy Shorts',
6422 'playlist_mincount': 100,
6423 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6427 def suitable(cls
, url
):
6428 return False if YoutubeIE
.suitable(url
) else super().suitable(url
)
6430 _URL_RE
= re
.compile(rf
'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
6432 def _get_url_mobj(self
, url
):
6433 mobj
= self
._URL
_RE
.match(url
).groupdict()
6434 mobj
.update((k
, '') for k
, v
in mobj
.items() if v
is None)
6437 def _extract_tab_id_and_name(self
, tab
, base_url
='https://www.youtube.com'):
6438 tab_name
= (tab
.get('title') or '').lower()
6439 tab_url
= urljoin(base_url
, traverse_obj(
6440 tab
, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
6442 tab_id
= (tab_url
and self
._get
_url
_mobj
(tab_url
)['tab'][1:]
6443 or traverse_obj(tab
, 'tabIdentifier', expected_type
=str))
6446 'TAB_ID_SPONSORSHIPS': 'membership',
6447 }.get(tab_id
, tab_id
), tab_name
6449 # Fallback to tab name if we cannot get the tab id.
6450 # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6451 # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6453 self
.write_debug(f
'Falling back to selected tab name: {tab_name}')
6457 }.get(tab_name
, tab_name
), tab_name
6459 def _has_tab(self
, tabs
, tab_id
):
6460 return any(self
._extract
_tab
_id
_and
_name
(tab
)[0] == tab_id
for tab
in tabs
)
6462 @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6463 def _real_extract(self
, url
, smuggled_data
):
6464 item_id
= self
._match
_id
(url
)
6465 url
= urllib
.parse
.urlunparse(
6466 urllib
.parse
.urlparse(url
)._replace
(netloc
='www.youtube.com'))
6467 compat_opts
= self
.get_param('compat_opts', [])
6469 mobj
= self
._get
_url
_mobj
(url
)
6470 pre
, tab
, post
, is_channel
= mobj
['pre'], mobj
['tab'], mobj
['post'], not mobj
['not_channel']
6471 if is_channel
and smuggled_data
.get('is_music_url'):
6472 if item_id
[:2] == 'VL': # Youtube music VL channels have an equivalent playlist
6473 return self
.url_result(
6474 f
'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE
, item_id
[2:])
6475 elif item_id
[:2] == 'MP': # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6476 mdata
= self
._extract
_tab
_endpoint
(
6477 f
'https://music.youtube.com/channel/{item_id}', item_id
, default_client
='web_music')
6478 murl
= traverse_obj(mdata
, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6479 get_all
=False, expected_type
=str)
6481 raise ExtractorError('Failed to resolve album to playlist')
6482 return self
.url_result(murl
, YoutubeTabIE
)
6483 elif mobj
['channel_type'] == 'browse': # Youtube music /browse/ should be changed to /channel/
6484 return self
.url_result(
6485 f
'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE
, item_id
)
6487 original_tab_id
, display_id
= tab
[1:], f
'{item_id}{tab}'
6488 if is_channel
and not tab
and 'no-youtube-channel-redirect' not in compat_opts
:
6489 url
= f
'{pre}/videos{post}'
6490 if smuggled_data
.get('is_music_url'):
6491 self
.report_warning(f
'YouTube Music is not directly supported. Redirecting to {url}')
6493 # Handle both video/playlist URLs
6495 video_id
, playlist_id
= [traverse_obj(qs
, (key
, 0)) for key
in ('v', 'list')]
6496 if not video_id
and mobj
['not_channel'].startswith('watch'):
6498 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6499 raise ExtractorError('A video URL was given without video ID', expected
=True)
6500 # Common mistake: https://www.youtube.com/watch?list=playlist_id
6501 self
.report_warning(f
'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6502 return self
.url_result(
6503 f
'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE
, playlist_id
)
6505 if not self
._yes
_playlist
(playlist_id
, video_id
):
6506 return self
.url_result(
6507 f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6509 data
, ytcfg
= self
._extract
_data
(url
, display_id
)
6511 # YouTube may provide a non-standard redirect to the regional channel
6512 # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6513 # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6514 redirect_url
= traverse_obj(
6515 data
, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all
=False)
6516 if redirect_url
and 'no-youtube-channel-redirect' not in compat_opts
:
6517 redirect_url
= ''.join((urljoin('https://www.youtube.com', redirect_url
), tab
, post
))
6518 self
.to_screen(f
'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6519 return self
.url_result(redirect_url
, YoutubeTabIE
)
6521 tabs
, extra_tabs
= self
._extract
_tab
_renderers
(data
), []
6522 if is_channel
and tabs
and 'no-youtube-channel-redirect' not in compat_opts
:
6523 selected_tab
= self
._extract
_selected
_tab
(tabs
)
6524 selected_tab_id
, selected_tab_name
= self
._extract
_tab
_id
_and
_name
(selected_tab
, url
) # NB: Name may be translated
6525 self
.write_debug(f
'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6527 if not original_tab_id
and selected_tab_name
:
6528 self
.to_screen('Downloading all uploads of the channel. '
6529 'To download only the videos in a specific tab, pass the tab\'s URL')
6530 if self
._has
_tab
(tabs
, 'streams'):
6531 extra_tabs
.append(''.join((pre
, '/streams', post
)))
6532 if self
._has
_tab
(tabs
, 'shorts'):
6533 extra_tabs
.append(''.join((pre
, '/shorts', post
)))
6534 # XXX: Members-only tab should also be extracted
6536 if not extra_tabs
and selected_tab_id
!= 'videos':
6537 # Channel does not have streams, shorts or videos tabs
6538 if item_id
[:2] != 'UC':
6539 raise ExtractorError('This channel has no uploads', expected
=True)
6541 # Topic channels don't have /videos. Use the equivalent playlist instead
6542 pl_id
= f
'UU{item_id[2:]}'
6543 pl_url
= f
'https://www.youtube.com/playlist?list={pl_id}'
6545 data
, ytcfg
= self
._extract
_data
(pl_url
, pl_id
, ytcfg
=ytcfg
, fatal
=True, webpage_fatal
=True)
6546 except ExtractorError
:
6547 raise ExtractorError('This channel has no uploads', expected
=True)
6549 item_id
, url
= pl_id
, pl_url
6551 f
'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6553 elif extra_tabs
and selected_tab_id
!= 'videos':
6554 # When there are shorts/live tabs but not videos tab
6555 url
, data
= f
'{pre}{post}', None
6557 elif (original_tab_id
or 'videos') != selected_tab_id
:
6558 if original_tab_id
== 'live':
6559 # Live tab should have redirected to the video
6560 # Except in the case the channel has an actual live tab
6561 # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6562 raise UserNotLive(video_id
=item_id
)
6563 elif selected_tab_name
:
6564 raise ExtractorError(f
'This channel does not have a {original_tab_id} tab', expected
=True)
6566 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6567 url
= f
'{pre}{post}'
6569 # YouTube sometimes provides a button to reload playlist with unavailable videos.
6570 if 'no-youtube-unavailable-videos' not in compat_opts
:
6571 data
= self
._reload
_with
_unavailable
_videos
(display_id
, data
, ytcfg
) or data
6572 self
._extract
_and
_report
_alerts
(data
, only_once
=True)
6574 tabs
, entries
= self
._extract
_tab
_renderers
(data
), []
6576 entries
= [self
._extract
_from
_tabs
(item_id
, ytcfg
, data
, tabs
)]
6578 'extractor_key': YoutubeTabIE
.ie_key(),
6579 'extractor': YoutubeTabIE
.IE_NAME
,
6582 if self
.get_param('playlist_items') == '0':
6583 entries
.extend(self
.url_result(u
, YoutubeTabIE
) for u
in extra_tabs
)
6584 else: # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6585 entries
.extend(map(self
._real
_extract
, extra_tabs
))
6587 if len(entries
) == 1:
6590 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
6591 uploads_url
= 'the Uploads (UU) playlist URL'
6592 if try_get(metadata
, lambda x
: x
['channel_id'].startswith('UC')):
6593 uploads_url
= f
'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6595 'Downloading as multiple playlists, separated by tabs. '
6596 f
'To download as a single playlist instead, pass {uploads_url}')
6597 return self
.playlist_result(entries
, item_id
, **metadata
)
6600 playlist
= traverse_obj(
6601 data
, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type
=dict)
6603 return self
._extract
_from
_playlist
(item_id
, url
, data
, playlist
, ytcfg
)
6605 video_id
= traverse_obj(
6606 data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str) or video_id
6608 if tab
!= '/live': # live tab is expected to redirect to video
6609 self
.report_warning(f
'Unable to recognize playlist. Downloading just video {video_id}')
6610 return self
.url_result(f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6612 raise ExtractorError('Unable to recognize tab page')
6615 class YoutubePlaylistIE(InfoExtractor
):
6616 IE_DESC
= 'YouTube playlists'
6617 _VALID_URL
= r
'''(?x)(?:
6622 youtube(?:kids)?\.com|
6627 (?P<id>%(playlist_id)s)
6629 'playlist_id': YoutubeBaseInfoExtractor
._PLAYLIST
_ID
_RE
,
6630 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
6632 IE_NAME
= 'youtube:playlist'
6634 'note': 'issue #673',
6635 'url': 'PLBB231211A4F62143',
6637 'title': '[OLD]Team Fortress 2 (Class-based LP)',
6638 'id': 'PLBB231211A4F62143',
6639 'uploader': 'Wickman',
6640 'uploader_id': '@WickmanVT',
6641 'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6643 'uploader_url': 'https://www.youtube.com/@WickmanVT',
6644 'modified_date': r
're:\d{8}',
6645 'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6646 'channel': 'Wickman',
6648 'channel_url': 'https://www.youtube.com/channel/UCKSpbfbl5kRQpTdL7kMc-1Q',
6649 'availability': 'public',
6651 'playlist_mincount': 29,
6653 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6655 'title': 'YDL_safe_search',
6656 'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6658 'playlist_count': 2,
6659 'skip': 'This playlist is private',
6662 'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6663 'playlist_count': 4,
6666 'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6667 'uploader': 'milan',
6668 'uploader_id': '@milan5503',
6670 'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6672 'modified_date': '20140919',
6675 'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6676 'uploader_url': 'https://www.youtube.com/@milan5503',
6677 'availability': 'public',
6679 'expected_warnings': [r
'[Uu]navailable videos? (is|are|will be) hidden'],
6681 'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6682 'playlist_mincount': 455,
6684 'title': '2018 Chinese New Singles (11/6 updated)',
6685 'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6687 'uploader_id': '@music_king',
6688 'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6691 'channel_url': 'https://www.youtube.com/channel/UC21nz3_MesPLqtDqwdvnoxA',
6693 'uploader_url': 'https://www.youtube.com/@music_king',
6694 'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6695 'modified_date': r
're:\d{8}',
6696 'availability': 'public',
6698 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6700 'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6701 'only_matching': True,
6703 # music album playlist
6704 'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6705 'only_matching': True,
6709 def suitable(cls
, url
):
6710 if YoutubeTabIE
.suitable(url
):
6712 from ..utils
import parse_qs
6714 if qs
.get('v', [None])[0]:
6716 return super().suitable(url
)
6718 def _real_extract(self
, url
):
6719 playlist_id
= self
._match
_id
(url
)
6720 is_music_url
= YoutubeBaseInfoExtractor
.is_music_url(url
)
6721 url
= update_url_query(
6722 'https://www.youtube.com/playlist',
6723 parse_qs(url
) or {'list': playlist_id}
)
6725 url
= smuggle_url(url
, {'is_music_url': True}
)
6726 return self
.url_result(url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6729 class YoutubeYtBeIE(InfoExtractor
):
6730 IE_DESC
= 'youtu.be'
6731 _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}
6733 'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6735 'id': 'yeWKywCrFtk',
6737 'title': 'Small Scale Baler and Braiding Rugs',
6738 'uploader': 'Backus-Page House Museum',
6739 'uploader_id': '@backuspagemuseum',
6740 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/@backuspagemuseum',
6741 'upload_date': '20161008',
6742 'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6743 'categories': ['Nonprofits & Activism'],
6747 'playable_in_embed': True,
6748 'thumbnail': r
're:^https?://.*\.webp',
6749 'channel': 'Backus-Page House Museum',
6750 'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6751 'live_status': 'not_live',
6753 'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6754 'availability': 'public',
6756 'comment_count': int,
6757 'channel_follower_count': int
6761 'skip_download': True,
6764 'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6765 'only_matching': True,
6768 def _real_extract(self
, url
):
6769 mobj
= self
._match
_valid
_url
(url
)
6770 video_id
= mobj
.group('id')
6771 playlist_id
= mobj
.group('playlist_id')
6772 return self
.url_result(
6773 update_url_query('https://www.youtube.com/watch', {
6775 'list': playlist_id
,
6776 'feature': 'youtu.be',
6777 }), ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6780 class YoutubeLivestreamEmbedIE(InfoExtractor
):
6781 IE_DESC
= 'YouTube livestream embeds'
6782 _VALID_URL
= r
'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6784 'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6785 'only_matching': True,
6788 def _real_extract(self
, url
):
6789 channel_id
= self
._match
_id
(url
)
6790 return self
.url_result(
6791 f
'https://www.youtube.com/channel/{channel_id}/live',
6792 ie
=YoutubeTabIE
.ie_key(), video_id
=channel_id
)
6795 class YoutubeYtUserIE(InfoExtractor
):
6796 IE_DESC
= 'YouTube user videos; "ytuser:" prefix'
6797 IE_NAME
= 'youtube:user'
6798 _VALID_URL
= r
'ytuser:(?P<id>.+)'
6800 'url': 'ytuser:phihag',
6801 'only_matching': True,
6804 def _real_extract(self
, url
):
6805 user_id
= self
._match
_id
(url
)
6806 return self
.url_result(f
'https://www.youtube.com/user/{user_id}', YoutubeTabIE
, user_id
)
6809 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor
):
6810 IE_NAME
= 'youtube:favorites'
6811 IE_DESC
= 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6812 _VALID_URL
= r
':ytfav(?:ou?rite)?s?'
6813 _LOGIN_REQUIRED
= True
6816 'only_matching': True,
6818 'url': ':ytfavorites',
6819 'only_matching': True,
6822 def _real_extract(self
, url
):
6823 return self
.url_result(
6824 'https://www.youtube.com/playlist?list=LL',
6825 ie
=YoutubeTabIE
.ie_key())
6828 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor
):
6829 IE_NAME
= 'youtube:notif'
6830 IE_DESC
= 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6831 _VALID_URL
= r
':ytnotif(?:ication)?s?'
6832 _LOGIN_REQUIRED
= True
6835 'only_matching': True,
6837 'url': ':ytnotifications',
6838 'only_matching': True,
6841 def _extract_notification_menu(self
, response
, continuation_list
):
6842 notification_list
= traverse_obj(
6844 ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6845 ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6846 expected_type
=list) or []
6847 continuation_list
[0] = None
6848 for item
in notification_list
:
6849 entry
= self
._extract
_notification
_renderer
(item
.get('notificationRenderer'))
6852 continuation
= item
.get('continuationItemRenderer')
6854 continuation_list
[0] = continuation
6856 def _extract_notification_renderer(self
, notification
):
6857 video_id
= traverse_obj(
6858 notification
, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str)
6859 url
= f
'https://www.youtube.com/watch?v={video_id}'
6862 browse_ep
= traverse_obj(
6863 notification
, ('navigationEndpoint', 'browseEndpoint'), expected_type
=dict)
6864 channel_id
= self
.ucid_or_none(traverse_obj(browse_ep
, 'browseId', expected_type
=str))
6865 post_id
= self
._search
_regex
(
6866 r
'/post/(.+)', traverse_obj(browse_ep
, 'canonicalBaseUrl', expected_type
=str),
6867 'post id', default
=None)
6868 if not channel_id
or not post_id
:
6870 # The direct /post url redirects to this in the browser
6871 url
= f
'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
6873 channel
= traverse_obj(
6874 notification
, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
6876 notification_title
= self
._get
_text
(notification
, 'shortMessage')
6877 if notification_title
:
6878 notification_title
= notification_title
.replace('\xad', '') # remove soft hyphens
6879 # TODO: handle recommended videos
6880 title
= self
._search
_regex
(
6881 rf
'{re.escape(channel or "")}[^:]+: (.+)', notification_title
,
6882 'video title', default
=None)
6883 timestamp
= (self
._parse
_time
_text
(self
._get
_text
(notification
, 'sentTimeText'))
6884 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
6889 'ie_key': (YoutubeIE
if video_id
else YoutubeTabIE
).ie_key(),
6890 'video_id': video_id
,
6892 'channel_id': channel_id
,
6894 'uploader': channel
,
6895 'thumbnails': self
._extract
_thumbnails
(notification
, 'videoThumbnail'),
6896 'timestamp': timestamp
,
6899 def _notification_menu_entries(self
, ytcfg
):
6900 continuation_list
= [None]
6902 for page
in itertools
.count(1):
6903 ctoken
= traverse_obj(
6904 continuation_list
, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type
=str)
6905 response
= self
._extract
_response
(
6906 item_id
=f
'page {page}', query
={'ctoken': ctoken}
if ctoken
else {}, ytcfg
=ytcfg
,
6907 ep
='notification/get_notification_menu', check_get_keys
='actions',
6908 headers
=self
.generate_api_headers(ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(response
)))
6909 yield from self
._extract
_notification
_menu
(response
, continuation_list
)
6910 if not continuation_list
[0]:
6913 def _real_extract(self
, url
):
6914 display_id
= 'notifications'
6915 ytcfg
= self
._download
_ytcfg
('web', display_id
) if not self
.skip_webpage
else {}
6916 self
._report
_playlist
_authcheck
(ytcfg
)
6917 return self
.playlist_result(self
._notification
_menu
_entries
(ytcfg
), display_id
, display_id
)
6920 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6921 IE_DESC
= 'YouTube search'
6922 IE_NAME
= 'youtube:search'
6923 _SEARCH_KEY
= 'ytsearch'
6924 _SEARCH_PARAMS
= 'EgIQAQ%3D%3D' # Videos only
6926 'url': 'ytsearch5:youtube-dl test video',
6927 'playlist_count': 5,
6929 'id': 'youtube-dl test video',
6930 'title': 'youtube-dl test video',
6935 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6936 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ ':date'
6937 _SEARCH_KEY
= 'ytsearchdate'
6938 IE_DESC
= 'YouTube search, newest videos first'
6939 _SEARCH_PARAMS
= 'CAISAhAB' # Videos only, sorted by date
6941 'url': 'ytsearchdate5:youtube-dl test video',
6942 'playlist_count': 5,
6944 'id': 'youtube-dl test video',
6945 'title': 'youtube-dl test video',
6950 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor
):
6951 IE_DESC
= 'YouTube search URLs with sorting and filter support'
6952 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ '_url'
6953 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6955 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
6956 'playlist_mincount': 5,
6958 'id': 'youtube-dl test video',
6959 'title': 'youtube-dl test video',
6962 'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
6963 'playlist_mincount': 5,
6969 'url': 'https://www.youtube.com/results?search_query=%23cats',
6970 'playlist_mincount': 1,
6974 # The test suite does not have support for nested playlists
6976 # 'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
6982 'url': 'https://www.youtube.com/results?search_query=kurzgesagt&sp=EgIQAg%253D%253D',
6985 'title': 'kurzgesagt',
6990 'id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6991 'url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6992 'ie_key': 'YoutubeTab',
6993 'channel': 'Kurzgesagt – In a Nutshell',
6994 'description': 'md5:4ae48dfa9505ffc307dad26342d06bfc',
6995 'title': 'Kurzgesagt – In a Nutshell',
6996 'channel_id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6997 # No longer available for search as it is set to the handle.
6998 # 'playlist_count': int,
6999 'channel_url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
7001 'uploader_id': '@kurzgesagt',
7002 'uploader_url': 'https://www.youtube.com/@kurzgesagt',
7003 'uploader': 'Kurzgesagt – In a Nutshell',
7004 'channel_is_verified': True,
7005 'channel_follower_count': int,
7008 'params': {'extract_flat': True, 'playlist_items': '1'}
,
7009 'playlist_mincount': 1,
7011 'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
7012 'only_matching': True,
7015 def _real_extract(self
, url
):
7017 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7018 return self
.playlist_result(self
._search
_results
(query
, qs
.get('sp', (None,))[0]), query
, query
)
7021 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor
):
7022 IE_DESC
= 'YouTube music search URLs with selectable sections, e.g. #songs'
7023 IE_NAME
= 'youtube:music:search_url'
7024 _VALID_URL
= r
'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
7026 'url': 'https://music.youtube.com/search?q=royalty+free+music',
7027 'playlist_count': 16,
7029 'id': 'royalty free music',
7030 'title': 'royalty free music',
7033 'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
7034 'playlist_mincount': 30,
7036 'id': 'royalty free music - songs',
7037 'title': 'royalty free music - songs',
7039 'params': {'extract_flat': 'in_playlist'}
7041 'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
7042 'playlist_mincount': 30,
7044 'id': 'royalty free music - community playlists',
7045 'title': 'royalty free music - community playlists',
7047 'params': {'extract_flat': 'in_playlist'}
7051 'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
7052 'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
7053 'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
7054 'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
7055 'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
7056 'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
7059 def _real_extract(self
, url
):
7061 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7062 params
= qs
.get('sp', (None,))[0]
7064 section
= next((k
for k
, v
in self
._SECTIONS
.items() if v
== params
), params
)
7066 section
= urllib
.parse
.unquote_plus((url
.split('#') + [''])[1]).lower()
7067 params
= self
._SECTIONS
.get(section
)
7070 title
= join_nonempty(query
, section
, delim
=' - ')
7071 return self
.playlist_result(self
._search
_results
(query
, params
, default_client
='web_music'), title
, title
)
7074 class YoutubeFeedsInfoExtractor(InfoExtractor
):
7076 Base class for feed extractors
7077 Subclasses must re-define the _FEED_NAME property.
7079 _LOGIN_REQUIRED
= True
7080 _FEED_NAME
= 'feeds'
7082 def _real_initialize(self
):
7083 YoutubeBaseInfoExtractor
._check
_login
_required
(self
)
7087 return f
'youtube:{self._FEED_NAME}'
7089 def _real_extract(self
, url
):
7090 return self
.url_result(
7091 f
'https://www.youtube.com/feed/{self._FEED_NAME}', ie
=YoutubeTabIE
.ie_key())
7094 class YoutubeWatchLaterIE(InfoExtractor
):
7095 IE_NAME
= 'youtube:watchlater'
7096 IE_DESC
= 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
7097 _VALID_URL
= r
':ytwatchlater'
7099 'url': ':ytwatchlater',
7100 'only_matching': True,
7103 def _real_extract(self
, url
):
7104 return self
.url_result(
7105 'https://www.youtube.com/playlist?list=WL', ie
=YoutubeTabIE
.ie_key())
7108 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor
):
7109 IE_DESC
= 'YouTube recommended videos; ":ytrec" keyword'
7110 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
7111 _FEED_NAME
= 'recommended'
7112 _LOGIN_REQUIRED
= False
7115 'only_matching': True,
7117 'url': ':ytrecommended',
7118 'only_matching': True,
7120 'url': 'https://youtube.com',
7121 'only_matching': True,
7125 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor
):
7126 IE_DESC
= 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
7127 _VALID_URL
= r
':ytsub(?:scription)?s?'
7128 _FEED_NAME
= 'subscriptions'
7131 'only_matching': True,
7133 'url': ':ytsubscriptions',
7134 'only_matching': True,
7138 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor
):
7139 IE_DESC
= 'Youtube watch history; ":ythis" keyword (requires cookies)'
7140 _VALID_URL
= r
':ythis(?:tory)?'
7141 _FEED_NAME
= 'history'
7143 'url': ':ythistory',
7144 'only_matching': True,
7148 class YoutubeStoriesIE(InfoExtractor
):
7149 IE_DESC
= 'YouTube channel stories; "ytstories:" prefix'
7150 IE_NAME
= 'youtube:stories'
7151 _VALID_URL
= r
'ytstories:UC(?P<id>[A-Za-z0-9_-]{21}[AQgw])$'
7153 'url': 'ytstories:UCwFCb4jeqaKWnciAYM-ZVHg',
7154 'only_matching': True,
7157 def _real_extract(self
, url
):
7158 playlist_id
= f
'RLTD{self._match_id(url)}'
7159 return self
.url_result(
7160 smuggle_url(f
'https://www.youtube.com/playlist?list={playlist_id}&playnext=1', {'is_story': True}
),
7161 ie
=YoutubeTabIE
, video_id
=playlist_id
)
7164 class YoutubeShortsAudioPivotIE(InfoExtractor
):
7165 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
7166 IE_NAME
= 'youtube:shorts:pivot:audio'
7167 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
7169 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
7170 'only_matching': True,
7174 def _generate_audio_pivot_params(video_id
):
7176 Generates sfv_audio_pivot browse params for this video id
7178 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
7179 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
7181 def _real_extract(self
, url
):
7182 video_id
= self
._match
_id
(url
)
7183 return self
.url_result(
7184 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
7188 class YoutubeTruncatedURLIE(InfoExtractor
):
7189 IE_NAME
= 'youtube:truncated_url'
7190 IE_DESC
= False # Do not list
7191 _VALID_URL
= r
'''(?x)
7193 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
7196 annotation_id=annotation_[^&]+|
7202 attribution_link\?a=[^&]+
7208 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
7209 'only_matching': True,
7211 'url': 'https://www.youtube.com/watch?',
7212 'only_matching': True,
7214 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
7215 'only_matching': True,
7217 'url': 'https://www.youtube.com/watch?feature=foo',
7218 'only_matching': True,
7220 'url': 'https://www.youtube.com/watch?hl=en-GB',
7221 'only_matching': True,
7223 'url': 'https://www.youtube.com/watch?t=2372',
7224 'only_matching': True,
7227 def _real_extract(self
, url
):
7228 raise ExtractorError(
7229 'Did you forget to quote the URL? Remember that & is a meta '
7230 'character in most shells, so you want to put the URL in quotes, '
7232 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
7233 ' or simply youtube-dl BaW_jenozKc .',
7237 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
7238 IE_NAME
= 'youtube:clip'
7239 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7241 # FIXME: Other metadata should be extracted from the clip, not from the base video
7242 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7244 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7246 'section_start': 29.0,
7247 'section_end': 39.7,
7250 'availability': 'public',
7251 'categories': ['Gaming'],
7252 'channel': 'Scott The Woz',
7253 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7254 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7255 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7257 'playable_in_embed': True,
7259 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7260 'title': 'Mobile Games on Console - Scott The Woz',
7261 'upload_date': '20210920',
7262 'uploader': 'Scott The Woz',
7263 'uploader_id': '@ScottTheWoz',
7264 'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7266 'live_status': 'not_live',
7267 'channel_follower_count': int,
7268 'chapters': 'count:20',
7269 'comment_count': int,
7270 'heatmap': 'count:100',
7274 def _real_extract(self
, url
):
7275 clip_id
= self
._match
_id
(url
)
7276 _
, data
= self
._extract
_webpage
(url
, clip_id
)
7278 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7280 raise ExtractorError('Unable to find video ID')
7282 clip_data
= traverse_obj(data
, (
7283 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7284 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7285 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7286 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
7289 '_type': 'url_transparent',
7290 'url': f
'https://www.youtube.com/watch?v={video_id}',
7291 'ie_key': YoutubeIE
.ie_key(),
7293 'section_start': int(clip_data
['startTimeMs']) / 1000,
7294 'section_end': int(clip_data
['endTimeMs']) / 1000,
7298 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor
):
7299 IE_NAME
= 'youtube:consent'
7300 IE_DESC
= False # Do not list
7301 _VALID_URL
= r
'https?://consent\.youtube\.com/m\?'
7303 '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',
7305 'id': 'qVv6vCqciTM',
7308 'uploader_id': '@sana_natori',
7309 'comment_count': int,
7310 'chapters': 'count:13',
7311 'upload_date': '20221223',
7312 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7313 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7314 'uploader_url': 'https://www.youtube.com/@sana_natori',
7316 'release_date': '20221223',
7317 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7318 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7320 'playable_in_embed': True,
7322 'availability': 'public',
7323 'channel_follower_count': int,
7324 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7325 'categories': ['Entertainment'],
7326 'live_status': 'was_live',
7327 'release_timestamp': 1671793345,
7328 'channel': 'さなちゃんねる',
7329 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7330 'uploader': 'さなちゃんねる',
7331 'channel_is_verified': True,
7332 'heatmap': 'count:100',
7334 'add_ie': ['Youtube'],
7335 'params': {'skip_download': 'Youtube'}
,
7338 def _real_extract(self
, url
):
7339 redirect_url
= url_or_none(parse_qs(url
).get('continue', [None])[-1])
7340 if not redirect_url
:
7341 raise ExtractorError('Invalid cookie consent redirect URL', expected
=True)
7342 return self
.url_result(redirect_url
)
7345 class YoutubeTruncatedIDIE(InfoExtractor
):
7346 IE_NAME
= 'youtube:truncated_id'
7347 IE_DESC
= False # Do not list
7348 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7351 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7352 'only_matching': True,
7355 def _real_extract(self
, url
):
7356 video_id
= self
._match
_id
(url
)
7357 raise ExtractorError(
7358 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',