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_from_player_overlay(self, data):
3296 content_list = traverse_obj(data, (
3297 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer', 'decoratedPlayerBarRenderer', 'playerBar',
3298 'multiMarkersPlayerBarRenderer', 'markersMap', ..., 'value', 'heatmap', 'heatmapRenderer', 'heatMarkers', {list}))
3299 return next(filter(None, (
3300 traverse_obj(contents, (..., 'heatMarkerRenderer', {
3301 'start_time': ('timeRangeStartMillis', {functools.partial(float_or_none, scale=1000)}),
3302 'end_time': {lambda x: (x['timeRangeStartMillis'] + x['markerDurationMillis']) / 1000},
3303 'value': ('heatMarkerIntensityScoreNormalized', {float_or_none}),
3304 })) for contents in content_list)), None)
3306 def _extract_comment(self, comment_renderer, parent=None):
3307 comment_id = comment_renderer.get('commentId')
3313 'text': self._get_text(comment_renderer, 'contentText'),
3314 'like_count': self._get_count(comment_renderer, 'voteCount'),
3315 'author_id': traverse_obj(comment_renderer, ('authorEndpoint', 'browseEndpoint', 'browseId', {self.ucid_or_none})),
3316 'author': self._get_text(comment_renderer, 'authorText'),
3317 'author_thumbnail': traverse_obj(comment_renderer, ('authorThumbnail', 'thumbnails', -1, 'url', {url_or_none})),
3318 'parent': parent or 'root',
3321 # Timestamp is an estimate calculated from the current time and time_text
3322 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3323 timestamp = self._parse_time_text(time_text)
3326 # FIXME: non-standard, but we need a way of showing that it is an estimate.
3327 '_time_text': time_text,
3328 'timestamp': timestamp,
3331 info['author_url'] = urljoin(
3332 'https://www.youtube.com', traverse_obj(comment_renderer, ('authorEndpoint', (
3333 ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'))),
3334 expected_type=str, get_all=False))
3336 author_is_uploader = traverse_obj(comment_renderer, 'authorIsChannelOwner')
3337 if author_is_uploader is not None:
3338 info['author_is_uploader'] = author_is_uploader
3340 comment_abr = traverse_obj(
3341 comment_renderer, ('actionButtons', 'commentActionButtonsRenderer'), expected_type=dict)
3342 if comment_abr is not None:
3343 info['is_favorited'] = 'creatorHeart' in comment_abr
3345 badges = self._extract_badges([traverse_obj(comment_renderer, 'authorCommentBadge')])
3346 if self._has_badge(badges, BadgeType.VERIFIED):
3347 info['author_is_verified'] = True
3349 is_pinned = traverse_obj(comment_renderer, 'pinnedCommentBadge')
3351 info['is_pinned'] = True
3355 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3357 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3359 def extract_header(contents):
3360 _continuation = None
3361 for content in contents:
3362 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3363 expected_comment_count = self._get_count(
3364 comments_header_renderer, 'countText', 'commentsCount')
3366 if expected_comment_count is not None:
3367 tracker['est_total'] = expected_comment_count
3368 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3369 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3371 sort_menu_item = try_get(
3372 comments_header_renderer,
3373 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3374 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3376 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3377 if not _continuation:
3380 sort_text = str_or_none(sort_menu_item.get('title'))
3382 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3383 self.to_screen('Sorting comments by %s' % sort_text.lower())
3385 return _continuation
3387 def extract_thread(contents):
3389 tracker['current_page_thread'] = 0
3390 for content in contents:
3391 if not parent and tracker['total_parent_comments'] >= max_parents:
3393 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3394 comment_renderer = get_first(
3395 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3396 expected_type=dict, default={})
3398 comment = self._extract_comment(comment_renderer, parent)
3401 comment_id = comment['id']
3402 if comment.get('is_pinned'):
3403 tracker['pinned_comment_ids'].add(comment_id)
3404 # Sometimes YouTube may break and give us infinite looping comments.
3405 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3406 if comment_id in tracker['seen_comment_ids']:
3407 if comment_id in tracker['pinned_comment_ids'] and not comment.get('is_pinned'):
3408 # Pinned comments may appear a second time in newest first sort
3409 # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3411 self.report_warning(
3412 'Detected YouTube comments looping. Stopping comment extraction '
3413 f'{"for this thread" if parent else ""} as we probably cannot get any more.')
3416 tracker['seen_comment_ids'].add(comment['id'])
3418 tracker['running_total'] += 1
3419 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3422 # Attempt to get the replies
3423 comment_replies_renderer = try_get(
3424 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3426 if comment_replies_renderer:
3427 tracker['current_page_thread'] += 1
3428 comment_entries_iter = self._comment_entries(
3429 comment_replies_renderer, ytcfg, video_id,
3430 parent=comment.get('id'), tracker=tracker)
3431 yield from itertools.islice(comment_entries_iter, min(
3432 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3434 # Keeps track of counts across recursive calls
3439 current_page_thread=0,
3440 total_parent_comments=0,
3441 total_reply_comments=0,
3442 seen_comment_ids=set(),
3443 pinned_comment_ids=set()
3447 # YouTube comments have a max depth of 2
3448 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3450 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3451 'Set max replies in the max-comments extractor argument instead')
3452 if max_depth == 1 and parent:
3455 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
3456 lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
3458 continuation = self._extract_continuation(root_continuation_data)
3461 is_forced_continuation = False
3462 is_first_continuation = parent is None
3463 if is_first_continuation and not continuation:
3464 # Sometimes you can get comments by generating the continuation yourself,
3465 # even if YouTube initially reports them being disabled - e.g. stories comments.
3466 # Note: if the comment section is actually disabled, YouTube may return a response with
3467 # required check_get_keys missing. So we will disable that check initially in this case.
3468 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3469 is_forced_continuation = True
3471 continuation_items_path = (
3472 'onResponseReceivedEndpoints', ..., ('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems')
3473 for page_num in itertools.count(0):
3474 if not continuation:
3476 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3477 comment_prog_str = f"({tracker['running_total']}
/~{tracker['est_total']}
)"
3479 if is_first_continuation:
3480 note_prefix = 'Downloading comment section API JSON'
3482 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3483 tracker['current_page_thread'], comment_prog_str)
3485 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
3486 ' ' if parent else '', ' replies' if parent else '',
3487 page_num, comment_prog_str)
3489 # Do a deep check for incomplete data as sometimes YouTube may return no comments for a continuation
3490 # Ignore check if YouTube says the comment count is 0.
3491 check_get_keys = None
3492 if not is_forced_continuation and not (tracker['est_total'] == 0 and tracker['running_total'] == 0):
3493 check_get_keys = [[*continuation_items_path, ..., (
3494 'commentsHeaderRenderer' if is_first_continuation else ('commentThreadRenderer', 'commentRenderer'))]]
3496 response = self._extract_response(
3497 item_id=None, query=continuation,
3498 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3499 check_get_keys=check_get_keys)
3500 except ExtractorError as e:
3501 # Ignore incomplete data error for replies if retries didn't work.
3502 # This is to allow any other parent comments and comment threads to be downloaded.
3503 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3504 if 'incomplete data' in str(e).lower() and parent:
3505 if self.get_param('ignoreerrors') in (True, 'only_download'):
3506 self.report_warning(
3507 'Received incomplete data for a comment reply thread and retrying did not help. '
3508 'Ignoring to let other comments be downloaded. Pass --no-ignore-errors to not ignore.')
3511 raise ExtractorError(
3512 'Incomplete data received for comment reply thread. '
3513 'Pass --ignore-errors to ignore and allow rest of comments to download.',
3516 is_forced_continuation = False
3518 for continuation_items in traverse_obj(response, continuation_items_path, expected_type=list, default=[]):
3519 if is_first_continuation:
3520 continuation = extract_header(continuation_items)
3521 is_first_continuation = False
3526 for entry in extract_thread(continuation_items):
3530 continuation = self._extract_continuation({'contents': continuation_items})
3534 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3535 if message and not parent and tracker['running_total'] == 0:
3536 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3537 raise self.CommentsDisabled
3540 def _generate_comment_continuation(video_id):
3542 Generates initial comment section continuation token from given video id
3544 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3545 return base64.b64encode(token.encode()).decode()
3547 def _get_comments(self, ytcfg, video_id, contents, webpage):
3548 """Entry for comment extraction"""
3549 def _real_comment_extract(contents):
3551 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3552 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3553 yield from self._comment_entries(renderer, ytcfg, video_id)
3555 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3556 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3559 def _get_checkok_params():
3560 return {'contentCheckOk': True, 'racyCheckOk': True}
3563 def _generate_player_context(cls, sts=None):
3565 'html5Preference': 'HTML5_PREF_WANTS',
3568 context['signatureTimestamp'] = sts
3570 'playbackContext': {
3571 'contentPlaybackContext': context
3573 **cls._get_checkok_params()
3577 def _is_agegated(player_response):
3578 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3581 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3582 AGE_GATE_REASONS = (
3583 'confirm your age', 'age-restricted', 'inappropriate', # reason
3584 'age_verification_required', 'age_check_required', # status
3586 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3589 def _is_unplayable(player_response):
3590 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3592 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3594 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3595 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3596 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3597 headers = self.generate_api_headers(
3598 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3601 'videoId': video_id,
3603 if _split_innertube_client(client)[0] == 'android':
3604 yt_query['params'] = 'CgIQBg=='
3606 pp_arg = self._configuration_arg('player_params', [None], casesense=True)[0]
3608 yt_query['params'] = pp_arg
3610 yt_query.update(self._generate_player_context(sts))
3611 return self._extract_response(
3612 item_id=video_id, ep='player', query=yt_query,
3613 ytcfg=player_ytcfg, headers=headers, fatal=True,
3614 default_client=client,
3615 note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
3618 def _get_requested_clients(self, url, smuggled_data):
3619 requested_clients = []
3620 default = ['ios', 'android', 'web']
3621 allowed_clients = sorted(
3622 (client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'),
3623 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3624 for client in self._configuration_arg('player_client'):
3625 if client in allowed_clients:
3626 requested_clients.append(client)
3627 elif client == 'default':
3628 requested_clients.extend(default)
3629 elif client == 'all':
3630 requested_clients.extend(allowed_clients)
3632 self.report_warning(f'Skipping unsupported client {client}')
3633 if not requested_clients:
3634 requested_clients = default
3636 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3637 requested_clients.extend(
3638 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3640 return orderedSet(requested_clients)
3642 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3645 initial_pr = self._search_json(
3646 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3648 all_clients = set(clients)
3649 clients = clients[::-1]
3652 def append_client(*client_names):
3653 """ Append the first client name that exists but not already used """
3654 for client_name in client_names:
3655 actual_client = _split_innertube_client(client_name)[0]
3656 if actual_client in INNERTUBE_CLIENTS:
3657 if actual_client not in all_clients:
3658 clients.append(client_name)
3659 all_clients.add(actual_client)
3662 # Android player_response does not have microFormats which are needed for
3663 # extraction of some data. So we return the initial_pr with formats
3664 # stripped out even if not requested by the user
3665 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3667 pr = dict(initial_pr)
3668 pr['streamingData'] = None
3672 tried_iframe_fallback = False
3675 client, base_client, variant = _split_innertube_client(clients.pop())
3676 player_ytcfg = master_ytcfg if client == 'web' else {}
3677 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3678 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3680 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3681 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3682 if 'js' in self._configuration_arg('player_skip'):
3683 require_js_player = False
3686 if not player_url and not tried_iframe_fallback and require_js_player:
3687 player_url = self._download_player_url(video_id)
3688 tried_iframe_fallback = True
3691 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3692 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3693 except ExtractorError as e:
3695 self.report_warning(last_error)
3700 # YouTube may return a different video player response than expected.
3701 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3702 pr_video_id = traverse_obj(pr, ('videoDetails', 'videoId'))
3703 if pr_video_id and pr_video_id != video_id:
3704 self.report_warning(
3705 f'Skipping player response from {client} client (got player response for video "{pr_video_id}
" instead of "{video_id}
")' + bug_reports_message())
3707 # Save client name for introspection later
3708 name = short_client_name(client)
3709 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3710 sd[STREAMING_DATA_CLIENT_NAME] = name
3711 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3712 f[STREAMING_DATA_CLIENT_NAME] = name
3715 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3716 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3717 append_client(f'{base_client}_creator')
3718 elif self._is_agegated(pr):
3719 if variant == 'tv_embedded':
3720 append_client(f'{base_client}_embedded')
3722 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3727 self.report_warning(last_error)
3728 return prs, player_url
3730 def _needs_live_processing(self, live_status, duration):
3731 if (live_status == 'is_live' and self.get_param('live_from_start')
3732 or live_status == 'post_live' and (duration or 0) > 2 * 3600):
3735 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3736 CHUNK_SIZE = 10 << 20
3737 itags, stream_ids = collections.defaultdict(set), []
3738 itag_qualities, res_qualities = {}, {0: None}
3740 # Normally tiny is the smallest video-only formats. But
3741 # audio-only formats with unknown quality may get tagged as tiny
3743 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3744 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
3746 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3747 format_types = self._configuration_arg('formats')
3748 all_formats = 'duplicate' in format_types
3749 if self._configuration_arg('include_duplicate_formats'):
3751 self._downloader.deprecated_feature('[youtube] include_duplicate_formats extractor argument is deprecated. '
3752 'Use formats=duplicate extractor argument instead')
3754 def build_fragments(f):
3756 'url': update_url_query(f['url'], {
3757 'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}'
3759 } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3761 for fmt in streaming_formats:
3762 if fmt.get('targetDurationSec'):
3765 itag = str_or_none(fmt.get('itag'))
3766 audio_track = fmt.get('audioTrack') or {}
3767 stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3769 if stream_id in stream_ids:
3772 quality = fmt.get('quality')
3773 height = int_or_none(fmt.get('height'))
3774 if quality == 'tiny' or not quality:
3775 quality = fmt.get('audioQuality', '').lower() or quality
3776 # The 3gp format (17) in android client has a quality of "small
",
3777 # but is actually worse than other formats
3782 itag_qualities[itag] = quality
3784 res_qualities[height] = quality
3785 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3786 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3787 # number of fragment that would subsequently requested with (`&sq=N`)
3788 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3791 fmt_url = fmt.get('url')
3793 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3794 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3795 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3796 if not all((sc, fmt_url, player_url, encrypted_sig)):
3799 fmt_url += '&%s=%s' % (
3800 traverse_obj(sc, ('sp', -1)) or 'signature',
3801 self._decrypt_signature(encrypted_sig, video_id, player_url)
3803 except ExtractorError as e:
3804 self.report_warning('Signature extraction failed: Some formats may be missing',
3805 video_id=video_id, only_once=True)
3806 self.write_debug(e, only_once=True)
3809 query = parse_qs(fmt_url)
3813 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3814 fmt_url = update_url_query(fmt_url, {
3815 'n': decrypt_nsig(query['n'][0], video_id, player_url)
3817 except ExtractorError as e:
3819 if isinstance(e, JSInterpreter.Exception):
3820 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3821 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3823 self.report_warning(
3824 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3825 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3826 self.write_debug(e, only_once=True)
3828 self.report_warning(
3829 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3830 video_id=video_id, only_once=True)
3833 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3834 language_preference = (
3835 10 if audio_track.get('audioIsDefault') and 10
3836 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3838 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3839 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3840 # Make sure to avoid false positives with small duration differences.
3841 # E.g. __2ABJjxzNo, ySuUZEjARPY
3842 is_damaged = try_get(fmt, lambda x: float(x['approxDurationMs']) / duration < 500)
3844 self.report_warning(
3845 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3847 client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3848 name = fmt.get('qualityLabel') or quality.replace('audio_quality_', '') or ''
3849 fps = int_or_none(fmt.get('fps')) or 0
3851 'asr': int_or_none(fmt.get('audioSampleRate')),
3852 'filesize': int_or_none(fmt.get('contentLength')),
3853 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3854 'format_note': join_nonempty(
3855 join_nonempty(audio_track.get('displayName'),
3856 language_preference > 0 and ' (default)', delim=''),
3857 name, fmt.get('isDrc') and 'DRC',
3858 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3859 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3860 throttled and 'THROTTLED', is_damaged and 'DAMAGED',
3861 (self.get_param('verbose') or all_formats) and client_name,
3863 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3864 'source_preference': ((-10 if throttled else -5 if itag == '22' else -1)
3865 + (100 if 'Premium' in name else 0)),
3866 'fps': fps if fps > 1 else None, # For some formats, fps is wrongly returned as 1
3867 'audio_channels': fmt.get('audioChannels'),
3869 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3870 'has_drm': bool(fmt.get('drmFamilies')),
3873 'width': int_or_none(fmt.get('width')),
3874 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3875 'desc' if language_preference < -1 else '') or None,
3876 'language_preference': language_preference,
3877 # Strictly de-prioritize damaged and 3gp formats
3878 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3880 mime_mobj = re.match(
3881 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3883 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3884 dct.update(parse_codecs(mime_mobj.group(2)))
3886 itags[itag].add(('https
', dct.get('language
')))
3887 stream_ids.append(stream_id)
3888 single_stream = 'none
' in (dct.get('acodec
'), dct.get('vcodec
'))
3889 if single_stream and dct.get('ext
'):
3890 dct['container
'] = dct['ext
'] + '_dash
'
3892 if (all_formats or 'dashy
' in format_types) and dct['filesize
']:
3895 'format_id
': f'{dct["format_id"]}
-dashy
' if all_formats else dct['format_id
'],
3896 'protocol
': 'http_dash_segments
',
3897 'fragments
': build_fragments(dct),
3899 if all_formats or 'dashy
' not in format_types:
3900 dct['downloader_options
'] = {'http_chunk_size': CHUNK_SIZE}
3903 needs_live_processing = self._needs_live_processing(live_status, duration)
3904 skip_bad_formats = 'incomplete
' not in format_types
3905 if self._configuration_arg('include_incomplete_formats
'):
3906 skip_bad_formats = False
3907 self._downloader.deprecated_feature('[youtube
] include_incomplete_formats extractor argument
is deprecated
. '
3908 'Use formats
=incomplete extractor argument instead
')
3910 skip_manifests = set(self._configuration_arg('skip
'))
3911 if (not self.get_param('youtube_include_hls_manifest
', True)
3912 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3913 or needs_live_processing and skip_bad_formats):
3914 skip_manifests.add('hls
')
3916 if not self.get_param('youtube_include_dash_manifest
', True):
3917 skip_manifests.add('dash
')
3918 if self._configuration_arg('include_live_dash
'):
3919 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3920 'Use formats
=incomplete extractor argument instead
')
3921 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3922 skip_manifests.add('dash
')
3924 def process_manifest_format(f, proto, client_name, itag):
3925 key = (proto, f.get('language
'))
3926 if not all_formats and key in itags[itag]:
3928 itags[itag].add(key)
3930 if itag and all_formats:
3931 f['format_id
'] = f'{itag}
-{proto}
'
3932 elif any(p != proto for p, _ in itags[itag]):
3933 f['format_id
'] = f'{itag}
-{proto}
'
3935 f['format_id
'] = itag
3937 if f.get('source_preference
') is None:
3938 f['source_preference
'] = -1
3940 if itag in ('616', '235'):
3941 f['format_note
'] = join_nonempty(f.get('format_note
'), 'Premium
', delim=' ')
3942 f['source_preference
'] += 100
3944 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
3945 if f['quality
'] == -1 and f.get('height
'):
3946 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
3947 if self.get_param('verbose
') or all_formats:
3948 f['format_note
'] = join_nonempty(f.get('format_note
'), client_name, delim=', ')
3949 if f.get('fps
') and f['fps
'] <= 1:
3952 if proto == 'hls
' and f.get('has_drm
'):
3953 f['has_drm
'] = 'maybe
'
3954 f['source_preference
'] -= 5
3958 for sd in streaming_data:
3959 client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
3961 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
3962 if hls_manifest_url:
3963 fmts, subs = self._extract_m3u8_formats_and_subtitles(
3964 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
3965 subtitles = self._merge_subtitles(subs, subtitles)
3967 if process_manifest_format(f, 'hls
', client_name, self._search_regex(
3968 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
3971 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
3972 if dash_manifest_url:
3973 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
3974 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
3976 if process_manifest_format(f, 'dash
', client_name, f['format_id
']):
3977 f['filesize
'] = int_or_none(self._search_regex(
3978 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
3979 if needs_live_processing:
3980 f['is_from_start
'] = True
3985 def _extract_storyboard(self, player_responses, duration):
3987 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
3988 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
3992 for i, args in enumerate(spec):
3993 args = args.split('#')
3994 counts
= list(map(int_or_none
, args
[:5]))
3995 if len(args
) != 8 or not all(counts
):
3996 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
3998 width
, height
, frame_count
, cols
, rows
= counts
4001 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
4002 fragment_count
= frame_count
/ (cols
* rows
)
4003 fragment_duration
= duration
/ fragment_count
4005 'format_id': f
'sb{i}',
4006 'format_note': 'storyboard',
4008 'protocol': 'mhtml',
4014 'fps': frame_count
/ duration
,
4018 'url': url
.replace('$M', str(j
)),
4019 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
4020 } for j
in range(math
.ceil(fragment_count
))],
4023 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
4025 if 'webpage' not in self
._configuration
_arg
('player_skip'):
4026 query
= {'bpctr': '9999999999', 'has_verified': '1'}
4027 pp
= self
._configuration
_arg
('player_params', [None], casesense
=True)[0]
4030 webpage
= self
._download
_webpage
(
4031 webpage_url
, video_id
, fatal
=False, query
=query
)
4033 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
4035 player_responses
, player_url
= self
._extract
_player
_responses
(
4036 self
._get
_requested
_clients
(url
, smuggled_data
),
4037 video_id
, webpage
, master_ytcfg
, smuggled_data
)
4039 return webpage
, master_ytcfg
, player_responses
, player_url
4041 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
4042 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
4043 is_live
= get_first(video_details
, 'isLive')
4045 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
4046 live_content
= get_first(video_details
, 'isLiveContent')
4047 is_upcoming
= get_first(video_details
, 'isUpcoming')
4048 post_live
= get_first(video_details
, 'isPostLiveDvr')
4049 live_status
= ('post_live' if post_live
4050 else 'is_live' if is_live
4051 else 'is_upcoming' if is_upcoming
4052 else 'was_live' if live_content
4053 else 'not_live' if False in (is_live
, live_content
)
4055 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'))
4056 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
4057 if all(f
.get('has_drm') for f
in formats
):
4058 # If there are no formats that definitely don't have DRM, all have DRM
4062 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
4064 def _real_extract(self
, url
):
4065 url
, smuggled_data
= unsmuggle_url(url
, {})
4066 video_id
= self
._match
_id
(url
)
4068 base_url
= self
.http_scheme() + '//www.youtube.com/'
4069 webpage_url
= base_url
+ 'watch?v=' + video_id
4071 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
4073 playability_statuses
= traverse_obj(
4074 player_responses
, (..., 'playabilityStatus'), expected_type
=dict)
4076 trailer_video_id
= get_first(
4077 playability_statuses
,
4078 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
4080 if trailer_video_id
:
4081 return self
.url_result(
4082 trailer_video_id
, self
.ie_key(), trailer_video_id
)
4084 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
4085 if webpage
else (lambda x
: None))
4087 video_details
= traverse_obj(player_responses
, (..., 'videoDetails'), expected_type
=dict)
4088 microformats
= traverse_obj(
4089 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
4092 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
4093 video_title
= (self
._preferred
_lang
and translated_title
4094 or get_first(video_details
, 'title') # primary
4096 or search_meta(['og:title', 'twitter:title', 'title']))
4097 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
4098 original_description
= get_first(video_details
, 'shortDescription')
4099 video_description
= (
4100 self
._preferred
_lang
and translated_description
4101 # If original description is blank, it will be an empty string.
4102 # Do not prefer translated description in this case.
4103 or original_description
if original_description
is not None else translated_description
)
4105 multifeed_metadata_list
= get_first(
4107 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
4109 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
4110 if self
.get_param('noplaylist'):
4111 self
.to_screen('Downloading just video %s because of --no-playlist' % video_id
)
4115 for feed
in multifeed_metadata_list
.split(','):
4116 # Unquote should take place before split on comma (,) since textual
4117 # fields may contain comma as well (see
4118 # https://github.com/ytdl-org/youtube-dl/issues/8536)
4119 feed_data
= urllib
.parse
.parse_qs(
4120 urllib
.parse
.unquote_plus(feed
))
4122 def feed_entry(name
):
4124 feed_data
, lambda x
: x
[name
][0], str)
4126 feed_id
= feed_entry('id')
4129 feed_title
= feed_entry('title')
4132 title
+= ' (%s)' % feed_title
4134 '_type': 'url_transparent',
4135 'ie_key': 'Youtube',
4137 '%swatch?v=%s' % (base_url
, feed_data
['id'][0]),
4138 {'force_singlefeed': True}
),
4141 feed_ids
.append(feed_id
)
4143 'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
4144 % (', '.join(feed_ids
), video_id
))
4145 return self
.playlist_result(
4146 entries
, video_id
, video_title
, video_description
)
4148 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
4149 or int_or_none(get_first(microformats
, 'lengthSeconds'))
4150 or parse_duration(search_meta('duration')) or None)
4152 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
4153 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
4154 if live_status
== 'post_live':
4155 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
4158 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
4159 self
.report_drm(video_id
)
4161 playability_statuses
,
4162 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
4163 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
4164 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
4166 if subreason
== 'The uploader has not made this video available in your country.':
4167 countries
= get_first(microformats
, 'availableCountries')
4169 regions_allowed
= search_meta('regionsAllowed')
4170 countries
= regions_allowed
.split(',') if regions_allowed
else None
4171 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
4172 reason
+= f
'. {subreason}'
4174 self
.raise_no_formats(reason
, expected
=True)
4176 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
4177 if not keywords
and webpage
:
4179 unescapeHTML(m
.group('content'))
4180 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
4181 for keyword
in keywords
:
4182 if keyword
.startswith('yt:stretch='):
4183 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
4185 # NB: float is intentional for forcing float division
4186 w
, h
= (float(v
) for v
in mobj
.groups())
4190 if f
.get('vcodec') != 'none':
4191 f
['stretched_ratio'] = ratio
4193 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
4194 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
4197 'url': thumbnail_url
,
4199 original_thumbnails
= thumbnails
.copy()
4201 # The best resolution thumbnails sometimes does not appear in the webpage
4202 # See: https://github.com/yt-dlp/yt-dlp/issues/340
4203 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4205 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4206 # in resolution, these are not the custom thumbnail. So de-prioritize them
4207 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4208 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3'
4210 n_thumbnail_names
= len(thumbnail_names
)
4212 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4213 video_id
=video_id
, name
=name
, ext
=ext
,
4214 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
4215 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
4216 for thumb
in thumbnails
:
4217 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
4218 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
4219 self
._remove
_duplicate
_formats
(thumbnails
)
4220 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
4222 category
= get_first(microformats
, 'category') or search_meta('genre')
4223 channel_id
= self
.ucid_or_none(str_or_none(
4224 get_first(video_details
, 'channelId')
4225 or get_first(microformats
, 'externalChannelId')
4226 or search_meta('channelId')))
4227 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
4229 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
4230 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
4231 if not duration
and live_end_time
and live_start_time
:
4232 duration
= live_end_time
- live_start_time
4234 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
4236 def is_bad_format(fmt
):
4237 if needs_live_processing
and not fmt
.get('is_from_start'):
4239 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
4240 and fmt
.get('protocol') == 'http_dash_segments'):
4243 for fmt
in filter(is_bad_format
, formats
):
4244 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4245 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 2 hours)', delim
=' ')
4247 if needs_live_processing
:
4248 self
._prepare
_live
_from
_start
_formats
(
4249 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4251 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4253 channel_handle
= self
.handle_from_url(owner_profile_url
)
4257 'title': video_title
,
4259 'thumbnails': thumbnails
,
4260 # The best thumbnail that we are sure exists. Prevents unnecessary
4261 # URL checking if user don't care about getting the best possible thumbnail
4262 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4263 'description': video_description
,
4264 'channel_id': channel_id
,
4265 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None),
4266 'duration': duration
,
4267 'view_count': int_or_none(
4268 get_first((video_details
, microformats
), (..., 'viewCount'))
4269 or search_meta('interactionCount')),
4270 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4271 'age_limit': 18 if (
4272 get_first(microformats
, 'isFamilySafe') is False
4273 or search_meta('isFamilyFriendly') == 'false'
4274 or search_meta('og:restrictions:age') == '18+') else 0,
4275 'webpage_url': webpage_url
,
4276 'categories': [category
] if category
else None,
4278 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4279 'live_status': live_status
,
4280 'release_timestamp': live_start_time
,
4281 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4282 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto')
4286 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4288 def get_lang_code(track
):
4289 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4290 or track
.get('languageCode'))
4292 # Converted into dicts to remove duplicates
4294 get_lang_code(sub
): sub
4295 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...))}
4296 translation_languages
= {
4297 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4298 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...))}
4300 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4301 lang_subs
= container
.setdefault(lang_code
, [])
4302 for fmt
in self
._SUBTITLE
_FORMATS
:
4308 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4312 # NB: Constructing the full subtitle dictionary is slow
4313 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4314 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4315 for lang_code
, caption_track
in captions
.items():
4316 base_url
= caption_track
.get('baseUrl')
4317 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4320 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4321 if caption_track
.get('kind') != 'asr':
4325 subtitles
, base_url
, lang_code
, lang_name
, {})
4326 if not caption_track
.get('isTranslatable'):
4328 for trans_code
, trans_name
in translation_languages
.items():
4331 orig_trans_code
= trans_code
4332 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4333 if not get_translated_subs
:
4335 trans_code
+= f
'-{lang_code}'
4336 trans_name
+= format_field(lang_name
, None, ' from %s')
4337 if lang_code
== f
'a-{orig_trans_code}':
4338 # Set audio language based on original subtitles
4340 if f
.get('acodec') != 'none' and not f
.get('language'):
4341 f
['language'] = orig_trans_code
4342 # Add an "-orig" label to the original language so that it can be distinguished.
4343 # The subs are returned without "-orig" as well for compatibility
4345 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4346 # Setting tlang=lang returns damaged subtitles.
4347 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4348 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4350 info
['automatic_captions'] = automatic_captions
4351 info
['subtitles'] = subtitles
4353 parsed_url
= urllib
.parse
.urlparse(url
)
4354 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4355 query
= urllib
.parse
.parse_qs(component
)
4356 for k
, v
in query
.items():
4357 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4359 if d_k
not in info
and k
in s_ks
:
4360 info
[d_k
] = parse_duration(query
[k
][0])
4362 # Youtube Music Auto-generated description
4363 if (video_description
or '').strip().endswith('\nAuto-generated by YouTube.'):
4364 # XXX: Causes catastrophic backtracking if description has "·"
4365 # E.g. https://www.youtube.com/watch?v=DoPaAxMQoiI
4366 # Simulating atomic groups: (?P<a>[^xy]+)x => (?=(?P<a>[^xy]+))(?P=a)x
4367 # reduces it, but does not fully fix it. https://regex101.com/r/8Ssf2h/2
4370 (?=(?P<track>[^\n·]+))(?P=track)·
4371 (?=(?P<artist>[^\n]+))(?P=artist)\n+
4372 (?=(?P<album>[^\n]+))(?P=album)\n
4373 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4374 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4376 (?=(?P<clean_artist>[^\n]+))(?P=clean_artist)\n
4377 )?.+\nAuto-generated\ by\ YouTube\.\s*$
4378 ''', video_description
)
4380 release_year
= mobj
.group('release_year')
4381 release_date
= mobj
.group('release_date')
4383 release_date
= release_date
.replace('-', '')
4384 if not release_year
:
4385 release_year
= release_date
[:4]
4387 'album': mobj
.group('album'.strip()),
4388 'artist': mobj
.group('clean_artist') or ', '.join(a
.strip() for a
in mobj
.group('artist').split('·')),
4389 'track': mobj
.group('track').strip(),
4390 'release_date': release_date
,
4391 'release_year': int_or_none(release_year
),
4396 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4397 if not traverse_obj(initial_data
, 'contents'):
4398 self
.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4400 if not initial_data
:
4401 query
= {'videoId': video_id}
4402 query
.update(self
._get
_checkok
_params
())
4403 initial_data
= self
._extract
_response
(
4404 item_id
=video_id
, ep
='next', fatal
=False,
4405 ytcfg
=master_ytcfg
, query
=query
, check_get_keys
='contents',
4406 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4407 note
='Downloading initial data API JSON')
4409 info
['comment_count'] = traverse_obj(initial_data
, (
4410 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4411 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount'
4413 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4414 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo'
4415 ), expected_type
=self
._get
_count
, get_all
=False)
4417 try: # This will error if there is no livechat
4418 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4419 except (KeyError, IndexError, TypeError):
4422 info
.setdefault('subtitles', {})['live_chat'] = [{
4423 # url is needed to set cookies
4424 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4425 'video_id': video_id
,
4427 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4428 else 'youtube_live_chat_replay'),
4432 info
['chapters'] = (
4433 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4434 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4435 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4438 info
['heatmap'] = self
._extract
_heatmap
_from
_player
_overlay
(initial_data
)
4440 contents
= traverse_obj(
4441 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4442 expected_type
=list, default
=[])
4444 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4446 stl
= vpir
.get('superTitleLink')
4448 stl
= self
._get
_text
(stl
)
4451 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4452 info
['location'] = stl
4454 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4457 'series': mobj
.group(1),
4458 'season_number': int(mobj
.group(2)),
4459 'episode_number': int(mobj
.group(3)),
4461 for tlb
in (try_get(
4463 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4467 tlb
, ('toggleButtonRenderer', ...),
4468 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4470 for getter
, regex
in [(
4471 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4472 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4473 lambda x
: x
['accessibility'],
4474 lambda x
: x
['accessibilityData']['accessibilityData'],
4475 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4476 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4478 mobj
= re
.match(regex
, label
)
4480 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4482 sbr_tooltip
= try_get(
4483 vpir
, lambda x
: x
['sentimentBar']['sentimentBarRenderer']['tooltip'])
4485 like_count
, dislike_count
= sbr_tooltip
.split(' / ')
4487 'like_count': str_to_int(like_count
),
4488 'dislike_count': str_to_int(dislike_count
),
4490 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4492 vc
= self
._get
_count
(vcr
, 'viewCount')
4493 # Upcoming premieres with waiting count are treated as live here
4494 if vcr
.get('isLive'):
4495 info
['concurrent_view_count'] = vc
4496 elif info
.get('view_count') is None:
4497 info
['view_count'] = vc
4499 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4501 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4503 'channel': self
._get
_text
(vor
, 'title'),
4504 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4506 if not channel_handle
:
4507 channel_handle
= self
.handle_from_url(
4509 ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4510 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4511 {str}
), get_all
=False))
4515 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4517 multiple_songs
= False
4519 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4520 multiple_songs
= True
4523 mrr
= row
.get('metadataRowRenderer') or {}
4524 mrr_title
= mrr
.get('title')
4527 mrr_title
= self
._get
_text
(mrr
, 'title')
4528 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4529 if mrr_title
== 'License':
4530 info
['license'] = mrr_contents_text
4531 elif not multiple_songs
:
4532 if mrr_title
== 'Album':
4533 info
['album'] = mrr_contents_text
4534 elif mrr_title
== 'Artist':
4535 info
['artist'] = mrr_contents_text
4536 elif mrr_title
== 'Song':
4537 info
['track'] = mrr_contents_text
4538 owner_badges
= self
._extract
_badges
(traverse_obj(vsir
, ('owner', 'videoOwnerRenderer', 'badges')))
4539 if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
):
4540 info
['channel_is_verified'] = True
4543 'uploader': info
.get('channel'),
4544 'uploader_id': channel_handle
,
4545 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4547 # The upload date for scheduled, live and past live streams / premieres in microformats
4548 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4549 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4551 unified_strdate(get_first(microformats
, 'uploadDate'))
4552 or unified_strdate(search_meta('uploadDate')))
4553 if not upload_date
or (
4554 live_status
in ('not_live', None)
4555 and 'no-youtube-prefer-utc-upload-date' not in self
.get_param('compat_opts', [])
4557 upload_date
= strftime_or_none(
4558 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText'))) or upload_date
4559 info
['upload_date'] = upload_date
4561 for s_k
, d_k
in [('artist', 'creator'), ('track', 'alt_title')]:
4566 badges
= self
._extract
_badges
(traverse_obj(vpir
, 'badges'))
4568 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4569 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4571 info
['availability'] = (
4572 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4573 else self
._availability
(
4574 is_private
=is_private
,
4576 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4577 or False if initial_data
and is_private
is not None else None),
4578 needs_subscription
=(
4579 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4580 or False if initial_data
and is_private
is not None else None),
4581 needs_auth
=info
['age_limit'] >= 18,
4582 is_unlisted
=None if is_private
is None else (
4583 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4584 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4586 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4588 self
.mark_watched(video_id
, player_responses
)
4593 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4595 def passthrough_smuggled_data(func
):
4596 def _smuggle(info
, smuggled_data
):
4597 if info
.get('_type') not in ('url', 'url_transparent'):
4599 if smuggled_data
.get('is_music_url'):
4600 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4601 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4602 smuggled_data
.pop('is_music_url')
4603 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4605 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4608 @functools.wraps(func
)
4609 def wrapper(self
, url
):
4610 url
, smuggled_data
= unsmuggle_url(url
, {})
4611 if self
.is_music_url(url
):
4612 smuggled_data
['is_music_url'] = True
4613 info_dict
= func(self
, url
, smuggled_data
)
4615 _smuggle(info_dict
, smuggled_data
)
4616 if info_dict
.get('entries'):
4617 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4622 def _extract_basic_item_renderer(item
):
4623 # Modified from _extract_grid_item_renderer
4624 known_basic_renderers
= (
4625 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer'
4627 for key
, renderer
in item
.items():
4628 if not isinstance(renderer
, dict):
4630 elif key
in known_basic_renderers
:
4632 elif key
.startswith('grid') and key
.endswith('Renderer'):
4635 def _extract_channel_renderer(self
, renderer
):
4636 channel_id
= self
.ucid_or_none(renderer
['channelId'])
4637 title
= self
._get
_text
(renderer
, 'title')
4638 channel_url
= format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None)
4639 channel_handle
= self
.handle_from_url(
4640 traverse_obj(renderer
, (
4641 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4642 ('browseEndpoint', 'canonicalBaseUrl')),
4643 {str}
), get_all
=False))
4644 if not channel_handle
:
4645 # As of 2023-06-01, YouTube sets subscriberCountText to the handle in search
4646 channel_handle
= self
.handle_or_none(self
._get
_text
(renderer
, 'subscriberCountText'))
4651 'ie_key': YoutubeTabIE
.ie_key(),
4654 'channel_id': channel_id
,
4655 'channel_url': channel_url
,
4657 'uploader_id': channel_handle
,
4658 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4659 # See above. YouTube sets videoCountText to the subscriber text in search channel renderers.
4660 # However, in feed/channels this is set correctly to the subscriber count
4661 'channel_follower_count': traverse_obj(
4662 renderer
, 'subscriberCountText', 'videoCountText', expected_type
=self
._get
_count
),
4663 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
4665 # videoCountText may be the subscriber count
4666 self
._get
_count
(renderer
, 'videoCountText')
4667 if self
._get
_count
(renderer
, 'subscriberCountText') is not None else None),
4668 'description': self
._get
_text
(renderer
, 'descriptionSnippet'),
4669 'channel_is_verified': True if self
._has
_badge
(
4670 self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges')), BadgeType
.VERIFIED
) else None,
4673 def _grid_entries(self
, grid_renderer
):
4674 for item
in grid_renderer
['items']:
4675 if not isinstance(item
, dict):
4677 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4678 if not isinstance(renderer
, dict):
4680 title
= self
._get
_text
(renderer
, 'title')
4683 playlist_id
= renderer
.get('playlistId')
4685 yield self
.url_result(
4686 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4687 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4691 video_id
= renderer
.get('videoId')
4693 yield self
._extract
_video
(renderer
)
4696 channel_id
= renderer
.get('channelId')
4698 yield self
._extract
_channel
_renderer
(renderer
)
4700 # generic endpoint URL support
4701 ep_url
= urljoin('https://www.youtube.com/', try_get(
4702 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4705 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4706 if ie
.suitable(ep_url
):
4707 yield self
.url_result(
4708 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4711 def _music_reponsive_list_entry(self
, renderer
):
4712 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4714 title
= traverse_obj(renderer
, (
4715 'flexColumns', 0, 'musicResponsiveListItemFlexColumnRenderer',
4716 'text', 'runs', 0, 'text'))
4717 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4718 ie
=YoutubeIE
.ie_key(), video_id
=video_id
, title
=title
)
4719 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4721 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4723 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4724 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4725 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4726 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4727 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4729 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4730 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4732 def _shelf_entries_from_content(self
, shelf_renderer
):
4733 content
= shelf_renderer
.get('content')
4734 if not isinstance(content
, dict):
4736 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4738 # TODO: add support for nested playlists so each shelf is processed
4739 # as separate playlist
4740 # TODO: this includes only first N items
4741 yield from self
._grid
_entries
(renderer
)
4742 renderer
= content
.get('horizontalListRenderer')
4747 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4749 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4751 shelf_url
= urljoin('https://www.youtube.com', ep
)
4753 # Skipping links to another channels, note that checking for
4754 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4756 if skip_channels
and '/channels?' in shelf_url
:
4758 title
= self
._get
_text
(shelf_renderer
, 'title')
4759 yield self
.url_result(shelf_url
, video_title
=title
)
4760 # Shelf may not contain shelf URL, fallback to extraction from content
4761 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4763 def _playlist_entries(self
, video_list_renderer
):
4764 for content
in video_list_renderer
['contents']:
4765 if not isinstance(content
, dict):
4767 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4768 if not isinstance(renderer
, dict):
4770 video_id
= renderer
.get('videoId')
4773 yield self
._extract
_video
(renderer
)
4775 def _rich_entries(self
, rich_grid_renderer
):
4776 renderer
= traverse_obj(
4778 ('content', ('videoRenderer', 'reelItemRenderer', 'playlistRenderer')), get_all
=False) or {}
4779 video_id
= renderer
.get('videoId')
4781 yield self
._extract
_video
(renderer
)
4783 playlist_id
= renderer
.get('playlistId')
4785 yield self
.url_result(
4786 f
'https://www.youtube.com/playlist?list={playlist_id}',
4787 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4788 video_title
=self
._get
_text
(renderer
, 'title'))
4791 def _video_entry(self
, video_renderer
):
4792 video_id
= video_renderer
.get('videoId')
4794 return self
._extract
_video
(video_renderer
)
4796 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4797 url
= urljoin('https://youtube.com', traverse_obj(
4798 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4800 return self
.url_result(
4801 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4803 def _post_thread_entries(self
, post_thread_renderer
):
4804 post_renderer
= try_get(
4805 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4806 if not post_renderer
:
4809 video_renderer
= try_get(
4810 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4811 video_id
= video_renderer
.get('videoId')
4813 entry
= self
._extract
_video
(video_renderer
)
4816 # playlist attachment
4817 playlist_id
= try_get(
4818 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4820 yield self
.url_result(
4821 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4822 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4823 # inline video links
4824 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4826 if not isinstance(run
, dict):
4829 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4832 if not YoutubeIE
.suitable(ep_url
):
4834 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4835 if video_id
== ep_video_id
:
4837 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4839 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4840 contents
= post_thread_continuation
.get('contents')
4841 if not isinstance(contents
, list):
4843 for content
in contents
:
4844 renderer
= content
.get('backstagePostThreadRenderer')
4845 if isinstance(renderer
, dict):
4846 yield from self
._post
_thread
_entries
(renderer
)
4848 renderer
= content
.get('videoRenderer')
4849 if isinstance(renderer
, dict):
4850 yield self
._video
_entry
(renderer
)
4853 def _rich_grid_entries(self, contents):
4854 for content in contents:
4855 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4857 entry = self._video_entry(video_renderer)
4862 def _report_history_entries(self
, renderer
):
4863 for url
in traverse_obj(renderer
, (
4864 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4865 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4866 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4867 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4869 def _extract_entries(self
, parent_renderer
, continuation_list
):
4870 # continuation_list is modified in-place with continuation_list = [continuation_token]
4871 continuation_list
[:] = [None]
4872 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4873 for content
in contents
:
4874 if not isinstance(content
, dict):
4876 is_renderer
= traverse_obj(
4877 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4880 if content
.get('richItemRenderer'):
4881 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4883 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4884 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4885 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4886 yield from self
._report
_history
_entries
(table
)
4887 continuation_list
[0] = self
._extract
_continuation
(table
)
4890 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4891 for isr_content
in isr_contents
:
4892 if not isinstance(isr_content
, dict):
4896 'playlistVideoListRenderer': self
._playlist
_entries
,
4897 'gridRenderer': self
._grid
_entries
,
4898 'reelShelfRenderer': self
._grid
_entries
,
4899 'shelfRenderer': self
._shelf
_entries
,
4900 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4901 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4902 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4903 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4904 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4905 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)],
4906 'richGridRenderer': lambda x
: self
._extract
_entries
(x
, continuation_list
),
4908 for key
, renderer
in isr_content
.items():
4909 if key
not in known_renderers
:
4911 for entry
in known_renderers
[key
](renderer
):
4914 continuation_list
[0] = self
._extract
_continuation
(renderer
)
4917 if not continuation_list
[0]:
4918 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
4920 if not continuation_list
[0]:
4921 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4923 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
4924 continuation_list
= [None]
4925 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
4926 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
4930 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
4931 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
4932 yield from extract_entries(parent_renderer
)
4933 continuation
= continuation_list
[0]
4934 seen_continuations
= set()
4935 for page_num
in itertools
.count(1):
4936 if not continuation
:
4938 continuation_token
= continuation
.get('continuation')
4939 if continuation_token
is not None and continuation_token
in seen_continuations
:
4940 self
.write_debug('Detected YouTube feed looping - assuming end of feed.')
4942 seen_continuations
.add(continuation_token
)
4943 headers
= self
.generate_api_headers(
4944 ytcfg
=ytcfg
, account_syncid
=account_syncid
, visitor_data
=visitor_data
)
4945 response
= self
._extract
_response
(
4946 item_id
=f
'{item_id} page {page_num}',
4947 query
=continuation
, headers
=headers
, ytcfg
=ytcfg
,
4948 check_get_keys
=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4952 # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
4953 # See: https://github.com/ytdl-org/youtube-dl/issues/28702
4954 visitor_data
= self
._extract
_visitor
_data
(response
) or visitor_data
4957 'videoRenderer': (self
._grid
_entries
, 'items'), # for membership tab
4958 'gridPlaylistRenderer': (self
._grid
_entries
, 'items'),
4959 'gridVideoRenderer': (self
._grid
_entries
, 'items'),
4960 'gridChannelRenderer': (self
._grid
_entries
, 'items'),
4961 'playlistVideoRenderer': (self
._playlist
_entries
, 'contents'),
4962 'itemSectionRenderer': (extract_entries
, 'contents'), # for feeds
4963 'richItemRenderer': (extract_entries
, 'contents'), # for hashtag
4964 'backstagePostThreadRenderer': (self
._post
_thread
_continuation
_entries
, 'contents'),
4965 'reportHistoryTableRowRenderer': (self
._report
_history
_entries
, 'rows'),
4966 'playlistVideoListContinuation': (self
._playlist
_entries
, None),
4967 'gridContinuation': (self
._grid
_entries
, None),
4968 'itemSectionContinuation': (self
._post
_thread
_continuation
_entries
, None),
4969 'sectionListContinuation': (extract_entries
, None), # for feeds
4972 continuation_items
= traverse_obj(response
, (
4973 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
4974 'appendContinuationItemsAction', 'continuationItems'
4975 ), 'continuationContents', get_all
=False)
4976 continuation_item
= traverse_obj(continuation_items
, 0, None, expected_type
=dict, default
={})
4978 video_items_renderer
= None
4979 for key
in continuation_item
.keys():
4980 if key
not in known_renderers
:
4982 func
, parent_key
= known_renderers
[key
]
4983 video_items_renderer
= {parent_key: continuation_items}
if parent_key
else continuation_items
4984 continuation_list
= [None]
4985 yield from func(video_items_renderer
)
4986 continuation
= continuation_list
[0] or self
._extract
_continuation
(video_items_renderer
)
4988 if not video_items_renderer
:
4992 def _extract_selected_tab(tabs
, fatal
=True):
4993 for tab_renderer
in tabs
:
4994 if tab_renderer
.get('selected'):
4997 raise ExtractorError('Unable to find selected tab')
5000 def _extract_tab_renderers(response
):
5001 return traverse_obj(
5002 response
, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type
=dict)
5004 def _extract_from_tabs(self
, item_id
, ytcfg
, data
, tabs
):
5005 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
5007 selected_tab
= self
._extract
_selected
_tab
(tabs
)
5008 metadata
['title'] += format_field(selected_tab
, 'title', ' - %s')
5009 metadata
['title'] += format_field(selected_tab
, 'expandedText', ' - %s')
5011 return self
.playlist_result(
5013 selected_tab
, metadata
['id'], ytcfg
,
5014 self
._extract
_account
_syncid
(ytcfg
, data
),
5015 self
._extract
_visitor
_data
(data
, ytcfg
)),
5018 def _extract_metadata_from_tabs(self
, item_id
, data
):
5019 info
= {'id': item_id}
5021 metadata_renderer
= traverse_obj(data
, ('metadata', 'channelMetadataRenderer'), expected_type
=dict)
5022 if metadata_renderer
:
5023 channel_id
= traverse_obj(metadata_renderer
, ('externalId', {self.ucid_or_none}
),
5024 ('channelUrl', {self.ucid_from_url}
))
5026 'channel': metadata_renderer
.get('title'),
5027 'channel_id': channel_id
,
5029 if info
['channel_id']:
5030 info
['id'] = info
['channel_id']
5032 metadata_renderer
= traverse_obj(data
, ('metadata', 'playlistMetadataRenderer'), expected_type
=dict)
5034 # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
5035 # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
5036 def _get_uncropped(url
):
5037 return url_or_none((url
or '').split('=')[0] + '=s0')
5039 avatar_thumbnails
= self
._extract
_thumbnails
(metadata_renderer
, 'avatar')
5040 if avatar_thumbnails
:
5041 uncropped_avatar
= _get_uncropped(avatar_thumbnails
[0]['url'])
5042 if uncropped_avatar
:
5043 avatar_thumbnails
.append({
5044 'url': uncropped_avatar
,
5045 'id': 'avatar_uncropped',
5049 channel_banners
= self
._extract
_thumbnails
(
5050 data
, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
5051 for banner
in channel_banners
:
5052 banner
['preference'] = -10
5055 uncropped_banner
= _get_uncropped(channel_banners
[0]['url'])
5056 if uncropped_banner
:
5057 channel_banners
.append({
5058 'url': uncropped_banner
,
5059 'id': 'banner_uncropped',
5063 # Deprecated - remove primary_sidebar_renderer when layout discontinued
5064 primary_sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer')
5065 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer'), expected_type
=dict)
5067 primary_thumbnails
= self
._extract
_thumbnails
(
5068 primary_sidebar_renderer
, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
5069 playlist_thumbnails
= self
._extract
_thumbnails
(
5070 playlist_header_renderer
, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
5073 'title': (traverse_obj(metadata_renderer
, 'title')
5074 or self
._get
_text
(data
, ('header', 'hashtagHeaderRenderer', 'hashtag'))
5076 'availability': self
._extract
_availability
(data
),
5077 'channel_follower_count': self
._get
_count
(data
, ('header', ..., 'subscriberCountText')),
5078 'description': try_get(metadata_renderer
, lambda x
: x
.get('description', '')),
5079 'tags': try_get(metadata_renderer
or {}, lambda x
: x
.get('keywords', '').split()),
5080 'thumbnails': (primary_thumbnails
or playlist_thumbnails
) + avatar_thumbnails
+ channel_banners
,
5084 traverse_obj(metadata_renderer
, (('vanityChannelUrl', ('ownerUrls', ...)), {self.handle_from_url}
), get_all
=False)
5085 or traverse_obj(data
, ('header', ..., 'channelHandleText', {self.handle_or_none}
), get_all
=False))
5089 'uploader_id': channel_handle
,
5090 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
5093 channel_badges
= self
._extract
_badges
(traverse_obj(data
, ('header', ..., 'badges'), get_all
=False))
5094 if self
._has
_badge
(channel_badges
, BadgeType
.VERIFIED
):
5095 info
['channel_is_verified'] = True
5096 # Playlist stats is a text runs array containing [video count, view count, last updated].
5097 # last updated or (view count and last updated) may be missing.
5098 playlist_stats
= get_first(
5099 (primary_sidebar_renderer
, playlist_header_renderer
), (('stats', 'briefStats', 'numVideosText'), ))
5101 last_updated_unix
= self
._parse
_time
_text
(
5102 self
._get
_text
(playlist_stats
, 2) # deprecated, remove when old layout discontinued
5103 or self
._get
_text
(playlist_header_renderer
, ('byline', 1, 'playlistBylineRenderer', 'text')))
5104 info
['modified_date'] = strftime_or_none(last_updated_unix
)
5106 info
['view_count'] = self
._get
_count
(playlist_stats
, 1)
5107 if info
['view_count'] is None: # 0 is allowed
5108 info
['view_count'] = self
._get
_count
(playlist_header_renderer
, 'viewCountText')
5109 if info
['view_count'] is None:
5110 info
['view_count'] = self
._get
_count
(data
, (
5111 'contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., 'tabRenderer', 'content', 'sectionListRenderer',
5112 'contents', ..., 'itemSectionRenderer', 'contents', ..., 'channelAboutFullMetadataRenderer', 'viewCountText'))
5114 info
['playlist_count'] = self
._get
_count
(playlist_stats
, 0)
5115 if info
['playlist_count'] is None: # 0 is allowed
5116 info
['playlist_count'] = self
._get
_count
(playlist_header_renderer
, ('byline', 0, 'playlistBylineRenderer', 'text'))
5118 if not info
.get('channel_id'):
5119 owner
= traverse_obj(playlist_header_renderer
, 'ownerText')
5120 if not owner
: # Deprecated
5121 owner
= traverse_obj(
5122 self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarSecondaryInfoRenderer'),
5123 ('videoOwner', 'videoOwnerRenderer', 'title'))
5124 owner_text
= self
._get
_text
(owner
)
5125 browse_ep
= traverse_obj(owner
, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
5127 'channel': self
._search
_regex
(r
'^by (.+) and \d+ others?$', owner_text
, 'uploader', default
=owner_text
),
5128 'channel_id': self
.ucid_or_none(browse_ep
.get('browseId')),
5129 'uploader_id': self
.handle_from_url(urljoin('https://www.youtube.com', browse_ep
.get('canonicalBaseUrl')))
5133 'uploader': info
['channel'],
5134 'channel_url': format_field(info
.get('channel_id'), None, 'https://www.youtube.com/channel/%s', default
=None),
5135 'uploader_url': format_field(info
.get('uploader_id'), None, 'https://www.youtube.com/%s', default
=None),
5140 def _extract_inline_playlist(self
, playlist
, playlist_id
, data
, ytcfg
):
5141 first_id
= last_id
= response
= None
5142 for page_num
in itertools
.count(1):
5143 videos
= list(self
._playlist
_entries
(playlist
))
5146 start
= next((i
for i
, v
in enumerate(videos
) if v
['id'] == last_id
), -1) + 1
5147 if start
>= len(videos
):
5149 yield from videos
[start
:]
5150 first_id
= first_id
or videos
[0]['id']
5151 last_id
= videos
[-1]['id']
5152 watch_endpoint
= try_get(
5153 playlist
, lambda x
: x
['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
5154 headers
= self
.generate_api_headers(
5155 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5156 visitor_data
=self
._extract
_visitor
_data
(response
, data
, ytcfg
))
5158 'playlistId': playlist_id
,
5159 'videoId': watch_endpoint
.get('videoId') or last_id
,
5160 'index': watch_endpoint
.get('index') or len(videos
),
5161 'params': watch_endpoint
.get('params') or 'OAE%3D'
5163 response
= self
._extract
_response
(
5164 item_id
='%s page %d' % (playlist_id
, page_num
),
5165 query
=query
, ep
='next', headers
=headers
, ytcfg
=ytcfg
,
5166 check_get_keys
='contents'
5169 response
, lambda x
: x
['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
5171 def _extract_from_playlist(self
, item_id
, url
, data
, playlist
, ytcfg
):
5172 title
= playlist
.get('title') or try_get(
5173 data
, lambda x
: x
['titleText']['simpleText'], str)
5174 playlist_id
= playlist
.get('playlistId') or item_id
5176 # Delegating everything except mix playlists to regular tab-based playlist URL
5177 playlist_url
= urljoin(url
, try_get(
5178 playlist
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
5181 # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
5182 # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
5183 is_known_unviewable
= re
.fullmatch(r
'MLCT|RLTD[\w-]{22}', playlist_id
)
5185 if playlist_url
and playlist_url
!= url
and not is_known_unviewable
:
5186 return self
.url_result(
5187 playlist_url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
5190 return self
.playlist_result(
5191 self
._extract
_inline
_playlist
(playlist
, playlist_id
, data
, ytcfg
),
5192 playlist_id
=playlist_id
, playlist_title
=title
)
5194 def _extract_availability(self
, data
):
5196 Gets the availability of a given playlist/tab.
5197 Note: Unless YouTube tells us explicitly, we do not assume it is public
5198 @param data: response
5200 sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer') or {}
5201 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer')) or {}
5202 player_header_privacy
= playlist_header_renderer
.get('privacy')
5204 badges
= self
._extract
_badges
(traverse_obj(sidebar_renderer
, 'badges'))
5206 # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
5207 privacy_setting_icon
= get_first(
5208 (playlist_header_renderer
, sidebar_renderer
),
5209 ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
5210 lambda _
, v
: v
['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
5213 microformats_is_unlisted
= traverse_obj(
5214 data
, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type
=bool)
5218 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
5219 or player_header_privacy
== 'PUBLIC'
5220 or privacy_setting_icon
== 'PRIVACY_PUBLIC')
5221 else self
._availability
(
5223 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
5224 or player_header_privacy
== 'PRIVATE' if player_header_privacy
is not None
5225 else privacy_setting_icon
== 'PRIVACY_PRIVATE' if privacy_setting_icon
is not None else None),
5227 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
5228 or player_header_privacy
== 'UNLISTED' if player_header_privacy
is not None
5229 else privacy_setting_icon
== 'PRIVACY_UNLISTED' if privacy_setting_icon
is not None
5230 else microformats_is_unlisted
if microformats_is_unlisted
is not None else None),
5231 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
5232 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
5236 def _extract_sidebar_info_renderer(data
, info_renderer
, expected_type
=dict):
5237 sidebar_renderer
= try_get(
5238 data
, lambda x
: x
['sidebar']['playlistSidebarRenderer']['items'], list) or []
5239 for item
in sidebar_renderer
:
5240 renderer
= try_get(item
, lambda x
: x
[info_renderer
], expected_type
)
5244 def _reload_with_unavailable_videos(self
, item_id
, data
, ytcfg
):
5246 Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
5248 is_playlist
= bool(traverse_obj(
5249 data
, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
5252 headers
= self
.generate_api_headers(
5253 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5254 visitor_data
=self
._extract
_visitor
_data
(data
, ytcfg
))
5256 'params': 'wgYCCAA=',
5257 'browseId': f
'VL{item_id}'
5259 return self
._extract
_response
(
5260 item_id
=item_id
, headers
=headers
, query
=query
,
5261 check_get_keys
='contents', fatal
=False, ytcfg
=ytcfg
,
5262 note
='Redownloading playlist API JSON with unavailable videos')
5264 @functools.cached_property
5265 def skip_webpage(self
):
5266 return 'webpage' in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key())
5268 def _extract_webpage(self
, url
, item_id
, fatal
=True):
5269 webpage
, data
= None, None
5270 for retry
in self
.RetryManager(fatal
=fatal
):
5272 webpage
= self
._download
_webpage
(url
, item_id
, note
='Downloading webpage')
5273 data
= self
.extract_yt_initial_data(item_id
, webpage
or '', fatal
=fatal
) or {}
5274 except ExtractorError
as e
:
5275 if isinstance(e
.cause
, network_exceptions
):
5276 if not isinstance(e
.cause
, HTTPError
) or e
.cause
.status
not in (403, 429):
5279 self
._error
_or
_warning
(e
, fatal
=fatal
)
5283 self
._extract
_and
_report
_alerts
(data
)
5284 except ExtractorError
as e
:
5285 self
._error
_or
_warning
(e
, fatal
=fatal
)
5288 # Sometimes youtube returns a webpage with incomplete ytInitialData
5289 # See: https://github.com/yt-dlp/yt-dlp/issues/116
5290 if not traverse_obj(data
, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
5291 retry
.error
= ExtractorError('Incomplete yt initial data received')
5294 return webpage
, data
5296 def _report_playlist_authcheck(self
, ytcfg
, fatal
=True):
5297 """Use if failed to extract ytcfg (and data) from initial webpage"""
5298 if not ytcfg
and self
.is_authenticated
:
5299 msg
= 'Playlists that require authentication may not extract correctly without a successful webpage download'
5300 if 'authcheck' not in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key()) and fatal
:
5301 raise ExtractorError(
5302 f
'{msg}. If you are not downloading private content, or '
5303 'your cookies are only for the first account and channel,'
5304 ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
5306 self
.report_warning(msg
, only_once
=True)
5308 def _extract_data(self
, url
, item_id
, ytcfg
=None, fatal
=True, webpage_fatal
=False, default_client
='web'):
5310 if not self
.skip_webpage
:
5311 webpage
, data
= self
._extract
_webpage
(url
, item_id
, fatal
=webpage_fatal
)
5312 ytcfg
= ytcfg
or self
.extract_ytcfg(item_id
, webpage
)
5313 # Reject webpage data if redirected to home page without explicitly requesting
5314 selected_tab
= self
._extract
_selected
_tab
(self
._extract
_tab
_renderers
(data
), fatal
=False) or {}
5315 if (url
!= 'https://www.youtube.com/feed/recommended'
5316 and selected_tab
.get('tabIdentifier') == 'FEwhat_to_watch' # Home page
5317 and 'no-youtube-channel-redirect' not in self
.get_param('compat_opts', [])):
5318 msg
= 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
5320 raise ExtractorError(msg
, expected
=True)
5321 self
.report_warning(msg
, only_once
=True)
5323 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=fatal
)
5324 data
= self
._extract
_tab
_endpoint
(url
, item_id
, ytcfg
, fatal
=fatal
, default_client
=default_client
)
5327 def _extract_tab_endpoint(self
, url
, item_id
, ytcfg
=None, fatal
=True, default_client
='web'):
5328 headers
= self
.generate_api_headers(ytcfg
=ytcfg
, default_client
=default_client
)
5329 resolve_response
= self
._extract
_response
(
5330 item_id
=item_id
, query
={'url': url}
, check_get_keys
='endpoint', headers
=headers
, ytcfg
=ytcfg
, fatal
=fatal
,
5331 ep
='navigation/resolve_url', note
='Downloading API parameters API JSON', default_client
=default_client
)
5332 endpoints
= {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5333 for ep_key
, ep
in endpoints
.items():
5334 params
= try_get(resolve_response
, lambda x
: x
['endpoint'][ep_key
], dict)
5336 return self
._extract
_response
(
5337 item_id
=item_id
, query
=params
, ep
=ep
, headers
=headers
,
5338 ytcfg
=ytcfg
, fatal
=fatal
, default_client
=default_client
,
5339 check_get_keys
=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5340 err_note
= 'Failed to resolve url (does the playlist exist?)'
5342 raise ExtractorError(err_note
, expected
=True)
5343 self
.report_warning(err_note
, item_id
)
5345 _SEARCH_PARAMS
= None
5347 def _search_results(self
, query
, params
=NO_DEFAULT
, default_client
='web'):
5348 data
= {'query': query}
5349 if params
is NO_DEFAULT
:
5350 params
= self
._SEARCH
_PARAMS
5352 data
['params'] = params
5355 ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5356 ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5358 ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5359 ('continuationContents', ),
5361 display_id
= f
'query "{query}"'
5362 check_get_keys
= tuple({keys[0] for keys in content_keys}
)
5363 ytcfg
= self
._download
_ytcfg
(default_client
, display_id
) if not self
.skip_webpage
else {}
5364 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=False)
5366 continuation_list
= [None]
5368 for page_num
in itertools
.count(1):
5369 data
.update(continuation_list
[0] or {})
5370 headers
= self
.generate_api_headers(
5371 ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(search
), default_client
=default_client
)
5372 search
= self
._extract
_response
(
5373 item_id
=f
'{display_id} page {page_num}', ep
='search', query
=data
,
5374 default_client
=default_client
, check_get_keys
=check_get_keys
, ytcfg
=ytcfg
, headers
=headers
)
5375 slr_contents
= traverse_obj(search
, *content_keys
)
5376 yield from self
._extract
_entries
({'contents': list(variadic(slr_contents))}
, continuation_list
)
5377 if not continuation_list
[0]:
5381 class YoutubeTabIE(YoutubeTabBaseInfoExtractor
):
5382 IE_DESC
= 'YouTube Tabs'
5383 _VALID_URL
= r
'''(?x:
5385 (?!consent\.)(?:\w+\.)?
5387 youtube(?:kids)?\.com|
5391 (?P<channel_type>channel|c|user|browse)/|
5394 (?:playlist|watch)\?.*?\blist=
5396 (?!(?:%(reserved_names)s)\b) # Direct URLs
5400 'reserved_names': YoutubeBaseInfoExtractor
._RESERVED
_NAMES
,
5401 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
5403 IE_NAME
= 'youtube:tab'
5406 'note': 'playlists, multipage',
5407 'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5408 'playlist_mincount': 94,
5410 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5411 'title': 'Igor Kleiner - Playlists',
5412 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5413 'uploader': 'Igor Kleiner',
5414 'uploader_id': '@IgorDataScience',
5415 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5416 'channel': 'Igor Kleiner',
5417 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5418 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5419 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5420 'channel_follower_count': int
5423 'note': 'playlists, multipage, different order',
5424 'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5425 'playlist_mincount': 94,
5427 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5428 'title': 'Igor Kleiner - Playlists',
5429 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5430 'uploader': 'Igor Kleiner',
5431 'uploader_id': '@IgorDataScience',
5432 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5433 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5434 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5435 'channel': 'Igor Kleiner',
5436 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5437 'channel_follower_count': int
5440 'note': 'playlists, series',
5441 'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5442 'playlist_mincount': 5,
5444 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5445 'title': '3Blue1Brown - Playlists',
5446 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5447 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5448 'channel': '3Blue1Brown',
5449 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5450 'uploader_id': '@3blue1brown',
5451 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5452 'uploader': '3Blue1Brown',
5453 'tags': ['Mathematics'],
5454 'channel_follower_count': int,
5455 'channel_is_verified': True,
5458 'note': 'playlists, singlepage',
5459 'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5460 'playlist_mincount': 4,
5462 'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5463 'title': 'ThirstForScience - Playlists',
5464 'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5465 'uploader': 'ThirstForScience',
5466 'uploader_url': 'https://www.youtube.com/@ThirstForScience',
5467 'uploader_id': '@ThirstForScience',
5468 'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5469 'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5471 'channel': 'ThirstForScience',
5472 'channel_follower_count': int
5475 'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5476 'only_matching': True,
5478 'note': 'basic, single video playlist',
5479 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5481 'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5482 'title': 'youtube-dl public playlist',
5486 'modified_date': '20201130',
5487 'channel': 'Sergey M.',
5488 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5489 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5490 'availability': 'public',
5491 'uploader': 'Sergey M.',
5492 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5493 'uploader_id': '@sergeym.6173',
5495 'playlist_count': 1,
5497 'note': 'empty playlist',
5498 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5500 'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5501 'title': 'youtube-dl empty playlist',
5503 'channel': 'Sergey M.',
5505 'modified_date': '20160902',
5506 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5507 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5508 'availability': 'public',
5509 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5510 'uploader_id': '@sergeym.6173',
5511 'uploader': 'Sergey M.',
5513 'playlist_count': 0,
5516 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5518 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5519 'title': 'lex will - Home',
5520 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5521 'uploader': 'lex will',
5522 'uploader_id': '@lexwill718',
5523 'channel': 'lex will',
5524 'tags': ['bible', 'history', 'prophesy'],
5525 'uploader_url': 'https://www.youtube.com/@lexwill718',
5526 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5527 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5528 'channel_follower_count': int
5530 'playlist_mincount': 2,
5532 'note': 'Videos tab',
5533 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5535 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5536 'title': 'lex will - Videos',
5537 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5538 'uploader': 'lex will',
5539 'uploader_id': '@lexwill718',
5540 'tags': ['bible', 'history', 'prophesy'],
5541 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5542 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5543 'uploader_url': 'https://www.youtube.com/@lexwill718',
5544 'channel': 'lex will',
5545 'channel_follower_count': int
5547 'playlist_mincount': 975,
5549 'note': 'Videos tab, sorted by popular',
5550 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5552 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5553 'title': 'lex will - Videos',
5554 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5555 'uploader': 'lex will',
5556 'uploader_id': '@lexwill718',
5557 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5558 'uploader_url': 'https://www.youtube.com/@lexwill718',
5559 'channel': 'lex will',
5560 'tags': ['bible', 'history', 'prophesy'],
5561 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5562 'channel_follower_count': int
5564 'playlist_mincount': 199,
5566 'note': 'Playlists tab',
5567 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5569 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5570 'title': 'lex will - Playlists',
5571 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5572 'uploader': 'lex will',
5573 'uploader_id': '@lexwill718',
5574 'uploader_url': 'https://www.youtube.com/@lexwill718',
5575 'channel': 'lex will',
5576 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5577 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5578 'tags': ['bible', 'history', 'prophesy'],
5579 'channel_follower_count': int
5581 'playlist_mincount': 17,
5583 'note': 'Community tab',
5584 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5586 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5587 'title': 'lex will - Community',
5588 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5589 'channel': 'lex will',
5590 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5591 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5592 'tags': ['bible', 'history', 'prophesy'],
5593 'channel_follower_count': int,
5594 'uploader_url': 'https://www.youtube.com/@lexwill718',
5595 'uploader_id': '@lexwill718',
5596 'uploader': 'lex will',
5598 'playlist_mincount': 18,
5600 'note': 'Channels tab',
5601 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5603 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5604 'title': 'lex will - Channels',
5605 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5606 'channel': 'lex will',
5607 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5608 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5609 'tags': ['bible', 'history', 'prophesy'],
5610 'channel_follower_count': int,
5611 'uploader_url': 'https://www.youtube.com/@lexwill718',
5612 'uploader_id': '@lexwill718',
5613 'uploader': 'lex will',
5615 'playlist_mincount': 12,
5617 'note': 'Search tab',
5618 'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5619 'playlist_mincount': 40,
5621 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5622 'title': '3Blue1Brown - Search - linear algebra',
5623 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5624 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5625 'tags': ['Mathematics'],
5626 'channel': '3Blue1Brown',
5627 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5628 'channel_follower_count': int,
5629 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5630 'uploader_id': '@3blue1brown',
5631 'uploader': '3Blue1Brown',
5632 'channel_is_verified': True,
5635 'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5636 'only_matching': True,
5638 'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5639 'only_matching': True,
5641 'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5642 'only_matching': True,
5644 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5645 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5647 'title': '29C3: Not my department',
5648 'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5649 'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5652 'modified_date': '20150605',
5653 'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5654 'channel_url': 'https://www.youtube.com/channel/UCEPzS1rYsrkqzSLNp76nrcg',
5655 'channel': 'Christiaan008',
5656 'availability': 'public',
5657 'uploader_id': '@ChRiStIaAn008',
5658 'uploader': 'Christiaan008',
5659 'uploader_url': 'https://www.youtube.com/@ChRiStIaAn008',
5661 'playlist_count': 96,
5663 'note': 'Large playlist',
5664 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5666 'title': 'Uploads from Cauchemar',
5667 'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5668 'channel_url': 'https://www.youtube.com/channel/UCBABnxM4Ar9ten8Mdjj1j0Q',
5670 'modified_date': r
're:\d{8}',
5671 'channel': 'Cauchemar',
5674 'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5675 'availability': 'public',
5676 'uploader_id': '@Cauchemar89',
5677 'uploader': 'Cauchemar',
5678 'uploader_url': 'https://www.youtube.com/@Cauchemar89',
5680 'playlist_mincount': 1123,
5681 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5683 'note': 'even larger playlist, 8832 videos',
5684 'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5685 'only_matching': True,
5687 'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5688 'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5690 'title': 'Uploads from Interstellar Movie',
5691 'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5694 'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5695 'channel_url': 'https://www.youtube.com/channel/UCXw-G3eDE9trcvY2sBMM_aA',
5696 'channel': 'Interstellar Movie',
5698 'modified_date': r
're:\d{8}',
5699 'availability': 'public',
5700 'uploader_id': '@InterstellarMovie',
5701 'uploader': 'Interstellar Movie',
5702 'uploader_url': 'https://www.youtube.com/@InterstellarMovie',
5704 'playlist_mincount': 21,
5706 'note': 'Playlist with "show unavailable videos" button',
5707 'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5709 'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5710 'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5712 'channel': 'Phim Siêu Nhân Nhật Bản',
5715 'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5716 'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5717 'modified_date': r
're:\d{8}',
5718 'availability': 'public',
5719 'uploader_url': 'https://www.youtube.com/@phimsieunhannhatban',
5720 'uploader_id': '@phimsieunhannhatban',
5721 'uploader': 'Phim Siêu Nhân Nhật Bản',
5723 'playlist_mincount': 200,
5724 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5726 'note': 'Playlist with unavailable videos in page 7',
5727 'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5729 'title': 'Uploads from BlankTV',
5730 'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5731 'channel': 'BlankTV',
5732 'channel_url': 'https://www.youtube.com/channel/UC8l9frL61Yl5KFOl87nIm2w',
5733 'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5736 'modified_date': r
're:\d{8}',
5738 'availability': 'public',
5739 'uploader_id': '@blanktv',
5740 'uploader': 'BlankTV',
5741 'uploader_url': 'https://www.youtube.com/@blanktv',
5743 'playlist_mincount': 1000,
5744 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5746 'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5747 'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5749 'title': 'Data Analysis with Dr Mike Pound',
5750 'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5751 'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5754 'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5755 'channel_url': 'https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA',
5756 'channel': 'Computerphile',
5757 'availability': 'public',
5758 'modified_date': '20190712',
5759 'uploader_id': '@Computerphile',
5760 'uploader': 'Computerphile',
5761 'uploader_url': 'https://www.youtube.com/@Computerphile',
5763 'playlist_mincount': 11,
5765 'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5766 'only_matching': True,
5768 'note': 'Playlist URL that does not actually serve a playlist',
5769 'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5771 'id': 'FqZTN594JQw',
5773 'title': "Smiley's People 01 detective, Adventure Series, Action",
5774 'upload_date': '20150526',
5775 'license': 'Standard YouTube License',
5776 'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5777 'categories': ['People & Blogs'],
5783 'skip_download': True,
5785 'skip': 'This video is not available.',
5786 'add_ie': [YoutubeIE
.ie_key()],
5788 'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5789 'only_matching': True,
5791 'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5792 'only_matching': True,
5794 'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5796 'id': 'hGkQjiJLjWQ', # This will keep changing
5799 'upload_date': r
're:\d{8}',
5801 'categories': ['News & Politics'],
5804 'release_timestamp': int,
5805 'channel': 'Sky News',
5806 'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5809 'thumbnail': r
're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5810 'playable_in_embed': True,
5811 'release_date': r
're:\d+',
5812 'availability': 'public',
5813 'live_status': 'is_live',
5814 'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5815 'channel_follower_count': int,
5816 'concurrent_view_count': int,
5817 'uploader_url': 'https://www.youtube.com/@SkyNews',
5818 'uploader_id': '@SkyNews',
5819 'uploader': 'Sky News',
5820 'channel_is_verified': True,
5823 'skip_download': True,
5825 'expected_warnings': ['Ignoring subtitle tracks found in '],
5827 'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5829 'id': 'a48o2S1cPoo',
5831 'title': 'The Young Turks - Live Main Show',
5832 'upload_date': '20150715',
5833 'license': 'Standard YouTube License',
5834 'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5835 'categories': ['News & Politics'],
5836 'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5840 'skip_download': True,
5842 'only_matching': True,
5844 'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5845 'only_matching': True,
5847 'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5848 'only_matching': True,
5850 'note': 'A channel that is not live. Should raise error',
5851 'url': 'https://www.youtube.com/user/numberphile/live',
5852 'only_matching': True,
5854 'url': 'https://www.youtube.com/feed/trending',
5855 'only_matching': True,
5857 'url': 'https://www.youtube.com/feed/library',
5858 'only_matching': True,
5860 'url': 'https://www.youtube.com/feed/history',
5861 'only_matching': True,
5863 'url': 'https://www.youtube.com/feed/subscriptions',
5864 'only_matching': True,
5866 'url': 'https://www.youtube.com/feed/watch_later',
5867 'only_matching': True,
5869 'note': 'Recommended - redirects to home page.',
5870 'url': 'https://www.youtube.com/feed/recommended',
5871 'only_matching': True,
5873 'note': 'inline playlist with not always working continuations',
5874 'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5875 'only_matching': True,
5877 'url': 'https://www.youtube.com/course',
5878 'only_matching': True,
5880 'url': 'https://www.youtube.com/zsecurity',
5881 'only_matching': True,
5883 'url': 'http://www.youtube.com/NASAgovVideo/videos',
5884 'only_matching': True,
5886 'url': 'https://www.youtube.com/TheYoungTurks/live',
5887 'only_matching': True,
5889 'url': 'https://www.youtube.com/hashtag/cctv9',
5895 'playlist_mincount': 300, # not consistent but should be over 300
5897 'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
5898 'only_matching': True,
5900 'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
5901 'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5902 'only_matching': True
5904 'note': '/browse/ should redirect to /channel/',
5905 'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
5906 'only_matching': True
5908 'note': 'VLPL, should redirect to playlist?list=PL...',
5909 'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5911 'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5912 'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
5913 'title': 'NCS : All Releases 💿',
5914 'channel_url': 'https://www.youtube.com/channel/UC_aEa8K-EOJ3D6gOs7HcyNg',
5915 'modified_date': r
're:\d{8}',
5917 'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
5919 'channel': 'NoCopyrightSounds',
5920 'availability': 'public',
5921 'uploader_url': 'https://www.youtube.com/@NoCopyrightSounds',
5922 'uploader': 'NoCopyrightSounds',
5923 'uploader_id': '@NoCopyrightSounds',
5925 'playlist_mincount': 166,
5926 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden', 'YouTube Music is not directly supported'],
5928 # TODO: fix 'unviewable' issue with this playlist when reloading with unavailable videos
5929 'note': 'Topic, should redirect to playlist?list=UU...',
5930 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5932 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5933 'title': 'Uploads from Royalty Free Music - Topic',
5935 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5936 'channel': 'Royalty Free Music - Topic',
5938 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5939 'modified_date': r
're:\d{8}',
5941 'availability': 'public',
5942 'uploader': 'Royalty Free Music - Topic',
5944 'playlist_mincount': 101,
5945 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5947 # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
5948 # Treat as a general feed
5949 'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
5951 'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
5952 'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
5955 'playlist_mincount': 9,
5957 'note': 'Youtube music Album',
5958 'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
5960 'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
5961 'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
5965 'availability': 'unlisted',
5966 'modified_date': r
're:\d{8}',
5968 'playlist_count': 50,
5969 'expected_warnings': ['YouTube Music is not directly supported'],
5971 'note': 'unlisted single video playlist',
5972 'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5974 'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5975 'title': 'yt-dlp unlisted playlist test',
5976 'availability': 'unlisted',
5978 'modified_date': '20220418',
5979 'channel': 'colethedj',
5982 'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5983 'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5984 'uploader_url': 'https://www.youtube.com/@colethedj1894',
5985 'uploader_id': '@colethedj1894',
5986 'uploader': 'colethedj',
5990 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
5991 'id': 'BaW_jenozKc',
5993 'ie_key': 'Youtube',
5995 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
5996 'channel_url': 'https://www.youtube.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
5998 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc',
5999 'channel': 'Philipp Hagemeister',
6000 'uploader_id': '@PhilippHagemeister',
6001 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
6002 'uploader': 'Philipp Hagemeister',
6005 'playlist_count': 1,
6006 'params': {'extract_flat': True}
,
6008 'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
6009 'url': 'https://www.youtube.com/feed/recommended',
6011 'id': 'recommended',
6012 'title': 'recommended',
6015 'playlist_mincount': 50,
6017 'skip_download': True,
6018 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6021 'note': 'API Fallback: /videos tab, sorted by oldest first',
6022 'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
6024 'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6025 'title': 'Cody\'sLab - Videos',
6026 'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
6027 'channel': 'Cody\'sLab',
6028 'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6030 'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
6031 'channel_follower_count': int
6033 'playlist_mincount': 650,
6035 'skip_download': True,
6036 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6038 'skip': 'Query for sorting no longer works',
6040 'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
6041 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
6043 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
6044 'title': 'Uploads from Royalty Free Music - Topic',
6045 'modified_date': r
're:\d{8}',
6046 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
6048 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
6050 'channel': 'Royalty Free Music - Topic',
6052 'availability': 'public',
6053 'uploader': 'Royalty Free Music - Topic',
6055 'playlist_mincount': 101,
6057 'skip_download': True,
6058 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6060 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
6062 'note': 'non-standard redirect to regional channel',
6063 'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
6064 'only_matching': True
6066 'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
6067 'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6069 'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6070 'modified_date': '20220407',
6071 'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
6073 'availability': 'unlisted',
6074 'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
6075 'channel': 'pukkandan',
6076 'description': 'Test for collaborative playlist',
6077 'title': 'yt-dlp test - collaborative playlist',
6079 'uploader_url': 'https://www.youtube.com/@pukkandan',
6080 'uploader_id': '@pukkandan',
6081 'uploader': 'pukkandan',
6083 'playlist_mincount': 2
6085 'note': 'translated tab name',
6086 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
6088 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6090 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6091 'description': 'test description',
6092 'title': 'cole-dlp-test-acc - 再生リスト',
6093 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6094 'channel': 'cole-dlp-test-acc',
6095 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6096 'uploader_id': '@coletdjnz',
6097 'uploader': 'cole-dlp-test-acc',
6099 'playlist_mincount': 1,
6100 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6101 'expected_warnings': ['Preferring "ja"'],
6103 # XXX: this should really check flat playlist entries, but the test suite doesn't support that
6104 'note': 'preferred lang set with playlist with translated video titles',
6105 'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6107 'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6110 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6111 'channel': 'cole-dlp-test-acc',
6112 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6113 'description': 'test',
6114 'title': 'dlp test playlist',
6115 'availability': 'public',
6116 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6117 'uploader_id': '@coletdjnz',
6118 'uploader': 'cole-dlp-test-acc',
6120 'playlist_mincount': 1,
6121 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6122 'expected_warnings': ['Preferring "ja"'],
6124 # shorts audio pivot for 2GtVksBMYFM.
6125 'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
6127 'id': 'sfv_audio_pivot',
6128 'title': 'sfv_audio_pivot',
6131 'playlist_mincount': 50,
6134 # Channel with a real live tab (not to be mistaken with streams tab)
6135 # Do not treat like it should redirect to live stream
6136 'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
6138 'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
6139 'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
6142 'playlist_mincount': 20,
6144 # Tab name is not the same as tab id
6145 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
6147 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6148 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
6151 'playlist_mincount': 8,
6153 # Home tab id is literally home. Not to get mistaken with featured
6154 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
6156 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6157 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
6160 'playlist_mincount': 8,
6162 # Should get three playlists for videos, shorts and streams tabs
6163 'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6165 'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6166 'title': 'Polka Ch. 尾丸ポルカ',
6167 'channel_follower_count': int,
6168 'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6169 'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6170 'description': 'md5:e56b74b5bb7e9c701522162e9abfb822',
6171 'channel': 'Polka Ch. 尾丸ポルカ',
6173 'uploader_url': 'https://www.youtube.com/@OmaruPolka',
6174 'uploader': 'Polka Ch. 尾丸ポルカ',
6175 'uploader_id': '@OmaruPolka',
6177 'playlist_count': 3,
6179 # Shorts tab with channel with handle
6180 # TODO: fix channel description
6181 'url': 'https://www.youtube.com/@NotJustBikes/shorts',
6183 'id': 'UC0intLFzLaudFG-xAvUEO-A',
6184 'title': 'Not Just Bikes - Shorts',
6186 'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
6187 'description': 'md5:26bc55af26855a608a5cf89dfa595c8d',
6188 'channel_follower_count': int,
6189 'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
6190 'channel': 'Not Just Bikes',
6191 'uploader_url': 'https://www.youtube.com/@NotJustBikes',
6192 'uploader': 'Not Just Bikes',
6193 'uploader_id': '@NotJustBikes',
6195 'playlist_mincount': 10,
6198 'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
6200 'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6201 'title': '中村悠一 - Live',
6203 'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6204 'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
6206 'channel_follower_count': int,
6207 'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
6208 'uploader_url': 'https://www.youtube.com/@Yuichi-Nakamura',
6209 'uploader_id': '@Yuichi-Nakamura',
6212 'playlist_mincount': 60,
6214 # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
6215 # See test_youtube_lists
6216 'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
6217 'only_matching': True,
6219 # No uploads and no UCID given. Should fail with no uploads error
6220 # See test_youtube_lists
6221 'url': 'https://www.youtube.com/news',
6222 'only_matching': True
6224 # No videos tab but has a shorts tab
6225 'url': 'https://www.youtube.com/c/TKFShorts',
6227 'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6228 'title': 'Shorts Break - Shorts',
6230 'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6231 'channel': 'Shorts Break',
6232 'description': 'md5:6de33c5e7ba686e5f3efd4e19c7ef499',
6233 'channel_follower_count': int,
6234 'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
6235 'uploader_url': 'https://www.youtube.com/@ShortsBreak_Official',
6236 'uploader': 'Shorts Break',
6237 'uploader_id': '@ShortsBreak_Official',
6239 'playlist_mincount': 30,
6241 # Trending Now Tab. tab id is empty
6242 'url': 'https://www.youtube.com/feed/trending',
6245 'title': 'trending - Now',
6248 'playlist_mincount': 30,
6250 # Trending Gaming Tab. tab id is empty
6251 'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
6254 'title': 'trending - Gaming',
6257 'playlist_mincount': 30,
6259 # Shorts url result in shorts tab
6260 # TODO: Fix channel id extraction
6261 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
6263 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6264 'title': 'cole-dlp-test-acc - Shorts',
6265 'channel': 'cole-dlp-test-acc',
6266 'description': 'test description',
6267 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6268 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6270 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6271 'uploader_id': '@coletdjnz',
6272 'uploader': 'cole-dlp-test-acc',
6276 # Channel data is not currently available for short renderers (as of 2023-03-01)
6278 'ie_key': 'Youtube',
6279 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
6280 'id': 'sSM9J5YH_60',
6281 'title': 'SHORT short',
6286 'params': {'extract_flat': True}
,
6288 # Live video status should be extracted
6289 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
6291 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6292 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live', # TODO, should be Minecraft - Live or Minecraft - Topic - Live
6298 'ie_key': 'Youtube',
6299 'url': 'startswith:https://www.youtube.com/watch?v=',
6302 'live_status': 'is_live',
6305 'concurrent_view_count': int,
6308 'uploader_url': str,
6310 'channel_is_verified': bool, # this will keep changing
6313 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6314 'playlist_mincount': 1
6316 # Channel renderer metadata. Contains number of videos on the channel
6317 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/channels',
6319 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6320 'title': 'cole-dlp-test-acc - Channels',
6321 'channel': 'cole-dlp-test-acc',
6322 'description': 'test description',
6323 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6324 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6326 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6327 'uploader_id': '@coletdjnz',
6328 'uploader': 'cole-dlp-test-acc',
6333 'ie_key': 'YoutubeTab',
6334 'url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6335 'id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6336 'channel_id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6337 'title': 'PewDiePie',
6338 'channel': 'PewDiePie',
6339 'channel_url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6341 'channel_follower_count': int,
6342 'playlist_count': int,
6343 'uploader': 'PewDiePie',
6344 'uploader_url': 'https://www.youtube.com/@PewDiePie',
6345 'uploader_id': '@PewDiePie',
6346 'channel_is_verified': True,
6349 'params': {'extract_flat': True}
,
6351 'url': 'https://www.youtube.com/@3blue1brown/about',
6353 'id': 'UCYO_jab_esuFRV4b17AJtAw',
6354 'tags': ['Mathematics'],
6355 'title': '3Blue1Brown - About',
6356 'channel_follower_count': int,
6357 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
6358 'channel': '3Blue1Brown',
6360 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
6361 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
6362 'uploader_url': 'https://www.youtube.com/@3blue1brown',
6363 'uploader_id': '@3blue1brown',
6364 'uploader': '3Blue1Brown',
6365 'channel_is_verified': True,
6367 'playlist_count': 0,
6369 # Podcasts tab, with rich entry playlistRenderers
6370 'url': 'https://www.youtube.com/@99percentinvisiblepodcast/podcasts',
6372 'id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6373 'channel_id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6374 'uploader_url': 'https://www.youtube.com/@99percentinvisiblepodcast',
6375 'description': 'md5:3a0ed38f1ad42a68ef0428c04a15695c',
6376 'title': '99 Percent Invisible - Podcasts',
6377 'uploader': '99 Percent Invisible',
6378 'channel_follower_count': int,
6379 'channel_url': 'https://www.youtube.com/channel/UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6381 'channel': '99 Percent Invisible',
6382 'uploader_id': '@99percentinvisiblepodcast',
6384 'playlist_count': 1,
6386 # Releases tab, with rich entry playlistRenderers (same as Podcasts tab)
6387 'url': 'https://www.youtube.com/@AHimitsu/releases',
6389 'id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6390 'channel': 'A Himitsu',
6391 'uploader_url': 'https://www.youtube.com/@AHimitsu',
6392 'title': 'A Himitsu - Releases',
6393 'uploader_id': '@AHimitsu',
6394 'uploader': 'A Himitsu',
6395 'channel_id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6397 'description': 'I make music',
6398 'channel_url': 'https://www.youtube.com/channel/UCgFwu-j5-xNJml2FtTrrB3A',
6399 'channel_follower_count': int,
6400 'channel_is_verified': True,
6402 'playlist_mincount': 10,
6404 # Playlist with only shorts, shown as reel renderers
6405 # FIXME: future: YouTube currently doesn't give continuation for this,
6407 'url': 'https://www.youtube.com/playlist?list=UUxqPAgubo4coVn9Lx1FuKcg',
6409 'id': 'UUxqPAgubo4coVn9Lx1FuKcg',
6410 'channel_url': 'https://www.youtube.com/channel/UCxqPAgubo4coVn9Lx1FuKcg',
6412 'uploader_id': '@BangyShorts',
6414 'uploader_url': 'https://www.youtube.com/@BangyShorts',
6415 'channel_id': 'UCxqPAgubo4coVn9Lx1FuKcg',
6416 'channel': 'Bangy Shorts',
6417 'uploader': 'Bangy Shorts',
6419 'availability': 'public',
6420 'modified_date': '20230626',
6421 'title': 'Uploads from Bangy Shorts',
6423 'playlist_mincount': 100,
6424 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6428 def suitable(cls
, url
):
6429 return False if YoutubeIE
.suitable(url
) else super().suitable(url
)
6431 _URL_RE
= re
.compile(rf
'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
6433 def _get_url_mobj(self
, url
):
6434 mobj
= self
._URL
_RE
.match(url
).groupdict()
6435 mobj
.update((k
, '') for k
, v
in mobj
.items() if v
is None)
6438 def _extract_tab_id_and_name(self
, tab
, base_url
='https://www.youtube.com'):
6439 tab_name
= (tab
.get('title') or '').lower()
6440 tab_url
= urljoin(base_url
, traverse_obj(
6441 tab
, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
6443 tab_id
= (tab_url
and self
._get
_url
_mobj
(tab_url
)['tab'][1:]
6444 or traverse_obj(tab
, 'tabIdentifier', expected_type
=str))
6447 'TAB_ID_SPONSORSHIPS': 'membership',
6448 }.get(tab_id
, tab_id
), tab_name
6450 # Fallback to tab name if we cannot get the tab id.
6451 # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6452 # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6454 self
.write_debug(f
'Falling back to selected tab name: {tab_name}')
6458 }.get(tab_name
, tab_name
), tab_name
6460 def _has_tab(self
, tabs
, tab_id
):
6461 return any(self
._extract
_tab
_id
_and
_name
(tab
)[0] == tab_id
for tab
in tabs
)
6463 @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6464 def _real_extract(self
, url
, smuggled_data
):
6465 item_id
= self
._match
_id
(url
)
6466 url
= urllib
.parse
.urlunparse(
6467 urllib
.parse
.urlparse(url
)._replace
(netloc
='www.youtube.com'))
6468 compat_opts
= self
.get_param('compat_opts', [])
6470 mobj
= self
._get
_url
_mobj
(url
)
6471 pre
, tab
, post
, is_channel
= mobj
['pre'], mobj
['tab'], mobj
['post'], not mobj
['not_channel']
6472 if is_channel
and smuggled_data
.get('is_music_url'):
6473 if item_id
[:2] == 'VL': # Youtube music VL channels have an equivalent playlist
6474 return self
.url_result(
6475 f
'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE
, item_id
[2:])
6476 elif item_id
[:2] == 'MP': # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6477 mdata
= self
._extract
_tab
_endpoint
(
6478 f
'https://music.youtube.com/channel/{item_id}', item_id
, default_client
='web_music')
6479 murl
= traverse_obj(mdata
, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6480 get_all
=False, expected_type
=str)
6482 raise ExtractorError('Failed to resolve album to playlist')
6483 return self
.url_result(murl
, YoutubeTabIE
)
6484 elif mobj
['channel_type'] == 'browse': # Youtube music /browse/ should be changed to /channel/
6485 return self
.url_result(
6486 f
'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE
, item_id
)
6488 original_tab_id
, display_id
= tab
[1:], f
'{item_id}{tab}'
6489 if is_channel
and not tab
and 'no-youtube-channel-redirect' not in compat_opts
:
6490 url
= f
'{pre}/videos{post}'
6491 if smuggled_data
.get('is_music_url'):
6492 self
.report_warning(f
'YouTube Music is not directly supported. Redirecting to {url}')
6494 # Handle both video/playlist URLs
6496 video_id
, playlist_id
= [traverse_obj(qs
, (key
, 0)) for key
in ('v', 'list')]
6497 if not video_id
and mobj
['not_channel'].startswith('watch'):
6499 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6500 raise ExtractorError('A video URL was given without video ID', expected
=True)
6501 # Common mistake: https://www.youtube.com/watch?list=playlist_id
6502 self
.report_warning(f
'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6503 return self
.url_result(
6504 f
'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE
, playlist_id
)
6506 if not self
._yes
_playlist
(playlist_id
, video_id
):
6507 return self
.url_result(
6508 f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6510 data
, ytcfg
= self
._extract
_data
(url
, display_id
)
6512 # YouTube may provide a non-standard redirect to the regional channel
6513 # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6514 # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6515 redirect_url
= traverse_obj(
6516 data
, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all
=False)
6517 if redirect_url
and 'no-youtube-channel-redirect' not in compat_opts
:
6518 redirect_url
= ''.join((urljoin('https://www.youtube.com', redirect_url
), tab
, post
))
6519 self
.to_screen(f
'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6520 return self
.url_result(redirect_url
, YoutubeTabIE
)
6522 tabs
, extra_tabs
= self
._extract
_tab
_renderers
(data
), []
6523 if is_channel
and tabs
and 'no-youtube-channel-redirect' not in compat_opts
:
6524 selected_tab
= self
._extract
_selected
_tab
(tabs
)
6525 selected_tab_id
, selected_tab_name
= self
._extract
_tab
_id
_and
_name
(selected_tab
, url
) # NB: Name may be translated
6526 self
.write_debug(f
'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6528 if not original_tab_id
and selected_tab_name
:
6529 self
.to_screen('Downloading all uploads of the channel. '
6530 'To download only the videos in a specific tab, pass the tab\'s URL')
6531 if self
._has
_tab
(tabs
, 'streams'):
6532 extra_tabs
.append(''.join((pre
, '/streams', post
)))
6533 if self
._has
_tab
(tabs
, 'shorts'):
6534 extra_tabs
.append(''.join((pre
, '/shorts', post
)))
6535 # XXX: Members-only tab should also be extracted
6537 if not extra_tabs
and selected_tab_id
!= 'videos':
6538 # Channel does not have streams, shorts or videos tabs
6539 if item_id
[:2] != 'UC':
6540 raise ExtractorError('This channel has no uploads', expected
=True)
6542 # Topic channels don't have /videos. Use the equivalent playlist instead
6543 pl_id
= f
'UU{item_id[2:]}'
6544 pl_url
= f
'https://www.youtube.com/playlist?list={pl_id}'
6546 data
, ytcfg
= self
._extract
_data
(pl_url
, pl_id
, ytcfg
=ytcfg
, fatal
=True, webpage_fatal
=True)
6547 except ExtractorError
:
6548 raise ExtractorError('This channel has no uploads', expected
=True)
6550 item_id
, url
= pl_id
, pl_url
6552 f
'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6554 elif extra_tabs
and selected_tab_id
!= 'videos':
6555 # When there are shorts/live tabs but not videos tab
6556 url
, data
= f
'{pre}{post}', None
6558 elif (original_tab_id
or 'videos') != selected_tab_id
:
6559 if original_tab_id
== 'live':
6560 # Live tab should have redirected to the video
6561 # Except in the case the channel has an actual live tab
6562 # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6563 raise UserNotLive(video_id
=item_id
)
6564 elif selected_tab_name
:
6565 raise ExtractorError(f
'This channel does not have a {original_tab_id} tab', expected
=True)
6567 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6568 url
= f
'{pre}{post}'
6570 # YouTube sometimes provides a button to reload playlist with unavailable videos.
6571 if 'no-youtube-unavailable-videos' not in compat_opts
:
6572 data
= self
._reload
_with
_unavailable
_videos
(display_id
, data
, ytcfg
) or data
6573 self
._extract
_and
_report
_alerts
(data
, only_once
=True)
6575 tabs
, entries
= self
._extract
_tab
_renderers
(data
), []
6577 entries
= [self
._extract
_from
_tabs
(item_id
, ytcfg
, data
, tabs
)]
6579 'extractor_key': YoutubeTabIE
.ie_key(),
6580 'extractor': YoutubeTabIE
.IE_NAME
,
6583 if self
.get_param('playlist_items') == '0':
6584 entries
.extend(self
.url_result(u
, YoutubeTabIE
) for u
in extra_tabs
)
6585 else: # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6586 entries
.extend(map(self
._real
_extract
, extra_tabs
))
6588 if len(entries
) == 1:
6591 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
6592 uploads_url
= 'the Uploads (UU) playlist URL'
6593 if try_get(metadata
, lambda x
: x
['channel_id'].startswith('UC')):
6594 uploads_url
= f
'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6596 'Downloading as multiple playlists, separated by tabs. '
6597 f
'To download as a single playlist instead, pass {uploads_url}')
6598 return self
.playlist_result(entries
, item_id
, **metadata
)
6601 playlist
= traverse_obj(
6602 data
, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type
=dict)
6604 return self
._extract
_from
_playlist
(item_id
, url
, data
, playlist
, ytcfg
)
6606 video_id
= traverse_obj(
6607 data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str) or video_id
6609 if tab
!= '/live': # live tab is expected to redirect to video
6610 self
.report_warning(f
'Unable to recognize playlist. Downloading just video {video_id}')
6611 return self
.url_result(f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6613 raise ExtractorError('Unable to recognize tab page')
6616 class YoutubePlaylistIE(InfoExtractor
):
6617 IE_DESC
= 'YouTube playlists'
6618 _VALID_URL
= r
'''(?x)(?:
6623 youtube(?:kids)?\.com|
6628 (?P<id>%(playlist_id)s)
6630 'playlist_id': YoutubeBaseInfoExtractor
._PLAYLIST
_ID
_RE
,
6631 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
6633 IE_NAME
= 'youtube:playlist'
6635 'note': 'issue #673',
6636 'url': 'PLBB231211A4F62143',
6638 'title': '[OLD]Team Fortress 2 (Class-based LP)',
6639 'id': 'PLBB231211A4F62143',
6640 'uploader': 'Wickman',
6641 'uploader_id': '@WickmanVT',
6642 'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6644 'uploader_url': 'https://www.youtube.com/@WickmanVT',
6645 'modified_date': r
're:\d{8}',
6646 'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6647 'channel': 'Wickman',
6649 'channel_url': 'https://www.youtube.com/channel/UCKSpbfbl5kRQpTdL7kMc-1Q',
6650 'availability': 'public',
6652 'playlist_mincount': 29,
6654 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6656 'title': 'YDL_safe_search',
6657 'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6659 'playlist_count': 2,
6660 'skip': 'This playlist is private',
6663 'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6664 'playlist_count': 4,
6667 'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6668 'uploader': 'milan',
6669 'uploader_id': '@milan5503',
6671 'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6673 'modified_date': '20140919',
6676 'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6677 'uploader_url': 'https://www.youtube.com/@milan5503',
6678 'availability': 'public',
6680 'expected_warnings': [r
'[Uu]navailable videos? (is|are|will be) hidden'],
6682 'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6683 'playlist_mincount': 455,
6685 'title': '2018 Chinese New Singles (11/6 updated)',
6686 'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6688 'uploader_id': '@music_king',
6689 'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6692 'channel_url': 'https://www.youtube.com/channel/UC21nz3_MesPLqtDqwdvnoxA',
6694 'uploader_url': 'https://www.youtube.com/@music_king',
6695 'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6696 'modified_date': r
're:\d{8}',
6697 'availability': 'public',
6699 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6701 'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6702 'only_matching': True,
6704 # music album playlist
6705 'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6706 'only_matching': True,
6710 def suitable(cls
, url
):
6711 if YoutubeTabIE
.suitable(url
):
6713 from ..utils
import parse_qs
6715 if qs
.get('v', [None])[0]:
6717 return super().suitable(url
)
6719 def _real_extract(self
, url
):
6720 playlist_id
= self
._match
_id
(url
)
6721 is_music_url
= YoutubeBaseInfoExtractor
.is_music_url(url
)
6722 url
= update_url_query(
6723 'https://www.youtube.com/playlist',
6724 parse_qs(url
) or {'list': playlist_id}
)
6726 url
= smuggle_url(url
, {'is_music_url': True}
)
6727 return self
.url_result(url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6730 class YoutubeYtBeIE(InfoExtractor
):
6731 IE_DESC
= 'youtu.be'
6732 _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}
6734 'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6736 'id': 'yeWKywCrFtk',
6738 'title': 'Small Scale Baler and Braiding Rugs',
6739 'uploader': 'Backus-Page House Museum',
6740 'uploader_id': '@backuspagemuseum',
6741 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/@backuspagemuseum',
6742 'upload_date': '20161008',
6743 'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6744 'categories': ['Nonprofits & Activism'],
6748 'playable_in_embed': True,
6749 'thumbnail': r
're:^https?://.*\.webp',
6750 'channel': 'Backus-Page House Museum',
6751 'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6752 'live_status': 'not_live',
6754 'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6755 'availability': 'public',
6757 'comment_count': int,
6758 'channel_follower_count': int
6762 'skip_download': True,
6765 'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6766 'only_matching': True,
6769 def _real_extract(self
, url
):
6770 mobj
= self
._match
_valid
_url
(url
)
6771 video_id
= mobj
.group('id')
6772 playlist_id
= mobj
.group('playlist_id')
6773 return self
.url_result(
6774 update_url_query('https://www.youtube.com/watch', {
6776 'list': playlist_id
,
6777 'feature': 'youtu.be',
6778 }), ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6781 class YoutubeLivestreamEmbedIE(InfoExtractor
):
6782 IE_DESC
= 'YouTube livestream embeds'
6783 _VALID_URL
= r
'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6785 'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6786 'only_matching': True,
6789 def _real_extract(self
, url
):
6790 channel_id
= self
._match
_id
(url
)
6791 return self
.url_result(
6792 f
'https://www.youtube.com/channel/{channel_id}/live',
6793 ie
=YoutubeTabIE
.ie_key(), video_id
=channel_id
)
6796 class YoutubeYtUserIE(InfoExtractor
):
6797 IE_DESC
= 'YouTube user videos; "ytuser:" prefix'
6798 IE_NAME
= 'youtube:user'
6799 _VALID_URL
= r
'ytuser:(?P<id>.+)'
6801 'url': 'ytuser:phihag',
6802 'only_matching': True,
6805 def _real_extract(self
, url
):
6806 user_id
= self
._match
_id
(url
)
6807 return self
.url_result(f
'https://www.youtube.com/user/{user_id}', YoutubeTabIE
, user_id
)
6810 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor
):
6811 IE_NAME
= 'youtube:favorites'
6812 IE_DESC
= 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6813 _VALID_URL
= r
':ytfav(?:ou?rite)?s?'
6814 _LOGIN_REQUIRED
= True
6817 'only_matching': True,
6819 'url': ':ytfavorites',
6820 'only_matching': True,
6823 def _real_extract(self
, url
):
6824 return self
.url_result(
6825 'https://www.youtube.com/playlist?list=LL',
6826 ie
=YoutubeTabIE
.ie_key())
6829 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor
):
6830 IE_NAME
= 'youtube:notif'
6831 IE_DESC
= 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6832 _VALID_URL
= r
':ytnotif(?:ication)?s?'
6833 _LOGIN_REQUIRED
= True
6836 'only_matching': True,
6838 'url': ':ytnotifications',
6839 'only_matching': True,
6842 def _extract_notification_menu(self
, response
, continuation_list
):
6843 notification_list
= traverse_obj(
6845 ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6846 ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6847 expected_type
=list) or []
6848 continuation_list
[0] = None
6849 for item
in notification_list
:
6850 entry
= self
._extract
_notification
_renderer
(item
.get('notificationRenderer'))
6853 continuation
= item
.get('continuationItemRenderer')
6855 continuation_list
[0] = continuation
6857 def _extract_notification_renderer(self
, notification
):
6858 video_id
= traverse_obj(
6859 notification
, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str)
6860 url
= f
'https://www.youtube.com/watch?v={video_id}'
6863 browse_ep
= traverse_obj(
6864 notification
, ('navigationEndpoint', 'browseEndpoint'), expected_type
=dict)
6865 channel_id
= self
.ucid_or_none(traverse_obj(browse_ep
, 'browseId', expected_type
=str))
6866 post_id
= self
._search
_regex
(
6867 r
'/post/(.+)', traverse_obj(browse_ep
, 'canonicalBaseUrl', expected_type
=str),
6868 'post id', default
=None)
6869 if not channel_id
or not post_id
:
6871 # The direct /post url redirects to this in the browser
6872 url
= f
'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
6874 channel
= traverse_obj(
6875 notification
, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
6877 notification_title
= self
._get
_text
(notification
, 'shortMessage')
6878 if notification_title
:
6879 notification_title
= notification_title
.replace('\xad', '') # remove soft hyphens
6880 # TODO: handle recommended videos
6881 title
= self
._search
_regex
(
6882 rf
'{re.escape(channel or "")}[^:]+: (.+)', notification_title
,
6883 'video title', default
=None)
6884 timestamp
= (self
._parse
_time
_text
(self
._get
_text
(notification
, 'sentTimeText'))
6885 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
6890 'ie_key': (YoutubeIE
if video_id
else YoutubeTabIE
).ie_key(),
6891 'video_id': video_id
,
6893 'channel_id': channel_id
,
6895 'uploader': channel
,
6896 'thumbnails': self
._extract
_thumbnails
(notification
, 'videoThumbnail'),
6897 'timestamp': timestamp
,
6900 def _notification_menu_entries(self
, ytcfg
):
6901 continuation_list
= [None]
6903 for page
in itertools
.count(1):
6904 ctoken
= traverse_obj(
6905 continuation_list
, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type
=str)
6906 response
= self
._extract
_response
(
6907 item_id
=f
'page {page}', query
={'ctoken': ctoken}
if ctoken
else {}, ytcfg
=ytcfg
,
6908 ep
='notification/get_notification_menu', check_get_keys
='actions',
6909 headers
=self
.generate_api_headers(ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(response
)))
6910 yield from self
._extract
_notification
_menu
(response
, continuation_list
)
6911 if not continuation_list
[0]:
6914 def _real_extract(self
, url
):
6915 display_id
= 'notifications'
6916 ytcfg
= self
._download
_ytcfg
('web', display_id
) if not self
.skip_webpage
else {}
6917 self
._report
_playlist
_authcheck
(ytcfg
)
6918 return self
.playlist_result(self
._notification
_menu
_entries
(ytcfg
), display_id
, display_id
)
6921 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6922 IE_DESC
= 'YouTube search'
6923 IE_NAME
= 'youtube:search'
6924 _SEARCH_KEY
= 'ytsearch'
6925 _SEARCH_PARAMS
= 'EgIQAQ%3D%3D' # Videos only
6927 'url': 'ytsearch5:youtube-dl test video',
6928 'playlist_count': 5,
6930 'id': 'youtube-dl test video',
6931 'title': 'youtube-dl test video',
6936 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6937 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ ':date'
6938 _SEARCH_KEY
= 'ytsearchdate'
6939 IE_DESC
= 'YouTube search, newest videos first'
6940 _SEARCH_PARAMS
= 'CAISAhAB' # Videos only, sorted by date
6942 'url': 'ytsearchdate5:youtube-dl test video',
6943 'playlist_count': 5,
6945 'id': 'youtube-dl test video',
6946 'title': 'youtube-dl test video',
6951 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor
):
6952 IE_DESC
= 'YouTube search URLs with sorting and filter support'
6953 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ '_url'
6954 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6956 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
6957 'playlist_mincount': 5,
6959 'id': 'youtube-dl test video',
6960 'title': 'youtube-dl test video',
6963 'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
6964 'playlist_mincount': 5,
6970 'url': 'https://www.youtube.com/results?search_query=%23cats',
6971 'playlist_mincount': 1,
6975 # The test suite does not have support for nested playlists
6977 # 'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
6983 'url': 'https://www.youtube.com/results?search_query=kurzgesagt&sp=EgIQAg%253D%253D',
6986 'title': 'kurzgesagt',
6991 'id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6992 'url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6993 'ie_key': 'YoutubeTab',
6994 'channel': 'Kurzgesagt – In a Nutshell',
6995 'description': 'md5:4ae48dfa9505ffc307dad26342d06bfc',
6996 'title': 'Kurzgesagt – In a Nutshell',
6997 'channel_id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6998 # No longer available for search as it is set to the handle.
6999 # 'playlist_count': int,
7000 'channel_url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
7002 'uploader_id': '@kurzgesagt',
7003 'uploader_url': 'https://www.youtube.com/@kurzgesagt',
7004 'uploader': 'Kurzgesagt – In a Nutshell',
7005 'channel_is_verified': True,
7006 'channel_follower_count': int,
7009 'params': {'extract_flat': True, 'playlist_items': '1'}
,
7010 'playlist_mincount': 1,
7012 'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
7013 'only_matching': True,
7016 def _real_extract(self
, url
):
7018 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7019 return self
.playlist_result(self
._search
_results
(query
, qs
.get('sp', (None,))[0]), query
, query
)
7022 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor
):
7023 IE_DESC
= 'YouTube music search URLs with selectable sections, e.g. #songs'
7024 IE_NAME
= 'youtube:music:search_url'
7025 _VALID_URL
= r
'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
7027 'url': 'https://music.youtube.com/search?q=royalty+free+music',
7028 'playlist_count': 16,
7030 'id': 'royalty free music',
7031 'title': 'royalty free music',
7034 'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
7035 'playlist_mincount': 30,
7037 'id': 'royalty free music - songs',
7038 'title': 'royalty free music - songs',
7040 'params': {'extract_flat': 'in_playlist'}
7042 'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
7043 'playlist_mincount': 30,
7045 'id': 'royalty free music - community playlists',
7046 'title': 'royalty free music - community playlists',
7048 'params': {'extract_flat': 'in_playlist'}
7052 'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
7053 'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
7054 'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
7055 'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
7056 'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
7057 'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
7060 def _real_extract(self
, url
):
7062 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7063 params
= qs
.get('sp', (None,))[0]
7065 section
= next((k
for k
, v
in self
._SECTIONS
.items() if v
== params
), params
)
7067 section
= urllib
.parse
.unquote_plus((url
.split('#') + [''])[1]).lower()
7068 params
= self
._SECTIONS
.get(section
)
7071 title
= join_nonempty(query
, section
, delim
=' - ')
7072 return self
.playlist_result(self
._search
_results
(query
, params
, default_client
='web_music'), title
, title
)
7075 class YoutubeFeedsInfoExtractor(InfoExtractor
):
7077 Base class for feed extractors
7078 Subclasses must re-define the _FEED_NAME property.
7080 _LOGIN_REQUIRED
= True
7081 _FEED_NAME
= 'feeds'
7083 def _real_initialize(self
):
7084 YoutubeBaseInfoExtractor
._check
_login
_required
(self
)
7088 return f
'youtube:{self._FEED_NAME}'
7090 def _real_extract(self
, url
):
7091 return self
.url_result(
7092 f
'https://www.youtube.com/feed/{self._FEED_NAME}', ie
=YoutubeTabIE
.ie_key())
7095 class YoutubeWatchLaterIE(InfoExtractor
):
7096 IE_NAME
= 'youtube:watchlater'
7097 IE_DESC
= 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
7098 _VALID_URL
= r
':ytwatchlater'
7100 'url': ':ytwatchlater',
7101 'only_matching': True,
7104 def _real_extract(self
, url
):
7105 return self
.url_result(
7106 'https://www.youtube.com/playlist?list=WL', ie
=YoutubeTabIE
.ie_key())
7109 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor
):
7110 IE_DESC
= 'YouTube recommended videos; ":ytrec" keyword'
7111 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
7112 _FEED_NAME
= 'recommended'
7113 _LOGIN_REQUIRED
= False
7116 'only_matching': True,
7118 'url': ':ytrecommended',
7119 'only_matching': True,
7121 'url': 'https://youtube.com',
7122 'only_matching': True,
7126 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor
):
7127 IE_DESC
= 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
7128 _VALID_URL
= r
':ytsub(?:scription)?s?'
7129 _FEED_NAME
= 'subscriptions'
7132 'only_matching': True,
7134 'url': ':ytsubscriptions',
7135 'only_matching': True,
7139 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor
):
7140 IE_DESC
= 'Youtube watch history; ":ythis" keyword (requires cookies)'
7141 _VALID_URL
= r
':ythis(?:tory)?'
7142 _FEED_NAME
= 'history'
7144 'url': ':ythistory',
7145 'only_matching': True,
7149 class YoutubeShortsAudioPivotIE(InfoExtractor
):
7150 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
7151 IE_NAME
= 'youtube:shorts:pivot:audio'
7152 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
7154 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
7155 'only_matching': True,
7159 def _generate_audio_pivot_params(video_id
):
7161 Generates sfv_audio_pivot browse params for this video id
7163 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
7164 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
7166 def _real_extract(self
, url
):
7167 video_id
= self
._match
_id
(url
)
7168 return self
.url_result(
7169 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
7173 class YoutubeTruncatedURLIE(InfoExtractor
):
7174 IE_NAME
= 'youtube:truncated_url'
7175 IE_DESC
= False # Do not list
7176 _VALID_URL
= r
'''(?x)
7178 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
7181 annotation_id=annotation_[^&]+|
7187 attribution_link\?a=[^&]+
7193 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
7194 'only_matching': True,
7196 'url': 'https://www.youtube.com/watch?',
7197 'only_matching': True,
7199 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
7200 'only_matching': True,
7202 'url': 'https://www.youtube.com/watch?feature=foo',
7203 'only_matching': True,
7205 'url': 'https://www.youtube.com/watch?hl=en-GB',
7206 'only_matching': True,
7208 'url': 'https://www.youtube.com/watch?t=2372',
7209 'only_matching': True,
7212 def _real_extract(self
, url
):
7213 raise ExtractorError(
7214 'Did you forget to quote the URL? Remember that & is a meta '
7215 'character in most shells, so you want to put the URL in quotes, '
7217 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
7218 ' or simply youtube-dl BaW_jenozKc .',
7222 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
7223 IE_NAME
= 'youtube:clip'
7224 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7226 # FIXME: Other metadata should be extracted from the clip, not from the base video
7227 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7229 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7231 'section_start': 29.0,
7232 'section_end': 39.7,
7235 'availability': 'public',
7236 'categories': ['Gaming'],
7237 'channel': 'Scott The Woz',
7238 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7239 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7240 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7242 'playable_in_embed': True,
7244 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7245 'title': 'Mobile Games on Console - Scott The Woz',
7246 'upload_date': '20210920',
7247 'uploader': 'Scott The Woz',
7248 'uploader_id': '@ScottTheWoz',
7249 'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7251 'live_status': 'not_live',
7252 'channel_follower_count': int,
7253 'chapters': 'count:20',
7254 'comment_count': int,
7255 'heatmap': 'count:100',
7259 def _real_extract(self
, url
):
7260 clip_id
= self
._match
_id
(url
)
7261 _
, data
= self
._extract
_webpage
(url
, clip_id
)
7263 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7265 raise ExtractorError('Unable to find video ID')
7267 clip_data
= traverse_obj(data
, (
7268 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7269 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7270 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7271 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
7274 '_type': 'url_transparent',
7275 'url': f
'https://www.youtube.com/watch?v={video_id}',
7276 'ie_key': YoutubeIE
.ie_key(),
7278 'section_start': int(clip_data
['startTimeMs']) / 1000,
7279 'section_end': int(clip_data
['endTimeMs']) / 1000,
7283 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor
):
7284 IE_NAME
= 'youtube:consent'
7285 IE_DESC
= False # Do not list
7286 _VALID_URL
= r
'https?://consent\.youtube\.com/m\?'
7288 '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',
7290 'id': 'qVv6vCqciTM',
7293 'uploader_id': '@sana_natori',
7294 'comment_count': int,
7295 'chapters': 'count:13',
7296 'upload_date': '20221223',
7297 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7298 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7299 'uploader_url': 'https://www.youtube.com/@sana_natori',
7301 'release_date': '20221223',
7302 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7303 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7305 'playable_in_embed': True,
7307 'availability': 'public',
7308 'channel_follower_count': int,
7309 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7310 'categories': ['Entertainment'],
7311 'live_status': 'was_live',
7312 'release_timestamp': 1671793345,
7313 'channel': 'さなちゃんねる',
7314 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7315 'uploader': 'さなちゃんねる',
7316 'channel_is_verified': True,
7317 'heatmap': 'count:100',
7319 'add_ie': ['Youtube'],
7320 'params': {'skip_download': 'Youtube'}
,
7323 def _real_extract(self
, url
):
7324 redirect_url
= url_or_none(parse_qs(url
).get('continue', [None])[-1])
7325 if not redirect_url
:
7326 raise ExtractorError('Invalid cookie consent redirect URL', expected
=True)
7327 return self
.url_result(redirect_url
)
7330 class YoutubeTruncatedIDIE(InfoExtractor
):
7331 IE_NAME
= 'youtube:truncated_id'
7332 IE_DESC
= False # Do not list
7333 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7336 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7337 'only_matching': True,
7340 def _real_extract(self
, url
):
7341 video_id
= self
._match
_id
(url
)
7342 raise ExtractorError(
7343 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',