20 from .common
import InfoExtractor
, SearchInfoExtractor
21 from .openload
import PhantomJSwrapper
22 from ..compat
import functools
23 from ..jsinterp
import JSInterpreter
24 from ..networking
.exceptions
import HTTPError
, network_exceptions
68 STREAMING_DATA_CLIENT_NAME
= '__yt_dlp_client'
69 # any clients starting with _ cannot be explicitly requested by the user
72 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
73 'INNERTUBE_CONTEXT': {
76 'clientVersion': '2.20220801.00.00',
79 'INNERTUBE_CONTEXT_CLIENT_NAME': 1
82 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
83 'INNERTUBE_CONTEXT': {
85 'clientName': 'WEB_EMBEDDED_PLAYER',
86 'clientVersion': '1.20220731.00.00',
89 'INNERTUBE_CONTEXT_CLIENT_NAME': 56
92 'INNERTUBE_API_KEY': 'AIzaSyC9XL3ZjWddXya6X74dJoCTL-WEYFDNX30',
93 'INNERTUBE_HOST': 'music.youtube.com',
94 'INNERTUBE_CONTEXT': {
96 'clientName': 'WEB_REMIX',
97 'clientVersion': '1.20220727.01.00',
100 'INNERTUBE_CONTEXT_CLIENT_NAME': 67,
103 'INNERTUBE_API_KEY': 'AIzaSyBUPetSUmoZL-OhlxA7wSac5XinrygCqMo',
104 'INNERTUBE_CONTEXT': {
106 'clientName': 'WEB_CREATOR',
107 'clientVersion': '1.20220726.00.00',
110 'INNERTUBE_CONTEXT_CLIENT_NAME': 62,
113 'INNERTUBE_API_KEY': 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w',
114 'INNERTUBE_CONTEXT': {
116 'clientName': 'ANDROID',
117 'clientVersion': '17.31.35',
118 'androidSdkVersion': 30,
119 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
122 'INNERTUBE_CONTEXT_CLIENT_NAME': 3,
123 'REQUIRE_JS_PLAYER': False
125 'android_embedded': {
126 'INNERTUBE_API_KEY': 'AIzaSyCjc_pVEDi4qsv5MtC2dMXzpIaDoRFLsxw',
127 'INNERTUBE_CONTEXT': {
129 'clientName': 'ANDROID_EMBEDDED_PLAYER',
130 'clientVersion': '17.31.35',
131 'androidSdkVersion': 30,
132 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
135 'INNERTUBE_CONTEXT_CLIENT_NAME': 55,
136 'REQUIRE_JS_PLAYER': False
139 'INNERTUBE_API_KEY': 'AIzaSyAOghZGza2MQSZkY_zfZ370N-PUdXEo8AI',
140 'INNERTUBE_CONTEXT': {
142 'clientName': 'ANDROID_MUSIC',
143 'clientVersion': '5.16.51',
144 'androidSdkVersion': 30,
145 'userAgent': 'com.google.android.apps.youtube.music/5.16.51 (Linux; U; Android 11) gzip'
148 'INNERTUBE_CONTEXT_CLIENT_NAME': 21,
149 'REQUIRE_JS_PLAYER': False
152 'INNERTUBE_API_KEY': 'AIzaSyD_qjV8zaaUMehtLkrKFgVeSX_Iqbtyws8',
153 'INNERTUBE_CONTEXT': {
155 'clientName': 'ANDROID_CREATOR',
156 'clientVersion': '22.30.100',
157 'androidSdkVersion': 30,
158 'userAgent': 'com.google.android.apps.youtube.creator/22.30.100 (Linux; U; Android 11) gzip'
161 'INNERTUBE_CONTEXT_CLIENT_NAME': 14,
162 'REQUIRE_JS_PLAYER': False
164 # iOS clients have HLS live streams. Setting device model to get 60fps formats.
165 # See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/680#issuecomment-1002724558
167 'INNERTUBE_API_KEY': 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc',
168 'INNERTUBE_CONTEXT': {
171 'clientVersion': '17.33.2',
172 'deviceModel': 'iPhone14,3',
173 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
176 'INNERTUBE_CONTEXT_CLIENT_NAME': 5,
177 'REQUIRE_JS_PLAYER': False
180 'INNERTUBE_CONTEXT': {
182 'clientName': 'IOS_MESSAGES_EXTENSION',
183 'clientVersion': '17.33.2',
184 'deviceModel': 'iPhone14,3',
185 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
188 'INNERTUBE_CONTEXT_CLIENT_NAME': 66,
189 'REQUIRE_JS_PLAYER': False
192 'INNERTUBE_API_KEY': 'AIzaSyBAETezhkwP0ZWA02RsqT1zu78Fpt0bC_s',
193 'INNERTUBE_CONTEXT': {
195 'clientName': 'IOS_MUSIC',
196 'clientVersion': '5.21',
197 'deviceModel': 'iPhone14,3',
198 'userAgent': 'com.google.ios.youtubemusic/5.21 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
201 'INNERTUBE_CONTEXT_CLIENT_NAME': 26,
202 'REQUIRE_JS_PLAYER': False
205 'INNERTUBE_CONTEXT': {
207 'clientName': 'IOS_CREATOR',
208 'clientVersion': '22.33.101',
209 'deviceModel': 'iPhone14,3',
210 'userAgent': 'com.google.ios.ytcreator/22.33.101 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
213 'INNERTUBE_CONTEXT_CLIENT_NAME': 15,
214 'REQUIRE_JS_PLAYER': False
216 # mweb has 'ultralow' formats
217 # See: https://github.com/yt-dlp/yt-dlp/pull/557
219 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
220 'INNERTUBE_CONTEXT': {
222 'clientName': 'MWEB',
223 'clientVersion': '2.20220801.00.00',
226 'INNERTUBE_CONTEXT_CLIENT_NAME': 2
228 # This client can access age restricted videos (unless the uploader has disabled the 'allow embedding' option)
229 # See: https://github.com/zerodytrash/YouTube-Internal-Clients
231 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
232 'INNERTUBE_CONTEXT': {
234 'clientName': 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
235 'clientVersion': '2.0',
238 'INNERTUBE_CONTEXT_CLIENT_NAME': 85
243 def _split_innertube_client(client_name
):
244 variant
, *base
= client_name
.rsplit('.', 1)
246 return variant
, base
[0], variant
247 base
, *variant
= client_name
.split('_', 1)
248 return client_name
, base
, variant
[0] if variant
else None
251 def short_client_name(client_name
):
252 main
, *parts
= _split_innertube_client(client_name
)[0].replace('embedscreen', 'e_s').split('_')
253 return join_nonempty(main
[:4], ''.join(x
[0] for x
in parts
)).upper()
256 def build_innertube_clients():
258 'embedUrl': 'https://www.youtube.com/', # Can be any valid URL
260 BASE_CLIENTS
= ('ios', 'android', 'web', 'tv', 'mweb')
261 priority
= qualities(BASE_CLIENTS
[::-1])
263 for client
, ytcfg
in tuple(INNERTUBE_CLIENTS
.items()):
264 ytcfg
.setdefault('INNERTUBE_API_KEY', 'AIzaSyDCU8hByM-4DrUqRUYnGn-3llEO78bcxq8')
265 ytcfg
.setdefault('INNERTUBE_HOST', 'www.youtube.com')
266 ytcfg
.setdefault('REQUIRE_JS_PLAYER', True)
267 ytcfg
['INNERTUBE_CONTEXT']['client'].setdefault('hl', 'en')
269 _
, base_client
, variant
= _split_innertube_client(client
)
270 ytcfg
['priority'] = 10 * priority(base_client
)
273 INNERTUBE_CLIENTS
[f
'{client}_embedscreen'] = embedscreen
= copy
.deepcopy(ytcfg
)
274 embedscreen
['INNERTUBE_CONTEXT']['client']['clientScreen'] = 'EMBED'
275 embedscreen
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
276 embedscreen
['priority'] -= 3
277 elif variant
== 'embedded':
278 ytcfg
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
279 ytcfg
['priority'] -= 2
281 ytcfg
['priority'] -= 3
284 build_innertube_clients()
287 class BadgeType(enum
.Enum
):
288 AVAILABILITY_UNLISTED
= enum
.auto()
289 AVAILABILITY_PRIVATE
= enum
.auto()
290 AVAILABILITY_PUBLIC
= enum
.auto()
291 AVAILABILITY_PREMIUM
= enum
.auto()
292 AVAILABILITY_SUBSCRIPTION
= enum
.auto()
293 LIVE_NOW
= enum
.auto()
294 VERIFIED
= enum
.auto()
297 class YoutubeBaseInfoExtractor(InfoExtractor
):
298 """Provide base functions for Youtube extractors"""
301 r
'channel|c|user|playlist|watch|w|v|embed|e|live|watch_popup|clip|'
302 r
'shorts|movies|results|search|shared|hashtag|trending|explore|feed|feeds|'
303 r
'browse|oembed|get_video_info|iframe_api|s/player|source|'
304 r
'storefront|oops|index|account|t/terms|about|upload|signin|logout')
306 _PLAYLIST_ID_RE
= r
'(?:(?:PL|LL|EC|UU|FL|RD|UL|TL|PU|OLAK5uy_)[0-9A-Za-z-_]{10,}|RDMM|WL|LL|LM)'
308 # _NETRC_MACHINE = 'youtube'
310 # If True it will raise an error if no login info is provided
311 _LOGIN_REQUIRED
= False
314 # invidious-redirect websites
315 r
'(?:www\.)?redirect\.invidious\.io',
316 r
'(?:(?:www|dev)\.)?invidio\.us',
317 # Invidious instances taken from https://github.com/iv-org/documentation/blob/master/docs/instances.md
318 r
'(?:www\.)?invidious\.pussthecat\.org',
319 r
'(?:www\.)?invidious\.zee\.li',
320 r
'(?:www\.)?invidious\.ethibox\.fr',
321 r
'(?:www\.)?iv\.ggtyler\.dev',
322 r
'(?:www\.)?inv\.vern\.i2p',
323 r
'(?:www\.)?am74vkcrjp2d5v36lcdqgsj2m6x36tbrkhsruoegwfcizzabnfgf5zyd\.onion',
324 r
'(?:www\.)?inv\.riverside\.rocks',
325 r
'(?:www\.)?invidious\.silur\.me',
326 r
'(?:www\.)?inv\.bp\.projectsegfau\.lt',
327 r
'(?:www\.)?invidious\.g4c3eya4clenolymqbpgwz3q3tawoxw56yhzk4vugqrl6dtu3ejvhjid\.onion',
328 r
'(?:www\.)?invidious\.slipfox\.xyz',
329 r
'(?:www\.)?invidious\.esmail5pdn24shtvieloeedh7ehz3nrwcdivnfhfcedl7gf4kwddhkqd\.onion',
330 r
'(?:www\.)?inv\.vernccvbvyi5qhfzyqengccj7lkove6bjot2xhh5kajhwvidqafczrad\.onion',
331 r
'(?:www\.)?invidious\.tiekoetter\.com',
332 r
'(?:www\.)?iv\.odysfvr23q5wgt7i456o5t3trw2cw5dgn56vbjfbq2m7xsc5vqbqpcyd\.onion',
333 r
'(?:www\.)?invidious\.nerdvpn\.de',
334 r
'(?:www\.)?invidious\.weblibre\.org',
335 r
'(?:www\.)?inv\.odyssey346\.dev',
336 r
'(?:www\.)?invidious\.dhusch\.de',
337 r
'(?:www\.)?iv\.melmac\.space',
338 r
'(?:www\.)?watch\.thekitty\.zone',
339 r
'(?:www\.)?invidious\.privacydev\.net',
340 r
'(?:www\.)?ng27owmagn5amdm7l5s3rsqxwscl5ynppnis5dqcasogkyxcfqn7psid\.onion',
341 r
'(?:www\.)?invidious\.drivet\.xyz',
342 r
'(?:www\.)?vid\.priv\.au',
343 r
'(?:www\.)?euxxcnhsynwmfidvhjf6uzptsmh4dipkmgdmcmxxuo7tunp3ad2jrwyd\.onion',
344 r
'(?:www\.)?inv\.vern\.cc',
345 r
'(?:www\.)?invidious\.esmailelbob\.xyz',
346 r
'(?:www\.)?invidious\.sethforprivacy\.com',
347 r
'(?:www\.)?yt\.oelrichsgarcia\.de',
348 r
'(?:www\.)?yt\.artemislena\.eu',
349 r
'(?:www\.)?invidious\.flokinet\.to',
350 r
'(?:www\.)?invidious\.baczek\.me',
351 r
'(?:www\.)?y\.com\.sb',
352 r
'(?:www\.)?invidious\.epicsite\.xyz',
353 r
'(?:www\.)?invidious\.lidarshield\.cloud',
354 r
'(?:www\.)?yt\.funami\.tech',
355 r
'(?:www\.)?invidious\.3o7z6yfxhbw7n3za4rss6l434kmv55cgw2vuziwuigpwegswvwzqipyd\.onion',
356 r
'(?:www\.)?osbivz6guyeahrwp2lnwyjk2xos342h4ocsxyqrlaopqjuhwn2djiiyd\.onion',
357 r
'(?:www\.)?u2cvlit75owumwpy4dj2hsmvkq7nvrclkpht7xgyye2pyoxhpmclkrad\.onion',
358 # youtube-dl invidious instances list
359 r
'(?:(?:www|no)\.)?invidiou\.sh',
360 r
'(?:(?:www|fi)\.)?invidious\.snopyta\.org',
361 r
'(?:www\.)?invidious\.kabi\.tk',
362 r
'(?:www\.)?invidious\.mastodon\.host',
363 r
'(?:www\.)?invidious\.zapashcanon\.fr',
364 r
'(?:www\.)?(?:invidious(?:-us)?|piped)\.kavin\.rocks',
365 r
'(?:www\.)?invidious\.tinfoil-hat\.net',
366 r
'(?:www\.)?invidious\.himiko\.cloud',
367 r
'(?:www\.)?invidious\.reallyancient\.tech',
368 r
'(?:www\.)?invidious\.tube',
369 r
'(?:www\.)?invidiou\.site',
370 r
'(?:www\.)?invidious\.site',
371 r
'(?:www\.)?invidious\.xyz',
372 r
'(?:www\.)?invidious\.nixnet\.xyz',
373 r
'(?:www\.)?invidious\.048596\.xyz',
374 r
'(?:www\.)?invidious\.drycat\.fr',
375 r
'(?:www\.)?inv\.skyn3t\.in',
376 r
'(?:www\.)?tube\.poal\.co',
377 r
'(?:www\.)?tube\.connect\.cafe',
378 r
'(?:www\.)?vid\.wxzm\.sx',
379 r
'(?:www\.)?vid\.mint\.lgbt',
380 r
'(?:www\.)?vid\.puffyan\.us',
381 r
'(?:www\.)?yewtu\.be',
382 r
'(?:www\.)?yt\.elukerio\.org',
383 r
'(?:www\.)?yt\.lelux\.fi',
384 r
'(?:www\.)?invidious\.ggc-project\.de',
385 r
'(?:www\.)?yt\.maisputain\.ovh',
386 r
'(?:www\.)?ytprivate\.com',
387 r
'(?:www\.)?invidious\.13ad\.de',
388 r
'(?:www\.)?invidious\.toot\.koeln',
389 r
'(?:www\.)?invidious\.fdn\.fr',
390 r
'(?:www\.)?watch\.nettohikari\.com',
391 r
'(?:www\.)?invidious\.namazso\.eu',
392 r
'(?:www\.)?invidious\.silkky\.cloud',
393 r
'(?:www\.)?invidious\.exonip\.de',
394 r
'(?:www\.)?invidious\.riverside\.rocks',
395 r
'(?:www\.)?invidious\.blamefran\.net',
396 r
'(?:www\.)?invidious\.moomoo\.de',
397 r
'(?:www\.)?ytb\.trom\.tf',
398 r
'(?:www\.)?yt\.cyberhost\.uk',
399 r
'(?:www\.)?kgg2m7yk5aybusll\.onion',
400 r
'(?:www\.)?qklhadlycap4cnod\.onion',
401 r
'(?:www\.)?axqzx4s6s54s32yentfqojs3x5i7faxza6xo3ehd4bzzsg2ii4fv2iid\.onion',
402 r
'(?:www\.)?c7hqkpkpemu6e7emz5b4vyz7idjgdvgaaa3dyimmeojqbgpea3xqjoid\.onion',
403 r
'(?:www\.)?fz253lmuao3strwbfbmx46yu7acac2jz27iwtorgmbqlkurlclmancad\.onion',
404 r
'(?:www\.)?invidious\.l4qlywnpwqsluw65ts7md3khrivpirse744un3x7mlskqauz5pyuzgqd\.onion',
405 r
'(?:www\.)?owxfohz4kjyv25fvlqilyxast7inivgiktls3th44jhk3ej3i7ya\.b32\.i2p',
406 r
'(?:www\.)?4l2dgddgsrkf2ous66i6seeyi6etzfgrue332grh2n7madpwopotugyd\.onion',
407 r
'(?:www\.)?w6ijuptxiku4xpnnaetxvnkc5vqcdu7mgns2u77qefoixi63vbvnpnqd\.onion',
408 r
'(?:www\.)?kbjggqkzv65ivcqj6bumvp337z6264huv5kpkwuv6gu5yjiskvan7fad\.onion',
409 r
'(?:www\.)?grwp24hodrefzvjjuccrkw3mjq4tzhaaq32amf33dzpmuxe7ilepcmad\.onion',
410 r
'(?:www\.)?hpniueoejy4opn7bc4ftgazyqjoeqwlvh2uiku2xqku6zpoa4bf5ruid\.onion',
411 # piped instances from https://github.com/TeamPiped/Piped/wiki/Instances
412 r
'(?:www\.)?piped\.kavin\.rocks',
413 r
'(?:www\.)?piped\.tokhmi\.xyz',
414 r
'(?:www\.)?piped\.syncpundit\.io',
415 r
'(?:www\.)?piped\.mha\.fi',
416 r
'(?:www\.)?watch\.whatever\.social',
417 r
'(?:www\.)?piped\.garudalinux\.org',
418 r
'(?:www\.)?piped\.rivo\.lol',
419 r
'(?:www\.)?piped-libre\.kavin\.rocks',
420 r
'(?:www\.)?yt\.jae\.fi',
421 r
'(?:www\.)?piped\.mint\.lgbt',
423 r
'(?:www\.)?piped\.esmailelbob\.xyz',
424 r
'(?:www\.)?piped\.projectsegfau\.lt',
425 r
'(?:www\.)?piped\.privacydev\.net',
426 r
'(?:www\.)?piped\.palveluntarjoaja\.eu',
427 r
'(?:www\.)?piped\.smnz\.de',
428 r
'(?:www\.)?piped\.adminforge\.de',
429 r
'(?:www\.)?watch\.whatevertinfoil\.de',
430 r
'(?:www\.)?piped\.qdi\.fi',
431 r
'(?:www\.)?piped\.video',
432 r
'(?:www\.)?piped\.aeong\.one',
433 r
'(?:www\.)?piped\.moomoo\.me',
434 r
'(?:www\.)?piped\.chauvet\.pro',
435 r
'(?:www\.)?watch\.leptons\.xyz',
436 r
'(?:www\.)?pd\.vern\.cc',
437 r
'(?:www\.)?piped\.hostux\.net',
438 r
'(?:www\.)?piped\.lunar\.icu',
439 # Hyperpipe instances from https://hyperpipe.codeberg.page/
440 r
'(?:www\.)?hyperpipe\.surge\.sh',
441 r
'(?:www\.)?hyperpipe\.esmailelbob\.xyz',
442 r
'(?:www\.)?listen\.whatever\.social',
443 r
'(?:www\.)?music\.adminforge\.de',
446 # extracted from account/account_menu ep
447 # XXX: These are the supported YouTube UI and API languages,
448 # which is slightly different from languages supported for translation in YouTube studio
449 _SUPPORTED_LANG_CODES
= [
450 'af', 'az', 'id', 'ms', 'bs', 'ca', 'cs', 'da', 'de', 'et', 'en-IN', 'en-GB', 'en', 'es',
451 'es-419', 'es-US', 'eu', 'fil', 'fr', 'fr-CA', 'gl', 'hr', 'zu', 'is', 'it', 'sw', 'lv',
452 'lt', 'hu', 'nl', 'no', 'uz', 'pl', 'pt-PT', 'pt', 'ro', 'sq', 'sk', 'sl', 'sr-Latn', 'fi',
453 'sv', 'vi', 'tr', 'be', 'bg', 'ky', 'kk', 'mk', 'mn', 'ru', 'sr', 'uk', 'el', 'hy', 'iw',
454 'ur', 'ar', 'fa', 'ne', 'mr', 'hi', 'as', 'bn', 'pa', 'gu', 'or', 'ta', 'te', 'kn', 'ml',
455 'si', 'th', 'lo', 'my', 'ka', 'am', 'km', 'zh-CN', 'zh-TW', 'zh-HK', 'ja', 'ko'
458 _IGNORED_WARNINGS
= {'Unavailable videos will be hidden during playback'}
460 _YT_HANDLE_RE
= r
'@[\w.-]{3,30}' # https://support.google.com/youtube/answer/11585688?hl=en
461 _YT_CHANNEL_UCID_RE
= r
'UC[\w-]{22}'
463 def ucid_or_none(self
, ucid
):
464 return self
._search
_regex
(rf
'^({self._YT_CHANNEL_UCID_RE})$', ucid
, 'UC-id', default
=None)
466 def handle_or_none(self
, handle
):
467 return self
._search
_regex
(rf
'^({self._YT_HANDLE_RE})$', handle
, '@-handle', default
=None)
469 def handle_from_url(self
, url
):
470 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_HANDLE_RE})',
471 url
, 'channel handle', default
=None)
473 def ucid_from_url(self
, url
):
474 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_CHANNEL_UCID_RE})',
475 url
, 'channel id', default
=None)
477 @functools.cached_property
478 def _preferred_lang(self
):
480 Returns a language code supported by YouTube for the user preferred language.
481 Returns None if no preferred language set.
483 preferred_lang
= self
._configuration
_arg
('lang', ie_key
='Youtube', casesense
=True, default
=[''])[0]
484 if not preferred_lang
:
486 if preferred_lang
not in self
._SUPPORTED
_LANG
_CODES
:
487 raise ExtractorError(
488 f
'Unsupported language code: {preferred_lang}. Supported language codes (case-sensitive): {join_nonempty(*self._SUPPORTED_LANG_CODES, delim=", ")}.',
490 elif preferred_lang
!= 'en':
492 f
'Preferring "{preferred_lang}" translated fields. Note that some metadata extraction may fail or be incorrect.')
493 return preferred_lang
495 def _initialize_consent(self
):
496 cookies
= self
._get
_cookies
('https://www.youtube.com/')
497 if cookies
.get('__Secure-3PSID'):
499 socs
= cookies
.get('SOCS')
500 if socs
and not socs
.value
.startswith('CAA'): # not consented
502 self
._set
_cookie
('.youtube.com', 'SOCS', 'CAI', secure
=True) # accept all (required for mixes)
504 def _initialize_pref(self
):
505 cookies
= self
._get
_cookies
('https://www.youtube.com/')
506 pref_cookie
= cookies
.get('PREF')
510 pref
= dict(urllib
.parse
.parse_qsl(pref_cookie
.value
))
512 self
.report_warning('Failed to parse user PREF cookie' + bug_reports_message())
513 pref
.update({'hl': self._preferred_lang or 'en', 'tz': 'UTC'}
)
514 self
._set
_cookie
('.youtube.com', name
='PREF', value
=urllib
.parse
.urlencode(pref
))
516 def _real_initialize(self
):
517 self
._initialize
_pref
()
518 self
._initialize
_consent
()
519 self
._check
_login
_required
()
521 def _check_login_required(self
):
522 if self
._LOGIN
_REQUIRED
and not self
._cookies
_passed
:
523 self
.raise_login_required('Login details are needed to download this content', method
='cookies')
525 _YT_INITIAL_DATA_RE
= r
'(?:window\s*\[\s*["\']ytInitialData
["\']\s*\]|ytInitialData)\s*='
526 _YT_INITIAL_PLAYER_RESPONSE_RE = r'ytInitialPlayerResponse\s*='
528 def _get_default_ytcfg(self, client='web'):
529 return copy.deepcopy(INNERTUBE_CLIENTS[client])
531 def _get_innertube_host(self, client='web'):
532 return INNERTUBE_CLIENTS[client]['INNERTUBE_HOST']
534 def _ytcfg_get_safe(self, ytcfg, getter, expected_type=None, default_client='web'):
535 # try_get but with fallback to default ytcfg client values when present
536 _func = lambda y: try_get(y, getter, expected_type)
537 return _func(ytcfg) or _func(self._get_default_ytcfg(default_client))
539 def _extract_client_name(self, ytcfg, default_client='web'):
540 return self._ytcfg_get_safe(
541 ytcfg, (lambda x: x['INNERTUBE_CLIENT_NAME'],
542 lambda x: x['INNERTUBE_CONTEXT']['client']['clientName']), str, default_client)
544 def _extract_client_version(self, ytcfg, default_client='web'):
545 return self._ytcfg_get_safe(
546 ytcfg, (lambda x: x['INNERTUBE_CLIENT_VERSION'],
547 lambda x: x['INNERTUBE_CONTEXT']['client']['clientVersion']), str, default_client)
549 def _select_api_hostname(self, req_api_hostname, default_client=None):
550 return (self._configuration_arg('innertube_host', [''], ie_key=YoutubeIE.ie_key())[0]
551 or req_api_hostname or self._get_innertube_host(default_client or 'web'))
553 def _extract_api_key(self, ytcfg=None, default_client='web'):
554 return self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_API_KEY'], str, default_client)
556 def _extract_context(self, ytcfg=None, default_client='web'):
558 (ytcfg, self._get_default_ytcfg(default_client)), 'INNERTUBE_CONTEXT', expected_type=dict)
559 # Enforce language and tz for extraction
560 client_context = traverse_obj(context, 'client', expected_type=dict, default={})
561 client_context.update({'hl': self._preferred_lang or 'en', 'timeZone': 'UTC', 'utcOffsetMinutes': 0})
566 def _generate_sapisidhash_header(self, origin='https://www.youtube.com'):
567 time_now = round(time.time())
568 if self._SAPISID is None:
569 yt_cookies = self._get_cookies('https://www.youtube.com')
570 # Sometimes SAPISID cookie isn't present but __Secure-3PAPISID is.
571 # See: https://github.com/yt-dlp/yt-dlp/issues/393
572 sapisid_cookie = dict_get(
573 yt_cookies, ('__Secure-3PAPISID', 'SAPISID'))
574 if sapisid_cookie and sapisid_cookie.value:
575 self._SAPISID = sapisid_cookie.value
576 self.write_debug('Extracted SAPISID cookie')
577 # SAPISID cookie is required if not already present
578 if not yt_cookies.get('SAPISID'):
579 self.write_debug('Copying __Secure-3PAPISID cookie to SAPISID cookie')
581 '.youtube.com', 'SAPISID', self._SAPISID, secure=True, expire_time=time_now + 3600)
583 self._SAPISID = False
584 if not self._SAPISID:
586 # SAPISIDHASH algorithm from https://stackoverflow.com/a/32065323
587 sapisidhash = hashlib.sha1(
588 f'{time_now} {self._SAPISID} {origin}'.encode()).hexdigest()
589 return f'SAPISIDHASH {time_now}_{sapisidhash}'
591 def _call_api(self, ep, query, video_id, fatal=True, headers=None,
592 note='Downloading API JSON', errnote='Unable to download API page',
593 context=None, api_key=None, api_hostname=None, default_client='web'):
595 data = {'context': context} if context else {'context': self._extract_context(default_client=default_client)}
597 real_headers = self.generate_api_headers(default_client=default_client)
598 real_headers.update({'content-type': 'application/json'})
600 real_headers.update(headers)
601 api_key = (self._configuration_arg('innertube_key', [''], ie_key=YoutubeIE.ie_key(), casesense=True)[0]
602 or api_key or self._extract_api_key(default_client=default_client))
603 return self._download_json(
604 f'https://{self._select_api_hostname(api_hostname, default_client)}/youtubei/v1/{ep}',
605 video_id=video_id, fatal=fatal, note=note, errnote=errnote,
606 data=json.dumps(data).encode('utf8'), headers=real_headers,
607 query={'key': api_key, 'prettyPrint': 'false'})
609 def extract_yt_initial_data(self, item_id, webpage, fatal=True):
610 return self._search_json(self._YT_INITIAL_DATA_RE, webpage, 'yt initial data', item_id, fatal=fatal)
613 def _extract_session_index(*data):
615 Index of current account in account list.
616 See: https://github.com/yt-dlp/yt-dlp/pull/519
619 session_index = int_or_none(try_get(ytcfg, lambda x: x['SESSION_INDEX']))
620 if session_index is not None:
624 def _extract_identity_token(self, ytcfg=None, webpage=None):
626 token = try_get(ytcfg, lambda x: x['ID_TOKEN'], str)
630 return self._search_regex(
631 r'\bID_TOKEN["\']\s
*:\s
*["\'](.+?)["\']', webpage,
632 'identity token
', default=None, fatal=False)
635 def _extract_account_syncid(*args):
637 Extract syncId required to download private playlists of secondary channels
638 @params response and/or ytcfg
641 # ytcfg includes channel_syncid if on secondary channel
642 delegated_sid = try_get(data, lambda x: x['DELEGATED_SESSION_ID
'], str)
646 data, (lambda x: x['responseContext
']['mainAppWebResponseContext
']['datasyncId
'],
647 lambda x: x['DATASYNC_ID
']), str) or '').split('||
')
648 if len(sync_ids) >= 2 and sync_ids[1]:
649 # datasyncid is of the form "channel_syncid||user_syncid" for secondary channel
650 # and just "user_syncid||" for primary channel. We only want the channel_syncid
654 def _extract_visitor_data(*args):
656 Extracts visitorData from an API response or ytcfg
657 Appears to be used to track session state
660 args, [('VISITOR_DATA
', ('INNERTUBE_CONTEXT
', 'client
', 'visitorData
'), ('responseContext
', 'visitorData
'))],
663 @functools.cached_property
664 def is_authenticated(self):
665 return bool(self._generate_sapisidhash_header())
667 def extract_ytcfg(self, video_id, webpage):
670 return self._parse_json(
672 r'ytcfg\
.set\s
*\
(\s
*({.+?}
)\s
*\
)\s
*;', webpage, 'ytcfg
',
673 default='{}'), video_id, fatal=False) or {}
675 def generate_api_headers(
676 self
, *, ytcfg
=None, account_syncid
=None, session_index
=None,
677 visitor_data
=None, identity_token
=None, api_hostname
=None, default_client
='web'):
679 origin
= 'https://' + (self
._select
_api
_hostname
(api_hostname
, default_client
))
681 'X-YouTube-Client-Name': str(
682 self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT_CLIENT_NAME'], default_client
=default_client
)),
683 'X-YouTube-Client-Version': self
._extract
_client
_version
(ytcfg
, default_client
),
685 'X-Youtube-Identity-Token': identity_token
or self
._extract
_identity
_token
(ytcfg
),
686 'X-Goog-PageId': account_syncid
or self
._extract
_account
_syncid
(ytcfg
),
687 'X-Goog-Visitor-Id': visitor_data
or self
._extract
_visitor
_data
(ytcfg
),
688 'User-Agent': self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT']['client']['userAgent'], default_client
=default_client
)
690 if session_index
is None:
691 session_index
= self
._extract
_session
_index
(ytcfg
)
692 if account_syncid
or session_index
is not None:
693 headers
['X-Goog-AuthUser'] = session_index
if session_index
is not None else 0
695 auth
= self
._generate
_sapisidhash
_header
(origin
)
697 headers
['Authorization'] = auth
698 headers
['X-Origin'] = origin
699 return filter_dict(headers
)
701 def _download_ytcfg(self
, client
, video_id
):
703 'web': 'https://www.youtube.com',
704 'web_music': 'https://music.youtube.com',
705 'web_embedded': f
'https://www.youtube.com/embed/{video_id}?html5=1'
709 webpage
= self
._download
_webpage
(
710 url
, video_id
, fatal
=False, note
=f
'Downloading {client.replace("_", " ").strip()} client config')
711 return self
.extract_ytcfg(video_id
, webpage
) or {}
714 def _build_api_continuation_query(continuation
, ctp
=None):
716 'continuation': continuation
718 # TODO: Inconsistency with clickTrackingParams.
719 # Currently we have a fixed ctp contained within context (from ytcfg)
720 # and a ctp in root query for continuation.
722 query
['clickTracking'] = {'clickTrackingParams': ctp}
726 def _extract_next_continuation_data(cls
, renderer
):
727 next_continuation
= try_get(
728 renderer
, (lambda x
: x
['continuations'][0]['nextContinuationData'],
729 lambda x
: x
['continuation']['reloadContinuationData']), dict)
730 if not next_continuation
:
732 continuation
= next_continuation
.get('continuation')
735 ctp
= next_continuation
.get('clickTrackingParams')
736 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
739 def _extract_continuation_ep_data(cls
, continuation_ep
: dict):
740 if isinstance(continuation_ep
, dict):
741 continuation
= try_get(
742 continuation_ep
, lambda x
: x
['continuationCommand']['token'], str)
745 ctp
= continuation_ep
.get('clickTrackingParams')
746 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
749 def _extract_continuation(cls
, renderer
):
750 next_continuation
= cls
._extract
_next
_continuation
_data
(renderer
)
751 if next_continuation
:
752 return next_continuation
754 return traverse_obj(renderer
, (
755 ('contents', 'items', 'rows'), ..., 'continuationItemRenderer',
756 ('continuationEndpoint', ('button', 'buttonRenderer', 'command'))
757 ), get_all
=False, expected_type
=cls
._extract
_continuation
_ep
_data
)
760 def _extract_alerts(cls
, data
):
761 for alert_dict
in try_get(data
, lambda x
: x
['alerts'], list) or []:
762 if not isinstance(alert_dict
, dict):
764 for alert
in alert_dict
.values():
765 alert_type
= alert
.get('type')
768 message
= cls
._get
_text
(alert
, 'text')
770 yield alert_type
, message
772 def _report_alerts(self
, alerts
, expected
=True, fatal
=True, only_once
=False):
773 errors
, warnings
= [], []
774 for alert_type
, alert_message
in alerts
:
775 if alert_type
.lower() == 'error' and fatal
:
776 errors
.append([alert_type
, alert_message
])
777 elif alert_message
not in self
._IGNORED
_WARNINGS
:
778 warnings
.append([alert_type
, alert_message
])
780 for alert_type
, alert_message
in (warnings
+ errors
[:-1]):
781 self
.report_warning(f
'YouTube said: {alert_type} - {alert_message}', only_once
=only_once
)
783 raise ExtractorError('YouTube said: %s' % errors
[-1][1], expected
=expected
)
785 def _extract_and_report_alerts(self
, data
, *args
, **kwargs
):
786 return self
._report
_alerts
(self
._extract
_alerts
(data
), *args
, **kwargs
)
788 def _extract_badges(self
, badge_list
: list):
790 Extract known BadgeType's from a list of badge renderers.
791 @returns [{'type': BadgeType}]
794 'PRIVACY_UNLISTED': BadgeType
.AVAILABILITY_UNLISTED
,
795 'PRIVACY_PRIVATE': BadgeType
.AVAILABILITY_PRIVATE
,
796 'PRIVACY_PUBLIC': BadgeType
.AVAILABILITY_PUBLIC
,
797 'CHECK_CIRCLE_THICK': BadgeType
.VERIFIED
,
798 'OFFICIAL_ARTIST_BADGE': BadgeType
.VERIFIED
,
799 'CHECK': BadgeType
.VERIFIED
,
803 'BADGE_STYLE_TYPE_MEMBERS_ONLY': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
804 'BADGE_STYLE_TYPE_PREMIUM': BadgeType
.AVAILABILITY_PREMIUM
,
805 'BADGE_STYLE_TYPE_LIVE_NOW': BadgeType
.LIVE_NOW
,
806 'BADGE_STYLE_TYPE_VERIFIED': BadgeType
.VERIFIED
,
807 'BADGE_STYLE_TYPE_VERIFIED_ARTIST': BadgeType
.VERIFIED
,
811 'unlisted': BadgeType
.AVAILABILITY_UNLISTED
,
812 'private': BadgeType
.AVAILABILITY_PRIVATE
,
813 'members only': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
814 'live': BadgeType
.LIVE_NOW
,
815 'premium': BadgeType
.AVAILABILITY_PREMIUM
,
816 'verified': BadgeType
.VERIFIED
,
817 'official artist channel': BadgeType
.VERIFIED
,
821 for badge
in traverse_obj(badge_list
, (..., lambda key
, _
: re
.search(r
'[bB]adgeRenderer$', key
))):
823 icon_type_map
.get(traverse_obj(badge
, ('icon', 'iconType'), expected_type
=str))
824 or badge_style_map
.get(traverse_obj(badge
, 'style'))
827 badges
.append({'type': badge_type}
)
830 # fallback, won't work in some languages
831 label
= traverse_obj(
832 badge
, 'label', ('accessibilityData', 'label'), 'tooltip', 'iconTooltip', get_all
=False, expected_type
=str, default
='')
833 for match
, label_badge_type
in label_map
.items():
834 if match
in label
.lower():
835 badges
.append({'type': label_badge_type}
)
841 def _has_badge(badges
, badge_type
):
842 return bool(traverse_obj(badges
, lambda _
, v
: v
['type'] == badge_type
))
845 def _get_text(data
, *path_list
, max_runs
=None):
846 for path
in path_list
or [None]:
850 obj
= traverse_obj(data
, path
, default
=[])
851 if not any(key
is ... or isinstance(key
, (list, tuple)) for key
in variadic(path
)):
854 text
= try_get(item
, lambda x
: x
['simpleText'], str)
857 runs
= try_get(item
, lambda x
: x
['runs'], list) or []
858 if not runs
and isinstance(item
, list):
861 runs
= runs
[:min(len(runs
), max_runs
or len(runs
))]
862 text
= ''.join(traverse_obj(runs
, (..., 'text'), expected_type
=str))
866 def _get_count(self
, data
, *path_list
):
867 count_text
= self
._get
_text
(data
, *path_list
) or ''
868 count
= parse_count(count_text
)
871 self
._search
_regex
(r
'^([\d,]+)', re
.sub(r
'\s', '', count_text
), 'count', default
=None))
875 def _extract_thumbnails(data
, *path_list
):
877 Extract thumbnails from thumbnails dict
878 @param path_list: path list to level that contains 'thumbnails' key
881 for path
in path_list
or [()]:
882 for thumbnail
in traverse_obj(data
, (*variadic(path
), 'thumbnails', ...)):
883 thumbnail_url
= url_or_none(thumbnail
.get('url'))
884 if not thumbnail_url
:
886 # Sometimes youtube gives a wrong thumbnail URL. See:
887 # https://github.com/yt-dlp/yt-dlp/issues/233
888 # https://github.com/ytdl-org/youtube-dl/issues/28023
889 if 'maxresdefault' in thumbnail_url
:
890 thumbnail_url
= thumbnail_url
.split('?')[0]
892 'url': thumbnail_url
,
893 'height': int_or_none(thumbnail
.get('height')),
894 'width': int_or_none(thumbnail
.get('width')),
899 def extract_relative_time(relative_time_text
):
901 Extracts a relative time from string and converts to dt object
902 e.g. 'streamed 6 days ago', '5 seconds ago (edited)', 'updated today', '8 yr ago'
905 # XXX: this could be moved to a general function in utils/_utils.py
906 # The relative time text strings are roughly the same as what
907 # Javascript's Intl.RelativeTimeFormat function generates.
908 # See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
910 r
'(?P<start>today|yesterday|now)|(?P<time>\d+)\s*(?P<unit>sec(?:ond)?|s|min(?:ute)?|h(?:our|r)?|d(?:ay)?|w(?:eek|k)?|mo(?:nth)?|y(?:ear|r)?)s?\s*ago',
913 start
= mobj
.group('start')
915 return datetime_from_str(start
)
917 return datetime_from_str('now-%s%s' % (mobj
.group('time'), mobj
.group('unit')))
921 def _parse_time_text(self
, text
):
924 dt
= self
.extract_relative_time(text
)
926 if isinstance(dt
, datetime
.datetime
):
927 timestamp
= calendar
.timegm(dt
.timetuple())
929 if timestamp
is None:
931 unified_timestamp(text
) or unified_timestamp(
933 (r
'([a-z]+\s*\d{1,2},?\s*20\d{2})', r
'(?:.+|^)(?:live|premieres|ed|ing)(?:\s*(?:on|for))?\s*(.+\d)'),
934 text
.lower(), 'time text', default
=None)))
936 if text
and timestamp
is None and self
._preferred
_lang
in (None, 'en'):
938 f
'Cannot parse localized time text "{text}"', only_once
=True)
941 def _extract_response(self
, item_id
, query
, note
='Downloading API JSON', headers
=None,
942 ytcfg
=None, check_get_keys
=None, ep
='browse', fatal
=True, api_hostname
=None,
943 default_client
='web'):
944 raise_for_incomplete
= bool(self
._configuration
_arg
('raise_incomplete_data', ie_key
=YoutubeIE
))
945 # Incomplete Data should be a warning by default when retries are exhausted, while other errors should be fatal.
946 icd_retries
= iter(self
.RetryManager(fatal
=raise_for_incomplete
))
947 icd_rm
= next(icd_retries
)
948 main_retries
= iter(self
.RetryManager())
949 main_rm
= next(main_retries
)
950 for _
in range(main_rm
.retries
+ icd_rm
.retries
+ 1):
952 response
= self
._call
_api
(
953 ep
=ep
, fatal
=True, headers
=headers
,
954 video_id
=item_id
, query
=query
, note
=note
,
955 context
=self
._extract
_context
(ytcfg
, default_client
),
956 api_key
=self
._extract
_api
_key
(ytcfg
, default_client
),
957 api_hostname
=api_hostname
, default_client
=default_client
)
958 except ExtractorError
as e
:
959 if not isinstance(e
.cause
, network_exceptions
):
960 return self
._error
_or
_warning
(e
, fatal
=fatal
)
961 elif not isinstance(e
.cause
, HTTPError
):
966 first_bytes
= e
.cause
.response
.read(512)
967 if not is_html(first_bytes
):
970 self
._webpage
_read
_content
(e
.cause
.response
, 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 received. 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
.status
not in (403, 429):
982 return self
._error
_or
_warning
(e
, fatal
=fatal
)
985 self
._extract
_and
_report
_alerts
(response
, only_once
=True)
986 except ExtractorError
as e
:
987 # YouTube's servers may return errors we want to retry on in a 200 OK response
988 # See: https://github.com/yt-dlp/yt-dlp/issues/839
989 if 'unknown error' in e
.msg
.lower():
993 return self
._error
_or
_warning
(e
, fatal
=fatal
)
994 # Youtube sometimes sends incomplete data
995 # See: https://github.com/ytdl-org/youtube-dl/issues/28194
996 if not traverse_obj(response
, *variadic(check_get_keys
)):
997 icd_rm
.error
= ExtractorError('Incomplete data received', expected
=True)
998 should_retry
= next(icd_retries
, None)
1006 def is_music_url(url
):
1007 return re
.match(r
'(https?://)?music\.youtube\.com/', url
) is not None
1009 def _extract_video(self
, renderer
):
1010 video_id
= renderer
.get('videoId')
1012 reel_header_renderer
= traverse_obj(renderer
, (
1013 'navigationEndpoint', 'reelWatchEndpoint', 'overlay', 'reelPlayerOverlayRenderer',
1014 'reelPlayerHeaderSupportedRenderers', 'reelPlayerHeaderRenderer'))
1016 title
= self
._get
_text
(renderer
, 'title', 'headline') or self
._get
_text
(reel_header_renderer
, 'reelTitleText')
1017 description
= self
._get
_text
(renderer
, 'descriptionSnippet')
1019 duration
= int_or_none(renderer
.get('lengthSeconds'))
1020 if duration
is None:
1021 duration
= parse_duration(self
._get
_text
(
1022 renderer
, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
1023 if duration
is None:
1024 # XXX: should write a parser to be more general to support more cases (e.g. shorts in shorts tab)
1025 duration
= parse_duration(self
._search
_regex
(
1026 r
'(?i)(ago)(?!.*\1)\s+(?P<duration>[a-z0-9 ,]+?)(?:\s+[\d,]+\s+views)?(?:\s+-\s+play\s+short)?$',
1027 traverse_obj(renderer
, ('title', 'accessibility', 'accessibilityData', 'label'), default
='', expected_type
=str),
1028 video_id
, default
=None, group
='duration'))
1030 channel_id
= traverse_obj(
1031 renderer
, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'),
1032 expected_type
=str, get_all
=False)
1034 channel_id
= traverse_obj(reel_header_renderer
, ('channelNavigationEndpoint', 'browseEndpoint', 'browseId'))
1036 channel_id
= self
.ucid_or_none(channel_id
)
1038 overlay_style
= traverse_obj(
1039 renderer
, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'),
1040 get_all
=False, expected_type
=str)
1041 badges
= self
._extract
_badges
(traverse_obj(renderer
, 'badges'))
1042 owner_badges
= self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges'))
1043 navigation_url
= urljoin('https://www.youtube.com/', traverse_obj(
1044 renderer
, ('navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url'),
1045 expected_type
=str)) or ''
1046 url
= f
'https://www.youtube.com/watch?v={video_id}'
1047 if overlay_style
== 'SHORTS' or '/shorts/' in navigation_url
:
1048 url
= f
'https://www.youtube.com/shorts/{video_id}'
1050 time_text
= (self
._get
_text
(renderer
, 'publishedTimeText', 'videoInfo')
1051 or self
._get
_text
(reel_header_renderer
, 'timestampText') or '')
1052 scheduled_timestamp
= str_to_int(traverse_obj(renderer
, ('upcomingEventData', 'startTime'), get_all
=False))
1055 'is_upcoming' if scheduled_timestamp
is not None
1056 else 'was_live' if 'streamed' in time_text
.lower()
1057 else 'is_live' if overlay_style
== 'LIVE' or self
._has
_badge
(badges
, BadgeType
.LIVE_NOW
)
1060 # videoInfo is a string like '50K views • 10 years ago'.
1061 view_count_text
= self
._get
_text
(renderer
, 'viewCountText', 'shortViewCountText', 'videoInfo') or ''
1062 view_count
= (0 if 'no views' in view_count_text
.lower()
1063 else self
._get
_count
({'simpleText': view_count_text}
))
1064 view_count_field
= 'concurrent_view_count' if live_status
in ('is_live', 'is_upcoming') else 'view_count'
1066 channel
= (self
._get
_text
(renderer
, 'ownerText', 'shortBylineText')
1067 or self
._get
_text
(reel_header_renderer
, 'channelTitleText'))
1069 channel_handle
= traverse_obj(renderer
, (
1070 'shortBylineText', 'runs', ..., 'navigationEndpoint',
1071 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl'))),
1072 expected_type
=self
.handle_from_url
, get_all
=False)
1075 'ie_key': YoutubeIE
.ie_key(),
1079 'description': description
,
1080 'duration': duration
,
1081 'channel_id': channel_id
,
1083 'channel_url': f
'https://www.youtube.com/channel/{channel_id}' if channel_id
else None,
1084 'uploader': channel
,
1085 'uploader_id': channel_handle
,
1086 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
1087 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
1088 'timestamp': (self
._parse
_time
_text
(time_text
)
1089 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
1091 'release_timestamp': scheduled_timestamp
,
1093 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
1094 else self
._availability
(
1095 is_private
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
) or None,
1096 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
1097 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
1098 is_unlisted
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
) or None),
1099 view_count_field
: view_count
,
1100 'live_status': live_status
,
1101 'channel_is_verified': True if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
) else None
1105 class YoutubeIE(YoutubeBaseInfoExtractor
):
1107 _VALID_URL
= r
"""(?x)^
1109 (?:https?://|//) # http(s):// or protocol-independent URL
1110 (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
1111 (?:www\.)?deturl\.com/www\.youtube\.com|
1112 (?:www\.)?pwnyoutube\.com|
1113 (?:www\.)?hooktube\.com|
1114 (?:www\.)?yourepeat\.com|
1115 tube\.majestyc\.net|
1117 youtube\.googleapis\.com)/ # the various hostnames, with wildcard subdomains
1118 (?:.*?\#/)? # handle anchor (#/) redirect urls
1119 (?: # the various things that can precede the ID:
1120 (?:(?:v|embed|e|shorts|live)/(?!videoseries|live_stream)) # v/ or embed/ or e/ or shorts/
1121 |(?: # or the v= param in all its forms
1122 (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
1123 (?:\?|\#!?) # the params delimiter ? or # or #!
1124 (?:.*?[&;])?? # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&v=V36LpHqtcDY)
1129 youtu\.be| # just youtu.be/xxxx
1130 vid\.plus| # or vid.plus/xxxx
1131 zwearz\.com/watch| # or zwearz.com/watch/xxxx
1134 |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
1136 )? # all until now is optional -> you can pass the naked ID
1137 (?P<id>[0-9A-Za-z_-]{11}) # here is it! the YouTube video ID
1138 (?(1).+)? # if we found the ID, everything can follow
1140 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
1145 <(?:[0-9A-Za-z-]+?)?iframe[^>]+?src=|
1153 (?P
<url
>(?
:https?
:)?
//(?
:www\
.)?
youtube(?
:-nocookie
)?\
.com
/
1154 (?
:embed|v|p
)/[0-9A
-Za
-z_
-]{11}
.*?
)
1156 # https://wordpress.org/plugins/lazy-load-for-videos/
1158 <a\s
[^
>]*\bhref
="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"
1159 \s
[^
>]*\bclass
="[^"]*\blazy
-load
-youtube
''',
1161 _RETURN_TYPE = 'video' # XXX: How to handle multifeed?
1164 r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
1165 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$',
1166 r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
1169 '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1170 '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1171 '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
1172 '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
1173 '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
1174 '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1175 '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1176 '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1177 # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
1178 '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
1179 '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1180 '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1181 '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1182 '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1183 '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1184 '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1185 '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1186 '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1190 '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1191 '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1192 '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1193 '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1194 '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
1195 '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1196 '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1198 # Apple HTTP Live Streaming
1199 '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1200 '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1201 '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1202 '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1203 '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1204 '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1205 '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1206 '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
1209 '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
1210 '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
1211 '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1212 '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
1213 '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
1214 '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'}, # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
1215 '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
1216 '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1217 '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
1218 '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1219 '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1220 '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
1223 '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
1224 '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
1225 '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
1226 '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1227 '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1228 '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
1229 '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
1232 '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1233 '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1234 '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1235 '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1236 '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1237 '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1238 '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
1239 '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1240 '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1241 '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1242 '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1243 '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1244 '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1245 '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1246 '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1247 # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
1248 '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1249 '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1250 '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1251 '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1252 '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1253 '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1256 '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
1257 '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
1259 # Dash webm audio with opus inside
1260 '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
1261 '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
1262 '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
1265 '_rtmp': {'protocol': 'rtmp'},
1267 # av01 video only formats sometimes served with "unknown" codecs
1268 '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1269 '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1270 '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1271 '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1272 '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1273 '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1274 '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1275 '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1277 _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1284 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1286 'id': 'BaW_jenozKc',
1288 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1289 'channel': 'Philipp Hagemeister',
1290 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1291 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1292 'upload_date': '20121002',
1293 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1294 'categories': ['Science & Technology'],
1295 'tags': ['youtube-dl'],
1299 'availability': 'public',
1300 'playable_in_embed': True,
1301 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1302 'live_status': 'not_live',
1306 'comment_count': int,
1307 'channel_follower_count': int,
1308 'uploader': 'Philipp Hagemeister',
1309 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1310 'uploader_id': '@PhilippHagemeister',
1311 'heatmap': 'count:100',
1315 'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1316 'note': 'Embed-only video (#1746)',
1318 'id': 'yZIXLfi8CZQ',
1320 'upload_date': '20120608',
1321 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1322 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1325 'skip': 'Private video',
1328 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1329 'note': 'Use the first video ID in the URL',
1331 'id': 'BaW_jenozKc',
1333 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1334 'channel': 'Philipp Hagemeister',
1335 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1336 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1337 'upload_date': '20121002',
1338 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1339 'categories': ['Science & Technology'],
1340 'tags': ['youtube-dl'],
1344 'availability': 'public',
1345 'playable_in_embed': True,
1346 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1347 'live_status': 'not_live',
1349 'comment_count': int,
1350 'channel_follower_count': int,
1351 'uploader': 'Philipp Hagemeister',
1352 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1353 'uploader_id': '@PhilippHagemeister',
1354 'heatmap': 'count:100',
1357 'skip_download': True,
1361 'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1362 'note': '256k DASH audio (format 141) via DASH manifest',
1364 'id': 'a9LDPn-MO4I',
1366 'upload_date': '20121002',
1368 'title': 'UHDTV TEST 8K VIDEO.mp4'
1371 'youtube_include_dash_manifest': True,
1374 'skip': 'format 141 not served anymore',
1376 # DASH manifest with encrypted signature
1378 'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1380 'id': 'IB3lcPjvWLA',
1382 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1383 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1385 'upload_date': '20131011',
1388 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1389 'playable_in_embed': True,
1390 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1392 'track': 'The Spark',
1393 'live_status': 'not_live',
1394 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1395 'channel': 'Afrojack',
1397 'availability': 'public',
1398 'categories': ['Music'],
1400 'alt_title': 'The Spark',
1401 'channel_follower_count': int,
1402 'uploader': 'Afrojack',
1403 'uploader_url': 'https://www.youtube.com/@Afrojack',
1404 'uploader_id': '@Afrojack',
1407 'youtube_include_dash_manifest': True,
1408 'format': '141/bestaudio[ext=m4a]',
1411 # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1413 'note': 'Embed allowed age-gate video',
1414 'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1416 'id': 'HtVdAasjOgU',
1418 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1419 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1421 'upload_date': '20140605',
1423 'categories': ['Gaming'],
1424 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1425 'availability': 'needs_auth',
1426 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1428 'channel': 'The Witcher',
1429 'live_status': 'not_live',
1431 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1432 'playable_in_embed': True,
1434 'channel_follower_count': int,
1435 'uploader': 'The Witcher',
1436 'uploader_url': 'https://www.youtube.com/@thewitcher',
1437 'uploader_id': '@thewitcher',
1438 'comment_count': int,
1439 'channel_is_verified': True,
1440 'heatmap': 'count:100',
1444 'note': 'Age-gate video with embed allowed in public site',
1445 'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1447 'id': 'HsUATh_Nc2U',
1449 'title': 'Godzilla 2 (Official Video)',
1450 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1451 'upload_date': '20200408',
1453 'availability': 'needs_auth',
1454 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1455 'channel': 'FlyingKitty',
1456 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1458 'categories': ['Entertainment'],
1459 'live_status': 'not_live',
1460 'tags': ['Flyingkitty', 'godzilla 2'],
1461 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1464 'playable_in_embed': True,
1465 'channel_follower_count': int,
1466 'uploader': 'FlyingKitty',
1467 'uploader_url': 'https://www.youtube.com/@FlyingKitty900',
1468 'uploader_id': '@FlyingKitty900',
1469 'comment_count': int,
1470 'channel_is_verified': True,
1474 'note': 'Age-gate video embedable only with clientScreen=EMBED',
1475 'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1477 'id': 'Tq92D6wQ1mg',
1478 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1480 'upload_date': '20191228',
1481 'description': 'md5:17eccca93a786d51bc67646756894066',
1484 'availability': 'needs_auth',
1485 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1487 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1488 'channel': 'Projekt Melody',
1489 'live_status': 'not_live',
1490 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1491 'playable_in_embed': True,
1492 'categories': ['Entertainment'],
1494 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1495 'comment_count': int,
1496 'channel_follower_count': int,
1497 'uploader': 'Projekt Melody',
1498 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
1499 'uploader_id': '@ProjektMelody',
1503 'note': 'Non-Agegated non-embeddable video',
1504 'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1506 'id': 'MeJVWBSsPAY',
1508 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1509 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1510 'upload_date': '20130730',
1511 'track': 'Such mich find mich',
1513 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1515 'playable_in_embed': False,
1516 'creator': 'OOMPH!',
1517 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1519 'alt_title': 'Such mich find mich',
1521 'channel': 'Herr Lurik',
1522 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1523 'categories': ['Music'],
1524 'availability': 'public',
1525 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1526 'live_status': 'not_live',
1528 'channel_follower_count': int,
1529 'uploader': 'Herr Lurik',
1530 'uploader_url': 'https://www.youtube.com/@HerrLurik',
1531 'uploader_id': '@HerrLurik',
1535 'note': 'Non-bypassable age-gated video',
1536 'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1537 'only_matching': True,
1539 # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1540 # YouTube Red ad is not captured for creator
1542 'url': '__2ABJjxzNo',
1544 'id': '__2ABJjxzNo',
1547 'upload_date': '20100430',
1548 'creator': 'deadmau5',
1549 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1550 'title': 'Deadmau5 - Some Chords (HD)',
1551 'alt_title': 'Some Chords',
1552 'availability': 'public',
1554 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1556 'live_status': 'not_live',
1557 'channel': 'deadmau5',
1558 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1560 'track': 'Some Chords',
1561 'artist': 'deadmau5',
1562 'playable_in_embed': True,
1564 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1565 'categories': ['Music'],
1566 'album': 'Some Chords',
1567 'channel_follower_count': int,
1568 'uploader': 'deadmau5',
1569 'uploader_url': 'https://www.youtube.com/@deadmau5',
1570 'uploader_id': '@deadmau5',
1572 'expected_warnings': [
1573 'DASH manifest missing',
1576 # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1578 'url': 'lqQg6PlCWgI',
1580 'id': 'lqQg6PlCWgI',
1583 'upload_date': '20150827',
1584 'description': 'md5:04bbbf3ccceb6795947572ca36f45904',
1585 'title': 'Hockey - Women - GER-AUS - London 2012 Olympic Games',
1587 'release_timestamp': 1343767800,
1588 'playable_in_embed': True,
1589 'categories': ['Sports'],
1590 'release_date': '20120731',
1591 'channel': 'Olympics',
1592 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1593 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1594 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1596 'availability': 'public',
1597 'live_status': 'was_live',
1599 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1600 'channel_follower_count': int,
1601 'uploader': 'Olympics',
1602 'uploader_url': 'https://www.youtube.com/@Olympics',
1603 'uploader_id': '@Olympics',
1604 'channel_is_verified': True,
1607 'skip_download': 'requires avconv',
1612 'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1614 'id': '_b-2C3KPAM0',
1616 'stretched_ratio': 16 / 9.,
1618 'upload_date': '20110310',
1619 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1620 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1621 'playable_in_embed': True,
1625 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1626 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1627 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1629 'categories': ['People & Blogs'],
1631 'live_status': 'not_live',
1632 'availability': 'unlisted',
1633 'comment_count': int,
1634 'channel_follower_count': int,
1636 'uploader_url': 'https://www.youtube.com/@AllenMeow',
1637 'uploader_id': '@AllenMeow',
1640 # url_encoded_fmt_stream_map is empty string
1642 'url': 'qEJwOuvDf7I',
1644 'id': 'qEJwOuvDf7I',
1646 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1648 'upload_date': '20150404',
1651 'skip_download': 'requires avconv',
1653 'skip': 'This live event has ended.',
1655 # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1657 'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1659 'id': 'FIl7x6_3R5Y',
1661 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1662 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1664 'upload_date': '20150625',
1665 'formats': 'mincount:31',
1667 'skip': 'not actual anymore',
1669 # DASH manifest with segment_list
1671 'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1672 'md5': '8ce563a1d667b599d21064e982ab9e31',
1674 'id': 'CsmdDsKjzN8',
1676 'upload_date': '20150501', # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1677 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1678 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1681 'youtube_include_dash_manifest': True,
1682 'format': '135', # bestvideo
1684 'skip': 'This live event has ended.',
1687 # Multifeed videos (multiple cameras), URL can be of any Camera
1688 # TODO: fix multifeed titles
1689 'url': 'https://www.youtube.com/watch?v=zaPI8MvL8pg',
1691 'id': 'zaPI8MvL8pg',
1692 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04',
1693 'description': 'md5:563ccbc698b39298481ca3c571169519',
1697 'id': 'j5yGuxZ8lLU',
1699 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Chris)',
1700 'description': 'md5:563ccbc698b39298481ca3c571169519',
1702 'channel_follower_count': int,
1703 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1704 'availability': 'public',
1705 'playable_in_embed': True,
1706 'upload_date': '20131105',
1707 'categories': ['Gaming'],
1708 'live_status': 'was_live',
1710 'release_timestamp': 1383701910,
1711 'thumbnail': 'https://i.ytimg.com/vi/j5yGuxZ8lLU/maxresdefault.jpg',
1712 'comment_count': int,
1715 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1716 'channel': 'WiiLikeToPlay',
1718 'release_date': '20131106',
1719 'uploader': 'WiiLikeToPlay',
1720 'uploader_id': '@WLTP',
1721 'uploader_url': 'https://www.youtube.com/@WLTP',
1725 'id': 'zaPI8MvL8pg',
1727 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Tyson)',
1728 'availability': 'public',
1729 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1730 'channel': 'WiiLikeToPlay',
1731 'channel_follower_count': int,
1732 'description': 'md5:563ccbc698b39298481ca3c571169519',
1737 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1738 'release_timestamp': 1383701915,
1739 'comment_count': int,
1740 'upload_date': '20131105',
1741 'thumbnail': 'https://i.ytimg.com/vi/zaPI8MvL8pg/maxresdefault.jpg',
1742 'release_date': '20131106',
1743 'playable_in_embed': True,
1744 'live_status': 'was_live',
1745 'categories': ['Gaming'],
1747 'uploader': 'WiiLikeToPlay',
1748 'uploader_id': '@WLTP',
1749 'uploader_url': 'https://www.youtube.com/@WLTP',
1753 'id': 'R7r3vfO7Hao',
1755 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Spencer)',
1756 'thumbnail': 'https://i.ytimg.com/vi/R7r3vfO7Hao/maxresdefault.jpg',
1757 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1759 'availability': 'public',
1760 'playable_in_embed': True,
1761 'upload_date': '20131105',
1762 'description': 'md5:563ccbc698b39298481ca3c571169519',
1763 'channel_follower_count': int,
1765 'release_date': '20131106',
1766 'comment_count': int,
1767 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1768 'channel': 'WiiLikeToPlay',
1769 'categories': ['Gaming'],
1770 'release_timestamp': 1383701914,
1771 'live_status': 'was_live',
1775 'uploader': 'WiiLikeToPlay',
1776 'uploader_id': '@WLTP',
1777 'uploader_url': 'https://www.youtube.com/@WLTP',
1780 'params': {'skip_download': True},
1783 # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1784 'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1786 'id': 'gVfLd0zydlo',
1787 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1789 'playlist_count': 2,
1790 'skip': 'Not multifeed anymore',
1793 'url': 'https://vid.plus/FlRa-iH7PGw',
1794 'only_matching': True,
1797 'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1798 'only_matching': True,
1801 # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1802 # Also tests cut-off URL expansion in video description (see
1803 # https://github.com/ytdl-org/youtube-dl/issues/1892,
1804 # https://github.com/ytdl-org/youtube-dl/issues/8164)
1805 'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1807 'id': 'lsguqyKfVQg',
1809 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1810 'alt_title': 'Dark Walk',
1811 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1813 'upload_date': '20151119',
1814 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1815 'track': 'Dark Walk',
1816 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1817 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1818 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1819 'categories': ['Film & Animation'],
1821 'live_status': 'not_live',
1822 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1823 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1825 'availability': 'public',
1826 'channel': 'IronSoulElf',
1827 'playable_in_embed': True,
1830 'channel_follower_count': int
1833 'skip_download': True,
1837 # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1838 'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1839 'only_matching': True,
1842 # Video with yt:stretch=17:0
1843 'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1845 'id': 'Q39EVAstoRM',
1847 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1848 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1849 'upload_date': '20151107',
1852 'skip_download': True,
1854 'skip': 'This video does not exist.',
1857 # Video with incomplete 'yt:stretch=16:'
1858 'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1859 'only_matching': True,
1862 # Video licensed under Creative Commons
1863 'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1865 'id': 'M4gD1WSo5mA',
1867 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1868 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1870 'upload_date': '20150128',
1871 'license': 'Creative Commons Attribution license (reuse allowed)',
1872 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1873 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1876 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1877 'channel': 'The Berkman Klein Center for Internet & Society',
1878 'availability': 'public',
1880 'categories': ['Education'],
1881 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1882 'live_status': 'not_live',
1883 'playable_in_embed': True,
1884 'channel_follower_count': int,
1886 'uploader': 'The Berkman Klein Center for Internet & Society',
1887 'uploader_id': '@BKCHarvard',
1888 'uploader_url': 'https://www.youtube.com/@BKCHarvard',
1891 'skip_download': True,
1895 'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1897 'id': 'eQcmzGIKrzg',
1899 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1900 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1902 'upload_date': '20151120',
1903 'license': 'Creative Commons Attribution license (reuse allowed)',
1904 'playable_in_embed': True,
1907 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1909 'availability': 'public',
1910 'categories': ['News & Politics'],
1911 'channel': 'Bernie Sanders',
1912 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1914 'live_status': 'not_live',
1915 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1916 'comment_count': int,
1917 'channel_follower_count': int,
1919 'uploader': 'Bernie Sanders',
1920 'uploader_url': 'https://www.youtube.com/@BernieSanders',
1921 'uploader_id': '@BernieSanders',
1922 'channel_is_verified': True,
1923 'heatmap': 'count:100',
1926 'skip_download': True,
1930 'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;v=V36LpHqtcDY',
1931 'only_matching': True,
1934 # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1935 'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1936 'only_matching': True,
1939 # Rental video preview
1940 'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1942 'id': 'uGpuVWrhIzE',
1944 'title': 'Piku - Trailer',
1945 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1946 'upload_date': '20150811',
1947 'license': 'Standard YouTube License',
1950 'skip_download': True,
1952 'skip': 'This video is not available.',
1955 # YouTube Red video with episode data
1956 'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1958 'id': 'iqKdEhx-dD4',
1960 'title': 'Isolation - Mind Field (Ep 1)',
1961 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1963 'upload_date': '20170118',
1964 'series': 'Mind Field',
1966 'episode_number': 1,
1967 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1970 'availability': 'public',
1972 'channel': 'Vsauce',
1973 'episode': 'Episode 1',
1974 'categories': ['Entertainment'],
1975 'season': 'Season 1',
1976 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
1977 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
1979 'playable_in_embed': True,
1980 'live_status': 'not_live',
1981 'channel_follower_count': int,
1982 'uploader': 'Vsauce',
1983 'uploader_url': 'https://www.youtube.com/@Vsauce',
1984 'uploader_id': '@Vsauce',
1985 'comment_count': int,
1986 'channel_is_verified': True,
1989 'skip_download': True,
1991 'expected_warnings': [
1992 'Skipping DASH manifest',
1996 # The following content has been identified by the YouTube community
1997 # as inappropriate or offensive to some audiences.
1998 'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
2000 'id': '6SJNVb0GnPI',
2002 'title': 'Race Differences in Intelligence',
2003 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
2005 'upload_date': '20140124',
2008 'skip_download': True,
2010 'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
2014 'url': '1t24XAntNCY',
2015 'only_matching': True,
2018 # geo restricted to JP
2019 'url': 'sJL6WA-aGkQ',
2020 'only_matching': True,
2023 'url': 'https://invidio.us/watch?v=BaW_jenozKc',
2024 'only_matching': True,
2027 'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
2028 'only_matching': True,
2031 # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
2032 'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
2033 'only_matching': True,
2037 'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
2038 'only_matching': True,
2041 # Video with unsupported adaptive stream type formats
2042 'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
2044 'id': 'Z4Vy8R84T1U',
2046 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
2047 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
2049 'upload_date': '20130923',
2050 'formats': 'maxcount:10',
2053 'skip_download': True,
2054 'youtube_include_dash_manifest': False,
2056 'skip': 'not actual anymore',
2059 # Youtube Music Auto-generated description
2060 # TODO: fix metadata extraction
2061 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2063 'id': 'MgNrAu2pzNs',
2065 'title': 'Voyeur Girl',
2066 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
2067 'upload_date': '20190312',
2068 'artist': 'Stephen',
2069 'track': 'Voyeur Girl',
2070 'album': 'it\'s too much love to know my dear',
2071 'release_date': '20190313',
2072 'release_year': 2019,
2073 'alt_title': 'Voyeur Girl',
2075 'playable_in_embed': True,
2077 'categories': ['Music'],
2078 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
2079 'channel': 'Stephen', # TODO: should be "Stephen - Topic"
2080 'uploader': 'Stephen',
2081 'availability': 'public',
2082 'creator': 'Stephen',
2084 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
2086 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
2088 'live_status': 'not_live',
2089 'channel_follower_count': int
2092 'skip_download': True,
2096 'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
2097 'only_matching': True,
2100 # invalid -> valid video id redirection
2101 'url': 'DJztXj2GPfl',
2103 'id': 'DJztXj2GPfk',
2105 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
2106 'description': 'md5:bf577a41da97918e94fa9798d9228825',
2107 'upload_date': '20090125',
2108 'artist': 'Panjabi MC',
2109 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
2110 'album': 'Beware of the Boys (Mundian To Bach Ke)',
2113 'skip_download': True,
2115 'skip': 'Video unavailable',
2118 # empty description results in an empty string
2119 'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
2121 'id': 'x41yOUIvK2k',
2123 'title': 'IMG 3456',
2125 'upload_date': '20170613',
2127 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
2129 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
2131 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
2132 'availability': 'public',
2134 'categories': ['Pets & Animals'],
2136 'playable_in_embed': True,
2137 'live_status': 'not_live',
2138 'channel': 'l\'Or Vert asbl',
2139 'channel_follower_count': int,
2140 'uploader': 'l\'Or Vert asbl',
2141 'uploader_url': 'https://www.youtube.com/@ElevageOrVert',
2142 'uploader_id': '@ElevageOrVert',
2145 'skip_download': True,
2149 # with '};' inside yt initial data (see [1])
2150 # see [2] for an example with '};' inside ytInitialPlayerResponse
2151 # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
2152 # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
2153 'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
2155 'id': 'CHqg6qOn4no',
2157 'title': 'Part 77 Sort a list of simple types in c#',
2158 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
2159 'upload_date': '20130831',
2160 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
2162 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
2163 'live_status': 'not_live',
2164 'categories': ['Education'],
2165 'availability': 'public',
2166 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
2168 'playable_in_embed': True,
2172 'channel': 'kudvenkat',
2173 'comment_count': int,
2174 'channel_follower_count': int,
2176 'uploader': 'kudvenkat',
2177 'uploader_url': 'https://www.youtube.com/@Csharp-video-tutorialsBlogspot',
2178 'uploader_id': '@Csharp-video-tutorialsBlogspot',
2179 'channel_is_verified': True,
2180 'heatmap': 'count:100',
2183 'skip_download': True,
2187 # another example of '};' in ytInitialData
2188 'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
2189 'only_matching': True,
2192 'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
2193 'only_matching': True,
2196 # https://github.com/ytdl-org/youtube-dl/pull/28094
2197 'url': 'OtqTfy26tG0',
2199 'id': 'OtqTfy26tG0',
2201 'title': 'Burn Out',
2202 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
2203 'upload_date': '20141120',
2204 'artist': 'The Cinematic Orchestra',
2205 'track': 'Burn Out',
2206 'album': 'Every Day',
2208 'live_status': 'not_live',
2209 'alt_title': 'Burn Out',
2213 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2214 'creator': 'The Cinematic Orchestra',
2215 'channel': 'The Cinematic Orchestra',
2216 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
2217 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2218 'availability': 'public',
2219 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
2220 'categories': ['Music'],
2221 'playable_in_embed': True,
2222 'channel_follower_count': int,
2223 'uploader': 'The Cinematic Orchestra',
2224 'comment_count': int,
2227 'skip_download': True,
2231 # controversial video, only works with bpctr when authenticated with cookies
2232 'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
2233 'only_matching': True,
2236 # controversial video, requires bpctr/contentCheckOk
2237 'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
2239 'id': 'SZJvDhaSDnc',
2241 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
2242 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
2243 'upload_date': '20140716',
2244 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
2246 'categories': ['News & Politics'],
2248 'channel': 'CBS Mornings',
2249 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
2250 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
2252 'availability': 'needs_auth',
2253 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
2255 'live_status': 'not_live',
2256 'playable_in_embed': True,
2257 'channel_follower_count': int,
2258 'uploader': 'CBS Mornings',
2259 'uploader_url': 'https://www.youtube.com/@CBSMornings',
2260 'uploader_id': '@CBSMornings',
2261 'comment_count': int,
2262 'channel_is_verified': True,
2266 # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
2267 'url': 'cBvYw8_A0vQ',
2269 'id': 'cBvYw8_A0vQ',
2271 'title': '4K Ueno Okachimachi Street Scenes 上野御徒町歩き',
2272 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
2273 'upload_date': '20201120',
2275 'categories': ['Travel & Events'],
2276 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2278 'channel': 'Walk around Japan',
2279 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
2280 'thumbnail': 'https://i.ytimg.com/vi_webp/cBvYw8_A0vQ/hqdefault.webp',
2282 'availability': 'public',
2283 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2284 'live_status': 'not_live',
2285 'playable_in_embed': True,
2286 'channel_follower_count': int,
2287 'uploader': 'Walk around Japan',
2288 'uploader_url': 'https://www.youtube.com/@walkaroundjapan7124',
2289 'uploader_id': '@walkaroundjapan7124',
2292 'skip_download': True,
2295 # Has multiple audio streams
2296 'url': 'WaOKSUlf4TM',
2297 'only_matching': True
2299 # Requires Premium: has format 141 when requested using YTM url
2300 'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2301 'only_matching': True
2303 # multiple subtitles with same lang_code
2304 'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2305 'only_matching': True,
2307 # Force use android client fallback
2308 'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2310 'id': 'YOelRv7fMxY',
2311 'title': 'DIGGING A SECRET TUNNEL Part 1',
2313 'upload_date': '20210624',
2314 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2315 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2316 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2318 'categories': ['Entertainment'],
2320 'channel': 'colinfurze',
2321 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2322 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2324 'availability': 'public',
2326 'live_status': 'not_live',
2327 'playable_in_embed': True,
2328 'channel_follower_count': int,
2330 'uploader': 'colinfurze',
2331 'uploader_url': 'https://www.youtube.com/@colinfurze',
2332 'uploader_id': '@colinfurze',
2333 'comment_count': int,
2334 'channel_is_verified': True,
2335 'heatmap': 'count:100',
2338 'format': '17', # 3gp format available on android
2339 'extractor_args': {'youtube': {'player_client': ['android']}},
2343 # Skip download of additional client configs (remix client config in this case)
2344 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2345 'only_matching': True,
2347 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2351 'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2352 'only_matching': True,
2354 'note': 'Storyboards',
2355 'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2357 'id': '5KLPxDtMqe8',
2360 'title': 'Your Brain is Plastic',
2361 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2362 'upload_date': '20140324',
2364 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2365 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2367 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2368 'playable_in_embed': True,
2370 'availability': 'public',
2371 'channel': 'SciShow',
2372 'live_status': 'not_live',
2374 'categories': ['Education'],
2376 'channel_follower_count': int,
2378 'uploader': 'SciShow',
2379 'uploader_url': 'https://www.youtube.com/@SciShow',
2380 'uploader_id': '@SciShow',
2381 'comment_count': int,
2382 'channel_is_verified': True,
2383 'heatmap': 'count:100',
2384 }, 'params': {'format': 'mhtml', 'skip_download': True}
2386 # Ensure video upload_date is in UTC timezone (video was uploaded 1641170939)
2387 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2389 'id': '2NUZ8W2llS4',
2391 'title': 'The NP that test your phone performance 🙂',
2392 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2393 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2394 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2398 'categories': ['Gaming'],
2400 'playable_in_embed': True,
2401 'live_status': 'not_live',
2402 'upload_date': '20220103',
2404 'availability': 'public',
2405 'channel': 'Leon Nguyen',
2406 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2407 'comment_count': int,
2408 'channel_follower_count': int,
2409 'uploader': 'Leon Nguyen',
2410 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2411 'uploader_id': '@LeonNguyen',
2412 'heatmap': 'count:100',
2415 # Same video as above, but with --compat-opt no-youtube-prefer-utc-upload-date
2416 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2418 'id': '2NUZ8W2llS4',
2420 'title': 'The NP that test your phone performance 🙂',
2421 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2422 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2423 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2427 'categories': ['Gaming'],
2429 'playable_in_embed': True,
2430 'live_status': 'not_live',
2431 'upload_date': '20220102',
2433 'availability': 'public',
2434 'channel': 'Leon Nguyen',
2435 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2436 'comment_count': int,
2437 'channel_follower_count': int,
2438 'uploader': 'Leon Nguyen',
2439 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2440 'uploader_id': '@LeonNguyen',
2441 'heatmap': 'count:100',
2443 'params': {'compat_opts': ['no-youtube-prefer-utc-upload-date']}
2445 # date text is premiered video, ensure upload date in UTC (published 1641172509)
2446 'url': 'https://www.youtube.com/watch?v=mzZzzBU6lrM',
2448 'id': 'mzZzzBU6lrM',
2450 'title': 'I Met GeorgeNotFound In Real Life...',
2451 'description': 'md5:978296ec9783a031738b684d4ebf302d',
2452 'channel_id': 'UC_8NknAFiyhOUaZqHR3lq3Q',
2453 'channel_url': 'https://www.youtube.com/channel/UC_8NknAFiyhOUaZqHR3lq3Q',
2457 'categories': ['Entertainment'],
2459 'playable_in_embed': True,
2460 'live_status': 'not_live',
2461 'release_timestamp': 1641172509,
2462 'release_date': '20220103',
2463 'upload_date': '20220103',
2465 'availability': 'public',
2466 'channel': 'Quackity',
2467 'thumbnail': 'https://i.ytimg.com/vi/mzZzzBU6lrM/maxresdefault.jpg',
2468 'channel_follower_count': int,
2469 'uploader': 'Quackity',
2470 'uploader_id': '@Quackity',
2471 'uploader_url': 'https://www.youtube.com/@Quackity',
2472 'comment_count': int,
2473 'channel_is_verified': True,
2474 'heatmap': 'count:100',
2477 { # continuous livestream. Microformat upload date should be preferred.
2478 # Upload date was 2021-06-19 (not UTC), while stream start is 2021-11-27
2479 'url': 'https://www.youtube.com/watch?v=kgx4WGK0oNU',
2481 'id': 'kgx4WGK0oNU',
2482 '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}',
2484 'channel_id': 'UC84whx2xxsiA1gXHXXqKGOA',
2485 'availability': 'public',
2487 'release_timestamp': 1637975704,
2488 'upload_date': '20210619',
2489 'channel_url': 'https://www.youtube.com/channel/UC84whx2xxsiA1gXHXXqKGOA',
2490 'live_status': 'is_live',
2491 'thumbnail': 'https://i.ytimg.com/vi/kgx4WGK0oNU/maxresdefault.jpg',
2492 'channel': 'Abao in Tokyo',
2493 'channel_follower_count': int,
2494 'release_date': '20211127',
2496 'categories': ['People & Blogs'],
2499 'playable_in_embed': True,
2500 'description': 'md5:2ef1d002cad520f65825346e2084e49d',
2501 'concurrent_view_count': int,
2502 'uploader': 'Abao in Tokyo',
2503 'uploader_url': 'https://www.youtube.com/@abaointokyo',
2504 'uploader_id': '@abaointokyo',
2506 'params': {'skip_download': True}
2508 'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2510 'id': 'tjjjtzRLHvA',
2512 'title': 'ハッシュタグ無し };if window.ytcsi',
2513 'upload_date': '20220323',
2515 'availability': 'unlisted',
2516 'channel': 'Lesmiscore',
2517 'thumbnail': r're:^https?://.*\.jpg',
2519 'categories': ['Music'],
2522 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2523 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2524 'live_status': 'not_live',
2525 'playable_in_embed': True,
2526 'channel_follower_count': int,
2529 'uploader_id': '@lesmiscore',
2530 'uploader': 'Lesmiscore',
2531 'uploader_url': 'https://www.youtube.com/@lesmiscore',
2534 # Prefer primary title+description language metadata by default
2535 # Do not prefer translated description if primary is empty
2536 'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2538 'id': 'el3E4MbxRqQ',
2540 'title': 'dlp test video 2 - primary sv no desc',
2542 'channel': 'cole-dlp-test-acc',
2545 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2547 'playable_in_embed': True,
2548 'availability': 'unlisted',
2549 'thumbnail': r're:^https?://.*\.jpg',
2552 'live_status': 'not_live',
2553 'upload_date': '20220908',
2554 'categories': ['People & Blogs'],
2555 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2556 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2557 'uploader_id': '@coletdjnz',
2558 'uploader': 'cole-dlp-test-acc',
2560 'params': {'skip_download': True}
2562 # Extractor argument: prefer translated title+description
2563 'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2565 'id': 'gHKT4uU8Zng',
2567 'channel': 'cole-dlp-test-acc',
2570 'live_status': 'not_live',
2571 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2572 'upload_date': '20220728',
2574 'categories': ['People & Blogs'],
2575 'thumbnail': r're:^https?://.*\.jpg',
2576 'title': 'dlp test video title translated (fr)',
2577 'availability': 'public',
2579 'description': 'dlp test video description translated (fr)',
2580 'playable_in_embed': True,
2581 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2582 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2583 'uploader_id': '@coletdjnz',
2584 'uploader': 'cole-dlp-test-acc',
2586 'params': {'skip_download': True, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2587 'expected_warnings': [r'Preferring "fr" translated fields'],
2589 'note': '6 channel audio',
2590 'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2591 'only_matching': True,
2593 'note': 'Multiple HLS formats with same itag',
2594 'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2596 'id': 'kX3nB4PpJko',
2598 'categories': ['Entertainment'],
2599 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2600 'live_status': 'not_live',
2602 'channel_follower_count': int,
2603 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2604 'title': 'Last To Take Hand Off Jet, Keeps It!',
2605 'channel': 'MrBeast',
2606 'playable_in_embed': True,
2608 'upload_date': '20221112',
2609 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2611 'availability': 'public',
2612 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2615 'uploader': 'MrBeast',
2616 'uploader_url': 'https://www.youtube.com/@MrBeast',
2617 'uploader_id': '@MrBeast',
2618 'comment_count': int,
2619 'channel_is_verified': True,
2620 'heatmap': 'count:100',
2622 'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2624 'note': 'Audio formats with Dynamic Range Compression',
2625 'url': 'https://www.youtube.com/watch?v=Tq92D6wQ1mg',
2627 'id': 'Tq92D6wQ1mg',
2629 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
2630 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
2631 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
2632 'channel_follower_count': int,
2633 'description': 'md5:17eccca93a786d51bc67646756894066',
2634 'upload_date': '20191228',
2635 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
2636 'playable_in_embed': True,
2638 'categories': ['Entertainment'],
2639 'thumbnail': 'https://i.ytimg.com/vi/Tq92D6wQ1mg/sddefault.jpg',
2641 'channel': 'Projekt Melody',
2643 'availability': 'needs_auth',
2644 'comment_count': int,
2645 'live_status': 'not_live',
2647 'uploader': 'Projekt Melody',
2648 'uploader_id': '@ProjektMelody',
2649 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
2651 'params': {'extractor_args': {'youtube': {'player_client': ['tv_embedded']}}, 'format': '251-drc'},
2654 'url': 'https://www.youtube.com/live/qVv6vCqciTM',
2656 'id': 'qVv6vCqciTM',
2659 'comment_count': int,
2660 'chapters': 'count:13',
2661 'upload_date': '20221223',
2662 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
2663 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
2665 'release_date': '20221223',
2666 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
2667 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
2669 'playable_in_embed': True,
2671 'availability': 'public',
2672 'channel_follower_count': int,
2673 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
2674 'categories': ['Entertainment'],
2675 'live_status': 'was_live',
2676 'release_timestamp': 1671793345,
2677 'channel': 'さなちゃんねる',
2678 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
2679 'uploader': 'さなちゃんねる',
2680 'uploader_url': 'https://www.youtube.com/@sana_natori',
2681 'uploader_id': '@sana_natori',
2682 'channel_is_verified': True,
2683 'heatmap': 'count:100',
2687 # Fallbacks when webpage and web client is unavailable
2688 'url': 'https://www.youtube.com/watch?v=wSSmNUl9Snw',
2690 'id': 'wSSmNUl9Snw',
2692 # 'categories': ['Science & Technology'],
2694 'chapters': 'count:2',
2695 'channel': 'Scott Manley',
2698 # 'availability': 'public',
2699 'channel_follower_count': int,
2700 'live_status': 'not_live',
2701 'upload_date': '20170831',
2704 'uploader_url': 'https://www.youtube.com/@scottmanley',
2705 'description': 'md5:f4bed7b200404b72a394c2f97b782c02',
2706 'uploader': 'Scott Manley',
2707 'uploader_id': '@scottmanley',
2708 'title': 'The Computer Hack That Saved Apollo 14',
2709 'channel_id': 'UCxzC4EngIsMrPmbm6Nxvb-A',
2710 'thumbnail': r're:^https?://.*\.webp',
2711 'channel_url': 'https://www.youtube.com/channel/UCxzC4EngIsMrPmbm6Nxvb-A',
2712 'playable_in_embed': True,
2713 'comment_count': int,
2714 'channel_is_verified': True,
2715 'heatmap': 'count:100',
2718 'extractor_args': {'youtube': {'player_client': ['android'], 'player_skip': ['webpage']}},
2724 # YouTube <object> embed
2726 'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2727 'md5': '873c81d308b979f0e23ee7e620b312a3',
2729 'id': 'msN87y-iEx0',
2731 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2732 'upload_date': '20080526',
2733 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2735 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2736 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2737 'playable_in_embed': True,
2738 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2740 'comment_count': int,
2741 'channel': 'Christopher Sykes',
2742 'live_status': 'not_live',
2743 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2744 'availability': 'public',
2747 'categories': ['Science & Technology'],
2748 'channel_follower_count': int,
2749 'uploader': 'Christopher Sykes',
2750 'uploader_url': 'https://www.youtube.com/@ChristopherSykesDocumentaries',
2751 'uploader_id': '@ChristopherSykesDocumentaries',
2752 'heatmap': 'count:100',
2755 'skip_download': True,
2761 def suitable(cls, url):
2762 from ..utils import parse_qs
2765 if qs.get('list', [None])[0]:
2767 return super().suitable(url)
2769 def __init__(self, *args, **kwargs):
2770 super().__init__(*args, **kwargs)
2771 self._code_cache = {}
2772 self._player_cache = {}
2774 def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2775 lock = threading.Lock()
2776 start_time = time.time()
2777 formats = [f for f in formats if f.get('is_from_start')]
2779 def refetch_manifest(format_id, delay):
2780 nonlocal formats, start_time, is_live
2781 if time.time() <= start_time + delay:
2784 _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2785 video_details = traverse_obj(prs, (..., 'videoDetails'), expected_type=dict)
2786 microformats = traverse_obj(
2787 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2789 _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2790 is_live = live_status == 'is_live'
2791 start_time = time.time()
2793 def mpd_feed(format_id, delay):
2795 @returns (manifest_url, manifest_stream_number, is_live) or None
2797 for retry in self.RetryManager(fatal=False):
2799 refetch_manifest(format_id, delay)
2801 f = next((f for f in formats if f['format_id'] == format_id), None)
2804 retry.error = f'{video_id}: Video is no longer live'
2806 retry.error = f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}'
2808 return f['manifest_url'], f['manifest_stream_number'], is_live
2812 f['is_live'] = is_live
2813 gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2814 live_start_time, mpd_feed, not is_live and f.copy())
2816 f['fragments'] = gen
2817 f['protocol'] = 'http_dash_segments_generator'
2819 f['fragments'] = LazyList(gen({}))
2820 del f['is_from_start']
2822 def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2823 FETCH_SPAN, MAX_DURATION = 5, 432000
2825 mpd_url, stream_number, is_live = None, None, True
2828 download_start_time = ctx.get('start') or time.time()
2830 lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2831 if lack_early_segments:
2832 self.report_warning(bug_reports_message(
2833 'Starting download from the last 120 hours of the live stream since '
2834 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2835 lack_early_segments = True
2837 known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2838 fragments, fragment_base_url = None, None
2840 def _extract_sequence_from_mpd(refresh_sequence, immediate):
2841 nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2842 # Obtain from MPD's maximum seq value
2843 old_mpd_url = mpd_url
2844 last_error = ctx.pop('last_error', None)
2845 expire_fast = immediate or last_error and isinstance(last_error, HTTPError) and last_error.status == 403
2846 mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2847 or (mpd_url, stream_number, False))
2848 if not refresh_sequence:
2849 if expire_fast and not is_live:
2850 return False, last_seq
2851 elif old_mpd_url == mpd_url:
2852 return True, last_seq
2853 if manifestless_orig_fmt:
2854 fmt_info = manifestless_orig_fmt
2857 fmts, _ = self._extract_mpd_formats_and_subtitles(
2858 mpd_url, None, note=False, errnote=False, fatal=False)
2859 except ExtractorError:
2862 no_fragment_score += 2
2863 return False, last_seq
2864 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2865 fragments = fmt_info['fragments']
2866 fragment_base_url = fmt_info['fragment_base_url']
2867 assert fragment_base_url
2869 _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2870 return True, _last_seq
2872 self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2874 fetch_time = time.time()
2875 if no_fragment_score > 30:
2877 if last_segment_url:
2878 # Obtain from "X-Head-Seqnum" header value from each segment
2880 urlh = self._request_webpage(
2881 last_segment_url, None, note=False, errnote=False, fatal=False)
2882 except ExtractorError:
2884 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2885 if last_seq is None:
2886 no_fragment_score += 2
2887 last_segment_url = None
2890 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2891 no_fragment_score += 2
2892 if not should_continue:
2895 if known_idx > last_seq:
2896 last_segment_url = None
2901 if begin_index < 0 and known_idx < 0:
2902 # skip from the start when it's negative value
2903 known_idx = last_seq + begin_index
2904 if lack_early_segments:
2905 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2907 for idx in range(known_idx, last_seq):
2908 # do not update sequence here or you'll get skipped some part of it
2909 should_continue, _ = _extract_sequence_from_mpd(False, False)
2910 if not should_continue:
2912 raise ExtractorError('breaking out of outer loop')
2913 last_segment_url = urljoin(fragment_base_url, 'sq/%d' % idx)
2915 'url': last_segment_url,
2916 'fragment_count': last_seq,
2918 if known_idx == last_seq:
2919 no_fragment_score += 5
2921 no_fragment_score = 0
2922 known_idx = last_seq
2923 except ExtractorError:
2926 if manifestless_orig_fmt:
2927 # Stop at the first iteration if running for post-live manifestless;
2928 # fragment count no longer increase since it starts
2931 time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2933 def _extract_player_url(self, *ytcfgs, webpage=None):
2934 player_url = traverse_obj(
2935 ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2936 get_all=False, expected_type=str)
2939 return urljoin('https://www.youtube.com', player_url)
2941 def _download_player_url(self, video_id, fatal=False):
2942 res = self._download_webpage(
2943 'https://www.youtube.com/iframe_api',
2944 note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2946 player_version = self._search_regex(
2947 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2949 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2951 def _signature_cache_id(self, example_sig):
2952 """ Return a string representation of a signature """
2953 return '.'.join(str(len(part)) for part in example_sig.split('.'))
2956 def _extract_player_info(cls, player_url):
2957 for player_re in cls._PLAYER_INFO_RE:
2958 id_m = re.search(player_re, player_url)
2962 raise ExtractorError('Cannot identify player %r' % player_url)
2963 return id_m.group('id')
2965 def _load_player(self, video_id, player_url, fatal=True):
2966 player_id = self._extract_player_info(player_url)
2967 if player_id not in self._code_cache:
2968 code = self._download_webpage(
2969 player_url, video_id, fatal=fatal,
2970 note='Downloading player ' + player_id,
2971 errnote='Download of %s failed' % player_url)
2973 self._code_cache[player_id] = code
2974 return self._code_cache.get(player_id)
2976 def _extract_signature_function(self, video_id, player_url, example_sig):
2977 player_id = self._extract_player_info(player_url)
2979 # Read from filesystem cache
2980 func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2981 assert os.path.basename(func_id) == func_id
2983 self.write_debug(f'Extracting signature function {func_id}')
2984 cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
2987 code = self._load_player(video_id, player_url)
2989 res = self._parse_sig_js(code)
2990 test_string = ''.join(map(chr, range(len(example_sig))))
2991 cache_spec = [ord(c) for c in res(test_string)]
2992 self.cache.store('youtube-sigfuncs', func_id, cache_spec)
2994 return lambda s: ''.join(s[i] for i in cache_spec)
2996 def _print_sig_code(self, func, example_sig):
2997 if not self.get_param('youtube_print_sig_code'):
3000 def gen_sig_code(idxs):
3001 def _genslice(start, end, step):
3002 starts = '' if start == 0 else str(start)
3003 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
3004 steps = '' if step == 1 else (':%d' % step)
3005 return f's[{starts}{ends}{steps}]'
3008 # Quelch pyflakes warnings - start will be set when step is set
3009 start = '(Never used)'
3010 for i, prev in zip(idxs[1:], idxs[:-1]):
3011 if step is not None:
3012 if i - prev == step:
3014 yield _genslice(start, prev, step)
3017 if i - prev in [-1, 1]:
3022 yield 's[%d]' % prev
3026 yield _genslice(start, i, step)
3028 test_string = ''.join(map(chr, range(len(example_sig))))
3029 cache_res = func(test_string)
3030 cache_spec = [ord(c) for c in cache_res]
3031 expr_code = ' + '.join(gen_sig_code(cache_spec))
3032 signature_id_tuple = '(%s)' % (
3033 ', '.join(str(len(p)) for p in example_sig.split('.')))
3034 code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
3035 ' return %s\n') % (signature_id_tuple, expr_code)
3036 self.to_screen('Extracted signature function:\n' + code)
3038 def _parse_sig_js(self, jscode):
3039 funcname = self._search_regex(
3040 (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3041 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3042 r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
3043 r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
3044 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+\))?',
3045 r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
3047 r'("|\')signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3048 r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
3049 r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3050 r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3051 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3052 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
3053 jscode, 'Initial JS player signature function name', group='sig')
3055 jsi = JSInterpreter(jscode)
3056 initial_function = jsi.extract_function(funcname)
3057 return lambda s: initial_function([s])
3059 def _cached(self, func, *cache_id):
3060 def inner(*args, **kwargs):
3061 if cache_id not in self._player_cache:
3063 self._player_cache[cache_id] = func(*args, **kwargs)
3064 except ExtractorError as e:
3065 self._player_cache[cache_id] = e
3066 except Exception as e:
3067 self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
3069 ret = self._player_cache[cache_id]
3070 if isinstance(ret, Exception):
3075 def _decrypt_signature(self, s, video_id, player_url):
3076 """Turn the encrypted s field into a working signature"""
3077 extract_sig = self._cached(
3078 self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
3079 func = extract_sig(video_id, player_url, s)
3080 self._print_sig_code(func, s)
3083 def _decrypt_nsig(self, s, video_id, player_url):
3084 """Turn the encrypted n field into a working signature"""
3085 if player_url is None:
3086 raise ExtractorError('Cannot decrypt nsig without player_url')
3087 player_url = urljoin('https://www.youtube.com', player_url)
3090 jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
3091 except ExtractorError as e:
3092 raise ExtractorError('Unable to extract nsig function code', cause=e)
3093 if self.get_param('youtube_print_sig_code'):
3094 self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
3097 extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
3098 ret = extract_nsig(jsi, func_code)(s)
3099 except JSInterpreter.Exception as e:
3101 jsi = PhantomJSwrapper(self, timeout=5000)
3102 except ExtractorError:
3104 self.report_warning(
3105 f'Native nsig extraction failed: Trying with PhantomJS\n'
3106 f' n = {s} ; player = {player_url}', video_id)
3107 self.write_debug(e, only_once=True)
3109 args, func_body = func_code
3111 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
3112 video_id=video_id, note='Executing signature code').strip()
3114 self.write_debug(f'Decrypted nsig {s} => {ret}')
3117 def _extract_n_function_name(self, jscode):
3118 funcname, idx = self._search_regex(
3119 r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
3120 jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
3124 return json.loads(js_to_json(self._search_regex(
3125 rf'var {re.escape(funcname)}\s*=\s*(\[.+?\])\s*[,;]', jscode,
3126 f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
3128 def _extract_n_function_code(self, video_id, player_url):
3129 player_id = self._extract_player_info(player_url)
3130 func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
3131 jscode = func_code or self._load_player(video_id, player_url)
3132 jsi = JSInterpreter(jscode)
3135 return jsi, player_id, func_code
3137 func_name = self._extract_n_function_name(jscode)
3140 func_code = self._search_regex(
3141 r'''(?xs
)%s\s
*=\s
*function\s
*\
((?P
<var
>[\w$
]+)\
)\s
*
3142 # NB: The end of the regex is intentionally kept strict
3143 {(?P<code>.+?}\s
*return\
[\w$
]+.join\
(""\
))};''' % func_name,
3144 jscode, 'nsig function', group=('var', 'code'), default=None)
3146 func_code = ([func_code[0]], func_code[1])
3148 self.write_debug('Extracting nsig function with jsinterp')
3149 func_code = jsi.extract_function_code(func_name)
3151 self.cache.store('youtube-nsig', player_id, func_code)
3152 return jsi, player_id, func_code
3154 def _extract_n_function_from_code(self, jsi, func_code):
3155 func = jsi.extract_function_from_code(*func_code)
3157 def extract_nsig(s):
3160 except JSInterpreter.Exception:
3162 except Exception as e:
3163 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
3165 if ret.startswith('enhanced_except_'):
3166 raise JSInterpreter.Exception('Signature function returned an exception')
3171 def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3173 Extract signatureTimestamp (sts)
3174 Required to tell API what sig/player version is in use.
3177 if isinstance(ytcfg, dict):
3178 sts = int_or_none(ytcfg.get('STS'))
3181 # Attempt to extract from player
3182 if player_url is None:
3183 error_msg = 'Cannot extract signature timestamp without player_url.'
3185 raise ExtractorError(error_msg)
3186 self.report_warning(error_msg)
3188 code = self._load_player(video_id, player_url, fatal=fatal)
3190 sts = int_or_none(self._search_regex(
3191 r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3192 'JS player signature timestamp', group='sts', fatal=fatal))
3195 def _mark_watched(self, video_id, player_responses):
3196 for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3197 label = 'fully ' if is_full else ''
3198 url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3199 expected_type=url_or_none)
3201 self.report_warning(f'Unable to mark {label}watched')
3203 parsed_url = urllib.parse.urlparse(url)
3204 qs = urllib.parse.parse_qs(parsed_url.query)
3206 # cpn generation algorithm is reverse engineered from base.js.
3207 # In fact it works even with dummy cpn.
3208 CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3209 cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16))
3211 # # more consistent results setting it to right before the end
3212 video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3217 'cmt': video_length,
3218 'el': 'detailpage', # otherwise defaults to "shorts"
3222 # these seem to mark watchtime "history" in the real world
3223 # they're required, so send in a single value
3229 url = urllib.parse.urlunparse(
3230 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3232 self._download_webpage(
3233 url, video_id, f'Marking {label}watched',
3234 'Unable to mark watched', fatal=False)
3237 def _extract_from_webpage(cls, url, webpage):
3238 # Invidious Instances
3239 # https://github.com/yt-dlp/yt-dlp/issues/195
3240 # https://github.com/iv-org/invidious/pull/1730
3242 r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3245 yield cls.url_result(mobj.group('url'), cls)
3246 raise cls.StopExtraction()
3248 yield from super()._extract_from_webpage(url, webpage)
3250 # lazyYT YouTube embed
3251 for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3252 yield cls.url_result(unescapeHTML(id_), cls, id_)
3254 # Wordpress "YouTube Video Importer" plugin
3255 for m in re.findall(r'''(?x
)<div
[^
>]+
3256 class=(?P
<q1
>[\'"])[^\'"]*\byvii
_single
_video
_player
\b[^
\'"]*(?P=q1)[^>]+
3257 data-video_id=(?P<q2>[\'"])([^
\'"]+)(?P=q2)''', webpage):
3258 yield cls.url_result(m[-1], cls, m[-1])
3261 def extract_id(cls, url):
3262 video_id = cls.get_temp_id(url)
3264 raise ExtractorError(f'Invalid URL: {url}')
3267 def _extract_chapters_from_json(self, data, duration):
3268 chapter_list = traverse_obj(
3270 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3271 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters'
3272 ), expected_type=list)
3274 return self._extract_chapters_helper(
3276 start_function=lambda chapter: float_or_none(
3277 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3278 title_function=lambda chapter: traverse_obj(
3279 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3282 def _extract_chapters_from_engagement_panel(self, data, duration):
3283 content_list = traverse_obj(
3285 ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3287 chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3288 chapter_title = lambda chapter: self._get_text(chapter, 'title')
3290 return next(filter(None, (
3291 self._extract_chapters_helper(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3292 chapter_time, chapter_title, duration)
3293 for contents in content_list)), [])
3295 def _extract_heatmap(self, data):
3296 return traverse_obj(data, (
3297 'frameworkUpdates', 'entityBatchUpdate', 'mutations',
3298 lambda _, v: v['payload']['macroMarkersListEntity']['markersList']['markerType'] == 'MARKER_TYPE_HEATMAP',
3299 'payload', 'macroMarkersListEntity', 'markersList', 'markers', ..., {
3300 'start_time': ('startMillis', {functools.partial(float_or_none, scale=1000)}),
3301 'end_time': {lambda x: (int(x['startMillis']) + int(x['durationMillis'])) / 1000},
3302 'value': ('intensityScoreNormalized', {float_or_none}),
3305 def _extract_comment(self, comment_renderer, parent=None):
3306 comment_id = comment_renderer.get('commentId')
3312 'text': self._get_text(comment_renderer, 'contentText'),
3313 'like_count': self._get_count(comment_renderer, 'voteCount'),
3314 'author_id': traverse_obj(comment_renderer, ('authorEndpoint', 'browseEndpoint', 'browseId', {self.ucid_or_none})),
3315 'author': self._get_text(comment_renderer, 'authorText'),
3316 'author_thumbnail': traverse_obj(comment_renderer, ('authorThumbnail', 'thumbnails', -1, 'url', {url_or_none})),
3317 'parent': parent or 'root',
3320 # Timestamp is an estimate calculated from the current time and time_text
3321 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3322 timestamp = self._parse_time_text(time_text)
3325 # FIXME: non-standard, but we need a way of showing that it is an estimate.
3326 '_time_text': time_text,
3327 'timestamp': timestamp,
3330 info['author_url'] = urljoin(
3331 'https://www.youtube.com', traverse_obj(comment_renderer, ('authorEndpoint', (
3332 ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'))),
3333 expected_type=str, get_all=False))
3335 author_is_uploader = traverse_obj(comment_renderer, 'authorIsChannelOwner')
3336 if author_is_uploader is not None:
3337 info['author_is_uploader'] = author_is_uploader
3339 comment_abr = traverse_obj(
3340 comment_renderer, ('actionButtons', 'commentActionButtonsRenderer'), expected_type=dict)
3341 if comment_abr is not None:
3342 info['is_favorited'] = 'creatorHeart' in comment_abr
3344 badges = self._extract_badges([traverse_obj(comment_renderer, 'authorCommentBadge')])
3345 if self._has_badge(badges, BadgeType.VERIFIED):
3346 info['author_is_verified'] = True
3348 is_pinned = traverse_obj(comment_renderer, 'pinnedCommentBadge')
3350 info['is_pinned'] = True
3354 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3356 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3358 def extract_header(contents):
3359 _continuation = None
3360 for content in contents:
3361 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3362 expected_comment_count = self._get_count(
3363 comments_header_renderer, 'countText', 'commentsCount')
3365 if expected_comment_count is not None:
3366 tracker['est_total'] = expected_comment_count
3367 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3368 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3370 sort_menu_item = try_get(
3371 comments_header_renderer,
3372 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3373 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3375 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3376 if not _continuation:
3379 sort_text = str_or_none(sort_menu_item.get('title'))
3381 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3382 self.to_screen('Sorting comments by %s' % sort_text.lower())
3384 return _continuation
3386 def extract_thread(contents):
3388 tracker['current_page_thread'] = 0
3389 for content in contents:
3390 if not parent and tracker['total_parent_comments'] >= max_parents:
3392 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3393 comment_renderer = get_first(
3394 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3395 expected_type=dict, default={})
3397 comment = self._extract_comment(comment_renderer, parent)
3400 comment_id = comment['id']
3401 if comment.get('is_pinned'):
3402 tracker['pinned_comment_ids'].add(comment_id)
3403 # Sometimes YouTube may break and give us infinite looping comments.
3404 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3405 if comment_id in tracker['seen_comment_ids']:
3406 if comment_id in tracker['pinned_comment_ids'] and not comment.get('is_pinned'):
3407 # Pinned comments may appear a second time in newest first sort
3408 # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3410 self.report_warning(
3411 'Detected YouTube comments looping. Stopping comment extraction '
3412 f'{"for this thread" if parent else ""} as we probably cannot get any more.')
3415 tracker['seen_comment_ids'].add(comment['id'])
3417 tracker['running_total'] += 1
3418 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3421 # Attempt to get the replies
3422 comment_replies_renderer = try_get(
3423 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3425 if comment_replies_renderer:
3426 tracker['current_page_thread'] += 1
3427 comment_entries_iter = self._comment_entries(
3428 comment_replies_renderer, ytcfg, video_id,
3429 parent=comment.get('id'), tracker=tracker)
3430 yield from itertools.islice(comment_entries_iter, min(
3431 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3433 # Keeps track of counts across recursive calls
3438 current_page_thread=0,
3439 total_parent_comments=0,
3440 total_reply_comments=0,
3441 seen_comment_ids=set(),
3442 pinned_comment_ids=set()
3446 # YouTube comments have a max depth of 2
3447 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3449 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3450 'Set max replies in the max-comments extractor argument instead')
3451 if max_depth == 1 and parent:
3454 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
3455 lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
3457 continuation = self._extract_continuation(root_continuation_data)
3460 is_forced_continuation = False
3461 is_first_continuation = parent is None
3462 if is_first_continuation and not continuation:
3463 # Sometimes you can get comments by generating the continuation yourself,
3464 # even if YouTube initially reports them being disabled - e.g. stories comments.
3465 # Note: if the comment section is actually disabled, YouTube may return a response with
3466 # required check_get_keys missing. So we will disable that check initially in this case.
3467 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3468 is_forced_continuation = True
3470 continuation_items_path = (
3471 'onResponseReceivedEndpoints', ..., ('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems')
3472 for page_num in itertools.count(0):
3473 if not continuation:
3475 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3476 comment_prog_str = f"({tracker['running_total']}
/~{tracker['est_total']}
)"
3478 if is_first_continuation:
3479 note_prefix = 'Downloading comment section API JSON'
3481 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3482 tracker['current_page_thread'], comment_prog_str)
3484 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
3485 ' ' if parent else '', ' replies' if parent else '',
3486 page_num, comment_prog_str)
3488 # Do a deep check for incomplete data as sometimes YouTube may return no comments for a continuation
3489 # Ignore check if YouTube says the comment count is 0.
3490 check_get_keys = None
3491 if not is_forced_continuation and not (tracker['est_total'] == 0 and tracker['running_total'] == 0):
3492 check_get_keys = [[*continuation_items_path, ..., (
3493 'commentsHeaderRenderer' if is_first_continuation else ('commentThreadRenderer', 'commentRenderer'))]]
3495 response = self._extract_response(
3496 item_id=None, query=continuation,
3497 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3498 check_get_keys=check_get_keys)
3499 except ExtractorError as e:
3500 # Ignore incomplete data error for replies if retries didn't work.
3501 # This is to allow any other parent comments and comment threads to be downloaded.
3502 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3503 if 'incomplete data' in str(e).lower() and parent:
3504 if self.get_param('ignoreerrors') in (True, 'only_download'):
3505 self.report_warning(
3506 'Received incomplete data for a comment reply thread and retrying did not help. '
3507 'Ignoring to let other comments be downloaded. Pass --no-ignore-errors to not ignore.')
3510 raise ExtractorError(
3511 'Incomplete data received for comment reply thread. '
3512 'Pass --ignore-errors to ignore and allow rest of comments to download.',
3515 is_forced_continuation = False
3517 for continuation_items in traverse_obj(response, continuation_items_path, expected_type=list, default=[]):
3518 if is_first_continuation:
3519 continuation = extract_header(continuation_items)
3520 is_first_continuation = False
3525 for entry in extract_thread(continuation_items):
3529 continuation = self._extract_continuation({'contents': continuation_items})
3533 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3534 if message and not parent and tracker['running_total'] == 0:
3535 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3536 raise self.CommentsDisabled
3539 def _generate_comment_continuation(video_id):
3541 Generates initial comment section continuation token from given video id
3543 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3544 return base64.b64encode(token.encode()).decode()
3546 def _get_comments(self, ytcfg, video_id, contents, webpage):
3547 """Entry for comment extraction"""
3548 def _real_comment_extract(contents):
3550 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3551 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3552 yield from self._comment_entries(renderer, ytcfg, video_id)
3554 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3555 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3558 def _get_checkok_params():
3559 return {'contentCheckOk': True, 'racyCheckOk': True}
3562 def _generate_player_context(cls, sts=None):
3564 'html5Preference': 'HTML5_PREF_WANTS',
3567 context['signatureTimestamp'] = sts
3569 'playbackContext': {
3570 'contentPlaybackContext': context
3572 **cls._get_checkok_params()
3576 def _is_agegated(player_response):
3577 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3580 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3581 AGE_GATE_REASONS = (
3582 'confirm your age', 'age-restricted', 'inappropriate', # reason
3583 'age_verification_required', 'age_check_required', # status
3585 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3588 def _is_unplayable(player_response):
3589 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3591 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3593 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3594 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3595 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3596 headers = self.generate_api_headers(
3597 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3600 'videoId': video_id,
3602 if _split_innertube_client(client)[0] == 'android':
3603 yt_query['params'] = 'CgIQBg=='
3605 pp_arg = self._configuration_arg('player_params', [None], casesense=True)[0]
3607 yt_query['params'] = pp_arg
3609 yt_query.update(self._generate_player_context(sts))
3610 return self._extract_response(
3611 item_id=video_id, ep='player', query=yt_query,
3612 ytcfg=player_ytcfg, headers=headers, fatal=True,
3613 default_client=client,
3614 note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
3617 def _get_requested_clients(self, url, smuggled_data):
3618 requested_clients = []
3619 default = ['ios', 'android', 'web']
3620 allowed_clients = sorted(
3621 (client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'),
3622 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3623 for client in self._configuration_arg('player_client'):
3624 if client in allowed_clients:
3625 requested_clients.append(client)
3626 elif client == 'default':
3627 requested_clients.extend(default)
3628 elif client == 'all':
3629 requested_clients.extend(allowed_clients)
3631 self.report_warning(f'Skipping unsupported client {client}')
3632 if not requested_clients:
3633 requested_clients = default
3635 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3636 requested_clients.extend(
3637 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3639 return orderedSet(requested_clients)
3641 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3644 initial_pr = self._search_json(
3645 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3647 all_clients = set(clients)
3648 clients = clients[::-1]
3651 def append_client(*client_names):
3652 """ Append the first client name that exists but not already used """
3653 for client_name in client_names:
3654 actual_client = _split_innertube_client(client_name)[0]
3655 if actual_client in INNERTUBE_CLIENTS:
3656 if actual_client not in all_clients:
3657 clients.append(client_name)
3658 all_clients.add(actual_client)
3661 # Android player_response does not have microFormats which are needed for
3662 # extraction of some data. So we return the initial_pr with formats
3663 # stripped out even if not requested by the user
3664 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3666 pr = dict(initial_pr)
3667 pr['streamingData'] = None
3671 tried_iframe_fallback = False
3674 client, base_client, variant = _split_innertube_client(clients.pop())
3675 player_ytcfg = master_ytcfg if client == 'web' else {}
3676 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3677 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3679 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3680 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3681 if 'js' in self._configuration_arg('player_skip'):
3682 require_js_player = False
3685 if not player_url and not tried_iframe_fallback and require_js_player:
3686 player_url = self._download_player_url(video_id)
3687 tried_iframe_fallback = True
3690 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3691 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3692 except ExtractorError as e:
3694 self.report_warning(last_error)
3699 # YouTube may return a different video player response than expected.
3700 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3701 pr_video_id = traverse_obj(pr, ('videoDetails', 'videoId'))
3702 if pr_video_id and pr_video_id != video_id:
3703 self.report_warning(
3704 f'Skipping player response from {client} client (got player response for video "{pr_video_id}
" instead of "{video_id}
")' + bug_reports_message())
3706 # Save client name for introspection later
3707 name = short_client_name(client)
3708 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3709 sd[STREAMING_DATA_CLIENT_NAME] = name
3710 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3711 f[STREAMING_DATA_CLIENT_NAME] = name
3714 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3715 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3716 append_client(f'{base_client}_creator')
3717 elif self._is_agegated(pr):
3718 if variant == 'tv_embedded':
3719 append_client(f'{base_client}_embedded')
3721 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3726 self.report_warning(last_error)
3727 return prs, player_url
3729 def _needs_live_processing(self, live_status, duration):
3730 if (live_status == 'is_live' and self.get_param('live_from_start')
3731 or live_status == 'post_live' and (duration or 0) > 2 * 3600):
3734 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3735 CHUNK_SIZE = 10 << 20
3736 itags, stream_ids = collections.defaultdict(set), []
3737 itag_qualities, res_qualities = {}, {0: None}
3739 # Normally tiny is the smallest video-only formats. But
3740 # audio-only formats with unknown quality may get tagged as tiny
3742 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3743 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
3745 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3746 format_types = self._configuration_arg('formats')
3747 all_formats = 'duplicate' in format_types
3748 if self._configuration_arg('include_duplicate_formats'):
3750 self._downloader.deprecated_feature('[youtube] include_duplicate_formats extractor argument is deprecated. '
3751 'Use formats=duplicate extractor argument instead')
3753 def build_fragments(f):
3755 'url': update_url_query(f['url'], {
3756 'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}'
3758 } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3760 for fmt in streaming_formats:
3761 if fmt.get('targetDurationSec'):
3764 itag = str_or_none(fmt.get('itag'))
3765 audio_track = fmt.get('audioTrack') or {}
3766 stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3768 if stream_id in stream_ids:
3771 quality = fmt.get('quality')
3772 height = int_or_none(fmt.get('height'))
3773 if quality == 'tiny' or not quality:
3774 quality = fmt.get('audioQuality', '').lower() or quality
3775 # The 3gp format (17) in android client has a quality of "small
",
3776 # but is actually worse than other formats
3781 itag_qualities[itag] = quality
3783 res_qualities[height] = quality
3784 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3785 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3786 # number of fragment that would subsequently requested with (`&sq=N`)
3787 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3790 fmt_url = fmt.get('url')
3792 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3793 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3794 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3795 if not all((sc, fmt_url, player_url, encrypted_sig)):
3798 fmt_url += '&%s=%s' % (
3799 traverse_obj(sc, ('sp', -1)) or 'signature',
3800 self._decrypt_signature(encrypted_sig, video_id, player_url)
3802 except ExtractorError as e:
3803 self.report_warning('Signature extraction failed: Some formats may be missing',
3804 video_id=video_id, only_once=True)
3805 self.write_debug(e, only_once=True)
3808 query = parse_qs(fmt_url)
3812 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3813 fmt_url = update_url_query(fmt_url, {
3814 'n': decrypt_nsig(query['n'][0], video_id, player_url)
3816 except ExtractorError as e:
3818 if isinstance(e, JSInterpreter.Exception):
3819 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3820 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3822 self.report_warning(
3823 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3824 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3825 self.write_debug(e, only_once=True)
3827 self.report_warning(
3828 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3829 video_id=video_id, only_once=True)
3832 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3833 language_preference = (
3834 10 if audio_track.get('audioIsDefault') and 10
3835 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3837 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3838 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3839 # Make sure to avoid false positives with small duration differences.
3840 # E.g. __2ABJjxzNo, ySuUZEjARPY
3841 is_damaged = try_get(fmt, lambda x: float(x['approxDurationMs']) / duration < 500)
3843 self.report_warning(
3844 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3846 client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3847 name = fmt.get('qualityLabel') or quality.replace('audio_quality_', '') or ''
3848 fps = int_or_none(fmt.get('fps')) or 0
3850 'asr': int_or_none(fmt.get('audioSampleRate')),
3851 'filesize': int_or_none(fmt.get('contentLength')),
3852 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3853 'format_note': join_nonempty(
3854 join_nonempty(audio_track.get('displayName'),
3855 language_preference > 0 and ' (default)', delim=''),
3856 name, fmt.get('isDrc') and 'DRC',
3857 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3858 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3859 throttled and 'THROTTLED', is_damaged and 'DAMAGED',
3860 (self.get_param('verbose') or all_formats) and client_name,
3862 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3863 'source_preference': ((-10 if throttled else -5 if itag == '22' else -1)
3864 + (100 if 'Premium' in name else 0)),
3865 'fps': fps if fps > 1 else None, # For some formats, fps is wrongly returned as 1
3866 'audio_channels': fmt.get('audioChannels'),
3868 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3869 'has_drm': bool(fmt.get('drmFamilies')),
3872 'width': int_or_none(fmt.get('width')),
3873 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3874 'desc' if language_preference < -1 else '') or None,
3875 'language_preference': language_preference,
3876 # Strictly de-prioritize damaged and 3gp formats
3877 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3879 mime_mobj = re.match(
3880 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3882 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3883 dct.update(parse_codecs(mime_mobj.group(2)))
3885 itags[itag].add(('https
', dct.get('language
')))
3886 stream_ids.append(stream_id)
3887 single_stream = 'none
' in (dct.get('acodec
'), dct.get('vcodec
'))
3888 if single_stream and dct.get('ext
'):
3889 dct['container
'] = dct['ext
'] + '_dash
'
3891 if (all_formats or 'dashy
' in format_types) and dct['filesize
']:
3894 'format_id
': f'{dct["format_id"]}
-dashy
' if all_formats else dct['format_id
'],
3895 'protocol
': 'http_dash_segments
',
3896 'fragments
': build_fragments(dct),
3898 if all_formats or 'dashy
' not in format_types:
3899 dct['downloader_options
'] = {'http_chunk_size': CHUNK_SIZE}
3902 needs_live_processing = self._needs_live_processing(live_status, duration)
3903 skip_bad_formats = 'incomplete
' not in format_types
3904 if self._configuration_arg('include_incomplete_formats
'):
3905 skip_bad_formats = False
3906 self._downloader.deprecated_feature('[youtube
] include_incomplete_formats extractor argument
is deprecated
. '
3907 'Use formats
=incomplete extractor argument instead
')
3909 skip_manifests = set(self._configuration_arg('skip
'))
3910 if (not self.get_param('youtube_include_hls_manifest
', True)
3911 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3912 or needs_live_processing and skip_bad_formats):
3913 skip_manifests.add('hls
')
3915 if not self.get_param('youtube_include_dash_manifest
', True):
3916 skip_manifests.add('dash
')
3917 if self._configuration_arg('include_live_dash
'):
3918 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3919 'Use formats
=incomplete extractor argument instead
')
3920 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3921 skip_manifests.add('dash
')
3923 def process_manifest_format(f, proto, client_name, itag):
3924 key = (proto, f.get('language
'))
3925 if not all_formats and key in itags[itag]:
3927 itags[itag].add(key)
3929 if itag and all_formats:
3930 f['format_id
'] = f'{itag}
-{proto}
'
3931 elif any(p != proto for p, _ in itags[itag]):
3932 f['format_id
'] = f'{itag}
-{proto}
'
3934 f['format_id
'] = itag
3936 if f.get('source_preference
') is None:
3937 f['source_preference
'] = -1
3939 if itag in ('616', '235'):
3940 f['format_note
'] = join_nonempty(f.get('format_note
'), 'Premium
', delim=' ')
3941 f['source_preference
'] += 100
3943 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
3944 if f['quality
'] == -1 and f.get('height
'):
3945 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
3946 if self.get_param('verbose
') or all_formats:
3947 f['format_note
'] = join_nonempty(f.get('format_note
'), client_name, delim=', ')
3948 if f.get('fps
') and f['fps
'] <= 1:
3951 if proto == 'hls
' and f.get('has_drm
'):
3952 f['has_drm
'] = 'maybe
'
3953 f['source_preference
'] -= 5
3957 for sd in streaming_data:
3958 client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
3960 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
3961 if hls_manifest_url:
3962 fmts, subs = self._extract_m3u8_formats_and_subtitles(
3963 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
3964 subtitles = self._merge_subtitles(subs, subtitles)
3966 if process_manifest_format(f, 'hls
', client_name, self._search_regex(
3967 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
3970 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
3971 if dash_manifest_url:
3972 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
3973 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
3975 if process_manifest_format(f, 'dash
', client_name, f['format_id
']):
3976 f['filesize
'] = int_or_none(self._search_regex(
3977 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
3978 if needs_live_processing:
3979 f['is_from_start
'] = True
3984 def _extract_storyboard(self, player_responses, duration):
3986 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
3987 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
3991 for i, args in enumerate(spec):
3992 args = args.split('#')
3993 counts
= list(map(int_or_none
, args
[:5]))
3994 if len(args
) != 8 or not all(counts
):
3995 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
3997 width
, height
, frame_count
, cols
, rows
= counts
4000 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
4001 fragment_count
= frame_count
/ (cols
* rows
)
4002 fragment_duration
= duration
/ fragment_count
4004 'format_id': f
'sb{i}',
4005 'format_note': 'storyboard',
4007 'protocol': 'mhtml',
4013 'fps': frame_count
/ duration
,
4017 'url': url
.replace('$M', str(j
)),
4018 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
4019 } for j
in range(math
.ceil(fragment_count
))],
4022 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
4024 if 'webpage' not in self
._configuration
_arg
('player_skip'):
4025 query
= {'bpctr': '9999999999', 'has_verified': '1'}
4026 pp
= self
._configuration
_arg
('player_params', [None], casesense
=True)[0]
4029 webpage
= self
._download
_webpage
(
4030 webpage_url
, video_id
, fatal
=False, query
=query
)
4032 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
4034 player_responses
, player_url
= self
._extract
_player
_responses
(
4035 self
._get
_requested
_clients
(url
, smuggled_data
),
4036 video_id
, webpage
, master_ytcfg
, smuggled_data
)
4038 return webpage
, master_ytcfg
, player_responses
, player_url
4040 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
4041 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
4042 is_live
= get_first(video_details
, 'isLive')
4044 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
4045 live_content
= get_first(video_details
, 'isLiveContent')
4046 is_upcoming
= get_first(video_details
, 'isUpcoming')
4047 post_live
= get_first(video_details
, 'isPostLiveDvr')
4048 live_status
= ('post_live' if post_live
4049 else 'is_live' if is_live
4050 else 'is_upcoming' if is_upcoming
4051 else 'was_live' if live_content
4052 else 'not_live' if False in (is_live
, live_content
)
4054 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'))
4055 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
4056 if all(f
.get('has_drm') for f
in formats
):
4057 # If there are no formats that definitely don't have DRM, all have DRM
4061 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
4063 def _real_extract(self
, url
):
4064 url
, smuggled_data
= unsmuggle_url(url
, {})
4065 video_id
= self
._match
_id
(url
)
4067 base_url
= self
.http_scheme() + '//www.youtube.com/'
4068 webpage_url
= base_url
+ 'watch?v=' + video_id
4070 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
4072 playability_statuses
= traverse_obj(
4073 player_responses
, (..., 'playabilityStatus'), expected_type
=dict)
4075 trailer_video_id
= get_first(
4076 playability_statuses
,
4077 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
4079 if trailer_video_id
:
4080 return self
.url_result(
4081 trailer_video_id
, self
.ie_key(), trailer_video_id
)
4083 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
4084 if webpage
else (lambda x
: None))
4086 video_details
= traverse_obj(player_responses
, (..., 'videoDetails'), expected_type
=dict)
4087 microformats
= traverse_obj(
4088 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
4091 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
4092 video_title
= (self
._preferred
_lang
and translated_title
4093 or get_first(video_details
, 'title') # primary
4095 or search_meta(['og:title', 'twitter:title', 'title']))
4096 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
4097 original_description
= get_first(video_details
, 'shortDescription')
4098 video_description
= (
4099 self
._preferred
_lang
and translated_description
4100 # If original description is blank, it will be an empty string.
4101 # Do not prefer translated description in this case.
4102 or original_description
if original_description
is not None else translated_description
)
4104 multifeed_metadata_list
= get_first(
4106 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
4108 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
4109 if self
.get_param('noplaylist'):
4110 self
.to_screen('Downloading just video %s because of --no-playlist' % video_id
)
4114 for feed
in multifeed_metadata_list
.split(','):
4115 # Unquote should take place before split on comma (,) since textual
4116 # fields may contain comma as well (see
4117 # https://github.com/ytdl-org/youtube-dl/issues/8536)
4118 feed_data
= urllib
.parse
.parse_qs(
4119 urllib
.parse
.unquote_plus(feed
))
4121 def feed_entry(name
):
4123 feed_data
, lambda x
: x
[name
][0], str)
4125 feed_id
= feed_entry('id')
4128 feed_title
= feed_entry('title')
4131 title
+= ' (%s)' % feed_title
4133 '_type': 'url_transparent',
4134 'ie_key': 'Youtube',
4136 '%swatch?v=%s' % (base_url
, feed_data
['id'][0]),
4137 {'force_singlefeed': True}
),
4140 feed_ids
.append(feed_id
)
4142 'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
4143 % (', '.join(feed_ids
), video_id
))
4144 return self
.playlist_result(
4145 entries
, video_id
, video_title
, video_description
)
4147 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
4148 or int_or_none(get_first(microformats
, 'lengthSeconds'))
4149 or parse_duration(search_meta('duration')) or None)
4151 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
4152 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
4153 if live_status
== 'post_live':
4154 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
4157 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
4158 self
.report_drm(video_id
)
4160 playability_statuses
,
4161 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
4162 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
4163 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
4165 if subreason
== 'The uploader has not made this video available in your country.':
4166 countries
= get_first(microformats
, 'availableCountries')
4168 regions_allowed
= search_meta('regionsAllowed')
4169 countries
= regions_allowed
.split(',') if regions_allowed
else None
4170 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
4171 reason
+= f
'. {subreason}'
4173 self
.raise_no_formats(reason
, expected
=True)
4175 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
4176 if not keywords
and webpage
:
4178 unescapeHTML(m
.group('content'))
4179 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
4180 for keyword
in keywords
:
4181 if keyword
.startswith('yt:stretch='):
4182 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
4184 # NB: float is intentional for forcing float division
4185 w
, h
= (float(v
) for v
in mobj
.groups())
4189 if f
.get('vcodec') != 'none':
4190 f
['stretched_ratio'] = ratio
4192 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
4193 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
4196 'url': thumbnail_url
,
4198 original_thumbnails
= thumbnails
.copy()
4200 # The best resolution thumbnails sometimes does not appear in the webpage
4201 # See: https://github.com/yt-dlp/yt-dlp/issues/340
4202 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4204 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4205 # in resolution, these are not the custom thumbnail. So de-prioritize them
4206 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4207 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3'
4209 n_thumbnail_names
= len(thumbnail_names
)
4211 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4212 video_id
=video_id
, name
=name
, ext
=ext
,
4213 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
4214 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
4215 for thumb
in thumbnails
:
4216 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
4217 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
4218 self
._remove
_duplicate
_formats
(thumbnails
)
4219 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
4221 category
= get_first(microformats
, 'category') or search_meta('genre')
4222 channel_id
= self
.ucid_or_none(str_or_none(
4223 get_first(video_details
, 'channelId')
4224 or get_first(microformats
, 'externalChannelId')
4225 or search_meta('channelId')))
4226 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
4228 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
4229 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
4230 if not duration
and live_end_time
and live_start_time
:
4231 duration
= live_end_time
- live_start_time
4233 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
4235 def is_bad_format(fmt
):
4236 if needs_live_processing
and not fmt
.get('is_from_start'):
4238 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
4239 and fmt
.get('protocol') == 'http_dash_segments'):
4242 for fmt
in filter(is_bad_format
, formats
):
4243 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4244 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 2 hours)', delim
=' ')
4246 if needs_live_processing
:
4247 self
._prepare
_live
_from
_start
_formats
(
4248 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4250 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4252 channel_handle
= self
.handle_from_url(owner_profile_url
)
4256 'title': video_title
,
4258 'thumbnails': thumbnails
,
4259 # The best thumbnail that we are sure exists. Prevents unnecessary
4260 # URL checking if user don't care about getting the best possible thumbnail
4261 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4262 'description': video_description
,
4263 'channel_id': channel_id
,
4264 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None),
4265 'duration': duration
,
4266 'view_count': int_or_none(
4267 get_first((video_details
, microformats
), (..., 'viewCount'))
4268 or search_meta('interactionCount')),
4269 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4270 'age_limit': 18 if (
4271 get_first(microformats
, 'isFamilySafe') is False
4272 or search_meta('isFamilyFriendly') == 'false'
4273 or search_meta('og:restrictions:age') == '18+') else 0,
4274 'webpage_url': webpage_url
,
4275 'categories': [category
] if category
else None,
4277 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4278 'live_status': live_status
,
4279 'release_timestamp': live_start_time
,
4280 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4281 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto')
4285 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4287 def get_lang_code(track
):
4288 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4289 or track
.get('languageCode'))
4291 # Converted into dicts to remove duplicates
4293 get_lang_code(sub
): sub
4294 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...))}
4295 translation_languages
= {
4296 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4297 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...))}
4299 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4300 lang_subs
= container
.setdefault(lang_code
, [])
4301 for fmt
in self
._SUBTITLE
_FORMATS
:
4307 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4311 # NB: Constructing the full subtitle dictionary is slow
4312 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4313 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4314 for lang_code
, caption_track
in captions
.items():
4315 base_url
= caption_track
.get('baseUrl')
4316 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4319 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4320 if caption_track
.get('kind') != 'asr':
4324 subtitles
, base_url
, lang_code
, lang_name
, {})
4325 if not caption_track
.get('isTranslatable'):
4327 for trans_code
, trans_name
in translation_languages
.items():
4330 orig_trans_code
= trans_code
4331 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4332 if not get_translated_subs
:
4334 trans_code
+= f
'-{lang_code}'
4335 trans_name
+= format_field(lang_name
, None, ' from %s')
4336 if lang_code
== f
'a-{orig_trans_code}':
4337 # Set audio language based on original subtitles
4339 if f
.get('acodec') != 'none' and not f
.get('language'):
4340 f
['language'] = orig_trans_code
4341 # Add an "-orig" label to the original language so that it can be distinguished.
4342 # The subs are returned without "-orig" as well for compatibility
4344 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4345 # Setting tlang=lang returns damaged subtitles.
4346 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4347 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4349 info
['automatic_captions'] = automatic_captions
4350 info
['subtitles'] = subtitles
4352 parsed_url
= urllib
.parse
.urlparse(url
)
4353 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4354 query
= urllib
.parse
.parse_qs(component
)
4355 for k
, v
in query
.items():
4356 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4358 if d_k
not in info
and k
in s_ks
:
4359 info
[d_k
] = parse_duration(query
[k
][0])
4361 # Youtube Music Auto-generated description
4362 if (video_description
or '').strip().endswith('\nAuto-generated by YouTube.'):
4363 # XXX: Causes catastrophic backtracking if description has "·"
4364 # E.g. https://www.youtube.com/watch?v=DoPaAxMQoiI
4365 # Simulating atomic groups: (?P<a>[^xy]+)x => (?=(?P<a>[^xy]+))(?P=a)x
4366 # reduces it, but does not fully fix it. https://regex101.com/r/8Ssf2h/2
4369 (?=(?P<track>[^\n·]+))(?P=track)·
4370 (?=(?P<artist>[^\n]+))(?P=artist)\n+
4371 (?=(?P<album>[^\n]+))(?P=album)\n
4372 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4373 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4375 (?=(?P<clean_artist>[^\n]+))(?P=clean_artist)\n
4376 )?.+\nAuto-generated\ by\ YouTube\.\s*$
4377 ''', video_description
)
4379 release_year
= mobj
.group('release_year')
4380 release_date
= mobj
.group('release_date')
4382 release_date
= release_date
.replace('-', '')
4383 if not release_year
:
4384 release_year
= release_date
[:4]
4386 'album': mobj
.group('album'.strip()),
4387 'artist': mobj
.group('clean_artist') or ', '.join(a
.strip() for a
in mobj
.group('artist').split('·')),
4388 'track': mobj
.group('track').strip(),
4389 'release_date': release_date
,
4390 'release_year': int_or_none(release_year
),
4395 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4396 if not traverse_obj(initial_data
, 'contents'):
4397 self
.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4399 if not initial_data
:
4400 query
= {'videoId': video_id}
4401 query
.update(self
._get
_checkok
_params
())
4402 initial_data
= self
._extract
_response
(
4403 item_id
=video_id
, ep
='next', fatal
=False,
4404 ytcfg
=master_ytcfg
, query
=query
, check_get_keys
='contents',
4405 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4406 note
='Downloading initial data API JSON')
4408 info
['comment_count'] = traverse_obj(initial_data
, (
4409 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4410 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount'
4412 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4413 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo'
4414 ), expected_type
=self
._get
_count
, get_all
=False)
4416 try: # This will error if there is no livechat
4417 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4418 except (KeyError, IndexError, TypeError):
4421 info
.setdefault('subtitles', {})['live_chat'] = [{
4422 # url is needed to set cookies
4423 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4424 'video_id': video_id
,
4426 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4427 else 'youtube_live_chat_replay'),
4431 info
['chapters'] = (
4432 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4433 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4434 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4437 info
['heatmap'] = self
._extract
_heatmap
(initial_data
)
4439 contents
= traverse_obj(
4440 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4441 expected_type
=list, default
=[])
4443 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4445 stl
= vpir
.get('superTitleLink')
4447 stl
= self
._get
_text
(stl
)
4450 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4451 info
['location'] = stl
4453 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4456 'series': mobj
.group(1),
4457 'season_number': int(mobj
.group(2)),
4458 'episode_number': int(mobj
.group(3)),
4460 for tlb
in (try_get(
4462 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4466 tlb
, ('toggleButtonRenderer', ...),
4467 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4469 for getter
, regex
in [(
4470 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4471 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4472 lambda x
: x
['accessibility'],
4473 lambda x
: x
['accessibilityData']['accessibilityData'],
4474 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4475 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4477 mobj
= re
.match(regex
, label
)
4479 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4481 sbr_tooltip
= try_get(
4482 vpir
, lambda x
: x
['sentimentBar']['sentimentBarRenderer']['tooltip'])
4484 like_count
, dislike_count
= sbr_tooltip
.split(' / ')
4486 'like_count': str_to_int(like_count
),
4487 'dislike_count': str_to_int(dislike_count
),
4489 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4491 vc
= self
._get
_count
(vcr
, 'viewCount')
4492 # Upcoming premieres with waiting count are treated as live here
4493 if vcr
.get('isLive'):
4494 info
['concurrent_view_count'] = vc
4495 elif info
.get('view_count') is None:
4496 info
['view_count'] = vc
4498 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4500 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4502 'channel': self
._get
_text
(vor
, 'title'),
4503 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4505 if not channel_handle
:
4506 channel_handle
= self
.handle_from_url(
4508 ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4509 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4510 {str}
), get_all
=False))
4514 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4516 multiple_songs
= False
4518 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4519 multiple_songs
= True
4522 mrr
= row
.get('metadataRowRenderer') or {}
4523 mrr_title
= mrr
.get('title')
4526 mrr_title
= self
._get
_text
(mrr
, 'title')
4527 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4528 if mrr_title
== 'License':
4529 info
['license'] = mrr_contents_text
4530 elif not multiple_songs
:
4531 if mrr_title
== 'Album':
4532 info
['album'] = mrr_contents_text
4533 elif mrr_title
== 'Artist':
4534 info
['artist'] = mrr_contents_text
4535 elif mrr_title
== 'Song':
4536 info
['track'] = mrr_contents_text
4537 owner_badges
= self
._extract
_badges
(traverse_obj(vsir
, ('owner', 'videoOwnerRenderer', 'badges')))
4538 if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
):
4539 info
['channel_is_verified'] = True
4542 'uploader': info
.get('channel'),
4543 'uploader_id': channel_handle
,
4544 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4546 # The upload date for scheduled, live and past live streams / premieres in microformats
4547 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4548 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4550 unified_strdate(get_first(microformats
, 'uploadDate'))
4551 or unified_strdate(search_meta('uploadDate')))
4552 if not upload_date
or (
4553 live_status
in ('not_live', None)
4554 and 'no-youtube-prefer-utc-upload-date' not in self
.get_param('compat_opts', [])
4556 upload_date
= strftime_or_none(
4557 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText'))) or upload_date
4558 info
['upload_date'] = upload_date
4560 for s_k
, d_k
in [('artist', 'creator'), ('track', 'alt_title')]:
4565 badges
= self
._extract
_badges
(traverse_obj(vpir
, 'badges'))
4567 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4568 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4570 info
['availability'] = (
4571 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4572 else self
._availability
(
4573 is_private
=is_private
,
4575 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4576 or False if initial_data
and is_private
is not None else None),
4577 needs_subscription
=(
4578 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4579 or False if initial_data
and is_private
is not None else None),
4580 needs_auth
=info
['age_limit'] >= 18,
4581 is_unlisted
=None if is_private
is None else (
4582 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4583 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4585 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4587 self
.mark_watched(video_id
, player_responses
)
4592 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4594 def passthrough_smuggled_data(func
):
4595 def _smuggle(info
, smuggled_data
):
4596 if info
.get('_type') not in ('url', 'url_transparent'):
4598 if smuggled_data
.get('is_music_url'):
4599 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4600 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4601 smuggled_data
.pop('is_music_url')
4602 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4604 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4607 @functools.wraps(func
)
4608 def wrapper(self
, url
):
4609 url
, smuggled_data
= unsmuggle_url(url
, {})
4610 if self
.is_music_url(url
):
4611 smuggled_data
['is_music_url'] = True
4612 info_dict
= func(self
, url
, smuggled_data
)
4614 _smuggle(info_dict
, smuggled_data
)
4615 if info_dict
.get('entries'):
4616 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4621 def _extract_basic_item_renderer(item
):
4622 # Modified from _extract_grid_item_renderer
4623 known_basic_renderers
= (
4624 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer'
4626 for key
, renderer
in item
.items():
4627 if not isinstance(renderer
, dict):
4629 elif key
in known_basic_renderers
:
4631 elif key
.startswith('grid') and key
.endswith('Renderer'):
4634 def _extract_channel_renderer(self
, renderer
):
4635 channel_id
= self
.ucid_or_none(renderer
['channelId'])
4636 title
= self
._get
_text
(renderer
, 'title')
4637 channel_url
= format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None)
4638 channel_handle
= self
.handle_from_url(
4639 traverse_obj(renderer
, (
4640 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4641 ('browseEndpoint', 'canonicalBaseUrl')),
4642 {str}
), get_all
=False))
4643 if not channel_handle
:
4644 # As of 2023-06-01, YouTube sets subscriberCountText to the handle in search
4645 channel_handle
= self
.handle_or_none(self
._get
_text
(renderer
, 'subscriberCountText'))
4650 'ie_key': YoutubeTabIE
.ie_key(),
4653 'channel_id': channel_id
,
4654 'channel_url': channel_url
,
4656 'uploader_id': channel_handle
,
4657 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4658 # See above. YouTube sets videoCountText to the subscriber text in search channel renderers.
4659 # However, in feed/channels this is set correctly to the subscriber count
4660 'channel_follower_count': traverse_obj(
4661 renderer
, 'subscriberCountText', 'videoCountText', expected_type
=self
._get
_count
),
4662 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
4664 # videoCountText may be the subscriber count
4665 self
._get
_count
(renderer
, 'videoCountText')
4666 if self
._get
_count
(renderer
, 'subscriberCountText') is not None else None),
4667 'description': self
._get
_text
(renderer
, 'descriptionSnippet'),
4668 'channel_is_verified': True if self
._has
_badge
(
4669 self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges')), BadgeType
.VERIFIED
) else None,
4672 def _grid_entries(self
, grid_renderer
):
4673 for item
in grid_renderer
['items']:
4674 if not isinstance(item
, dict):
4676 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4677 if not isinstance(renderer
, dict):
4679 title
= self
._get
_text
(renderer
, 'title')
4682 playlist_id
= renderer
.get('playlistId')
4684 yield self
.url_result(
4685 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4686 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4690 video_id
= renderer
.get('videoId')
4692 yield self
._extract
_video
(renderer
)
4695 channel_id
= renderer
.get('channelId')
4697 yield self
._extract
_channel
_renderer
(renderer
)
4699 # generic endpoint URL support
4700 ep_url
= urljoin('https://www.youtube.com/', try_get(
4701 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4704 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4705 if ie
.suitable(ep_url
):
4706 yield self
.url_result(
4707 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4710 def _music_reponsive_list_entry(self
, renderer
):
4711 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4713 title
= traverse_obj(renderer
, (
4714 'flexColumns', 0, 'musicResponsiveListItemFlexColumnRenderer',
4715 'text', 'runs', 0, 'text'))
4716 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4717 ie
=YoutubeIE
.ie_key(), video_id
=video_id
, title
=title
)
4718 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4720 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4722 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4723 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4724 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4725 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4726 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4728 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4729 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4731 def _shelf_entries_from_content(self
, shelf_renderer
):
4732 content
= shelf_renderer
.get('content')
4733 if not isinstance(content
, dict):
4735 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4737 # TODO: add support for nested playlists so each shelf is processed
4738 # as separate playlist
4739 # TODO: this includes only first N items
4740 yield from self
._grid
_entries
(renderer
)
4741 renderer
= content
.get('horizontalListRenderer')
4746 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4748 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4750 shelf_url
= urljoin('https://www.youtube.com', ep
)
4752 # Skipping links to another channels, note that checking for
4753 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4755 if skip_channels
and '/channels?' in shelf_url
:
4757 title
= self
._get
_text
(shelf_renderer
, 'title')
4758 yield self
.url_result(shelf_url
, video_title
=title
)
4759 # Shelf may not contain shelf URL, fallback to extraction from content
4760 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4762 def _playlist_entries(self
, video_list_renderer
):
4763 for content
in video_list_renderer
['contents']:
4764 if not isinstance(content
, dict):
4766 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4767 if not isinstance(renderer
, dict):
4769 video_id
= renderer
.get('videoId')
4772 yield self
._extract
_video
(renderer
)
4774 def _rich_entries(self
, rich_grid_renderer
):
4775 renderer
= traverse_obj(
4777 ('content', ('videoRenderer', 'reelItemRenderer', 'playlistRenderer')), get_all
=False) or {}
4778 video_id
= renderer
.get('videoId')
4780 yield self
._extract
_video
(renderer
)
4782 playlist_id
= renderer
.get('playlistId')
4784 yield self
.url_result(
4785 f
'https://www.youtube.com/playlist?list={playlist_id}',
4786 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4787 video_title
=self
._get
_text
(renderer
, 'title'))
4790 def _video_entry(self
, video_renderer
):
4791 video_id
= video_renderer
.get('videoId')
4793 return self
._extract
_video
(video_renderer
)
4795 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4796 url
= urljoin('https://youtube.com', traverse_obj(
4797 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4799 return self
.url_result(
4800 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4802 def _post_thread_entries(self
, post_thread_renderer
):
4803 post_renderer
= try_get(
4804 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4805 if not post_renderer
:
4808 video_renderer
= try_get(
4809 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4810 video_id
= video_renderer
.get('videoId')
4812 entry
= self
._extract
_video
(video_renderer
)
4815 # playlist attachment
4816 playlist_id
= try_get(
4817 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4819 yield self
.url_result(
4820 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4821 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4822 # inline video links
4823 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4825 if not isinstance(run
, dict):
4828 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4831 if not YoutubeIE
.suitable(ep_url
):
4833 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4834 if video_id
== ep_video_id
:
4836 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4838 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4839 contents
= post_thread_continuation
.get('contents')
4840 if not isinstance(contents
, list):
4842 for content
in contents
:
4843 renderer
= content
.get('backstagePostThreadRenderer')
4844 if isinstance(renderer
, dict):
4845 yield from self
._post
_thread
_entries
(renderer
)
4847 renderer
= content
.get('videoRenderer')
4848 if isinstance(renderer
, dict):
4849 yield self
._video
_entry
(renderer
)
4852 def _rich_grid_entries(self, contents):
4853 for content in contents:
4854 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4856 entry = self._video_entry(video_renderer)
4861 def _report_history_entries(self
, renderer
):
4862 for url
in traverse_obj(renderer
, (
4863 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4864 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4865 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4866 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4868 def _extract_entries(self
, parent_renderer
, continuation_list
):
4869 # continuation_list is modified in-place with continuation_list = [continuation_token]
4870 continuation_list
[:] = [None]
4871 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4872 for content
in contents
:
4873 if not isinstance(content
, dict):
4875 is_renderer
= traverse_obj(
4876 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4879 if content
.get('richItemRenderer'):
4880 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4882 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4883 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4884 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4885 yield from self
._report
_history
_entries
(table
)
4886 continuation_list
[0] = self
._extract
_continuation
(table
)
4889 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4890 for isr_content
in isr_contents
:
4891 if not isinstance(isr_content
, dict):
4895 'playlistVideoListRenderer': self
._playlist
_entries
,
4896 'gridRenderer': self
._grid
_entries
,
4897 'reelShelfRenderer': self
._grid
_entries
,
4898 'shelfRenderer': self
._shelf
_entries
,
4899 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4900 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4901 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4902 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4903 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4904 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)],
4905 'richGridRenderer': lambda x
: self
._extract
_entries
(x
, continuation_list
),
4907 for key
, renderer
in isr_content
.items():
4908 if key
not in known_renderers
:
4910 for entry
in known_renderers
[key
](renderer
):
4913 continuation_list
[0] = self
._extract
_continuation
(renderer
)
4916 if not continuation_list
[0]:
4917 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
4919 if not continuation_list
[0]:
4920 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4922 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
4923 continuation_list
= [None]
4924 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
4925 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
4929 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
4930 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
4931 yield from extract_entries(parent_renderer
)
4932 continuation
= continuation_list
[0]
4933 seen_continuations
= set()
4934 for page_num
in itertools
.count(1):
4935 if not continuation
:
4937 continuation_token
= continuation
.get('continuation')
4938 if continuation_token
is not None and continuation_token
in seen_continuations
:
4939 self
.write_debug('Detected YouTube feed looping - assuming end of feed.')
4941 seen_continuations
.add(continuation_token
)
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
, HTTPError
) or e
.cause
.status
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 YoutubeShortsAudioPivotIE(InfoExtractor
):
7149 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
7150 IE_NAME
= 'youtube:shorts:pivot:audio'
7151 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
7153 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
7154 'only_matching': True,
7158 def _generate_audio_pivot_params(video_id
):
7160 Generates sfv_audio_pivot browse params for this video id
7162 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
7163 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
7165 def _real_extract(self
, url
):
7166 video_id
= self
._match
_id
(url
)
7167 return self
.url_result(
7168 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
7172 class YoutubeTruncatedURLIE(InfoExtractor
):
7173 IE_NAME
= 'youtube:truncated_url'
7174 IE_DESC
= False # Do not list
7175 _VALID_URL
= r
'''(?x)
7177 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
7180 annotation_id=annotation_[^&]+|
7186 attribution_link\?a=[^&]+
7192 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
7193 'only_matching': True,
7195 'url': 'https://www.youtube.com/watch?',
7196 'only_matching': True,
7198 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
7199 'only_matching': True,
7201 'url': 'https://www.youtube.com/watch?feature=foo',
7202 'only_matching': True,
7204 'url': 'https://www.youtube.com/watch?hl=en-GB',
7205 'only_matching': True,
7207 'url': 'https://www.youtube.com/watch?t=2372',
7208 'only_matching': True,
7211 def _real_extract(self
, url
):
7212 raise ExtractorError(
7213 'Did you forget to quote the URL? Remember that & is a meta '
7214 'character in most shells, so you want to put the URL in quotes, '
7216 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
7217 ' or simply youtube-dl BaW_jenozKc .',
7221 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
7222 IE_NAME
= 'youtube:clip'
7223 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7225 # FIXME: Other metadata should be extracted from the clip, not from the base video
7226 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7228 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7230 'section_start': 29.0,
7231 'section_end': 39.7,
7234 'availability': 'public',
7235 'categories': ['Gaming'],
7236 'channel': 'Scott The Woz',
7237 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7238 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7239 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7241 'playable_in_embed': True,
7243 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7244 'title': 'Mobile Games on Console - Scott The Woz',
7245 'upload_date': '20210920',
7246 'uploader': 'Scott The Woz',
7247 'uploader_id': '@ScottTheWoz',
7248 'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7250 'live_status': 'not_live',
7251 'channel_follower_count': int,
7252 'chapters': 'count:20',
7253 'comment_count': int,
7254 'heatmap': 'count:100',
7258 def _real_extract(self
, url
):
7259 clip_id
= self
._match
_id
(url
)
7260 _
, data
= self
._extract
_webpage
(url
, clip_id
)
7262 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7264 raise ExtractorError('Unable to find video ID')
7266 clip_data
= traverse_obj(data
, (
7267 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7268 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7269 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7270 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
7273 '_type': 'url_transparent',
7274 'url': f
'https://www.youtube.com/watch?v={video_id}',
7275 'ie_key': YoutubeIE
.ie_key(),
7277 'section_start': int(clip_data
['startTimeMs']) / 1000,
7278 'section_end': int(clip_data
['endTimeMs']) / 1000,
7282 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor
):
7283 IE_NAME
= 'youtube:consent'
7284 IE_DESC
= False # Do not list
7285 _VALID_URL
= r
'https?://consent\.youtube\.com/m\?'
7287 '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',
7289 'id': 'qVv6vCqciTM',
7292 'uploader_id': '@sana_natori',
7293 'comment_count': int,
7294 'chapters': 'count:13',
7295 'upload_date': '20221223',
7296 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7297 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7298 'uploader_url': 'https://www.youtube.com/@sana_natori',
7300 'release_date': '20221223',
7301 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7302 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7304 'playable_in_embed': True,
7306 'availability': 'public',
7307 'channel_follower_count': int,
7308 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7309 'categories': ['Entertainment'],
7310 'live_status': 'was_live',
7311 'release_timestamp': 1671793345,
7312 'channel': 'さなちゃんねる',
7313 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7314 'uploader': 'さなちゃんねる',
7315 'channel_is_verified': True,
7316 'heatmap': 'count:100',
7318 'add_ie': ['Youtube'],
7319 'params': {'skip_download': 'Youtube'}
,
7322 def _real_extract(self
, url
):
7323 redirect_url
= url_or_none(parse_qs(url
).get('continue', [None])[-1])
7324 if not redirect_url
:
7325 raise ExtractorError('Invalid cookie consent redirect URL', expected
=True)
7326 return self
.url_result(redirect_url
)
7329 class YoutubeTruncatedIDIE(InfoExtractor
):
7330 IE_NAME
= 'youtube:truncated_id'
7331 IE_DESC
= False # Do not list
7332 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7335 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7336 'only_matching': True,
7339 def _real_extract(self
, url
):
7340 video_id
= self
._match
_id
(url
)
7341 raise ExtractorError(
7342 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',