21 from .common
import InfoExtractor
, SearchInfoExtractor
22 from .openload
import PhantomJSwrapper
23 from ..compat
import functools
24 from ..jsinterp
import JSInterpreter
25 from ..networking
.exceptions
import HTTPError
, network_exceptions
71 STREAMING_DATA_CLIENT_NAME
= '__yt_dlp_client'
72 # any clients starting with _ cannot be explicitly requested by the user
75 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
76 'INNERTUBE_CONTEXT': {
79 'clientVersion': '2.20220801.00.00',
82 'INNERTUBE_CONTEXT_CLIENT_NAME': 1,
85 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
86 'INNERTUBE_CONTEXT': {
88 'clientName': 'WEB_EMBEDDED_PLAYER',
89 'clientVersion': '1.20220731.00.00',
92 'INNERTUBE_CONTEXT_CLIENT_NAME': 56,
95 'INNERTUBE_API_KEY': 'AIzaSyC9XL3ZjWddXya6X74dJoCTL-WEYFDNX30',
96 'INNERTUBE_HOST': 'music.youtube.com',
97 'INNERTUBE_CONTEXT': {
99 'clientName': 'WEB_REMIX',
100 'clientVersion': '1.20220727.01.00',
103 'INNERTUBE_CONTEXT_CLIENT_NAME': 67,
106 'INNERTUBE_API_KEY': 'AIzaSyBUPetSUmoZL-OhlxA7wSac5XinrygCqMo',
107 'INNERTUBE_CONTEXT': {
109 'clientName': 'WEB_CREATOR',
110 'clientVersion': '1.20220726.00.00',
113 'INNERTUBE_CONTEXT_CLIENT_NAME': 62,
116 'INNERTUBE_API_KEY': 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w',
117 'INNERTUBE_CONTEXT': {
119 'clientName': 'ANDROID',
120 'clientVersion': '19.09.37',
121 'androidSdkVersion': 30,
122 'userAgent': 'com.google.android.youtube/19.09.37 (Linux; U; Android 11) gzip',
125 'INNERTUBE_CONTEXT_CLIENT_NAME': 3,
126 'REQUIRE_JS_PLAYER': False,
128 'android_embedded': {
129 'INNERTUBE_API_KEY': 'AIzaSyCjc_pVEDi4qsv5MtC2dMXzpIaDoRFLsxw',
130 'INNERTUBE_CONTEXT': {
132 'clientName': 'ANDROID_EMBEDDED_PLAYER',
133 'clientVersion': '19.09.37',
134 'androidSdkVersion': 30,
135 'userAgent': 'com.google.android.youtube/19.09.37 (Linux; U; Android 11) gzip',
138 'INNERTUBE_CONTEXT_CLIENT_NAME': 55,
139 'REQUIRE_JS_PLAYER': False,
142 'INNERTUBE_API_KEY': 'AIzaSyAOghZGza2MQSZkY_zfZ370N-PUdXEo8AI',
143 'INNERTUBE_CONTEXT': {
145 'clientName': 'ANDROID_MUSIC',
146 'clientVersion': '6.42.52',
147 'androidSdkVersion': 30,
148 'userAgent': 'com.google.android.apps.youtube.music/6.42.52 (Linux; U; Android 11) gzip',
151 'INNERTUBE_CONTEXT_CLIENT_NAME': 21,
152 'REQUIRE_JS_PLAYER': False,
155 'INNERTUBE_API_KEY': 'AIzaSyD_qjV8zaaUMehtLkrKFgVeSX_Iqbtyws8',
156 'INNERTUBE_CONTEXT': {
158 'clientName': 'ANDROID_CREATOR',
159 'clientVersion': '22.30.100',
160 'androidSdkVersion': 30,
161 'userAgent': 'com.google.android.apps.youtube.creator/22.30.100 (Linux; U; Android 11) gzip',
164 'INNERTUBE_CONTEXT_CLIENT_NAME': 14,
165 'REQUIRE_JS_PLAYER': False,
167 # iOS clients have HLS live streams. Setting device model to get 60fps formats.
168 # See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/680#issuecomment-1002724558
170 'INNERTUBE_API_KEY': 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc',
171 'INNERTUBE_CONTEXT': {
174 'clientVersion': '19.09.3',
175 'deviceModel': 'iPhone14,3',
176 'userAgent': 'com.google.ios.youtube/19.09.3 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)',
179 'INNERTUBE_CONTEXT_CLIENT_NAME': 5,
180 'REQUIRE_JS_PLAYER': False,
183 'INNERTUBE_CONTEXT': {
185 'clientName': 'IOS_MESSAGES_EXTENSION',
186 'clientVersion': '19.09.3',
187 'deviceModel': 'iPhone14,3',
188 'userAgent': 'com.google.ios.youtube/19.09.3 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)',
191 'INNERTUBE_CONTEXT_CLIENT_NAME': 66,
192 'REQUIRE_JS_PLAYER': False,
195 'INNERTUBE_API_KEY': 'AIzaSyBAETezhkwP0ZWA02RsqT1zu78Fpt0bC_s',
196 'INNERTUBE_CONTEXT': {
198 'clientName': 'IOS_MUSIC',
199 'clientVersion': '6.33.3',
200 'deviceModel': 'iPhone14,3',
201 'userAgent': 'com.google.ios.youtubemusic/6.33.3 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)',
204 'INNERTUBE_CONTEXT_CLIENT_NAME': 26,
205 'REQUIRE_JS_PLAYER': False,
208 'INNERTUBE_CONTEXT': {
210 'clientName': 'IOS_CREATOR',
211 'clientVersion': '22.33.101',
212 'deviceModel': 'iPhone14,3',
213 'userAgent': 'com.google.ios.ytcreator/22.33.101 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)',
216 'INNERTUBE_CONTEXT_CLIENT_NAME': 15,
217 'REQUIRE_JS_PLAYER': False,
219 # mweb has 'ultralow' formats
220 # See: https://github.com/yt-dlp/yt-dlp/pull/557
222 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
223 'INNERTUBE_CONTEXT': {
225 'clientName': 'MWEB',
226 'clientVersion': '2.20220801.00.00',
229 'INNERTUBE_CONTEXT_CLIENT_NAME': 2,
231 # This client can access age restricted videos (unless the uploader has disabled the 'allow embedding' option)
232 # See: https://github.com/zerodytrash/YouTube-Internal-Clients
234 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
235 'INNERTUBE_CONTEXT': {
237 'clientName': 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
238 'clientVersion': '2.0',
241 'INNERTUBE_CONTEXT_CLIENT_NAME': 85,
243 # This client has pre-merged video+audio 720p/1080p streams
245 'INNERTUBE_CONTEXT': {
247 'clientName': 'MEDIA_CONNECT_FRONTEND',
248 'clientVersion': '0.1',
251 'INNERTUBE_CONTEXT_CLIENT_NAME': 95,
256 def _split_innertube_client(client_name
):
257 variant
, *base
= client_name
.rsplit('.', 1)
259 return variant
, base
[0], variant
260 base
, *variant
= client_name
.split('_', 1)
261 return client_name
, base
, variant
[0] if variant
else None
264 def short_client_name(client_name
):
265 main
, *parts
= _split_innertube_client(client_name
)[0].replace('embedscreen', 'e_s').split('_')
266 return join_nonempty(main
[:4], ''.join(x
[0] for x
in parts
)).upper()
269 def build_innertube_clients():
271 'embedUrl': 'https://www.youtube.com/', # Can be any valid URL
273 BASE_CLIENTS
= ('ios', 'android', 'web', 'tv', 'mweb')
274 priority
= qualities(BASE_CLIENTS
[::-1])
276 for client
, ytcfg
in tuple(INNERTUBE_CLIENTS
.items()):
277 ytcfg
.setdefault('INNERTUBE_API_KEY', 'AIzaSyDCU8hByM-4DrUqRUYnGn-3llEO78bcxq8')
278 ytcfg
.setdefault('INNERTUBE_HOST', 'www.youtube.com')
279 ytcfg
.setdefault('REQUIRE_JS_PLAYER', True)
280 ytcfg
['INNERTUBE_CONTEXT']['client'].setdefault('hl', 'en')
282 _
, base_client
, variant
= _split_innertube_client(client
)
283 ytcfg
['priority'] = 10 * priority(base_client
)
286 INNERTUBE_CLIENTS
[f
'{client}_embedscreen'] = embedscreen
= copy
.deepcopy(ytcfg
)
287 embedscreen
['INNERTUBE_CONTEXT']['client']['clientScreen'] = 'EMBED'
288 embedscreen
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
289 embedscreen
['priority'] -= 3
290 elif variant
== 'embedded':
291 ytcfg
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
292 ytcfg
['priority'] -= 2
294 ytcfg
['priority'] -= 3
297 build_innertube_clients()
300 class BadgeType(enum
.Enum
):
301 AVAILABILITY_UNLISTED
= enum
.auto()
302 AVAILABILITY_PRIVATE
= enum
.auto()
303 AVAILABILITY_PUBLIC
= enum
.auto()
304 AVAILABILITY_PREMIUM
= enum
.auto()
305 AVAILABILITY_SUBSCRIPTION
= enum
.auto()
306 LIVE_NOW
= enum
.auto()
307 VERIFIED
= enum
.auto()
310 class YoutubeBaseInfoExtractor(InfoExtractor
):
311 """Provide base functions for Youtube extractors"""
314 r
'channel|c|user|playlist|watch|w|v|embed|e|live|watch_popup|clip|'
315 r
'shorts|movies|results|search|shared|hashtag|trending|explore|feed|feeds|'
316 r
'browse|oembed|get_video_info|iframe_api|s/player|source|'
317 r
'storefront|oops|index|account|t/terms|about|upload|signin|logout')
319 _PLAYLIST_ID_RE
= r
'(?:(?:PL|LL|EC|UU|FL|RD|UL|TL|PU|OLAK5uy_)[0-9A-Za-z-_]{10,}|RDMM|WL|LL|LM)'
321 # _NETRC_MACHINE = 'youtube'
323 # If True it will raise an error if no login info is provided
324 _LOGIN_REQUIRED
= False
327 # invidious-redirect websites
328 r
'(?:www\.)?redirect\.invidious\.io',
329 r
'(?:(?:www|dev)\.)?invidio\.us',
330 # Invidious instances taken from https://github.com/iv-org/documentation/blob/master/docs/instances.md
331 r
'(?:www\.)?invidious\.pussthecat\.org',
332 r
'(?:www\.)?invidious\.zee\.li',
333 r
'(?:www\.)?invidious\.ethibox\.fr',
334 r
'(?:www\.)?iv\.ggtyler\.dev',
335 r
'(?:www\.)?inv\.vern\.i2p',
336 r
'(?:www\.)?am74vkcrjp2d5v36lcdqgsj2m6x36tbrkhsruoegwfcizzabnfgf5zyd\.onion',
337 r
'(?:www\.)?inv\.riverside\.rocks',
338 r
'(?:www\.)?invidious\.silur\.me',
339 r
'(?:www\.)?inv\.bp\.projectsegfau\.lt',
340 r
'(?:www\.)?invidious\.g4c3eya4clenolymqbpgwz3q3tawoxw56yhzk4vugqrl6dtu3ejvhjid\.onion',
341 r
'(?:www\.)?invidious\.slipfox\.xyz',
342 r
'(?:www\.)?invidious\.esmail5pdn24shtvieloeedh7ehz3nrwcdivnfhfcedl7gf4kwddhkqd\.onion',
343 r
'(?:www\.)?inv\.vernccvbvyi5qhfzyqengccj7lkove6bjot2xhh5kajhwvidqafczrad\.onion',
344 r
'(?:www\.)?invidious\.tiekoetter\.com',
345 r
'(?:www\.)?iv\.odysfvr23q5wgt7i456o5t3trw2cw5dgn56vbjfbq2m7xsc5vqbqpcyd\.onion',
346 r
'(?:www\.)?invidious\.nerdvpn\.de',
347 r
'(?:www\.)?invidious\.weblibre\.org',
348 r
'(?:www\.)?inv\.odyssey346\.dev',
349 r
'(?:www\.)?invidious\.dhusch\.de',
350 r
'(?:www\.)?iv\.melmac\.space',
351 r
'(?:www\.)?watch\.thekitty\.zone',
352 r
'(?:www\.)?invidious\.privacydev\.net',
353 r
'(?:www\.)?ng27owmagn5amdm7l5s3rsqxwscl5ynppnis5dqcasogkyxcfqn7psid\.onion',
354 r
'(?:www\.)?invidious\.drivet\.xyz',
355 r
'(?:www\.)?vid\.priv\.au',
356 r
'(?:www\.)?euxxcnhsynwmfidvhjf6uzptsmh4dipkmgdmcmxxuo7tunp3ad2jrwyd\.onion',
357 r
'(?:www\.)?inv\.vern\.cc',
358 r
'(?:www\.)?invidious\.esmailelbob\.xyz',
359 r
'(?:www\.)?invidious\.sethforprivacy\.com',
360 r
'(?:www\.)?yt\.oelrichsgarcia\.de',
361 r
'(?:www\.)?yt\.artemislena\.eu',
362 r
'(?:www\.)?invidious\.flokinet\.to',
363 r
'(?:www\.)?invidious\.baczek\.me',
364 r
'(?:www\.)?y\.com\.sb',
365 r
'(?:www\.)?invidious\.epicsite\.xyz',
366 r
'(?:www\.)?invidious\.lidarshield\.cloud',
367 r
'(?:www\.)?yt\.funami\.tech',
368 r
'(?:www\.)?invidious\.3o7z6yfxhbw7n3za4rss6l434kmv55cgw2vuziwuigpwegswvwzqipyd\.onion',
369 r
'(?:www\.)?osbivz6guyeahrwp2lnwyjk2xos342h4ocsxyqrlaopqjuhwn2djiiyd\.onion',
370 r
'(?:www\.)?u2cvlit75owumwpy4dj2hsmvkq7nvrclkpht7xgyye2pyoxhpmclkrad\.onion',
371 # youtube-dl invidious instances list
372 r
'(?:(?:www|no)\.)?invidiou\.sh',
373 r
'(?:(?:www|fi)\.)?invidious\.snopyta\.org',
374 r
'(?:www\.)?invidious\.kabi\.tk',
375 r
'(?:www\.)?invidious\.mastodon\.host',
376 r
'(?:www\.)?invidious\.zapashcanon\.fr',
377 r
'(?:www\.)?(?:invidious(?:-us)?|piped)\.kavin\.rocks',
378 r
'(?:www\.)?invidious\.tinfoil-hat\.net',
379 r
'(?:www\.)?invidious\.himiko\.cloud',
380 r
'(?:www\.)?invidious\.reallyancient\.tech',
381 r
'(?:www\.)?invidious\.tube',
382 r
'(?:www\.)?invidiou\.site',
383 r
'(?:www\.)?invidious\.site',
384 r
'(?:www\.)?invidious\.xyz',
385 r
'(?:www\.)?invidious\.nixnet\.xyz',
386 r
'(?:www\.)?invidious\.048596\.xyz',
387 r
'(?:www\.)?invidious\.drycat\.fr',
388 r
'(?:www\.)?inv\.skyn3t\.in',
389 r
'(?:www\.)?tube\.poal\.co',
390 r
'(?:www\.)?tube\.connect\.cafe',
391 r
'(?:www\.)?vid\.wxzm\.sx',
392 r
'(?:www\.)?vid\.mint\.lgbt',
393 r
'(?:www\.)?vid\.puffyan\.us',
394 r
'(?:www\.)?yewtu\.be',
395 r
'(?:www\.)?yt\.elukerio\.org',
396 r
'(?:www\.)?yt\.lelux\.fi',
397 r
'(?:www\.)?invidious\.ggc-project\.de',
398 r
'(?:www\.)?yt\.maisputain\.ovh',
399 r
'(?:www\.)?ytprivate\.com',
400 r
'(?:www\.)?invidious\.13ad\.de',
401 r
'(?:www\.)?invidious\.toot\.koeln',
402 r
'(?:www\.)?invidious\.fdn\.fr',
403 r
'(?:www\.)?watch\.nettohikari\.com',
404 r
'(?:www\.)?invidious\.namazso\.eu',
405 r
'(?:www\.)?invidious\.silkky\.cloud',
406 r
'(?:www\.)?invidious\.exonip\.de',
407 r
'(?:www\.)?invidious\.riverside\.rocks',
408 r
'(?:www\.)?invidious\.blamefran\.net',
409 r
'(?:www\.)?invidious\.moomoo\.de',
410 r
'(?:www\.)?ytb\.trom\.tf',
411 r
'(?:www\.)?yt\.cyberhost\.uk',
412 r
'(?:www\.)?kgg2m7yk5aybusll\.onion',
413 r
'(?:www\.)?qklhadlycap4cnod\.onion',
414 r
'(?:www\.)?axqzx4s6s54s32yentfqojs3x5i7faxza6xo3ehd4bzzsg2ii4fv2iid\.onion',
415 r
'(?:www\.)?c7hqkpkpemu6e7emz5b4vyz7idjgdvgaaa3dyimmeojqbgpea3xqjoid\.onion',
416 r
'(?:www\.)?fz253lmuao3strwbfbmx46yu7acac2jz27iwtorgmbqlkurlclmancad\.onion',
417 r
'(?:www\.)?invidious\.l4qlywnpwqsluw65ts7md3khrivpirse744un3x7mlskqauz5pyuzgqd\.onion',
418 r
'(?:www\.)?owxfohz4kjyv25fvlqilyxast7inivgiktls3th44jhk3ej3i7ya\.b32\.i2p',
419 r
'(?:www\.)?4l2dgddgsrkf2ous66i6seeyi6etzfgrue332grh2n7madpwopotugyd\.onion',
420 r
'(?:www\.)?w6ijuptxiku4xpnnaetxvnkc5vqcdu7mgns2u77qefoixi63vbvnpnqd\.onion',
421 r
'(?:www\.)?kbjggqkzv65ivcqj6bumvp337z6264huv5kpkwuv6gu5yjiskvan7fad\.onion',
422 r
'(?:www\.)?grwp24hodrefzvjjuccrkw3mjq4tzhaaq32amf33dzpmuxe7ilepcmad\.onion',
423 r
'(?:www\.)?hpniueoejy4opn7bc4ftgazyqjoeqwlvh2uiku2xqku6zpoa4bf5ruid\.onion',
424 # piped instances from https://github.com/TeamPiped/Piped/wiki/Instances
425 r
'(?:www\.)?piped\.kavin\.rocks',
426 r
'(?:www\.)?piped\.tokhmi\.xyz',
427 r
'(?:www\.)?piped\.syncpundit\.io',
428 r
'(?:www\.)?piped\.mha\.fi',
429 r
'(?:www\.)?watch\.whatever\.social',
430 r
'(?:www\.)?piped\.garudalinux\.org',
431 r
'(?:www\.)?piped\.rivo\.lol',
432 r
'(?:www\.)?piped-libre\.kavin\.rocks',
433 r
'(?:www\.)?yt\.jae\.fi',
434 r
'(?:www\.)?piped\.mint\.lgbt',
436 r
'(?:www\.)?piped\.esmailelbob\.xyz',
437 r
'(?:www\.)?piped\.projectsegfau\.lt',
438 r
'(?:www\.)?piped\.privacydev\.net',
439 r
'(?:www\.)?piped\.palveluntarjoaja\.eu',
440 r
'(?:www\.)?piped\.smnz\.de',
441 r
'(?:www\.)?piped\.adminforge\.de',
442 r
'(?:www\.)?watch\.whatevertinfoil\.de',
443 r
'(?:www\.)?piped\.qdi\.fi',
444 r
'(?:(?:www|cf)\.)?piped\.video',
445 r
'(?:www\.)?piped\.aeong\.one',
446 r
'(?:www\.)?piped\.moomoo\.me',
447 r
'(?:www\.)?piped\.chauvet\.pro',
448 r
'(?:www\.)?watch\.leptons\.xyz',
449 r
'(?:www\.)?pd\.vern\.cc',
450 r
'(?:www\.)?piped\.hostux\.net',
451 r
'(?:www\.)?piped\.lunar\.icu',
452 # Hyperpipe instances from https://hyperpipe.codeberg.page/
453 r
'(?:www\.)?hyperpipe\.surge\.sh',
454 r
'(?:www\.)?hyperpipe\.esmailelbob\.xyz',
455 r
'(?:www\.)?listen\.whatever\.social',
456 r
'(?:www\.)?music\.adminforge\.de',
459 # extracted from account/account_menu ep
460 # XXX: These are the supported YouTube UI and API languages,
461 # which is slightly different from languages supported for translation in YouTube studio
462 _SUPPORTED_LANG_CODES
= [
463 'af', 'az', 'id', 'ms', 'bs', 'ca', 'cs', 'da', 'de', 'et', 'en-IN', 'en-GB', 'en', 'es',
464 'es-419', 'es-US', 'eu', 'fil', 'fr', 'fr-CA', 'gl', 'hr', 'zu', 'is', 'it', 'sw', 'lv',
465 'lt', 'hu', 'nl', 'no', 'uz', 'pl', 'pt-PT', 'pt', 'ro', 'sq', 'sk', 'sl', 'sr-Latn', 'fi',
466 'sv', 'vi', 'tr', 'be', 'bg', 'ky', 'kk', 'mk', 'mn', 'ru', 'sr', 'uk', 'el', 'hy', 'iw',
467 'ur', 'ar', 'fa', 'ne', 'mr', 'hi', 'as', 'bn', 'pa', 'gu', 'or', 'ta', 'te', 'kn', 'ml',
468 'si', 'th', 'lo', 'my', 'ka', 'am', 'km', 'zh-CN', 'zh-TW', 'zh-HK', 'ja', 'ko',
471 _IGNORED_WARNINGS
= {'Unavailable videos will be hidden during playback'}
473 _YT_HANDLE_RE
= r
'@[\w.-]{3,30}' # https://support.google.com/youtube/answer/11585688?hl=en
474 _YT_CHANNEL_UCID_RE
= r
'UC[\w-]{22}'
476 def ucid_or_none(self
, ucid
):
477 return self
._search
_regex
(rf
'^({self._YT_CHANNEL_UCID_RE})$', ucid
, 'UC-id', default
=None)
479 def handle_or_none(self
, handle
):
480 return self
._search
_regex
(rf
'^({self._YT_HANDLE_RE})$', handle
, '@-handle', default
=None)
482 def handle_from_url(self
, url
):
483 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_HANDLE_RE})',
484 url
, 'channel handle', default
=None)
486 def ucid_from_url(self
, url
):
487 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_CHANNEL_UCID_RE})',
488 url
, 'channel id', default
=None)
490 @functools.cached_property
491 def _preferred_lang(self
):
493 Returns a language code supported by YouTube for the user preferred language.
494 Returns None if no preferred language set.
496 preferred_lang
= self
._configuration
_arg
('lang', ie_key
='Youtube', casesense
=True, default
=[''])[0]
497 if not preferred_lang
:
499 if preferred_lang
not in self
._SUPPORTED
_LANG
_CODES
:
500 raise ExtractorError(
501 f
'Unsupported language code: {preferred_lang}. Supported language codes (case-sensitive): {join_nonempty(*self._SUPPORTED_LANG_CODES, delim=", ")}.',
503 elif preferred_lang
!= 'en':
505 f
'Preferring "{preferred_lang}" translated fields. Note that some metadata extraction may fail or be incorrect.')
506 return preferred_lang
508 def _initialize_consent(self
):
509 cookies
= self
._get
_cookies
('https://www.youtube.com/')
510 if cookies
.get('__Secure-3PSID'):
512 socs
= cookies
.get('SOCS')
513 if socs
and not socs
.value
.startswith('CAA'): # not consented
515 self
._set
_cookie
('.youtube.com', 'SOCS', 'CAI', secure
=True) # accept all (required for mixes)
517 def _initialize_pref(self
):
518 cookies
= self
._get
_cookies
('https://www.youtube.com/')
519 pref_cookie
= cookies
.get('PREF')
523 pref
= dict(urllib
.parse
.parse_qsl(pref_cookie
.value
))
525 self
.report_warning('Failed to parse user PREF cookie' + bug_reports_message())
526 pref
.update({'hl': self._preferred_lang or 'en', 'tz': 'UTC'}
)
527 self
._set
_cookie
('.youtube.com', name
='PREF', value
=urllib
.parse
.urlencode(pref
))
529 def _real_initialize(self
):
530 self
._initialize
_pref
()
531 self
._initialize
_consent
()
532 self
._check
_login
_required
()
534 def _check_login_required(self
):
535 if self
._LOGIN
_REQUIRED
and not self
._cookies
_passed
:
536 self
.raise_login_required('Login details are needed to download this content', method
='cookies')
538 _YT_INITIAL_DATA_RE
= r
'(?:window\s*\[\s*["\']ytInitialData
["\']\s*\]|ytInitialData)\s*='
539 _YT_INITIAL_PLAYER_RESPONSE_RE = r'ytInitialPlayerResponse\s*='
541 def _get_default_ytcfg(self, client='web'):
542 return copy.deepcopy(INNERTUBE_CLIENTS[client])
544 def _get_innertube_host(self, client='web'):
545 return INNERTUBE_CLIENTS[client]['INNERTUBE_HOST']
547 def _ytcfg_get_safe(self, ytcfg, getter, expected_type=None, default_client='web'):
548 # try_get but with fallback to default ytcfg client values when present
549 _func = lambda y: try_get(y, getter, expected_type)
550 return _func(ytcfg) or _func(self._get_default_ytcfg(default_client))
552 def _extract_client_name(self, ytcfg, default_client='web'):
553 return self._ytcfg_get_safe(
554 ytcfg, (lambda x: x['INNERTUBE_CLIENT_NAME'],
555 lambda x: x['INNERTUBE_CONTEXT']['client']['clientName']), str, default_client)
557 def _extract_client_version(self, ytcfg, default_client='web'):
558 return self._ytcfg_get_safe(
559 ytcfg, (lambda x: x['INNERTUBE_CLIENT_VERSION'],
560 lambda x: x['INNERTUBE_CONTEXT']['client']['clientVersion']), str, default_client)
562 def _select_api_hostname(self, req_api_hostname, default_client=None):
563 return (self._configuration_arg('innertube_host', [''], ie_key=YoutubeIE.ie_key())[0]
564 or req_api_hostname or self._get_innertube_host(default_client or 'web'))
566 def _extract_api_key(self, ytcfg=None, default_client='web'):
567 return self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_API_KEY'], str, default_client)
569 def _extract_context(self, ytcfg=None, default_client='web'):
571 (ytcfg, self._get_default_ytcfg(default_client)), 'INNERTUBE_CONTEXT', expected_type=dict)
572 # Enforce language and tz for extraction
573 client_context = traverse_obj(context, 'client', expected_type=dict, default={})
574 client_context.update({'hl': self._preferred_lang or 'en', 'timeZone': 'UTC', 'utcOffsetMinutes': 0})
579 def _generate_sapisidhash_header(self, origin='https://www.youtube.com'):
580 time_now = round(time.time())
581 if self._SAPISID is None:
582 yt_cookies = self._get_cookies('https://www.youtube.com')
583 # Sometimes SAPISID cookie isn't present but __Secure-3PAPISID is.
584 # See: https://github.com/yt-dlp/yt-dlp/issues/393
585 sapisid_cookie = dict_get(
586 yt_cookies, ('__Secure-3PAPISID', 'SAPISID'))
587 if sapisid_cookie and sapisid_cookie.value:
588 self._SAPISID = sapisid_cookie.value
589 self.write_debug('Extracted SAPISID cookie')
590 # SAPISID cookie is required if not already present
591 if not yt_cookies.get('SAPISID'):
592 self.write_debug('Copying __Secure-3PAPISID cookie to SAPISID cookie')
594 '.youtube.com', 'SAPISID', self._SAPISID, secure=True, expire_time=time_now + 3600)
596 self._SAPISID = False
597 if not self._SAPISID:
599 # SAPISIDHASH algorithm from https://stackoverflow.com/a/32065323
600 sapisidhash = hashlib.sha1(
601 f'{time_now} {self._SAPISID} {origin}'.encode()).hexdigest()
602 return f'SAPISIDHASH {time_now}_{sapisidhash}'
604 def _call_api(self, ep, query, video_id, fatal=True, headers=None,
605 note='Downloading API JSON', errnote='Unable to download API page',
606 context=None, api_key=None, api_hostname=None, default_client='web'):
608 data = {'context': context} if context else {'context': self._extract_context(default_client=default_client)}
610 real_headers = self.generate_api_headers(default_client=default_client)
611 real_headers.update({'content-type': 'application/json'})
613 real_headers.update(headers)
614 api_key = (self._configuration_arg('innertube_key', [''], ie_key=YoutubeIE.ie_key(), casesense=True)[0]
615 or api_key or self._extract_api_key(default_client=default_client))
616 return self._download_json(
617 f'https://{self._select_api_hostname(api_hostname, default_client)}/youtubei/v1/{ep}',
618 video_id=video_id, fatal=fatal, note=note, errnote=errnote,
619 data=json.dumps(data).encode('utf8'), headers=real_headers,
620 query={'key': api_key, 'prettyPrint': 'false'})
622 def extract_yt_initial_data(self, item_id, webpage, fatal=True):
623 return self._search_json(self._YT_INITIAL_DATA_RE, webpage, 'yt initial data', item_id, fatal=fatal)
626 def _extract_session_index(*data):
628 Index of current account in account list.
629 See: https://github.com/yt-dlp/yt-dlp/pull/519
632 session_index = int_or_none(try_get(ytcfg, lambda x: x['SESSION_INDEX']))
633 if session_index is not None:
637 def _extract_identity_token(self, ytcfg=None, webpage=None):
639 token = try_get(ytcfg, lambda x: x['ID_TOKEN'], str)
643 return self._search_regex(
644 r'\bID_TOKEN["\']\s
*:\s
*["\'](.+?)["\']', webpage,
645 'identity token
', default=None, fatal=False)
648 def _extract_account_syncid(*args):
650 Extract syncId required to download private playlists of secondary channels
651 @params response and/or ytcfg
654 # ytcfg includes channel_syncid if on secondary channel
655 delegated_sid = try_get(data, lambda x: x['DELEGATED_SESSION_ID
'], str)
659 data, (lambda x: x['responseContext
']['mainAppWebResponseContext
']['datasyncId
'],
660 lambda x: x['DATASYNC_ID
']), str) or '').split('||
')
661 if len(sync_ids) >= 2 and sync_ids[1]:
662 # datasyncid is of the form "channel_syncid||user_syncid" for secondary channel
663 # and just "user_syncid||" for primary channel. We only want the channel_syncid
667 def _extract_visitor_data(*args):
669 Extracts visitorData from an API response or ytcfg
670 Appears to be used to track session state
673 args, [('VISITOR_DATA
', ('INNERTUBE_CONTEXT
', 'client
', 'visitorData
'), ('responseContext
', 'visitorData
'))],
676 @functools.cached_property
677 def is_authenticated(self):
678 return bool(self._generate_sapisidhash_header())
680 def extract_ytcfg(self, video_id, webpage):
683 return self._parse_json(
685 r'ytcfg\
.set\s
*\
(\s
*({.+?}
)\s
*\
)\s
*;', webpage, 'ytcfg
',
686 default='{}'), video_id, fatal=False) or {}
688 def generate_api_headers(
689 self
, *, ytcfg
=None, account_syncid
=None, session_index
=None,
690 visitor_data
=None, identity_token
=None, api_hostname
=None, default_client
='web'):
692 origin
= 'https://' + (self
._select
_api
_hostname
(api_hostname
, default_client
))
694 'X-YouTube-Client-Name': str(
695 self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT_CLIENT_NAME'], default_client
=default_client
)),
696 'X-YouTube-Client-Version': self
._extract
_client
_version
(ytcfg
, default_client
),
698 'X-Youtube-Identity-Token': identity_token
or self
._extract
_identity
_token
(ytcfg
),
699 'X-Goog-PageId': account_syncid
or self
._extract
_account
_syncid
(ytcfg
),
700 'X-Goog-Visitor-Id': visitor_data
or self
._extract
_visitor
_data
(ytcfg
),
701 'User-Agent': self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT']['client']['userAgent'], default_client
=default_client
),
703 if session_index
is None:
704 session_index
= self
._extract
_session
_index
(ytcfg
)
705 if account_syncid
or session_index
is not None:
706 headers
['X-Goog-AuthUser'] = session_index
if session_index
is not None else 0
708 auth
= self
._generate
_sapisidhash
_header
(origin
)
710 headers
['Authorization'] = auth
711 headers
['X-Origin'] = origin
712 return filter_dict(headers
)
714 def _download_ytcfg(self
, client
, video_id
):
716 'web': 'https://www.youtube.com',
717 'web_music': 'https://music.youtube.com',
718 'web_embedded': f
'https://www.youtube.com/embed/{video_id}?html5=1',
722 webpage
= self
._download
_webpage
(
723 url
, video_id
, fatal
=False, note
=f
'Downloading {client.replace("_", " ").strip()} client config')
724 return self
.extract_ytcfg(video_id
, webpage
) or {}
727 def _build_api_continuation_query(continuation
, ctp
=None):
729 'continuation': continuation
,
731 # TODO: Inconsistency with clickTrackingParams.
732 # Currently we have a fixed ctp contained within context (from ytcfg)
733 # and a ctp in root query for continuation.
735 query
['clickTracking'] = {'clickTrackingParams': ctp}
739 def _extract_next_continuation_data(cls
, renderer
):
740 next_continuation
= try_get(
741 renderer
, (lambda x
: x
['continuations'][0]['nextContinuationData'],
742 lambda x
: x
['continuation']['reloadContinuationData']), dict)
743 if not next_continuation
:
745 continuation
= next_continuation
.get('continuation')
748 ctp
= next_continuation
.get('clickTrackingParams')
749 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
752 def _extract_continuation_ep_data(cls
, continuation_ep
: dict):
753 if isinstance(continuation_ep
, dict):
754 continuation
= try_get(
755 continuation_ep
, lambda x
: x
['continuationCommand']['token'], str)
758 ctp
= continuation_ep
.get('clickTrackingParams')
759 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
762 def _extract_continuation(cls
, renderer
):
763 next_continuation
= cls
._extract
_next
_continuation
_data
(renderer
)
764 if next_continuation
:
765 return next_continuation
767 return traverse_obj(renderer
, (
768 ('contents', 'items', 'rows'), ..., 'continuationItemRenderer',
769 ('continuationEndpoint', ('button', 'buttonRenderer', 'command')),
770 ), get_all
=False, expected_type
=cls
._extract
_continuation
_ep
_data
)
773 def _extract_alerts(cls
, data
):
774 for alert_dict
in try_get(data
, lambda x
: x
['alerts'], list) or []:
775 if not isinstance(alert_dict
, dict):
777 for alert
in alert_dict
.values():
778 alert_type
= alert
.get('type')
781 message
= cls
._get
_text
(alert
, 'text')
783 yield alert_type
, message
785 def _report_alerts(self
, alerts
, expected
=True, fatal
=True, only_once
=False):
786 errors
, warnings
= [], []
787 for alert_type
, alert_message
in alerts
:
788 if alert_type
.lower() == 'error' and fatal
:
789 errors
.append([alert_type
, alert_message
])
790 elif alert_message
not in self
._IGNORED
_WARNINGS
:
791 warnings
.append([alert_type
, alert_message
])
793 for alert_type
, alert_message
in (warnings
+ errors
[:-1]):
794 self
.report_warning(f
'YouTube said: {alert_type} - {alert_message}', only_once
=only_once
)
796 raise ExtractorError(f
'YouTube said: {errors[-1][1]}', expected
=expected
)
798 def _extract_and_report_alerts(self
, data
, *args
, **kwargs
):
799 return self
._report
_alerts
(self
._extract
_alerts
(data
), *args
, **kwargs
)
801 def _extract_badges(self
, badge_list
: list):
803 Extract known BadgeType's from a list of badge renderers.
804 @returns [{'type': BadgeType}]
807 'PRIVACY_UNLISTED': BadgeType
.AVAILABILITY_UNLISTED
,
808 'PRIVACY_PRIVATE': BadgeType
.AVAILABILITY_PRIVATE
,
809 'PRIVACY_PUBLIC': BadgeType
.AVAILABILITY_PUBLIC
,
810 'CHECK_CIRCLE_THICK': BadgeType
.VERIFIED
,
811 'OFFICIAL_ARTIST_BADGE': BadgeType
.VERIFIED
,
812 'CHECK': BadgeType
.VERIFIED
,
816 'BADGE_STYLE_TYPE_MEMBERS_ONLY': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
817 'BADGE_STYLE_TYPE_PREMIUM': BadgeType
.AVAILABILITY_PREMIUM
,
818 'BADGE_STYLE_TYPE_LIVE_NOW': BadgeType
.LIVE_NOW
,
819 'BADGE_STYLE_TYPE_VERIFIED': BadgeType
.VERIFIED
,
820 'BADGE_STYLE_TYPE_VERIFIED_ARTIST': BadgeType
.VERIFIED
,
824 'unlisted': BadgeType
.AVAILABILITY_UNLISTED
,
825 'private': BadgeType
.AVAILABILITY_PRIVATE
,
826 'members only': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
827 'live': BadgeType
.LIVE_NOW
,
828 'premium': BadgeType
.AVAILABILITY_PREMIUM
,
829 'verified': BadgeType
.VERIFIED
,
830 'official artist channel': BadgeType
.VERIFIED
,
834 for badge
in traverse_obj(badge_list
, (..., lambda key
, _
: re
.search(r
'[bB]adgeRenderer$', key
))):
836 icon_type_map
.get(traverse_obj(badge
, ('icon', 'iconType'), expected_type
=str))
837 or badge_style_map
.get(traverse_obj(badge
, 'style'))
840 badges
.append({'type': badge_type}
)
843 # fallback, won't work in some languages
844 label
= traverse_obj(
845 badge
, 'label', ('accessibilityData', 'label'), 'tooltip', 'iconTooltip', get_all
=False, expected_type
=str, default
='')
846 for match
, label_badge_type
in label_map
.items():
847 if match
in label
.lower():
848 badges
.append({'type': label_badge_type}
)
854 def _has_badge(badges
, badge_type
):
855 return bool(traverse_obj(badges
, lambda _
, v
: v
['type'] == badge_type
))
858 def _get_text(data
, *path_list
, max_runs
=None):
859 for path
in path_list
or [None]:
863 obj
= traverse_obj(data
, path
, default
=[])
864 if not any(key
is ... or isinstance(key
, (list, tuple)) for key
in variadic(path
)):
867 text
= try_get(item
, lambda x
: x
['simpleText'], str)
870 runs
= try_get(item
, lambda x
: x
['runs'], list) or []
871 if not runs
and isinstance(item
, list):
874 runs
= runs
[:min(len(runs
), max_runs
or len(runs
))]
875 text
= ''.join(traverse_obj(runs
, (..., 'text'), expected_type
=str))
879 def _get_count(self
, data
, *path_list
):
880 count_text
= self
._get
_text
(data
, *path_list
) or ''
881 count
= parse_count(count_text
)
884 self
._search
_regex
(r
'^([\d,]+)', re
.sub(r
'\s', '', count_text
), 'count', default
=None))
888 def _extract_thumbnails(data
, *path_list
, final_key
='thumbnails'):
890 Extract thumbnails from thumbnails dict
891 @param path_list: path list to level that contains 'thumbnails' key
894 for path
in path_list
or [()]:
895 for thumbnail
in traverse_obj(data
, (*variadic(path
), final_key
, ...)):
896 thumbnail_url
= url_or_none(thumbnail
.get('url'))
897 if not thumbnail_url
:
899 # Sometimes youtube gives a wrong thumbnail URL. See:
900 # https://github.com/yt-dlp/yt-dlp/issues/233
901 # https://github.com/ytdl-org/youtube-dl/issues/28023
902 if 'maxresdefault' in thumbnail_url
:
903 thumbnail_url
= thumbnail_url
.split('?')[0]
905 'url': thumbnail_url
,
906 'height': int_or_none(thumbnail
.get('height')),
907 'width': int_or_none(thumbnail
.get('width')),
912 def extract_relative_time(relative_time_text
):
914 Extracts a relative time from string and converts to dt object
915 e.g. 'streamed 6 days ago', '5 seconds ago (edited)', 'updated today', '8 yr ago'
918 # XXX: this could be moved to a general function in utils/_utils.py
919 # The relative time text strings are roughly the same as what
920 # Javascript's Intl.RelativeTimeFormat function generates.
921 # See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
923 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',
926 start
= mobj
.group('start')
928 return datetime_from_str(start
)
930 return datetime_from_str('now-{}{}'.format(mobj
.group('time'), mobj
.group('unit')))
934 def _parse_time_text(self
, text
):
937 dt_
= self
.extract_relative_time(text
)
939 if isinstance(dt_
, dt
.datetime
):
940 timestamp
= calendar
.timegm(dt_
.timetuple())
942 if timestamp
is None:
944 unified_timestamp(text
) or unified_timestamp(
946 (r
'([a-z]+\s*\d{1,2},?\s*20\d{2})', r
'(?:.+|^)(?:live|premieres|ed|ing)(?:\s*(?:on|for))?\s*(.+\d)'),
947 text
.lower(), 'time text', default
=None)))
949 if text
and timestamp
is None and self
._preferred
_lang
in (None, 'en'):
951 f
'Cannot parse localized time text "{text}"', only_once
=True)
954 def _extract_response(self
, item_id
, query
, note
='Downloading API JSON', headers
=None,
955 ytcfg
=None, check_get_keys
=None, ep
='browse', fatal
=True, api_hostname
=None,
956 default_client
='web'):
957 raise_for_incomplete
= bool(self
._configuration
_arg
('raise_incomplete_data', ie_key
=YoutubeIE
))
958 # Incomplete Data should be a warning by default when retries are exhausted, while other errors should be fatal.
959 icd_retries
= iter(self
.RetryManager(fatal
=raise_for_incomplete
))
960 icd_rm
= next(icd_retries
)
961 main_retries
= iter(self
.RetryManager())
962 main_rm
= next(main_retries
)
963 # Manual retry loop for multiple RetryManagers
964 # The proper RetryManager MUST be advanced after an error
965 # and its result MUST be checked if the manager is non fatal
968 response
= self
._call
_api
(
969 ep
=ep
, fatal
=True, headers
=headers
,
970 video_id
=item_id
, query
=query
, note
=note
,
971 context
=self
._extract
_context
(ytcfg
, default_client
),
972 api_key
=self
._extract
_api
_key
(ytcfg
, default_client
),
973 api_hostname
=api_hostname
, default_client
=default_client
)
974 except ExtractorError
as e
:
975 if not isinstance(e
.cause
, network_exceptions
):
976 return self
._error
_or
_warning
(e
, fatal
=fatal
)
977 elif not isinstance(e
.cause
, HTTPError
):
982 first_bytes
= e
.cause
.response
.read(512)
983 if not is_html(first_bytes
):
986 self
._webpage
_read
_content
(e
.cause
.response
, None, item_id
, prefix
=first_bytes
) or '{}', item_id
, fatal
=False),
987 lambda x
: x
['error']['message'], str)
989 self
._report
_alerts
([('ERROR', yt_error
)], fatal
=False)
990 # Downloading page may result in intermittent 5xx HTTP error
991 # Sometimes a 404 is also received. See: https://github.com/ytdl-org/youtube-dl/issues/28289
992 # We also want to catch all other network exceptions since errors in later pages can be troublesome
993 # See https://github.com/yt-dlp/yt-dlp/issues/507#issuecomment-880188210
994 if e
.cause
.status
not in (403, 429):
998 return self
._error
_or
_warning
(e
, fatal
=fatal
)
1001 self
._extract
_and
_report
_alerts
(response
, only_once
=True)
1002 except ExtractorError
as e
:
1003 # YouTube's servers may return errors we want to retry on in a 200 OK response
1004 # See: https://github.com/yt-dlp/yt-dlp/issues/839
1005 if 'unknown error' in e
.msg
.lower():
1009 return self
._error
_or
_warning
(e
, fatal
=fatal
)
1010 # Youtube sometimes sends incomplete data
1011 # See: https://github.com/ytdl-org/youtube-dl/issues/28194
1012 if not traverse_obj(response
, *variadic(check_get_keys
)):
1013 icd_rm
.error
= ExtractorError('Incomplete data received', expected
=True)
1014 should_retry
= next(icd_retries
, None)
1015 if not should_retry
:
1022 def is_music_url(url
):
1023 return re
.match(r
'(https?://)?music\.youtube\.com/', url
) is not None
1025 def _extract_video(self
, renderer
):
1026 video_id
= renderer
.get('videoId')
1028 reel_header_renderer
= traverse_obj(renderer
, (
1029 'navigationEndpoint', 'reelWatchEndpoint', 'overlay', 'reelPlayerOverlayRenderer',
1030 'reelPlayerHeaderSupportedRenderers', 'reelPlayerHeaderRenderer'))
1032 title
= self
._get
_text
(renderer
, 'title', 'headline') or self
._get
_text
(reel_header_renderer
, 'reelTitleText')
1033 description
= self
._get
_text
(renderer
, 'descriptionSnippet')
1035 duration
= int_or_none(renderer
.get('lengthSeconds'))
1036 if duration
is None:
1037 duration
= parse_duration(self
._get
_text
(
1038 renderer
, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
1039 if duration
is None:
1040 # XXX: should write a parser to be more general to support more cases (e.g. shorts in shorts tab)
1041 duration
= parse_duration(self
._search
_regex
(
1042 r
'(?i)(ago)(?!.*\1)\s+(?P<duration>[a-z0-9 ,]+?)(?:\s+[\d,]+\s+views)?(?:\s+-\s+play\s+short)?$',
1043 traverse_obj(renderer
, ('title', 'accessibility', 'accessibilityData', 'label'), default
='', expected_type
=str),
1044 video_id
, default
=None, group
='duration'))
1046 channel_id
= traverse_obj(
1047 renderer
, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'),
1048 expected_type
=str, get_all
=False)
1050 channel_id
= traverse_obj(reel_header_renderer
, ('channelNavigationEndpoint', 'browseEndpoint', 'browseId'))
1052 channel_id
= self
.ucid_or_none(channel_id
)
1054 overlay_style
= traverse_obj(
1055 renderer
, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'),
1056 get_all
=False, expected_type
=str)
1057 badges
= self
._extract
_badges
(traverse_obj(renderer
, 'badges'))
1058 owner_badges
= self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges'))
1059 navigation_url
= urljoin('https://www.youtube.com/', traverse_obj(
1060 renderer
, ('navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url'),
1061 expected_type
=str)) or ''
1062 url
= f
'https://www.youtube.com/watch?v={video_id}'
1063 if overlay_style
== 'SHORTS' or '/shorts/' in navigation_url
:
1064 url
= f
'https://www.youtube.com/shorts/{video_id}'
1066 time_text
= (self
._get
_text
(renderer
, 'publishedTimeText', 'videoInfo')
1067 or self
._get
_text
(reel_header_renderer
, 'timestampText') or '')
1068 scheduled_timestamp
= str_to_int(traverse_obj(renderer
, ('upcomingEventData', 'startTime'), get_all
=False))
1071 'is_upcoming' if scheduled_timestamp
is not None
1072 else 'was_live' if 'streamed' in time_text
.lower()
1073 else 'is_live' if overlay_style
== 'LIVE' or self
._has
_badge
(badges
, BadgeType
.LIVE_NOW
)
1076 # videoInfo is a string like '50K views • 10 years ago'.
1077 view_count_text
= self
._get
_text
(renderer
, 'viewCountText', 'shortViewCountText', 'videoInfo') or ''
1078 view_count
= (0 if 'no views' in view_count_text
.lower()
1079 else self
._get
_count
({'simpleText': view_count_text}
))
1080 view_count_field
= 'concurrent_view_count' if live_status
in ('is_live', 'is_upcoming') else 'view_count'
1082 channel
= (self
._get
_text
(renderer
, 'ownerText', 'shortBylineText')
1083 or self
._get
_text
(reel_header_renderer
, 'channelTitleText'))
1085 channel_handle
= traverse_obj(renderer
, (
1086 'shortBylineText', 'runs', ..., 'navigationEndpoint',
1087 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl'))),
1088 expected_type
=self
.handle_from_url
, get_all
=False)
1091 'ie_key': YoutubeIE
.ie_key(),
1095 'description': description
,
1096 'duration': duration
,
1097 'channel_id': channel_id
,
1099 'channel_url': f
'https://www.youtube.com/channel/{channel_id}' if channel_id
else None,
1100 'uploader': channel
,
1101 'uploader_id': channel_handle
,
1102 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
1103 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
1104 'timestamp': (self
._parse
_time
_text
(time_text
)
1105 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
1107 'release_timestamp': scheduled_timestamp
,
1109 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
1110 else self
._availability
(
1111 is_private
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
) or None,
1112 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
1113 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
1114 is_unlisted
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
) or None),
1115 view_count_field
: view_count
,
1116 'live_status': live_status
,
1117 'channel_is_verified': True if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
) else None,
1121 class YoutubeIE(YoutubeBaseInfoExtractor
):
1123 _VALID_URL
= r
'''(?x)^
1125 (?:https?://|//) # http(s):// or protocol-independent URL
1126 (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
1127 (?:www\.)?deturl\.com/www\.youtube\.com|
1128 (?:www\.)?pwnyoutube\.com|
1129 (?:www\.)?hooktube\.com|
1130 (?:www\.)?yourepeat\.com|
1131 tube\.majestyc\.net|
1133 youtube\.googleapis\.com)/ # the various hostnames, with wildcard subdomains
1134 (?:.*?\#/)? # handle anchor (#/) redirect urls
1135 (?: # the various things that can precede the ID:
1136 (?:(?:v|embed|e|shorts|live)/(?!videoseries|live_stream)) # v/ or embed/ or e/ or shorts/
1137 |(?: # or the v= param in all its forms
1138 (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
1139 (?:\?|\#!?) # the params delimiter ? or # or #!
1140 (?:.*?[&;])?? # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&v=V36LpHqtcDY)
1145 youtu\.be| # just youtu.be/xxxx
1146 vid\.plus| # or vid.plus/xxxx
1147 zwearz\.com/watch| # or zwearz.com/watch/xxxx
1150 |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
1152 )? # all until now is optional -> you can pass the naked ID
1153 (?P<id>[0-9A-Za-z_-]{{11}}) # here is it! the YouTube video ID
1154 (?(1).+)? # if we found the ID, everything can follow
1156 invidious
='|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
1161 <(?:[0-9A-Za-z-]+?)?iframe[^>]+?src=|
1169 (?P
<url
>(?
:https?
:)?
//(?
:www\
.)?
youtube(?
:-nocookie
)?\
.com
/
1170 (?
:embed|v|p
)/[0-9A
-Za
-z_
-]{11}
.*?
)
1172 # https://wordpress.org/plugins/lazy-load-for-videos/
1174 <a\s
[^
>]*\bhref
="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"
1175 \s
[^
>]*\bclass
="[^"]*\blazy
-load
-youtube
''',
1177 _RETURN_TYPE = 'video' # XXX: How to handle multifeed?
1180 r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
1181 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$',
1182 r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
1184 _formats = { # NB: Used in YoutubeWebArchiveIE and GoogleDriveIE
1185 '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1186 '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1187 '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
1188 '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
1189 '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
1190 '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1191 '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1192 '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1193 # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
1194 '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
1195 '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1196 '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1197 '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1198 '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1199 '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1200 '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1201 '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1202 '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1206 '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1207 '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1208 '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1209 '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1210 '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
1211 '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1212 '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1214 # Apple HTTP Live Streaming
1215 '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1216 '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1217 '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1218 '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1219 '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1220 '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1221 '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1222 '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
1225 '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
1226 '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
1227 '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1228 '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
1229 '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
1230 '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'}, # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
1231 '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
1232 '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1233 '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
1234 '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1235 '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1236 '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
1239 '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
1240 '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
1241 '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
1242 '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1243 '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1244 '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
1245 '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
1248 '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1249 '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1250 '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1251 '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1252 '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1253 '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1254 '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
1255 '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1256 '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1257 '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1258 '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1259 '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1260 '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1261 '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1262 '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1263 # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
1264 '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1265 '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1266 '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1267 '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1268 '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1269 '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1272 '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
1273 '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
1275 # Dash webm audio with opus inside
1276 '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
1277 '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
1278 '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
1281 '_rtmp': {'protocol': 'rtmp'},
1283 # av01 video only formats sometimes served with "unknown" codecs
1284 '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1285 '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1286 '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1287 '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1288 '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1289 '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1290 '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1291 '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1293 _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1300 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1302 'id': 'BaW_jenozKc',
1304 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1305 'channel': 'Philipp Hagemeister',
1306 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1307 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1308 'upload_date': '20121002',
1309 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1310 'categories': ['Science & Technology'],
1311 'tags': ['youtube-dl'],
1315 'availability': 'public',
1316 'playable_in_embed': True,
1317 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1318 'live_status': 'not_live',
1322 'comment_count': int,
1323 'channel_follower_count': int,
1324 'uploader': 'Philipp Hagemeister',
1325 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1326 'uploader_id': '@PhilippHagemeister',
1327 'heatmap': 'count:100',
1328 'timestamp': 1349198244,
1332 'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1333 'note': 'Embed-only video (#1746)',
1335 'id': 'yZIXLfi8CZQ',
1337 'upload_date': '20120608',
1338 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1339 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1342 'skip': 'Private video',
1345 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1346 'note': 'Use the first video ID in the URL',
1348 'id': 'BaW_jenozKc',
1350 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1351 'channel': 'Philipp Hagemeister',
1352 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1353 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1354 'upload_date': '20121002',
1355 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1356 'categories': ['Science & Technology'],
1357 'tags': ['youtube-dl'],
1361 'availability': 'public',
1362 'playable_in_embed': True,
1363 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1364 'live_status': 'not_live',
1366 'comment_count': int,
1367 'channel_follower_count': int,
1368 'uploader': 'Philipp Hagemeister',
1369 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1370 'uploader_id': '@PhilippHagemeister',
1371 'heatmap': 'count:100',
1372 'timestamp': 1349198244,
1375 'skip_download': True,
1379 'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1380 'note': '256k DASH audio (format 141) via DASH manifest',
1382 'id': 'a9LDPn-MO4I',
1384 'upload_date': '20121002',
1386 'title': 'UHDTV TEST 8K VIDEO.mp4',
1389 'youtube_include_dash_manifest': True,
1392 'skip': 'format 141 not served anymore',
1394 # DASH manifest with encrypted signature
1396 'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1398 'id': 'IB3lcPjvWLA',
1400 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1401 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1403 'upload_date': '20131011',
1406 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1407 'playable_in_embed': True,
1408 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1410 'track': 'The Spark',
1411 'live_status': 'not_live',
1412 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1413 'channel': 'Afrojack',
1415 'availability': 'public',
1416 'categories': ['Music'],
1418 'alt_title': 'The Spark',
1419 'channel_follower_count': int,
1420 'uploader': 'Afrojack',
1421 'uploader_url': 'https://www.youtube.com/@Afrojack',
1422 'uploader_id': '@Afrojack',
1425 'youtube_include_dash_manifest': True,
1426 'format': '141/bestaudio[ext=m4a]',
1429 # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1431 'note': 'Embed allowed age-gate video',
1432 'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1434 'id': 'HtVdAasjOgU',
1436 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1437 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1439 'upload_date': '20140605',
1441 'categories': ['Gaming'],
1442 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1443 'availability': 'needs_auth',
1444 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1446 'channel': 'The Witcher',
1447 'live_status': 'not_live',
1449 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1450 'playable_in_embed': True,
1452 'channel_follower_count': int,
1453 'uploader': 'The Witcher',
1454 'uploader_url': 'https://www.youtube.com/@thewitcher',
1455 'uploader_id': '@thewitcher',
1456 'comment_count': int,
1457 'channel_is_verified': True,
1458 'heatmap': 'count:100',
1459 'timestamp': 1401991663,
1463 'note': 'Age-gate video with embed allowed in public site',
1464 'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1466 'id': 'HsUATh_Nc2U',
1468 'title': 'Godzilla 2 (Official Video)',
1469 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1470 'upload_date': '20200408',
1472 'availability': 'needs_auth',
1473 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1474 'channel': 'FlyingKitty',
1475 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1477 'categories': ['Entertainment'],
1478 'live_status': 'not_live',
1479 'tags': ['Flyingkitty', 'godzilla 2'],
1480 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1483 'playable_in_embed': True,
1484 'channel_follower_count': int,
1485 'uploader': 'FlyingKitty',
1486 'uploader_url': 'https://www.youtube.com/@FlyingKitty900',
1487 'uploader_id': '@FlyingKitty900',
1488 'comment_count': int,
1489 'channel_is_verified': True,
1493 'note': 'Age-gate video embedable only with clientScreen=EMBED',
1494 'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1496 'id': 'Tq92D6wQ1mg',
1497 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1499 'upload_date': '20191228',
1500 'description': 'md5:17eccca93a786d51bc67646756894066',
1503 'availability': 'needs_auth',
1504 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1506 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1507 'channel': 'Projekt Melody',
1508 'live_status': 'not_live',
1509 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1510 'playable_in_embed': True,
1511 'categories': ['Entertainment'],
1513 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1514 'comment_count': int,
1515 'channel_follower_count': int,
1516 'uploader': 'Projekt Melody',
1517 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
1518 'uploader_id': '@ProjektMelody',
1519 'timestamp': 1577508724,
1523 'note': 'Non-Agegated non-embeddable video',
1524 'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1526 'id': 'MeJVWBSsPAY',
1528 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1529 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1530 'upload_date': '20130730',
1531 'track': 'Such mich find mich',
1533 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1535 'playable_in_embed': False,
1536 'creator': 'OOMPH!',
1537 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1539 'alt_title': 'Such mich find mich',
1541 'channel': 'Herr Lurik',
1542 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1543 'categories': ['Music'],
1544 'availability': 'public',
1545 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1546 'live_status': 'not_live',
1548 'channel_follower_count': int,
1549 'uploader': 'Herr Lurik',
1550 'uploader_url': 'https://www.youtube.com/@HerrLurik',
1551 'uploader_id': '@HerrLurik',
1555 'note': 'Non-bypassable age-gated video',
1556 'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1557 'only_matching': True,
1559 # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1560 # YouTube Red ad is not captured for creator
1562 'url': '__2ABJjxzNo',
1564 'id': '__2ABJjxzNo',
1567 'upload_date': '20100430',
1568 'creator': 'deadmau5',
1569 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1570 'title': 'Deadmau5 - Some Chords (HD)',
1571 'alt_title': 'Some Chords',
1572 'availability': 'public',
1574 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1576 'live_status': 'not_live',
1577 'channel': 'deadmau5',
1578 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1580 'track': 'Some Chords',
1581 'artist': 'deadmau5',
1582 'playable_in_embed': True,
1584 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1585 'categories': ['Music'],
1586 'album': 'Some Chords',
1587 'channel_follower_count': int,
1588 'uploader': 'deadmau5',
1589 'uploader_url': 'https://www.youtube.com/@deadmau5',
1590 'uploader_id': '@deadmau5',
1592 'expected_warnings': [
1593 'DASH manifest missing',
1596 # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1598 'url': 'lqQg6PlCWgI',
1600 'id': 'lqQg6PlCWgI',
1603 'upload_date': '20150827',
1604 'description': 'md5:04bbbf3ccceb6795947572ca36f45904',
1605 'title': 'Hockey - Women - GER-AUS - London 2012 Olympic Games',
1607 'release_timestamp': 1343767800,
1608 'playable_in_embed': True,
1609 'categories': ['Sports'],
1610 'release_date': '20120731',
1611 'channel': 'Olympics',
1612 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1613 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1614 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1616 'availability': 'public',
1617 'live_status': 'was_live',
1619 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1620 'channel_follower_count': int,
1621 'uploader': 'Olympics',
1622 'uploader_url': 'https://www.youtube.com/@Olympics',
1623 'uploader_id': '@Olympics',
1624 'channel_is_verified': True,
1625 'timestamp': 1440707674,
1628 'skip_download': 'requires avconv',
1633 'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1635 'id': '_b-2C3KPAM0',
1637 'stretched_ratio': 16 / 9.,
1639 'upload_date': '20110310',
1640 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1641 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1642 'playable_in_embed': True,
1646 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1647 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1648 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1650 'categories': ['People & Blogs'],
1652 'live_status': 'not_live',
1653 'availability': 'unlisted',
1654 'comment_count': int,
1655 'channel_follower_count': int,
1657 'uploader_url': 'https://www.youtube.com/@AllenMeow',
1658 'uploader_id': '@AllenMeow',
1659 'timestamp': 1299776999,
1662 # url_encoded_fmt_stream_map is empty string
1664 'url': 'qEJwOuvDf7I',
1666 'id': 'qEJwOuvDf7I',
1668 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1670 'upload_date': '20150404',
1673 'skip_download': 'requires avconv',
1675 'skip': 'This live event has ended.',
1677 # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1679 'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1681 'id': 'FIl7x6_3R5Y',
1683 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1684 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1686 'upload_date': '20150625',
1687 'formats': 'mincount:31',
1689 'skip': 'not actual anymore',
1691 # DASH manifest with segment_list
1693 'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1694 'md5': '8ce563a1d667b599d21064e982ab9e31',
1696 'id': 'CsmdDsKjzN8',
1698 'upload_date': '20150501', # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1699 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1700 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1703 'youtube_include_dash_manifest': True,
1704 'format': '135', # bestvideo
1706 'skip': 'This live event has ended.',
1709 # Multifeed videos (multiple cameras), URL can be of any Camera
1710 # TODO: fix multifeed titles
1711 'url': 'https://www.youtube.com/watch?v=zaPI8MvL8pg',
1713 'id': 'zaPI8MvL8pg',
1714 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04',
1715 'description': 'md5:563ccbc698b39298481ca3c571169519',
1719 'id': 'j5yGuxZ8lLU',
1721 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Chris)',
1722 'description': 'md5:563ccbc698b39298481ca3c571169519',
1724 'channel_follower_count': int,
1725 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1726 'availability': 'public',
1727 'playable_in_embed': True,
1728 'upload_date': '20131105',
1729 'categories': ['Gaming'],
1730 'live_status': 'was_live',
1732 'release_timestamp': 1383701910,
1733 'thumbnail': 'https://i.ytimg.com/vi/j5yGuxZ8lLU/maxresdefault.jpg',
1734 'comment_count': int,
1737 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1738 'channel': 'WiiLikeToPlay',
1740 'release_date': '20131106',
1741 'uploader': 'WiiLikeToPlay',
1742 'uploader_id': '@WLTP',
1743 'uploader_url': 'https://www.youtube.com/@WLTP',
1747 'id': 'zaPI8MvL8pg',
1749 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Tyson)',
1750 'availability': 'public',
1751 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1752 'channel': 'WiiLikeToPlay',
1753 'channel_follower_count': int,
1754 'description': 'md5:563ccbc698b39298481ca3c571169519',
1759 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1760 'release_timestamp': 1383701915,
1761 'comment_count': int,
1762 'upload_date': '20131105',
1763 'thumbnail': 'https://i.ytimg.com/vi/zaPI8MvL8pg/maxresdefault.jpg',
1764 'release_date': '20131106',
1765 'playable_in_embed': True,
1766 'live_status': 'was_live',
1767 'categories': ['Gaming'],
1769 'uploader': 'WiiLikeToPlay',
1770 'uploader_id': '@WLTP',
1771 'uploader_url': 'https://www.youtube.com/@WLTP',
1775 'id': 'R7r3vfO7Hao',
1777 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Spencer)',
1778 'thumbnail': 'https://i.ytimg.com/vi/R7r3vfO7Hao/maxresdefault.jpg',
1779 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1781 'availability': 'public',
1782 'playable_in_embed': True,
1783 'upload_date': '20131105',
1784 'description': 'md5:563ccbc698b39298481ca3c571169519',
1785 'channel_follower_count': int,
1787 'release_date': '20131106',
1788 'comment_count': int,
1789 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1790 'channel': 'WiiLikeToPlay',
1791 'categories': ['Gaming'],
1792 'release_timestamp': 1383701914,
1793 'live_status': 'was_live',
1797 'uploader': 'WiiLikeToPlay',
1798 'uploader_id': '@WLTP',
1799 'uploader_url': 'https://www.youtube.com/@WLTP',
1802 'params': {'skip_download': True},
1803 'skip': 'Not multifeed anymore',
1806 # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1807 'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1809 'id': 'gVfLd0zydlo',
1810 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1812 'playlist_count': 2,
1813 'skip': 'Not multifeed anymore',
1816 'url': 'https://vid.plus/FlRa-iH7PGw',
1817 'only_matching': True,
1820 'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1821 'only_matching': True,
1824 # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1825 # Also tests cut-off URL expansion in video description (see
1826 # https://github.com/ytdl-org/youtube-dl/issues/1892,
1827 # https://github.com/ytdl-org/youtube-dl/issues/8164)
1828 'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1830 'id': 'lsguqyKfVQg',
1832 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1833 'alt_title': 'Dark Walk',
1834 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1836 'upload_date': '20151119',
1837 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1838 'track': 'Dark Walk',
1839 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1840 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1841 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1842 'categories': ['Film & Animation'],
1844 'live_status': 'not_live',
1845 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1846 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1848 'availability': 'public',
1849 'channel': 'IronSoulElf',
1850 'playable_in_embed': True,
1853 'channel_follower_count': int,
1856 'skip_download': True,
1860 # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1861 'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1862 'only_matching': True,
1865 # Video with yt:stretch=17:0
1866 'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1868 'id': 'Q39EVAstoRM',
1870 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1871 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1872 'upload_date': '20151107',
1875 'skip_download': True,
1877 'skip': 'This video does not exist.',
1880 # Video with incomplete 'yt:stretch=16:'
1881 'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1882 'only_matching': True,
1885 # Video licensed under Creative Commons
1886 'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1888 'id': 'M4gD1WSo5mA',
1890 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1891 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1893 'upload_date': '20150128',
1894 'license': 'Creative Commons Attribution license (reuse allowed)',
1895 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1896 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1899 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1900 'channel': 'The Berkman Klein Center for Internet & Society',
1901 'availability': 'public',
1903 'categories': ['Education'],
1904 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1905 'live_status': 'not_live',
1906 'playable_in_embed': True,
1907 'channel_follower_count': int,
1909 'uploader': 'The Berkman Klein Center for Internet & Society',
1910 'uploader_id': '@BKCHarvard',
1911 'uploader_url': 'https://www.youtube.com/@BKCHarvard',
1912 'timestamp': 1422422076,
1915 'skip_download': True,
1919 'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1921 'id': 'eQcmzGIKrzg',
1923 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1924 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1926 'upload_date': '20151120',
1927 'license': 'Creative Commons Attribution license (reuse allowed)',
1928 'playable_in_embed': True,
1931 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1933 'availability': 'public',
1934 'categories': ['News & Politics'],
1935 'channel': 'Bernie Sanders',
1936 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1938 'live_status': 'not_live',
1939 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1940 'comment_count': int,
1941 'channel_follower_count': int,
1943 'uploader': 'Bernie Sanders',
1944 'uploader_url': 'https://www.youtube.com/@BernieSanders',
1945 'uploader_id': '@BernieSanders',
1946 'channel_is_verified': True,
1947 'heatmap': 'count:100',
1948 'timestamp': 1447987198,
1951 'skip_download': True,
1955 'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;v=V36LpHqtcDY',
1956 'only_matching': True,
1959 # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1960 'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1961 'only_matching': True,
1964 # Rental video preview
1965 'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1967 'id': 'uGpuVWrhIzE',
1969 'title': 'Piku - Trailer',
1970 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1971 'upload_date': '20150811',
1972 'license': 'Standard YouTube License',
1975 'skip_download': True,
1977 'skip': 'This video is not available.',
1980 # YouTube Red video with episode data
1981 'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1983 'id': 'iqKdEhx-dD4',
1985 'title': 'Isolation - Mind Field (Ep 1)',
1986 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1988 'upload_date': '20170118',
1989 'series': 'Mind Field',
1991 'episode_number': 1,
1992 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1995 'availability': 'public',
1997 'channel': 'Vsauce',
1998 'episode': 'Episode 1',
1999 'categories': ['Entertainment'],
2000 'season': 'Season 1',
2001 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
2002 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
2004 'playable_in_embed': True,
2005 'live_status': 'not_live',
2006 'channel_follower_count': int,
2007 'uploader': 'Vsauce',
2008 'uploader_url': 'https://www.youtube.com/@Vsauce',
2009 'uploader_id': '@Vsauce',
2010 'comment_count': int,
2011 'channel_is_verified': True,
2012 'timestamp': 1484761047,
2015 'skip_download': True,
2017 'expected_warnings': [
2018 'Skipping DASH manifest',
2022 # The following content has been identified by the YouTube community
2023 # as inappropriate or offensive to some audiences.
2024 'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
2026 'id': '6SJNVb0GnPI',
2028 'title': 'Race Differences in Intelligence',
2029 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
2031 'upload_date': '20140124',
2034 'skip_download': True,
2036 'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
2040 'url': '1t24XAntNCY',
2041 'only_matching': True,
2044 # geo restricted to JP
2045 'url': 'sJL6WA-aGkQ',
2046 'only_matching': True,
2049 'url': 'https://invidio.us/watch?v=BaW_jenozKc',
2050 'only_matching': True,
2053 'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
2054 'only_matching': True,
2057 # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
2058 'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
2059 'only_matching': True,
2063 'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
2064 'only_matching': True,
2067 # Video with unsupported adaptive stream type formats
2068 'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
2070 'id': 'Z4Vy8R84T1U',
2072 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
2073 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
2075 'upload_date': '20130923',
2076 'formats': 'maxcount:10',
2079 'skip_download': True,
2080 'youtube_include_dash_manifest': False,
2082 'skip': 'not actual anymore',
2085 # Youtube Music Auto-generated description
2086 # TODO: fix metadata extraction
2087 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2089 'id': 'MgNrAu2pzNs',
2091 'title': 'Voyeur Girl',
2092 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
2093 'upload_date': '20190312',
2094 'artists': ['Stephen'],
2095 'creators': ['Stephen'],
2096 'track': 'Voyeur Girl',
2097 'album': 'it\'s too much love to know my dear',
2098 'release_date': '20190313',
2099 'alt_title': 'Voyeur Girl',
2101 'playable_in_embed': True,
2103 'categories': ['Music'],
2104 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
2105 'channel': 'Stephen', # TODO: should be "Stephen - Topic"
2106 'uploader': 'Stephen',
2107 'availability': 'public',
2109 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
2111 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
2113 'live_status': 'not_live',
2114 'channel_follower_count': int,
2117 'skip_download': True,
2121 'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
2122 'only_matching': True,
2125 # invalid -> valid video id redirection
2126 'url': 'DJztXj2GPfl',
2128 'id': 'DJztXj2GPfk',
2130 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
2131 'description': 'md5:bf577a41da97918e94fa9798d9228825',
2132 'upload_date': '20090125',
2133 'artist': 'Panjabi MC',
2134 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
2135 'album': 'Beware of the Boys (Mundian To Bach Ke)',
2138 'skip_download': True,
2140 'skip': 'Video unavailable',
2143 # empty description results in an empty string
2144 'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
2146 'id': 'x41yOUIvK2k',
2148 'title': 'IMG 3456',
2150 'upload_date': '20170613',
2152 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
2154 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
2156 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
2157 'availability': 'public',
2159 'categories': ['Pets & Animals'],
2161 'playable_in_embed': True,
2162 'live_status': 'not_live',
2163 'channel': 'l\'Or Vert asbl',
2164 'channel_follower_count': int,
2165 'uploader': 'l\'Or Vert asbl',
2166 'uploader_url': 'https://www.youtube.com/@ElevageOrVert',
2167 'uploader_id': '@ElevageOrVert',
2168 'timestamp': 1497343210,
2171 'skip_download': True,
2175 # with '};' inside yt initial data (see [1])
2176 # see [2] for an example with '};' inside ytInitialPlayerResponse
2177 # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
2178 # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
2179 'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
2181 'id': 'CHqg6qOn4no',
2183 'title': 'Part 77 Sort a list of simple types in c#',
2184 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
2185 'upload_date': '20130831',
2186 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
2188 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
2189 'live_status': 'not_live',
2190 'categories': ['Education'],
2191 'availability': 'public',
2192 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
2194 'playable_in_embed': True,
2198 'channel': 'kudvenkat',
2199 'comment_count': int,
2200 'channel_follower_count': int,
2202 'uploader': 'kudvenkat',
2203 'uploader_url': 'https://www.youtube.com/@Csharp-video-tutorialsBlogspot',
2204 'uploader_id': '@Csharp-video-tutorialsBlogspot',
2205 'channel_is_verified': True,
2206 'heatmap': 'count:100',
2207 'timestamp': 1377976349,
2210 'skip_download': True,
2214 # another example of '};' in ytInitialData
2215 'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
2216 'only_matching': True,
2219 'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
2220 'only_matching': True,
2223 # https://github.com/ytdl-org/youtube-dl/pull/28094
2224 'url': 'OtqTfy26tG0',
2226 'id': 'OtqTfy26tG0',
2228 'title': 'Burn Out',
2229 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
2230 'upload_date': '20141120',
2231 'artist': 'The Cinematic Orchestra',
2232 'track': 'Burn Out',
2233 'album': 'Every Day',
2235 'live_status': 'not_live',
2236 'alt_title': 'Burn Out',
2240 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2241 'creator': 'The Cinematic Orchestra',
2242 'channel': 'The Cinematic Orchestra',
2243 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
2244 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2245 'availability': 'public',
2246 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
2247 'categories': ['Music'],
2248 'playable_in_embed': True,
2249 'channel_follower_count': int,
2250 'uploader': 'The Cinematic Orchestra',
2251 'comment_count': int,
2254 'skip_download': True,
2258 # controversial video, only works with bpctr when authenticated with cookies
2259 'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
2260 'only_matching': True,
2263 # controversial video, requires bpctr/contentCheckOk
2264 'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
2266 'id': 'SZJvDhaSDnc',
2268 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
2269 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
2270 'upload_date': '20140716',
2271 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
2273 'categories': ['News & Politics'],
2275 'channel': 'CBS Mornings',
2276 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
2277 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
2279 'availability': 'needs_auth',
2280 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
2282 'live_status': 'not_live',
2283 'playable_in_embed': True,
2284 'channel_follower_count': int,
2285 'uploader': 'CBS Mornings',
2286 'uploader_url': 'https://www.youtube.com/@CBSMornings',
2287 'uploader_id': '@CBSMornings',
2288 'comment_count': int,
2289 'channel_is_verified': True,
2290 'timestamp': 1405513526,
2294 # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
2295 'url': 'cBvYw8_A0vQ',
2297 'id': 'cBvYw8_A0vQ',
2299 'title': '4K Ueno Okachimachi Street Scenes 上野御徒町歩き',
2300 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
2301 'upload_date': '20201120',
2303 'categories': ['Travel & Events'],
2304 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2306 'channel': 'Walk around Japan',
2307 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
2308 'thumbnail': 'https://i.ytimg.com/vi/cBvYw8_A0vQ/hqdefault.jpg',
2310 'availability': 'public',
2311 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2312 'live_status': 'not_live',
2313 'playable_in_embed': True,
2314 'channel_follower_count': int,
2315 'uploader': 'Walk around Japan',
2316 'uploader_url': 'https://www.youtube.com/@walkaroundjapan7124',
2317 'uploader_id': '@walkaroundjapan7124',
2318 'timestamp': 1605884416,
2321 'skip_download': True,
2324 # Has multiple audio streams
2325 'url': 'WaOKSUlf4TM',
2326 'only_matching': True,
2328 # Requires Premium: has format 141 when requested using YTM url
2329 'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2330 'only_matching': True,
2332 # multiple subtitles with same lang_code
2333 'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2334 'only_matching': True,
2336 # Force use android client fallback
2337 'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2339 'id': 'YOelRv7fMxY',
2340 'title': 'DIGGING A SECRET TUNNEL Part 1',
2342 'upload_date': '20210624',
2343 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2344 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2345 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2347 'categories': ['Entertainment'],
2349 'channel': 'colinfurze',
2350 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2351 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2353 'availability': 'public',
2355 'live_status': 'not_live',
2356 'playable_in_embed': True,
2357 'channel_follower_count': int,
2359 'uploader': 'colinfurze',
2360 'uploader_url': 'https://www.youtube.com/@colinfurze',
2361 'uploader_id': '@colinfurze',
2362 'comment_count': int,
2363 'channel_is_verified': True,
2364 'heatmap': 'count:100',
2367 'format': '17', # 3gp format available on android
2368 'extractor_args': {'youtube': {'player_client': ['android']}},
2370 'skip': 'android client broken',
2373 # Skip download of additional client configs (remix client config in this case)
2374 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2375 'only_matching': True,
2377 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2381 'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2382 'only_matching': True,
2384 'note': 'Storyboards',
2385 'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2387 'id': '5KLPxDtMqe8',
2390 'title': 'Your Brain is Plastic',
2391 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2392 'upload_date': '20140324',
2394 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2395 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2397 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2398 'playable_in_embed': True,
2400 'availability': 'public',
2401 'channel': 'SciShow',
2402 'live_status': 'not_live',
2404 'categories': ['Education'],
2406 'channel_follower_count': int,
2408 'uploader': 'SciShow',
2409 'uploader_url': 'https://www.youtube.com/@SciShow',
2410 'uploader_id': '@SciShow',
2411 'comment_count': int,
2412 'channel_is_verified': True,
2413 'heatmap': 'count:100',
2414 'timestamp': 1395685455,
2415 }, 'params': {'format': 'mhtml', 'skip_download': True},
2417 # Ensure video upload_date is in UTC timezone (video was uploaded 1641170939)
2418 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2420 'id': '2NUZ8W2llS4',
2422 'title': 'The NP that test your phone performance 🙂',
2423 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2424 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2425 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2429 'categories': ['Gaming'],
2431 'playable_in_embed': True,
2432 'live_status': 'not_live',
2433 'upload_date': '20220103',
2435 'availability': 'public',
2436 'channel': 'Leon Nguyen',
2437 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2438 'comment_count': int,
2439 'channel_follower_count': int,
2440 'uploader': 'Leon Nguyen',
2441 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2442 'uploader_id': '@LeonNguyen',
2443 'heatmap': 'count:100',
2444 'timestamp': 1641170939,
2447 # date text is premiered video, ensure upload date in UTC (published 1641172509)
2448 'url': 'https://www.youtube.com/watch?v=mzZzzBU6lrM',
2450 'id': 'mzZzzBU6lrM',
2452 'title': 'I Met GeorgeNotFound In Real Life...',
2453 'description': 'md5:978296ec9783a031738b684d4ebf302d',
2454 'channel_id': 'UC_8NknAFiyhOUaZqHR3lq3Q',
2455 'channel_url': 'https://www.youtube.com/channel/UC_8NknAFiyhOUaZqHR3lq3Q',
2459 'categories': ['Entertainment'],
2461 'playable_in_embed': True,
2462 'live_status': 'not_live',
2463 'release_timestamp': 1641172509,
2464 'release_date': '20220103',
2465 'upload_date': '20220103',
2467 'availability': 'public',
2468 'channel': 'Quackity',
2469 'thumbnail': 'https://i.ytimg.com/vi/mzZzzBU6lrM/maxresdefault.jpg',
2470 'channel_follower_count': int,
2471 'uploader': 'Quackity',
2472 'uploader_id': '@Quackity',
2473 'uploader_url': 'https://www.youtube.com/@Quackity',
2474 'comment_count': int,
2475 'channel_is_verified': True,
2476 'heatmap': 'count:100',
2477 'timestamp': 1641172509,
2480 { # continuous livestream.
2481 # Upload date was 2022-07-12T05:12:29-07:00, while stream start is 2022-07-12T15:59:30+00:00
2482 'url': 'https://www.youtube.com/watch?v=jfKfPfyJRdk',
2484 'id': 'jfKfPfyJRdk',
2486 'channel_id': 'UCSJ4gkVC6NrvII8umztf0Ow',
2488 'uploader': 'Lofi Girl',
2489 'categories': ['Music'],
2490 'concurrent_view_count': int,
2491 'playable_in_embed': True,
2492 'timestamp': 1657627949,
2493 'release_date': '20220712',
2494 'channel_url': 'https://www.youtube.com/channel/UCSJ4gkVC6NrvII8umztf0Ow',
2495 'description': 'md5:13a6f76df898f5674f9127139f3df6f7',
2497 'thumbnail': 'https://i.ytimg.com/vi/jfKfPfyJRdk/maxresdefault.jpg',
2498 'release_timestamp': 1657641570,
2499 'uploader_url': 'https://www.youtube.com/@LofiGirl',
2500 'channel_follower_count': int,
2501 'channel_is_verified': True,
2502 'title': r're:^lofi hip hop radio 📚 - beats to relax/study to',
2504 'live_status': 'is_live',
2506 'channel': 'Lofi Girl',
2507 'availability': 'public',
2508 'upload_date': '20220712',
2509 'uploader_id': '@LofiGirl',
2511 'params': {'skip_download': True},
2513 'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2515 'id': 'tjjjtzRLHvA',
2517 'title': 'ハッシュタグ無し };if window.ytcsi',
2518 'upload_date': '20220323',
2520 'availability': 'unlisted',
2521 'channel': 'Lesmiscore',
2522 'thumbnail': r're:^https?://.*\.jpg',
2524 'categories': ['Music'],
2527 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2528 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2529 'live_status': 'not_live',
2530 'playable_in_embed': True,
2531 'channel_follower_count': int,
2534 'uploader_id': '@lesmiscore',
2535 'uploader': 'Lesmiscore',
2536 'uploader_url': 'https://www.youtube.com/@lesmiscore',
2537 'timestamp': 1648005313,
2540 # Prefer primary title+description language metadata by default
2541 # Do not prefer translated description if primary is empty
2542 'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2544 'id': 'el3E4MbxRqQ',
2546 'title': 'dlp test video 2 - primary sv no desc',
2548 'channel': 'cole-dlp-test-acc',
2551 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2553 'playable_in_embed': True,
2554 'availability': 'unlisted',
2555 'thumbnail': r're:^https?://.*\.jpg',
2558 'live_status': 'not_live',
2559 'upload_date': '20220908',
2560 'categories': ['People & Blogs'],
2561 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2562 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2563 'uploader_id': '@coletdjnz',
2564 'uploader': 'cole-dlp-test-acc',
2565 'timestamp': 1662677394,
2567 'params': {'skip_download': True},
2569 # Extractor argument: prefer translated title+description
2570 'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2572 'id': 'gHKT4uU8Zng',
2574 'channel': 'cole-dlp-test-acc',
2577 'live_status': 'not_live',
2578 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2579 'upload_date': '20220729',
2581 'categories': ['People & Blogs'],
2582 'thumbnail': r're:^https?://.*\.jpg',
2583 'title': 'dlp test video title translated (fr)',
2584 'availability': 'public',
2586 'description': 'dlp test video description translated (fr)',
2587 'playable_in_embed': True,
2588 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2589 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2590 'uploader_id': '@coletdjnz',
2591 'uploader': 'cole-dlp-test-acc',
2592 'timestamp': 1659073275,
2595 'params': {'skip_download': True, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2596 'expected_warnings': [r'Preferring "fr" translated fields'],
2598 'note': '6 channel audio',
2599 'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2600 'only_matching': True,
2602 'note': 'Multiple HLS formats with same itag',
2603 'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2605 'id': 'kX3nB4PpJko',
2607 'categories': ['Entertainment'],
2608 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2609 'live_status': 'not_live',
2611 'channel_follower_count': int,
2612 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2613 'title': 'Last To Take Hand Off Jet, Keeps It!',
2614 'channel': 'MrBeast',
2615 'playable_in_embed': True,
2617 'upload_date': '20221112',
2618 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2620 'availability': 'public',
2621 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2624 'uploader': 'MrBeast',
2625 'uploader_url': 'https://www.youtube.com/@MrBeast',
2626 'uploader_id': '@MrBeast',
2627 'comment_count': int,
2628 'channel_is_verified': True,
2629 'heatmap': 'count:100',
2631 'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2633 'note': 'Audio formats with Dynamic Range Compression',
2634 'url': 'https://www.youtube.com/watch?v=Tq92D6wQ1mg',
2636 'id': 'Tq92D6wQ1mg',
2638 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
2639 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
2640 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
2641 'channel_follower_count': int,
2642 'description': 'md5:17eccca93a786d51bc67646756894066',
2643 'upload_date': '20191228',
2644 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
2645 'playable_in_embed': True,
2647 'categories': ['Entertainment'],
2648 'thumbnail': 'https://i.ytimg.com/vi/Tq92D6wQ1mg/sddefault.jpg',
2650 'channel': 'Projekt Melody',
2652 'availability': 'needs_auth',
2653 'comment_count': int,
2654 'live_status': 'not_live',
2656 'uploader': 'Projekt Melody',
2657 'uploader_id': '@ProjektMelody',
2658 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
2659 'timestamp': 1577508724,
2661 'params': {'extractor_args': {'youtube': {'player_client': ['tv_embedded']}}, 'format': '251-drc'},
2664 'url': 'https://www.youtube.com/live/qVv6vCqciTM',
2666 'id': 'qVv6vCqciTM',
2669 'comment_count': int,
2670 'chapters': 'count:13',
2671 'upload_date': '20221223',
2672 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
2673 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
2675 'release_date': '20221223',
2676 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
2677 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
2679 'playable_in_embed': True,
2681 'availability': 'public',
2682 'channel_follower_count': int,
2683 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
2684 'categories': ['Entertainment'],
2685 'live_status': 'was_live',
2686 'release_timestamp': 1671793345,
2687 'channel': 'さなちゃんねる',
2688 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
2689 'uploader': 'さなちゃんねる',
2690 'uploader_url': 'https://www.youtube.com/@sana_natori',
2691 'uploader_id': '@sana_natori',
2692 'channel_is_verified': True,
2693 'heatmap': 'count:100',
2694 'timestamp': 1671798112,
2698 # Fallbacks when webpage and web client is unavailable
2699 'url': 'https://www.youtube.com/watch?v=wSSmNUl9Snw',
2701 'id': 'wSSmNUl9Snw',
2703 # 'categories': ['Science & Technology'],
2705 'chapters': 'count:2',
2706 'channel': 'Scott Manley',
2709 # 'availability': 'public',
2710 'channel_follower_count': int,
2711 'live_status': 'not_live',
2712 'upload_date': '20170831',
2715 'uploader_url': 'https://www.youtube.com/@scottmanley',
2716 'description': 'md5:f4bed7b200404b72a394c2f97b782c02',
2717 'uploader': 'Scott Manley',
2718 'uploader_id': '@scottmanley',
2719 'title': 'The Computer Hack That Saved Apollo 14',
2720 'channel_id': 'UCxzC4EngIsMrPmbm6Nxvb-A',
2721 'thumbnail': r're:^https?://.*\.webp',
2722 'channel_url': 'https://www.youtube.com/channel/UCxzC4EngIsMrPmbm6Nxvb-A',
2723 'playable_in_embed': True,
2724 'comment_count': int,
2725 'channel_is_verified': True,
2726 'heatmap': 'count:100',
2729 'extractor_args': {'youtube': {'player_client': ['ios'], 'player_skip': ['webpage']}},
2735 # YouTube <object> embed
2737 'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2738 'md5': '873c81d308b979f0e23ee7e620b312a3',
2740 'id': 'msN87y-iEx0',
2742 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2743 'upload_date': '20080526',
2744 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2746 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2747 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2748 'playable_in_embed': True,
2749 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2751 'comment_count': int,
2752 'channel': 'Christopher Sykes',
2753 'live_status': 'not_live',
2754 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2755 'availability': 'public',
2758 'categories': ['Science & Technology'],
2759 'channel_follower_count': int,
2760 'uploader': 'Christopher Sykes',
2761 'uploader_url': 'https://www.youtube.com/@ChristopherSykesDocumentaries',
2762 'uploader_id': '@ChristopherSykesDocumentaries',
2763 'heatmap': 'count:100',
2764 'timestamp': 1211825920,
2767 'skip_download': True,
2773 def suitable(cls, url):
2774 from ..utils import parse_qs
2777 if qs.get('list', [None])[0]:
2779 return super().suitable(url)
2781 def __init__(self, *args, **kwargs):
2782 super().__init__(*args, **kwargs)
2783 self._code_cache = {}
2784 self._player_cache = {}
2786 def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2787 lock = threading.Lock()
2788 start_time = time.time()
2789 formats = [f for f in formats if f.get('is_from_start')]
2791 def refetch_manifest(format_id, delay):
2792 nonlocal formats, start_time, is_live
2793 if time.time() <= start_time + delay:
2796 _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2797 video_details = traverse_obj(prs, (..., 'videoDetails'), expected_type=dict)
2798 microformats = traverse_obj(
2799 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2801 _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2802 is_live = live_status == 'is_live'
2803 start_time = time.time()
2805 def mpd_feed(format_id, delay):
2807 @returns (manifest_url, manifest_stream_number, is_live) or None
2809 for retry in self.RetryManager(fatal=False):
2811 refetch_manifest(format_id, delay)
2813 f = next((f for f in formats if f['format_id'] == format_id), None)
2816 retry.error = f'{video_id}: Video is no longer live'
2818 retry.error = f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}'
2820 return f['manifest_url'], f['manifest_stream_number'], is_live
2824 f['is_live'] = is_live
2825 gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2826 live_start_time, mpd_feed, not is_live and f.copy())
2828 f['fragments'] = gen
2829 f['protocol'] = 'http_dash_segments_generator'
2831 f['fragments'] = LazyList(gen({}))
2832 del f['is_from_start']
2834 def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2835 FETCH_SPAN, MAX_DURATION = 5, 432000
2837 mpd_url, stream_number, is_live = None, None, True
2840 download_start_time = ctx.get('start') or time.time()
2842 lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2843 if lack_early_segments:
2844 self.report_warning(bug_reports_message(
2845 'Starting download from the last 120 hours of the live stream since '
2846 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2847 lack_early_segments = True
2849 known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2850 fragments, fragment_base_url = None, None
2852 def _extract_sequence_from_mpd(refresh_sequence, immediate):
2853 nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2854 # Obtain from MPD's maximum seq value
2855 old_mpd_url = mpd_url
2856 last_error = ctx.pop('last_error', None)
2857 expire_fast = immediate or last_error and isinstance(last_error, HTTPError) and last_error.status == 403
2858 mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2859 or (mpd_url, stream_number, False))
2860 if not refresh_sequence:
2861 if expire_fast and not is_live:
2862 return False, last_seq
2863 elif old_mpd_url == mpd_url:
2864 return True, last_seq
2865 if manifestless_orig_fmt:
2866 fmt_info = manifestless_orig_fmt
2869 fmts, _ = self._extract_mpd_formats_and_subtitles(
2870 mpd_url, None, note=False, errnote=False, fatal=False)
2871 except ExtractorError:
2874 no_fragment_score += 2
2875 return False, last_seq
2876 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2877 fragments = fmt_info['fragments']
2878 fragment_base_url = fmt_info['fragment_base_url']
2879 assert fragment_base_url
2881 _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2882 return True, _last_seq
2884 self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2886 fetch_time = time.time()
2887 if no_fragment_score > 30:
2889 if last_segment_url:
2890 # Obtain from "X-Head-Seqnum" header value from each segment
2892 urlh = self._request_webpage(
2893 last_segment_url, None, note=False, errnote=False, fatal=False)
2894 except ExtractorError:
2896 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2897 if last_seq is None:
2898 no_fragment_score += 2
2899 last_segment_url = None
2902 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2903 no_fragment_score += 2
2904 if not should_continue:
2907 if known_idx > last_seq:
2908 last_segment_url = None
2913 if begin_index < 0 and known_idx < 0:
2914 # skip from the start when it's negative value
2915 known_idx = last_seq + begin_index
2916 if lack_early_segments:
2917 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2919 for idx in range(known_idx, last_seq):
2920 # do not update sequence here or you'll get skipped some part of it
2921 should_continue, _ = _extract_sequence_from_mpd(False, False)
2922 if not should_continue:
2924 raise ExtractorError('breaking out of outer loop')
2925 last_segment_url = urljoin(fragment_base_url, f'sq/{idx}')
2927 'url': last_segment_url,
2928 'fragment_count': last_seq,
2930 if known_idx == last_seq:
2931 no_fragment_score += 5
2933 no_fragment_score = 0
2934 known_idx = last_seq
2935 except ExtractorError:
2938 if manifestless_orig_fmt:
2939 # Stop at the first iteration if running for post-live manifestless;
2940 # fragment count no longer increase since it starts
2943 time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2945 def _extract_player_url(self, *ytcfgs, webpage=None):
2946 player_url = traverse_obj(
2947 ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2948 get_all=False, expected_type=str)
2951 return urljoin('https://www.youtube.com', player_url)
2953 def _download_player_url(self, video_id, fatal=False):
2954 res = self._download_webpage(
2955 'https://www.youtube.com/iframe_api',
2956 note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2958 player_version = self._search_regex(
2959 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2961 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2963 def _signature_cache_id(self, example_sig):
2964 """ Return a string representation of a signature """
2965 return '.'.join(str(len(part)) for part in example_sig.split('.'))
2968 def _extract_player_info(cls, player_url):
2969 for player_re in cls._PLAYER_INFO_RE:
2970 id_m = re.search(player_re, player_url)
2974 raise ExtractorError(f'Cannot identify player {player_url!r}')
2975 return id_m.group('id')
2977 def _load_player(self, video_id, player_url, fatal=True):
2978 player_id = self._extract_player_info(player_url)
2979 if player_id not in self._code_cache:
2980 code = self._download_webpage(
2981 player_url, video_id, fatal=fatal,
2982 note='Downloading player ' + player_id,
2983 errnote=f'Download of {player_url} failed')
2985 self._code_cache[player_id] = code
2986 return self._code_cache.get(player_id)
2988 def _extract_signature_function(self, video_id, player_url, example_sig):
2989 player_id = self._extract_player_info(player_url)
2991 # Read from filesystem cache
2992 func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2993 assert os.path.basename(func_id) == func_id
2995 self.write_debug(f'Extracting signature function {func_id}')
2996 cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
2999 code = self._load_player(video_id, player_url)
3001 res = self._parse_sig_js(code)
3002 test_string = ''.join(map(chr, range(len(example_sig))))
3003 cache_spec = [ord(c) for c in res(test_string)]
3004 self.cache.store('youtube-sigfuncs', func_id, cache_spec)
3006 return lambda s: ''.join(s[i] for i in cache_spec)
3008 def _print_sig_code(self, func, example_sig):
3009 if not self.get_param('youtube_print_sig_code'):
3012 def gen_sig_code(idxs):
3013 def _genslice(start, end, step):
3014 starts = '' if start == 0 else str(start)
3015 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
3016 steps = '' if step == 1 else (':%d' % step)
3017 return f's[{starts}{ends}{steps}]'
3020 # Quelch pyflakes warnings - start will be set when step is set
3021 start = '(Never used)'
3022 for i, prev in zip(idxs[1:], idxs[:-1]):
3023 if step is not None:
3024 if i - prev == step:
3026 yield _genslice(start, prev, step)
3029 if i - prev in [-1, 1]:
3034 yield 's[%d]' % prev
3038 yield _genslice(start, i, step)
3040 test_string = ''.join(map(chr, range(len(example_sig))))
3041 cache_res = func(test_string)
3042 cache_spec = [ord(c) for c in cache_res]
3043 expr_code = ' + '.join(gen_sig_code(cache_spec))
3044 signature_id_tuple = '({})'.format(', '.join(str(len(p)) for p in example_sig.split('.')))
3045 code = (f'if tuple(len(p) for p in s.split(\'.\')) == {signature_id_tuple}:\n'
3046 f' return {expr_code}\n')
3047 self.to_screen('Extracted signature function:\n' + code)
3049 def _parse_sig_js(self, jscode):
3050 funcname = self._search_regex(
3051 (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3052 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3053 r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
3054 r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
3055 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+\))?',
3056 r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
3058 r'("|\')signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3059 r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
3060 r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3061 r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3062 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3063 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
3064 jscode, 'Initial JS player signature function name', group='sig')
3066 jsi = JSInterpreter(jscode)
3067 initial_function = jsi.extract_function(funcname)
3068 return lambda s: initial_function([s])
3070 def _cached(self, func, *cache_id):
3071 def inner(*args, **kwargs):
3072 if cache_id not in self._player_cache:
3074 self._player_cache[cache_id] = func(*args, **kwargs)
3075 except ExtractorError as e:
3076 self._player_cache[cache_id] = e
3077 except Exception as e:
3078 self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
3080 ret = self._player_cache[cache_id]
3081 if isinstance(ret, Exception):
3086 def _decrypt_signature(self, s, video_id, player_url):
3087 """Turn the encrypted s field into a working signature"""
3088 extract_sig = self._cached(
3089 self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
3090 func = extract_sig(video_id, player_url, s)
3091 self._print_sig_code(func, s)
3094 def _decrypt_nsig(self, s, video_id, player_url):
3095 """Turn the encrypted n field into a working signature"""
3096 if player_url is None:
3097 raise ExtractorError('Cannot decrypt nsig without player_url')
3098 player_url = urljoin('https://www.youtube.com', player_url)
3101 jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
3102 except ExtractorError as e:
3103 raise ExtractorError('Unable to extract nsig function code', cause=e)
3104 if self.get_param('youtube_print_sig_code'):
3105 self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
3108 extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
3109 ret = extract_nsig(jsi, func_code)(s)
3110 except JSInterpreter.Exception as e:
3112 jsi = PhantomJSwrapper(self, timeout=5000)
3113 except ExtractorError:
3115 self.report_warning(
3116 f'Native nsig extraction failed: Trying with PhantomJS\n'
3117 f' n = {s} ; player = {player_url}', video_id)
3118 self.write_debug(e, only_once=True)
3120 args, func_body = func_code
3122 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
3123 video_id=video_id, note='Executing signature code').strip()
3125 self.write_debug(f'Decrypted nsig {s} => {ret}')
3128 def _extract_n_function_name(self, jscode):
3129 funcname, idx = self._search_regex(
3130 r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
3131 jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
3135 return json.loads(js_to_json(self._search_regex(
3136 rf'var {re.escape(funcname)}\s*=\s*(\[.+?\])\s*[,;]', jscode,
3137 f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
3139 def _extract_n_function_code(self, video_id, player_url):
3140 player_id = self._extract_player_info(player_url)
3141 func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
3142 jscode = func_code or self._load_player(video_id, player_url)
3143 jsi = JSInterpreter(jscode)
3146 return jsi, player_id, func_code
3148 func_name = self._extract_n_function_name(jscode)
3151 func_code = self._search_regex(
3152 rf'''(?xs
){func_name}\s
*=\s
*function\s
*\
((?P
<var
>[\w$
]+)\
)\s
*
3153 # NB: The end of the regex is intentionally kept strict
3154 {{(?P<code>.+?}
}\s
*return\
[\w$
]+.join\
(""\
))}};''',
3155 jscode, 'nsig function', group=('var', 'code'), default=None)
3157 func_code = ([func_code[0]], func_code[1])
3159 self.write_debug('Extracting nsig function with jsinterp')
3160 func_code = jsi.extract_function_code(func_name)
3162 self.cache.store('youtube-nsig', player_id, func_code)
3163 return jsi, player_id, func_code
3165 def _extract_n_function_from_code(self, jsi, func_code):
3166 func = jsi.extract_function_from_code(*func_code)
3168 def extract_nsig(s):
3171 except JSInterpreter.Exception:
3173 except Exception as e:
3174 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
3176 if ret.startswith('enhanced_except_'):
3177 raise JSInterpreter.Exception('Signature function returned an exception')
3182 def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3184 Extract signatureTimestamp (sts)
3185 Required to tell API what sig/player version is in use.
3188 if isinstance(ytcfg, dict):
3189 sts = int_or_none(ytcfg.get('STS'))
3192 # Attempt to extract from player
3193 if player_url is None:
3194 error_msg = 'Cannot extract signature timestamp without player_url.'
3196 raise ExtractorError(error_msg)
3197 self.report_warning(error_msg)
3199 code = self._load_player(video_id, player_url, fatal=fatal)
3201 sts = int_or_none(self._search_regex(
3202 r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3203 'JS player signature timestamp', group='sts', fatal=fatal))
3206 def _mark_watched(self, video_id, player_responses):
3207 for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3208 label = 'fully ' if is_full else ''
3209 url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3210 expected_type=url_or_none)
3212 self.report_warning(f'Unable to mark {label}watched')
3214 parsed_url = urllib.parse.urlparse(url)
3215 qs = urllib.parse.parse_qs(parsed_url.query)
3217 # cpn generation algorithm is reverse engineered from base.js.
3218 # In fact it works even with dummy cpn.
3219 CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3220 cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(16))
3222 # # more consistent results setting it to right before the end
3223 video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3228 'cmt': video_length,
3229 'el': 'detailpage', # otherwise defaults to "shorts"
3233 # these seem to mark watchtime "history" in the real world
3234 # they're required, so send in a single value
3240 url = urllib.parse.urlunparse(
3241 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3243 self._download_webpage(
3244 url, video_id, f'Marking {label}watched',
3245 'Unable to mark watched', fatal=False)
3248 def _extract_from_webpage(cls, url, webpage):
3249 # Invidious Instances
3250 # https://github.com/yt-dlp/yt-dlp/issues/195
3251 # https://github.com/iv-org/invidious/pull/1730
3253 r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3256 yield cls.url_result(mobj.group('url'), cls)
3257 raise cls.StopExtraction
3259 yield from super()._extract_from_webpage(url, webpage)
3261 # lazyYT YouTube embed
3262 for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3263 yield cls.url_result(unescapeHTML(id_), cls, id_)
3265 # Wordpress "YouTube Video Importer" plugin
3266 for m in re.findall(r'''(?x
)<div
[^
>]+
3267 class=(?P
<q1
>[\'"])[^\'"]*\byvii
_single
_video
_player
\b[^
\'"]*(?P=q1)[^>]+
3268 data-video_id=(?P<q2>[\'"])([^
\'"]+)(?P=q2)''', webpage):
3269 yield cls.url_result(m[-1], cls, m[-1])
3272 def extract_id(cls, url):
3273 video_id = cls.get_temp_id(url)
3275 raise ExtractorError(f'Invalid URL: {url}')
3278 def _extract_chapters_from_json(self, data, duration):
3279 chapter_list = traverse_obj(
3281 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3282 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters',
3283 ), expected_type=list)
3285 return self._extract_chapters_helper(
3287 start_function=lambda chapter: float_or_none(
3288 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3289 title_function=lambda chapter: traverse_obj(
3290 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3293 def _extract_chapters_from_engagement_panel(self, data, duration):
3294 content_list = traverse_obj(
3296 ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3298 chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3299 chapter_title = lambda chapter: self._get_text(chapter, 'title')
3301 return next(filter(None, (
3302 self._extract_chapters_helper(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3303 chapter_time, chapter_title, duration)
3304 for contents in content_list)), [])
3306 def _extract_heatmap(self, data):
3307 return traverse_obj(data, (
3308 'frameworkUpdates', 'entityBatchUpdate', 'mutations',
3309 lambda _, v: v['payload']['macroMarkersListEntity']['markersList']['markerType'] == 'MARKER_TYPE_HEATMAP',
3310 'payload', 'macroMarkersListEntity', 'markersList', 'markers', ..., {
3311 'start_time': ('startMillis', {functools.partial(float_or_none, scale=1000)}),
3312 'end_time': {lambda x: (int(x['startMillis']) + int(x['durationMillis'])) / 1000},
3313 'value': ('intensityScoreNormalized', {float_or_none}),
3316 def _extract_comment(self, entities, parent=None):
3317 comment_entity_payload = get_first(entities, ('payload', 'commentEntityPayload', {dict}))
3318 if not (comment_id := traverse_obj(comment_entity_payload, ('properties', 'commentId', {str}))):
3321 toolbar_entity_payload = get_first(entities, ('payload', 'engagementToolbarStateEntityPayload', {dict}))
3322 time_text = traverse_obj(comment_entity_payload, ('properties', 'publishedTime', {str})) or ''
3326 'parent': parent or 'root',
3327 **traverse_obj(comment_entity_payload, {
3328 'text': ('properties', 'content', 'content', {str}),
3329 'like_count': ('toolbar', 'likeCountA11y', {parse_count}),
3330 'author_id': ('author', 'channelId', {self.ucid_or_none}),
3331 'author': ('author', 'displayName', {str}),
3332 'author_thumbnail': ('author', 'avatarThumbnailUrl', {url_or_none}),
3333 'author_is_uploader': ('author', 'isCreator', {bool}),
3334 'author_is_verified': ('author', 'isVerified', {bool}),
3335 'author_url': ('author', 'channelCommand', 'innertubeCommand', (
3336 ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'),
3337 ), {lambda x: urljoin('https://www.youtube.com', x)}),
3339 'is_favorited': (None if toolbar_entity_payload is None else
3340 toolbar_entity_payload.get('heartState') == 'TOOLBAR_HEART_STATE_HEARTED'),
3341 '_time_text': time_text, # FIXME: non-standard, but we need a way of showing that it is an estimate.
3342 'timestamp': self._parse_time_text(time_text),
3345 def _extract_comment_old(self, comment_renderer, parent=None):
3346 comment_id = comment_renderer.get('commentId')
3352 'text': self._get_text(comment_renderer, 'contentText'),
3353 'like_count': self._get_count(comment_renderer, 'voteCount'),
3354 'author_id': traverse_obj(comment_renderer, ('authorEndpoint', 'browseEndpoint', 'browseId', {self.ucid_or_none})),
3355 'author': self._get_text(comment_renderer, 'authorText'),
3356 'author_thumbnail': traverse_obj(comment_renderer, ('authorThumbnail', 'thumbnails', -1, 'url', {url_or_none})),
3357 'parent': parent or 'root',
3360 # Timestamp is an estimate calculated from the current time and time_text
3361 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3362 timestamp = self._parse_time_text(time_text)
3365 # FIXME: non-standard, but we need a way of showing that it is an estimate.
3366 '_time_text': time_text,
3367 'timestamp': timestamp,
3370 info['author_url'] = urljoin(
3371 'https://www.youtube.com', traverse_obj(comment_renderer, ('authorEndpoint', (
3372 ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'))),
3373 expected_type=str, get_all=False))
3375 author_is_uploader = traverse_obj(comment_renderer, 'authorIsChannelOwner')
3376 if author_is_uploader is not None:
3377 info['author_is_uploader'] = author_is_uploader
3379 comment_abr = traverse_obj(
3380 comment_renderer, ('actionButtons', 'commentActionButtonsRenderer'), expected_type=dict)
3381 if comment_abr is not None:
3382 info['is_favorited'] = 'creatorHeart' in comment_abr
3384 badges = self._extract_badges([traverse_obj(comment_renderer, 'authorCommentBadge')])
3385 if self._has_badge(badges, BadgeType.VERIFIED):
3386 info['author_is_verified'] = True
3388 is_pinned = traverse_obj(comment_renderer, 'pinnedCommentBadge')
3390 info['is_pinned'] = True
3394 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3396 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3398 def extract_header(contents):
3399 _continuation = None
3400 for content in contents:
3401 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3402 expected_comment_count = self._get_count(
3403 comments_header_renderer, 'countText', 'commentsCount')
3405 if expected_comment_count is not None:
3406 tracker['est_total'] = expected_comment_count
3407 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3408 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3410 sort_menu_item = try_get(
3411 comments_header_renderer,
3412 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3413 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3415 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3416 if not _continuation:
3419 sort_text = str_or_none(sort_menu_item.get('title'))
3421 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3422 self.to_screen(f'Sorting comments by {sort_text.lower()}')
3424 return _continuation
3426 def extract_thread(contents, entity_payloads):
3428 tracker['current_page_thread'] = 0
3429 for content in contents:
3430 if not parent and tracker['total_parent_comments'] >= max_parents:
3432 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3434 # old comment format
3435 if not entity_payloads:
3436 comment_renderer = get_first(
3437 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3438 expected_type=dict, default={})
3440 comment = self._extract_comment_old(comment_renderer, parent)
3442 # new comment format
3445 traverse_obj(comment_thread_renderer, ('commentViewModel', 'commentViewModel', {dict}))
3446 or traverse_obj(content, ('commentViewModel', {dict})))
3447 comment_keys = traverse_obj(view_model, (('commentKey', 'toolbarStateKey'), {str}))
3448 if not comment_keys:
3450 entities = traverse_obj(entity_payloads, lambda _, v: v['entityKey'] in comment_keys)
3451 comment = self._extract_comment(entities, parent)
3453 comment['is_pinned'] = traverse_obj(view_model, ('pinnedText', {str})) is not None
3457 comment_id = comment['id']
3459 if comment.get('is_pinned'):
3460 tracker['pinned_comment_ids'].add(comment_id)
3461 # Sometimes YouTube may break and give us infinite looping comments.
3462 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3463 if comment_id in tracker['seen_comment_ids']:
3464 if comment_id in tracker['pinned_comment_ids'] and not comment.get('is_pinned'):
3465 # Pinned comments may appear a second time in newest first sort
3466 # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3468 self.report_warning(
3469 'Detected YouTube comments looping. Stopping comment extraction '
3470 f'{"for this thread" if parent else ""} as we probably cannot get any more.')
3473 tracker['seen_comment_ids'].add(comment['id'])
3475 tracker['running_total'] += 1
3476 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3479 # Attempt to get the replies
3480 comment_replies_renderer = try_get(
3481 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3483 if comment_replies_renderer:
3484 tracker['current_page_thread'] += 1
3485 comment_entries_iter = self._comment_entries(
3486 comment_replies_renderer, ytcfg, video_id,
3487 parent=comment.get('id'), tracker=tracker)
3488 yield from itertools.islice(comment_entries_iter, min(
3489 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3491 # Keeps track of counts across recursive calls
3496 'current_page_thread': 0,
3497 'total_parent_comments': 0,
3498 'total_reply_comments': 0,
3499 'seen_comment_ids': set(),
3500 'pinned_comment_ids': set(),
3504 # YouTube comments have a max depth of 2
3505 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3507 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3508 'Set max replies in the max-comments extractor argument instead')
3509 if max_depth == 1 and parent:
3512 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = (
3513 int_or_none(p, default=sys.maxsize) for p in self._configuration_arg('max_comments') + [''] * 4)
3515 continuation = self._extract_continuation(root_continuation_data)
3518 is_forced_continuation = False
3519 is_first_continuation = parent is None
3520 if is_first_continuation and not continuation:
3521 # Sometimes you can get comments by generating the continuation yourself,
3522 # even if YouTube initially reports them being disabled - e.g. stories comments.
3523 # Note: if the comment section is actually disabled, YouTube may return a response with
3524 # required check_get_keys missing. So we will disable that check initially in this case.
3525 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3526 is_forced_continuation = True
3528 continuation_items_path = (
3529 'onResponseReceivedEndpoints', ..., ('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems')
3530 for page_num in itertools.count(0):
3531 if not continuation:
3533 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3534 comment_prog_str = f"({tracker['running_total']}
/~{tracker['est_total']}
)"
3536 if is_first_continuation:
3537 note_prefix = 'Downloading comment section API JSON'
3539 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3540 tracker['current_page_thread'], comment_prog_str)
3542 note_prefix = '{}Downloading comment{} API JSON page {} {}'.format(
3543 ' ' if parent else '', ' replies' if parent else '',
3544 page_num, comment_prog_str)
3546 # Do a deep check for incomplete data as sometimes YouTube may return no comments for a continuation
3547 # Ignore check if YouTube says the comment count is 0.
3548 check_get_keys = None
3549 if not is_forced_continuation and not (tracker['est_total'] == 0 and tracker['running_total'] == 0):
3550 check_get_keys = [[*continuation_items_path, ..., (
3551 'commentsHeaderRenderer' if is_first_continuation else ('commentThreadRenderer', 'commentViewModel', 'commentRenderer'))]]
3553 response = self._extract_response(
3554 item_id=None, query=continuation,
3555 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3556 check_get_keys=check_get_keys)
3557 except ExtractorError as e:
3558 # Ignore incomplete data error for replies if retries didn't work.
3559 # This is to allow any other parent comments and comment threads to be downloaded.
3560 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3561 if 'incomplete data' in str(e).lower() and parent:
3562 if self.get_param('ignoreerrors') in (True, 'only_download'):
3563 self.report_warning(
3564 'Received incomplete data for a comment reply thread and retrying did not help. '
3565 'Ignoring to let other comments be downloaded. Pass --no-ignore-errors to not ignore.')
3568 raise ExtractorError(
3569 'Incomplete data received for comment reply thread. '
3570 'Pass --ignore-errors to ignore and allow rest of comments to download.',
3573 is_forced_continuation = False
3575 mutations = traverse_obj(response, ('frameworkUpdates', 'entityBatchUpdate', 'mutations', ..., {dict}))
3576 for continuation_items in traverse_obj(response, continuation_items_path, expected_type=list, default=[]):
3577 if is_first_continuation:
3578 continuation = extract_header(continuation_items)
3579 is_first_continuation = False
3584 for entry in extract_thread(continuation_items, mutations):
3588 continuation = self._extract_continuation({'contents': continuation_items})
3592 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3593 if message and not parent and tracker['running_total'] == 0:
3594 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3595 raise self.CommentsDisabled
3598 def _generate_comment_continuation(video_id):
3600 Generates initial comment section continuation token from given video id
3602 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3603 return base64.b64encode(token.encode()).decode()
3605 def _get_comments(self, ytcfg, video_id, contents, webpage):
3606 """Entry for comment extraction"""
3607 def _real_comment_extract(contents):
3609 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3610 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3611 yield from self._comment_entries(renderer, ytcfg, video_id)
3613 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3614 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3617 def _get_checkok_params():
3618 return {'contentCheckOk': True, 'racyCheckOk': True}
3621 def _generate_player_context(cls, sts=None):
3623 'html5Preference': 'HTML5_PREF_WANTS',
3626 context['signatureTimestamp'] = sts
3628 'playbackContext': {
3629 'contentPlaybackContext': context,
3631 **cls._get_checkok_params(),
3635 def _is_agegated(player_response):
3636 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3639 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3640 AGE_GATE_REASONS = (
3641 'confirm your age', 'age-restricted', 'inappropriate', # reason
3642 'age_verification_required', 'age_check_required', # status
3644 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3647 def _is_unplayable(player_response):
3648 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3650 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3652 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3653 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3654 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3655 headers = self.generate_api_headers(
3656 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3659 'videoId': video_id,
3662 pp_arg = self._configuration_arg('player_params', [None], casesense=True)[0]
3664 yt_query['params'] = pp_arg
3666 yt_query.update(self._generate_player_context(sts))
3667 return self._extract_response(
3668 item_id=video_id, ep='player', query=yt_query,
3669 ytcfg=player_ytcfg, headers=headers, fatal=True,
3670 default_client=client,
3671 note='Downloading {} player API JSON'.format(client.replace('_', ' ').strip()),
3674 def _get_requested_clients(self, url, smuggled_data):
3675 requested_clients = []
3676 android_clients = []
3677 default = ['ios', 'web']
3678 allowed_clients = sorted(
3679 (client for client in INNERTUBE_CLIENTS if client[:1] != '_'),
3680 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3681 for client in self._configuration_arg('player_client'):
3682 if client == 'default':
3683 requested_clients.extend(default)
3684 elif client == 'all':
3685 requested_clients.extend(allowed_clients)
3686 elif client not in allowed_clients:
3687 self.report_warning(f'Skipping unsupported client {client}')
3688 elif client.startswith('android'):
3689 android_clients.append(client)
3691 requested_clients.append(client)
3692 # Force deprioritization of broken Android clients for format de-duplication
3693 requested_clients.extend(android_clients)
3694 if not requested_clients:
3695 requested_clients = default
3697 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3698 requested_clients.extend(
3699 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3701 return orderedSet(requested_clients)
3703 def _invalid_player_response(self, pr, video_id):
3704 # YouTube may return a different video player response than expected.
3705 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3706 if (pr_id := traverse_obj(pr, ('videoDetails', 'videoId'))) != video_id:
3709 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3712 initial_pr = self._search_json(
3713 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3716 if initial_pr and not self._invalid_player_response(initial_pr, video_id):
3717 # Android player_response does not have microFormats which are needed for
3718 # extraction of some data. So we return the initial_pr with formats
3719 # stripped out even if not requested by the user
3720 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3721 prs.append({**initial_pr, 'streamingData': None})
3723 all_clients = set(clients)
3724 clients = clients[::-1]
3726 def append_client(*client_names):
3727 """ Append the first client name that exists but not already used """
3728 for client_name in client_names:
3729 actual_client = _split_innertube_client(client_name)[0]
3730 if actual_client in INNERTUBE_CLIENTS:
3731 if actual_client not in all_clients:
3732 clients.append(client_name)
3733 all_clients.add(actual_client)
3736 tried_iframe_fallback = False
3738 skipped_clients = {}
3740 client, base_client, variant = _split_innertube_client(clients.pop())
3741 player_ytcfg = master_ytcfg if client == 'web' else {}
3742 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3743 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3745 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3746 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3747 if 'js' in self._configuration_arg('player_skip'):
3748 require_js_player = False
3751 if not player_url and not tried_iframe_fallback and require_js_player:
3752 player_url = self._download_player_url(video_id)
3753 tried_iframe_fallback = True
3756 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3757 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3758 except ExtractorError as e:
3759 self.report_warning(e)
3762 if pr_id := self._invalid_player_response(pr, video_id):
3763 skipped_clients[client] = pr_id
3765 # Save client name for introspection later
3766 name = short_client_name(client)
3767 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3768 sd[STREAMING_DATA_CLIENT_NAME] = name
3769 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3770 f[STREAMING_DATA_CLIENT_NAME] = name
3773 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3774 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3775 append_client(f'{base_client}_creator')
3776 elif self._is_agegated(pr):
3777 if variant == 'tv_embedded':
3778 append_client(f'{base_client}_embedded')
3780 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3783 self.report_warning(
3784 f'Skipping player responses from {"/".join(skipped_clients)} clients '
3785 f'(got player responses for video "{"/".join(set(skipped_clients.values()))}
" instead of "{video_id}
")')
3787 raise ExtractorError(
3788 'All player responses are invalid. Your IP is likely being blocked by Youtube', expected=True)
3790 raise ExtractorError('Failed to extract any player response')
3791 return prs, player_url
3793 def _needs_live_processing(self, live_status, duration):
3794 if (live_status == 'is_live' and self.get_param('live_from_start')
3795 or live_status == 'post_live' and (duration or 0) > 2 * 3600):
3798 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3799 CHUNK_SIZE = 10 << 20
3800 itags, stream_ids = collections.defaultdict(set), []
3801 itag_qualities, res_qualities = {}, {0: None}
3803 # Normally tiny is the smallest video-only formats. But
3804 # audio-only formats with unknown quality may get tagged as tiny
3806 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3807 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres',
3809 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3810 format_types = self._configuration_arg('formats')
3811 all_formats = 'duplicate' in format_types
3812 if self._configuration_arg('include_duplicate_formats'):
3814 self._downloader.deprecated_feature('[youtube] include_duplicate_formats extractor argument is deprecated. '
3815 'Use formats=duplicate extractor argument instead')
3817 def build_fragments(f):
3819 'url': update_url_query(f['url'], {
3820 'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}',
3822 } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3824 for fmt in streaming_formats:
3825 if fmt.get('targetDurationSec'):
3828 itag = str_or_none(fmt.get('itag'))
3829 audio_track = fmt.get('audioTrack') or {}
3830 stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3832 if stream_id in stream_ids:
3835 quality = fmt.get('quality')
3836 height = int_or_none(fmt.get('height'))
3837 if quality == 'tiny' or not quality:
3838 quality = fmt.get('audioQuality', '').lower() or quality
3839 # The 3gp format (17) in android client has a quality of "small
",
3840 # but is actually worse than other formats
3845 itag_qualities[itag] = quality
3847 res_qualities[height] = quality
3848 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3849 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3850 # number of fragment that would subsequently requested with (`&sq=N`)
3851 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3854 fmt_url = fmt.get('url')
3856 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3857 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3858 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3859 if not all((sc, fmt_url, player_url, encrypted_sig)):
3862 fmt_url += '&{}={}'.format(
3863 traverse_obj(sc, ('sp', -1)) or 'signature',
3864 self._decrypt_signature(encrypted_sig, video_id, player_url),
3866 except ExtractorError as e:
3867 self.report_warning('Signature extraction failed: Some formats may be missing',
3868 video_id=video_id, only_once=True)
3869 self.write_debug(e, only_once=True)
3872 query = parse_qs(fmt_url)
3876 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3877 fmt_url = update_url_query(fmt_url, {
3878 'n': decrypt_nsig(query['n'][0], video_id, player_url),
3880 except ExtractorError as e:
3882 if isinstance(e, JSInterpreter.Exception):
3883 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3884 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3886 self.report_warning(
3887 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3888 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3889 self.write_debug(e, only_once=True)
3891 self.report_warning(
3892 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3893 video_id=video_id, only_once=True)
3896 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3897 language_preference = (
3898 10 if audio_track.get('audioIsDefault') and 10
3899 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3901 format_duration = traverse_obj(fmt, ('approxDurationMs', {lambda x: float_or_none(x, 1000)}))
3902 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3903 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3904 # Make sure to avoid false positives with small duration differences.
3905 # E.g. __2ABJjxzNo, ySuUZEjARPY
3906 is_damaged = try_call(lambda: format_duration < duration // 2)
3908 self.report_warning(
3909 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3911 client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3912 # Android client formats are broken due to integrity check enforcement
3913 # Ref: https://github.com/yt-dlp/yt-dlp/issues/9554
3914 is_broken = client_name and client_name.startswith(short_client_name('android'))
3916 self.report_warning(
3917 f'{video_id}: Android client formats are broken and may yield HTTP Error 403. '
3918 'They will be deprioritized', only_once=True)
3920 name = fmt.get('qualityLabel') or quality.replace('audio_quality_', '') or ''
3921 fps = int_or_none(fmt.get('fps')) or 0
3923 'asr': int_or_none(fmt.get('audioSampleRate')),
3924 'filesize': int_or_none(fmt.get('contentLength')),
3925 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3926 'format_note': join_nonempty(
3927 join_nonempty(audio_track.get('displayName'),
3928 language_preference > 0 and ' (default)', delim=''),
3929 name, fmt.get('isDrc') and 'DRC',
3930 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3931 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3932 throttled and 'THROTTLED', is_damaged and 'DAMAGED', is_broken and 'BROKEN',
3933 (self.get_param('verbose') or all_formats) and client_name,
3935 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3936 'source_preference': ((-10 if throttled else -5 if itag == '22' else -1)
3937 + (100 if 'Premium' in name else 0)),
3938 'fps': fps if fps > 1 else None, # For some formats, fps is wrongly returned as 1
3939 'audio_channels': fmt.get('audioChannels'),
3941 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3942 'has_drm': bool(fmt.get('drmFamilies')),
3944 'filesize_approx': filesize_from_tbr(tbr, format_duration),
3946 'width': int_or_none(fmt.get('width')),
3947 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3948 'desc' if language_preference < -1 else '') or None,
3949 'language_preference': language_preference,
3950 # Strictly de-prioritize broken, damaged and 3gp formats
3951 'preference': -20 if is_broken else -10 if is_damaged else -2 if itag == '17' else None,
3953 mime_mobj = re.match(
3954 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3956 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3957 dct.update(parse_codecs(mime_mobj.group(2)))
3959 itags[itag].add(('https
', dct.get('language
')))
3960 stream_ids.append(stream_id)
3961 single_stream = 'none
' in (dct.get('acodec
'), dct.get('vcodec
'))
3962 if single_stream and dct.get('ext
'):
3963 dct['container
'] = dct['ext
'] + '_dash
'
3965 if (all_formats or 'dashy
' in format_types) and dct['filesize
']:
3968 'format_id
': f'{dct["format_id"]}
-dashy
' if all_formats else dct['format_id
'],
3969 'protocol
': 'http_dash_segments
',
3970 'fragments
': build_fragments(dct),
3972 if all_formats or 'dashy
' not in format_types:
3973 dct['downloader_options
'] = {'http_chunk_size': CHUNK_SIZE}
3976 needs_live_processing = self._needs_live_processing(live_status, duration)
3977 skip_bad_formats = 'incomplete
' not in format_types
3978 if self._configuration_arg('include_incomplete_formats
'):
3979 skip_bad_formats = False
3980 self._downloader.deprecated_feature('[youtube
] include_incomplete_formats extractor argument
is deprecated
. '
3981 'Use formats
=incomplete extractor argument instead
')
3983 skip_manifests = set(self._configuration_arg('skip
'))
3984 if (not self.get_param('youtube_include_hls_manifest
', True)
3985 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3986 or needs_live_processing and skip_bad_formats):
3987 skip_manifests.add('hls
')
3989 if not self.get_param('youtube_include_dash_manifest
', True):
3990 skip_manifests.add('dash
')
3991 if self._configuration_arg('include_live_dash
'):
3992 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3993 'Use formats
=incomplete extractor argument instead
')
3994 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3995 skip_manifests.add('dash
')
3997 def process_manifest_format(f, proto, client_name, itag):
3998 key = (proto, f.get('language
'))
3999 if not all_formats and key in itags[itag]:
4001 itags[itag].add(key)
4003 if itag and all_formats:
4004 f['format_id
'] = f'{itag}
-{proto}
'
4005 elif any(p != proto for p, _ in itags[itag]):
4006 f['format_id
'] = f'{itag}
-{proto}
'
4008 f['format_id
'] = itag
4010 if f.get('source_preference
') is None:
4011 f['source_preference
'] = -1
4013 if itag in ('616', '235'):
4014 f['format_note
'] = join_nonempty(f.get('format_note
'), 'Premium
', delim=' ')
4015 f['source_preference
'] += 100
4017 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
4018 if f['quality
'] == -1 and f.get('height
'):
4019 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
4020 if self.get_param('verbose
') or all_formats:
4021 f['format_note
'] = join_nonempty(f.get('format_note
'), client_name, delim=', ')
4022 if f.get('fps
') and f['fps
'] <= 1:
4025 if proto == 'hls
' and f.get('has_drm
'):
4026 f['has_drm
'] = 'maybe
'
4027 f['source_preference
'] -= 5
4031 for sd in streaming_data:
4032 client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
4034 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
4035 if hls_manifest_url:
4036 fmts, subs = self._extract_m3u8_formats_and_subtitles(
4037 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
4038 subtitles = self._merge_subtitles(subs, subtitles)
4040 if process_manifest_format(f, 'hls
', client_name, self._search_regex(
4041 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
4044 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
4045 if dash_manifest_url:
4046 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
4047 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
4049 if process_manifest_format(f, 'dash
', client_name, f['format_id
']):
4050 f['filesize
'] = int_or_none(self._search_regex(
4051 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
4052 if needs_live_processing:
4053 f['is_from_start
'] = True
4058 def _extract_storyboard(self, player_responses, duration):
4060 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
4061 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
4065 for i, args in enumerate(spec):
4066 args = args.split('#')
4067 counts
= list(map(int_or_none
, args
[:5]))
4068 if len(args
) != 8 or not all(counts
):
4069 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
4071 width
, height
, frame_count
, cols
, rows
= counts
4074 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
4075 fragment_count
= frame_count
/ (cols
* rows
)
4076 fragment_duration
= duration
/ fragment_count
4078 'format_id': f
'sb{i}',
4079 'format_note': 'storyboard',
4081 'protocol': 'mhtml',
4087 'fps': frame_count
/ duration
,
4091 'url': url
.replace('$M', str(j
)),
4092 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
4093 } for j
in range(math
.ceil(fragment_count
))],
4096 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
4098 if 'webpage' not in self
._configuration
_arg
('player_skip'):
4099 query
= {'bpctr': '9999999999', 'has_verified': '1'}
4100 pp
= self
._configuration
_arg
('player_params', [None], casesense
=True)[0]
4103 webpage
= self
._download
_webpage
(
4104 webpage_url
, video_id
, fatal
=False, query
=query
)
4106 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
4108 player_responses
, player_url
= self
._extract
_player
_responses
(
4109 self
._get
_requested
_clients
(url
, smuggled_data
),
4110 video_id
, webpage
, master_ytcfg
, smuggled_data
)
4112 return webpage
, master_ytcfg
, player_responses
, player_url
4114 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
4115 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
4116 is_live
= get_first(video_details
, 'isLive')
4118 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
4119 live_content
= get_first(video_details
, 'isLiveContent')
4120 is_upcoming
= get_first(video_details
, 'isUpcoming')
4121 post_live
= get_first(video_details
, 'isPostLiveDvr')
4122 live_status
= ('post_live' if post_live
4123 else 'is_live' if is_live
4124 else 'is_upcoming' if is_upcoming
4125 else 'was_live' if live_content
4126 else 'not_live' if False in (is_live
, live_content
)
4128 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'))
4129 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
4130 if all(f
.get('has_drm') for f
in formats
):
4131 # If there are no formats that definitely don't have DRM, all have DRM
4135 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
4137 def _real_extract(self
, url
):
4138 url
, smuggled_data
= unsmuggle_url(url
, {})
4139 video_id
= self
._match
_id
(url
)
4141 base_url
= self
.http_scheme() + '//www.youtube.com/'
4142 webpage_url
= base_url
+ 'watch?v=' + video_id
4144 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
4146 playability_statuses
= traverse_obj(
4147 player_responses
, (..., 'playabilityStatus'), expected_type
=dict)
4149 trailer_video_id
= get_first(
4150 playability_statuses
,
4151 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
4153 if trailer_video_id
:
4154 return self
.url_result(
4155 trailer_video_id
, self
.ie_key(), trailer_video_id
)
4157 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
4158 if webpage
else (lambda x
: None))
4160 video_details
= traverse_obj(player_responses
, (..., 'videoDetails'), expected_type
=dict)
4161 microformats
= traverse_obj(
4162 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
4165 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
4166 video_title
= (self
._preferred
_lang
and translated_title
4167 or get_first(video_details
, 'title') # primary
4169 or search_meta(['og:title', 'twitter:title', 'title']))
4170 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
4171 original_description
= get_first(video_details
, 'shortDescription')
4172 video_description
= (
4173 self
._preferred
_lang
and translated_description
4174 # If original description is blank, it will be an empty string.
4175 # Do not prefer translated description in this case.
4176 or original_description
if original_description
is not None else translated_description
)
4178 multifeed_metadata_list
= get_first(
4180 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
4182 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
4183 if self
.get_param('noplaylist'):
4184 self
.to_screen(f
'Downloading just video {video_id} because of --no-playlist')
4188 for feed
in multifeed_metadata_list
.split(','):
4189 # Unquote should take place before split on comma (,) since textual
4190 # fields may contain comma as well (see
4191 # https://github.com/ytdl-org/youtube-dl/issues/8536)
4192 feed_data
= urllib
.parse
.parse_qs(
4193 urllib
.parse
.unquote_plus(feed
))
4195 def feed_entry(name
):
4197 feed_data
, lambda x
: x
[name
][0], str)
4199 feed_id
= feed_entry('id')
4202 feed_title
= feed_entry('title')
4205 title
+= f
' ({feed_title})'
4207 '_type': 'url_transparent',
4208 'ie_key': 'Youtube',
4210 '{}watch?v={}'.format(base_url
, feed_data
['id'][0]),
4211 {'force_singlefeed': True}
),
4214 feed_ids
.append(feed_id
)
4216 'Downloading multifeed video ({}) - add --no-playlist to just download video {}'.format(
4217 ', '.join(feed_ids
), video_id
))
4218 return self
.playlist_result(
4219 entries
, video_id
, video_title
, video_description
)
4221 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
4222 or int_or_none(get_first(microformats
, 'lengthSeconds'))
4223 or parse_duration(search_meta('duration')) or None)
4225 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
4226 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
4227 if live_status
== 'post_live':
4228 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
4231 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
4232 self
.report_drm(video_id
)
4234 playability_statuses
,
4235 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
4236 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
4237 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
4239 if subreason
== 'The uploader has not made this video available in your country.':
4240 countries
= get_first(microformats
, 'availableCountries')
4242 regions_allowed
= search_meta('regionsAllowed')
4243 countries
= regions_allowed
.split(',') if regions_allowed
else None
4244 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
4245 reason
+= f
'. {subreason}'
4247 self
.raise_no_formats(reason
, expected
=True)
4249 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
4250 if not keywords
and webpage
:
4252 unescapeHTML(m
.group('content'))
4253 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
4254 for keyword
in keywords
:
4255 if keyword
.startswith('yt:stretch='):
4256 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
4258 # NB: float is intentional for forcing float division
4259 w
, h
= (float(v
) for v
in mobj
.groups())
4263 if f
.get('vcodec') != 'none':
4264 f
['stretched_ratio'] = ratio
4266 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
4267 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
4270 'url': thumbnail_url
,
4272 original_thumbnails
= thumbnails
.copy()
4274 # The best resolution thumbnails sometimes does not appear in the webpage
4275 # See: https://github.com/yt-dlp/yt-dlp/issues/340
4276 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4278 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4279 # in resolution, these are not the custom thumbnail. So de-prioritize them
4280 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4281 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3',
4283 n_thumbnail_names
= len(thumbnail_names
)
4285 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4286 video_id
=video_id
, name
=name
, ext
=ext
,
4287 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
4288 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
4289 for thumb
in thumbnails
:
4290 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
4291 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
4292 self
._remove
_duplicate
_formats
(thumbnails
)
4293 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
4295 category
= get_first(microformats
, 'category') or search_meta('genre')
4296 channel_id
= self
.ucid_or_none(str_or_none(
4297 get_first(video_details
, 'channelId')
4298 or get_first(microformats
, 'externalChannelId')
4299 or search_meta('channelId')))
4300 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
4302 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
4303 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
4304 if not duration
and live_end_time
and live_start_time
:
4305 duration
= live_end_time
- live_start_time
4307 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
4309 def is_bad_format(fmt
):
4310 if needs_live_processing
and not fmt
.get('is_from_start'):
4312 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
4313 and fmt
.get('protocol') == 'http_dash_segments'):
4316 for fmt
in filter(is_bad_format
, formats
):
4317 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4318 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 2 hours)', delim
=' ')
4320 if needs_live_processing
:
4321 self
._prepare
_live
_from
_start
_formats
(
4322 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4324 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4326 channel_handle
= self
.handle_from_url(owner_profile_url
)
4330 'title': video_title
,
4332 'thumbnails': thumbnails
,
4333 # The best thumbnail that we are sure exists. Prevents unnecessary
4334 # URL checking if user don't care about getting the best possible thumbnail
4335 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4336 'description': video_description
,
4337 'channel_id': channel_id
,
4338 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None),
4339 'duration': duration
,
4340 'view_count': int_or_none(
4341 get_first((video_details
, microformats
), (..., 'viewCount'))
4342 or search_meta('interactionCount')),
4343 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4344 'age_limit': 18 if (
4345 get_first(microformats
, 'isFamilySafe') is False
4346 or search_meta('isFamilyFriendly') == 'false'
4347 or search_meta('og:restrictions:age') == '18+') else 0,
4348 'webpage_url': webpage_url
,
4349 'categories': [category
] if category
else None,
4351 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4352 'live_status': live_status
,
4353 'release_timestamp': live_start_time
,
4354 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4355 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto'),
4359 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4361 def get_lang_code(track
):
4362 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4363 or track
.get('languageCode'))
4365 # Converted into dicts to remove duplicates
4367 get_lang_code(sub
): sub
4368 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...))}
4369 translation_languages
= {
4370 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4371 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...))}
4373 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4374 lang_subs
= container
.setdefault(lang_code
, [])
4375 for fmt
in self
._SUBTITLE
_FORMATS
:
4381 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4385 # NB: Constructing the full subtitle dictionary is slow
4386 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4387 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4388 for lang_code
, caption_track
in captions
.items():
4389 base_url
= caption_track
.get('baseUrl')
4390 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4393 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4394 if caption_track
.get('kind') != 'asr':
4398 subtitles
, base_url
, lang_code
, lang_name
, {})
4399 if not caption_track
.get('isTranslatable'):
4401 for trans_code
, trans_name
in translation_languages
.items():
4404 orig_trans_code
= trans_code
4405 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4406 if not get_translated_subs
:
4408 trans_code
+= f
'-{lang_code}'
4409 trans_name
+= format_field(lang_name
, None, ' from %s')
4410 if lang_code
== f
'a-{orig_trans_code}':
4411 # Set audio language based on original subtitles
4413 if f
.get('acodec') != 'none' and not f
.get('language'):
4414 f
['language'] = orig_trans_code
4415 # Add an "-orig" label to the original language so that it can be distinguished.
4416 # The subs are returned without "-orig" as well for compatibility
4418 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4419 # Setting tlang=lang returns damaged subtitles.
4420 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4421 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4423 info
['automatic_captions'] = automatic_captions
4424 info
['subtitles'] = subtitles
4426 parsed_url
= urllib
.parse
.urlparse(url
)
4427 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4428 query
= urllib
.parse
.parse_qs(component
)
4429 for k
, v
in query
.items():
4430 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4432 if d_k
not in info
and k
in s_ks
:
4433 info
[d_k
] = parse_duration(v
[0])
4435 # Youtube Music Auto-generated description
4436 if (video_description
or '').strip().endswith('\nAuto-generated by YouTube.'):
4437 # XXX: Causes catastrophic backtracking if description has "·"
4438 # E.g. https://www.youtube.com/watch?v=DoPaAxMQoiI
4439 # Simulating atomic groups: (?P<a>[^xy]+)x => (?=(?P<a>[^xy]+))(?P=a)x
4440 # reduces it, but does not fully fix it. https://regex101.com/r/8Ssf2h/2
4443 (?=(?P<track>[^\n·]+))(?P=track)·
4444 (?=(?P<artist>[^\n]+))(?P=artist)\n+
4445 (?=(?P<album>[^\n]+))(?P=album)\n
4446 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4447 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4449 (?=(?P<clean_artist>[^\n]+))(?P=clean_artist)\n
4450 )?.+\nAuto-generated\ by\ YouTube\.\s*$
4451 ''', video_description
)
4453 release_year
= mobj
.group('release_year')
4454 release_date
= mobj
.group('release_date')
4456 release_date
= release_date
.replace('-', '')
4457 if not release_year
:
4458 release_year
= release_date
[:4]
4460 'album': mobj
.group('album'.strip()),
4461 'artists': ([a
] if (a
:= mobj
.group('clean_artist'))
4462 else [a
.strip() for a
in mobj
.group('artist').split('·')]),
4463 'track': mobj
.group('track').strip(),
4464 'release_date': release_date
,
4465 'release_year': int_or_none(release_year
),
4470 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4471 if not traverse_obj(initial_data
, 'contents'):
4472 self
.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4474 if not initial_data
:
4475 query
= {'videoId': video_id}
4476 query
.update(self
._get
_checkok
_params
())
4477 initial_data
= self
._extract
_response
(
4478 item_id
=video_id
, ep
='next', fatal
=False,
4479 ytcfg
=master_ytcfg
, query
=query
, check_get_keys
='contents',
4480 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4481 note
='Downloading initial data API JSON')
4483 info
['comment_count'] = traverse_obj(initial_data
, (
4484 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4485 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount',
4487 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4488 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo',
4489 ), expected_type
=self
._get
_count
, get_all
=False)
4491 try: # This will error if there is no livechat
4492 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4493 except (KeyError, IndexError, TypeError):
4496 info
.setdefault('subtitles', {})['live_chat'] = [{
4497 # url is needed to set cookies
4498 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4499 'video_id': video_id
,
4501 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4502 else 'youtube_live_chat_replay'),
4506 info
['chapters'] = (
4507 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4508 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4509 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4512 info
['heatmap'] = self
._extract
_heatmap
(initial_data
)
4514 contents
= traverse_obj(
4515 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4516 expected_type
=list, default
=[])
4518 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4520 stl
= vpir
.get('superTitleLink')
4522 stl
= self
._get
_text
(stl
)
4525 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4526 info
['location'] = stl
4528 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4531 'series': mobj
.group(1),
4532 'season_number': int(mobj
.group(2)),
4533 'episode_number': int(mobj
.group(3)),
4535 for tlb
in (try_get(
4537 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4541 tlb
, ('toggleButtonRenderer', ...),
4542 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4544 for getter
, regex
in [(
4545 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4546 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4547 lambda x
: x
['accessibility'],
4548 lambda x
: x
['accessibilityData']['accessibilityData'],
4549 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4550 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4552 mobj
= re
.match(regex
, label
)
4554 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4557 info
['like_count'] = traverse_obj(vpir
, (
4558 'videoActions', 'menuRenderer', 'topLevelButtons', ...,
4559 'segmentedLikeDislikeButtonViewModel', 'likeButtonViewModel', 'likeButtonViewModel',
4560 'toggleButtonViewModel', 'toggleButtonViewModel', 'defaultButtonViewModel',
4561 'buttonViewModel', 'accessibilityText', {parse_count}
), get_all
=False)
4563 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4565 vc
= self
._get
_count
(vcr
, 'viewCount')
4566 # Upcoming premieres with waiting count are treated as live here
4567 if vcr
.get('isLive'):
4568 info
['concurrent_view_count'] = vc
4569 elif info
.get('view_count') is None:
4570 info
['view_count'] = vc
4572 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4574 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4576 'channel': self
._get
_text
(vor
, 'title'),
4577 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4579 if not channel_handle
:
4580 channel_handle
= self
.handle_from_url(
4582 ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4583 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4584 {str}
), get_all
=False))
4588 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4590 multiple_songs
= False
4592 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4593 multiple_songs
= True
4596 mrr
= row
.get('metadataRowRenderer') or {}
4597 mrr_title
= mrr
.get('title')
4600 mrr_title
= self
._get
_text
(mrr
, 'title')
4601 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4602 if mrr_title
== 'License':
4603 info
['license'] = mrr_contents_text
4604 elif not multiple_songs
:
4605 if mrr_title
== 'Album':
4606 info
['album'] = mrr_contents_text
4607 elif mrr_title
== 'Artist':
4608 info
['artists'] = [mrr_contents_text
] if mrr_contents_text
else None
4609 elif mrr_title
== 'Song':
4610 info
['track'] = mrr_contents_text
4611 owner_badges
= self
._extract
_badges
(traverse_obj(vsir
, ('owner', 'videoOwnerRenderer', 'badges')))
4612 if self
._has
_badge
(owner_badges
, BadgeType
.VERIFIED
):
4613 info
['channel_is_verified'] = True
4616 'uploader': info
.get('channel'),
4617 'uploader_id': channel_handle
,
4618 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4621 # We only want timestamp IF it has time precision AND a timezone
4622 # Currently the uploadDate in microformats appears to be in US/Pacific timezone.
4624 parse_iso8601(get_first(microformats
, 'uploadDate'), timezone
=NO_DEFAULT
)
4625 or parse_iso8601(search_meta('uploadDate'), timezone
=NO_DEFAULT
)
4628 dt
.datetime
.fromtimestamp(timestamp
, dt
.timezone
.utc
).strftime('%Y%m%d') if timestamp
else
4630 unified_strdate(get_first(microformats
, 'uploadDate'))
4631 or unified_strdate(search_meta('uploadDate'))
4634 # In the case we cannot get the timestamp:
4635 # The upload date for scheduled, live and past live streams / premieres in microformats
4636 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4637 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4638 if not upload_date
or (not timestamp
and live_status
in ('not_live', None)):
4639 # this should be in UTC, as configured in the cookie/client context
4640 upload_date
= strftime_or_none(
4641 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText'))) or upload_date
4643 info
['upload_date'] = upload_date
4644 info
['timestamp'] = timestamp
4646 if upload_date
and live_status
not in ('is_live', 'post_live', 'is_upcoming'):
4647 # Newly uploaded videos' HLS formats are potentially problematic and need to be checked
4648 upload_datetime
= datetime_from_str(upload_date
).replace(tzinfo
=dt
.timezone
.utc
)
4649 if upload_datetime
>= datetime_from_str('today-2days'):
4650 for fmt
in info
['formats']:
4651 if fmt
.get('protocol') == 'm3u8_native':
4652 fmt
['__needs_testing'] = True
4654 for s_k
, d_k
in [('artists', 'creators'), ('track', 'alt_title')]:
4659 badges
= self
._extract
_badges
(traverse_obj(vpir
, 'badges'))
4661 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4662 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4664 info
['availability'] = (
4665 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4666 else self
._availability
(
4667 is_private
=is_private
,
4669 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4670 or False if initial_data
and is_private
is not None else None),
4671 needs_subscription
=(
4672 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4673 or False if initial_data
and is_private
is not None else None),
4674 needs_auth
=info
['age_limit'] >= 18,
4675 is_unlisted
=None if is_private
is None else (
4676 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4677 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4679 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4681 self
.mark_watched(video_id
, player_responses
)
4686 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4688 def passthrough_smuggled_data(func
):
4689 def _smuggle(info
, smuggled_data
):
4690 if info
.get('_type') not in ('url', 'url_transparent'):
4692 if smuggled_data
.get('is_music_url'):
4693 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4694 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4695 smuggled_data
.pop('is_music_url')
4696 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4698 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4701 @functools.wraps(func
)
4702 def wrapper(self
, url
):
4703 url
, smuggled_data
= unsmuggle_url(url
, {})
4704 if self
.is_music_url(url
):
4705 smuggled_data
['is_music_url'] = True
4706 info_dict
= func(self
, url
, smuggled_data
)
4708 _smuggle(info_dict
, smuggled_data
)
4709 if info_dict
.get('entries'):
4710 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4715 def _extract_basic_item_renderer(item
):
4716 # Modified from _extract_grid_item_renderer
4717 known_basic_renderers
= (
4718 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer',
4720 for key
, renderer
in item
.items():
4721 if not isinstance(renderer
, dict):
4723 elif key
in known_basic_renderers
:
4725 elif key
.startswith('grid') and key
.endswith('Renderer'):
4728 def _extract_channel_renderer(self
, renderer
):
4729 channel_id
= self
.ucid_or_none(renderer
['channelId'])
4730 title
= self
._get
_text
(renderer
, 'title')
4731 channel_url
= format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None)
4732 channel_handle
= self
.handle_from_url(
4733 traverse_obj(renderer
, (
4734 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4735 ('browseEndpoint', 'canonicalBaseUrl')),
4736 {str}
), get_all
=False))
4737 if not channel_handle
:
4738 # As of 2023-06-01, YouTube sets subscriberCountText to the handle in search
4739 channel_handle
= self
.handle_or_none(self
._get
_text
(renderer
, 'subscriberCountText'))
4744 'ie_key': YoutubeTabIE
.ie_key(),
4747 'channel_id': channel_id
,
4748 'channel_url': channel_url
,
4750 'uploader_id': channel_handle
,
4751 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4752 # See above. YouTube sets videoCountText to the subscriber text in search channel renderers.
4753 # However, in feed/channels this is set correctly to the subscriber count
4754 'channel_follower_count': traverse_obj(
4755 renderer
, 'subscriberCountText', 'videoCountText', expected_type
=self
._get
_count
),
4756 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
4758 # videoCountText may be the subscriber count
4759 self
._get
_count
(renderer
, 'videoCountText')
4760 if self
._get
_count
(renderer
, 'subscriberCountText') is not None else None),
4761 'description': self
._get
_text
(renderer
, 'descriptionSnippet'),
4762 'channel_is_verified': True if self
._has
_badge
(
4763 self
._extract
_badges
(traverse_obj(renderer
, 'ownerBadges')), BadgeType
.VERIFIED
) else None,
4766 def _grid_entries(self
, grid_renderer
):
4767 for item
in grid_renderer
['items']:
4768 if not isinstance(item
, dict):
4770 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4771 if not isinstance(renderer
, dict):
4773 title
= self
._get
_text
(renderer
, 'title')
4776 playlist_id
= renderer
.get('playlistId')
4778 yield self
.url_result(
4779 f
'https://www.youtube.com/playlist?list={playlist_id}',
4780 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4784 video_id
= renderer
.get('videoId')
4786 yield self
._extract
_video
(renderer
)
4789 channel_id
= renderer
.get('channelId')
4791 yield self
._extract
_channel
_renderer
(renderer
)
4793 # generic endpoint URL support
4794 ep_url
= urljoin('https://www.youtube.com/', try_get(
4795 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4798 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4799 if ie
.suitable(ep_url
):
4800 yield self
.url_result(
4801 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4804 def _music_reponsive_list_entry(self
, renderer
):
4805 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4807 title
= traverse_obj(renderer
, (
4808 'flexColumns', 0, 'musicResponsiveListItemFlexColumnRenderer',
4809 'text', 'runs', 0, 'text'))
4810 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4811 ie
=YoutubeIE
.ie_key(), video_id
=video_id
, title
=title
)
4812 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4814 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4816 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4817 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4818 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4819 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4820 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4822 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4823 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4825 def _shelf_entries_from_content(self
, shelf_renderer
):
4826 content
= shelf_renderer
.get('content')
4827 if not isinstance(content
, dict):
4829 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4831 # TODO: add support for nested playlists so each shelf is processed
4832 # as separate playlist
4833 # TODO: this includes only first N items
4834 yield from self
._grid
_entries
(renderer
)
4835 renderer
= content
.get('horizontalListRenderer')
4840 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4842 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4844 shelf_url
= urljoin('https://www.youtube.com', ep
)
4846 # Skipping links to another channels, note that checking for
4847 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4849 if skip_channels
and '/channels?' in shelf_url
:
4851 title
= self
._get
_text
(shelf_renderer
, 'title')
4852 yield self
.url_result(shelf_url
, video_title
=title
)
4853 # Shelf may not contain shelf URL, fallback to extraction from content
4854 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4856 def _playlist_entries(self
, video_list_renderer
):
4857 for content
in video_list_renderer
['contents']:
4858 if not isinstance(content
, dict):
4860 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4861 if not isinstance(renderer
, dict):
4863 video_id
= renderer
.get('videoId')
4866 yield self
._extract
_video
(renderer
)
4868 def _rich_entries(self
, rich_grid_renderer
):
4869 renderer
= traverse_obj(
4871 ('content', ('videoRenderer', 'reelItemRenderer', 'playlistRenderer')), get_all
=False) or {}
4872 video_id
= renderer
.get('videoId')
4874 yield self
._extract
_video
(renderer
)
4876 playlist_id
= renderer
.get('playlistId')
4878 yield self
.url_result(
4879 f
'https://www.youtube.com/playlist?list={playlist_id}',
4880 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4881 video_title
=self
._get
_text
(renderer
, 'title'))
4884 def _video_entry(self
, video_renderer
):
4885 video_id
= video_renderer
.get('videoId')
4887 return self
._extract
_video
(video_renderer
)
4889 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4890 url
= urljoin('https://youtube.com', traverse_obj(
4891 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4893 return self
.url_result(
4894 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4896 def _post_thread_entries(self
, post_thread_renderer
):
4897 post_renderer
= try_get(
4898 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4899 if not post_renderer
:
4902 video_renderer
= try_get(
4903 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4904 video_id
= video_renderer
.get('videoId')
4906 entry
= self
._extract
_video
(video_renderer
)
4909 # playlist attachment
4910 playlist_id
= try_get(
4911 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4913 yield self
.url_result(
4914 f
'https://www.youtube.com/playlist?list={playlist_id}',
4915 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4916 # inline video links
4917 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4919 if not isinstance(run
, dict):
4922 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4925 if not YoutubeIE
.suitable(ep_url
):
4927 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4928 if video_id
== ep_video_id
:
4930 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4932 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4933 contents
= post_thread_continuation
.get('contents')
4934 if not isinstance(contents
, list):
4936 for content
in contents
:
4937 renderer
= content
.get('backstagePostThreadRenderer')
4938 if isinstance(renderer
, dict):
4939 yield from self
._post
_thread
_entries
(renderer
)
4941 renderer
= content
.get('videoRenderer')
4942 if isinstance(renderer
, dict):
4943 yield self
._video
_entry
(renderer
)
4946 def _rich_grid_entries(self, contents):
4947 for content in contents:
4948 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4950 entry = self._video_entry(video_renderer)
4955 def _report_history_entries(self
, renderer
):
4956 for url
in traverse_obj(renderer
, (
4957 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4958 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4959 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4960 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4962 def _extract_entries(self
, parent_renderer
, continuation_list
):
4963 # continuation_list is modified in-place with continuation_list = [continuation_token]
4964 continuation_list
[:] = [None]
4965 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4966 for content
in contents
:
4967 if not isinstance(content
, dict):
4969 is_renderer
= traverse_obj(
4970 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4973 if content
.get('richItemRenderer'):
4974 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4976 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4977 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4978 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4979 yield from self
._report
_history
_entries
(table
)
4980 continuation_list
[0] = self
._extract
_continuation
(table
)
4983 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4984 for isr_content
in isr_contents
:
4985 if not isinstance(isr_content
, dict):
4989 'playlistVideoListRenderer': self
._playlist
_entries
,
4990 'gridRenderer': self
._grid
_entries
,
4991 'reelShelfRenderer': self
._grid
_entries
,
4992 'shelfRenderer': self
._shelf
_entries
,
4993 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4994 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4995 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4996 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4997 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4998 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)],
4999 'richGridRenderer': lambda x
: self
._extract
_entries
(x
, continuation_list
),
5001 for key
, renderer
in isr_content
.items():
5002 if key
not in known_renderers
:
5004 for entry
in known_renderers
[key
](renderer
):
5007 continuation_list
[0] = self
._extract
_continuation
(renderer
)
5010 if not continuation_list
[0]:
5011 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
5013 if not continuation_list
[0]:
5014 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
5016 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
5017 continuation_list
= [None]
5018 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
5019 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
5023 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
5024 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
5025 yield from extract_entries(parent_renderer
)
5026 continuation
= continuation_list
[0]
5027 seen_continuations
= set()
5028 for page_num
in itertools
.count(1):
5029 if not continuation
:
5031 continuation_token
= continuation
.get('continuation')
5032 if continuation_token
is not None and continuation_token
in seen_continuations
:
5033 self
.write_debug('Detected YouTube feed looping - assuming end of feed.')
5035 seen_continuations
.add(continuation_token
)
5036 headers
= self
.generate_api_headers(
5037 ytcfg
=ytcfg
, account_syncid
=account_syncid
, visitor_data
=visitor_data
)
5038 response
= self
._extract
_response
(
5039 item_id
=f
'{item_id} page {page_num}',
5040 query
=continuation
, headers
=headers
, ytcfg
=ytcfg
,
5041 check_get_keys
=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
5045 # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
5046 # See: https://github.com/ytdl-org/youtube-dl/issues/28702
5047 visitor_data
= self
._extract
_visitor
_data
(response
) or visitor_data
5050 'videoRenderer': (self
._grid
_entries
, 'items'), # for membership tab
5051 'gridPlaylistRenderer': (self
._grid
_entries
, 'items'),
5052 'gridVideoRenderer': (self
._grid
_entries
, 'items'),
5053 'gridChannelRenderer': (self
._grid
_entries
, 'items'),
5054 'playlistVideoRenderer': (self
._playlist
_entries
, 'contents'),
5055 'itemSectionRenderer': (extract_entries
, 'contents'), # for feeds
5056 'richItemRenderer': (extract_entries
, 'contents'), # for hashtag
5057 'backstagePostThreadRenderer': (self
._post
_thread
_continuation
_entries
, 'contents'),
5058 'reportHistoryTableRowRenderer': (self
._report
_history
_entries
, 'rows'),
5059 'playlistVideoListContinuation': (self
._playlist
_entries
, None),
5060 'gridContinuation': (self
._grid
_entries
, None),
5061 'itemSectionContinuation': (self
._post
_thread
_continuation
_entries
, None),
5062 'sectionListContinuation': (extract_entries
, None), # for feeds
5065 continuation_items
= traverse_obj(response
, (
5066 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
5067 'appendContinuationItemsAction', 'continuationItems',
5068 ), 'continuationContents', get_all
=False)
5069 continuation_item
= traverse_obj(continuation_items
, 0, None, expected_type
=dict, default
={})
5071 video_items_renderer
= None
5072 for key
in continuation_item
:
5073 if key
not in known_renderers
:
5075 func
, parent_key
= known_renderers
[key
]
5076 video_items_renderer
= {parent_key: continuation_items}
if parent_key
else continuation_items
5077 continuation_list
= [None]
5078 yield from func(video_items_renderer
)
5079 continuation
= continuation_list
[0] or self
._extract
_continuation
(video_items_renderer
)
5081 if not video_items_renderer
:
5085 def _extract_selected_tab(tabs
, fatal
=True):
5086 for tab_renderer
in tabs
:
5087 if tab_renderer
.get('selected'):
5090 raise ExtractorError('Unable to find selected tab')
5093 def _extract_tab_renderers(response
):
5094 return traverse_obj(
5095 response
, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type
=dict)
5097 def _extract_from_tabs(self
, item_id
, ytcfg
, data
, tabs
):
5098 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
5100 selected_tab
= self
._extract
_selected
_tab
(tabs
)
5101 metadata
['title'] += format_field(selected_tab
, 'title', ' - %s')
5102 metadata
['title'] += format_field(selected_tab
, 'expandedText', ' - %s')
5104 return self
.playlist_result(
5106 selected_tab
, metadata
['id'], ytcfg
,
5107 self
._extract
_account
_syncid
(ytcfg
, data
),
5108 self
._extract
_visitor
_data
(data
, ytcfg
)),
5111 def _extract_metadata_from_tabs(self
, item_id
, data
):
5112 info
= {'id': item_id}
5114 metadata_renderer
= traverse_obj(data
, ('metadata', 'channelMetadataRenderer'), expected_type
=dict)
5115 if metadata_renderer
:
5116 channel_id
= traverse_obj(metadata_renderer
, ('externalId', {self.ucid_or_none}
),
5117 ('channelUrl', {self.ucid_from_url}
))
5119 'channel': metadata_renderer
.get('title'),
5120 'channel_id': channel_id
,
5122 if info
['channel_id']:
5123 info
['id'] = info
['channel_id']
5125 metadata_renderer
= traverse_obj(data
, ('metadata', 'playlistMetadataRenderer'), expected_type
=dict)
5127 # pageHeaderViewModel slow rollout began April 2024
5128 page_header_view_model
= traverse_obj(data
, (
5129 'header', 'pageHeaderRenderer', 'content', 'pageHeaderViewModel', {dict}
))
5131 # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
5132 # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
5133 def _get_uncropped(url
):
5134 return url_or_none((url
or '').split('=')[0] + '=s0')
5136 avatar_thumbnails
= self
._extract
_thumbnails
(metadata_renderer
, 'avatar')
5137 if avatar_thumbnails
:
5138 uncropped_avatar
= _get_uncropped(avatar_thumbnails
[0]['url'])
5139 if uncropped_avatar
:
5140 avatar_thumbnails
.append({
5141 'url': uncropped_avatar
,
5142 'id': 'avatar_uncropped',
5147 self
._extract
_thumbnails
(data
, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
5148 or self
._extract
_thumbnails
(
5149 page_header_view_model
, ('banner', 'imageBannerViewModel', 'image'), final_key
='sources'))
5150 for banner
in channel_banners
:
5151 banner
['preference'] = -10
5154 uncropped_banner
= _get_uncropped(channel_banners
[0]['url'])
5155 if uncropped_banner
:
5156 channel_banners
.append({
5157 'url': uncropped_banner
,
5158 'id': 'banner_uncropped',
5162 # Deprecated - remove primary_sidebar_renderer when layout discontinued
5163 primary_sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer')
5164 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer'), expected_type
=dict)
5166 primary_thumbnails
= self
._extract
_thumbnails
(
5167 primary_sidebar_renderer
, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
5168 playlist_thumbnails
= self
._extract
_thumbnails
(
5169 playlist_header_renderer
, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
5172 'title': (traverse_obj(metadata_renderer
, 'title')
5173 or self
._get
_text
(data
, ('header', 'hashtagHeaderRenderer', 'hashtag'))
5175 'availability': self
._extract
_availability
(data
),
5176 'channel_follower_count': (
5177 self
._get
_count
(data
, ('header', ..., 'subscriberCountText'))
5178 or traverse_obj(page_header_view_model
, (
5179 'metadata', 'contentMetadataViewModel', 'metadataRows', ..., 'metadataParts',
5180 lambda _
, v
: 'subscribers' in v
['text']['content'], 'text', 'content', {parse_count}
, any
))),
5181 'description': try_get(metadata_renderer
, lambda x
: x
.get('description', '')),
5182 'tags': (traverse_obj(data
, ('microformat', 'microformatDataRenderer', 'tags', ..., {str}
))
5183 or traverse_obj(metadata_renderer
, ('keywords', {lambda x: x and shlex.split(x)}
, ...))),
5184 'thumbnails': (primary_thumbnails
or playlist_thumbnails
) + avatar_thumbnails
+ channel_banners
,
5188 traverse_obj(metadata_renderer
, (('vanityChannelUrl', ('ownerUrls', ...)), {self.handle_from_url}
), get_all
=False)
5189 or traverse_obj(data
, ('header', ..., 'channelHandleText', {self.handle_or_none}
), get_all
=False))
5193 'uploader_id': channel_handle
,
5194 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
5197 channel_badges
= self
._extract
_badges
(traverse_obj(data
, ('header', ..., 'badges'), get_all
=False))
5198 if self
._has
_badge
(channel_badges
, BadgeType
.VERIFIED
):
5199 info
['channel_is_verified'] = True
5200 # Playlist stats is a text runs array containing [video count, view count, last updated].
5201 # last updated or (view count and last updated) may be missing.
5202 playlist_stats
= get_first(
5203 (primary_sidebar_renderer
, playlist_header_renderer
), (('stats', 'briefStats', 'numVideosText'), ))
5205 last_updated_unix
= self
._parse
_time
_text
(
5206 self
._get
_text
(playlist_stats
, 2) # deprecated, remove when old layout discontinued
5207 or self
._get
_text
(playlist_header_renderer
, ('byline', 1, 'playlistBylineRenderer', 'text')))
5208 info
['modified_date'] = strftime_or_none(last_updated_unix
)
5210 info
['view_count'] = self
._get
_count
(playlist_stats
, 1)
5211 if info
['view_count'] is None: # 0 is allowed
5212 info
['view_count'] = self
._get
_count
(playlist_header_renderer
, 'viewCountText')
5213 if info
['view_count'] is None:
5214 info
['view_count'] = self
._get
_count
(data
, (
5215 'contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., 'tabRenderer', 'content', 'sectionListRenderer',
5216 'contents', ..., 'itemSectionRenderer', 'contents', ..., 'channelAboutFullMetadataRenderer', 'viewCountText'))
5218 info
['playlist_count'] = self
._get
_count
(playlist_stats
, 0)
5219 if info
['playlist_count'] is None: # 0 is allowed
5220 info
['playlist_count'] = self
._get
_count
(playlist_header_renderer
, ('byline', 0, 'playlistBylineRenderer', 'text'))
5222 if not info
.get('channel_id'):
5223 owner
= traverse_obj(playlist_header_renderer
, 'ownerText')
5224 if not owner
: # Deprecated
5225 owner
= traverse_obj(
5226 self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarSecondaryInfoRenderer'),
5227 ('videoOwner', 'videoOwnerRenderer', 'title'))
5228 owner_text
= self
._get
_text
(owner
)
5229 browse_ep
= traverse_obj(owner
, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
5231 'channel': self
._search
_regex
(r
'^by (.+) and \d+ others?$', owner_text
, 'uploader', default
=owner_text
),
5232 'channel_id': self
.ucid_or_none(browse_ep
.get('browseId')),
5233 'uploader_id': self
.handle_from_url(urljoin('https://www.youtube.com', browse_ep
.get('canonicalBaseUrl'))),
5237 'uploader': info
['channel'],
5238 'channel_url': format_field(info
.get('channel_id'), None, 'https://www.youtube.com/channel/%s', default
=None),
5239 'uploader_url': format_field(info
.get('uploader_id'), None, 'https://www.youtube.com/%s', default
=None),
5244 def _extract_inline_playlist(self
, playlist
, playlist_id
, data
, ytcfg
):
5245 first_id
= last_id
= response
= None
5246 for page_num
in itertools
.count(1):
5247 videos
= list(self
._playlist
_entries
(playlist
))
5250 start
= next((i
for i
, v
in enumerate(videos
) if v
['id'] == last_id
), -1) + 1
5251 if start
>= len(videos
):
5253 yield from videos
[start
:]
5254 first_id
= first_id
or videos
[0]['id']
5255 last_id
= videos
[-1]['id']
5256 watch_endpoint
= try_get(
5257 playlist
, lambda x
: x
['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
5258 headers
= self
.generate_api_headers(
5259 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5260 visitor_data
=self
._extract
_visitor
_data
(response
, data
, ytcfg
))
5262 'playlistId': playlist_id
,
5263 'videoId': watch_endpoint
.get('videoId') or last_id
,
5264 'index': watch_endpoint
.get('index') or len(videos
),
5265 'params': watch_endpoint
.get('params') or 'OAE%3D',
5267 response
= self
._extract
_response
(
5268 item_id
=f
'{playlist_id} page {page_num}',
5269 query
=query
, ep
='next', headers
=headers
, ytcfg
=ytcfg
,
5270 check_get_keys
='contents',
5273 response
, lambda x
: x
['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
5275 def _extract_from_playlist(self
, item_id
, url
, data
, playlist
, ytcfg
):
5276 title
= playlist
.get('title') or try_get(
5277 data
, lambda x
: x
['titleText']['simpleText'], str)
5278 playlist_id
= playlist
.get('playlistId') or item_id
5280 # Delegating everything except mix playlists to regular tab-based playlist URL
5281 playlist_url
= urljoin(url
, try_get(
5282 playlist
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
5285 # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
5286 # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
5287 is_known_unviewable
= re
.fullmatch(r
'MLCT|RLTD[\w-]{22}', playlist_id
)
5289 if playlist_url
and playlist_url
!= url
and not is_known_unviewable
:
5290 return self
.url_result(
5291 playlist_url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
5294 return self
.playlist_result(
5295 self
._extract
_inline
_playlist
(playlist
, playlist_id
, data
, ytcfg
),
5296 playlist_id
=playlist_id
, playlist_title
=title
)
5298 def _extract_availability(self
, data
):
5300 Gets the availability of a given playlist/tab.
5301 Note: Unless YouTube tells us explicitly, we do not assume it is public
5302 @param data: response
5304 sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer') or {}
5305 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer')) or {}
5306 player_header_privacy
= playlist_header_renderer
.get('privacy')
5308 badges
= self
._extract
_badges
(traverse_obj(sidebar_renderer
, 'badges'))
5310 # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
5311 privacy_setting_icon
= get_first(
5312 (playlist_header_renderer
, sidebar_renderer
),
5313 ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
5314 lambda _
, v
: v
['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
5317 microformats_is_unlisted
= traverse_obj(
5318 data
, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type
=bool)
5322 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
5323 or player_header_privacy
== 'PUBLIC'
5324 or privacy_setting_icon
== 'PRIVACY_PUBLIC')
5325 else self
._availability
(
5327 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
5328 or player_header_privacy
== 'PRIVATE' if player_header_privacy
is not None
5329 else privacy_setting_icon
== 'PRIVACY_PRIVATE' if privacy_setting_icon
is not None else None),
5331 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
5332 or player_header_privacy
== 'UNLISTED' if player_header_privacy
is not None
5333 else privacy_setting_icon
== 'PRIVACY_UNLISTED' if privacy_setting_icon
is not None
5334 else microformats_is_unlisted
if microformats_is_unlisted
is not None else None),
5335 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
5336 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
5340 def _extract_sidebar_info_renderer(data
, info_renderer
, expected_type
=dict):
5341 sidebar_renderer
= try_get(
5342 data
, lambda x
: x
['sidebar']['playlistSidebarRenderer']['items'], list) or []
5343 for item
in sidebar_renderer
:
5344 renderer
= try_get(item
, lambda x
: x
[info_renderer
], expected_type
)
5348 def _reload_with_unavailable_videos(self
, item_id
, data
, ytcfg
):
5350 Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
5352 is_playlist
= bool(traverse_obj(
5353 data
, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
5356 headers
= self
.generate_api_headers(
5357 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5358 visitor_data
=self
._extract
_visitor
_data
(data
, ytcfg
))
5360 'params': 'wgYCCAA=',
5361 'browseId': f
'VL{item_id}',
5363 return self
._extract
_response
(
5364 item_id
=item_id
, headers
=headers
, query
=query
,
5365 check_get_keys
='contents', fatal
=False, ytcfg
=ytcfg
,
5366 note
='Redownloading playlist API JSON with unavailable videos')
5368 @functools.cached_property
5369 def skip_webpage(self
):
5370 return 'webpage' in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key())
5372 def _extract_webpage(self
, url
, item_id
, fatal
=True):
5373 webpage
, data
= None, None
5374 for retry
in self
.RetryManager(fatal
=fatal
):
5376 webpage
= self
._download
_webpage
(url
, item_id
, note
='Downloading webpage')
5377 data
= self
.extract_yt_initial_data(item_id
, webpage
or '', fatal
=fatal
) or {}
5378 except ExtractorError
as e
:
5379 if isinstance(e
.cause
, network_exceptions
):
5380 if not isinstance(e
.cause
, HTTPError
) or e
.cause
.status
not in (403, 429):
5383 self
._error
_or
_warning
(e
, fatal
=fatal
)
5387 self
._extract
_and
_report
_alerts
(data
)
5388 except ExtractorError
as e
:
5389 self
._error
_or
_warning
(e
, fatal
=fatal
)
5392 # Sometimes youtube returns a webpage with incomplete ytInitialData
5393 # See: https://github.com/yt-dlp/yt-dlp/issues/116
5394 if not traverse_obj(data
, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
5395 retry
.error
= ExtractorError('Incomplete yt initial data received')
5399 return webpage
, data
5401 def _report_playlist_authcheck(self
, ytcfg
, fatal
=True):
5402 """Use if failed to extract ytcfg (and data) from initial webpage"""
5403 if not ytcfg
and self
.is_authenticated
:
5404 msg
= 'Playlists that require authentication may not extract correctly without a successful webpage download'
5405 if 'authcheck' not in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key()) and fatal
:
5406 raise ExtractorError(
5407 f
'{msg}. If you are not downloading private content, or '
5408 'your cookies are only for the first account and channel,'
5409 ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
5411 self
.report_warning(msg
, only_once
=True)
5413 def _extract_data(self
, url
, item_id
, ytcfg
=None, fatal
=True, webpage_fatal
=False, default_client
='web'):
5415 if not self
.skip_webpage
:
5416 webpage
, data
= self
._extract
_webpage
(url
, item_id
, fatal
=webpage_fatal
)
5417 ytcfg
= ytcfg
or self
.extract_ytcfg(item_id
, webpage
)
5418 # Reject webpage data if redirected to home page without explicitly requesting
5419 selected_tab
= self
._extract
_selected
_tab
(self
._extract
_tab
_renderers
(data
), fatal
=False) or {}
5420 if (url
!= 'https://www.youtube.com/feed/recommended'
5421 and selected_tab
.get('tabIdentifier') == 'FEwhat_to_watch' # Home page
5422 and 'no-youtube-channel-redirect' not in self
.get_param('compat_opts', [])):
5423 msg
= 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
5425 raise ExtractorError(msg
, expected
=True)
5426 self
.report_warning(msg
, only_once
=True)
5428 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=fatal
)
5429 data
= self
._extract
_tab
_endpoint
(url
, item_id
, ytcfg
, fatal
=fatal
, default_client
=default_client
)
5432 def _extract_tab_endpoint(self
, url
, item_id
, ytcfg
=None, fatal
=True, default_client
='web'):
5433 headers
= self
.generate_api_headers(ytcfg
=ytcfg
, default_client
=default_client
)
5434 resolve_response
= self
._extract
_response
(
5435 item_id
=item_id
, query
={'url': url}
, check_get_keys
='endpoint', headers
=headers
, ytcfg
=ytcfg
, fatal
=fatal
,
5436 ep
='navigation/resolve_url', note
='Downloading API parameters API JSON', default_client
=default_client
)
5437 endpoints
= {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5438 for ep_key
, ep
in endpoints
.items():
5439 params
= try_get(resolve_response
, lambda x
: x
['endpoint'][ep_key
], dict)
5441 return self
._extract
_response
(
5442 item_id
=item_id
, query
=params
, ep
=ep
, headers
=headers
,
5443 ytcfg
=ytcfg
, fatal
=fatal
, default_client
=default_client
,
5444 check_get_keys
=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5445 err_note
= 'Failed to resolve url (does the playlist exist?)'
5447 raise ExtractorError(err_note
, expected
=True)
5448 self
.report_warning(err_note
, item_id
)
5450 _SEARCH_PARAMS
= None
5452 def _search_results(self
, query
, params
=NO_DEFAULT
, default_client
='web'):
5453 data
= {'query': query}
5454 if params
is NO_DEFAULT
:
5455 params
= self
._SEARCH
_PARAMS
5457 data
['params'] = params
5460 ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5461 ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5463 ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5464 ('continuationContents', ),
5466 display_id
= f
'query "{query}"'
5467 check_get_keys
= tuple({keys[0] for keys in content_keys}
)
5468 ytcfg
= self
._download
_ytcfg
(default_client
, display_id
) if not self
.skip_webpage
else {}
5469 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=False)
5471 continuation_list
= [None]
5473 for page_num
in itertools
.count(1):
5474 data
.update(continuation_list
[0] or {})
5475 headers
= self
.generate_api_headers(
5476 ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(search
), default_client
=default_client
)
5477 search
= self
._extract
_response
(
5478 item_id
=f
'{display_id} page {page_num}', ep
='search', query
=data
,
5479 default_client
=default_client
, check_get_keys
=check_get_keys
, ytcfg
=ytcfg
, headers
=headers
)
5480 slr_contents
= traverse_obj(search
, *content_keys
)
5481 yield from self
._extract
_entries
({'contents': list(variadic(slr_contents))}
, continuation_list
)
5482 if not continuation_list
[0]:
5486 class YoutubeTabIE(YoutubeTabBaseInfoExtractor
):
5487 IE_DESC
= 'YouTube Tabs'
5488 _VALID_URL
= r
'''(?x:
5490 (?!consent\.)(?:\w+\.)?
5492 youtube(?:kids)?\.com|
5496 (?P<channel_type>channel|c|user|browse)/|
5499 (?:playlist|watch)\?.*?\blist=
5501 (?!(?:{reserved_names})\b) # Direct URLs
5505 reserved_names
=YoutubeBaseInfoExtractor
._RESERVED
_NAMES
,
5506 invidious
='|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
5508 IE_NAME
= 'youtube:tab'
5511 'note': 'playlists, multipage',
5512 'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5513 'playlist_mincount': 94,
5515 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5516 'title': 'Igor Kleiner Ph.D. - Playlists',
5517 'description': 'md5:15d7dd9e333cb987907fcb0d604b233a',
5518 'uploader': 'Igor Kleiner Ph.D.',
5519 'uploader_id': '@IgorDataScience',
5520 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5521 'channel': 'Igor Kleiner Ph.D.',
5522 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5523 'tags': ['критическое мышление', 'наука просто', 'математика', 'анализ данных'],
5524 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5525 'channel_follower_count': int,
5528 'note': 'playlists, multipage, different order',
5529 'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5530 'playlist_mincount': 94,
5532 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5533 'title': 'Igor Kleiner Ph.D. - Playlists',
5534 'description': 'md5:15d7dd9e333cb987907fcb0d604b233a',
5535 'uploader': 'Igor Kleiner Ph.D.',
5536 'uploader_id': '@IgorDataScience',
5537 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5538 'tags': ['критическое мышление', 'наука просто', 'математика', 'анализ данных'],
5539 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5540 'channel': 'Igor Kleiner Ph.D.',
5541 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5542 'channel_follower_count': int,
5545 'note': 'playlists, series',
5546 'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5547 'playlist_mincount': 5,
5549 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5550 'title': '3Blue1Brown - Playlists',
5551 'description': 'md5:4d1da95432004b7ba840ebc895b6b4c9',
5552 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5553 'channel': '3Blue1Brown',
5554 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5555 'uploader_id': '@3blue1brown',
5556 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5557 'uploader': '3Blue1Brown',
5558 'tags': ['Mathematics'],
5559 'channel_follower_count': int,
5560 'channel_is_verified': True,
5563 'note': 'playlists, singlepage',
5564 'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5565 'playlist_mincount': 4,
5567 'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5568 'title': 'ThirstForScience - Playlists',
5569 'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5570 'uploader': 'ThirstForScience',
5571 'uploader_url': 'https://www.youtube.com/@ThirstForScience',
5572 'uploader_id': '@ThirstForScience',
5573 'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5574 'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5576 'channel': 'ThirstForScience',
5577 'channel_follower_count': int,
5580 'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5581 'only_matching': True,
5583 'note': 'basic, single video playlist',
5584 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5586 'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5587 'title': 'youtube-dl public playlist',
5591 'modified_date': '20201130',
5592 'channel': 'Sergey M.',
5593 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5594 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5595 'availability': 'public',
5596 'uploader': 'Sergey M.',
5597 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5598 'uploader_id': '@sergeym.6173',
5600 'playlist_count': 1,
5602 'note': 'empty playlist',
5603 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5605 'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5606 'title': 'youtube-dl empty playlist',
5608 'channel': 'Sergey M.',
5610 'modified_date': '20230921',
5611 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5612 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5613 'availability': 'unlisted',
5614 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5615 'uploader_id': '@sergeym.6173',
5616 'uploader': 'Sergey M.',
5618 'playlist_count': 0,
5621 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5623 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5624 'title': 'lex will - Home',
5625 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5626 'uploader': 'lex will',
5627 'uploader_id': '@lexwill718',
5628 'channel': 'lex will',
5629 'tags': ['bible', 'history', 'prophesy'],
5630 'uploader_url': 'https://www.youtube.com/@lexwill718',
5631 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5632 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5633 'channel_follower_count': int,
5635 'playlist_mincount': 2,
5637 'note': 'Videos tab',
5638 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5640 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5641 'title': 'lex will - Videos',
5642 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5643 'uploader': 'lex will',
5644 'uploader_id': '@lexwill718',
5645 'tags': ['bible', 'history', 'prophesy'],
5646 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5647 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5648 'uploader_url': 'https://www.youtube.com/@lexwill718',
5649 'channel': 'lex will',
5650 'channel_follower_count': int,
5652 'playlist_mincount': 975,
5654 'note': 'Videos tab, sorted by popular',
5655 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5657 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5658 'title': 'lex will - Videos',
5659 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5660 'uploader': 'lex will',
5661 'uploader_id': '@lexwill718',
5662 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5663 'uploader_url': 'https://www.youtube.com/@lexwill718',
5664 'channel': 'lex will',
5665 'tags': ['bible', 'history', 'prophesy'],
5666 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5667 'channel_follower_count': int,
5669 'playlist_mincount': 199,
5671 'note': 'Playlists tab',
5672 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5674 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5675 'title': 'lex will - Playlists',
5676 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5677 'uploader': 'lex will',
5678 'uploader_id': '@lexwill718',
5679 'uploader_url': 'https://www.youtube.com/@lexwill718',
5680 'channel': 'lex will',
5681 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5682 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5683 'tags': ['bible', 'history', 'prophesy'],
5684 'channel_follower_count': int,
5686 'playlist_mincount': 17,
5688 'note': 'Community tab',
5689 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5691 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5692 'title': 'lex will - Community',
5693 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5694 'channel': 'lex will',
5695 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5696 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5697 'tags': ['bible', 'history', 'prophesy'],
5698 'channel_follower_count': int,
5699 'uploader_url': 'https://www.youtube.com/@lexwill718',
5700 'uploader_id': '@lexwill718',
5701 'uploader': 'lex will',
5703 'playlist_mincount': 18,
5705 'note': 'Channels tab',
5706 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5708 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5709 'title': 'lex will - Channels',
5710 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5711 'channel': 'lex will',
5712 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5713 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5714 'tags': ['bible', 'history', 'prophesy'],
5715 'channel_follower_count': int,
5716 'uploader_url': 'https://www.youtube.com/@lexwill718',
5717 'uploader_id': '@lexwill718',
5718 'uploader': 'lex will',
5720 'playlist_mincount': 12,
5722 'note': 'Search tab',
5723 'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5724 'playlist_mincount': 40,
5726 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5727 'title': '3Blue1Brown - Search - linear algebra',
5728 'description': 'md5:4d1da95432004b7ba840ebc895b6b4c9',
5729 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5730 'tags': ['Mathematics'],
5731 'channel': '3Blue1Brown',
5732 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5733 'channel_follower_count': int,
5734 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5735 'uploader_id': '@3blue1brown',
5736 'uploader': '3Blue1Brown',
5737 'channel_is_verified': True,
5740 'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5741 'only_matching': True,
5743 'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5744 'only_matching': True,
5746 'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5747 'only_matching': True,
5749 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5750 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5752 'title': '29C3: Not my department',
5753 'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5754 'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5757 'modified_date': '20150605',
5758 'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5759 'channel_url': 'https://www.youtube.com/channel/UCEPzS1rYsrkqzSLNp76nrcg',
5760 'channel': 'Christiaan008',
5761 'availability': 'public',
5762 'uploader_id': '@ChRiStIaAn008',
5763 'uploader': 'Christiaan008',
5764 'uploader_url': 'https://www.youtube.com/@ChRiStIaAn008',
5766 'playlist_count': 96,
5768 'note': 'Large playlist',
5769 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5771 'title': 'Uploads from Cauchemar',
5772 'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5773 'channel_url': 'https://www.youtube.com/channel/UCBABnxM4Ar9ten8Mdjj1j0Q',
5775 'modified_date': r
're:\d{8}',
5776 'channel': 'Cauchemar',
5779 'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5780 'availability': 'public',
5781 'uploader_id': '@Cauchemar89',
5782 'uploader': 'Cauchemar',
5783 'uploader_url': 'https://www.youtube.com/@Cauchemar89',
5785 'playlist_mincount': 1123,
5786 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5788 'note': 'even larger playlist, 8832 videos',
5789 'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5790 'only_matching': True,
5792 'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5793 'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5795 'title': 'Uploads from Interstellar Movie',
5796 'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5799 'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5800 'channel_url': 'https://www.youtube.com/channel/UCXw-G3eDE9trcvY2sBMM_aA',
5801 'channel': 'Interstellar Movie',
5803 'modified_date': r
're:\d{8}',
5804 'availability': 'public',
5805 'uploader_id': '@InterstellarMovie',
5806 'uploader': 'Interstellar Movie',
5807 'uploader_url': 'https://www.youtube.com/@InterstellarMovie',
5809 'playlist_mincount': 21,
5811 'note': 'Playlist with "show unavailable videos" button',
5812 'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5814 'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5815 'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5817 'channel': 'Phim Siêu Nhân Nhật Bản',
5820 'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5821 'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5822 'modified_date': r
're:\d{8}',
5823 'availability': 'public',
5824 'uploader_url': 'https://www.youtube.com/@phimsieunhannhatban',
5825 'uploader_id': '@phimsieunhannhatban',
5826 'uploader': 'Phim Siêu Nhân Nhật Bản',
5828 'playlist_mincount': 200,
5829 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5831 'note': 'Playlist with unavailable videos in page 7',
5832 'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5834 'title': 'Uploads from BlankTV',
5835 'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5836 'channel': 'BlankTV',
5837 'channel_url': 'https://www.youtube.com/channel/UC8l9frL61Yl5KFOl87nIm2w',
5838 'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5841 'modified_date': r
're:\d{8}',
5843 'availability': 'public',
5844 'uploader_id': '@blanktv',
5845 'uploader': 'BlankTV',
5846 'uploader_url': 'https://www.youtube.com/@blanktv',
5848 'playlist_mincount': 1000,
5849 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5851 'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5852 'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5854 'title': 'Data Analysis with Dr Mike Pound',
5855 'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5856 'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5859 'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5860 'channel_url': 'https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA',
5861 'channel': 'Computerphile',
5862 'availability': 'public',
5863 'modified_date': '20190712',
5864 'uploader_id': '@Computerphile',
5865 'uploader': 'Computerphile',
5866 'uploader_url': 'https://www.youtube.com/@Computerphile',
5868 'playlist_mincount': 11,
5870 'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5871 'only_matching': True,
5873 'note': 'Playlist URL that does not actually serve a playlist',
5874 'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5876 'id': 'FqZTN594JQw',
5878 'title': "Smiley's People 01 detective, Adventure Series, Action",
5879 'upload_date': '20150526',
5880 'license': 'Standard YouTube License',
5881 'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5882 'categories': ['People & Blogs'],
5888 'skip_download': True,
5890 'skip': 'This video is not available.',
5891 'add_ie': [YoutubeIE
.ie_key()],
5893 'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5894 'only_matching': True,
5896 'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5897 'only_matching': True,
5899 'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5901 'id': 'hGkQjiJLjWQ', # This will keep changing
5904 'upload_date': r
're:\d{8}',
5906 'categories': ['News & Politics'],
5909 'release_timestamp': int,
5910 'channel': 'Sky News',
5911 'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5914 'thumbnail': r
're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5915 'playable_in_embed': True,
5916 'release_date': r
're:\d+',
5917 'availability': 'public',
5918 'live_status': 'is_live',
5919 'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5920 'channel_follower_count': int,
5921 'concurrent_view_count': int,
5922 'uploader_url': 'https://www.youtube.com/@SkyNews',
5923 'uploader_id': '@SkyNews',
5924 'uploader': 'Sky News',
5925 'channel_is_verified': True,
5928 'skip_download': True,
5930 'expected_warnings': ['Ignoring subtitle tracks found in '],
5932 'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5934 'id': 'a48o2S1cPoo',
5936 'title': 'The Young Turks - Live Main Show',
5937 'upload_date': '20150715',
5938 'license': 'Standard YouTube License',
5939 'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5940 'categories': ['News & Politics'],
5941 'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5945 'skip_download': True,
5947 'only_matching': True,
5949 'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5950 'only_matching': True,
5952 'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5953 'only_matching': True,
5955 'note': 'A channel that is not live. Should raise error',
5956 'url': 'https://www.youtube.com/user/numberphile/live',
5957 'only_matching': True,
5959 'url': 'https://www.youtube.com/feed/trending',
5960 'only_matching': True,
5962 'url': 'https://www.youtube.com/feed/library',
5963 'only_matching': True,
5965 'url': 'https://www.youtube.com/feed/history',
5966 'only_matching': True,
5968 'url': 'https://www.youtube.com/feed/subscriptions',
5969 'only_matching': True,
5971 'url': 'https://www.youtube.com/feed/watch_later',
5972 'only_matching': True,
5974 'note': 'Recommended - redirects to home page.',
5975 'url': 'https://www.youtube.com/feed/recommended',
5976 'only_matching': True,
5978 'note': 'inline playlist with not always working continuations',
5979 'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5980 'only_matching': True,
5982 'url': 'https://www.youtube.com/course',
5983 'only_matching': True,
5985 'url': 'https://www.youtube.com/zsecurity',
5986 'only_matching': True,
5988 'url': 'http://www.youtube.com/NASAgovVideo/videos',
5989 'only_matching': True,
5991 'url': 'https://www.youtube.com/TheYoungTurks/live',
5992 'only_matching': True,
5994 'url': 'https://www.youtube.com/hashtag/cctv9',
5997 'title': 'cctv9 - All',
6000 'playlist_mincount': 300, # not consistent but should be over 300
6002 'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
6003 'only_matching': True,
6005 'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
6006 'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
6007 'only_matching': True,
6009 'note': '/browse/ should redirect to /channel/',
6010 'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
6011 'only_matching': True,
6013 'note': 'VLPL, should redirect to playlist?list=PL...',
6014 'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
6016 'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
6017 'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
6018 'title': 'NCS : All Releases 💿',
6019 'channel_url': 'https://www.youtube.com/channel/UC_aEa8K-EOJ3D6gOs7HcyNg',
6020 'modified_date': r
're:\d{8}',
6022 'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
6024 'channel': 'NoCopyrightSounds',
6025 'availability': 'public',
6026 'uploader_url': 'https://www.youtube.com/@NoCopyrightSounds',
6027 'uploader': 'NoCopyrightSounds',
6028 'uploader_id': '@NoCopyrightSounds',
6030 'playlist_mincount': 166,
6031 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden', 'YouTube Music is not directly supported'],
6033 # TODO: fix 'unviewable' issue with this playlist when reloading with unavailable videos
6034 'note': 'Topic, should redirect to playlist?list=UU...',
6035 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
6037 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
6038 'title': 'Uploads from Royalty Free Music - Topic',
6040 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
6041 'channel': 'Royalty Free Music - Topic',
6043 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
6044 'modified_date': r
're:\d{8}',
6046 'availability': 'public',
6047 'uploader': 'Royalty Free Music - Topic',
6049 'playlist_mincount': 101,
6050 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
6052 # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
6053 # Treat as a general feed
6054 'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
6056 'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
6057 'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
6060 'playlist_mincount': 9,
6062 'note': 'Youtube music Album',
6063 'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
6065 'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
6066 'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
6070 'availability': 'unlisted',
6071 'modified_date': r
're:\d{8}',
6073 'playlist_count': 50,
6074 'expected_warnings': ['YouTube Music is not directly supported'],
6076 'note': 'unlisted single video playlist',
6077 'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
6079 'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
6080 'title': 'yt-dlp unlisted playlist test',
6081 'availability': 'unlisted',
6083 'modified_date': '20220418',
6084 'channel': 'colethedj',
6087 'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
6088 'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
6089 'uploader_url': 'https://www.youtube.com/@colethedj1894',
6090 'uploader_id': '@colethedj1894',
6091 'uploader': 'colethedj',
6095 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
6096 'id': 'BaW_jenozKc',
6098 'ie_key': 'Youtube',
6100 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
6101 'channel_url': 'https://www.youtube.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
6103 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc',
6104 'channel': 'Philipp Hagemeister',
6105 'uploader_id': '@PhilippHagemeister',
6106 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
6107 'uploader': 'Philipp Hagemeister',
6110 'playlist_count': 1,
6111 'params': {'extract_flat': True}
,
6113 'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
6114 'url': 'https://www.youtube.com/feed/recommended',
6116 'id': 'recommended',
6117 'title': 'recommended',
6120 'playlist_mincount': 50,
6122 'skip_download': True,
6123 'extractor_args': {'youtubetab': {'skip': ['webpage']}
},
6126 'note': 'API Fallback: /videos tab, sorted by oldest first',
6127 'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
6129 'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6130 'title': 'Cody\'sLab - Videos',
6131 'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
6132 'channel': 'Cody\'sLab',
6133 'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
6135 'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
6136 'channel_follower_count': int,
6138 'playlist_mincount': 650,
6140 'skip_download': True,
6141 'extractor_args': {'youtubetab': {'skip': ['webpage']}
},
6143 'skip': 'Query for sorting no longer works',
6145 'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
6146 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
6148 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
6149 'title': 'Uploads from Royalty Free Music - Topic',
6150 'modified_date': r
're:\d{8}',
6151 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
6153 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
6155 'channel': 'Royalty Free Music - Topic',
6157 'availability': 'public',
6158 'uploader': 'Royalty Free Music - Topic',
6160 'playlist_mincount': 101,
6162 'skip_download': True,
6163 'extractor_args': {'youtubetab': {'skip': ['webpage']}
},
6165 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
6167 'note': 'non-standard redirect to regional channel',
6168 'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
6169 'only_matching': True,
6171 'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
6172 'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6174 'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6175 'modified_date': '20220407',
6176 'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
6178 'availability': 'unlisted',
6179 'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
6180 'channel': 'pukkandan',
6181 'description': 'Test for collaborative playlist',
6182 'title': 'yt-dlp test - collaborative playlist',
6184 'uploader_url': 'https://www.youtube.com/@pukkandan',
6185 'uploader_id': '@pukkandan',
6186 'uploader': 'pukkandan',
6188 'playlist_mincount': 2,
6190 'note': 'translated tab name',
6191 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
6193 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6195 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6196 'description': 'test description',
6197 'title': 'cole-dlp-test-acc - 再生リスト',
6198 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6199 'channel': 'cole-dlp-test-acc',
6200 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6201 'uploader_id': '@coletdjnz',
6202 'uploader': 'cole-dlp-test-acc',
6204 'playlist_mincount': 1,
6205 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6206 'expected_warnings': ['Preferring "ja"'],
6208 # XXX: this should really check flat playlist entries, but the test suite doesn't support that
6209 'note': 'preferred lang set with playlist with translated video titles',
6210 'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6212 'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6215 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6216 'channel': 'cole-dlp-test-acc',
6217 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6218 'description': 'test',
6219 'title': 'dlp test playlist',
6220 'availability': 'public',
6221 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6222 'uploader_id': '@coletdjnz',
6223 'uploader': 'cole-dlp-test-acc',
6225 'playlist_mincount': 1,
6226 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6227 'expected_warnings': ['Preferring "ja"'],
6229 # shorts audio pivot for 2GtVksBMYFM.
6230 'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
6232 'id': 'sfv_audio_pivot',
6233 'title': 'sfv_audio_pivot',
6236 'playlist_mincount': 50,
6239 # Channel with a real live tab (not to be mistaken with streams tab)
6240 # Do not treat like it should redirect to live stream
6241 'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
6243 'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
6244 'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
6247 'playlist_mincount': 20,
6249 # Tab name is not the same as tab id
6250 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
6252 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6253 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
6256 'playlist_mincount': 8,
6258 # Home tab id is literally home. Not to get mistaken with featured
6259 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
6261 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6262 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
6265 'playlist_mincount': 8,
6267 # Should get three playlists for videos, shorts and streams tabs
6268 'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6270 'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6271 'title': 'Polka Ch. 尾丸ポルカ',
6272 'channel_follower_count': int,
6273 'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6274 'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6275 'description': 'md5:49809d8bf9da539bc48ed5d1f83c33f2',
6276 'channel': 'Polka Ch. 尾丸ポルカ',
6278 'uploader_url': 'https://www.youtube.com/@OmaruPolka',
6279 'uploader': 'Polka Ch. 尾丸ポルカ',
6280 'uploader_id': '@OmaruPolka',
6281 'channel_is_verified': True,
6283 'playlist_count': 3,
6285 # Shorts tab with channel with handle
6286 # TODO: fix channel description
6287 'url': 'https://www.youtube.com/@NotJustBikes/shorts',
6289 'id': 'UC0intLFzLaudFG-xAvUEO-A',
6290 'title': 'Not Just Bikes - Shorts',
6292 'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
6293 'description': 'md5:5e82545b3a041345927a92d0585df247',
6294 'channel_follower_count': int,
6295 'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
6296 'channel': 'Not Just Bikes',
6297 'uploader_url': 'https://www.youtube.com/@NotJustBikes',
6298 'uploader': 'Not Just Bikes',
6299 'uploader_id': '@NotJustBikes',
6300 'channel_is_verified': True,
6302 'playlist_mincount': 10,
6305 'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
6307 'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6308 'title': '中村悠一 - Live',
6310 'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6311 'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
6313 'channel_follower_count': int,
6314 'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
6315 'uploader_url': 'https://www.youtube.com/@Yuichi-Nakamura',
6316 'uploader_id': '@Yuichi-Nakamura',
6319 'playlist_mincount': 60,
6321 # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
6322 # See test_youtube_lists
6323 'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
6324 'only_matching': True,
6326 # No uploads and no UCID given. Should fail with no uploads error
6327 # See test_youtube_lists
6328 'url': 'https://www.youtube.com/news',
6329 'only_matching': True,
6331 # No videos tab but has a shorts tab
6332 'url': 'https://www.youtube.com/c/TKFShorts',
6334 'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6335 'title': 'Shorts Break - Shorts',
6337 'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6338 'channel': 'Shorts Break',
6339 'description': 'md5:6de33c5e7ba686e5f3efd4e19c7ef499',
6340 'channel_follower_count': int,
6341 'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
6342 'uploader_url': 'https://www.youtube.com/@ShortsBreak_Official',
6343 'uploader': 'Shorts Break',
6344 'uploader_id': '@ShortsBreak_Official',
6346 'playlist_mincount': 30,
6348 # Trending Now Tab. tab id is empty
6349 'url': 'https://www.youtube.com/feed/trending',
6352 'title': 'trending - Now',
6355 'playlist_mincount': 30,
6357 # Trending Gaming Tab. tab id is empty
6358 'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
6361 'title': 'trending - Gaming',
6364 'playlist_mincount': 30,
6366 # Shorts url result in shorts tab
6367 # TODO: Fix channel id extraction
6368 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
6370 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6371 'title': 'cole-dlp-test-acc - Shorts',
6372 'channel': 'cole-dlp-test-acc',
6373 'description': 'test description',
6374 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6375 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6377 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6378 'uploader_id': '@coletdjnz',
6379 'uploader': 'cole-dlp-test-acc',
6383 # Channel data is not currently available for short renderers (as of 2023-03-01)
6385 'ie_key': 'Youtube',
6386 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
6387 'id': 'sSM9J5YH_60',
6388 'title': 'SHORT short',
6393 'params': {'extract_flat': True}
,
6395 # Live video status should be extracted
6396 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
6398 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6399 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live', # TODO: should be Minecraft - Live or Minecraft - Topic - Live
6405 'ie_key': 'Youtube',
6406 'url': 'startswith:https://www.youtube.com/watch?v=',
6409 'live_status': 'is_live',
6412 'concurrent_view_count': int,
6415 'uploader_url': str,
6417 'channel_is_verified': bool, # this will keep changing
6420 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6421 'playlist_mincount': 1,
6423 # Channel renderer metadata. Contains number of videos on the channel
6424 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/channels',
6426 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6427 'title': 'cole-dlp-test-acc - Channels',
6428 'channel': 'cole-dlp-test-acc',
6429 'description': 'test description',
6430 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6431 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6433 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6434 'uploader_id': '@coletdjnz',
6435 'uploader': 'cole-dlp-test-acc',
6440 'ie_key': 'YoutubeTab',
6441 'url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6442 'id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6443 'channel_id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6444 'title': 'PewDiePie',
6445 'channel': 'PewDiePie',
6446 'channel_url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6448 'channel_follower_count': int,
6449 'playlist_count': int,
6450 'uploader': 'PewDiePie',
6451 'uploader_url': 'https://www.youtube.com/@PewDiePie',
6452 'uploader_id': '@PewDiePie',
6453 'channel_is_verified': True,
6456 'params': {'extract_flat': True}
,
6458 'url': 'https://www.youtube.com/@3blue1brown/about',
6460 'id': '@3blue1brown',
6461 'tags': ['Mathematics'],
6462 'title': '3Blue1Brown',
6463 'channel_follower_count': int,
6464 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
6465 'channel': '3Blue1Brown',
6466 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
6467 'description': 'md5:4d1da95432004b7ba840ebc895b6b4c9',
6468 'uploader_url': 'https://www.youtube.com/@3blue1brown',
6469 'uploader_id': '@3blue1brown',
6470 'uploader': '3Blue1Brown',
6471 'channel_is_verified': True,
6473 'playlist_count': 0,
6475 # Podcasts tab, with rich entry playlistRenderers
6476 'url': 'https://www.youtube.com/@99percentinvisiblepodcast/podcasts',
6478 'id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6479 'channel_id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6480 'uploader_url': 'https://www.youtube.com/@99percentinvisiblepodcast',
6481 'description': 'md5:3a0ed38f1ad42a68ef0428c04a15695c',
6482 'title': '99 Percent Invisible - Podcasts',
6483 'uploader': '99 Percent Invisible',
6484 'channel_follower_count': int,
6485 'channel_url': 'https://www.youtube.com/channel/UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6487 'channel': '99 Percent Invisible',
6488 'uploader_id': '@99percentinvisiblepodcast',
6490 'playlist_count': 0,
6492 # Releases tab, with rich entry playlistRenderers (same as Podcasts tab)
6493 'url': 'https://www.youtube.com/@AHimitsu/releases',
6495 'id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6496 'channel': 'A Himitsu',
6497 'uploader_url': 'https://www.youtube.com/@AHimitsu',
6498 'title': 'A Himitsu - Releases',
6499 'uploader_id': '@AHimitsu',
6500 'uploader': 'A Himitsu',
6501 'channel_id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6503 'description': 'I make music',
6504 'channel_url': 'https://www.youtube.com/channel/UCgFwu-j5-xNJml2FtTrrB3A',
6505 'channel_follower_count': int,
6506 'channel_is_verified': True,
6508 'playlist_mincount': 10,
6510 # Playlist with only shorts, shown as reel renderers
6511 # FIXME: future: YouTube currently doesn't give continuation for this,
6513 'url': 'https://www.youtube.com/playlist?list=UUxqPAgubo4coVn9Lx1FuKcg',
6515 'id': 'UUxqPAgubo4coVn9Lx1FuKcg',
6516 'channel_url': 'https://www.youtube.com/channel/UCxqPAgubo4coVn9Lx1FuKcg',
6518 'uploader_id': '@BangyShorts',
6520 'uploader_url': 'https://www.youtube.com/@BangyShorts',
6521 'channel_id': 'UCxqPAgubo4coVn9Lx1FuKcg',
6522 'channel': 'Bangy Shorts',
6523 'uploader': 'Bangy Shorts',
6525 'availability': 'public',
6526 'modified_date': r
're:\d{8}',
6527 'title': 'Uploads from Bangy Shorts',
6529 'playlist_mincount': 100,
6530 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6532 'note': 'Tags containing spaces',
6533 'url': 'https://www.youtube.com/channel/UC7_YxT-KID8kRbqZo7MyscQ',
6534 'playlist_count': 3,
6536 'id': 'UC7_YxT-KID8kRbqZo7MyscQ',
6537 'channel': 'Markiplier',
6538 'channel_id': 'UC7_YxT-KID8kRbqZo7MyscQ',
6539 'title': 'Markiplier',
6540 'channel_follower_count': int,
6541 'description': 'md5:0c010910558658824402809750dc5d97',
6542 'uploader_id': '@markiplier',
6543 'uploader_url': 'https://www.youtube.com/@markiplier',
6544 'uploader': 'Markiplier',
6545 'channel_url': 'https://www.youtube.com/channel/UC7_YxT-KID8kRbqZo7MyscQ',
6546 'channel_is_verified': True,
6547 'tags': ['markiplier', 'comedy', 'gaming', 'funny videos', 'funny moments',
6548 'sketch comedy', 'laughing', 'lets play', 'challenge videos', 'hilarious',
6549 'challenges', 'sketches', 'scary games', 'funny games', 'rage games',
6555 def suitable(cls
, url
):
6556 return False if YoutubeIE
.suitable(url
) else super().suitable(url
)
6558 _URL_RE
= re
.compile(rf
'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
6560 def _get_url_mobj(self
, url
):
6561 mobj
= self
._URL
_RE
.match(url
).groupdict()
6562 mobj
.update((k
, '') for k
, v
in mobj
.items() if v
is None)
6565 def _extract_tab_id_and_name(self
, tab
, base_url
='https://www.youtube.com'):
6566 tab_name
= (tab
.get('title') or '').lower()
6567 tab_url
= urljoin(base_url
, traverse_obj(
6568 tab
, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
6570 tab_id
= (tab_url
and self
._get
_url
_mobj
(tab_url
)['tab'][1:]
6571 or traverse_obj(tab
, 'tabIdentifier', expected_type
=str))
6574 'TAB_ID_SPONSORSHIPS': 'membership',
6575 }.get(tab_id
, tab_id
), tab_name
6577 # Fallback to tab name if we cannot get the tab id.
6578 # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6579 # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6581 self
.write_debug(f
'Falling back to selected tab name: {tab_name}')
6585 }.get(tab_name
, tab_name
), tab_name
6587 def _has_tab(self
, tabs
, tab_id
):
6588 return any(self
._extract
_tab
_id
_and
_name
(tab
)[0] == tab_id
for tab
in tabs
)
6590 def _empty_playlist(self
, item_id
, data
):
6591 return self
.playlist_result([], item_id
, **self
._extract
_metadata
_from
_tabs
(item_id
, data
))
6593 @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6594 def _real_extract(self
, url
, smuggled_data
):
6595 item_id
= self
._match
_id
(url
)
6596 url
= urllib
.parse
.urlunparse(
6597 urllib
.parse
.urlparse(url
)._replace
(netloc
='www.youtube.com'))
6598 compat_opts
= self
.get_param('compat_opts', [])
6600 mobj
= self
._get
_url
_mobj
(url
)
6601 pre
, tab
, post
, is_channel
= mobj
['pre'], mobj
['tab'], mobj
['post'], not mobj
['not_channel']
6602 if is_channel
and smuggled_data
.get('is_music_url'):
6603 if item_id
[:2] == 'VL': # Youtube music VL channels have an equivalent playlist
6604 return self
.url_result(
6605 f
'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE
, item_id
[2:])
6606 elif item_id
[:2] == 'MP': # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6607 mdata
= self
._extract
_tab
_endpoint
(
6608 f
'https://music.youtube.com/channel/{item_id}', item_id
, default_client
='web_music')
6609 murl
= traverse_obj(mdata
, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6610 get_all
=False, expected_type
=str)
6612 raise ExtractorError('Failed to resolve album to playlist')
6613 return self
.url_result(murl
, YoutubeTabIE
)
6614 elif mobj
['channel_type'] == 'browse': # Youtube music /browse/ should be changed to /channel/
6615 return self
.url_result(
6616 f
'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE
, item_id
)
6618 original_tab_id
, display_id
= tab
[1:], f
'{item_id}{tab}'
6619 if is_channel
and not tab
and 'no-youtube-channel-redirect' not in compat_opts
:
6620 url
= f
'{pre}/videos{post}'
6621 if smuggled_data
.get('is_music_url'):
6622 self
.report_warning(f
'YouTube Music is not directly supported. Redirecting to {url}')
6624 # Handle both video/playlist URLs
6626 video_id
, playlist_id
= (traverse_obj(qs
, (key
, 0)) for key
in ('v', 'list'))
6627 if not video_id
and mobj
['not_channel'].startswith('watch'):
6629 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6630 raise ExtractorError('A video URL was given without video ID', expected
=True)
6631 # Common mistake: https://www.youtube.com/watch?list=playlist_id
6632 self
.report_warning(f
'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6633 return self
.url_result(
6634 f
'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE
, playlist_id
)
6636 if not self
._yes
_playlist
(playlist_id
, video_id
):
6637 return self
.url_result(
6638 f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6640 data
, ytcfg
= self
._extract
_data
(url
, display_id
)
6642 # YouTube may provide a non-standard redirect to the regional channel
6643 # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6644 # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6645 redirect_url
= traverse_obj(
6646 data
, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all
=False)
6647 if redirect_url
and 'no-youtube-channel-redirect' not in compat_opts
:
6648 redirect_url
= ''.join((urljoin('https://www.youtube.com', redirect_url
), tab
, post
))
6649 self
.to_screen(f
'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6650 return self
.url_result(redirect_url
, YoutubeTabIE
)
6652 tabs
, extra_tabs
= self
._extract
_tab
_renderers
(data
), []
6653 if is_channel
and tabs
and 'no-youtube-channel-redirect' not in compat_opts
:
6654 selected_tab
= self
._extract
_selected
_tab
(tabs
)
6655 selected_tab_id
, selected_tab_name
= self
._extract
_tab
_id
_and
_name
(selected_tab
, url
) # NB: Name may be translated
6656 self
.write_debug(f
'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6658 # /about is no longer a tab
6659 if original_tab_id
== 'about':
6660 return self
._empty
_playlist
(item_id
, data
)
6662 if not original_tab_id
and selected_tab_name
:
6663 self
.to_screen('Downloading all uploads of the channel. '
6664 'To download only the videos in a specific tab, pass the tab\'s URL')
6665 if self
._has
_tab
(tabs
, 'streams'):
6666 extra_tabs
.append(''.join((pre
, '/streams', post
)))
6667 if self
._has
_tab
(tabs
, 'shorts'):
6668 extra_tabs
.append(''.join((pre
, '/shorts', post
)))
6669 # XXX: Members-only tab should also be extracted
6671 if not extra_tabs
and selected_tab_id
!= 'videos':
6672 # Channel does not have streams, shorts or videos tabs
6673 if item_id
[:2] != 'UC':
6674 return self
._empty
_playlist
(item_id
, data
)
6676 # Topic channels don't have /videos. Use the equivalent playlist instead
6677 pl_id
= f
'UU{item_id[2:]}'
6678 pl_url
= f
'https://www.youtube.com/playlist?list={pl_id}'
6680 data
, ytcfg
= self
._extract
_data
(pl_url
, pl_id
, ytcfg
=ytcfg
, fatal
=True, webpage_fatal
=True)
6681 except ExtractorError
:
6682 return self
._empty
_playlist
(item_id
, data
)
6684 item_id
, url
= pl_id
, pl_url
6686 f
'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6688 elif extra_tabs
and selected_tab_id
!= 'videos':
6689 # When there are shorts/live tabs but not videos tab
6690 url
, data
= f
'{pre}{post}', None
6692 elif (original_tab_id
or 'videos') != selected_tab_id
:
6693 if original_tab_id
== 'live':
6694 # Live tab should have redirected to the video
6695 # Except in the case the channel has an actual live tab
6696 # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6697 raise UserNotLive(video_id
=item_id
)
6698 elif selected_tab_name
:
6699 raise ExtractorError(f
'This channel does not have a {original_tab_id} tab', expected
=True)
6701 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6702 url
= f
'{pre}{post}'
6704 # YouTube sometimes provides a button to reload playlist with unavailable videos.
6705 if 'no-youtube-unavailable-videos' not in compat_opts
:
6706 data
= self
._reload
_with
_unavailable
_videos
(display_id
, data
, ytcfg
) or data
6707 self
._extract
_and
_report
_alerts
(data
, only_once
=True)
6709 tabs
, entries
= self
._extract
_tab
_renderers
(data
), []
6711 entries
= [self
._extract
_from
_tabs
(item_id
, ytcfg
, data
, tabs
)]
6713 'extractor_key': YoutubeTabIE
.ie_key(),
6714 'extractor': YoutubeTabIE
.IE_NAME
,
6717 if self
.get_param('playlist_items') == '0':
6718 entries
.extend(self
.url_result(u
, YoutubeTabIE
) for u
in extra_tabs
)
6719 else: # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6720 entries
.extend(map(self
._real
_extract
, extra_tabs
))
6722 if len(entries
) == 1:
6725 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
6726 uploads_url
= 'the Uploads (UU) playlist URL'
6727 if try_get(metadata
, lambda x
: x
['channel_id'].startswith('UC')):
6728 uploads_url
= f
'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6730 'Downloading as multiple playlists, separated by tabs. '
6731 f
'To download as a single playlist instead, pass {uploads_url}')
6732 return self
.playlist_result(entries
, item_id
, **metadata
)
6735 playlist
= traverse_obj(
6736 data
, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type
=dict)
6738 return self
._extract
_from
_playlist
(item_id
, url
, data
, playlist
, ytcfg
)
6740 video_id
= traverse_obj(
6741 data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str) or video_id
6743 if tab
!= '/live': # live tab is expected to redirect to video
6744 self
.report_warning(f
'Unable to recognize playlist. Downloading just video {video_id}')
6745 return self
.url_result(f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6747 raise ExtractorError('Unable to recognize tab page')
6750 class YoutubePlaylistIE(InfoExtractor
):
6751 IE_DESC
= 'YouTube playlists'
6752 _VALID_URL
= r
'''(?x)(?:
6757 youtube(?:kids)?\.com|
6762 (?P<id>{playlist_id})
6764 playlist_id
=YoutubeBaseInfoExtractor
._PLAYLIST
_ID
_RE
,
6765 invidious
='|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
6767 IE_NAME
= 'youtube:playlist'
6769 'note': 'issue #673',
6770 'url': 'PLBB231211A4F62143',
6772 'title': '[OLD]Team Fortress 2 (Class-based LP)',
6773 'id': 'PLBB231211A4F62143',
6774 'uploader': 'Wickman',
6775 'uploader_id': '@WickmanVT',
6776 'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6778 'uploader_url': 'https://www.youtube.com/@WickmanVT',
6779 'modified_date': r
're:\d{8}',
6780 'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6781 'channel': 'Wickman',
6783 'channel_url': 'https://www.youtube.com/channel/UCKSpbfbl5kRQpTdL7kMc-1Q',
6784 'availability': 'public',
6786 'playlist_mincount': 29,
6788 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6790 'title': 'YDL_safe_search',
6791 'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6793 'playlist_count': 2,
6794 'skip': 'This playlist is private',
6797 'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6798 'playlist_count': 4,
6801 'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6802 'uploader': 'milan',
6803 'uploader_id': '@milan5503',
6805 'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6807 'modified_date': '20140919',
6810 'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6811 'uploader_url': 'https://www.youtube.com/@milan5503',
6812 'availability': 'public',
6814 'expected_warnings': [r
'[Uu]navailable videos? (is|are|will be) hidden', 'Retrying', 'Giving up'],
6816 'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6817 'playlist_mincount': 455,
6819 'title': '2018 Chinese New Singles (11/6 updated)',
6820 'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6822 'uploader_id': '@music_king',
6823 'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6826 'channel_url': 'https://www.youtube.com/channel/UC21nz3_MesPLqtDqwdvnoxA',
6828 'uploader_url': 'https://www.youtube.com/@music_king',
6829 'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6830 'modified_date': r
're:\d{8}',
6831 'availability': 'public',
6833 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6835 'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6836 'only_matching': True,
6838 # music album playlist
6839 'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6840 'only_matching': True,
6844 def suitable(cls
, url
):
6845 if YoutubeTabIE
.suitable(url
):
6847 from ..utils
import parse_qs
6849 if qs
.get('v', [None])[0]:
6851 return super().suitable(url
)
6853 def _real_extract(self
, url
):
6854 playlist_id
= self
._match
_id
(url
)
6855 is_music_url
= YoutubeBaseInfoExtractor
.is_music_url(url
)
6856 url
= update_url_query(
6857 'https://www.youtube.com/playlist',
6858 parse_qs(url
) or {'list': playlist_id}
)
6860 url
= smuggle_url(url
, {'is_music_url': True}
)
6861 return self
.url_result(url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6864 class YoutubeYtBeIE(InfoExtractor
):
6865 IE_DESC
= 'youtu.be'
6866 _VALID_URL
= rf
'https?://youtu\.be/(?P<id>[0-9A-Za-z_-]{{11}})/*?.*?\blist=(?P<playlist_id>{YoutubeBaseInfoExtractor._PLAYLIST_ID_RE})'
6868 'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6870 'id': 'yeWKywCrFtk',
6872 'title': 'Small Scale Baler and Braiding Rugs',
6873 'uploader': 'Backus-Page House Museum',
6874 'uploader_id': '@backuspagemuseum',
6875 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/@backuspagemuseum',
6876 'upload_date': '20161008',
6877 'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6878 'categories': ['Nonprofits & Activism'],
6882 'playable_in_embed': True,
6883 'thumbnail': r
're:^https?://.*\.webp',
6884 'channel': 'Backus-Page House Museum',
6885 'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6886 'live_status': 'not_live',
6888 'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6889 'availability': 'public',
6891 'comment_count': int,
6892 'channel_follower_count': int,
6896 'skip_download': True,
6899 'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6900 'only_matching': True,
6903 def _real_extract(self
, url
):
6904 mobj
= self
._match
_valid
_url
(url
)
6905 video_id
= mobj
.group('id')
6906 playlist_id
= mobj
.group('playlist_id')
6907 return self
.url_result(
6908 update_url_query('https://www.youtube.com/watch', {
6910 'list': playlist_id
,
6911 'feature': 'youtu.be',
6912 }), ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6915 class YoutubeLivestreamEmbedIE(InfoExtractor
):
6916 IE_DESC
= 'YouTube livestream embeds'
6917 _VALID_URL
= r
'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6919 'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6920 'only_matching': True,
6923 def _real_extract(self
, url
):
6924 channel_id
= self
._match
_id
(url
)
6925 return self
.url_result(
6926 f
'https://www.youtube.com/channel/{channel_id}/live',
6927 ie
=YoutubeTabIE
.ie_key(), video_id
=channel_id
)
6930 class YoutubeYtUserIE(InfoExtractor
):
6931 IE_DESC
= 'YouTube user videos; "ytuser:" prefix'
6932 IE_NAME
= 'youtube:user'
6933 _VALID_URL
= r
'ytuser:(?P<id>.+)'
6935 'url': 'ytuser:phihag',
6936 'only_matching': True,
6939 def _real_extract(self
, url
):
6940 user_id
= self
._match
_id
(url
)
6941 return self
.url_result(f
'https://www.youtube.com/user/{user_id}', YoutubeTabIE
, user_id
)
6944 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor
):
6945 IE_NAME
= 'youtube:favorites'
6946 IE_DESC
= 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6947 _VALID_URL
= r
':ytfav(?:ou?rite)?s?'
6948 _LOGIN_REQUIRED
= True
6951 'only_matching': True,
6953 'url': ':ytfavorites',
6954 'only_matching': True,
6957 def _real_extract(self
, url
):
6958 return self
.url_result(
6959 'https://www.youtube.com/playlist?list=LL',
6960 ie
=YoutubeTabIE
.ie_key())
6963 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor
):
6964 IE_NAME
= 'youtube:notif'
6965 IE_DESC
= 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6966 _VALID_URL
= r
':ytnotif(?:ication)?s?'
6967 _LOGIN_REQUIRED
= True
6970 'only_matching': True,
6972 'url': ':ytnotifications',
6973 'only_matching': True,
6976 def _extract_notification_menu(self
, response
, continuation_list
):
6977 notification_list
= traverse_obj(
6979 ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6980 ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6981 expected_type
=list) or []
6982 continuation_list
[0] = None
6983 for item
in notification_list
:
6984 entry
= self
._extract
_notification
_renderer
(item
.get('notificationRenderer'))
6987 continuation
= item
.get('continuationItemRenderer')
6989 continuation_list
[0] = continuation
6991 def _extract_notification_renderer(self
, notification
):
6992 video_id
= traverse_obj(
6993 notification
, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str)
6994 url
= f
'https://www.youtube.com/watch?v={video_id}'
6997 browse_ep
= traverse_obj(
6998 notification
, ('navigationEndpoint', 'browseEndpoint'), expected_type
=dict)
6999 channel_id
= self
.ucid_or_none(traverse_obj(browse_ep
, 'browseId', expected_type
=str))
7000 post_id
= self
._search
_regex
(
7001 r
'/post/(.+)', traverse_obj(browse_ep
, 'canonicalBaseUrl', expected_type
=str),
7002 'post id', default
=None)
7003 if not channel_id
or not post_id
:
7005 # The direct /post url redirects to this in the browser
7006 url
= f
'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
7008 channel
= traverse_obj(
7009 notification
, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
7011 notification_title
= self
._get
_text
(notification
, 'shortMessage')
7012 if notification_title
:
7013 notification_title
= notification_title
.replace('\xad', '') # remove soft hyphens
7014 # TODO: handle recommended videos
7015 title
= self
._search
_regex
(
7016 rf
'{re.escape(channel or "")}[^:]+: (.+)', notification_title
,
7017 'video title', default
=None)
7018 timestamp
= (self
._parse
_time
_text
(self
._get
_text
(notification
, 'sentTimeText'))
7019 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
7024 'ie_key': (YoutubeIE
if video_id
else YoutubeTabIE
).ie_key(),
7025 'video_id': video_id
,
7027 'channel_id': channel_id
,
7029 'uploader': channel
,
7030 'thumbnails': self
._extract
_thumbnails
(notification
, 'videoThumbnail'),
7031 'timestamp': timestamp
,
7034 def _notification_menu_entries(self
, ytcfg
):
7035 continuation_list
= [None]
7037 for page
in itertools
.count(1):
7038 ctoken
= traverse_obj(
7039 continuation_list
, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type
=str)
7040 response
= self
._extract
_response
(
7041 item_id
=f
'page {page}', query
={'ctoken': ctoken}
if ctoken
else {}, ytcfg
=ytcfg
,
7042 ep
='notification/get_notification_menu', check_get_keys
='actions',
7043 headers
=self
.generate_api_headers(ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(response
)))
7044 yield from self
._extract
_notification
_menu
(response
, continuation_list
)
7045 if not continuation_list
[0]:
7048 def _real_extract(self
, url
):
7049 display_id
= 'notifications'
7050 ytcfg
= self
._download
_ytcfg
('web', display_id
) if not self
.skip_webpage
else {}
7051 self
._report
_playlist
_authcheck
(ytcfg
)
7052 return self
.playlist_result(self
._notification
_menu
_entries
(ytcfg
), display_id
, display_id
)
7055 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
7056 IE_DESC
= 'YouTube search'
7057 IE_NAME
= 'youtube:search'
7058 _SEARCH_KEY
= 'ytsearch'
7059 _SEARCH_PARAMS
= 'EgIQAfABAQ==' # Videos only
7061 'url': 'ytsearch5:youtube-dl test video',
7062 'playlist_count': 5,
7064 'id': 'youtube-dl test video',
7065 'title': 'youtube-dl test video',
7068 'note': 'Suicide/self-harm search warning',
7069 'url': 'ytsearch1:i hate myself and i wanna die',
7070 'playlist_count': 1,
7072 'id': 'i hate myself and i wanna die',
7073 'title': 'i hate myself and i wanna die',
7078 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
7079 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ ':date'
7080 _SEARCH_KEY
= 'ytsearchdate'
7081 IE_DESC
= 'YouTube search, newest videos first'
7082 _SEARCH_PARAMS
= 'CAISAhAB8AEB' # Videos only, sorted by date
7084 'url': 'ytsearchdate5:youtube-dl test video',
7085 'playlist_count': 5,
7087 'id': 'youtube-dl test video',
7088 'title': 'youtube-dl test video',
7093 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor
):
7094 IE_DESC
= 'YouTube search URLs with sorting and filter support'
7095 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ '_url'
7096 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
7098 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
7099 'playlist_mincount': 5,
7101 'id': 'youtube-dl test video',
7102 'title': 'youtube-dl test video',
7105 'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
7106 'playlist_mincount': 5,
7112 'url': 'https://www.youtube.com/results?search_query=%23cats',
7113 'playlist_mincount': 1,
7117 # The test suite does not have support for nested playlists
7119 # 'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
7125 'url': 'https://www.youtube.com/results?search_query=kurzgesagt&sp=EgIQAg%253D%253D',
7128 'title': 'kurzgesagt',
7133 'id': 'UCsXVk37bltHxD1rDPwtNM8Q',
7134 'url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
7135 'ie_key': 'YoutubeTab',
7136 'channel': 'Kurzgesagt – In a Nutshell',
7137 'description': 'md5:4ae48dfa9505ffc307dad26342d06bfc',
7138 'title': 'Kurzgesagt – In a Nutshell',
7139 'channel_id': 'UCsXVk37bltHxD1rDPwtNM8Q',
7140 # No longer available for search as it is set to the handle.
7141 # 'playlist_count': int,
7142 'channel_url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
7144 'uploader_id': '@kurzgesagt',
7145 'uploader_url': 'https://www.youtube.com/@kurzgesagt',
7146 'uploader': 'Kurzgesagt – In a Nutshell',
7147 'channel_is_verified': True,
7148 'channel_follower_count': int,
7151 'params': {'extract_flat': True, 'playlist_items': '1'}
,
7152 'playlist_mincount': 1,
7154 'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
7155 'only_matching': True,
7158 def _real_extract(self
, url
):
7160 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7161 return self
.playlist_result(self
._search
_results
(query
, qs
.get('sp', (None,))[0]), query
, query
)
7164 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor
):
7165 IE_DESC
= 'YouTube music search URLs with selectable sections, e.g. #songs'
7166 IE_NAME
= 'youtube:music:search_url'
7167 _VALID_URL
= r
'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
7169 'url': 'https://music.youtube.com/search?q=royalty+free+music',
7170 'playlist_count': 16,
7172 'id': 'royalty free music',
7173 'title': 'royalty free music',
7176 'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
7177 'playlist_mincount': 30,
7179 'id': 'royalty free music - songs',
7180 'title': 'royalty free music - songs',
7182 'params': {'extract_flat': 'in_playlist'}
,
7184 'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
7185 'playlist_mincount': 30,
7187 'id': 'royalty free music - community playlists',
7188 'title': 'royalty free music - community playlists',
7190 'params': {'extract_flat': 'in_playlist'}
,
7194 'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
7195 'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
7196 'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
7197 'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
7198 'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
7199 'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
7202 def _real_extract(self
, url
):
7204 query
= (qs
.get('search_query') or qs
.get('q'))[0]
7205 params
= qs
.get('sp', (None,))[0]
7207 section
= next((k
for k
, v
in self
._SECTIONS
.items() if v
== params
), params
)
7209 section
= urllib
.parse
.unquote_plus(([*url
.split('#'), ''])[1]).lower()
7210 params
= self
._SECTIONS
.get(section
)
7213 title
= join_nonempty(query
, section
, delim
=' - ')
7214 return self
.playlist_result(self
._search
_results
(query
, params
, default_client
='web_music'), title
, title
)
7217 class YoutubeFeedsInfoExtractor(InfoExtractor
):
7219 Base class for feed extractors
7220 Subclasses must re-define the _FEED_NAME property.
7222 _LOGIN_REQUIRED
= True
7223 _FEED_NAME
= 'feeds'
7225 def _real_initialize(self
):
7226 YoutubeBaseInfoExtractor
._check
_login
_required
(self
)
7230 return f
'youtube:{cls._FEED_NAME}'
7232 def _real_extract(self
, url
):
7233 return self
.url_result(
7234 f
'https://www.youtube.com/feed/{self._FEED_NAME}', ie
=YoutubeTabIE
.ie_key())
7237 class YoutubeWatchLaterIE(InfoExtractor
):
7238 IE_NAME
= 'youtube:watchlater'
7239 IE_DESC
= 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
7240 _VALID_URL
= r
':ytwatchlater'
7242 'url': ':ytwatchlater',
7243 'only_matching': True,
7246 def _real_extract(self
, url
):
7247 return self
.url_result(
7248 'https://www.youtube.com/playlist?list=WL', ie
=YoutubeTabIE
.ie_key())
7251 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor
):
7252 IE_DESC
= 'YouTube recommended videos; ":ytrec" keyword'
7253 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
7254 _FEED_NAME
= 'recommended'
7255 _LOGIN_REQUIRED
= False
7258 'only_matching': True,
7260 'url': ':ytrecommended',
7261 'only_matching': True,
7263 'url': 'https://youtube.com',
7264 'only_matching': True,
7268 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor
):
7269 IE_DESC
= 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
7270 _VALID_URL
= r
':ytsub(?:scription)?s?'
7271 _FEED_NAME
= 'subscriptions'
7274 'only_matching': True,
7276 'url': ':ytsubscriptions',
7277 'only_matching': True,
7281 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor
):
7282 IE_DESC
= 'Youtube watch history; ":ythis" keyword (requires cookies)'
7283 _VALID_URL
= r
':ythis(?:tory)?'
7284 _FEED_NAME
= 'history'
7286 'url': ':ythistory',
7287 'only_matching': True,
7291 class YoutubeShortsAudioPivotIE(InfoExtractor
):
7292 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
7293 IE_NAME
= 'youtube:shorts:pivot:audio'
7294 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
7296 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
7297 'only_matching': True,
7301 def _generate_audio_pivot_params(video_id
):
7303 Generates sfv_audio_pivot browse params for this video id
7305 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
7306 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
7308 def _real_extract(self
, url
):
7309 video_id
= self
._match
_id
(url
)
7310 return self
.url_result(
7311 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
7315 class YoutubeTruncatedURLIE(InfoExtractor
):
7316 IE_NAME
= 'youtube:truncated_url'
7317 IE_DESC
= False # Do not list
7318 _VALID_URL
= r
'''(?x)
7320 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
7323 annotation_id=annotation_[^&]+|
7329 attribution_link\?a=[^&]+
7335 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
7336 'only_matching': True,
7338 'url': 'https://www.youtube.com/watch?',
7339 'only_matching': True,
7341 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
7342 'only_matching': True,
7344 'url': 'https://www.youtube.com/watch?feature=foo',
7345 'only_matching': True,
7347 'url': 'https://www.youtube.com/watch?hl=en-GB',
7348 'only_matching': True,
7350 'url': 'https://www.youtube.com/watch?t=2372',
7351 'only_matching': True,
7354 def _real_extract(self
, url
):
7355 raise ExtractorError(
7356 'Did you forget to quote the URL? Remember that & is a meta '
7357 'character in most shells, so you want to put the URL in quotes, '
7359 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
7360 ' or simply youtube-dl BaW_jenozKc .',
7364 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
7365 IE_NAME
= 'youtube:clip'
7366 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7368 # FIXME: Other metadata should be extracted from the clip, not from the base video
7369 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7371 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7373 'section_start': 29.0,
7374 'section_end': 39.7,
7377 'availability': 'public',
7378 'categories': ['Gaming'],
7379 'channel': 'Scott The Woz',
7380 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7381 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7382 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7384 'playable_in_embed': True,
7386 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7387 'title': 'Mobile Games on Console - Scott The Woz',
7388 'upload_date': '20210920',
7389 'uploader': 'Scott The Woz',
7390 'uploader_id': '@ScottTheWoz',
7391 'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7393 'live_status': 'not_live',
7394 'channel_follower_count': int,
7395 'chapters': 'count:20',
7396 'comment_count': int,
7397 'heatmap': 'count:100',
7401 def _real_extract(self
, url
):
7402 clip_id
= self
._match
_id
(url
)
7403 _
, data
= self
._extract
_webpage
(url
, clip_id
)
7405 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7407 raise ExtractorError('Unable to find video ID')
7409 clip_data
= traverse_obj(data
, (
7410 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7411 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7412 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7413 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
7416 '_type': 'url_transparent',
7417 'url': f
'https://www.youtube.com/watch?v={video_id}',
7418 'ie_key': YoutubeIE
.ie_key(),
7420 'section_start': int(clip_data
['startTimeMs']) / 1000,
7421 'section_end': int(clip_data
['endTimeMs']) / 1000,
7425 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor
):
7426 IE_NAME
= 'youtube:consent'
7427 IE_DESC
= False # Do not list
7428 _VALID_URL
= r
'https?://consent\.youtube\.com/m\?'
7430 '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',
7432 'id': 'qVv6vCqciTM',
7435 'uploader_id': '@sana_natori',
7436 'comment_count': int,
7437 'chapters': 'count:13',
7438 'upload_date': '20221223',
7439 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7440 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7441 'uploader_url': 'https://www.youtube.com/@sana_natori',
7443 'release_date': '20221223',
7444 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7445 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7447 'playable_in_embed': True,
7449 'availability': 'public',
7450 'channel_follower_count': int,
7451 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7452 'categories': ['Entertainment'],
7453 'live_status': 'was_live',
7454 'release_timestamp': 1671793345,
7455 'channel': 'さなちゃんねる',
7456 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7457 'uploader': 'さなちゃんねる',
7458 'channel_is_verified': True,
7459 'heatmap': 'count:100',
7461 'add_ie': ['Youtube'],
7462 'params': {'skip_download': 'Youtube'}
,
7465 def _real_extract(self
, url
):
7466 redirect_url
= url_or_none(parse_qs(url
).get('continue', [None])[-1])
7467 if not redirect_url
:
7468 raise ExtractorError('Invalid cookie consent redirect URL', expected
=True)
7469 return self
.url_result(redirect_url
)
7472 class YoutubeTruncatedIDIE(InfoExtractor
):
7473 IE_NAME
= 'youtube:truncated_id'
7474 IE_DESC
= False # Do not list
7475 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7478 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7479 'only_matching': True,
7482 def _real_extract(self
, url
):
7483 video_id
= self
._match
_id
(url
)
7484 raise ExtractorError(
7485 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',