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 # Manual retry loop for multiple RetryManagers
951 # The proper RetryManager MUST be advanced after an error
952 # and its result MUST be checked if the manager is non fatal
955 response
= self
._call
_api
(
956 ep
=ep
, fatal
=True, headers
=headers
,
957 video_id
=item_id
, query
=query
, note
=note
,
958 context
=self
._extract
_context
(ytcfg
, default_client
),
959 api_key
=self
._extract
_api
_key
(ytcfg
, default_client
),
960 api_hostname
=api_hostname
, default_client
=default_client
)
961 except ExtractorError
as e
:
962 if not isinstance(e
.cause
, network_exceptions
):
963 return self
._error
_or
_warning
(e
, fatal
=fatal
)
964 elif not isinstance(e
.cause
, HTTPError
):
969 first_bytes
= e
.cause
.response
.read(512)
970 if not is_html(first_bytes
):
973 self
._webpage
_read
_content
(e
.cause
.response
, None, item_id
, prefix
=first_bytes
) or '{}', item_id
, fatal
=False),
974 lambda x
: x
['error']['message'], str)
976 self
._report
_alerts
([('ERROR', yt_error
)], fatal
=False)
977 # Downloading page may result in intermittent 5xx HTTP error
978 # Sometimes a 404 is also received. See: https://github.com/ytdl-org/youtube-dl/issues/28289
979 # We also want to catch all other network exceptions since errors in later pages can be troublesome
980 # See https://github.com/yt-dlp/yt-dlp/issues/507#issuecomment-880188210
981 if e
.cause
.status
not in (403, 429):
985 return self
._error
_or
_warning
(e
, fatal
=fatal
)
988 self
._extract
_and
_report
_alerts
(response
, only_once
=True)
989 except ExtractorError
as e
:
990 # YouTube's servers may return errors we want to retry on in a 200 OK response
991 # See: https://github.com/yt-dlp/yt-dlp/issues/839
992 if 'unknown error' in e
.msg
.lower():
996 return self
._error
_or
_warning
(e
, fatal
=fatal
)
997 # Youtube sometimes sends incomplete data
998 # See: https://github.com/ytdl-org/youtube-dl/issues/28194
999 if not traverse_obj(response
, *variadic(check_get_keys
)):
1000 icd_rm
.error
= ExtractorError('Incomplete data received', expected
=True)
1001 should_retry
= next(icd_retries
, None)
1002 if not should_retry
:
1009 def is_music_url(url
):
1010 return re
.match(r
'(https?://)?music\.youtube\.com/', url
) is not None
1012 def _extract_video(self
, renderer
):
1013 video_id
= renderer
.get('videoId')
1015 reel_header_renderer
= traverse_obj(renderer
, (
1016 'navigationEndpoint', 'reelWatchEndpoint', 'overlay', 'reelPlayerOverlayRenderer',
1017 'reelPlayerHeaderSupportedRenderers', 'reelPlayerHeaderRenderer'))
1019 title
= self
._get
_text
(renderer
, 'title', 'headline') or self
._get
_text
(reel_header_renderer
, 'reelTitleText')
1020 description
= self
._get
_text
(renderer
, 'descriptionSnippet')
1022 duration
= int_or_none(renderer
.get('lengthSeconds'))
1023 if duration
is None:
1024 duration
= parse_duration(self
._get
_text
(
1025 renderer
, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
1026 if duration
is None:
1027 # XXX: should write a parser to be more general to support more cases (e.g. shorts in shorts tab)
1028 duration
= parse_duration(self
._search
_regex
(
1029 r
'(?i)(ago)(?!.*\1)\s+(?P<duration>[a-z0-9 ,]+?)(?:\s+[\d,]+\s+views)?(?:\s+-\s+play\s+short)?$',
1030 traverse_obj(renderer
, ('title', 'accessibility', 'accessibilityData', 'label'), default
='', expected_type
=str),
1031 video_id
, default
=None, group
='duration'))
1033 channel_id
= traverse_obj(
1034 renderer
, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'),
1035 expected_type
=str, get_all
=False)
1037 channel_id
= traverse_obj(reel_header_renderer
, ('channelNavigationEndpoint', 'browseEndpoint', 'browseId'))
1039 channel_id
= self
.ucid_or_none(channel_id
)
1041 overlay_style
= traverse_obj(
1042 renderer
, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'),
1043 get_all
=False, expected_type
=str)
1044 badges
= self
._extract
_badges
(traverse_obj(renderer
, 'badges'))
1045 owner_badges
= self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges'))
1046 navigation_url
= urljoin('https://www.youtube.com/', traverse_obj(
1047 renderer
, ('navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url'),
1048 expected_type
=str)) or ''
1049 url
= f
'https://www.youtube.com/watch?v={video_id}'
1050 if overlay_style
== 'SHORTS' or '/shorts/' in navigation_url
:
1051 url
= f
'https://www.youtube.com/shorts/{video_id}'
1053 time_text
= (self
._get
_text
(renderer
, 'publishedTimeText', 'videoInfo')
1054 or self
._get
_text
(reel_header_renderer
, 'timestampText') or '')
1055 scheduled_timestamp
= str_to_int(traverse_obj(renderer
, ('upcomingEventData', 'startTime'), get_all
=False))
1058 'is_upcoming' if scheduled_timestamp
is not None
1059 else 'was_live' if 'streamed' in time_text
.lower()
1060 else 'is_live' if overlay_style
== 'LIVE' or self
._has
_badge
(badges
, BadgeType
.LIVE_NOW
)
1063 # videoInfo is a string like '50K views • 10 years ago'.
1064 view_count_text
= self
._get
_text
(renderer
, 'viewCountText', 'shortViewCountText', 'videoInfo') or ''
1065 view_count
= (0 if 'no views' in view_count_text
.lower()
1066 else self
._get
_count
({'simpleText': view_count_text}
))
1067 view_count_field
= 'concurrent_view_count' if live_status
in ('is_live', 'is_upcoming') else 'view_count'
1069 channel
= (self
._get
_text
(renderer
, 'ownerText', 'shortBylineText')
1070 or self
._get
_text
(reel_header_renderer
, 'channelTitleText'))
1072 channel_handle
= traverse_obj(renderer
, (
1073 'shortBylineText', 'runs', ..., 'navigationEndpoint',
1074 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl'))),
1075 expected_type
=self
.handle_from_url
, get_all
=False)
1078 'ie_key': YoutubeIE
.ie_key(),
1082 'description': description
,
1083 'duration': duration
,
1084 'channel_id': channel_id
,
1086 'channel_url': f
'https://www.youtube.com/channel/{channel_id}' if channel_id
else None,
1087 'uploader': channel
,
1088 'uploader_id': channel_handle
,
1089 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
1090 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
1091 'timestamp': (self
._parse
_time
_text
(time_text
)
1092 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
1094 'release_timestamp': scheduled_timestamp
,
1096 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
1097 else self
._availability
(
1098 is_private
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
) or None,
1099 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
1100 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
1101 is_unlisted
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
) or None),
1102 view_count_field
: view_count
,
1103 'live_status': live_status
,
1104 'channel_is_verified': True if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
) else None
1108 class YoutubeIE(YoutubeBaseInfoExtractor
):
1110 _VALID_URL
= r
"""(?x)^
1112 (?:https?://|//) # http(s):// or protocol-independent URL
1113 (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
1114 (?:www\.)?deturl\.com/www\.youtube\.com|
1115 (?:www\.)?pwnyoutube\.com|
1116 (?:www\.)?hooktube\.com|
1117 (?:www\.)?yourepeat\.com|
1118 tube\.majestyc\.net|
1120 youtube\.googleapis\.com)/ # the various hostnames, with wildcard subdomains
1121 (?:.*?\#/)? # handle anchor (#/) redirect urls
1122 (?: # the various things that can precede the ID:
1123 (?:(?:v|embed|e|shorts|live)/(?!videoseries|live_stream)) # v/ or embed/ or e/ or shorts/
1124 |(?: # or the v= param in all its forms
1125 (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
1126 (?:\?|\#!?) # the params delimiter ? or # or #!
1127 (?:.*?[&;])?? # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&v=V36LpHqtcDY)
1132 youtu\.be| # just youtu.be/xxxx
1133 vid\.plus| # or vid.plus/xxxx
1134 zwearz\.com/watch| # or zwearz.com/watch/xxxx
1137 |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
1139 )? # all until now is optional -> you can pass the naked ID
1140 (?P<id>[0-9A-Za-z_-]{11}) # here is it! the YouTube video ID
1141 (?(1).+)? # if we found the ID, everything can follow
1143 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
1148 <(?:[0-9A-Za-z-]+?)?iframe[^>]+?src=|
1156 (?P
<url
>(?
:https?
:)?
//(?
:www\
.)?
youtube(?
:-nocookie
)?\
.com
/
1157 (?
:embed|v|p
)/[0-9A
-Za
-z_
-]{11}
.*?
)
1159 # https://wordpress.org/plugins/lazy-load-for-videos/
1161 <a\s
[^
>]*\bhref
="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"
1162 \s
[^
>]*\bclass
="[^"]*\blazy
-load
-youtube
''',
1164 _RETURN_TYPE = 'video' # XXX: How to handle multifeed?
1167 r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
1168 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$',
1169 r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
1172 '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1173 '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1174 '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
1175 '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
1176 '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
1177 '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1178 '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1179 '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1180 # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
1181 '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
1182 '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1183 '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1184 '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1185 '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1186 '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1187 '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1188 '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1189 '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1193 '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1194 '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1195 '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1196 '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1197 '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
1198 '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1199 '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1201 # Apple HTTP Live Streaming
1202 '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1203 '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1204 '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1205 '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1206 '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1207 '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1208 '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1209 '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
1212 '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
1213 '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
1214 '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1215 '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
1216 '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
1217 '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'}, # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
1218 '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
1219 '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1220 '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
1221 '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1222 '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1223 '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
1226 '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
1227 '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
1228 '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
1229 '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1230 '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1231 '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
1232 '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
1235 '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1236 '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1237 '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1238 '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1239 '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1240 '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1241 '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
1242 '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1243 '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1244 '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1245 '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1246 '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1247 '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1248 '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1249 '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1250 # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
1251 '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1252 '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1253 '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1254 '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1255 '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1256 '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1259 '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
1260 '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
1262 # Dash webm audio with opus inside
1263 '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
1264 '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
1265 '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
1268 '_rtmp': {'protocol': 'rtmp'},
1270 # av01 video only formats sometimes served with "unknown" codecs
1271 '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1272 '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1273 '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1274 '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1275 '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1276 '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1277 '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1278 '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1280 _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1287 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1289 'id': 'BaW_jenozKc',
1291 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1292 'channel': 'Philipp Hagemeister',
1293 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1294 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1295 'upload_date': '20121002',
1296 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1297 'categories': ['Science & Technology'],
1298 'tags': ['youtube-dl'],
1302 'availability': 'public',
1303 'playable_in_embed': True,
1304 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1305 'live_status': 'not_live',
1309 'comment_count': int,
1310 'channel_follower_count': int,
1311 'uploader': 'Philipp Hagemeister',
1312 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1313 'uploader_id': '@PhilippHagemeister',
1314 'heatmap': 'count:100',
1318 'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1319 'note': 'Embed-only video (#1746)',
1321 'id': 'yZIXLfi8CZQ',
1323 'upload_date': '20120608',
1324 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1325 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1328 'skip': 'Private video',
1331 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1332 'note': 'Use the first video ID in the URL',
1334 'id': 'BaW_jenozKc',
1336 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1337 'channel': 'Philipp Hagemeister',
1338 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1339 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1340 'upload_date': '20121002',
1341 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1342 'categories': ['Science & Technology'],
1343 'tags': ['youtube-dl'],
1347 'availability': 'public',
1348 'playable_in_embed': True,
1349 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1350 'live_status': 'not_live',
1352 'comment_count': int,
1353 'channel_follower_count': int,
1354 'uploader': 'Philipp Hagemeister',
1355 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1356 'uploader_id': '@PhilippHagemeister',
1357 'heatmap': 'count:100',
1360 'skip_download': True,
1364 'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1365 'note': '256k DASH audio (format 141) via DASH manifest',
1367 'id': 'a9LDPn-MO4I',
1369 'upload_date': '20121002',
1371 'title': 'UHDTV TEST 8K VIDEO.mp4'
1374 'youtube_include_dash_manifest': True,
1377 'skip': 'format 141 not served anymore',
1379 # DASH manifest with encrypted signature
1381 'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1383 'id': 'IB3lcPjvWLA',
1385 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1386 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1388 'upload_date': '20131011',
1391 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1392 'playable_in_embed': True,
1393 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1395 'track': 'The Spark',
1396 'live_status': 'not_live',
1397 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1398 'channel': 'Afrojack',
1400 'availability': 'public',
1401 'categories': ['Music'],
1403 'alt_title': 'The Spark',
1404 'channel_follower_count': int,
1405 'uploader': 'Afrojack',
1406 'uploader_url': 'https://www.youtube.com/@Afrojack',
1407 'uploader_id': '@Afrojack',
1410 'youtube_include_dash_manifest': True,
1411 'format': '141/bestaudio[ext=m4a]',
1414 # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1416 'note': 'Embed allowed age-gate video',
1417 'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1419 'id': 'HtVdAasjOgU',
1421 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1422 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1424 'upload_date': '20140605',
1426 'categories': ['Gaming'],
1427 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1428 'availability': 'needs_auth',
1429 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1431 'channel': 'The Witcher',
1432 'live_status': 'not_live',
1434 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1435 'playable_in_embed': True,
1437 'channel_follower_count': int,
1438 'uploader': 'The Witcher',
1439 'uploader_url': 'https://www.youtube.com/@thewitcher',
1440 'uploader_id': '@thewitcher',
1441 'comment_count': int,
1442 'channel_is_verified': True,
1443 'heatmap': 'count:100',
1447 'note': 'Age-gate video with embed allowed in public site',
1448 'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1450 'id': 'HsUATh_Nc2U',
1452 'title': 'Godzilla 2 (Official Video)',
1453 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1454 'upload_date': '20200408',
1456 'availability': 'needs_auth',
1457 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1458 'channel': 'FlyingKitty',
1459 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1461 'categories': ['Entertainment'],
1462 'live_status': 'not_live',
1463 'tags': ['Flyingkitty', 'godzilla 2'],
1464 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1467 'playable_in_embed': True,
1468 'channel_follower_count': int,
1469 'uploader': 'FlyingKitty',
1470 'uploader_url': 'https://www.youtube.com/@FlyingKitty900',
1471 'uploader_id': '@FlyingKitty900',
1472 'comment_count': int,
1473 'channel_is_verified': True,
1477 'note': 'Age-gate video embedable only with clientScreen=EMBED',
1478 'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1480 'id': 'Tq92D6wQ1mg',
1481 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1483 'upload_date': '20191228',
1484 'description': 'md5:17eccca93a786d51bc67646756894066',
1487 'availability': 'needs_auth',
1488 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1490 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1491 'channel': 'Projekt Melody',
1492 'live_status': 'not_live',
1493 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1494 'playable_in_embed': True,
1495 'categories': ['Entertainment'],
1497 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1498 'comment_count': int,
1499 'channel_follower_count': int,
1500 'uploader': 'Projekt Melody',
1501 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
1502 'uploader_id': '@ProjektMelody',
1506 'note': 'Non-Agegated non-embeddable video',
1507 'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1509 'id': 'MeJVWBSsPAY',
1511 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1512 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1513 'upload_date': '20130730',
1514 'track': 'Such mich find mich',
1516 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1518 'playable_in_embed': False,
1519 'creator': 'OOMPH!',
1520 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1522 'alt_title': 'Such mich find mich',
1524 'channel': 'Herr Lurik',
1525 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1526 'categories': ['Music'],
1527 'availability': 'public',
1528 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1529 'live_status': 'not_live',
1531 'channel_follower_count': int,
1532 'uploader': 'Herr Lurik',
1533 'uploader_url': 'https://www.youtube.com/@HerrLurik',
1534 'uploader_id': '@HerrLurik',
1538 'note': 'Non-bypassable age-gated video',
1539 'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1540 'only_matching': True,
1542 # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1543 # YouTube Red ad is not captured for creator
1545 'url': '__2ABJjxzNo',
1547 'id': '__2ABJjxzNo',
1550 'upload_date': '20100430',
1551 'creator': 'deadmau5',
1552 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1553 'title': 'Deadmau5 - Some Chords (HD)',
1554 'alt_title': 'Some Chords',
1555 'availability': 'public',
1557 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1559 'live_status': 'not_live',
1560 'channel': 'deadmau5',
1561 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1563 'track': 'Some Chords',
1564 'artist': 'deadmau5',
1565 'playable_in_embed': True,
1567 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1568 'categories': ['Music'],
1569 'album': 'Some Chords',
1570 'channel_follower_count': int,
1571 'uploader': 'deadmau5',
1572 'uploader_url': 'https://www.youtube.com/@deadmau5',
1573 'uploader_id': '@deadmau5',
1575 'expected_warnings': [
1576 'DASH manifest missing',
1579 # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1581 'url': 'lqQg6PlCWgI',
1583 'id': 'lqQg6PlCWgI',
1586 'upload_date': '20150827',
1587 'description': 'md5:04bbbf3ccceb6795947572ca36f45904',
1588 'title': 'Hockey - Women - GER-AUS - London 2012 Olympic Games',
1590 'release_timestamp': 1343767800,
1591 'playable_in_embed': True,
1592 'categories': ['Sports'],
1593 'release_date': '20120731',
1594 'channel': 'Olympics',
1595 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1596 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1597 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1599 'availability': 'public',
1600 'live_status': 'was_live',
1602 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1603 'channel_follower_count': int,
1604 'uploader': 'Olympics',
1605 'uploader_url': 'https://www.youtube.com/@Olympics',
1606 'uploader_id': '@Olympics',
1607 'channel_is_verified': True,
1610 'skip_download': 'requires avconv',
1615 'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1617 'id': '_b-2C3KPAM0',
1619 'stretched_ratio': 16 / 9.,
1621 'upload_date': '20110310',
1622 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1623 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1624 'playable_in_embed': True,
1628 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1629 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1630 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1632 'categories': ['People & Blogs'],
1634 'live_status': 'not_live',
1635 'availability': 'unlisted',
1636 'comment_count': int,
1637 'channel_follower_count': int,
1639 'uploader_url': 'https://www.youtube.com/@AllenMeow',
1640 'uploader_id': '@AllenMeow',
1643 # url_encoded_fmt_stream_map is empty string
1645 'url': 'qEJwOuvDf7I',
1647 'id': 'qEJwOuvDf7I',
1649 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1651 'upload_date': '20150404',
1654 'skip_download': 'requires avconv',
1656 'skip': 'This live event has ended.',
1658 # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1660 'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1662 'id': 'FIl7x6_3R5Y',
1664 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1665 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1667 'upload_date': '20150625',
1668 'formats': 'mincount:31',
1670 'skip': 'not actual anymore',
1672 # DASH manifest with segment_list
1674 'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1675 'md5': '8ce563a1d667b599d21064e982ab9e31',
1677 'id': 'CsmdDsKjzN8',
1679 'upload_date': '20150501', # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1680 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1681 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1684 'youtube_include_dash_manifest': True,
1685 'format': '135', # bestvideo
1687 'skip': 'This live event has ended.',
1690 # Multifeed videos (multiple cameras), URL can be of any Camera
1691 # TODO: fix multifeed titles
1692 'url': 'https://www.youtube.com/watch?v=zaPI8MvL8pg',
1694 'id': 'zaPI8MvL8pg',
1695 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04',
1696 'description': 'md5:563ccbc698b39298481ca3c571169519',
1700 'id': 'j5yGuxZ8lLU',
1702 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Chris)',
1703 'description': 'md5:563ccbc698b39298481ca3c571169519',
1705 'channel_follower_count': int,
1706 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1707 'availability': 'public',
1708 'playable_in_embed': True,
1709 'upload_date': '20131105',
1710 'categories': ['Gaming'],
1711 'live_status': 'was_live',
1713 'release_timestamp': 1383701910,
1714 'thumbnail': 'https://i.ytimg.com/vi/j5yGuxZ8lLU/maxresdefault.jpg',
1715 'comment_count': int,
1718 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1719 'channel': 'WiiLikeToPlay',
1721 'release_date': '20131106',
1722 'uploader': 'WiiLikeToPlay',
1723 'uploader_id': '@WLTP',
1724 'uploader_url': 'https://www.youtube.com/@WLTP',
1728 'id': 'zaPI8MvL8pg',
1730 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Tyson)',
1731 'availability': 'public',
1732 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1733 'channel': 'WiiLikeToPlay',
1734 'channel_follower_count': int,
1735 'description': 'md5:563ccbc698b39298481ca3c571169519',
1740 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1741 'release_timestamp': 1383701915,
1742 'comment_count': int,
1743 'upload_date': '20131105',
1744 'thumbnail': 'https://i.ytimg.com/vi/zaPI8MvL8pg/maxresdefault.jpg',
1745 'release_date': '20131106',
1746 'playable_in_embed': True,
1747 'live_status': 'was_live',
1748 'categories': ['Gaming'],
1750 'uploader': 'WiiLikeToPlay',
1751 'uploader_id': '@WLTP',
1752 'uploader_url': 'https://www.youtube.com/@WLTP',
1756 'id': 'R7r3vfO7Hao',
1758 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Spencer)',
1759 'thumbnail': 'https://i.ytimg.com/vi/R7r3vfO7Hao/maxresdefault.jpg',
1760 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1762 'availability': 'public',
1763 'playable_in_embed': True,
1764 'upload_date': '20131105',
1765 'description': 'md5:563ccbc698b39298481ca3c571169519',
1766 'channel_follower_count': int,
1768 'release_date': '20131106',
1769 'comment_count': int,
1770 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1771 'channel': 'WiiLikeToPlay',
1772 'categories': ['Gaming'],
1773 'release_timestamp': 1383701914,
1774 'live_status': 'was_live',
1778 'uploader': 'WiiLikeToPlay',
1779 'uploader_id': '@WLTP',
1780 'uploader_url': 'https://www.youtube.com/@WLTP',
1783 'params': {'skip_download': True},
1786 # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1787 'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1789 'id': 'gVfLd0zydlo',
1790 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1792 'playlist_count': 2,
1793 'skip': 'Not multifeed anymore',
1796 'url': 'https://vid.plus/FlRa-iH7PGw',
1797 'only_matching': True,
1800 'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1801 'only_matching': True,
1804 # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1805 # Also tests cut-off URL expansion in video description (see
1806 # https://github.com/ytdl-org/youtube-dl/issues/1892,
1807 # https://github.com/ytdl-org/youtube-dl/issues/8164)
1808 'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1810 'id': 'lsguqyKfVQg',
1812 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1813 'alt_title': 'Dark Walk',
1814 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1816 'upload_date': '20151119',
1817 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1818 'track': 'Dark Walk',
1819 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1820 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1821 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1822 'categories': ['Film & Animation'],
1824 'live_status': 'not_live',
1825 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1826 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1828 'availability': 'public',
1829 'channel': 'IronSoulElf',
1830 'playable_in_embed': True,
1833 'channel_follower_count': int
1836 'skip_download': True,
1840 # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1841 'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1842 'only_matching': True,
1845 # Video with yt:stretch=17:0
1846 'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1848 'id': 'Q39EVAstoRM',
1850 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1851 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1852 'upload_date': '20151107',
1855 'skip_download': True,
1857 'skip': 'This video does not exist.',
1860 # Video with incomplete 'yt:stretch=16:'
1861 'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1862 'only_matching': True,
1865 # Video licensed under Creative Commons
1866 'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1868 'id': 'M4gD1WSo5mA',
1870 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1871 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1873 'upload_date': '20150128',
1874 'license': 'Creative Commons Attribution license (reuse allowed)',
1875 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1876 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1879 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1880 'channel': 'The Berkman Klein Center for Internet & Society',
1881 'availability': 'public',
1883 'categories': ['Education'],
1884 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1885 'live_status': 'not_live',
1886 'playable_in_embed': True,
1887 'channel_follower_count': int,
1889 'uploader': 'The Berkman Klein Center for Internet & Society',
1890 'uploader_id': '@BKCHarvard',
1891 'uploader_url': 'https://www.youtube.com/@BKCHarvard',
1894 'skip_download': True,
1898 'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1900 'id': 'eQcmzGIKrzg',
1902 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1903 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1905 'upload_date': '20151120',
1906 'license': 'Creative Commons Attribution license (reuse allowed)',
1907 'playable_in_embed': True,
1910 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1912 'availability': 'public',
1913 'categories': ['News & Politics'],
1914 'channel': 'Bernie Sanders',
1915 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1917 'live_status': 'not_live',
1918 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1919 'comment_count': int,
1920 'channel_follower_count': int,
1922 'uploader': 'Bernie Sanders',
1923 'uploader_url': 'https://www.youtube.com/@BernieSanders',
1924 'uploader_id': '@BernieSanders',
1925 'channel_is_verified': True,
1926 'heatmap': 'count:100',
1929 'skip_download': True,
1933 'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;v=V36LpHqtcDY',
1934 'only_matching': True,
1937 # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1938 'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1939 'only_matching': True,
1942 # Rental video preview
1943 'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1945 'id': 'uGpuVWrhIzE',
1947 'title': 'Piku - Trailer',
1948 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1949 'upload_date': '20150811',
1950 'license': 'Standard YouTube License',
1953 'skip_download': True,
1955 'skip': 'This video is not available.',
1958 # YouTube Red video with episode data
1959 'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1961 'id': 'iqKdEhx-dD4',
1963 'title': 'Isolation - Mind Field (Ep 1)',
1964 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1966 'upload_date': '20170118',
1967 'series': 'Mind Field',
1969 'episode_number': 1,
1970 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1973 'availability': 'public',
1975 'channel': 'Vsauce',
1976 'episode': 'Episode 1',
1977 'categories': ['Entertainment'],
1978 'season': 'Season 1',
1979 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
1980 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
1982 'playable_in_embed': True,
1983 'live_status': 'not_live',
1984 'channel_follower_count': int,
1985 'uploader': 'Vsauce',
1986 'uploader_url': 'https://www.youtube.com/@Vsauce',
1987 'uploader_id': '@Vsauce',
1988 'comment_count': int,
1989 'channel_is_verified': True,
1992 'skip_download': True,
1994 'expected_warnings': [
1995 'Skipping DASH manifest',
1999 # The following content has been identified by the YouTube community
2000 # as inappropriate or offensive to some audiences.
2001 'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
2003 'id': '6SJNVb0GnPI',
2005 'title': 'Race Differences in Intelligence',
2006 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
2008 'upload_date': '20140124',
2011 'skip_download': True,
2013 'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
2017 'url': '1t24XAntNCY',
2018 'only_matching': True,
2021 # geo restricted to JP
2022 'url': 'sJL6WA-aGkQ',
2023 'only_matching': True,
2026 'url': 'https://invidio.us/watch?v=BaW_jenozKc',
2027 'only_matching': True,
2030 'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
2031 'only_matching': True,
2034 # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
2035 'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
2036 'only_matching': True,
2040 'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
2041 'only_matching': True,
2044 # Video with unsupported adaptive stream type formats
2045 'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
2047 'id': 'Z4Vy8R84T1U',
2049 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
2050 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
2052 'upload_date': '20130923',
2053 'formats': 'maxcount:10',
2056 'skip_download': True,
2057 'youtube_include_dash_manifest': False,
2059 'skip': 'not actual anymore',
2062 # Youtube Music Auto-generated description
2063 # TODO: fix metadata extraction
2064 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2066 'id': 'MgNrAu2pzNs',
2068 'title': 'Voyeur Girl',
2069 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
2070 'upload_date': '20190312',
2071 'artist': 'Stephen',
2072 'track': 'Voyeur Girl',
2073 'album': 'it\'s too much love to know my dear',
2074 'release_date': '20190313',
2075 'release_year': 2019,
2076 'alt_title': 'Voyeur Girl',
2078 'playable_in_embed': True,
2080 'categories': ['Music'],
2081 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
2082 'channel': 'Stephen', # TODO: should be "Stephen - Topic"
2083 'uploader': 'Stephen',
2084 'availability': 'public',
2085 'creator': 'Stephen',
2087 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
2089 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
2091 'live_status': 'not_live',
2092 'channel_follower_count': int
2095 'skip_download': True,
2099 'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
2100 'only_matching': True,
2103 # invalid -> valid video id redirection
2104 'url': 'DJztXj2GPfl',
2106 'id': 'DJztXj2GPfk',
2108 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
2109 'description': 'md5:bf577a41da97918e94fa9798d9228825',
2110 'upload_date': '20090125',
2111 'artist': 'Panjabi MC',
2112 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
2113 'album': 'Beware of the Boys (Mundian To Bach Ke)',
2116 'skip_download': True,
2118 'skip': 'Video unavailable',
2121 # empty description results in an empty string
2122 'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
2124 'id': 'x41yOUIvK2k',
2126 'title': 'IMG 3456',
2128 'upload_date': '20170613',
2130 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
2132 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
2134 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
2135 'availability': 'public',
2137 'categories': ['Pets & Animals'],
2139 'playable_in_embed': True,
2140 'live_status': 'not_live',
2141 'channel': 'l\'Or Vert asbl',
2142 'channel_follower_count': int,
2143 'uploader': 'l\'Or Vert asbl',
2144 'uploader_url': 'https://www.youtube.com/@ElevageOrVert',
2145 'uploader_id': '@ElevageOrVert',
2148 'skip_download': True,
2152 # with '};' inside yt initial data (see [1])
2153 # see [2] for an example with '};' inside ytInitialPlayerResponse
2154 # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
2155 # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
2156 'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
2158 'id': 'CHqg6qOn4no',
2160 'title': 'Part 77 Sort a list of simple types in c#',
2161 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
2162 'upload_date': '20130831',
2163 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
2165 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
2166 'live_status': 'not_live',
2167 'categories': ['Education'],
2168 'availability': 'public',
2169 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
2171 'playable_in_embed': True,
2175 'channel': 'kudvenkat',
2176 'comment_count': int,
2177 'channel_follower_count': int,
2179 'uploader': 'kudvenkat',
2180 'uploader_url': 'https://www.youtube.com/@Csharp-video-tutorialsBlogspot',
2181 'uploader_id': '@Csharp-video-tutorialsBlogspot',
2182 'channel_is_verified': True,
2183 'heatmap': 'count:100',
2186 'skip_download': True,
2190 # another example of '};' in ytInitialData
2191 'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
2192 'only_matching': True,
2195 'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
2196 'only_matching': True,
2199 # https://github.com/ytdl-org/youtube-dl/pull/28094
2200 'url': 'OtqTfy26tG0',
2202 'id': 'OtqTfy26tG0',
2204 'title': 'Burn Out',
2205 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
2206 'upload_date': '20141120',
2207 'artist': 'The Cinematic Orchestra',
2208 'track': 'Burn Out',
2209 'album': 'Every Day',
2211 'live_status': 'not_live',
2212 'alt_title': 'Burn Out',
2216 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2217 'creator': 'The Cinematic Orchestra',
2218 'channel': 'The Cinematic Orchestra',
2219 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
2220 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2221 'availability': 'public',
2222 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
2223 'categories': ['Music'],
2224 'playable_in_embed': True,
2225 'channel_follower_count': int,
2226 'uploader': 'The Cinematic Orchestra',
2227 'comment_count': int,
2230 'skip_download': True,
2234 # controversial video, only works with bpctr when authenticated with cookies
2235 'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
2236 'only_matching': True,
2239 # controversial video, requires bpctr/contentCheckOk
2240 'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
2242 'id': 'SZJvDhaSDnc',
2244 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
2245 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
2246 'upload_date': '20140716',
2247 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
2249 'categories': ['News & Politics'],
2251 'channel': 'CBS Mornings',
2252 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
2253 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
2255 'availability': 'needs_auth',
2256 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
2258 'live_status': 'not_live',
2259 'playable_in_embed': True,
2260 'channel_follower_count': int,
2261 'uploader': 'CBS Mornings',
2262 'uploader_url': 'https://www.youtube.com/@CBSMornings',
2263 'uploader_id': '@CBSMornings',
2264 'comment_count': int,
2265 'channel_is_verified': True,
2269 # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
2270 'url': 'cBvYw8_A0vQ',
2272 'id': 'cBvYw8_A0vQ',
2274 'title': '4K Ueno Okachimachi Street Scenes 上野御徒町歩き',
2275 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
2276 'upload_date': '20201120',
2278 'categories': ['Travel & Events'],
2279 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2281 'channel': 'Walk around Japan',
2282 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
2283 'thumbnail': 'https://i.ytimg.com/vi_webp/cBvYw8_A0vQ/hqdefault.webp',
2285 'availability': 'public',
2286 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2287 'live_status': 'not_live',
2288 'playable_in_embed': True,
2289 'channel_follower_count': int,
2290 'uploader': 'Walk around Japan',
2291 'uploader_url': 'https://www.youtube.com/@walkaroundjapan7124',
2292 'uploader_id': '@walkaroundjapan7124',
2295 'skip_download': True,
2298 # Has multiple audio streams
2299 'url': 'WaOKSUlf4TM',
2300 'only_matching': True
2302 # Requires Premium: has format 141 when requested using YTM url
2303 'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2304 'only_matching': True
2306 # multiple subtitles with same lang_code
2307 'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2308 'only_matching': True,
2310 # Force use android client fallback
2311 'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2313 'id': 'YOelRv7fMxY',
2314 'title': 'DIGGING A SECRET TUNNEL Part 1',
2316 'upload_date': '20210624',
2317 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2318 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2319 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2321 'categories': ['Entertainment'],
2323 'channel': 'colinfurze',
2324 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2325 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2327 'availability': 'public',
2329 'live_status': 'not_live',
2330 'playable_in_embed': True,
2331 'channel_follower_count': int,
2333 'uploader': 'colinfurze',
2334 'uploader_url': 'https://www.youtube.com/@colinfurze',
2335 'uploader_id': '@colinfurze',
2336 'comment_count': int,
2337 'channel_is_verified': True,
2338 'heatmap': 'count:100',
2341 'format': '17', # 3gp format available on android
2342 'extractor_args': {'youtube': {'player_client': ['android']}},
2346 # Skip download of additional client configs (remix client config in this case)
2347 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2348 'only_matching': True,
2350 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2354 'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2355 'only_matching': True,
2357 'note': 'Storyboards',
2358 'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2360 'id': '5KLPxDtMqe8',
2363 'title': 'Your Brain is Plastic',
2364 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2365 'upload_date': '20140324',
2367 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2368 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2370 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2371 'playable_in_embed': True,
2373 'availability': 'public',
2374 'channel': 'SciShow',
2375 'live_status': 'not_live',
2377 'categories': ['Education'],
2379 'channel_follower_count': int,
2381 'uploader': 'SciShow',
2382 'uploader_url': 'https://www.youtube.com/@SciShow',
2383 'uploader_id': '@SciShow',
2384 'comment_count': int,
2385 'channel_is_verified': True,
2386 'heatmap': 'count:100',
2387 }, 'params': {'format': 'mhtml', 'skip_download': True}
2389 # Ensure video upload_date is in UTC timezone (video was uploaded 1641170939)
2390 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2392 'id': '2NUZ8W2llS4',
2394 'title': 'The NP that test your phone performance 🙂',
2395 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2396 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2397 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2401 'categories': ['Gaming'],
2403 'playable_in_embed': True,
2404 'live_status': 'not_live',
2405 'upload_date': '20220103',
2407 'availability': 'public',
2408 'channel': 'Leon Nguyen',
2409 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2410 'comment_count': int,
2411 'channel_follower_count': int,
2412 'uploader': 'Leon Nguyen',
2413 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2414 'uploader_id': '@LeonNguyen',
2415 'heatmap': 'count:100',
2418 # Same video as above, but with --compat-opt no-youtube-prefer-utc-upload-date
2419 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2421 'id': '2NUZ8W2llS4',
2423 'title': 'The NP that test your phone performance 🙂',
2424 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2425 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2426 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2430 'categories': ['Gaming'],
2432 'playable_in_embed': True,
2433 'live_status': 'not_live',
2434 'upload_date': '20220102',
2436 'availability': 'public',
2437 'channel': 'Leon Nguyen',
2438 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2439 'comment_count': int,
2440 'channel_follower_count': int,
2441 'uploader': 'Leon Nguyen',
2442 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2443 'uploader_id': '@LeonNguyen',
2444 'heatmap': 'count:100',
2446 'params': {'compat_opts': ['no-youtube-prefer-utc-upload-date']}
2448 # date text is premiered video, ensure upload date in UTC (published 1641172509)
2449 'url': 'https://www.youtube.com/watch?v=mzZzzBU6lrM',
2451 'id': 'mzZzzBU6lrM',
2453 'title': 'I Met GeorgeNotFound In Real Life...',
2454 'description': 'md5:978296ec9783a031738b684d4ebf302d',
2455 'channel_id': 'UC_8NknAFiyhOUaZqHR3lq3Q',
2456 'channel_url': 'https://www.youtube.com/channel/UC_8NknAFiyhOUaZqHR3lq3Q',
2460 'categories': ['Entertainment'],
2462 'playable_in_embed': True,
2463 'live_status': 'not_live',
2464 'release_timestamp': 1641172509,
2465 'release_date': '20220103',
2466 'upload_date': '20220103',
2468 'availability': 'public',
2469 'channel': 'Quackity',
2470 'thumbnail': 'https://i.ytimg.com/vi/mzZzzBU6lrM/maxresdefault.jpg',
2471 'channel_follower_count': int,
2472 'uploader': 'Quackity',
2473 'uploader_id': '@Quackity',
2474 'uploader_url': 'https://www.youtube.com/@Quackity',
2475 'comment_count': int,
2476 'channel_is_verified': True,
2477 'heatmap': 'count:100',
2480 { # continuous livestream. Microformat upload date should be preferred.
2481 # Upload date was 2021-06-19 (not UTC), while stream start is 2021-11-27
2482 'url': 'https://www.youtube.com/watch?v=kgx4WGK0oNU',
2484 'id': 'kgx4WGK0oNU',
2485 '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}',
2487 'channel_id': 'UC84whx2xxsiA1gXHXXqKGOA',
2488 'availability': 'public',
2490 'release_timestamp': 1637975704,
2491 'upload_date': '20210619',
2492 'channel_url': 'https://www.youtube.com/channel/UC84whx2xxsiA1gXHXXqKGOA',
2493 'live_status': 'is_live',
2494 'thumbnail': 'https://i.ytimg.com/vi/kgx4WGK0oNU/maxresdefault.jpg',
2495 'channel': 'Abao in Tokyo',
2496 'channel_follower_count': int,
2497 'release_date': '20211127',
2499 'categories': ['People & Blogs'],
2502 'playable_in_embed': True,
2503 'description': 'md5:2ef1d002cad520f65825346e2084e49d',
2504 'concurrent_view_count': int,
2505 'uploader': 'Abao in Tokyo',
2506 'uploader_url': 'https://www.youtube.com/@abaointokyo',
2507 'uploader_id': '@abaointokyo',
2509 'params': {'skip_download': True}
2511 'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2513 'id': 'tjjjtzRLHvA',
2515 'title': 'ハッシュタグ無し };if window.ytcsi',
2516 'upload_date': '20220323',
2518 'availability': 'unlisted',
2519 'channel': 'Lesmiscore',
2520 'thumbnail': r're:^https?://.*\.jpg',
2522 'categories': ['Music'],
2525 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2526 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2527 'live_status': 'not_live',
2528 'playable_in_embed': True,
2529 'channel_follower_count': int,
2532 'uploader_id': '@lesmiscore',
2533 'uploader': 'Lesmiscore',
2534 'uploader_url': 'https://www.youtube.com/@lesmiscore',
2537 # Prefer primary title+description language metadata by default
2538 # Do not prefer translated description if primary is empty
2539 'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2541 'id': 'el3E4MbxRqQ',
2543 'title': 'dlp test video 2 - primary sv no desc',
2545 'channel': 'cole-dlp-test-acc',
2548 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2550 'playable_in_embed': True,
2551 'availability': 'unlisted',
2552 'thumbnail': r're:^https?://.*\.jpg',
2555 'live_status': 'not_live',
2556 'upload_date': '20220908',
2557 'categories': ['People & Blogs'],
2558 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2559 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2560 'uploader_id': '@coletdjnz',
2561 'uploader': 'cole-dlp-test-acc',
2563 'params': {'skip_download': True}
2565 # Extractor argument: prefer translated title+description
2566 'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2568 'id': 'gHKT4uU8Zng',
2570 'channel': 'cole-dlp-test-acc',
2573 'live_status': 'not_live',
2574 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2575 'upload_date': '20220728',
2577 'categories': ['People & Blogs'],
2578 'thumbnail': r're:^https?://.*\.jpg',
2579 'title': 'dlp test video title translated (fr)',
2580 'availability': 'public',
2582 'description': 'dlp test video description translated (fr)',
2583 'playable_in_embed': True,
2584 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2585 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2586 'uploader_id': '@coletdjnz',
2587 'uploader': 'cole-dlp-test-acc',
2589 'params': {'skip_download': True, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2590 'expected_warnings': [r'Preferring "fr" translated fields'],
2592 'note': '6 channel audio',
2593 'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2594 'only_matching': True,
2596 'note': 'Multiple HLS formats with same itag',
2597 'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2599 'id': 'kX3nB4PpJko',
2601 'categories': ['Entertainment'],
2602 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2603 'live_status': 'not_live',
2605 'channel_follower_count': int,
2606 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2607 'title': 'Last To Take Hand Off Jet, Keeps It!',
2608 'channel': 'MrBeast',
2609 'playable_in_embed': True,
2611 'upload_date': '20221112',
2612 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2614 'availability': 'public',
2615 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2618 'uploader': 'MrBeast',
2619 'uploader_url': 'https://www.youtube.com/@MrBeast',
2620 'uploader_id': '@MrBeast',
2621 'comment_count': int,
2622 'channel_is_verified': True,
2623 'heatmap': 'count:100',
2625 'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2627 'note': 'Audio formats with Dynamic Range Compression',
2628 'url': 'https://www.youtube.com/watch?v=Tq92D6wQ1mg',
2630 'id': 'Tq92D6wQ1mg',
2632 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
2633 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
2634 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
2635 'channel_follower_count': int,
2636 'description': 'md5:17eccca93a786d51bc67646756894066',
2637 'upload_date': '20191228',
2638 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
2639 'playable_in_embed': True,
2641 'categories': ['Entertainment'],
2642 'thumbnail': 'https://i.ytimg.com/vi/Tq92D6wQ1mg/sddefault.jpg',
2644 'channel': 'Projekt Melody',
2646 'availability': 'needs_auth',
2647 'comment_count': int,
2648 'live_status': 'not_live',
2650 'uploader': 'Projekt Melody',
2651 'uploader_id': '@ProjektMelody',
2652 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
2654 'params': {'extractor_args': {'youtube': {'player_client': ['tv_embedded']}}, 'format': '251-drc'},
2657 'url': 'https://www.youtube.com/live/qVv6vCqciTM',
2659 'id': 'qVv6vCqciTM',
2662 'comment_count': int,
2663 'chapters': 'count:13',
2664 'upload_date': '20221223',
2665 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
2666 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
2668 'release_date': '20221223',
2669 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
2670 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
2672 'playable_in_embed': True,
2674 'availability': 'public',
2675 'channel_follower_count': int,
2676 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
2677 'categories': ['Entertainment'],
2678 'live_status': 'was_live',
2679 'release_timestamp': 1671793345,
2680 'channel': 'さなちゃんねる',
2681 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
2682 'uploader': 'さなちゃんねる',
2683 'uploader_url': 'https://www.youtube.com/@sana_natori',
2684 'uploader_id': '@sana_natori',
2685 'channel_is_verified': True,
2686 'heatmap': 'count:100',
2690 # Fallbacks when webpage and web client is unavailable
2691 'url': 'https://www.youtube.com/watch?v=wSSmNUl9Snw',
2693 'id': 'wSSmNUl9Snw',
2695 # 'categories': ['Science & Technology'],
2697 'chapters': 'count:2',
2698 'channel': 'Scott Manley',
2701 # 'availability': 'public',
2702 'channel_follower_count': int,
2703 'live_status': 'not_live',
2704 'upload_date': '20170831',
2707 'uploader_url': 'https://www.youtube.com/@scottmanley',
2708 'description': 'md5:f4bed7b200404b72a394c2f97b782c02',
2709 'uploader': 'Scott Manley',
2710 'uploader_id': '@scottmanley',
2711 'title': 'The Computer Hack That Saved Apollo 14',
2712 'channel_id': 'UCxzC4EngIsMrPmbm6Nxvb-A',
2713 'thumbnail': r're:^https?://.*\.webp',
2714 'channel_url': 'https://www.youtube.com/channel/UCxzC4EngIsMrPmbm6Nxvb-A',
2715 'playable_in_embed': True,
2716 'comment_count': int,
2717 'channel_is_verified': True,
2718 'heatmap': 'count:100',
2721 'extractor_args': {'youtube': {'player_client': ['android'], 'player_skip': ['webpage']}},
2727 # YouTube <object> embed
2729 'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2730 'md5': '873c81d308b979f0e23ee7e620b312a3',
2732 'id': 'msN87y-iEx0',
2734 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2735 'upload_date': '20080526',
2736 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2738 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2739 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2740 'playable_in_embed': True,
2741 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2743 'comment_count': int,
2744 'channel': 'Christopher Sykes',
2745 'live_status': 'not_live',
2746 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2747 'availability': 'public',
2750 'categories': ['Science & Technology'],
2751 'channel_follower_count': int,
2752 'uploader': 'Christopher Sykes',
2753 'uploader_url': 'https://www.youtube.com/@ChristopherSykesDocumentaries',
2754 'uploader_id': '@ChristopherSykesDocumentaries',
2755 'heatmap': 'count:100',
2758 'skip_download': True,
2764 def suitable(cls, url):
2765 from ..utils import parse_qs
2768 if qs.get('list', [None])[0]:
2770 return super().suitable(url)
2772 def __init__(self, *args, **kwargs):
2773 super().__init__(*args, **kwargs)
2774 self._code_cache = {}
2775 self._player_cache = {}
2777 def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2778 lock = threading.Lock()
2779 start_time = time.time()
2780 formats = [f for f in formats if f.get('is_from_start')]
2782 def refetch_manifest(format_id, delay):
2783 nonlocal formats, start_time, is_live
2784 if time.time() <= start_time + delay:
2787 _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2788 video_details = traverse_obj(prs, (..., 'videoDetails'), expected_type=dict)
2789 microformats = traverse_obj(
2790 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2792 _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2793 is_live = live_status == 'is_live'
2794 start_time = time.time()
2796 def mpd_feed(format_id, delay):
2798 @returns (manifest_url, manifest_stream_number, is_live) or None
2800 for retry in self.RetryManager(fatal=False):
2802 refetch_manifest(format_id, delay)
2804 f = next((f for f in formats if f['format_id'] == format_id), None)
2807 retry.error = f'{video_id}: Video is no longer live'
2809 retry.error = f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}'
2811 return f['manifest_url'], f['manifest_stream_number'], is_live
2815 f['is_live'] = is_live
2816 gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2817 live_start_time, mpd_feed, not is_live and f.copy())
2819 f['fragments'] = gen
2820 f['protocol'] = 'http_dash_segments_generator'
2822 f['fragments'] = LazyList(gen({}))
2823 del f['is_from_start']
2825 def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2826 FETCH_SPAN, MAX_DURATION = 5, 432000
2828 mpd_url, stream_number, is_live = None, None, True
2831 download_start_time = ctx.get('start') or time.time()
2833 lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2834 if lack_early_segments:
2835 self.report_warning(bug_reports_message(
2836 'Starting download from the last 120 hours of the live stream since '
2837 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2838 lack_early_segments = True
2840 known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2841 fragments, fragment_base_url = None, None
2843 def _extract_sequence_from_mpd(refresh_sequence, immediate):
2844 nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2845 # Obtain from MPD's maximum seq value
2846 old_mpd_url = mpd_url
2847 last_error = ctx.pop('last_error', None)
2848 expire_fast = immediate or last_error and isinstance(last_error, HTTPError) and last_error.status == 403
2849 mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2850 or (mpd_url, stream_number, False))
2851 if not refresh_sequence:
2852 if expire_fast and not is_live:
2853 return False, last_seq
2854 elif old_mpd_url == mpd_url:
2855 return True, last_seq
2856 if manifestless_orig_fmt:
2857 fmt_info = manifestless_orig_fmt
2860 fmts, _ = self._extract_mpd_formats_and_subtitles(
2861 mpd_url, None, note=False, errnote=False, fatal=False)
2862 except ExtractorError:
2865 no_fragment_score += 2
2866 return False, last_seq
2867 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2868 fragments = fmt_info['fragments']
2869 fragment_base_url = fmt_info['fragment_base_url']
2870 assert fragment_base_url
2872 _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2873 return True, _last_seq
2875 self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2877 fetch_time = time.time()
2878 if no_fragment_score > 30:
2880 if last_segment_url:
2881 # Obtain from "X-Head-Seqnum" header value from each segment
2883 urlh = self._request_webpage(
2884 last_segment_url, None, note=False, errnote=False, fatal=False)
2885 except ExtractorError:
2887 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2888 if last_seq is None:
2889 no_fragment_score += 2
2890 last_segment_url = None
2893 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2894 no_fragment_score += 2
2895 if not should_continue:
2898 if known_idx > last_seq:
2899 last_segment_url = None
2904 if begin_index < 0 and known_idx < 0:
2905 # skip from the start when it's negative value
2906 known_idx = last_seq + begin_index
2907 if lack_early_segments:
2908 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2910 for idx in range(known_idx, last_seq):
2911 # do not update sequence here or you'll get skipped some part of it
2912 should_continue, _ = _extract_sequence_from_mpd(False, False)
2913 if not should_continue:
2915 raise ExtractorError('breaking out of outer loop')
2916 last_segment_url = urljoin(fragment_base_url, 'sq/%d' % idx)
2918 'url': last_segment_url,
2919 'fragment_count': last_seq,
2921 if known_idx == last_seq:
2922 no_fragment_score += 5
2924 no_fragment_score = 0
2925 known_idx = last_seq
2926 except ExtractorError:
2929 if manifestless_orig_fmt:
2930 # Stop at the first iteration if running for post-live manifestless;
2931 # fragment count no longer increase since it starts
2934 time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2936 def _extract_player_url(self, *ytcfgs, webpage=None):
2937 player_url = traverse_obj(
2938 ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2939 get_all=False, expected_type=str)
2942 return urljoin('https://www.youtube.com', player_url)
2944 def _download_player_url(self, video_id, fatal=False):
2945 res = self._download_webpage(
2946 'https://www.youtube.com/iframe_api',
2947 note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2949 player_version = self._search_regex(
2950 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2952 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2954 def _signature_cache_id(self, example_sig):
2955 """ Return a string representation of a signature """
2956 return '.'.join(str(len(part)) for part in example_sig.split('.'))
2959 def _extract_player_info(cls, player_url):
2960 for player_re in cls._PLAYER_INFO_RE:
2961 id_m = re.search(player_re, player_url)
2965 raise ExtractorError('Cannot identify player %r' % player_url)
2966 return id_m.group('id')
2968 def _load_player(self, video_id, player_url, fatal=True):
2969 player_id = self._extract_player_info(player_url)
2970 if player_id not in self._code_cache:
2971 code = self._download_webpage(
2972 player_url, video_id, fatal=fatal,
2973 note='Downloading player ' + player_id,
2974 errnote='Download of %s failed' % player_url)
2976 self._code_cache[player_id] = code
2977 return self._code_cache.get(player_id)
2979 def _extract_signature_function(self, video_id, player_url, example_sig):
2980 player_id = self._extract_player_info(player_url)
2982 # Read from filesystem cache
2983 func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2984 assert os.path.basename(func_id) == func_id
2986 self.write_debug(f'Extracting signature function {func_id}')
2987 cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
2990 code = self._load_player(video_id, player_url)
2992 res = self._parse_sig_js(code)
2993 test_string = ''.join(map(chr, range(len(example_sig))))
2994 cache_spec = [ord(c) for c in res(test_string)]
2995 self.cache.store('youtube-sigfuncs', func_id, cache_spec)
2997 return lambda s: ''.join(s[i] for i in cache_spec)
2999 def _print_sig_code(self, func, example_sig):
3000 if not self.get_param('youtube_print_sig_code'):
3003 def gen_sig_code(idxs):
3004 def _genslice(start, end, step):
3005 starts = '' if start == 0 else str(start)
3006 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
3007 steps = '' if step == 1 else (':%d' % step)
3008 return f's[{starts}{ends}{steps}]'
3011 # Quelch pyflakes warnings - start will be set when step is set
3012 start = '(Never used)'
3013 for i, prev in zip(idxs[1:], idxs[:-1]):
3014 if step is not None:
3015 if i - prev == step:
3017 yield _genslice(start, prev, step)
3020 if i - prev in [-1, 1]:
3025 yield 's[%d]' % prev
3029 yield _genslice(start, i, step)
3031 test_string = ''.join(map(chr, range(len(example_sig))))
3032 cache_res = func(test_string)
3033 cache_spec = [ord(c) for c in cache_res]
3034 expr_code = ' + '.join(gen_sig_code(cache_spec))
3035 signature_id_tuple = '(%s)' % (
3036 ', '.join(str(len(p)) for p in example_sig.split('.')))
3037 code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
3038 ' return %s\n') % (signature_id_tuple, expr_code)
3039 self.to_screen('Extracted signature function:\n' + code)
3041 def _parse_sig_js(self, jscode):
3042 funcname = self._search_regex(
3043 (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3044 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3045 r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
3046 r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
3047 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+\))?',
3048 r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
3050 r'("|\')signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3051 r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
3052 r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3053 r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3054 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3055 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
3056 jscode, 'Initial JS player signature function name', group='sig')
3058 jsi = JSInterpreter(jscode)
3059 initial_function = jsi.extract_function(funcname)
3060 return lambda s: initial_function([s])
3062 def _cached(self, func, *cache_id):
3063 def inner(*args, **kwargs):
3064 if cache_id not in self._player_cache:
3066 self._player_cache[cache_id] = func(*args, **kwargs)
3067 except ExtractorError as e:
3068 self._player_cache[cache_id] = e
3069 except Exception as e:
3070 self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
3072 ret = self._player_cache[cache_id]
3073 if isinstance(ret, Exception):
3078 def _decrypt_signature(self, s, video_id, player_url):
3079 """Turn the encrypted s field into a working signature"""
3080 extract_sig = self._cached(
3081 self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
3082 func = extract_sig(video_id, player_url, s)
3083 self._print_sig_code(func, s)
3086 def _decrypt_nsig(self, s, video_id, player_url):
3087 """Turn the encrypted n field into a working signature"""
3088 if player_url is None:
3089 raise ExtractorError('Cannot decrypt nsig without player_url')
3090 player_url = urljoin('https://www.youtube.com', player_url)
3093 jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
3094 except ExtractorError as e:
3095 raise ExtractorError('Unable to extract nsig function code', cause=e)
3096 if self.get_param('youtube_print_sig_code'):
3097 self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
3100 extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
3101 ret = extract_nsig(jsi, func_code)(s)
3102 except JSInterpreter.Exception as e:
3104 jsi = PhantomJSwrapper(self, timeout=5000)
3105 except ExtractorError:
3107 self.report_warning(
3108 f'Native nsig extraction failed: Trying with PhantomJS\n'
3109 f' n = {s} ; player = {player_url}', video_id)
3110 self.write_debug(e, only_once=True)
3112 args, func_body = func_code
3114 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
3115 video_id=video_id, note='Executing signature code').strip()
3117 self.write_debug(f'Decrypted nsig {s} => {ret}')
3120 def _extract_n_function_name(self, jscode):
3121 funcname, idx = self._search_regex(
3122 r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
3123 jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
3127 return json.loads(js_to_json(self._search_regex(
3128 rf'var {re.escape(funcname)}\s*=\s*(\[.+?\])\s*[,;]', jscode,
3129 f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
3131 def _extract_n_function_code(self, video_id, player_url):
3132 player_id = self._extract_player_info(player_url)
3133 func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
3134 jscode = func_code or self._load_player(video_id, player_url)
3135 jsi = JSInterpreter(jscode)
3138 return jsi, player_id, func_code
3140 func_name = self._extract_n_function_name(jscode)
3143 func_code = self._search_regex(
3144 r'''(?xs
)%s\s
*=\s
*function\s
*\
((?P
<var
>[\w$
]+)\
)\s
*
3145 # NB: The end of the regex is intentionally kept strict
3146 {(?P<code>.+?}\s
*return\
[\w$
]+.join\
(""\
))};''' % func_name,
3147 jscode, 'nsig function', group=('var', 'code'), default=None)
3149 func_code = ([func_code[0]], func_code[1])
3151 self.write_debug('Extracting nsig function with jsinterp')
3152 func_code = jsi.extract_function_code(func_name)
3154 self.cache.store('youtube-nsig', player_id, func_code)
3155 return jsi, player_id, func_code
3157 def _extract_n_function_from_code(self, jsi, func_code):
3158 func = jsi.extract_function_from_code(*func_code)
3160 def extract_nsig(s):
3163 except JSInterpreter.Exception:
3165 except Exception as e:
3166 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
3168 if ret.startswith('enhanced_except_'):
3169 raise JSInterpreter.Exception('Signature function returned an exception')
3174 def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3176 Extract signatureTimestamp (sts)
3177 Required to tell API what sig/player version is in use.
3180 if isinstance(ytcfg, dict):
3181 sts = int_or_none(ytcfg.get('STS'))
3184 # Attempt to extract from player
3185 if player_url is None:
3186 error_msg = 'Cannot extract signature timestamp without player_url.'
3188 raise ExtractorError(error_msg)
3189 self.report_warning(error_msg)
3191 code = self._load_player(video_id, player_url, fatal=fatal)
3193 sts = int_or_none(self._search_regex(
3194 r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3195 'JS player signature timestamp', group='sts', fatal=fatal))
3198 def _mark_watched(self, video_id, player_responses):
3199 for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3200 label = 'fully ' if is_full else ''
3201 url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3202 expected_type=url_or_none)
3204 self.report_warning(f'Unable to mark {label}watched')
3206 parsed_url = urllib.parse.urlparse(url)
3207 qs = urllib.parse.parse_qs(parsed_url.query)
3209 # cpn generation algorithm is reverse engineered from base.js.
3210 # In fact it works even with dummy cpn.
3211 CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3212 cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16))
3214 # # more consistent results setting it to right before the end
3215 video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3220 'cmt': video_length,
3221 'el': 'detailpage', # otherwise defaults to "shorts"
3225 # these seem to mark watchtime "history" in the real world
3226 # they're required, so send in a single value
3232 url = urllib.parse.urlunparse(
3233 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3235 self._download_webpage(
3236 url, video_id, f'Marking {label}watched',
3237 'Unable to mark watched', fatal=False)
3240 def _extract_from_webpage(cls, url, webpage):
3241 # Invidious Instances
3242 # https://github.com/yt-dlp/yt-dlp/issues/195
3243 # https://github.com/iv-org/invidious/pull/1730
3245 r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3248 yield cls.url_result(mobj.group('url'), cls)
3249 raise cls.StopExtraction()
3251 yield from super()._extract_from_webpage(url, webpage)
3253 # lazyYT YouTube embed
3254 for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3255 yield cls.url_result(unescapeHTML(id_), cls, id_)
3257 # Wordpress "YouTube Video Importer" plugin
3258 for m in re.findall(r'''(?x
)<div
[^
>]+
3259 class=(?P
<q1
>[\'"])[^\'"]*\byvii
_single
_video
_player
\b[^
\'"]*(?P=q1)[^>]+
3260 data-video_id=(?P<q2>[\'"])([^
\'"]+)(?P=q2)''', webpage):
3261 yield cls.url_result(m[-1], cls, m[-1])
3264 def extract_id(cls, url):
3265 video_id = cls.get_temp_id(url)
3267 raise ExtractorError(f'Invalid URL: {url}')
3270 def _extract_chapters_from_json(self, data, duration):
3271 chapter_list = traverse_obj(
3273 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3274 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters'
3275 ), expected_type=list)
3277 return self._extract_chapters_helper(
3279 start_function=lambda chapter: float_or_none(
3280 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3281 title_function=lambda chapter: traverse_obj(
3282 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3285 def _extract_chapters_from_engagement_panel(self, data, duration):
3286 content_list = traverse_obj(
3288 ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3290 chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3291 chapter_title = lambda chapter: self._get_text(chapter, 'title')
3293 return next(filter(None, (
3294 self._extract_chapters_helper(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3295 chapter_time, chapter_title, duration)
3296 for contents in content_list)), [])
3298 def _extract_heatmap(self, data):
3299 return traverse_obj(data, (
3300 'frameworkUpdates', 'entityBatchUpdate', 'mutations',
3301 lambda _, v: v['payload']['macroMarkersListEntity']['markersList']['markerType'] == 'MARKER_TYPE_HEATMAP',
3302 'payload', 'macroMarkersListEntity', 'markersList', 'markers', ..., {
3303 'start_time': ('startMillis', {functools.partial(float_or_none, scale=1000)}),
3304 'end_time': {lambda x: (int(x['startMillis']) + int(x['durationMillis'])) / 1000},
3305 'value': ('intensityScoreNormalized', {float_or_none}),
3308 def _extract_comment(self, comment_renderer, parent=None):
3309 comment_id = comment_renderer.get('commentId')
3315 'text': self._get_text(comment_renderer, 'contentText'),
3316 'like_count': self._get_count(comment_renderer, 'voteCount'),
3317 'author_id': traverse_obj(comment_renderer, ('authorEndpoint', 'browseEndpoint', 'browseId', {self.ucid_or_none})),
3318 'author': self._get_text(comment_renderer, 'authorText'),
3319 'author_thumbnail': traverse_obj(comment_renderer, ('authorThumbnail', 'thumbnails', -1, 'url', {url_or_none})),
3320 'parent': parent or 'root',
3323 # Timestamp is an estimate calculated from the current time and time_text
3324 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3325 timestamp = self._parse_time_text(time_text)
3328 # FIXME: non-standard, but we need a way of showing that it is an estimate.
3329 '_time_text': time_text,
3330 'timestamp': timestamp,
3333 info['author_url'] = urljoin(
3334 'https://www.youtube.com', traverse_obj(comment_renderer, ('authorEndpoint', (
3335 ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'))),
3336 expected_type=str, get_all=False))
3338 author_is_uploader = traverse_obj(comment_renderer, 'authorIsChannelOwner')
3339 if author_is_uploader is not None:
3340 info['author_is_uploader'] = author_is_uploader
3342 comment_abr = traverse_obj(
3343 comment_renderer, ('actionButtons', 'commentActionButtonsRenderer'), expected_type=dict)
3344 if comment_abr is not None:
3345 info['is_favorited'] = 'creatorHeart' in comment_abr
3347 badges = self._extract_badges([traverse_obj(comment_renderer, 'authorCommentBadge')])
3348 if self._has_badge(badges, BadgeType.VERIFIED):
3349 info['author_is_verified'] = True
3351 is_pinned = traverse_obj(comment_renderer, 'pinnedCommentBadge')
3353 info['is_pinned'] = True
3357 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3359 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3361 def extract_header(contents):
3362 _continuation = None
3363 for content in contents:
3364 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3365 expected_comment_count = self._get_count(
3366 comments_header_renderer, 'countText', 'commentsCount')
3368 if expected_comment_count is not None:
3369 tracker['est_total'] = expected_comment_count
3370 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3371 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3373 sort_menu_item = try_get(
3374 comments_header_renderer,
3375 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3376 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3378 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3379 if not _continuation:
3382 sort_text = str_or_none(sort_menu_item.get('title'))
3384 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3385 self.to_screen('Sorting comments by %s' % sort_text.lower())
3387 return _continuation
3389 def extract_thread(contents):
3391 tracker['current_page_thread'] = 0
3392 for content in contents:
3393 if not parent and tracker['total_parent_comments'] >= max_parents:
3395 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3396 comment_renderer = get_first(
3397 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3398 expected_type=dict, default={})
3400 comment = self._extract_comment(comment_renderer, parent)
3403 comment_id = comment['id']
3404 if comment.get('is_pinned'):
3405 tracker['pinned_comment_ids'].add(comment_id)
3406 # Sometimes YouTube may break and give us infinite looping comments.
3407 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3408 if comment_id in tracker['seen_comment_ids']:
3409 if comment_id in tracker['pinned_comment_ids'] and not comment.get('is_pinned'):
3410 # Pinned comments may appear a second time in newest first sort
3411 # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3413 self.report_warning(
3414 'Detected YouTube comments looping. Stopping comment extraction '
3415 f'{"for this thread" if parent else ""} as we probably cannot get any more.')
3418 tracker['seen_comment_ids'].add(comment['id'])
3420 tracker['running_total'] += 1
3421 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3424 # Attempt to get the replies
3425 comment_replies_renderer = try_get(
3426 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3428 if comment_replies_renderer:
3429 tracker['current_page_thread'] += 1
3430 comment_entries_iter = self._comment_entries(
3431 comment_replies_renderer, ytcfg, video_id,
3432 parent=comment.get('id'), tracker=tracker)
3433 yield from itertools.islice(comment_entries_iter, min(
3434 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3436 # Keeps track of counts across recursive calls
3441 current_page_thread=0,
3442 total_parent_comments=0,
3443 total_reply_comments=0,
3444 seen_comment_ids=set(),
3445 pinned_comment_ids=set()
3449 # YouTube comments have a max depth of 2
3450 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3452 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3453 'Set max replies in the max-comments extractor argument instead')
3454 if max_depth == 1 and parent:
3457 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
3458 lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
3460 continuation = self._extract_continuation(root_continuation_data)
3463 is_forced_continuation = False
3464 is_first_continuation = parent is None
3465 if is_first_continuation and not continuation:
3466 # Sometimes you can get comments by generating the continuation yourself,
3467 # even if YouTube initially reports them being disabled - e.g. stories comments.
3468 # Note: if the comment section is actually disabled, YouTube may return a response with
3469 # required check_get_keys missing. So we will disable that check initially in this case.
3470 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3471 is_forced_continuation = True
3473 continuation_items_path = (
3474 'onResponseReceivedEndpoints', ..., ('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems')
3475 for page_num in itertools.count(0):
3476 if not continuation:
3478 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3479 comment_prog_str = f"({tracker['running_total']}
/~{tracker['est_total']}
)"
3481 if is_first_continuation:
3482 note_prefix = 'Downloading comment section API JSON'
3484 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3485 tracker['current_page_thread'], comment_prog_str)
3487 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
3488 ' ' if parent else '', ' replies' if parent else '',
3489 page_num, comment_prog_str)
3491 # Do a deep check for incomplete data as sometimes YouTube may return no comments for a continuation
3492 # Ignore check if YouTube says the comment count is 0.
3493 check_get_keys = None
3494 if not is_forced_continuation and not (tracker['est_total'] == 0 and tracker['running_total'] == 0):
3495 check_get_keys = [[*continuation_items_path, ..., (
3496 'commentsHeaderRenderer' if is_first_continuation else ('commentThreadRenderer', 'commentRenderer'))]]
3498 response = self._extract_response(
3499 item_id=None, query=continuation,
3500 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3501 check_get_keys=check_get_keys)
3502 except ExtractorError as e:
3503 # Ignore incomplete data error for replies if retries didn't work.
3504 # This is to allow any other parent comments and comment threads to be downloaded.
3505 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3506 if 'incomplete data' in str(e).lower() and parent:
3507 if self.get_param('ignoreerrors') in (True, 'only_download'):
3508 self.report_warning(
3509 'Received incomplete data for a comment reply thread and retrying did not help. '
3510 'Ignoring to let other comments be downloaded. Pass --no-ignore-errors to not ignore.')
3513 raise ExtractorError(
3514 'Incomplete data received for comment reply thread. '
3515 'Pass --ignore-errors to ignore and allow rest of comments to download.',
3518 is_forced_continuation = False
3520 for continuation_items in traverse_obj(response, continuation_items_path, expected_type=list, default=[]):
3521 if is_first_continuation:
3522 continuation = extract_header(continuation_items)
3523 is_first_continuation = False
3528 for entry in extract_thread(continuation_items):
3532 continuation = self._extract_continuation({'contents': continuation_items})
3536 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3537 if message and not parent and tracker['running_total'] == 0:
3538 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3539 raise self.CommentsDisabled
3542 def _generate_comment_continuation(video_id):
3544 Generates initial comment section continuation token from given video id
3546 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3547 return base64.b64encode(token.encode()).decode()
3549 def _get_comments(self, ytcfg, video_id, contents, webpage):
3550 """Entry for comment extraction"""
3551 def _real_comment_extract(contents):
3553 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3554 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3555 yield from self._comment_entries(renderer, ytcfg, video_id)
3557 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3558 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3561 def _get_checkok_params():
3562 return {'contentCheckOk': True, 'racyCheckOk': True}
3565 def _generate_player_context(cls, sts=None):
3567 'html5Preference': 'HTML5_PREF_WANTS',
3570 context['signatureTimestamp'] = sts
3572 'playbackContext': {
3573 'contentPlaybackContext': context
3575 **cls._get_checkok_params()
3579 def _is_agegated(player_response):
3580 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3583 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3584 AGE_GATE_REASONS = (
3585 'confirm your age', 'age-restricted', 'inappropriate', # reason
3586 'age_verification_required', 'age_check_required', # status
3588 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3591 def _is_unplayable(player_response):
3592 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3594 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3596 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3597 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3598 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3599 headers = self.generate_api_headers(
3600 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3603 'videoId': video_id,
3605 if _split_innertube_client(client)[0] == 'android':
3606 yt_query['params'] = 'CgIQBg=='
3608 pp_arg = self._configuration_arg('player_params', [None], casesense=True)[0]
3610 yt_query['params'] = pp_arg
3612 yt_query.update(self._generate_player_context(sts))
3613 return self._extract_response(
3614 item_id=video_id, ep='player', query=yt_query,
3615 ytcfg=player_ytcfg, headers=headers, fatal=True,
3616 default_client=client,
3617 note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
3620 def _get_requested_clients(self, url, smuggled_data):
3621 requested_clients = []
3622 default = ['ios', 'android', 'web']
3623 allowed_clients = sorted(
3624 (client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'),
3625 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3626 for client in self._configuration_arg('player_client'):
3627 if client in allowed_clients:
3628 requested_clients.append(client)
3629 elif client == 'default':
3630 requested_clients.extend(default)
3631 elif client == 'all':
3632 requested_clients.extend(allowed_clients)
3634 self.report_warning(f'Skipping unsupported client {client}')
3635 if not requested_clients:
3636 requested_clients = default
3638 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3639 requested_clients.extend(
3640 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3642 return orderedSet(requested_clients)
3644 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3647 initial_pr = self._search_json(
3648 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3650 all_clients = set(clients)
3651 clients = clients[::-1]
3654 def append_client(*client_names):
3655 """ Append the first client name that exists but not already used """
3656 for client_name in client_names:
3657 actual_client = _split_innertube_client(client_name)[0]
3658 if actual_client in INNERTUBE_CLIENTS:
3659 if actual_client not in all_clients:
3660 clients.append(client_name)
3661 all_clients.add(actual_client)
3664 # Android player_response does not have microFormats which are needed for
3665 # extraction of some data. So we return the initial_pr with formats
3666 # stripped out even if not requested by the user
3667 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3669 pr = dict(initial_pr)
3670 pr['streamingData'] = None
3674 tried_iframe_fallback = False
3677 client, base_client, variant = _split_innertube_client(clients.pop())
3678 player_ytcfg = master_ytcfg if client == 'web' else {}
3679 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3680 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3682 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3683 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3684 if 'js' in self._configuration_arg('player_skip'):
3685 require_js_player = False
3688 if not player_url and not tried_iframe_fallback and require_js_player:
3689 player_url = self._download_player_url(video_id)
3690 tried_iframe_fallback = True
3693 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3694 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3695 except ExtractorError as e:
3697 self.report_warning(last_error)
3702 # YouTube may return a different video player response than expected.
3703 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3704 pr_video_id = traverse_obj(pr, ('videoDetails', 'videoId'))
3705 if pr_video_id and pr_video_id != video_id:
3706 self.report_warning(
3707 f'Skipping player response from {client} client (got player response for video "{pr_video_id}
" instead of "{video_id}
")' + bug_reports_message())
3709 # Save client name for introspection later
3710 name = short_client_name(client)
3711 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3712 sd[STREAMING_DATA_CLIENT_NAME] = name
3713 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3714 f[STREAMING_DATA_CLIENT_NAME] = name
3717 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3718 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3719 append_client(f'{base_client}_creator')
3720 elif self._is_agegated(pr):
3721 if variant == 'tv_embedded':
3722 append_client(f'{base_client}_embedded')
3724 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3729 self.report_warning(last_error)
3730 return prs, player_url
3732 def _needs_live_processing(self, live_status, duration):
3733 if (live_status == 'is_live' and self.get_param('live_from_start')
3734 or live_status == 'post_live' and (duration or 0) > 2 * 3600):
3737 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3738 CHUNK_SIZE = 10 << 20
3739 itags, stream_ids = collections.defaultdict(set), []
3740 itag_qualities, res_qualities = {}, {0: None}
3742 # Normally tiny is the smallest video-only formats. But
3743 # audio-only formats with unknown quality may get tagged as tiny
3745 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3746 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
3748 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3749 format_types = self._configuration_arg('formats')
3750 all_formats = 'duplicate' in format_types
3751 if self._configuration_arg('include_duplicate_formats'):
3753 self._downloader.deprecated_feature('[youtube] include_duplicate_formats extractor argument is deprecated. '
3754 'Use formats=duplicate extractor argument instead')
3756 def build_fragments(f):
3758 'url': update_url_query(f['url'], {
3759 'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}'
3761 } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3763 for fmt in streaming_formats:
3764 if fmt.get('targetDurationSec'):
3767 itag = str_or_none(fmt.get('itag'))
3768 audio_track = fmt.get('audioTrack') or {}
3769 stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3771 if stream_id in stream_ids:
3774 quality = fmt.get('quality')
3775 height = int_or_none(fmt.get('height'))
3776 if quality == 'tiny' or not quality:
3777 quality = fmt.get('audioQuality', '').lower() or quality
3778 # The 3gp format (17) in android client has a quality of "small
",
3779 # but is actually worse than other formats
3784 itag_qualities[itag] = quality
3786 res_qualities[height] = quality
3787 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3788 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3789 # number of fragment that would subsequently requested with (`&sq=N`)
3790 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3793 fmt_url = fmt.get('url')
3795 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3796 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3797 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3798 if not all((sc, fmt_url, player_url, encrypted_sig)):
3801 fmt_url += '&%s=%s' % (
3802 traverse_obj(sc, ('sp', -1)) or 'signature',
3803 self._decrypt_signature(encrypted_sig, video_id, player_url)
3805 except ExtractorError as e:
3806 self.report_warning('Signature extraction failed: Some formats may be missing',
3807 video_id=video_id, only_once=True)
3808 self.write_debug(e, only_once=True)
3811 query = parse_qs(fmt_url)
3815 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3816 fmt_url = update_url_query(fmt_url, {
3817 'n': decrypt_nsig(query['n'][0], video_id, player_url)
3819 except ExtractorError as e:
3821 if isinstance(e, JSInterpreter.Exception):
3822 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3823 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3825 self.report_warning(
3826 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3827 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3828 self.write_debug(e, only_once=True)
3830 self.report_warning(
3831 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3832 video_id=video_id, only_once=True)
3835 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3836 language_preference = (
3837 10 if audio_track.get('audioIsDefault') and 10
3838 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3840 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3841 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3842 # Make sure to avoid false positives with small duration differences.
3843 # E.g. __2ABJjxzNo, ySuUZEjARPY
3844 is_damaged = try_get(fmt, lambda x: float(x['approxDurationMs']) / duration < 500)
3846 self.report_warning(
3847 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3849 client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3850 name = fmt.get('qualityLabel') or quality.replace('audio_quality_', '') or ''
3851 fps = int_or_none(fmt.get('fps')) or 0
3853 'asr': int_or_none(fmt.get('audioSampleRate')),
3854 'filesize': int_or_none(fmt.get('contentLength')),
3855 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3856 'format_note': join_nonempty(
3857 join_nonempty(audio_track.get('displayName'),
3858 language_preference > 0 and ' (default)', delim=''),
3859 name, fmt.get('isDrc') and 'DRC',
3860 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3861 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3862 throttled and 'THROTTLED', is_damaged and 'DAMAGED',
3863 (self.get_param('verbose') or all_formats) and client_name,
3865 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3866 'source_preference': ((-10 if throttled else -5 if itag == '22' else -1)
3867 + (100 if 'Premium' in name else 0)),
3868 'fps': fps if fps > 1 else None, # For some formats, fps is wrongly returned as 1
3869 'audio_channels': fmt.get('audioChannels'),
3871 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3872 'has_drm': bool(fmt.get('drmFamilies')),
3875 'width': int_or_none(fmt.get('width')),
3876 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3877 'desc' if language_preference < -1 else '') or None,
3878 'language_preference': language_preference,
3879 # Strictly de-prioritize damaged and 3gp formats
3880 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3882 mime_mobj = re.match(
3883 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3885 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3886 dct.update(parse_codecs(mime_mobj.group(2)))
3888 itags[itag].add(('https
', dct.get('language
')))
3889 stream_ids.append(stream_id)
3890 single_stream = 'none
' in (dct.get('acodec
'), dct.get('vcodec
'))
3891 if single_stream and dct.get('ext
'):
3892 dct['container
'] = dct['ext
'] + '_dash
'
3894 if (all_formats or 'dashy
' in format_types) and dct['filesize
']:
3897 'format_id
': f'{dct["format_id"]}
-dashy
' if all_formats else dct['format_id
'],
3898 'protocol
': 'http_dash_segments
',
3899 'fragments
': build_fragments(dct),
3901 if all_formats or 'dashy
' not in format_types:
3902 dct['downloader_options
'] = {'http_chunk_size': CHUNK_SIZE}
3905 needs_live_processing = self._needs_live_processing(live_status, duration)
3906 skip_bad_formats = 'incomplete
' not in format_types
3907 if self._configuration_arg('include_incomplete_formats
'):
3908 skip_bad_formats = False
3909 self._downloader.deprecated_feature('[youtube
] include_incomplete_formats extractor argument
is deprecated
. '
3910 'Use formats
=incomplete extractor argument instead
')
3912 skip_manifests = set(self._configuration_arg('skip
'))
3913 if (not self.get_param('youtube_include_hls_manifest
', True)
3914 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3915 or needs_live_processing and skip_bad_formats):
3916 skip_manifests.add('hls
')
3918 if not self.get_param('youtube_include_dash_manifest
', True):
3919 skip_manifests.add('dash
')
3920 if self._configuration_arg('include_live_dash
'):
3921 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3922 'Use formats
=incomplete extractor argument instead
')
3923 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3924 skip_manifests.add('dash
')
3926 def process_manifest_format(f, proto, client_name, itag):
3927 key = (proto, f.get('language
'))
3928 if not all_formats and key in itags[itag]:
3930 itags[itag].add(key)
3932 if itag and all_formats:
3933 f['format_id
'] = f'{itag}
-{proto}
'
3934 elif any(p != proto for p, _ in itags[itag]):
3935 f['format_id
'] = f'{itag}
-{proto}
'
3937 f['format_id
'] = itag
3939 if f.get('source_preference
') is None:
3940 f['source_preference
'] = -1
3942 if itag in ('616', '235'):
3943 f['format_note
'] = join_nonempty(f.get('format_note
'), 'Premium
', delim=' ')
3944 f['source_preference
'] += 100
3946 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
3947 if f['quality
'] == -1 and f.get('height
'):
3948 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
3949 if self.get_param('verbose
') or all_formats:
3950 f['format_note
'] = join_nonempty(f.get('format_note
'), client_name, delim=', ')
3951 if f.get('fps
') and f['fps
'] <= 1:
3954 if proto == 'hls
' and f.get('has_drm
'):
3955 f['has_drm
'] = 'maybe
'
3956 f['source_preference
'] -= 5
3960 for sd in streaming_data:
3961 client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
3963 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
3964 if hls_manifest_url:
3965 fmts, subs = self._extract_m3u8_formats_and_subtitles(
3966 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
3967 subtitles = self._merge_subtitles(subs, subtitles)
3969 if process_manifest_format(f, 'hls
', client_name, self._search_regex(
3970 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
3973 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
3974 if dash_manifest_url:
3975 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
3976 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
3978 if process_manifest_format(f, 'dash
', client_name, f['format_id
']):
3979 f['filesize
'] = int_or_none(self._search_regex(
3980 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
3981 if needs_live_processing:
3982 f['is_from_start
'] = True
3987 def _extract_storyboard(self, player_responses, duration):
3989 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
3990 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
3994 for i, args in enumerate(spec):
3995 args = args.split('#')
3996 counts
= list(map(int_or_none
, args
[:5]))
3997 if len(args
) != 8 or not all(counts
):
3998 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
4000 width
, height
, frame_count
, cols
, rows
= counts
4003 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
4004 fragment_count
= frame_count
/ (cols
* rows
)
4005 fragment_duration
= duration
/ fragment_count
4007 'format_id': f
'sb{i}',
4008 'format_note': 'storyboard',
4010 'protocol': 'mhtml',
4016 'fps': frame_count
/ duration
,
4020 'url': url
.replace('$M', str(j
)),
4021 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
4022 } for j
in range(math
.ceil(fragment_count
))],
4025 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
4027 if 'webpage' not in self
._configuration
_arg
('player_skip'):
4028 query
= {'bpctr': '9999999999', 'has_verified': '1'}
4029 pp
= self
._configuration
_arg
('player_params', [None], casesense
=True)[0]
4032 webpage
= self
._download
_webpage
(
4033 webpage_url
, video_id
, fatal
=False, query
=query
)
4035 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
4037 player_responses
, player_url
= self
._extract
_player
_responses
(
4038 self
._get
_requested
_clients
(url
, smuggled_data
),
4039 video_id
, webpage
, master_ytcfg
, smuggled_data
)
4041 return webpage
, master_ytcfg
, player_responses
, player_url
4043 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
4044 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
4045 is_live
= get_first(video_details
, 'isLive')
4047 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
4048 live_content
= get_first(video_details
, 'isLiveContent')
4049 is_upcoming
= get_first(video_details
, 'isUpcoming')
4050 post_live
= get_first(video_details
, 'isPostLiveDvr')
4051 live_status
= ('post_live' if post_live
4052 else 'is_live' if is_live
4053 else 'is_upcoming' if is_upcoming
4054 else 'was_live' if live_content
4055 else 'not_live' if False in (is_live
, live_content
)
4057 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'))
4058 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
4059 if all(f
.get('has_drm') for f
in formats
):
4060 # If there are no formats that definitely don't have DRM, all have DRM
4064 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
4066 def _real_extract(self
, url
):
4067 url
, smuggled_data
= unsmuggle_url(url
, {})
4068 video_id
= self
._match
_id
(url
)
4070 base_url
= self
.http_scheme() + '//www.youtube.com/'
4071 webpage_url
= base_url
+ 'watch?v=' + video_id
4073 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
4075 playability_statuses
= traverse_obj(
4076 player_responses
, (..., 'playabilityStatus'), expected_type
=dict)
4078 trailer_video_id
= get_first(
4079 playability_statuses
,
4080 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
4082 if trailer_video_id
:
4083 return self
.url_result(
4084 trailer_video_id
, self
.ie_key(), trailer_video_id
)
4086 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
4087 if webpage
else (lambda x
: None))
4089 video_details
= traverse_obj(player_responses
, (..., 'videoDetails'), expected_type
=dict)
4090 microformats
= traverse_obj(
4091 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
4094 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
4095 video_title
= (self
._preferred
_lang
and translated_title
4096 or get_first(video_details
, 'title') # primary
4098 or search_meta(['og:title', 'twitter:title', 'title']))
4099 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
4100 original_description
= get_first(video_details
, 'shortDescription')
4101 video_description
= (
4102 self
._preferred
_lang
and translated_description
4103 # If original description is blank, it will be an empty string.
4104 # Do not prefer translated description in this case.
4105 or original_description
if original_description
is not None else translated_description
)
4107 multifeed_metadata_list
= get_first(
4109 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
4111 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
4112 if self
.get_param('noplaylist'):
4113 self
.to_screen('Downloading just video %s because of --no-playlist' % video_id
)
4117 for feed
in multifeed_metadata_list
.split(','):
4118 # Unquote should take place before split on comma (,) since textual
4119 # fields may contain comma as well (see
4120 # https://github.com/ytdl-org/youtube-dl/issues/8536)
4121 feed_data
= urllib
.parse
.parse_qs(
4122 urllib
.parse
.unquote_plus(feed
))
4124 def feed_entry(name
):
4126 feed_data
, lambda x
: x
[name
][0], str)
4128 feed_id
= feed_entry('id')
4131 feed_title
= feed_entry('title')
4134 title
+= ' (%s)' % feed_title
4136 '_type': 'url_transparent',
4137 'ie_key': 'Youtube',
4139 '%swatch?v=%s' % (base_url
, feed_data
['id'][0]),
4140 {'force_singlefeed': True}
),
4143 feed_ids
.append(feed_id
)
4145 'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
4146 % (', '.join(feed_ids
), video_id
))
4147 return self
.playlist_result(
4148 entries
, video_id
, video_title
, video_description
)
4150 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
4151 or int_or_none(get_first(microformats
, 'lengthSeconds'))
4152 or parse_duration(search_meta('duration')) or None)
4154 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
4155 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
4156 if live_status
== 'post_live':
4157 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
4160 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
4161 self
.report_drm(video_id
)
4163 playability_statuses
,
4164 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
4165 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
4166 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
4168 if subreason
== 'The uploader has not made this video available in your country.':
4169 countries
= get_first(microformats
, 'availableCountries')
4171 regions_allowed
= search_meta('regionsAllowed')
4172 countries
= regions_allowed
.split(',') if regions_allowed
else None
4173 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
4174 reason
+= f
'. {subreason}'
4176 self
.raise_no_formats(reason
, expected
=True)
4178 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
4179 if not keywords
and webpage
:
4181 unescapeHTML(m
.group('content'))
4182 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
4183 for keyword
in keywords
:
4184 if keyword
.startswith('yt:stretch='):
4185 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
4187 # NB: float is intentional for forcing float division
4188 w
, h
= (float(v
) for v
in mobj
.groups())
4192 if f
.get('vcodec') != 'none':
4193 f
['stretched_ratio'] = ratio
4195 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
4196 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
4199 'url': thumbnail_url
,
4201 original_thumbnails
= thumbnails
.copy()
4203 # The best resolution thumbnails sometimes does not appear in the webpage
4204 # See: https://github.com/yt-dlp/yt-dlp/issues/340
4205 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4207 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4208 # in resolution, these are not the custom thumbnail. So de-prioritize them
4209 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4210 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3'
4212 n_thumbnail_names
= len(thumbnail_names
)
4214 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4215 video_id
=video_id
, name
=name
, ext
=ext
,
4216 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
4217 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
4218 for thumb
in thumbnails
:
4219 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
4220 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
4221 self
._remove
_duplicate
_formats
(thumbnails
)
4222 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
4224 category
= get_first(microformats
, 'category') or search_meta('genre')
4225 channel_id
= self
.ucid_or_none(str_or_none(
4226 get_first(video_details
, 'channelId')
4227 or get_first(microformats
, 'externalChannelId')
4228 or search_meta('channelId')))
4229 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
4231 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
4232 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
4233 if not duration
and live_end_time
and live_start_time
:
4234 duration
= live_end_time
- live_start_time
4236 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
4238 def is_bad_format(fmt
):
4239 if needs_live_processing
and not fmt
.get('is_from_start'):
4241 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
4242 and fmt
.get('protocol') == 'http_dash_segments'):
4245 for fmt
in filter(is_bad_format
, formats
):
4246 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4247 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 2 hours)', delim
=' ')
4249 if needs_live_processing
:
4250 self
._prepare
_live
_from
_start
_formats
(
4251 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4253 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4255 channel_handle
= self
.handle_from_url(owner_profile_url
)
4259 'title': video_title
,
4261 'thumbnails': thumbnails
,
4262 # The best thumbnail that we are sure exists. Prevents unnecessary
4263 # URL checking if user don't care about getting the best possible thumbnail
4264 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4265 'description': video_description
,
4266 'channel_id': channel_id
,
4267 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None),
4268 'duration': duration
,
4269 'view_count': int_or_none(
4270 get_first((video_details
, microformats
), (..., 'viewCount'))
4271 or search_meta('interactionCount')),
4272 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4273 'age_limit': 18 if (
4274 get_first(microformats
, 'isFamilySafe') is False
4275 or search_meta('isFamilyFriendly') == 'false'
4276 or search_meta('og:restrictions:age') == '18+') else 0,
4277 'webpage_url': webpage_url
,
4278 'categories': [category
] if category
else None,
4280 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4281 'live_status': live_status
,
4282 'release_timestamp': live_start_time
,
4283 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4284 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto')
4288 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4290 def get_lang_code(track
):
4291 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4292 or track
.get('languageCode'))
4294 # Converted into dicts to remove duplicates
4296 get_lang_code(sub
): sub
4297 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...))}
4298 translation_languages
= {
4299 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4300 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...))}
4302 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4303 lang_subs
= container
.setdefault(lang_code
, [])
4304 for fmt
in self
._SUBTITLE
_FORMATS
:
4310 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4314 # NB: Constructing the full subtitle dictionary is slow
4315 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4316 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4317 for lang_code
, caption_track
in captions
.items():
4318 base_url
= caption_track
.get('baseUrl')
4319 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4322 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4323 if caption_track
.get('kind') != 'asr':
4327 subtitles
, base_url
, lang_code
, lang_name
, {})
4328 if not caption_track
.get('isTranslatable'):
4330 for trans_code
, trans_name
in translation_languages
.items():
4333 orig_trans_code
= trans_code
4334 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4335 if not get_translated_subs
:
4337 trans_code
+= f
'-{lang_code}'
4338 trans_name
+= format_field(lang_name
, None, ' from %s')
4339 if lang_code
== f
'a-{orig_trans_code}':
4340 # Set audio language based on original subtitles
4342 if f
.get('acodec') != 'none' and not f
.get('language'):
4343 f
['language'] = orig_trans_code
4344 # Add an "-orig" label to the original language so that it can be distinguished.
4345 # The subs are returned without "-orig" as well for compatibility
4347 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4348 # Setting tlang=lang returns damaged subtitles.
4349 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4350 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4352 info
['automatic_captions'] = automatic_captions
4353 info
['subtitles'] = subtitles
4355 parsed_url
= urllib
.parse
.urlparse(url
)
4356 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4357 query
= urllib
.parse
.parse_qs(component
)
4358 for k
, v
in query
.items():
4359 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4361 if d_k
not in info
and k
in s_ks
:
4362 info
[d_k
] = parse_duration(query
[k
][0])
4364 # Youtube Music Auto-generated description
4365 if (video_description
or '').strip().endswith('\nAuto-generated by YouTube.'):
4366 # XXX: Causes catastrophic backtracking if description has "·"
4367 # E.g. https://www.youtube.com/watch?v=DoPaAxMQoiI
4368 # Simulating atomic groups: (?P<a>[^xy]+)x => (?=(?P<a>[^xy]+))(?P=a)x
4369 # reduces it, but does not fully fix it. https://regex101.com/r/8Ssf2h/2
4372 (?=(?P<track>[^\n·]+))(?P=track)·
4373 (?=(?P<artist>[^\n]+))(?P=artist)\n+
4374 (?=(?P<album>[^\n]+))(?P=album)\n
4375 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4376 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4378 (?=(?P<clean_artist>[^\n]+))(?P=clean_artist)\n
4379 )?.+\nAuto-generated\ by\ YouTube\.\s*$
4380 ''', video_description
)
4382 release_year
= mobj
.group('release_year')
4383 release_date
= mobj
.group('release_date')
4385 release_date
= release_date
.replace('-', '')
4386 if not release_year
:
4387 release_year
= release_date
[:4]
4389 'album': mobj
.group('album'.strip()),
4390 'artist': mobj
.group('clean_artist') or ', '.join(a
.strip() for a
in mobj
.group('artist').split('·')),
4391 'track': mobj
.group('track').strip(),
4392 'release_date': release_date
,
4393 'release_year': int_or_none(release_year
),
4398 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4399 if not traverse_obj(initial_data
, 'contents'):
4400 self
.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4402 if not initial_data
:
4403 query
= {'videoId': video_id}
4404 query
.update(self
._get
_checkok
_params
())
4405 initial_data
= self
._extract
_response
(
4406 item_id
=video_id
, ep
='next', fatal
=False,
4407 ytcfg
=master_ytcfg
, query
=query
, check_get_keys
='contents',
4408 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4409 note
='Downloading initial data API JSON')
4411 info
['comment_count'] = traverse_obj(initial_data
, (
4412 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4413 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount'
4415 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4416 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo'
4417 ), expected_type
=self
._get
_count
, get_all
=False)
4419 try: # This will error if there is no livechat
4420 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4421 except (KeyError, IndexError, TypeError):
4424 info
.setdefault('subtitles', {})['live_chat'] = [{
4425 # url is needed to set cookies
4426 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4427 'video_id': video_id
,
4429 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4430 else 'youtube_live_chat_replay'),
4434 info
['chapters'] = (
4435 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4436 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4437 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4440 info
['heatmap'] = self
._extract
_heatmap
(initial_data
)
4442 contents
= traverse_obj(
4443 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4444 expected_type
=list, default
=[])
4446 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4448 stl
= vpir
.get('superTitleLink')
4450 stl
= self
._get
_text
(stl
)
4453 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4454 info
['location'] = stl
4456 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4459 'series': mobj
.group(1),
4460 'season_number': int(mobj
.group(2)),
4461 'episode_number': int(mobj
.group(3)),
4463 for tlb
in (try_get(
4465 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4469 tlb
, ('toggleButtonRenderer', ...),
4470 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4472 for getter
, regex
in [(
4473 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4474 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4475 lambda x
: x
['accessibility'],
4476 lambda x
: x
['accessibilityData']['accessibilityData'],
4477 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4478 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4480 mobj
= re
.match(regex
, label
)
4482 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4484 sbr_tooltip
= try_get(
4485 vpir
, lambda x
: x
['sentimentBar']['sentimentBarRenderer']['tooltip'])
4487 like_count
, dislike_count
= sbr_tooltip
.split(' / ')
4489 'like_count': str_to_int(like_count
),
4490 'dislike_count': str_to_int(dislike_count
),
4492 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4494 vc
= self
._get
_count
(vcr
, 'viewCount')
4495 # Upcoming premieres with waiting count are treated as live here
4496 if vcr
.get('isLive'):
4497 info
['concurrent_view_count'] = vc
4498 elif info
.get('view_count') is None:
4499 info
['view_count'] = vc
4501 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4503 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4505 'channel': self
._get
_text
(vor
, 'title'),
4506 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4508 if not channel_handle
:
4509 channel_handle
= self
.handle_from_url(
4511 ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4512 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4513 {str}
), get_all
=False))
4517 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4519 multiple_songs
= False
4521 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4522 multiple_songs
= True
4525 mrr
= row
.get('metadataRowRenderer') or {}
4526 mrr_title
= mrr
.get('title')
4529 mrr_title
= self
._get
_text
(mrr
, 'title')
4530 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4531 if mrr_title
== 'License':
4532 info
['license'] = mrr_contents_text
4533 elif not multiple_songs
:
4534 if mrr_title
== 'Album':
4535 info
['album'] = mrr_contents_text
4536 elif mrr_title
== 'Artist':
4537 info
['artist'] = mrr_contents_text
4538 elif mrr_title
== 'Song':
4539 info
['track'] = mrr_contents_text
4540 owner_badges
= self
._extract
_badges
(traverse_obj(vsir
, ('owner', 'videoOwnerRenderer', 'badges')))
4541 if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
):
4542 info
['channel_is_verified'] = True
4545 'uploader': info
.get('channel'),
4546 'uploader_id': channel_handle
,
4547 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4549 # The upload date for scheduled, live and past live streams / premieres in microformats
4550 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4551 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4553 unified_strdate(get_first(microformats
, 'uploadDate'))
4554 or unified_strdate(search_meta('uploadDate')))
4555 if not upload_date
or (
4556 live_status
in ('not_live', None)
4557 and 'no-youtube-prefer-utc-upload-date' not in self
.get_param('compat_opts', [])
4559 upload_date
= strftime_or_none(
4560 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText'))) or upload_date
4561 info
['upload_date'] = upload_date
4563 if upload_date
and live_status
not in ('is_live', 'post_live', 'is_upcoming'):
4564 # Newly uploaded videos' HLS formats are potentially problematic and need to be checked
4565 upload_datetime
= datetime_from_str(upload_date
).replace(tzinfo
=datetime
.timezone
.utc
)
4566 if upload_datetime
>= datetime_from_str('today-1day'):
4567 for fmt
in info
['formats']:
4568 if fmt
.get('protocol') == 'm3u8_native':
4569 fmt
['__needs_testing'] = True
4571 for s_k
, d_k
in [('artist', 'creator'), ('track', 'alt_title')]:
4576 badges
= self
._extract
_badges
(traverse_obj(vpir
, 'badges'))
4578 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4579 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4581 info
['availability'] = (
4582 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4583 else self
._availability
(
4584 is_private
=is_private
,
4586 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4587 or False if initial_data
and is_private
is not None else None),
4588 needs_subscription
=(
4589 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4590 or False if initial_data
and is_private
is not None else None),
4591 needs_auth
=info
['age_limit'] >= 18,
4592 is_unlisted
=None if is_private
is None else (
4593 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4594 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4596 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4598 self
.mark_watched(video_id
, player_responses
)
4603 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4605 def passthrough_smuggled_data(func
):
4606 def _smuggle(info
, smuggled_data
):
4607 if info
.get('_type') not in ('url', 'url_transparent'):
4609 if smuggled_data
.get('is_music_url'):
4610 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4611 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4612 smuggled_data
.pop('is_music_url')
4613 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4615 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4618 @functools.wraps(func
)
4619 def wrapper(self
, url
):
4620 url
, smuggled_data
= unsmuggle_url(url
, {})
4621 if self
.is_music_url(url
):
4622 smuggled_data
['is_music_url'] = True
4623 info_dict
= func(self
, url
, smuggled_data
)
4625 _smuggle(info_dict
, smuggled_data
)
4626 if info_dict
.get('entries'):
4627 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4632 def _extract_basic_item_renderer(item
):
4633 # Modified from _extract_grid_item_renderer
4634 known_basic_renderers
= (
4635 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer'
4637 for key
, renderer
in item
.items():
4638 if not isinstance(renderer
, dict):
4640 elif key
in known_basic_renderers
:
4642 elif key
.startswith('grid') and key
.endswith('Renderer'):
4645 def _extract_channel_renderer(self
, renderer
):
4646 channel_id
= self
.ucid_or_none(renderer
['channelId'])
4647 title
= self
._get
_text
(renderer
, 'title')
4648 channel_url
= format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None)
4649 channel_handle
= self
.handle_from_url(
4650 traverse_obj(renderer
, (
4651 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4652 ('browseEndpoint', 'canonicalBaseUrl')),
4653 {str}
), get_all
=False))
4654 if not channel_handle
:
4655 # As of 2023-06-01, YouTube sets subscriberCountText to the handle in search
4656 channel_handle
= self
.handle_or_none(self
._get
_text
(renderer
, 'subscriberCountText'))
4661 'ie_key': YoutubeTabIE
.ie_key(),
4664 'channel_id': channel_id
,
4665 'channel_url': channel_url
,
4667 'uploader_id': channel_handle
,
4668 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4669 # See above. YouTube sets videoCountText to the subscriber text in search channel renderers.
4670 # However, in feed/channels this is set correctly to the subscriber count
4671 'channel_follower_count': traverse_obj(
4672 renderer
, 'subscriberCountText', 'videoCountText', expected_type
=self
._get
_count
),
4673 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
4675 # videoCountText may be the subscriber count
4676 self
._get
_count
(renderer
, 'videoCountText')
4677 if self
._get
_count
(renderer
, 'subscriberCountText') is not None else None),
4678 'description': self
._get
_text
(renderer
, 'descriptionSnippet'),
4679 'channel_is_verified': True if self
._has
_badge
(
4680 self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges')), BadgeType
.VERIFIED
) else None,
4683 def _grid_entries(self
, grid_renderer
):
4684 for item
in grid_renderer
['items']:
4685 if not isinstance(item
, dict):
4687 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4688 if not isinstance(renderer
, dict):
4690 title
= self
._get
_text
(renderer
, 'title')
4693 playlist_id
= renderer
.get('playlistId')
4695 yield self
.url_result(
4696 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4697 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4701 video_id
= renderer
.get('videoId')
4703 yield self
._extract
_video
(renderer
)
4706 channel_id
= renderer
.get('channelId')
4708 yield self
._extract
_channel
_renderer
(renderer
)
4710 # generic endpoint URL support
4711 ep_url
= urljoin('https://www.youtube.com/', try_get(
4712 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4715 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4716 if ie
.suitable(ep_url
):
4717 yield self
.url_result(
4718 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4721 def _music_reponsive_list_entry(self
, renderer
):
4722 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4724 title
= traverse_obj(renderer
, (
4725 'flexColumns', 0, 'musicResponsiveListItemFlexColumnRenderer',
4726 'text', 'runs', 0, 'text'))
4727 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4728 ie
=YoutubeIE
.ie_key(), video_id
=video_id
, title
=title
)
4729 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4731 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4733 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4734 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4735 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4736 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4737 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4739 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4740 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4742 def _shelf_entries_from_content(self
, shelf_renderer
):
4743 content
= shelf_renderer
.get('content')
4744 if not isinstance(content
, dict):
4746 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4748 # TODO: add support for nested playlists so each shelf is processed
4749 # as separate playlist
4750 # TODO: this includes only first N items
4751 yield from self
._grid
_entries
(renderer
)
4752 renderer
= content
.get('horizontalListRenderer')
4757 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4759 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4761 shelf_url
= urljoin('https://www.youtube.com', ep
)
4763 # Skipping links to another channels, note that checking for
4764 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4766 if skip_channels
and '/channels?' in shelf_url
:
4768 title
= self
._get
_text
(shelf_renderer
, 'title')
4769 yield self
.url_result(shelf_url
, video_title
=title
)
4770 # Shelf may not contain shelf URL, fallback to extraction from content
4771 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4773 def _playlist_entries(self
, video_list_renderer
):
4774 for content
in video_list_renderer
['contents']:
4775 if not isinstance(content
, dict):
4777 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4778 if not isinstance(renderer
, dict):
4780 video_id
= renderer
.get('videoId')
4783 yield self
._extract
_video
(renderer
)
4785 def _rich_entries(self
, rich_grid_renderer
):
4786 renderer
= traverse_obj(
4788 ('content', ('videoRenderer', 'reelItemRenderer', 'playlistRenderer')), get_all
=False) or {}
4789 video_id
= renderer
.get('videoId')
4791 yield self
._extract
_video
(renderer
)
4793 playlist_id
= renderer
.get('playlistId')
4795 yield self
.url_result(
4796 f
'https://www.youtube.com/playlist?list={playlist_id}',
4797 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4798 video_title
=self
._get
_text
(renderer
, 'title'))
4801 def _video_entry(self
, video_renderer
):
4802 video_id
= video_renderer
.get('videoId')
4804 return self
._extract
_video
(video_renderer
)
4806 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4807 url
= urljoin('https://youtube.com', traverse_obj(
4808 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4810 return self
.url_result(
4811 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4813 def _post_thread_entries(self
, post_thread_renderer
):
4814 post_renderer
= try_get(
4815 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4816 if not post_renderer
:
4819 video_renderer
= try_get(
4820 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4821 video_id
= video_renderer
.get('videoId')
4823 entry
= self
._extract
_video
(video_renderer
)
4826 # playlist attachment
4827 playlist_id
= try_get(
4828 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4830 yield self
.url_result(
4831 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4832 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4833 # inline video links
4834 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4836 if not isinstance(run
, dict):
4839 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4842 if not YoutubeIE
.suitable(ep_url
):
4844 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4845 if video_id
== ep_video_id
:
4847 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4849 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4850 contents
= post_thread_continuation
.get('contents')
4851 if not isinstance(contents
, list):
4853 for content
in contents
:
4854 renderer
= content
.get('backstagePostThreadRenderer')
4855 if isinstance(renderer
, dict):
4856 yield from self
._post
_thread
_entries
(renderer
)
4858 renderer
= content
.get('videoRenderer')
4859 if isinstance(renderer
, dict):
4860 yield self
._video
_entry
(renderer
)
4863 def _rich_grid_entries(self, contents):
4864 for content in contents:
4865 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4867 entry = self._video_entry(video_renderer)
4872 def _report_history_entries(self
, renderer
):
4873 for url
in traverse_obj(renderer
, (
4874 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4875 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4876 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4877 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4879 def _extract_entries(self
, parent_renderer
, continuation_list
):
4880 # continuation_list is modified in-place with continuation_list = [continuation_token]
4881 continuation_list
[:] = [None]
4882 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4883 for content
in contents
:
4884 if not isinstance(content
, dict):
4886 is_renderer
= traverse_obj(
4887 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4890 if content
.get('richItemRenderer'):
4891 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4893 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4894 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4895 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4896 yield from self
._report
_history
_entries
(table
)
4897 continuation_list
[0] = self
._extract
_continuation
(table
)
4900 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4901 for isr_content
in isr_contents
:
4902 if not isinstance(isr_content
, dict):
4906 'playlistVideoListRenderer': self
._playlist
_entries
,
4907 'gridRenderer': self
._grid
_entries
,
4908 'reelShelfRenderer': self
._grid
_entries
,
4909 'shelfRenderer': self
._shelf
_entries
,
4910 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4911 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4912 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4913 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4914 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4915 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)],
4916 'richGridRenderer': lambda x
: self
._extract
_entries
(x
, continuation_list
),
4918 for key
, renderer
in isr_content
.items():
4919 if key
not in known_renderers
:
4921 for entry
in known_renderers
[key
](renderer
):
4924 continuation_list
[0] = self
._extract
_continuation
(renderer
)
4927 if not continuation_list
[0]:
4928 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
4930 if not continuation_list
[0]:
4931 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4933 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
4934 continuation_list
= [None]
4935 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
4936 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
4940 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
4941 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
4942 yield from extract_entries(parent_renderer
)
4943 continuation
= continuation_list
[0]
4944 seen_continuations
= set()
4945 for page_num
in itertools
.count(1):
4946 if not continuation
:
4948 continuation_token
= continuation
.get('continuation')
4949 if continuation_token
is not None and continuation_token
in seen_continuations
:
4950 self
.write_debug('Detected YouTube feed looping - assuming end of feed.')
4952 seen_continuations
.add(continuation_token
)
4953 headers
= self
.generate_api_headers(
4954 ytcfg
=ytcfg
, account_syncid
=account_syncid
, visitor_data
=visitor_data
)
4955 response
= self
._extract
_response
(
4956 item_id
=f
'{item_id} page {page_num}',
4957 query
=continuation
, headers
=headers
, ytcfg
=ytcfg
,
4958 check_get_keys
=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4962 # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
4963 # See: https://github.com/ytdl-org/youtube-dl/issues/28702
4964 visitor_data
= self
._extract
_visitor
_data
(response
) or visitor_data
4967 'videoRenderer': (self
._grid
_entries
, 'items'), # for membership tab
4968 'gridPlaylistRenderer': (self
._grid
_entries
, 'items'),
4969 'gridVideoRenderer': (self
._grid
_entries
, 'items'),
4970 'gridChannelRenderer': (self
._grid
_entries
, 'items'),
4971 'playlistVideoRenderer': (self
._playlist
_entries
, 'contents'),
4972 'itemSectionRenderer': (extract_entries
, 'contents'), # for feeds
4973 'richItemRenderer': (extract_entries
, 'contents'), # for hashtag
4974 'backstagePostThreadRenderer': (self
._post
_thread
_continuation
_entries
, 'contents'),
4975 'reportHistoryTableRowRenderer': (self
._report
_history
_entries
, 'rows'),
4976 'playlistVideoListContinuation': (self
._playlist
_entries
, None),
4977 'gridContinuation': (self
._grid
_entries
, None),
4978 'itemSectionContinuation': (self
._post
_thread
_continuation
_entries
, None),
4979 'sectionListContinuation': (extract_entries
, None), # for feeds
4982 continuation_items
= traverse_obj(response
, (
4983 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
4984 'appendContinuationItemsAction', 'continuationItems'
4985 ), 'continuationContents', get_all
=False)
4986 continuation_item
= traverse_obj(continuation_items
, 0, None, expected_type
=dict, default
={})
4988 video_items_renderer
= None
4989 for key
in continuation_item
.keys():
4990 if key
not in known_renderers
:
4992 func
, parent_key
= known_renderers
[key
]
4993 video_items_renderer
= {parent_key: continuation_items}
if parent_key
else continuation_items
4994 continuation_list
= [None]
4995 yield from func(video_items_renderer
)
4996 continuation
= continuation_list
[0] or self
._extract
_continuation
(video_items_renderer
)
4998 if not video_items_renderer
:
5002 def _extract_selected_tab(tabs
, fatal
=True):
5003 for tab_renderer
in tabs
:
5004 if tab_renderer
.get('selected'):
5007 raise ExtractorError('Unable to find selected tab')
5010 def _extract_tab_renderers(response
):
5011 return traverse_obj(
5012 response
, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type
=dict)
5014 def _extract_from_tabs(self
, item_id
, ytcfg
, data
, tabs
):
5015 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
5017 selected_tab
= self
._extract
_selected
_tab
(tabs
)
5018 metadata
['title'] += format_field(selected_tab
, 'title', ' - %s')
5019 metadata
['title'] += format_field(selected_tab
, 'expandedText', ' - %s')
5021 return self
.playlist_result(
5023 selected_tab
, metadata
['id'], ytcfg
,
5024 self
._extract
_account
_syncid
(ytcfg
, data
),
5025 self
._extract
_visitor
_data
(data
, ytcfg
)),
5028 def _extract_metadata_from_tabs(self
, item_id
, data
):
5029 info
= {'id': item_id}
5031 metadata_renderer
= traverse_obj(data
, ('metadata', 'channelMetadataRenderer'), expected_type
=dict)
5032 if metadata_renderer
:
5033 channel_id
= traverse_obj(metadata_renderer
, ('externalId', {self.ucid_or_none}
),
5034 ('channelUrl', {self.ucid_from_url}
))
5036 'channel': metadata_renderer
.get('title'),
5037 'channel_id': channel_id
,
5039 if info
['channel_id']:
5040 info
['id'] = info
['channel_id']
5042 metadata_renderer
= traverse_obj(data
, ('metadata', 'playlistMetadataRenderer'), expected_type
=dict)
5044 # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
5045 # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
5046 def _get_uncropped(url
):
5047 return url_or_none((url
or '').split('=')[0] + '=s0')
5049 avatar_thumbnails
= self
._extract
_thumbnails
(metadata_renderer
, 'avatar')
5050 if avatar_thumbnails
:
5051 uncropped_avatar
= _get_uncropped(avatar_thumbnails
[0]['url'])
5052 if uncropped_avatar
:
5053 avatar_thumbnails
.append({
5054 'url': uncropped_avatar
,
5055 'id': 'avatar_uncropped',
5059 channel_banners
= self
._extract
_thumbnails
(
5060 data
, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
5061 for banner
in channel_banners
:
5062 banner
['preference'] = -10
5065 uncropped_banner
= _get_uncropped(channel_banners
[0]['url'])
5066 if uncropped_banner
:
5067 channel_banners
.append({
5068 'url': uncropped_banner
,
5069 'id': 'banner_uncropped',
5073 # Deprecated - remove primary_sidebar_renderer when layout discontinued
5074 primary_sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer')
5075 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer'), expected_type
=dict)
5077 primary_thumbnails
= self
._extract
_thumbnails
(
5078 primary_sidebar_renderer
, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
5079 playlist_thumbnails
= self
._extract
_thumbnails
(
5080 playlist_header_renderer
, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
5083 'title': (traverse_obj(metadata_renderer
, 'title')
5084 or self
._get
_text
(data
, ('header', 'hashtagHeaderRenderer', 'hashtag'))
5086 'availability': self
._extract
_availability
(data
),
5087 'channel_follower_count': self
._get
_count
(data
, ('header', ..., 'subscriberCountText')),
5088 'description': try_get(metadata_renderer
, lambda x
: x
.get('description', '')),
5089 'tags': try_get(metadata_renderer
or {}, lambda x
: x
.get('keywords', '').split()),
5090 'thumbnails': (primary_thumbnails
or playlist_thumbnails
) + avatar_thumbnails
+ channel_banners
,
5094 traverse_obj(metadata_renderer
, (('vanityChannelUrl', ('ownerUrls', ...)), {self.handle_from_url}
), get_all
=False)
5095 or traverse_obj(data
, ('header', ..., 'channelHandleText', {self.handle_or_none}
), get_all
=False))
5099 'uploader_id': channel_handle
,
5100 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
5103 channel_badges
= self
._extract
_badges
(traverse_obj(data
, ('header', ..., 'badges'), get_all
=False))
5104 if self
._has
_badge
(channel_badges
, BadgeType
.VERIFIED
):
5105 info
['channel_is_verified'] = True
5106 # Playlist stats is a text runs array containing [video count, view count, last updated].
5107 # last updated or (view count and last updated) may be missing.
5108 playlist_stats
= get_first(
5109 (primary_sidebar_renderer
, playlist_header_renderer
), (('stats', 'briefStats', 'numVideosText'), ))
5111 last_updated_unix
= self
._parse
_time
_text
(
5112 self
._get
_text
(playlist_stats
, 2) # deprecated, remove when old layout discontinued
5113 or self
._get
_text
(playlist_header_renderer
, ('byline', 1, 'playlistBylineRenderer', 'text')))
5114 info
['modified_date'] = strftime_or_none(last_updated_unix
)
5116 info
['view_count'] = self
._get
_count
(playlist_stats
, 1)
5117 if info
['view_count'] is None: # 0 is allowed
5118 info
['view_count'] = self
._get
_count
(playlist_header_renderer
, 'viewCountText')
5119 if info
['view_count'] is None:
5120 info
['view_count'] = self
._get
_count
(data
, (
5121 'contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., 'tabRenderer', 'content', 'sectionListRenderer',
5122 'contents', ..., 'itemSectionRenderer', 'contents', ..., 'channelAboutFullMetadataRenderer', 'viewCountText'))
5124 info
['playlist_count'] = self
._get
_count
(playlist_stats
, 0)
5125 if info
['playlist_count'] is None: # 0 is allowed
5126 info
['playlist_count'] = self
._get
_count
(playlist_header_renderer
, ('byline', 0, 'playlistBylineRenderer', 'text'))
5128 if not info
.get('channel_id'):
5129 owner
= traverse_obj(playlist_header_renderer
, 'ownerText')
5130 if not owner
: # Deprecated
5131 owner
= traverse_obj(
5132 self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarSecondaryInfoRenderer'),
5133 ('videoOwner', 'videoOwnerRenderer', 'title'))
5134 owner_text
= self
._get
_text
(owner
)
5135 browse_ep
= traverse_obj(owner
, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
5137 'channel': self
._search
_regex
(r
'^by (.+) and \d+ others?$', owner_text
, 'uploader', default
=owner_text
),
5138 'channel_id': self
.ucid_or_none(browse_ep
.get('browseId')),
5139 'uploader_id': self
.handle_from_url(urljoin('https://www.youtube.com', browse_ep
.get('canonicalBaseUrl')))
5143 'uploader': info
['channel'],
5144 'channel_url': format_field(info
.get('channel_id'), None, 'https://www.youtube.com/channel/%s', default
=None),
5145 'uploader_url': format_field(info
.get('uploader_id'), None, 'https://www.youtube.com/%s', default
=None),
5150 def _extract_inline_playlist(self
, playlist
, playlist_id
, data
, ytcfg
):
5151 first_id
= last_id
= response
= None
5152 for page_num
in itertools
.count(1):
5153 videos
= list(self
._playlist
_entries
(playlist
))
5156 start
= next((i
for i
, v
in enumerate(videos
) if v
['id'] == last_id
), -1) + 1
5157 if start
>= len(videos
):
5159 yield from videos
[start
:]
5160 first_id
= first_id
or videos
[0]['id']
5161 last_id
= videos
[-1]['id']
5162 watch_endpoint
= try_get(
5163 playlist
, lambda x
: x
['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
5164 headers
= self
.generate_api_headers(
5165 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5166 visitor_data
=self
._extract
_visitor
_data
(response
, data
, ytcfg
))
5168 'playlistId': playlist_id
,
5169 'videoId': watch_endpoint
.get('videoId') or last_id
,
5170 'index': watch_endpoint
.get('index') or len(videos
),
5171 'params': watch_endpoint
.get('params') or 'OAE%3D'
5173 response
= self
._extract
_response
(
5174 item_id
='%s page %d' % (playlist_id
, page_num
),
5175 query
=query
, ep
='next', headers
=headers
, ytcfg
=ytcfg
,
5176 check_get_keys
='contents'
5179 response
, lambda x
: x
['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
5181 def _extract_from_playlist(self
, item_id
, url
, data
, playlist
, ytcfg
):
5182 title
= playlist
.get('title') or try_get(
5183 data
, lambda x
: x
['titleText']['simpleText'], str)
5184 playlist_id
= playlist
.get('playlistId') or item_id
5186 # Delegating everything except mix playlists to regular tab-based playlist URL
5187 playlist_url
= urljoin(url
, try_get(
5188 playlist
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
5191 # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
5192 # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
5193 is_known_unviewable
= re
.fullmatch(r
'MLCT|RLTD[\w-]{22}', playlist_id
)
5195 if playlist_url
and playlist_url
!= url
and not is_known_unviewable
:
5196 return self
.url_result(
5197 playlist_url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
5200 return self
.playlist_result(
5201 self
._extract
_inline
_playlist
(playlist
, playlist_id
, data
, ytcfg
),
5202 playlist_id
=playlist_id
, playlist_title
=title
)
5204 def _extract_availability(self
, data
):
5206 Gets the availability of a given playlist/tab.
5207 Note: Unless YouTube tells us explicitly, we do not assume it is public
5208 @param data: response
5210 sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer') or {}
5211 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer')) or {}
5212 player_header_privacy
= playlist_header_renderer
.get('privacy')
5214 badges
= self
._extract
_badges
(traverse_obj(sidebar_renderer
, 'badges'))
5216 # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
5217 privacy_setting_icon
= get_first(
5218 (playlist_header_renderer
, sidebar_renderer
),
5219 ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
5220 lambda _
, v
: v
['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
5223 microformats_is_unlisted
= traverse_obj(
5224 data
, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type
=bool)
5228 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
5229 or player_header_privacy
== 'PUBLIC'
5230 or privacy_setting_icon
== 'PRIVACY_PUBLIC')
5231 else self
._availability
(
5233 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
5234 or player_header_privacy
== 'PRIVATE' if player_header_privacy
is not None
5235 else privacy_setting_icon
== 'PRIVACY_PRIVATE' if privacy_setting_icon
is not None else None),
5237 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
5238 or player_header_privacy
== 'UNLISTED' if player_header_privacy
is not None
5239 else privacy_setting_icon
== 'PRIVACY_UNLISTED' if privacy_setting_icon
is not None
5240 else microformats_is_unlisted
if microformats_is_unlisted
is not None else None),
5241 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
5242 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
5246 def _extract_sidebar_info_renderer(data
, info_renderer
, expected_type
=dict):
5247 sidebar_renderer
= try_get(
5248 data
, lambda x
: x
['sidebar']['playlistSidebarRenderer']['items'], list) or []
5249 for item
in sidebar_renderer
:
5250 renderer
= try_get(item
, lambda x
: x
[info_renderer
], expected_type
)
5254 def _reload_with_unavailable_videos(self
, item_id
, data
, ytcfg
):
5256 Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
5258 is_playlist
= bool(traverse_obj(
5259 data
, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
5262 headers
= self
.generate_api_headers(
5263 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5264 visitor_data
=self
._extract
_visitor
_data
(data
, ytcfg
))
5266 'params': 'wgYCCAA=',
5267 'browseId': f
'VL{item_id}'
5269 return self
._extract
_response
(
5270 item_id
=item_id
, headers
=headers
, query
=query
,
5271 check_get_keys
='contents', fatal
=False, ytcfg
=ytcfg
,
5272 note
='Redownloading playlist API JSON with unavailable videos')
5274 @functools.cached_property
5275 def skip_webpage(self
):
5276 return 'webpage' in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key())
5278 def _extract_webpage(self
, url
, item_id
, fatal
=True):
5279 webpage
, data
= None, None
5280 for retry
in self
.RetryManager(fatal
=fatal
):
5282 webpage
= self
._download
_webpage
(url
, item_id
, note
='Downloading webpage')
5283 data
= self
.extract_yt_initial_data(item_id
, webpage
or '', fatal
=fatal
) or {}
5284 except ExtractorError
as e
:
5285 if isinstance(e
.cause
, network_exceptions
):
5286 if not isinstance(e
.cause
, HTTPError
) or e
.cause
.status
not in (403, 429):
5289 self
._error
_or
_warning
(e
, fatal
=fatal
)
5293 self
._extract
_and
_report
_alerts
(data
)
5294 except ExtractorError
as e
:
5295 self
._error
_or
_warning
(e
, fatal
=fatal
)
5298 # Sometimes youtube returns a webpage with incomplete ytInitialData
5299 # See: https://github.com/yt-dlp/yt-dlp/issues/116
5300 if not traverse_obj(data
, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
5301 retry
.error
= ExtractorError('Incomplete yt initial data received')
5304 return webpage
, data
5306 def _report_playlist_authcheck(self
, ytcfg
, fatal
=True):
5307 """Use if failed to extract ytcfg (and data) from initial webpage"""
5308 if not ytcfg
and self
.is_authenticated
:
5309 msg
= 'Playlists that require authentication may not extract correctly without a successful webpage download'
5310 if 'authcheck' not in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key()) and fatal
:
5311 raise ExtractorError(
5312 f
'{msg}. If you are not downloading private content, or '
5313 'your cookies are only for the first account and channel,'
5314 ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
5316 self
.report_warning(msg
, only_once
=True)
5318 def _extract_data(self
, url
, item_id
, ytcfg
=None, fatal
=True, webpage_fatal
=False, default_client
='web'):
5320 if not self
.skip_webpage
:
5321 webpage
, data
= self
._extract
_webpage
(url
, item_id
, fatal
=webpage_fatal
)
5322 ytcfg
= ytcfg
or self
.extract_ytcfg(item_id
, webpage
)
5323 # Reject webpage data if redirected to home page without explicitly requesting
5324 selected_tab
= self
._extract
_selected
_tab
(self
._extract
_tab
_renderers
(data
), fatal
=False) or {}
5325 if (url
!= 'https://www.youtube.com/feed/recommended'
5326 and selected_tab
.get('tabIdentifier') == 'FEwhat_to_watch' # Home page
5327 and 'no-youtube-channel-redirect' not in self
.get_param('compat_opts', [])):
5328 msg
= 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
5330 raise ExtractorError(msg
, expected
=True)
5331 self
.report_warning(msg
, only_once
=True)
5333 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=fatal
)
5334 data
= self
._extract
_tab
_endpoint
(url
, item_id
, ytcfg
, fatal
=fatal
, default_client
=default_client
)
5337 def _extract_tab_endpoint(self
, url
, item_id
, ytcfg
=None, fatal
=True, default_client
='web'):
5338 headers
= self
.generate_api_headers(ytcfg
=ytcfg
, default_client
=default_client
)
5339 resolve_response
= self
._extract
_response
(
5340 item_id
=item_id
, query
={'url': url}
, check_get_keys
='endpoint', headers
=headers
, ytcfg
=ytcfg
, fatal
=fatal
,
5341 ep
='navigation/resolve_url', note
='Downloading API parameters API JSON', default_client
=default_client
)
5342 endpoints
= {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5343 for ep_key
, ep
in endpoints
.items():
5344 params
= try_get(resolve_response
, lambda x
: x
['endpoint'][ep_key
], dict)
5346 return self
._extract
_response
(
5347 item_id
=item_id
, query
=params
, ep
=ep
, headers
=headers
,
5348 ytcfg
=ytcfg
, fatal
=fatal
, default_client
=default_client
,
5349 check_get_keys
=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5350 err_note
= 'Failed to resolve url (does the playlist exist?)'
5352 raise ExtractorError(err_note
, expected
=True)
5353 self
.report_warning(err_note
, item_id
)
5355 _SEARCH_PARAMS
= None
5357 def _search_results(self
, query
, params
=NO_DEFAULT
, default_client
='web'):
5358 data
= {'query': query}
5359 if params
is NO_DEFAULT
:
5360 params
= self
._SEARCH
_PARAMS
5362 data
['params'] = params
5365 ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5366 ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5368 ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5369 ('continuationContents', ),
5371 display_id
= f
'query "{query}"'
5372 check_get_keys
= tuple({keys[0] for keys in content_keys}
)
5373 ytcfg
= self
._download
_ytcfg
(default_client
, display_id
) if not self
.skip_webpage
else {}
5374 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=False)
5376 continuation_list
= [None]
5378 for page_num
in itertools
.count(1):
5379 data
.update(continuation_list
[0] or {})
5380 headers
= self
.generate_api_headers(
5381 ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(search
), default_client
=default_client
)
5382 search
= self
._extract
_response
(
5383 item_id
=f
'{display_id} page {page_num}', ep
='search', query
=data
,
5384 default_client
=default_client
, check_get_keys
=check_get_keys
, ytcfg
=ytcfg
, headers
=headers
)
5385 slr_contents
= traverse_obj(search
, *content_keys
)
5386 yield from self
._extract
_entries
({'contents': list(variadic(slr_contents))}
, continuation_list
)
5387 if not continuation_list
[0]:
5391 class YoutubeTabIE(YoutubeTabBaseInfoExtractor
):
5392 IE_DESC
= 'YouTube Tabs'
5393 _VALID_URL
= r
'''(?x:
5395 (?!consent\.)(?:\w+\.)?
5397 youtube(?:kids)?\.com|
5401 (?P<channel_type>channel|c|user|browse)/|
5404 (?:playlist|watch)\?.*?\blist=
5406 (?!(?:%(reserved_names)s)\b) # Direct URLs
5410 'reserved_names': YoutubeBaseInfoExtractor
._RESERVED
_NAMES
,
5411 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
5413 IE_NAME
= 'youtube:tab'
5416 'note': 'playlists, multipage',
5417 'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5418 'playlist_mincount': 94,
5420 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5421 'title': 'Igor Kleiner - Playlists',
5422 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5423 'uploader': 'Igor Kleiner',
5424 'uploader_id': '@IgorDataScience',
5425 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5426 'channel': 'Igor Kleiner',
5427 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5428 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5429 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5430 'channel_follower_count': int
5433 'note': 'playlists, multipage, different order',
5434 'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5435 'playlist_mincount': 94,
5437 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5438 'title': 'Igor Kleiner - Playlists',
5439 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5440 'uploader': 'Igor Kleiner',
5441 'uploader_id': '@IgorDataScience',
5442 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5443 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5444 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5445 'channel': 'Igor Kleiner',
5446 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5447 'channel_follower_count': int
5450 'note': 'playlists, series',
5451 'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5452 'playlist_mincount': 5,
5454 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5455 'title': '3Blue1Brown - Playlists',
5456 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5457 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5458 'channel': '3Blue1Brown',
5459 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5460 'uploader_id': '@3blue1brown',
5461 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5462 'uploader': '3Blue1Brown',
5463 'tags': ['Mathematics'],
5464 'channel_follower_count': int,
5465 'channel_is_verified': True,
5468 'note': 'playlists, singlepage',
5469 'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5470 'playlist_mincount': 4,
5472 'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5473 'title': 'ThirstForScience - Playlists',
5474 'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5475 'uploader': 'ThirstForScience',
5476 'uploader_url': 'https://www.youtube.com/@ThirstForScience',
5477 'uploader_id': '@ThirstForScience',
5478 'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5479 'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5481 'channel': 'ThirstForScience',
5482 'channel_follower_count': int
5485 'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5486 'only_matching': True,
5488 'note': 'basic, single video playlist',
5489 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5491 'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5492 'title': 'youtube-dl public playlist',
5496 'modified_date': '20201130',
5497 'channel': 'Sergey M.',
5498 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5499 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5500 'availability': 'public',
5501 'uploader': 'Sergey M.',
5502 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5503 'uploader_id': '@sergeym.6173',
5505 'playlist_count': 1,
5507 'note': 'empty playlist',
5508 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5510 'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5511 'title': 'youtube-dl empty playlist',
5513 'channel': 'Sergey M.',
5515 'modified_date': '20160902',
5516 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5517 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5518 'availability': 'public',
5519 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5520 'uploader_id': '@sergeym.6173',
5521 'uploader': 'Sergey M.',
5523 'playlist_count': 0,
5526 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5528 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5529 'title': 'lex will - Home',
5530 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5531 'uploader': 'lex will',
5532 'uploader_id': '@lexwill718',
5533 'channel': 'lex will',
5534 'tags': ['bible', 'history', 'prophesy'],
5535 'uploader_url': 'https://www.youtube.com/@lexwill718',
5536 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5537 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5538 'channel_follower_count': int
5540 'playlist_mincount': 2,
5542 'note': 'Videos tab',
5543 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5545 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5546 'title': 'lex will - Videos',
5547 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5548 'uploader': 'lex will',
5549 'uploader_id': '@lexwill718',
5550 'tags': ['bible', 'history', 'prophesy'],
5551 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5552 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5553 'uploader_url': 'https://www.youtube.com/@lexwill718',
5554 'channel': 'lex will',
5555 'channel_follower_count': int
5557 'playlist_mincount': 975,
5559 'note': 'Videos tab, sorted by popular',
5560 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5562 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5563 'title': 'lex will - Videos',
5564 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5565 'uploader': 'lex will',
5566 'uploader_id': '@lexwill718',
5567 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5568 'uploader_url': 'https://www.youtube.com/@lexwill718',
5569 'channel': 'lex will',
5570 'tags': ['bible', 'history', 'prophesy'],
5571 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5572 'channel_follower_count': int
5574 'playlist_mincount': 199,
5576 'note': 'Playlists tab',
5577 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5579 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5580 'title': 'lex will - Playlists',
5581 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5582 'uploader': 'lex will',
5583 'uploader_id': '@lexwill718',
5584 'uploader_url': 'https://www.youtube.com/@lexwill718',
5585 'channel': 'lex will',
5586 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5587 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5588 'tags': ['bible', 'history', 'prophesy'],
5589 'channel_follower_count': int
5591 'playlist_mincount': 17,
5593 'note': 'Community tab',
5594 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5596 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5597 'title': 'lex will - Community',
5598 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5599 'channel': 'lex will',
5600 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5601 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5602 'tags': ['bible', 'history', 'prophesy'],
5603 'channel_follower_count': int,
5604 'uploader_url': 'https://www.youtube.com/@lexwill718',
5605 'uploader_id': '@lexwill718',
5606 'uploader': 'lex will',
5608 'playlist_mincount': 18,
5610 'note': 'Channels tab',
5611 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5613 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5614 'title': 'lex will - Channels',
5615 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5616 'channel': 'lex will',
5617 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5618 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5619 'tags': ['bible', 'history', 'prophesy'],
5620 'channel_follower_count': int,
5621 'uploader_url': 'https://www.youtube.com/@lexwill718',
5622 'uploader_id': '@lexwill718',
5623 'uploader': 'lex will',
5625 'playlist_mincount': 12,
5627 'note': 'Search tab',
5628 'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5629 'playlist_mincount': 40,
5631 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5632 'title': '3Blue1Brown - Search - linear algebra',
5633 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5634 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5635 'tags': ['Mathematics'],
5636 'channel': '3Blue1Brown',
5637 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5638 'channel_follower_count': int,
5639 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5640 'uploader_id': '@3blue1brown',
5641 'uploader': '3Blue1Brown',
5642 'channel_is_verified': True,
5645 'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5646 'only_matching': True,
5648 'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5649 'only_matching': True,
5651 'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5652 'only_matching': True,
5654 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5655 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5657 'title': '29C3: Not my department',
5658 'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5659 'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5662 'modified_date': '20150605',
5663 'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5664 'channel_url': 'https://www.youtube.com/channel/UCEPzS1rYsrkqzSLNp76nrcg',
5665 'channel': 'Christiaan008',
5666 'availability': 'public',
5667 'uploader_id': '@ChRiStIaAn008',
5668 'uploader': 'Christiaan008',
5669 'uploader_url': 'https://www.youtube.com/@ChRiStIaAn008',
5671 'playlist_count': 96,
5673 'note': 'Large playlist',
5674 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5676 'title': 'Uploads from Cauchemar',
5677 'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5678 'channel_url': 'https://www.youtube.com/channel/UCBABnxM4Ar9ten8Mdjj1j0Q',
5680 'modified_date': r
're:\d{8}',
5681 'channel': 'Cauchemar',
5684 'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5685 'availability': 'public',
5686 'uploader_id': '@Cauchemar89',
5687 'uploader': 'Cauchemar',
5688 'uploader_url': 'https://www.youtube.com/@Cauchemar89',
5690 'playlist_mincount': 1123,
5691 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5693 'note': 'even larger playlist, 8832 videos',
5694 'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5695 'only_matching': True,
5697 'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5698 'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5700 'title': 'Uploads from Interstellar Movie',
5701 'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5704 'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5705 'channel_url': 'https://www.youtube.com/channel/UCXw-G3eDE9trcvY2sBMM_aA',
5706 'channel': 'Interstellar Movie',
5708 'modified_date': r
're:\d{8}',
5709 'availability': 'public',
5710 'uploader_id': '@InterstellarMovie',
5711 'uploader': 'Interstellar Movie',
5712 'uploader_url': 'https://www.youtube.com/@InterstellarMovie',
5714 'playlist_mincount': 21,
5716 'note': 'Playlist with "show unavailable videos" button',
5717 'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5719 'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5720 'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5722 'channel': 'Phim Siêu Nhân Nhật Bản',
5725 'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5726 'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5727 'modified_date': r
're:\d{8}',
5728 'availability': 'public',
5729 'uploader_url': 'https://www.youtube.com/@phimsieunhannhatban',
5730 'uploader_id': '@phimsieunhannhatban',
5731 'uploader': 'Phim Siêu Nhân Nhật Bản',
5733 'playlist_mincount': 200,
5734 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5736 'note': 'Playlist with unavailable videos in page 7',
5737 'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5739 'title': 'Uploads from BlankTV',
5740 'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5741 'channel': 'BlankTV',
5742 'channel_url': 'https://www.youtube.com/channel/UC8l9frL61Yl5KFOl87nIm2w',
5743 'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5746 'modified_date': r
're:\d{8}',
5748 'availability': 'public',
5749 'uploader_id': '@blanktv',
5750 'uploader': 'BlankTV',
5751 'uploader_url': 'https://www.youtube.com/@blanktv',
5753 'playlist_mincount': 1000,
5754 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5756 'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5757 'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5759 'title': 'Data Analysis with Dr Mike Pound',
5760 'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5761 'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5764 'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5765 'channel_url': 'https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA',
5766 'channel': 'Computerphile',
5767 'availability': 'public',
5768 'modified_date': '20190712',
5769 'uploader_id': '@Computerphile',
5770 'uploader': 'Computerphile',
5771 'uploader_url': 'https://www.youtube.com/@Computerphile',
5773 'playlist_mincount': 11,
5775 'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5776 'only_matching': True,
5778 'note': 'Playlist URL that does not actually serve a playlist',
5779 'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5781 'id': 'FqZTN594JQw',
5783 'title': "Smiley's People 01 detective, Adventure Series, Action",
5784 'upload_date': '20150526',
5785 'license': 'Standard YouTube License',
5786 'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5787 'categories': ['People & Blogs'],
5793 'skip_download': True,
5795 'skip': 'This video is not available.',
5796 'add_ie': [YoutubeIE
.ie_key()],
5798 'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5799 'only_matching': True,
5801 'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5802 'only_matching': True,
5804 'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5806 'id': 'hGkQjiJLjWQ', # This will keep changing
5809 'upload_date': r
're:\d{8}',
5811 'categories': ['News & Politics'],
5814 'release_timestamp': int,
5815 'channel': 'Sky News',
5816 'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5819 'thumbnail': r
're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5820 'playable_in_embed': True,
5821 'release_date': r
're:\d+',
5822 'availability': 'public',
5823 'live_status': 'is_live',
5824 'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5825 'channel_follower_count': int,
5826 'concurrent_view_count': int,
5827 'uploader_url': 'https://www.youtube.com/@SkyNews',
5828 'uploader_id': '@SkyNews',
5829 'uploader': 'Sky News',
5830 'channel_is_verified': True,
5833 'skip_download': True,
5835 'expected_warnings': ['Ignoring subtitle tracks found in '],
5837 'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5839 'id': 'a48o2S1cPoo',
5841 'title': 'The Young Turks - Live Main Show',
5842 'upload_date': '20150715',
5843 'license': 'Standard YouTube License',
5844 'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5845 'categories': ['News & Politics'],
5846 'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5850 'skip_download': True,
5852 'only_matching': True,
5854 'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5855 'only_matching': True,
5857 'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5858 'only_matching': True,
5860 'note': 'A channel that is not live. Should raise error',
5861 'url': 'https://www.youtube.com/user/numberphile/live',
5862 'only_matching': True,
5864 'url': 'https://www.youtube.com/feed/trending',
5865 'only_matching': True,
5867 'url': 'https://www.youtube.com/feed/library',
5868 'only_matching': True,
5870 'url': 'https://www.youtube.com/feed/history',
5871 'only_matching': True,
5873 'url': 'https://www.youtube.com/feed/subscriptions',
5874 'only_matching': True,
5876 'url': 'https://www.youtube.com/feed/watch_later',
5877 'only_matching': True,
5879 'note': 'Recommended - redirects to home page.',
5880 'url': 'https://www.youtube.com/feed/recommended',
5881 'only_matching': True,
5883 'note': 'inline playlist with not always working continuations',
5884 'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5885 'only_matching': True,
5887 'url': 'https://www.youtube.com/course',
5888 'only_matching': True,
5890 'url': 'https://www.youtube.com/zsecurity',
5891 'only_matching': True,
5893 'url': 'http://www.youtube.com/NASAgovVideo/videos',
5894 'only_matching': True,
5896 'url': 'https://www.youtube.com/TheYoungTurks/live',
5897 'only_matching': True,
5899 'url': 'https://www.youtube.com/hashtag/cctv9',
5905 'playlist_mincount': 300, # not consistent but should be over 300
5907 'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
5908 'only_matching': True,
5910 'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
5911 'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5912 'only_matching': True
5914 'note': '/browse/ should redirect to /channel/',
5915 'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
5916 'only_matching': True
5918 'note': 'VLPL, should redirect to playlist?list=PL...',
5919 'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5921 'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5922 'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
5923 'title': 'NCS : All Releases 💿',
5924 'channel_url': 'https://www.youtube.com/channel/UC_aEa8K-EOJ3D6gOs7HcyNg',
5925 'modified_date': r
're:\d{8}',
5927 'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
5929 'channel': 'NoCopyrightSounds',
5930 'availability': 'public',
5931 'uploader_url': 'https://www.youtube.com/@NoCopyrightSounds',
5932 'uploader': 'NoCopyrightSounds',
5933 'uploader_id': '@NoCopyrightSounds',
5935 'playlist_mincount': 166,
5936 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden', 'YouTube Music is not directly supported'],
5938 # TODO: fix 'unviewable' issue with this playlist when reloading with unavailable videos
5939 'note': 'Topic, should redirect to playlist?list=UU...',
5940 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5942 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5943 'title': 'Uploads from Royalty Free Music - Topic',
5945 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5946 'channel': 'Royalty Free Music - Topic',
5948 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5949 'modified_date': r
're:\d{8}',
5951 'availability': 'public',
5952 'uploader': 'Royalty Free Music - Topic',
5954 'playlist_mincount': 101,
5955 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5957 # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
5958 # Treat as a general feed
5959 'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
5961 'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
5962 'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
5965 'playlist_mincount': 9,
5967 'note': 'Youtube music Album',
5968 'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
5970 'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
5971 'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
5975 'availability': 'unlisted',
5976 'modified_date': r
're:\d{8}',
5978 'playlist_count': 50,
5979 'expected_warnings': ['YouTube Music is not directly supported'],
5981 'note': 'unlisted single video playlist',
5982 'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5984 'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5985 'title': 'yt-dlp unlisted playlist test',
5986 'availability': 'unlisted',
5988 'modified_date': '20220418',
5989 'channel': 'colethedj',
5992 'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5993 'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5994 'uploader_url': 'https://www.youtube.com/@colethedj1894',
5995 'uploader_id': '@colethedj1894',
5996 'uploader': 'colethedj',
6000 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
6001 'id': 'BaW_jenozKc',
6003 'ie_key': 'Youtube',
6005 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
6006 'channel_url': 'https://www.youtube.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
6008 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc',
6009 'channel': 'Philipp Hagemeister',
6010 'uploader_id': '@PhilippHagemeister',
6011 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
6012 'uploader': 'Philipp Hagemeister',
6015 'playlist_count': 1,
6016 'params': {'extract_flat': True}
,
6018 'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
6019 'url': 'https://www.youtube.com/feed/recommended',
6021 'id': 'recommended',
6022 'title': 'recommended',
6025 'playlist_mincount': 50,
6027 'skip_download': True,
6028 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6031 'note': 'API Fallback: /videos tab, sorted by oldest first',
6032 'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
6034 'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6035 'title': 'Cody\'sLab - Videos',
6036 'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
6037 'channel': 'Cody\'sLab',
6038 'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6040 'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
6041 'channel_follower_count': int
6043 'playlist_mincount': 650,
6045 'skip_download': True,
6046 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6048 'skip': 'Query for sorting no longer works',
6050 'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
6051 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
6053 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
6054 'title': 'Uploads from Royalty Free Music - Topic',
6055 'modified_date': r
're:\d{8}',
6056 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
6058 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
6060 'channel': 'Royalty Free Music - Topic',
6062 'availability': 'public',
6063 'uploader': 'Royalty Free Music - Topic',
6065 'playlist_mincount': 101,
6067 'skip_download': True,
6068 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
6070 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
6072 'note': 'non-standard redirect to regional channel',
6073 'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
6074 'only_matching': True
6076 'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
6077 'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6079 'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6080 'modified_date': '20220407',
6081 'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
6083 'availability': 'unlisted',
6084 'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
6085 'channel': 'pukkandan',
6086 'description': 'Test for collaborative playlist',
6087 'title': 'yt-dlp test - collaborative playlist',
6089 'uploader_url': 'https://www.youtube.com/@pukkandan',
6090 'uploader_id': '@pukkandan',
6091 'uploader': 'pukkandan',
6093 'playlist_mincount': 2
6095 'note': 'translated tab name',
6096 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
6098 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6100 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6101 'description': 'test description',
6102 'title': 'cole-dlp-test-acc - 再生リスト',
6103 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6104 'channel': 'cole-dlp-test-acc',
6105 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6106 'uploader_id': '@coletdjnz',
6107 'uploader': 'cole-dlp-test-acc',
6109 'playlist_mincount': 1,
6110 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6111 'expected_warnings': ['Preferring "ja"'],
6113 # XXX: this should really check flat playlist entries, but the test suite doesn't support that
6114 'note': 'preferred lang set with playlist with translated video titles',
6115 'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6117 'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6120 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6121 'channel': 'cole-dlp-test-acc',
6122 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6123 'description': 'test',
6124 'title': 'dlp test playlist',
6125 'availability': 'public',
6126 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6127 'uploader_id': '@coletdjnz',
6128 'uploader': 'cole-dlp-test-acc',
6130 'playlist_mincount': 1,
6131 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6132 'expected_warnings': ['Preferring "ja"'],
6134 # shorts audio pivot for 2GtVksBMYFM.
6135 'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
6137 'id': 'sfv_audio_pivot',
6138 'title': 'sfv_audio_pivot',
6141 'playlist_mincount': 50,
6144 # Channel with a real live tab (not to be mistaken with streams tab)
6145 # Do not treat like it should redirect to live stream
6146 'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
6148 'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
6149 'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
6152 'playlist_mincount': 20,
6154 # Tab name is not the same as tab id
6155 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
6157 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6158 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
6161 'playlist_mincount': 8,
6163 # Home tab id is literally home. Not to get mistaken with featured
6164 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
6166 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6167 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
6170 'playlist_mincount': 8,
6172 # Should get three playlists for videos, shorts and streams tabs
6173 'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6175 'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6176 'title': 'Polka Ch. 尾丸ポルカ',
6177 'channel_follower_count': int,
6178 'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6179 'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6180 'description': 'md5:e56b74b5bb7e9c701522162e9abfb822',
6181 'channel': 'Polka Ch. 尾丸ポルカ',
6183 'uploader_url': 'https://www.youtube.com/@OmaruPolka',
6184 'uploader': 'Polka Ch. 尾丸ポルカ',
6185 'uploader_id': '@OmaruPolka',
6187 'playlist_count': 3,
6189 # Shorts tab with channel with handle
6190 # TODO: fix channel description
6191 'url': 'https://www.youtube.com/@NotJustBikes/shorts',
6193 'id': 'UC0intLFzLaudFG-xAvUEO-A',
6194 'title': 'Not Just Bikes - Shorts',
6196 'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
6197 'description': 'md5:26bc55af26855a608a5cf89dfa595c8d',
6198 'channel_follower_count': int,
6199 'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
6200 'channel': 'Not Just Bikes',
6201 'uploader_url': 'https://www.youtube.com/@NotJustBikes',
6202 'uploader': 'Not Just Bikes',
6203 'uploader_id': '@NotJustBikes',
6205 'playlist_mincount': 10,
6208 'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
6210 'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6211 'title': '中村悠一 - Live',
6213 'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6214 'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
6216 'channel_follower_count': int,
6217 'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
6218 'uploader_url': 'https://www.youtube.com/@Yuichi-Nakamura',
6219 'uploader_id': '@Yuichi-Nakamura',
6222 'playlist_mincount': 60,
6224 # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
6225 # See test_youtube_lists
6226 'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
6227 'only_matching': True,
6229 # No uploads and no UCID given. Should fail with no uploads error
6230 # See test_youtube_lists
6231 'url': 'https://www.youtube.com/news',
6232 'only_matching': True
6234 # No videos tab but has a shorts tab
6235 'url': 'https://www.youtube.com/c/TKFShorts',
6237 'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6238 'title': 'Shorts Break - Shorts',
6240 'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6241 'channel': 'Shorts Break',
6242 'description': 'md5:6de33c5e7ba686e5f3efd4e19c7ef499',
6243 'channel_follower_count': int,
6244 'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
6245 'uploader_url': 'https://www.youtube.com/@ShortsBreak_Official',
6246 'uploader': 'Shorts Break',
6247 'uploader_id': '@ShortsBreak_Official',
6249 'playlist_mincount': 30,
6251 # Trending Now Tab. tab id is empty
6252 'url': 'https://www.youtube.com/feed/trending',
6255 'title': 'trending - Now',
6258 'playlist_mincount': 30,
6260 # Trending Gaming Tab. tab id is empty
6261 'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
6264 'title': 'trending - Gaming',
6267 'playlist_mincount': 30,
6269 # Shorts url result in shorts tab
6270 # TODO: Fix channel id extraction
6271 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
6273 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6274 'title': 'cole-dlp-test-acc - Shorts',
6275 'channel': 'cole-dlp-test-acc',
6276 'description': 'test description',
6277 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6278 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6280 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6281 'uploader_id': '@coletdjnz',
6282 'uploader': 'cole-dlp-test-acc',
6286 # Channel data is not currently available for short renderers (as of 2023-03-01)
6288 'ie_key': 'Youtube',
6289 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
6290 'id': 'sSM9J5YH_60',
6291 'title': 'SHORT short',
6296 'params': {'extract_flat': True}
,
6298 # Live video status should be extracted
6299 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
6301 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6302 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live', # TODO, should be Minecraft - Live or Minecraft - Topic - Live
6308 'ie_key': 'Youtube',
6309 'url': 'startswith:https://www.youtube.com/watch?v=',
6312 'live_status': 'is_live',
6315 'concurrent_view_count': int,
6318 'uploader_url': str,
6320 'channel_is_verified': bool, # this will keep changing
6323 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6324 'playlist_mincount': 1
6326 # Channel renderer metadata. Contains number of videos on the channel
6327 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/channels',
6329 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6330 'title': 'cole-dlp-test-acc - Channels',
6331 'channel': 'cole-dlp-test-acc',
6332 'description': 'test description',
6333 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6334 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6336 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6337 'uploader_id': '@coletdjnz',
6338 'uploader': 'cole-dlp-test-acc',
6343 'ie_key': 'YoutubeTab',
6344 'url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6345 'id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6346 'channel_id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6347 'title': 'PewDiePie',
6348 'channel': 'PewDiePie',
6349 'channel_url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6351 'channel_follower_count': int,
6352 'playlist_count': int,
6353 'uploader': 'PewDiePie',
6354 'uploader_url': 'https://www.youtube.com/@PewDiePie',
6355 'uploader_id': '@PewDiePie',
6356 'channel_is_verified': True,
6359 'params': {'extract_flat': True}
,
6361 'url': 'https://www.youtube.com/@3blue1brown/about',
6363 'id': 'UCYO_jab_esuFRV4b17AJtAw',
6364 'tags': ['Mathematics'],
6365 'title': '3Blue1Brown - About',
6366 'channel_follower_count': int,
6367 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
6368 'channel': '3Blue1Brown',
6370 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
6371 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
6372 'uploader_url': 'https://www.youtube.com/@3blue1brown',
6373 'uploader_id': '@3blue1brown',
6374 'uploader': '3Blue1Brown',
6375 'channel_is_verified': True,
6377 'playlist_count': 0,
6379 # Podcasts tab, with rich entry playlistRenderers
6380 'url': 'https://www.youtube.com/@99percentinvisiblepodcast/podcasts',
6382 'id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6383 'channel_id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6384 'uploader_url': 'https://www.youtube.com/@99percentinvisiblepodcast',
6385 'description': 'md5:3a0ed38f1ad42a68ef0428c04a15695c',
6386 'title': '99 Percent Invisible - Podcasts',
6387 'uploader': '99 Percent Invisible',
6388 'channel_follower_count': int,
6389 'channel_url': 'https://www.youtube.com/channel/UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6391 'channel': '99 Percent Invisible',
6392 'uploader_id': '@99percentinvisiblepodcast',
6394 'playlist_count': 1,
6396 # Releases tab, with rich entry playlistRenderers (same as Podcasts tab)
6397 'url': 'https://www.youtube.com/@AHimitsu/releases',
6399 'id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6400 'channel': 'A Himitsu',
6401 'uploader_url': 'https://www.youtube.com/@AHimitsu',
6402 'title': 'A Himitsu - Releases',
6403 'uploader_id': '@AHimitsu',
6404 'uploader': 'A Himitsu',
6405 'channel_id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6407 'description': 'I make music',
6408 'channel_url': 'https://www.youtube.com/channel/UCgFwu-j5-xNJml2FtTrrB3A',
6409 'channel_follower_count': int,
6410 'channel_is_verified': True,
6412 'playlist_mincount': 10,
6414 # Playlist with only shorts, shown as reel renderers
6415 # FIXME: future: YouTube currently doesn't give continuation for this,
6417 'url': 'https://www.youtube.com/playlist?list=UUxqPAgubo4coVn9Lx1FuKcg',
6419 'id': 'UUxqPAgubo4coVn9Lx1FuKcg',
6420 'channel_url': 'https://www.youtube.com/channel/UCxqPAgubo4coVn9Lx1FuKcg',
6422 'uploader_id': '@BangyShorts',
6424 'uploader_url': 'https://www.youtube.com/@BangyShorts',
6425 'channel_id': 'UCxqPAgubo4coVn9Lx1FuKcg',
6426 'channel': 'Bangy Shorts',
6427 'uploader': 'Bangy Shorts',
6429 'availability': 'public',
6430 'modified_date': '20230626',
6431 'title': 'Uploads from Bangy Shorts',
6433 'playlist_mincount': 100,
6434 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6438 def suitable(cls
, url
):
6439 return False if YoutubeIE
.suitable(url
) else super().suitable(url
)
6441 _URL_RE
= re
.compile(rf
'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
6443 def _get_url_mobj(self
, url
):
6444 mobj
= self
._URL
_RE
.match(url
).groupdict()
6445 mobj
.update((k
, '') for k
, v
in mobj
.items() if v
is None)
6448 def _extract_tab_id_and_name(self
, tab
, base_url
='https://www.youtube.com'):
6449 tab_name
= (tab
.get('title') or '').lower()
6450 tab_url
= urljoin(base_url
, traverse_obj(
6451 tab
, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
6453 tab_id
= (tab_url
and self
._get
_url
_mobj
(tab_url
)['tab'][1:]
6454 or traverse_obj(tab
, 'tabIdentifier', expected_type
=str))
6457 'TAB_ID_SPONSORSHIPS': 'membership',
6458 }.get(tab_id
, tab_id
), tab_name
6460 # Fallback to tab name if we cannot get the tab id.
6461 # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6462 # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6464 self
.write_debug(f
'Falling back to selected tab name: {tab_name}')
6468 }.get(tab_name
, tab_name
), tab_name
6470 def _has_tab(self
, tabs
, tab_id
):
6471 return any(self
._extract
_tab
_id
_and
_name
(tab
)[0] == tab_id
for tab
in tabs
)
6473 @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6474 def _real_extract(self
, url
, smuggled_data
):
6475 item_id
= self
._match
_id
(url
)
6476 url
= urllib
.parse
.urlunparse(
6477 urllib
.parse
.urlparse(url
)._replace
(netloc
='www.youtube.com'))
6478 compat_opts
= self
.get_param('compat_opts', [])
6480 mobj
= self
._get
_url
_mobj
(url
)
6481 pre
, tab
, post
, is_channel
= mobj
['pre'], mobj
['tab'], mobj
['post'], not mobj
['not_channel']
6482 if is_channel
and smuggled_data
.get('is_music_url'):
6483 if item_id
[:2] == 'VL': # Youtube music VL channels have an equivalent playlist
6484 return self
.url_result(
6485 f
'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE
, item_id
[2:])
6486 elif item_id
[:2] == 'MP': # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6487 mdata
= self
._extract
_tab
_endpoint
(
6488 f
'https://music.youtube.com/channel/{item_id}', item_id
, default_client
='web_music')
6489 murl
= traverse_obj(mdata
, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6490 get_all
=False, expected_type
=str)
6492 raise ExtractorError('Failed to resolve album to playlist')
6493 return self
.url_result(murl
, YoutubeTabIE
)
6494 elif mobj
['channel_type'] == 'browse': # Youtube music /browse/ should be changed to /channel/
6495 return self
.url_result(
6496 f
'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE
, item_id
)
6498 original_tab_id
, display_id
= tab
[1:], f
'{item_id}{tab}'
6499 if is_channel
and not tab
and 'no-youtube-channel-redirect' not in compat_opts
:
6500 url
= f
'{pre}/videos{post}'
6501 if smuggled_data
.get('is_music_url'):
6502 self
.report_warning(f
'YouTube Music is not directly supported. Redirecting to {url}')
6504 # Handle both video/playlist URLs
6506 video_id
, playlist_id
= [traverse_obj(qs
, (key
, 0)) for key
in ('v', 'list')]
6507 if not video_id
and mobj
['not_channel'].startswith('watch'):
6509 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6510 raise ExtractorError('A video URL was given without video ID', expected
=True)
6511 # Common mistake: https://www.youtube.com/watch?list=playlist_id
6512 self
.report_warning(f
'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6513 return self
.url_result(
6514 f
'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE
, playlist_id
)
6516 if not self
._yes
_playlist
(playlist_id
, video_id
):
6517 return self
.url_result(
6518 f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6520 data
, ytcfg
= self
._extract
_data
(url
, display_id
)
6522 # YouTube may provide a non-standard redirect to the regional channel
6523 # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6524 # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6525 redirect_url
= traverse_obj(
6526 data
, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all
=False)
6527 if redirect_url
and 'no-youtube-channel-redirect' not in compat_opts
:
6528 redirect_url
= ''.join((urljoin('https://www.youtube.com', redirect_url
), tab
, post
))
6529 self
.to_screen(f
'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6530 return self
.url_result(redirect_url
, YoutubeTabIE
)
6532 tabs
, extra_tabs
= self
._extract
_tab
_renderers
(data
), []
6533 if is_channel
and tabs
and 'no-youtube-channel-redirect' not in compat_opts
:
6534 selected_tab
= self
._extract
_selected
_tab
(tabs
)
6535 selected_tab_id
, selected_tab_name
= self
._extract
_tab
_id
_and
_name
(selected_tab
, url
) # NB: Name may be translated
6536 self
.write_debug(f
'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6538 if not original_tab_id
and selected_tab_name
:
6539 self
.to_screen('Downloading all uploads of the channel. '
6540 'To download only the videos in a specific tab, pass the tab\'s URL')
6541 if self
._has
_tab
(tabs
, 'streams'):
6542 extra_tabs
.append(''.join((pre
, '/streams', post
)))
6543 if self
._has
_tab
(tabs
, 'shorts'):
6544 extra_tabs
.append(''.join((pre
, '/shorts', post
)))
6545 # XXX: Members-only tab should also be extracted
6547 if not extra_tabs
and selected_tab_id
!= 'videos':
6548 # Channel does not have streams, shorts or videos tabs
6549 if item_id
[:2] != 'UC':
6550 raise ExtractorError('This channel has no uploads', expected
=True)
6552 # Topic channels don't have /videos. Use the equivalent playlist instead
6553 pl_id
= f
'UU{item_id[2:]}'
6554 pl_url
= f
'https://www.youtube.com/playlist?list={pl_id}'
6556 data
, ytcfg
= self
._extract
_data
(pl_url
, pl_id
, ytcfg
=ytcfg
, fatal
=True, webpage_fatal
=True)
6557 except ExtractorError
:
6558 raise ExtractorError('This channel has no uploads', expected
=True)
6560 item_id
, url
= pl_id
, pl_url
6562 f
'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6564 elif extra_tabs
and selected_tab_id
!= 'videos':
6565 # When there are shorts/live tabs but not videos tab
6566 url
, data
= f
'{pre}{post}', None
6568 elif (original_tab_id
or 'videos') != selected_tab_id
:
6569 if original_tab_id
== 'live':
6570 # Live tab should have redirected to the video
6571 # Except in the case the channel has an actual live tab
6572 # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6573 raise UserNotLive(video_id
=item_id
)
6574 elif selected_tab_name
:
6575 raise ExtractorError(f
'This channel does not have a {original_tab_id} tab', expected
=True)
6577 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6578 url
= f
'{pre}{post}'
6580 # YouTube sometimes provides a button to reload playlist with unavailable videos.
6581 if 'no-youtube-unavailable-videos' not in compat_opts
:
6582 data
= self
._reload
_with
_unavailable
_videos
(display_id
, data
, ytcfg
) or data
6583 self
._extract
_and
_report
_alerts
(data
, only_once
=True)
6585 tabs
, entries
= self
._extract
_tab
_renderers
(data
), []
6587 entries
= [self
._extract
_from
_tabs
(item_id
, ytcfg
, data
, tabs
)]
6589 'extractor_key': YoutubeTabIE
.ie_key(),
6590 'extractor': YoutubeTabIE
.IE_NAME
,
6593 if self
.get_param('playlist_items') == '0':
6594 entries
.extend(self
.url_result(u
, YoutubeTabIE
) for u
in extra_tabs
)
6595 else: # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6596 entries
.extend(map(self
._real
_extract
, extra_tabs
))
6598 if len(entries
) == 1:
6601 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
6602 uploads_url
= 'the Uploads (UU) playlist URL'
6603 if try_get(metadata
, lambda x
: x
['channel_id'].startswith('UC')):
6604 uploads_url
= f
'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6606 'Downloading as multiple playlists, separated by tabs. '
6607 f
'To download as a single playlist instead, pass {uploads_url}')
6608 return self
.playlist_result(entries
, item_id
, **metadata
)
6611 playlist
= traverse_obj(
6612 data
, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type
=dict)
6614 return self
._extract
_from
_playlist
(item_id
, url
, data
, playlist
, ytcfg
)
6616 video_id
= traverse_obj(
6617 data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str) or video_id
6619 if tab
!= '/live': # live tab is expected to redirect to video
6620 self
.report_warning(f
'Unable to recognize playlist. Downloading just video {video_id}')
6621 return self
.url_result(f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6623 raise ExtractorError('Unable to recognize tab page')
6626 class YoutubePlaylistIE(InfoExtractor
):
6627 IE_DESC
= 'YouTube playlists'
6628 _VALID_URL
= r
'''(?x)(?:
6633 youtube(?:kids)?\.com|
6638 (?P<id>%(playlist_id)s)
6640 'playlist_id': YoutubeBaseInfoExtractor
._PLAYLIST
_ID
_RE
,
6641 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
6643 IE_NAME
= 'youtube:playlist'
6645 'note': 'issue #673',
6646 'url': 'PLBB231211A4F62143',
6648 'title': '[OLD]Team Fortress 2 (Class-based LP)',
6649 'id': 'PLBB231211A4F62143',
6650 'uploader': 'Wickman',
6651 'uploader_id': '@WickmanVT',
6652 'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6654 'uploader_url': 'https://www.youtube.com/@WickmanVT',
6655 'modified_date': r
're:\d{8}',
6656 'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6657 'channel': 'Wickman',
6659 'channel_url': 'https://www.youtube.com/channel/UCKSpbfbl5kRQpTdL7kMc-1Q',
6660 'availability': 'public',
6662 'playlist_mincount': 29,
6664 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6666 'title': 'YDL_safe_search',
6667 'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6669 'playlist_count': 2,
6670 'skip': 'This playlist is private',
6673 'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6674 'playlist_count': 4,
6677 'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6678 'uploader': 'milan',
6679 'uploader_id': '@milan5503',
6681 'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6683 'modified_date': '20140919',
6686 'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6687 'uploader_url': 'https://www.youtube.com/@milan5503',
6688 'availability': 'public',
6690 'expected_warnings': [r
'[Uu]navailable videos? (is|are|will be) hidden'],
6692 'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6693 'playlist_mincount': 455,
6695 'title': '2018 Chinese New Singles (11/6 updated)',
6696 'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6698 'uploader_id': '@music_king',
6699 'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6702 'channel_url': 'https://www.youtube.com/channel/UC21nz3_MesPLqtDqwdvnoxA',
6704 'uploader_url': 'https://www.youtube.com/@music_king',
6705 'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6706 'modified_date': r
're:\d{8}',
6707 'availability': 'public',
6709 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6711 'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6712 'only_matching': True,
6714 # music album playlist
6715 'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6716 'only_matching': True,
6720 def suitable(cls
, url
):
6721 if YoutubeTabIE
.suitable(url
):
6723 from ..utils
import parse_qs
6725 if qs
.get('v', [None])[0]:
6727 return super().suitable(url
)
6729 def _real_extract(self
, url
):
6730 playlist_id
= self
._match
_id
(url
)
6731 is_music_url
= YoutubeBaseInfoExtractor
.is_music_url(url
)
6732 url
= update_url_query(
6733 'https://www.youtube.com/playlist',
6734 parse_qs(url
) or {'list': playlist_id}
)
6736 url
= smuggle_url(url
, {'is_music_url': True}
)
6737 return self
.url_result(url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6740 class YoutubeYtBeIE(InfoExtractor
):
6741 IE_DESC
= 'youtu.be'
6742 _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}
6744 'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6746 'id': 'yeWKywCrFtk',
6748 'title': 'Small Scale Baler and Braiding Rugs',
6749 'uploader': 'Backus-Page House Museum',
6750 'uploader_id': '@backuspagemuseum',
6751 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/@backuspagemuseum',
6752 'upload_date': '20161008',
6753 'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6754 'categories': ['Nonprofits & Activism'],
6758 'playable_in_embed': True,
6759 'thumbnail': r
're:^https?://.*\.webp',
6760 'channel': 'Backus-Page House Museum',
6761 'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6762 'live_status': 'not_live',
6764 'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6765 'availability': 'public',
6767 'comment_count': int,
6768 'channel_follower_count': int
6772 'skip_download': True,
6775 'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6776 'only_matching': True,
6779 def _real_extract(self
, url
):
6780 mobj
= self
._match
_valid
_url
(url
)
6781 video_id
= mobj
.group('id')
6782 playlist_id
= mobj
.group('playlist_id')
6783 return self
.url_result(
6784 update_url_query('https://www.youtube.com/watch', {
6786 'list': playlist_id
,
6787 'feature': 'youtu.be',
6788 }), ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6791 class YoutubeLivestreamEmbedIE(InfoExtractor
):
6792 IE_DESC
= 'YouTube livestream embeds'
6793 _VALID_URL
= r
'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6795 'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6796 'only_matching': True,
6799 def _real_extract(self
, url
):
6800 channel_id
= self
._match
_id
(url
)
6801 return self
.url_result(
6802 f
'https://www.youtube.com/channel/{channel_id}/live',
6803 ie
=YoutubeTabIE
.ie_key(), video_id
=channel_id
)
6806 class YoutubeYtUserIE(InfoExtractor
):
6807 IE_DESC
= 'YouTube user videos; "ytuser:" prefix'
6808 IE_NAME
= 'youtube:user'
6809 _VALID_URL
= r
'ytuser:(?P<id>.+)'
6811 'url': 'ytuser:phihag',
6812 'only_matching': True,
6815 def _real_extract(self
, url
):
6816 user_id
= self
._match
_id
(url
)
6817 return self
.url_result(f
'https://www.youtube.com/user/{user_id}', YoutubeTabIE
, user_id
)
6820 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor
):
6821 IE_NAME
= 'youtube:favorites'
6822 IE_DESC
= 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6823 _VALID_URL
= r
':ytfav(?:ou?rite)?s?'
6824 _LOGIN_REQUIRED
= True
6827 'only_matching': True,
6829 'url': ':ytfavorites',
6830 'only_matching': True,
6833 def _real_extract(self
, url
):
6834 return self
.url_result(
6835 'https://www.youtube.com/playlist?list=LL',
6836 ie
=YoutubeTabIE
.ie_key())
6839 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor
):
6840 IE_NAME
= 'youtube:notif'
6841 IE_DESC
= 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6842 _VALID_URL
= r
':ytnotif(?:ication)?s?'
6843 _LOGIN_REQUIRED
= True
6846 'only_matching': True,
6848 'url': ':ytnotifications',
6849 'only_matching': True,
6852 def _extract_notification_menu(self
, response
, continuation_list
):
6853 notification_list
= traverse_obj(
6855 ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6856 ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6857 expected_type
=list) or []
6858 continuation_list
[0] = None
6859 for item
in notification_list
:
6860 entry
= self
._extract
_notification
_renderer
(item
.get('notificationRenderer'))
6863 continuation
= item
.get('continuationItemRenderer')
6865 continuation_list
[0] = continuation
6867 def _extract_notification_renderer(self
, notification
):
6868 video_id
= traverse_obj(
6869 notification
, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str)
6870 url
= f
'https://www.youtube.com/watch?v={video_id}'
6873 browse_ep
= traverse_obj(
6874 notification
, ('navigationEndpoint', 'browseEndpoint'), expected_type
=dict)
6875 channel_id
= self
.ucid_or_none(traverse_obj(browse_ep
, 'browseId', expected_type
=str))
6876 post_id
= self
._search
_regex
(
6877 r
'/post/(.+)', traverse_obj(browse_ep
, 'canonicalBaseUrl', expected_type
=str),
6878 'post id', default
=None)
6879 if not channel_id
or not post_id
:
6881 # The direct /post url redirects to this in the browser
6882 url
= f
'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
6884 channel
= traverse_obj(
6885 notification
, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
6887 notification_title
= self
._get
_text
(notification
, 'shortMessage')
6888 if notification_title
:
6889 notification_title
= notification_title
.replace('\xad', '') # remove soft hyphens
6890 # TODO: handle recommended videos
6891 title
= self
._search
_regex
(
6892 rf
'{re.escape(channel or "")}[^:]+: (.+)', notification_title
,
6893 'video title', default
=None)
6894 timestamp
= (self
._parse
_time
_text
(self
._get
_text
(notification
, 'sentTimeText'))
6895 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
6900 'ie_key': (YoutubeIE
if video_id
else YoutubeTabIE
).ie_key(),
6901 'video_id': video_id
,
6903 'channel_id': channel_id
,
6905 'uploader': channel
,
6906 'thumbnails': self
._extract
_thumbnails
(notification
, 'videoThumbnail'),
6907 'timestamp': timestamp
,
6910 def _notification_menu_entries(self
, ytcfg
):
6911 continuation_list
= [None]
6913 for page
in itertools
.count(1):
6914 ctoken
= traverse_obj(
6915 continuation_list
, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type
=str)
6916 response
= self
._extract
_response
(
6917 item_id
=f
'page {page}', query
={'ctoken': ctoken}
if ctoken
else {}, ytcfg
=ytcfg
,
6918 ep
='notification/get_notification_menu', check_get_keys
='actions',
6919 headers
=self
.generate_api_headers(ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(response
)))
6920 yield from self
._extract
_notification
_menu
(response
, continuation_list
)
6921 if not continuation_list
[0]:
6924 def _real_extract(self
, url
):
6925 display_id
= 'notifications'
6926 ytcfg
= self
._download
_ytcfg
('web', display_id
) if not self
.skip_webpage
else {}
6927 self
._report
_playlist
_authcheck
(ytcfg
)
6928 return self
.playlist_result(self
._notification
_menu
_entries
(ytcfg
), display_id
, display_id
)
6931 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6932 IE_DESC
= 'YouTube search'
6933 IE_NAME
= 'youtube:search'
6934 _SEARCH_KEY
= 'ytsearch'
6935 _SEARCH_PARAMS
= 'EgIQAQ%3D%3D' # Videos only
6937 'url': 'ytsearch5:youtube-dl test video',
6938 'playlist_count': 5,
6940 'id': 'youtube-dl test video',
6941 'title': 'youtube-dl test video',
6946 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6947 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ ':date'
6948 _SEARCH_KEY
= 'ytsearchdate'
6949 IE_DESC
= 'YouTube search, newest videos first'
6950 _SEARCH_PARAMS
= 'CAISAhAB' # Videos only, sorted by date
6952 'url': 'ytsearchdate5:youtube-dl test video',
6953 'playlist_count': 5,
6955 'id': 'youtube-dl test video',
6956 'title': 'youtube-dl test video',
6961 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor
):
6962 IE_DESC
= 'YouTube search URLs with sorting and filter support'
6963 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ '_url'
6964 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6966 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
6967 'playlist_mincount': 5,
6969 'id': 'youtube-dl test video',
6970 'title': 'youtube-dl test video',
6973 'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
6974 'playlist_mincount': 5,
6980 'url': 'https://www.youtube.com/results?search_query=%23cats',
6981 'playlist_mincount': 1,
6985 # The test suite does not have support for nested playlists
6987 # 'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
6993 'url': 'https://www.youtube.com/results?search_query=kurzgesagt&sp=EgIQAg%253D%253D',
6996 'title': 'kurzgesagt',
7001 'id': 'UCsXVk37bltHxD1rDPwtNM8Q',
7002 'url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
7003 'ie_key': 'YoutubeTab',
7004 'channel': 'Kurzgesagt – In a Nutshell',
7005 'description': 'md5:4ae48dfa9505ffc307dad26342d06bfc',
7006 'title': 'Kurzgesagt – In a Nutshell',
7007 'channel_id': 'UCsXVk37bltHxD1rDPwtNM8Q',
7008 # No longer available for search as it is set to the handle.
7009 # 'playlist_count': int,
7010 'channel_url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
7012 'uploader_id': '@kurzgesagt',
7013 'uploader_url': 'https://www.youtube.com/@kurzgesagt',
7014 'uploader': 'Kurzgesagt – In a Nutshell',
7015 'channel_is_verified': True,
7016 'channel_follower_count': int,
7019 'params': {'extract_flat': True, 'playlist_items': '1'}
,
7020 'playlist_mincount': 1,
7022 'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
7023 'only_matching': True,
7026 def _real_extract(self
, url
):
7028 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7029 return self
.playlist_result(self
._search
_results
(query
, qs
.get('sp', (None,))[0]), query
, query
)
7032 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor
):
7033 IE_DESC
= 'YouTube music search URLs with selectable sections, e.g. #songs'
7034 IE_NAME
= 'youtube:music:search_url'
7035 _VALID_URL
= r
'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
7037 'url': 'https://music.youtube.com/search?q=royalty+free+music',
7038 'playlist_count': 16,
7040 'id': 'royalty free music',
7041 'title': 'royalty free music',
7044 'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
7045 'playlist_mincount': 30,
7047 'id': 'royalty free music - songs',
7048 'title': 'royalty free music - songs',
7050 'params': {'extract_flat': 'in_playlist'}
7052 'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
7053 'playlist_mincount': 30,
7055 'id': 'royalty free music - community playlists',
7056 'title': 'royalty free music - community playlists',
7058 'params': {'extract_flat': 'in_playlist'}
7062 'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
7063 'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
7064 'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
7065 'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
7066 'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
7067 'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
7070 def _real_extract(self
, url
):
7072 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7073 params
= qs
.get('sp', (None,))[0]
7075 section
= next((k
for k
, v
in self
._SECTIONS
.items() if v
== params
), params
)
7077 section
= urllib
.parse
.unquote_plus((url
.split('#') + [''])[1]).lower()
7078 params
= self
._SECTIONS
.get(section
)
7081 title
= join_nonempty(query
, section
, delim
=' - ')
7082 return self
.playlist_result(self
._search
_results
(query
, params
, default_client
='web_music'), title
, title
)
7085 class YoutubeFeedsInfoExtractor(InfoExtractor
):
7087 Base class for feed extractors
7088 Subclasses must re-define the _FEED_NAME property.
7090 _LOGIN_REQUIRED
= True
7091 _FEED_NAME
= 'feeds'
7093 def _real_initialize(self
):
7094 YoutubeBaseInfoExtractor
._check
_login
_required
(self
)
7098 return f
'youtube:{self._FEED_NAME}'
7100 def _real_extract(self
, url
):
7101 return self
.url_result(
7102 f
'https://www.youtube.com/feed/{self._FEED_NAME}', ie
=YoutubeTabIE
.ie_key())
7105 class YoutubeWatchLaterIE(InfoExtractor
):
7106 IE_NAME
= 'youtube:watchlater'
7107 IE_DESC
= 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
7108 _VALID_URL
= r
':ytwatchlater'
7110 'url': ':ytwatchlater',
7111 'only_matching': True,
7114 def _real_extract(self
, url
):
7115 return self
.url_result(
7116 'https://www.youtube.com/playlist?list=WL', ie
=YoutubeTabIE
.ie_key())
7119 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor
):
7120 IE_DESC
= 'YouTube recommended videos; ":ytrec" keyword'
7121 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
7122 _FEED_NAME
= 'recommended'
7123 _LOGIN_REQUIRED
= False
7126 'only_matching': True,
7128 'url': ':ytrecommended',
7129 'only_matching': True,
7131 'url': 'https://youtube.com',
7132 'only_matching': True,
7136 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor
):
7137 IE_DESC
= 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
7138 _VALID_URL
= r
':ytsub(?:scription)?s?'
7139 _FEED_NAME
= 'subscriptions'
7142 'only_matching': True,
7144 'url': ':ytsubscriptions',
7145 'only_matching': True,
7149 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor
):
7150 IE_DESC
= 'Youtube watch history; ":ythis" keyword (requires cookies)'
7151 _VALID_URL
= r
':ythis(?:tory)?'
7152 _FEED_NAME
= 'history'
7154 'url': ':ythistory',
7155 'only_matching': True,
7159 class YoutubeShortsAudioPivotIE(InfoExtractor
):
7160 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
7161 IE_NAME
= 'youtube:shorts:pivot:audio'
7162 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
7164 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
7165 'only_matching': True,
7169 def _generate_audio_pivot_params(video_id
):
7171 Generates sfv_audio_pivot browse params for this video id
7173 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
7174 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
7176 def _real_extract(self
, url
):
7177 video_id
= self
._match
_id
(url
)
7178 return self
.url_result(
7179 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
7183 class YoutubeTruncatedURLIE(InfoExtractor
):
7184 IE_NAME
= 'youtube:truncated_url'
7185 IE_DESC
= False # Do not list
7186 _VALID_URL
= r
'''(?x)
7188 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
7191 annotation_id=annotation_[^&]+|
7197 attribution_link\?a=[^&]+
7203 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
7204 'only_matching': True,
7206 'url': 'https://www.youtube.com/watch?',
7207 'only_matching': True,
7209 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
7210 'only_matching': True,
7212 'url': 'https://www.youtube.com/watch?feature=foo',
7213 'only_matching': True,
7215 'url': 'https://www.youtube.com/watch?hl=en-GB',
7216 'only_matching': True,
7218 'url': 'https://www.youtube.com/watch?t=2372',
7219 'only_matching': True,
7222 def _real_extract(self
, url
):
7223 raise ExtractorError(
7224 'Did you forget to quote the URL? Remember that & is a meta '
7225 'character in most shells, so you want to put the URL in quotes, '
7227 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
7228 ' or simply youtube-dl BaW_jenozKc .',
7232 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
7233 IE_NAME
= 'youtube:clip'
7234 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7236 # FIXME: Other metadata should be extracted from the clip, not from the base video
7237 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7239 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7241 'section_start': 29.0,
7242 'section_end': 39.7,
7245 'availability': 'public',
7246 'categories': ['Gaming'],
7247 'channel': 'Scott The Woz',
7248 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7249 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7250 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7252 'playable_in_embed': True,
7254 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7255 'title': 'Mobile Games on Console - Scott The Woz',
7256 'upload_date': '20210920',
7257 'uploader': 'Scott The Woz',
7258 'uploader_id': '@ScottTheWoz',
7259 'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7261 'live_status': 'not_live',
7262 'channel_follower_count': int,
7263 'chapters': 'count:20',
7264 'comment_count': int,
7265 'heatmap': 'count:100',
7269 def _real_extract(self
, url
):
7270 clip_id
= self
._match
_id
(url
)
7271 _
, data
= self
._extract
_webpage
(url
, clip_id
)
7273 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7275 raise ExtractorError('Unable to find video ID')
7277 clip_data
= traverse_obj(data
, (
7278 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7279 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7280 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7281 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
7284 '_type': 'url_transparent',
7285 'url': f
'https://www.youtube.com/watch?v={video_id}',
7286 'ie_key': YoutubeIE
.ie_key(),
7288 'section_start': int(clip_data
['startTimeMs']) / 1000,
7289 'section_end': int(clip_data
['endTimeMs']) / 1000,
7293 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor
):
7294 IE_NAME
= 'youtube:consent'
7295 IE_DESC
= False # Do not list
7296 _VALID_URL
= r
'https?://consent\.youtube\.com/m\?'
7298 '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',
7300 'id': 'qVv6vCqciTM',
7303 'uploader_id': '@sana_natori',
7304 'comment_count': int,
7305 'chapters': 'count:13',
7306 'upload_date': '20221223',
7307 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7308 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7309 'uploader_url': 'https://www.youtube.com/@sana_natori',
7311 'release_date': '20221223',
7312 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7313 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7315 'playable_in_embed': True,
7317 'availability': 'public',
7318 'channel_follower_count': int,
7319 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7320 'categories': ['Entertainment'],
7321 'live_status': 'was_live',
7322 'release_timestamp': 1671793345,
7323 'channel': 'さなちゃんねる',
7324 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7325 'uploader': 'さなちゃんねる',
7326 'channel_is_verified': True,
7327 'heatmap': 'count:100',
7329 'add_ie': ['Youtube'],
7330 'params': {'skip_download': 'Youtube'}
,
7333 def _real_extract(self
, url
):
7334 redirect_url
= url_or_none(parse_qs(url
).get('continue', [None])[-1])
7335 if not redirect_url
:
7336 raise ExtractorError('Invalid cookie consent redirect URL', expected
=True)
7337 return self
.url_result(redirect_url
)
7340 class YoutubeTruncatedIDIE(InfoExtractor
):
7341 IE_NAME
= 'youtube:truncated_id'
7342 IE_DESC
= False # Do not list
7343 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7346 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7347 'only_matching': True,
7350 def _real_extract(self
, url
):
7351 video_id
= self
._match
_id
(url
)
7352 raise ExtractorError(
7353 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',