21 from .common
import InfoExtractor
, SearchInfoExtractor
22 from .openload
import PhantomJSwrapper
23 from ..compat
import functools
24 from ..jsinterp
import JSInterpreter
69 STREAMING_DATA_CLIENT_NAME
= '__yt_dlp_client'
70 # any clients starting with _ cannot be explicitly requested by the user
73 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
74 'INNERTUBE_CONTEXT': {
77 'clientVersion': '2.20220801.00.00',
80 'INNERTUBE_CONTEXT_CLIENT_NAME': 1
83 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
84 'INNERTUBE_CONTEXT': {
86 'clientName': 'WEB_EMBEDDED_PLAYER',
87 'clientVersion': '1.20220731.00.00',
90 'INNERTUBE_CONTEXT_CLIENT_NAME': 56
93 'INNERTUBE_API_KEY': 'AIzaSyC9XL3ZjWddXya6X74dJoCTL-WEYFDNX30',
94 'INNERTUBE_HOST': 'music.youtube.com',
95 'INNERTUBE_CONTEXT': {
97 'clientName': 'WEB_REMIX',
98 'clientVersion': '1.20220727.01.00',
101 'INNERTUBE_CONTEXT_CLIENT_NAME': 67,
104 'INNERTUBE_API_KEY': 'AIzaSyBUPetSUmoZL-OhlxA7wSac5XinrygCqMo',
105 'INNERTUBE_CONTEXT': {
107 'clientName': 'WEB_CREATOR',
108 'clientVersion': '1.20220726.00.00',
111 'INNERTUBE_CONTEXT_CLIENT_NAME': 62,
114 'INNERTUBE_API_KEY': 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w',
115 'INNERTUBE_CONTEXT': {
117 'clientName': 'ANDROID',
118 'clientVersion': '17.31.35',
119 'androidSdkVersion': 30,
120 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
123 'INNERTUBE_CONTEXT_CLIENT_NAME': 3,
124 'REQUIRE_JS_PLAYER': False
126 'android_embedded': {
127 'INNERTUBE_API_KEY': 'AIzaSyCjc_pVEDi4qsv5MtC2dMXzpIaDoRFLsxw',
128 'INNERTUBE_CONTEXT': {
130 'clientName': 'ANDROID_EMBEDDED_PLAYER',
131 'clientVersion': '17.31.35',
132 'androidSdkVersion': 30,
133 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
136 'INNERTUBE_CONTEXT_CLIENT_NAME': 55,
137 'REQUIRE_JS_PLAYER': False
140 'INNERTUBE_API_KEY': 'AIzaSyAOghZGza2MQSZkY_zfZ370N-PUdXEo8AI',
141 'INNERTUBE_CONTEXT': {
143 'clientName': 'ANDROID_MUSIC',
144 'clientVersion': '5.16.51',
145 'androidSdkVersion': 30,
146 'userAgent': 'com.google.android.apps.youtube.music/5.16.51 (Linux; U; Android 11) gzip'
149 'INNERTUBE_CONTEXT_CLIENT_NAME': 21,
150 'REQUIRE_JS_PLAYER': False
153 'INNERTUBE_API_KEY': 'AIzaSyD_qjV8zaaUMehtLkrKFgVeSX_Iqbtyws8',
154 'INNERTUBE_CONTEXT': {
156 'clientName': 'ANDROID_CREATOR',
157 'clientVersion': '22.30.100',
158 'androidSdkVersion': 30,
159 'userAgent': 'com.google.android.apps.youtube.creator/22.30.100 (Linux; U; Android 11) gzip'
162 'INNERTUBE_CONTEXT_CLIENT_NAME': 14,
163 'REQUIRE_JS_PLAYER': False
165 # iOS clients have HLS live streams. Setting device model to get 60fps formats.
166 # See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/680#issuecomment-1002724558
168 'INNERTUBE_API_KEY': 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc',
169 'INNERTUBE_CONTEXT': {
172 'clientVersion': '17.33.2',
173 'deviceModel': 'iPhone14,3',
174 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
177 'INNERTUBE_CONTEXT_CLIENT_NAME': 5,
178 'REQUIRE_JS_PLAYER': False
181 'INNERTUBE_CONTEXT': {
183 'clientName': 'IOS_MESSAGES_EXTENSION',
184 'clientVersion': '17.33.2',
185 'deviceModel': 'iPhone14,3',
186 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
189 'INNERTUBE_CONTEXT_CLIENT_NAME': 66,
190 'REQUIRE_JS_PLAYER': False
193 'INNERTUBE_API_KEY': 'AIzaSyBAETezhkwP0ZWA02RsqT1zu78Fpt0bC_s',
194 'INNERTUBE_CONTEXT': {
196 'clientName': 'IOS_MUSIC',
197 'clientVersion': '5.21',
198 'deviceModel': 'iPhone14,3',
199 'userAgent': 'com.google.ios.youtubemusic/5.21 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
202 'INNERTUBE_CONTEXT_CLIENT_NAME': 26,
203 'REQUIRE_JS_PLAYER': False
206 'INNERTUBE_CONTEXT': {
208 'clientName': 'IOS_CREATOR',
209 'clientVersion': '22.33.101',
210 'deviceModel': 'iPhone14,3',
211 'userAgent': 'com.google.ios.ytcreator/22.33.101 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
214 'INNERTUBE_CONTEXT_CLIENT_NAME': 15,
215 'REQUIRE_JS_PLAYER': False
217 # mweb has 'ultralow' formats
218 # See: https://github.com/yt-dlp/yt-dlp/pull/557
220 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
221 'INNERTUBE_CONTEXT': {
223 'clientName': 'MWEB',
224 'clientVersion': '2.20220801.00.00',
227 'INNERTUBE_CONTEXT_CLIENT_NAME': 2
229 # This client can access age restricted videos (unless the uploader has disabled the 'allow embedding' option)
230 # See: https://github.com/zerodytrash/YouTube-Internal-Clients
232 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
233 'INNERTUBE_CONTEXT': {
235 'clientName': 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
236 'clientVersion': '2.0',
239 'INNERTUBE_CONTEXT_CLIENT_NAME': 85
244 def _split_innertube_client(client_name
):
245 variant
, *base
= client_name
.rsplit('.', 1)
247 return variant
, base
[0], variant
248 base
, *variant
= client_name
.split('_', 1)
249 return client_name
, base
, variant
[0] if variant
else None
252 def short_client_name(client_name
):
253 main
, *parts
= _split_innertube_client(client_name
)[0].replace('embedscreen', 'e_s').split('_')
254 return join_nonempty(main
[:4], ''.join(x
[0] for x
in parts
)).upper()
257 def build_innertube_clients():
259 'embedUrl': 'https://www.youtube.com/', # Can be any valid URL
261 BASE_CLIENTS
= ('android', 'web', 'tv', 'ios', 'mweb')
262 priority
= qualities(BASE_CLIENTS
[::-1])
264 for client
, ytcfg
in tuple(INNERTUBE_CLIENTS
.items()):
265 ytcfg
.setdefault('INNERTUBE_API_KEY', 'AIzaSyDCU8hByM-4DrUqRUYnGn-3llEO78bcxq8')
266 ytcfg
.setdefault('INNERTUBE_HOST', 'www.youtube.com')
267 ytcfg
.setdefault('REQUIRE_JS_PLAYER', True)
268 ytcfg
['INNERTUBE_CONTEXT']['client'].setdefault('hl', 'en')
270 _
, base_client
, variant
= _split_innertube_client(client
)
271 ytcfg
['priority'] = 10 * priority(base_client
)
274 INNERTUBE_CLIENTS
[f
'{client}_embedscreen'] = embedscreen
= copy
.deepcopy(ytcfg
)
275 embedscreen
['INNERTUBE_CONTEXT']['client']['clientScreen'] = 'EMBED'
276 embedscreen
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
277 embedscreen
['priority'] -= 3
278 elif variant
== 'embedded':
279 ytcfg
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
280 ytcfg
['priority'] -= 2
282 ytcfg
['priority'] -= 3
285 build_innertube_clients()
288 class BadgeType(enum
.Enum
):
289 AVAILABILITY_UNLISTED
= enum
.auto()
290 AVAILABILITY_PRIVATE
= enum
.auto()
291 AVAILABILITY_PUBLIC
= enum
.auto()
292 AVAILABILITY_PREMIUM
= enum
.auto()
293 AVAILABILITY_SUBSCRIPTION
= enum
.auto()
294 LIVE_NOW
= enum
.auto()
297 class YoutubeBaseInfoExtractor(InfoExtractor
):
298 """Provide base functions for Youtube extractors"""
301 r
'channel|c|user|playlist|watch|w|v|embed|e|live|watch_popup|clip|'
302 r
'shorts|movies|results|search|shared|hashtag|trending|explore|feed|feeds|'
303 r
'browse|oembed|get_video_info|iframe_api|s/player|source|'
304 r
'storefront|oops|index|account|t/terms|about|upload|signin|logout')
306 _PLAYLIST_ID_RE
= r
'(?:(?:PL|LL|EC|UU|FL|RD|UL|TL|PU|OLAK5uy_)[0-9A-Za-z-_]{10,}|RDMM|WL|LL|LM)'
308 # _NETRC_MACHINE = 'youtube'
310 # If True it will raise an error if no login info is provided
311 _LOGIN_REQUIRED
= False
314 # invidious-redirect websites
315 r
'(?:www\.)?redirect\.invidious\.io',
316 r
'(?:(?:www|dev)\.)?invidio\.us',
317 # Invidious instances taken from https://github.com/iv-org/documentation/blob/master/docs/instances.md
318 r
'(?:www\.)?invidious\.pussthecat\.org',
319 r
'(?:www\.)?invidious\.zee\.li',
320 r
'(?:www\.)?invidious\.ethibox\.fr',
321 r
'(?:www\.)?iv\.ggtyler\.dev',
322 r
'(?:www\.)?inv\.vern\.i2p',
323 r
'(?:www\.)?am74vkcrjp2d5v36lcdqgsj2m6x36tbrkhsruoegwfcizzabnfgf5zyd\.onion',
324 r
'(?:www\.)?inv\.riverside\.rocks',
325 r
'(?:www\.)?invidious\.silur\.me',
326 r
'(?:www\.)?inv\.bp\.projectsegfau\.lt',
327 r
'(?:www\.)?invidious\.g4c3eya4clenolymqbpgwz3q3tawoxw56yhzk4vugqrl6dtu3ejvhjid\.onion',
328 r
'(?:www\.)?invidious\.slipfox\.xyz',
329 r
'(?:www\.)?invidious\.esmail5pdn24shtvieloeedh7ehz3nrwcdivnfhfcedl7gf4kwddhkqd\.onion',
330 r
'(?:www\.)?inv\.vernccvbvyi5qhfzyqengccj7lkove6bjot2xhh5kajhwvidqafczrad\.onion',
331 r
'(?:www\.)?invidious\.tiekoetter\.com',
332 r
'(?:www\.)?iv\.odysfvr23q5wgt7i456o5t3trw2cw5dgn56vbjfbq2m7xsc5vqbqpcyd\.onion',
333 r
'(?:www\.)?invidious\.nerdvpn\.de',
334 r
'(?:www\.)?invidious\.weblibre\.org',
335 r
'(?:www\.)?inv\.odyssey346\.dev',
336 r
'(?:www\.)?invidious\.dhusch\.de',
337 r
'(?:www\.)?iv\.melmac\.space',
338 r
'(?:www\.)?watch\.thekitty\.zone',
339 r
'(?:www\.)?invidious\.privacydev\.net',
340 r
'(?:www\.)?ng27owmagn5amdm7l5s3rsqxwscl5ynppnis5dqcasogkyxcfqn7psid\.onion',
341 r
'(?:www\.)?invidious\.drivet\.xyz',
342 r
'(?:www\.)?vid\.priv\.au',
343 r
'(?:www\.)?euxxcnhsynwmfidvhjf6uzptsmh4dipkmgdmcmxxuo7tunp3ad2jrwyd\.onion',
344 r
'(?:www\.)?inv\.vern\.cc',
345 r
'(?:www\.)?invidious\.esmailelbob\.xyz',
346 r
'(?:www\.)?invidious\.sethforprivacy\.com',
347 r
'(?:www\.)?yt\.oelrichsgarcia\.de',
348 r
'(?:www\.)?yt\.artemislena\.eu',
349 r
'(?:www\.)?invidious\.flokinet\.to',
350 r
'(?:www\.)?invidious\.baczek\.me',
351 r
'(?:www\.)?y\.com\.sb',
352 r
'(?:www\.)?invidious\.epicsite\.xyz',
353 r
'(?:www\.)?invidious\.lidarshield\.cloud',
354 r
'(?:www\.)?yt\.funami\.tech',
355 r
'(?:www\.)?invidious\.3o7z6yfxhbw7n3za4rss6l434kmv55cgw2vuziwuigpwegswvwzqipyd\.onion',
356 r
'(?:www\.)?osbivz6guyeahrwp2lnwyjk2xos342h4ocsxyqrlaopqjuhwn2djiiyd\.onion',
357 r
'(?:www\.)?u2cvlit75owumwpy4dj2hsmvkq7nvrclkpht7xgyye2pyoxhpmclkrad\.onion',
358 # youtube-dl invidious instances list
359 r
'(?:(?:www|no)\.)?invidiou\.sh',
360 r
'(?:(?:www|fi)\.)?invidious\.snopyta\.org',
361 r
'(?:www\.)?invidious\.kabi\.tk',
362 r
'(?:www\.)?invidious\.mastodon\.host',
363 r
'(?:www\.)?invidious\.zapashcanon\.fr',
364 r
'(?:www\.)?(?:invidious(?:-us)?|piped)\.kavin\.rocks',
365 r
'(?:www\.)?invidious\.tinfoil-hat\.net',
366 r
'(?:www\.)?invidious\.himiko\.cloud',
367 r
'(?:www\.)?invidious\.reallyancient\.tech',
368 r
'(?:www\.)?invidious\.tube',
369 r
'(?:www\.)?invidiou\.site',
370 r
'(?:www\.)?invidious\.site',
371 r
'(?:www\.)?invidious\.xyz',
372 r
'(?:www\.)?invidious\.nixnet\.xyz',
373 r
'(?:www\.)?invidious\.048596\.xyz',
374 r
'(?:www\.)?invidious\.drycat\.fr',
375 r
'(?:www\.)?inv\.skyn3t\.in',
376 r
'(?:www\.)?tube\.poal\.co',
377 r
'(?:www\.)?tube\.connect\.cafe',
378 r
'(?:www\.)?vid\.wxzm\.sx',
379 r
'(?:www\.)?vid\.mint\.lgbt',
380 r
'(?:www\.)?vid\.puffyan\.us',
381 r
'(?:www\.)?yewtu\.be',
382 r
'(?:www\.)?yt\.elukerio\.org',
383 r
'(?:www\.)?yt\.lelux\.fi',
384 r
'(?:www\.)?invidious\.ggc-project\.de',
385 r
'(?:www\.)?yt\.maisputain\.ovh',
386 r
'(?:www\.)?ytprivate\.com',
387 r
'(?:www\.)?invidious\.13ad\.de',
388 r
'(?:www\.)?invidious\.toot\.koeln',
389 r
'(?:www\.)?invidious\.fdn\.fr',
390 r
'(?:www\.)?watch\.nettohikari\.com',
391 r
'(?:www\.)?invidious\.namazso\.eu',
392 r
'(?:www\.)?invidious\.silkky\.cloud',
393 r
'(?:www\.)?invidious\.exonip\.de',
394 r
'(?:www\.)?invidious\.riverside\.rocks',
395 r
'(?:www\.)?invidious\.blamefran\.net',
396 r
'(?:www\.)?invidious\.moomoo\.de',
397 r
'(?:www\.)?ytb\.trom\.tf',
398 r
'(?:www\.)?yt\.cyberhost\.uk',
399 r
'(?:www\.)?kgg2m7yk5aybusll\.onion',
400 r
'(?:www\.)?qklhadlycap4cnod\.onion',
401 r
'(?:www\.)?axqzx4s6s54s32yentfqojs3x5i7faxza6xo3ehd4bzzsg2ii4fv2iid\.onion',
402 r
'(?:www\.)?c7hqkpkpemu6e7emz5b4vyz7idjgdvgaaa3dyimmeojqbgpea3xqjoid\.onion',
403 r
'(?:www\.)?fz253lmuao3strwbfbmx46yu7acac2jz27iwtorgmbqlkurlclmancad\.onion',
404 r
'(?:www\.)?invidious\.l4qlywnpwqsluw65ts7md3khrivpirse744un3x7mlskqauz5pyuzgqd\.onion',
405 r
'(?:www\.)?owxfohz4kjyv25fvlqilyxast7inivgiktls3th44jhk3ej3i7ya\.b32\.i2p',
406 r
'(?:www\.)?4l2dgddgsrkf2ous66i6seeyi6etzfgrue332grh2n7madpwopotugyd\.onion',
407 r
'(?:www\.)?w6ijuptxiku4xpnnaetxvnkc5vqcdu7mgns2u77qefoixi63vbvnpnqd\.onion',
408 r
'(?:www\.)?kbjggqkzv65ivcqj6bumvp337z6264huv5kpkwuv6gu5yjiskvan7fad\.onion',
409 r
'(?:www\.)?grwp24hodrefzvjjuccrkw3mjq4tzhaaq32amf33dzpmuxe7ilepcmad\.onion',
410 r
'(?:www\.)?hpniueoejy4opn7bc4ftgazyqjoeqwlvh2uiku2xqku6zpoa4bf5ruid\.onion',
411 # piped instances from https://github.com/TeamPiped/Piped/wiki/Instances
412 r
'(?:www\.)?piped\.kavin\.rocks',
413 r
'(?:www\.)?piped\.tokhmi\.xyz',
414 r
'(?:www\.)?piped\.syncpundit\.io',
415 r
'(?:www\.)?piped\.mha\.fi',
416 r
'(?:www\.)?watch\.whatever\.social',
417 r
'(?:www\.)?piped\.garudalinux\.org',
418 r
'(?:www\.)?piped\.rivo\.lol',
419 r
'(?:www\.)?piped-libre\.kavin\.rocks',
420 r
'(?:www\.)?yt\.jae\.fi',
421 r
'(?:www\.)?piped\.mint\.lgbt',
423 r
'(?:www\.)?piped\.esmailelbob\.xyz',
424 r
'(?:www\.)?piped\.projectsegfau\.lt',
425 r
'(?:www\.)?piped\.privacydev\.net',
426 r
'(?:www\.)?piped\.palveluntarjoaja\.eu',
427 r
'(?:www\.)?piped\.smnz\.de',
428 r
'(?:www\.)?piped\.adminforge\.de',
429 r
'(?:www\.)?watch\.whatevertinfoil\.de',
430 r
'(?:www\.)?piped\.qdi\.fi',
431 r
'(?:www\.)?piped\.video',
432 r
'(?:www\.)?piped\.aeong\.one',
433 r
'(?:www\.)?piped\.moomoo\.me',
434 r
'(?:www\.)?piped\.chauvet\.pro',
435 r
'(?:www\.)?watch\.leptons\.xyz',
436 r
'(?:www\.)?pd\.vern\.cc',
437 r
'(?:www\.)?piped\.hostux\.net',
438 r
'(?:www\.)?piped\.lunar\.icu',
439 # Hyperpipe instances from https://hyperpipe.codeberg.page/
440 r
'(?:www\.)?hyperpipe\.surge\.sh',
441 r
'(?:www\.)?hyperpipe\.esmailelbob\.xyz',
442 r
'(?:www\.)?listen\.whatever\.social',
443 r
'(?:www\.)?music\.adminforge\.de',
446 # extracted from account/account_menu ep
447 # XXX: These are the supported YouTube UI and API languages,
448 # which is slightly different from languages supported for translation in YouTube studio
449 _SUPPORTED_LANG_CODES
= [
450 'af', 'az', 'id', 'ms', 'bs', 'ca', 'cs', 'da', 'de', 'et', 'en-IN', 'en-GB', 'en', 'es',
451 'es-419', 'es-US', 'eu', 'fil', 'fr', 'fr-CA', 'gl', 'hr', 'zu', 'is', 'it', 'sw', 'lv',
452 'lt', 'hu', 'nl', 'no', 'uz', 'pl', 'pt-PT', 'pt', 'ro', 'sq', 'sk', 'sl', 'sr-Latn', 'fi',
453 'sv', 'vi', 'tr', 'be', 'bg', 'ky', 'kk', 'mk', 'mn', 'ru', 'sr', 'uk', 'el', 'hy', 'iw',
454 'ur', 'ar', 'fa', 'ne', 'mr', 'hi', 'as', 'bn', 'pa', 'gu', 'or', 'ta', 'te', 'kn', 'ml',
455 'si', 'th', 'lo', 'my', 'ka', 'am', 'km', 'zh-CN', 'zh-TW', 'zh-HK', 'ja', 'ko'
458 _IGNORED_WARNINGS
= {'Unavailable videos will be hidden during playback'}
460 _YT_HANDLE_RE
= r
'@[\w.-]{3,30}' # https://support.google.com/youtube/answer/11585688?hl=en
461 _YT_CHANNEL_UCID_RE
= r
'UC[\w-]{22}'
463 def ucid_or_none(self
, ucid
):
464 return self
._search
_regex
(rf
'^({self._YT_CHANNEL_UCID_RE})$', ucid
, 'UC-id', default
=None)
466 def handle_or_none(self
, handle
):
467 return self
._search
_regex
(rf
'^({self._YT_HANDLE_RE})$', handle
, '@-handle', default
=None)
469 def handle_from_url(self
, url
):
470 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_HANDLE_RE})',
471 url
, 'channel handle', default
=None)
473 def ucid_from_url(self
, url
):
474 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_CHANNEL_UCID_RE})',
475 url
, 'channel id', default
=None)
477 @functools.cached_property
478 def _preferred_lang(self
):
480 Returns a language code supported by YouTube for the user preferred language.
481 Returns None if no preferred language set.
483 preferred_lang
= self
._configuration
_arg
('lang', ie_key
='Youtube', casesense
=True, default
=[''])[0]
484 if not preferred_lang
:
486 if preferred_lang
not in self
._SUPPORTED
_LANG
_CODES
:
487 raise ExtractorError(
488 f
'Unsupported language code: {preferred_lang}. Supported language codes (case-sensitive): {join_nonempty(*self._SUPPORTED_LANG_CODES, delim=", ")}.',
490 elif preferred_lang
!= 'en':
492 f
'Preferring "{preferred_lang}" translated fields. Note that some metadata extraction may fail or be incorrect.')
493 return preferred_lang
495 def _initialize_consent(self
):
496 cookies
= self
._get
_cookies
('https://www.youtube.com/')
497 if cookies
.get('__Secure-3PSID'):
500 consent
= cookies
.get('CONSENT')
502 if 'YES' in consent
.value
:
504 consent_id
= self
._search
_regex
(
505 r
'PENDING\+(\d+)', consent
.value
, 'consent', default
=None)
507 consent_id
= random
.randint(100, 999)
508 self
._set
_cookie
('.youtube.com', 'CONSENT', 'YES+cb.20210328-17-p0.en+FX+%s' % consent_id
)
510 def _initialize_pref(self
):
511 cookies
= self
._get
_cookies
('https://www.youtube.com/')
512 pref_cookie
= cookies
.get('PREF')
516 pref
= dict(urllib
.parse
.parse_qsl(pref_cookie
.value
))
518 self
.report_warning('Failed to parse user PREF cookie' + bug_reports_message())
519 pref
.update({'hl': self._preferred_lang or 'en', 'tz': 'UTC'}
)
520 self
._set
_cookie
('.youtube.com', name
='PREF', value
=urllib
.parse
.urlencode(pref
))
522 def _real_initialize(self
):
523 self
._initialize
_pref
()
524 self
._initialize
_consent
()
525 self
._check
_login
_required
()
527 def _check_login_required(self
):
528 if self
._LOGIN
_REQUIRED
and not self
._cookies
_passed
:
529 self
.raise_login_required('Login details are needed to download this content', method
='cookies')
531 _YT_INITIAL_DATA_RE
= r
'(?:window\s*\[\s*["\']ytInitialData
["\']\s*\]|ytInitialData)\s*='
532 _YT_INITIAL_PLAYER_RESPONSE_RE = r'ytInitialPlayerResponse\s*='
534 def _get_default_ytcfg(self, client='web'):
535 return copy.deepcopy(INNERTUBE_CLIENTS[client])
537 def _get_innertube_host(self, client='web'):
538 return INNERTUBE_CLIENTS[client]['INNERTUBE_HOST']
540 def _ytcfg_get_safe(self, ytcfg, getter, expected_type=None, default_client='web'):
541 # try_get but with fallback to default ytcfg client values when present
542 _func = lambda y: try_get(y, getter, expected_type)
543 return _func(ytcfg) or _func(self._get_default_ytcfg(default_client))
545 def _extract_client_name(self, ytcfg, default_client='web'):
546 return self._ytcfg_get_safe(
547 ytcfg, (lambda x: x['INNERTUBE_CLIENT_NAME'],
548 lambda x: x['INNERTUBE_CONTEXT']['client']['clientName']), str, default_client)
550 def _extract_client_version(self, ytcfg, default_client='web'):
551 return self._ytcfg_get_safe(
552 ytcfg, (lambda x: x['INNERTUBE_CLIENT_VERSION'],
553 lambda x: x['INNERTUBE_CONTEXT']['client']['clientVersion']), str, default_client)
555 def _select_api_hostname(self, req_api_hostname, default_client=None):
556 return (self._configuration_arg('innertube_host', [''], ie_key=YoutubeIE.ie_key())[0]
557 or req_api_hostname or self._get_innertube_host(default_client or 'web'))
559 def _extract_api_key(self, ytcfg=None, default_client='web'):
560 return self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_API_KEY'], str, default_client)
562 def _extract_context(self, ytcfg=None, default_client='web'):
564 (ytcfg, self._get_default_ytcfg(default_client)), 'INNERTUBE_CONTEXT', expected_type=dict)
565 # Enforce language and tz for extraction
566 client_context = traverse_obj(context, 'client', expected_type=dict, default={})
567 client_context.update({'hl': self._preferred_lang or 'en', 'timeZone': 'UTC', 'utcOffsetMinutes': 0})
572 def _generate_sapisidhash_header(self, origin='https://www.youtube.com'):
573 time_now = round(time.time())
574 if self._SAPISID is None:
575 yt_cookies = self._get_cookies('https://www.youtube.com')
576 # Sometimes SAPISID cookie isn't present but __Secure-3PAPISID is.
577 # See: https://github.com/yt-dlp/yt-dlp/issues/393
578 sapisid_cookie = dict_get(
579 yt_cookies, ('__Secure-3PAPISID', 'SAPISID'))
580 if sapisid_cookie and sapisid_cookie.value:
581 self._SAPISID = sapisid_cookie.value
582 self.write_debug('Extracted SAPISID cookie')
583 # SAPISID cookie is required if not already present
584 if not yt_cookies.get('SAPISID'):
585 self.write_debug('Copying __Secure-3PAPISID cookie to SAPISID cookie')
587 '.youtube.com', 'SAPISID', self._SAPISID, secure=True, expire_time=time_now + 3600)
589 self._SAPISID = False
590 if not self._SAPISID:
592 # SAPISIDHASH algorithm from https://stackoverflow.com/a/32065323
593 sapisidhash = hashlib.sha1(
594 f'{time_now} {self._SAPISID} {origin}'.encode()).hexdigest()
595 return f'SAPISIDHASH {time_now}_{sapisidhash}'
597 def _call_api(self, ep, query, video_id, fatal=True, headers=None,
598 note='Downloading API JSON', errnote='Unable to download API page',
599 context=None, api_key=None, api_hostname=None, default_client='web'):
601 data = {'context': context} if context else {'context': self._extract_context(default_client=default_client)}
603 real_headers = self.generate_api_headers(default_client=default_client)
604 real_headers.update({'content-type': 'application/json'})
606 real_headers.update(headers)
607 api_key = (self._configuration_arg('innertube_key', [''], ie_key=YoutubeIE.ie_key(), casesense=True)[0]
608 or api_key or self._extract_api_key(default_client=default_client))
609 return self._download_json(
610 f'https://{self._select_api_hostname(api_hostname, default_client)}/youtubei/v1/{ep}',
611 video_id=video_id, fatal=fatal, note=note, errnote=errnote,
612 data=json.dumps(data).encode('utf8'), headers=real_headers,
613 query={'key': api_key, 'prettyPrint': 'false'})
615 def extract_yt_initial_data(self, item_id, webpage, fatal=True):
616 return self._search_json(self._YT_INITIAL_DATA_RE, webpage, 'yt initial data', item_id, fatal=fatal)
619 def _extract_session_index(*data):
621 Index of current account in account list.
622 See: https://github.com/yt-dlp/yt-dlp/pull/519
625 session_index = int_or_none(try_get(ytcfg, lambda x: x['SESSION_INDEX']))
626 if session_index is not None:
630 def _extract_identity_token(self, ytcfg=None, webpage=None):
632 token = try_get(ytcfg, lambda x: x['ID_TOKEN'], str)
636 return self._search_regex(
637 r'\bID_TOKEN["\']\s
*:\s
*["\'](.+?)["\']', webpage,
638 'identity token
', default=None, fatal=False)
641 def _extract_account_syncid(*args):
643 Extract syncId required to download private playlists of secondary channels
644 @params response and/or ytcfg
647 # ytcfg includes channel_syncid if on secondary channel
648 delegated_sid = try_get(data, lambda x: x['DELEGATED_SESSION_ID
'], str)
652 data, (lambda x: x['responseContext
']['mainAppWebResponseContext
']['datasyncId
'],
653 lambda x: x['DATASYNC_ID
']), str) or '').split('||
')
654 if len(sync_ids) >= 2 and sync_ids[1]:
655 # datasyncid is of the form "channel_syncid||user_syncid" for secondary channel
656 # and just "user_syncid||" for primary channel. We only want the channel_syncid
660 def _extract_visitor_data(*args):
662 Extracts visitorData from an API response or ytcfg
663 Appears to be used to track session state
666 args, [('VISITOR_DATA
', ('INNERTUBE_CONTEXT
', 'client
', 'visitorData
'), ('responseContext
', 'visitorData
'))],
669 @functools.cached_property
670 def is_authenticated(self):
671 return bool(self._generate_sapisidhash_header())
673 def extract_ytcfg(self, video_id, webpage):
676 return self._parse_json(
678 r'ytcfg\
.set\s
*\
(\s
*({.+?}
)\s
*\
)\s
*;', webpage, 'ytcfg
',
679 default='{}'), video_id, fatal=False) or {}
681 def generate_api_headers(
682 self
, *, ytcfg
=None, account_syncid
=None, session_index
=None,
683 visitor_data
=None, identity_token
=None, api_hostname
=None, default_client
='web'):
685 origin
= 'https://' + (self
._select
_api
_hostname
(api_hostname
, default_client
))
687 'X-YouTube-Client-Name': str(
688 self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT_CLIENT_NAME'], default_client
=default_client
)),
689 'X-YouTube-Client-Version': self
._extract
_client
_version
(ytcfg
, default_client
),
691 'X-Youtube-Identity-Token': identity_token
or self
._extract
_identity
_token
(ytcfg
),
692 'X-Goog-PageId': account_syncid
or self
._extract
_account
_syncid
(ytcfg
),
693 'X-Goog-Visitor-Id': visitor_data
or self
._extract
_visitor
_data
(ytcfg
),
694 'User-Agent': self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT']['client']['userAgent'], default_client
=default_client
)
696 if session_index
is None:
697 session_index
= self
._extract
_session
_index
(ytcfg
)
698 if account_syncid
or session_index
is not None:
699 headers
['X-Goog-AuthUser'] = session_index
if session_index
is not None else 0
701 auth
= self
._generate
_sapisidhash
_header
(origin
)
703 headers
['Authorization'] = auth
704 headers
['X-Origin'] = origin
705 return filter_dict(headers
)
707 def _download_ytcfg(self
, client
, video_id
):
709 'web': 'https://www.youtube.com',
710 'web_music': 'https://music.youtube.com',
711 'web_embedded': f
'https://www.youtube.com/embed/{video_id}?html5=1'
715 webpage
= self
._download
_webpage
(
716 url
, video_id
, fatal
=False, note
=f
'Downloading {client.replace("_", " ").strip()} client config')
717 return self
.extract_ytcfg(video_id
, webpage
) or {}
720 def _build_api_continuation_query(continuation
, ctp
=None):
722 'continuation': continuation
724 # TODO: Inconsistency with clickTrackingParams.
725 # Currently we have a fixed ctp contained within context (from ytcfg)
726 # and a ctp in root query for continuation.
728 query
['clickTracking'] = {'clickTrackingParams': ctp}
732 def _extract_next_continuation_data(cls
, renderer
):
733 next_continuation
= try_get(
734 renderer
, (lambda x
: x
['continuations'][0]['nextContinuationData'],
735 lambda x
: x
['continuation']['reloadContinuationData']), dict)
736 if not next_continuation
:
738 continuation
= next_continuation
.get('continuation')
741 ctp
= next_continuation
.get('clickTrackingParams')
742 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
745 def _extract_continuation_ep_data(cls
, continuation_ep
: dict):
746 if isinstance(continuation_ep
, dict):
747 continuation
= try_get(
748 continuation_ep
, lambda x
: x
['continuationCommand']['token'], str)
751 ctp
= continuation_ep
.get('clickTrackingParams')
752 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
755 def _extract_continuation(cls
, renderer
):
756 next_continuation
= cls
._extract
_next
_continuation
_data
(renderer
)
757 if next_continuation
:
758 return next_continuation
760 return traverse_obj(renderer
, (
761 ('contents', 'items', 'rows'), ..., 'continuationItemRenderer',
762 ('continuationEndpoint', ('button', 'buttonRenderer', 'command'))
763 ), get_all
=False, expected_type
=cls
._extract
_continuation
_ep
_data
)
766 def _extract_alerts(cls
, data
):
767 for alert_dict
in try_get(data
, lambda x
: x
['alerts'], list) or []:
768 if not isinstance(alert_dict
, dict):
770 for alert
in alert_dict
.values():
771 alert_type
= alert
.get('type')
774 message
= cls
._get
_text
(alert
, 'text')
776 yield alert_type
, message
778 def _report_alerts(self
, alerts
, expected
=True, fatal
=True, only_once
=False):
779 errors
, warnings
= [], []
780 for alert_type
, alert_message
in alerts
:
781 if alert_type
.lower() == 'error' and fatal
:
782 errors
.append([alert_type
, alert_message
])
783 elif alert_message
not in self
._IGNORED
_WARNINGS
:
784 warnings
.append([alert_type
, alert_message
])
786 for alert_type
, alert_message
in (warnings
+ errors
[:-1]):
787 self
.report_warning(f
'YouTube said: {alert_type} - {alert_message}', only_once
=only_once
)
789 raise ExtractorError('YouTube said: %s' % errors
[-1][1], expected
=expected
)
791 def _extract_and_report_alerts(self
, data
, *args
, **kwargs
):
792 return self
._report
_alerts
(self
._extract
_alerts
(data
), *args
, **kwargs
)
794 def _extract_badges(self
, renderer
: dict):
796 'PRIVACY_UNLISTED': BadgeType
.AVAILABILITY_UNLISTED
,
797 'PRIVACY_PRIVATE': BadgeType
.AVAILABILITY_PRIVATE
,
798 'PRIVACY_PUBLIC': BadgeType
.AVAILABILITY_PUBLIC
802 'BADGE_STYLE_TYPE_MEMBERS_ONLY': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
803 'BADGE_STYLE_TYPE_PREMIUM': BadgeType
.AVAILABILITY_PREMIUM
,
804 'BADGE_STYLE_TYPE_LIVE_NOW': BadgeType
.LIVE_NOW
808 'unlisted': BadgeType
.AVAILABILITY_UNLISTED
,
809 'private': BadgeType
.AVAILABILITY_PRIVATE
,
810 'members only': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
811 'live': BadgeType
.LIVE_NOW
,
812 'premium': BadgeType
.AVAILABILITY_PREMIUM
816 for badge
in traverse_obj(renderer
, ('badges', ..., 'metadataBadgeRenderer')):
818 privacy_icon_map
.get(traverse_obj(badge
, ('icon', 'iconType'), expected_type
=str))
819 or badge_style_map
.get(traverse_obj(badge
, 'style'))
822 badges
.append({'type': badge_type}
)
825 # fallback, won't work in some languages
826 label
= traverse_obj(badge
, 'label', expected_type
=str, default
='')
827 for match
, label_badge_type
in label_map
.items():
828 if match
in label
.lower():
829 badges
.append({'type': badge_type}
)
835 def _has_badge(badges
, badge_type
):
836 return bool(traverse_obj(badges
, lambda _
, v
: v
['type'] == badge_type
))
839 def _get_text(data
, *path_list
, max_runs
=None):
840 for path
in path_list
or [None]:
844 obj
= traverse_obj(data
, path
, default
=[])
845 if not any(key
is ... or isinstance(key
, (list, tuple)) for key
in variadic(path
)):
848 text
= try_get(item
, lambda x
: x
['simpleText'], str)
851 runs
= try_get(item
, lambda x
: x
['runs'], list) or []
852 if not runs
and isinstance(item
, list):
855 runs
= runs
[:min(len(runs
), max_runs
or len(runs
))]
856 text
= ''.join(traverse_obj(runs
, (..., 'text'), expected_type
=str))
860 def _get_count(self
, data
, *path_list
):
861 count_text
= self
._get
_text
(data
, *path_list
) or ''
862 count
= parse_count(count_text
)
865 self
._search
_regex
(r
'^([\d,]+)', re
.sub(r
'\s', '', count_text
), 'count', default
=None))
869 def _extract_thumbnails(data
, *path_list
):
871 Extract thumbnails from thumbnails dict
872 @param path_list: path list to level that contains 'thumbnails' key
875 for path
in path_list
or [()]:
876 for thumbnail
in traverse_obj(data
, (*variadic(path
), 'thumbnails', ...)):
877 thumbnail_url
= url_or_none(thumbnail
.get('url'))
878 if not thumbnail_url
:
880 # Sometimes youtube gives a wrong thumbnail URL. See:
881 # https://github.com/yt-dlp/yt-dlp/issues/233
882 # https://github.com/ytdl-org/youtube-dl/issues/28023
883 if 'maxresdefault' in thumbnail_url
:
884 thumbnail_url
= thumbnail_url
.split('?')[0]
886 'url': thumbnail_url
,
887 'height': int_or_none(thumbnail
.get('height')),
888 'width': int_or_none(thumbnail
.get('width')),
893 def extract_relative_time(relative_time_text
):
895 Extracts a relative time from string and converts to dt object
896 e.g. 'streamed 6 days ago', '5 seconds ago (edited)', 'updated today'
898 mobj
= re
.search(r
'(?P<start>today|yesterday|now)|(?P<time>\d+)\s*(?P<unit>microsecond|second|minute|hour|day|week|month|year)s?\s*ago', relative_time_text
)
900 start
= mobj
.group('start')
902 return datetime_from_str(start
)
904 return datetime_from_str('now-%s%s' % (mobj
.group('time'), mobj
.group('unit')))
908 def _parse_time_text(self
, text
):
911 dt
= self
.extract_relative_time(text
)
913 if isinstance(dt
, datetime
.datetime
):
914 timestamp
= calendar
.timegm(dt
.timetuple())
916 if timestamp
is None:
918 unified_timestamp(text
) or unified_timestamp(
920 (r
'([a-z]+\s*\d{1,2},?\s*20\d{2})', r
'(?:.+|^)(?:live|premieres|ed|ing)(?:\s*(?:on|for))?\s*(.+\d)'),
921 text
.lower(), 'time text', default
=None)))
923 if text
and timestamp
is None and self
._preferred
_lang
in (None, 'en'):
925 f
'Cannot parse localized time text "{text}"', only_once
=True)
928 def _extract_response(self
, item_id
, query
, note
='Downloading API JSON', headers
=None,
929 ytcfg
=None, check_get_keys
=None, ep
='browse', fatal
=True, api_hostname
=None,
930 default_client
='web'):
931 for retry
in self
.RetryManager():
933 response
= self
._call
_api
(
934 ep
=ep
, fatal
=True, headers
=headers
,
935 video_id
=item_id
, query
=query
, note
=note
,
936 context
=self
._extract
_context
(ytcfg
, default_client
),
937 api_key
=self
._extract
_api
_key
(ytcfg
, default_client
),
938 api_hostname
=api_hostname
, default_client
=default_client
)
939 except ExtractorError
as e
:
940 if not isinstance(e
.cause
, network_exceptions
):
941 return self
._error
_or
_warning
(e
, fatal
=fatal
)
942 elif not isinstance(e
.cause
, urllib
.error
.HTTPError
):
946 first_bytes
= e
.cause
.read(512)
947 if not is_html(first_bytes
):
950 self
._webpage
_read
_content
(e
.cause
, None, item_id
, prefix
=first_bytes
) or '{}', item_id
, fatal
=False),
951 lambda x
: x
['error']['message'], str)
953 self
._report
_alerts
([('ERROR', yt_error
)], fatal
=False)
954 # Downloading page may result in intermittent 5xx HTTP error
955 # Sometimes a 404 is also recieved. See: https://github.com/ytdl-org/youtube-dl/issues/28289
956 # We also want to catch all other network exceptions since errors in later pages can be troublesome
957 # See https://github.com/yt-dlp/yt-dlp/issues/507#issuecomment-880188210
958 if e
.cause
.code
not in (403, 429):
961 return self
._error
_or
_warning
(e
, fatal
=fatal
)
964 self
._extract
_and
_report
_alerts
(response
, only_once
=True)
965 except ExtractorError
as e
:
966 # YouTube servers may return errors we want to retry on in a 200 OK response
967 # See: https://github.com/yt-dlp/yt-dlp/issues/839
968 if 'unknown error' in e
.msg
.lower():
971 return self
._error
_or
_warning
(e
, fatal
=fatal
)
972 # Youtube sometimes sends incomplete data
973 # See: https://github.com/ytdl-org/youtube-dl/issues/28194
974 if not traverse_obj(response
, *variadic(check_get_keys
)):
975 retry
.error
= ExtractorError('Incomplete data received', expected
=True)
981 def is_music_url(url
):
982 return re
.match(r
'(https?://)?music\.youtube\.com/', url
) is not None
984 def _extract_video(self
, renderer
):
985 video_id
= renderer
.get('videoId')
987 reel_header_renderer
= traverse_obj(renderer
, (
988 'navigationEndpoint', 'reelWatchEndpoint', 'overlay', 'reelPlayerOverlayRenderer',
989 'reelPlayerHeaderSupportedRenderers', 'reelPlayerHeaderRenderer'))
991 title
= self
._get
_text
(renderer
, 'title', 'headline') or self
._get
_text
(reel_header_renderer
, 'reelTitleText')
992 description
= self
._get
_text
(renderer
, 'descriptionSnippet')
994 duration
= int_or_none(renderer
.get('lengthSeconds'))
996 duration
= parse_duration(self
._get
_text
(
997 renderer
, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
999 # XXX: should write a parser to be more general to support more cases (e.g. shorts in shorts tab)
1000 duration
= parse_duration(self
._search
_regex
(
1001 r
'(?i)(ago)(?!.*\1)\s+(?P<duration>[a-z0-9 ,]+?)(?:\s+[\d,]+\s+views)?(?:\s+-\s+play\s+short)?$',
1002 traverse_obj(renderer
, ('title', 'accessibility', 'accessibilityData', 'label'), default
='', expected_type
=str),
1003 video_id
, default
=None, group
='duration'))
1005 channel_id
= traverse_obj(
1006 renderer
, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'),
1007 expected_type
=str, get_all
=False)
1009 channel_id
= traverse_obj(reel_header_renderer
, ('channelNavigationEndpoint', 'browseEndpoint', 'browseId'))
1011 channel_id
= self
.ucid_or_none(channel_id
)
1013 overlay_style
= traverse_obj(
1014 renderer
, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'),
1015 get_all
=False, expected_type
=str)
1016 badges
= self
._extract
_badges
(renderer
)
1018 navigation_url
= urljoin('https://www.youtube.com/', traverse_obj(
1019 renderer
, ('navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url'),
1020 expected_type
=str)) or ''
1021 url
= f
'https://www.youtube.com/watch?v={video_id}'
1022 if overlay_style
== 'SHORTS' or '/shorts/' in navigation_url
:
1023 url
= f
'https://www.youtube.com/shorts/{video_id}'
1025 time_text
= (self
._get
_text
(renderer
, 'publishedTimeText', 'videoInfo')
1026 or self
._get
_text
(reel_header_renderer
, 'timestampText') or '')
1027 scheduled_timestamp
= str_to_int(traverse_obj(renderer
, ('upcomingEventData', 'startTime'), get_all
=False))
1030 'is_upcoming' if scheduled_timestamp
is not None
1031 else 'was_live' if 'streamed' in time_text
.lower()
1032 else 'is_live' if overlay_style
== 'LIVE' or self
._has
_badge
(badges
, BadgeType
.LIVE_NOW
)
1035 # videoInfo is a string like '50K views • 10 years ago'.
1036 view_count_text
= self
._get
_text
(renderer
, 'viewCountText', 'shortViewCountText', 'videoInfo') or ''
1037 view_count
= (0 if 'no views' in view_count_text
.lower()
1038 else self
._get
_count
({'simpleText': view_count_text}
))
1039 view_count_field
= 'concurrent_view_count' if live_status
in ('is_live', 'is_upcoming') else 'view_count'
1043 'ie_key': YoutubeIE
.ie_key(),
1047 'description': description
,
1048 'duration': duration
,
1049 'channel_id': channel_id
,
1050 'channel': (self
._get
_text
(renderer
, 'ownerText', 'shortBylineText')
1051 or self
._get
_text
(reel_header_renderer
, 'channelTitleText')),
1052 'channel_url': f
'https://www.youtube.com/channel/{channel_id}' if channel_id
else None,
1053 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
1054 'timestamp': (self
._parse
_time
_text
(time_text
)
1055 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
1057 'release_timestamp': scheduled_timestamp
,
1059 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
1060 else self
._availability
(
1061 is_private
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
) or None,
1062 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
1063 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
1064 is_unlisted
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
) or None),
1065 view_count_field
: view_count
,
1066 'live_status': live_status
1070 class YoutubeIE(YoutubeBaseInfoExtractor
):
1072 _VALID_URL
= r
"""(?x)^
1074 (?:https?://|//) # http(s):// or protocol-independent URL
1075 (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
1076 (?:www\.)?deturl\.com/www\.youtube\.com|
1077 (?:www\.)?pwnyoutube\.com|
1078 (?:www\.)?hooktube\.com|
1079 (?:www\.)?yourepeat\.com|
1080 tube\.majestyc\.net|
1082 youtube\.googleapis\.com)/ # the various hostnames, with wildcard subdomains
1083 (?:.*?\#/)? # handle anchor (#/) redirect urls
1084 (?: # the various things that can precede the ID:
1085 (?:(?:v|embed|e|shorts|live)/(?!videoseries|live_stream)) # v/ or embed/ or e/ or shorts/
1086 |(?: # or the v= param in all its forms
1087 (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
1088 (?:\?|\#!?) # the params delimiter ? or # or #!
1089 (?:.*?[&;])?? # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&v=V36LpHqtcDY)
1094 youtu\.be| # just youtu.be/xxxx
1095 vid\.plus| # or vid.plus/xxxx
1096 zwearz\.com/watch| # or zwearz.com/watch/xxxx
1099 |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
1101 )? # all until now is optional -> you can pass the naked ID
1102 (?P<id>[0-9A-Za-z_-]{11}) # here is it! the YouTube video ID
1103 (?(1).+)? # if we found the ID, everything can follow
1105 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
1110 <(?:[0-9A-Za-z-]+?)?iframe[^>]+?src=|
1118 (?P
<url
>(?
:https?
:)?
//(?
:www\
.)?
youtube(?
:-nocookie
)?\
.com
/
1119 (?
:embed|v|p
)/[0-9A
-Za
-z_
-]{11}
.*?
)
1121 # https://wordpress.org/plugins/lazy-load-for-videos/
1123 <a\s
[^
>]*\bhref
="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"
1124 \s
[^
>]*\bclass
="[^"]*\blazy
-load
-youtube
''',
1126 _RETURN_TYPE = 'video' # XXX: How to handle multifeed?
1129 r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
1130 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$',
1131 r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
1134 '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1135 '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1136 '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
1137 '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
1138 '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
1139 '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1140 '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1141 '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1142 # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
1143 '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
1144 '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1145 '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1146 '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1147 '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1148 '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1149 '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1150 '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1151 '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1155 '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1156 '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1157 '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1158 '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1159 '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
1160 '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1161 '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1163 # Apple HTTP Live Streaming
1164 '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1165 '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1166 '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1167 '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1168 '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1169 '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1170 '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1171 '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
1174 '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
1175 '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
1176 '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1177 '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
1178 '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
1179 '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'}, # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
1180 '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
1181 '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1182 '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
1183 '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1184 '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1185 '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
1188 '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
1189 '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
1190 '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
1191 '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1192 '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1193 '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
1194 '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
1197 '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1198 '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1199 '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1200 '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1201 '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1202 '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1203 '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
1204 '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1205 '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1206 '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1207 '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1208 '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1209 '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1210 '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1211 '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1212 # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
1213 '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1214 '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1215 '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1216 '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1217 '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1218 '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1221 '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
1222 '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
1224 # Dash webm audio with opus inside
1225 '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
1226 '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
1227 '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
1230 '_rtmp': {'protocol': 'rtmp'},
1232 # av01 video only formats sometimes served with "unknown" codecs
1233 '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1234 '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1235 '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1236 '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1237 '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1238 '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1239 '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1240 '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1242 _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1249 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1251 'id': 'BaW_jenozKc',
1253 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1254 'channel': 'Philipp Hagemeister',
1255 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1256 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1257 'upload_date': '20121002',
1258 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1259 'categories': ['Science & Technology'],
1260 'tags': ['youtube-dl'],
1264 'availability': 'public',
1265 'playable_in_embed': True,
1266 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1267 'live_status': 'not_live',
1271 'comment_count': int,
1272 'channel_follower_count': int,
1273 'uploader': 'Philipp Hagemeister',
1274 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1275 'uploader_id': '@PhilippHagemeister',
1279 'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1280 'note': 'Embed-only video (#1746)',
1282 'id': 'yZIXLfi8CZQ',
1284 'upload_date': '20120608',
1285 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1286 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1289 'skip': 'Private video',
1292 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1293 'note': 'Use the first video ID in the URL',
1295 'id': 'BaW_jenozKc',
1297 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1298 'channel': 'Philipp Hagemeister',
1299 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1300 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1301 'upload_date': '20121002',
1302 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1303 'categories': ['Science & Technology'],
1304 'tags': ['youtube-dl'],
1308 'availability': 'public',
1309 'playable_in_embed': True,
1310 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1311 'live_status': 'not_live',
1313 'comment_count': int,
1314 'channel_follower_count': int,
1315 'uploader': 'Philipp Hagemeister',
1316 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1317 'uploader_id': '@PhilippHagemeister',
1320 'skip_download': True,
1324 'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1325 'note': '256k DASH audio (format 141) via DASH manifest',
1327 'id': 'a9LDPn-MO4I',
1329 'upload_date': '20121002',
1331 'title': 'UHDTV TEST 8K VIDEO.mp4'
1334 'youtube_include_dash_manifest': True,
1337 'skip': 'format 141 not served anymore',
1339 # DASH manifest with encrypted signature
1341 'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1343 'id': 'IB3lcPjvWLA',
1345 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1346 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1348 'upload_date': '20131011',
1351 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1352 'playable_in_embed': True,
1353 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1355 'track': 'The Spark',
1356 'live_status': 'not_live',
1357 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1358 'channel': 'Afrojack',
1360 'availability': 'public',
1361 'categories': ['Music'],
1363 'alt_title': 'The Spark',
1364 'channel_follower_count': int,
1365 'uploader': 'Afrojack',
1366 'uploader_url': 'https://www.youtube.com/@Afrojack',
1367 'uploader_id': '@Afrojack',
1370 'youtube_include_dash_manifest': True,
1371 'format': '141/bestaudio[ext=m4a]',
1374 # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1376 'note': 'Embed allowed age-gate video',
1377 'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1379 'id': 'HtVdAasjOgU',
1381 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1382 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1384 'upload_date': '20140605',
1386 'categories': ['Gaming'],
1387 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1388 'availability': 'needs_auth',
1389 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1391 'channel': 'The Witcher',
1392 'live_status': 'not_live',
1394 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1395 'playable_in_embed': True,
1397 'channel_follower_count': int,
1398 'uploader': 'The Witcher',
1399 'uploader_url': 'https://www.youtube.com/@thewitcher',
1400 'uploader_id': '@thewitcher',
1404 'note': 'Age-gate video with embed allowed in public site',
1405 'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1407 'id': 'HsUATh_Nc2U',
1409 'title': 'Godzilla 2 (Official Video)',
1410 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1411 'upload_date': '20200408',
1413 'availability': 'needs_auth',
1414 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1415 'channel': 'FlyingKitty',
1416 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1418 'categories': ['Entertainment'],
1419 'live_status': 'not_live',
1420 'tags': ['Flyingkitty', 'godzilla 2'],
1421 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1424 'playable_in_embed': True,
1425 'channel_follower_count': int,
1426 'uploader': 'FlyingKitty',
1427 'uploader_url': 'https://www.youtube.com/@FlyingKitty900',
1428 'uploader_id': '@FlyingKitty900',
1432 'note': 'Age-gate video embedable only with clientScreen=EMBED',
1433 'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1435 'id': 'Tq92D6wQ1mg',
1436 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1438 'upload_date': '20191228',
1439 'description': 'md5:17eccca93a786d51bc67646756894066',
1442 'availability': 'needs_auth',
1443 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1445 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1446 'channel': 'Projekt Melody',
1447 'live_status': 'not_live',
1448 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1449 'playable_in_embed': True,
1450 'categories': ['Entertainment'],
1452 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1453 'comment_count': int,
1454 'channel_follower_count': int,
1455 'uploader': 'Projekt Melody',
1456 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
1457 'uploader_id': '@ProjektMelody',
1461 'note': 'Non-Agegated non-embeddable video',
1462 'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1464 'id': 'MeJVWBSsPAY',
1466 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1467 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1468 'upload_date': '20130730',
1469 'track': 'Such mich find mich',
1471 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1473 'playable_in_embed': False,
1474 'creator': 'OOMPH!',
1475 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1477 'alt_title': 'Such mich find mich',
1479 'channel': 'Herr Lurik',
1480 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1481 'categories': ['Music'],
1482 'availability': 'public',
1483 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1484 'live_status': 'not_live',
1486 'channel_follower_count': int,
1487 'uploader': 'Herr Lurik',
1488 'uploader_url': 'https://www.youtube.com/@HerrLurik',
1489 'uploader_id': '@HerrLurik',
1493 'note': 'Non-bypassable age-gated video',
1494 'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1495 'only_matching': True,
1497 # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1498 # YouTube Red ad is not captured for creator
1500 'url': '__2ABJjxzNo',
1502 'id': '__2ABJjxzNo',
1505 'upload_date': '20100430',
1506 'creator': 'deadmau5',
1507 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1508 'title': 'Deadmau5 - Some Chords (HD)',
1509 'alt_title': 'Some Chords',
1510 'availability': 'public',
1512 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1514 'live_status': 'not_live',
1515 'channel': 'deadmau5',
1516 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1518 'track': 'Some Chords',
1519 'artist': 'deadmau5',
1520 'playable_in_embed': True,
1522 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1523 'categories': ['Music'],
1524 'album': 'Some Chords',
1525 'channel_follower_count': int,
1526 'uploader': 'deadmau5',
1527 'uploader_url': 'https://www.youtube.com/@deadmau5',
1528 'uploader_id': '@deadmau5',
1530 'expected_warnings': [
1531 'DASH manifest missing',
1534 # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1536 'url': 'lqQg6PlCWgI',
1538 'id': 'lqQg6PlCWgI',
1541 'upload_date': '20150827',
1542 'description': 'md5:04bbbf3ccceb6795947572ca36f45904',
1543 'title': 'Hockey - Women - GER-AUS - London 2012 Olympic Games',
1545 'release_timestamp': 1343767800,
1546 'playable_in_embed': True,
1547 'categories': ['Sports'],
1548 'release_date': '20120731',
1549 'channel': 'Olympics',
1550 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1551 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1552 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1554 'availability': 'public',
1555 'live_status': 'was_live',
1557 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1558 'channel_follower_count': int,
1559 'uploader': 'Olympics',
1560 'uploader_url': 'https://www.youtube.com/@Olympics',
1561 'uploader_id': '@Olympics',
1564 'skip_download': 'requires avconv',
1569 'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1571 'id': '_b-2C3KPAM0',
1573 'stretched_ratio': 16 / 9.,
1575 'upload_date': '20110310',
1576 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1577 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1578 'playable_in_embed': True,
1582 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1583 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1584 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1586 'categories': ['People & Blogs'],
1588 'live_status': 'not_live',
1589 'availability': 'unlisted',
1590 'comment_count': int,
1591 'channel_follower_count': int,
1593 'uploader_url': 'https://www.youtube.com/@AllenMeow',
1594 'uploader_id': '@AllenMeow',
1597 # url_encoded_fmt_stream_map is empty string
1599 'url': 'qEJwOuvDf7I',
1601 'id': 'qEJwOuvDf7I',
1603 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1605 'upload_date': '20150404',
1608 'skip_download': 'requires avconv',
1610 'skip': 'This live event has ended.',
1612 # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1614 'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1616 'id': 'FIl7x6_3R5Y',
1618 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1619 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1621 'upload_date': '20150625',
1622 'formats': 'mincount:31',
1624 'skip': 'not actual anymore',
1626 # DASH manifest with segment_list
1628 'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1629 'md5': '8ce563a1d667b599d21064e982ab9e31',
1631 'id': 'CsmdDsKjzN8',
1633 'upload_date': '20150501', # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1634 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1635 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1638 'youtube_include_dash_manifest': True,
1639 'format': '135', # bestvideo
1641 'skip': 'This live event has ended.',
1644 # Multifeed videos (multiple cameras), URL can be of any Camera
1645 # TODO: fix multifeed titles
1646 'url': 'https://www.youtube.com/watch?v=zaPI8MvL8pg',
1648 'id': 'zaPI8MvL8pg',
1649 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04',
1650 'description': 'md5:563ccbc698b39298481ca3c571169519',
1654 'id': 'j5yGuxZ8lLU',
1656 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Chris)',
1657 'description': 'md5:563ccbc698b39298481ca3c571169519',
1659 'channel_follower_count': int,
1660 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1661 'availability': 'public',
1662 'playable_in_embed': True,
1663 'upload_date': '20131105',
1664 'categories': ['Gaming'],
1665 'live_status': 'was_live',
1667 'release_timestamp': 1383701910,
1668 'thumbnail': 'https://i.ytimg.com/vi/j5yGuxZ8lLU/maxresdefault.jpg',
1669 'comment_count': int,
1672 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1673 'channel': 'WiiLikeToPlay',
1675 'release_date': '20131106',
1676 'uploader': 'WiiLikeToPlay',
1677 'uploader_id': '@WLTP',
1678 'uploader_url': 'https://www.youtube.com/@WLTP',
1682 'id': 'zaPI8MvL8pg',
1684 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Tyson)',
1685 'availability': 'public',
1686 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1687 'channel': 'WiiLikeToPlay',
1688 'channel_follower_count': int,
1689 'description': 'md5:563ccbc698b39298481ca3c571169519',
1694 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1695 'release_timestamp': 1383701915,
1696 'comment_count': int,
1697 'upload_date': '20131105',
1698 'thumbnail': 'https://i.ytimg.com/vi/zaPI8MvL8pg/maxresdefault.jpg',
1699 'release_date': '20131106',
1700 'playable_in_embed': True,
1701 'live_status': 'was_live',
1702 'categories': ['Gaming'],
1704 'uploader': 'WiiLikeToPlay',
1705 'uploader_id': '@WLTP',
1706 'uploader_url': 'https://www.youtube.com/@WLTP',
1710 'id': 'R7r3vfO7Hao',
1712 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Spencer)',
1713 'thumbnail': 'https://i.ytimg.com/vi/R7r3vfO7Hao/maxresdefault.jpg',
1714 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1716 'availability': 'public',
1717 'playable_in_embed': True,
1718 'upload_date': '20131105',
1719 'description': 'md5:563ccbc698b39298481ca3c571169519',
1720 'channel_follower_count': int,
1722 'release_date': '20131106',
1723 'comment_count': int,
1724 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1725 'channel': 'WiiLikeToPlay',
1726 'categories': ['Gaming'],
1727 'release_timestamp': 1383701914,
1728 'live_status': 'was_live',
1732 'uploader': 'WiiLikeToPlay',
1733 'uploader_id': '@WLTP',
1734 'uploader_url': 'https://www.youtube.com/@WLTP',
1737 'params': {'skip_download': True},
1740 # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1741 'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1743 'id': 'gVfLd0zydlo',
1744 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1746 'playlist_count': 2,
1747 'skip': 'Not multifeed anymore',
1750 'url': 'https://vid.plus/FlRa-iH7PGw',
1751 'only_matching': True,
1754 'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1755 'only_matching': True,
1758 # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1759 # Also tests cut-off URL expansion in video description (see
1760 # https://github.com/ytdl-org/youtube-dl/issues/1892,
1761 # https://github.com/ytdl-org/youtube-dl/issues/8164)
1762 'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1764 'id': 'lsguqyKfVQg',
1766 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1767 'alt_title': 'Dark Walk',
1768 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1770 'upload_date': '20151119',
1771 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1772 'track': 'Dark Walk',
1773 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1774 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1775 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1776 'categories': ['Film & Animation'],
1778 'live_status': 'not_live',
1779 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1780 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1782 'availability': 'public',
1783 'channel': 'IronSoulElf',
1784 'playable_in_embed': True,
1787 'channel_follower_count': int
1790 'skip_download': True,
1794 # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1795 'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1796 'only_matching': True,
1799 # Video with yt:stretch=17:0
1800 'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1802 'id': 'Q39EVAstoRM',
1804 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1805 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1806 'upload_date': '20151107',
1809 'skip_download': True,
1811 'skip': 'This video does not exist.',
1814 # Video with incomplete 'yt:stretch=16:'
1815 'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1816 'only_matching': True,
1819 # Video licensed under Creative Commons
1820 'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1822 'id': 'M4gD1WSo5mA',
1824 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1825 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1827 'upload_date': '20150128',
1828 'license': 'Creative Commons Attribution license (reuse allowed)',
1829 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1830 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1833 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1834 'channel': 'The Berkman Klein Center for Internet & Society',
1835 'availability': 'public',
1837 'categories': ['Education'],
1838 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1839 'live_status': 'not_live',
1840 'playable_in_embed': True,
1841 'channel_follower_count': int,
1843 'uploader': 'The Berkman Klein Center for Internet & Society',
1844 'uploader_id': '@BKCHarvard',
1845 'uploader_url': 'https://www.youtube.com/@BKCHarvard',
1848 'skip_download': True,
1852 'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1854 'id': 'eQcmzGIKrzg',
1856 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1857 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1859 'upload_date': '20151120',
1860 'license': 'Creative Commons Attribution license (reuse allowed)',
1861 'playable_in_embed': True,
1864 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1866 'availability': 'public',
1867 'categories': ['News & Politics'],
1868 'channel': 'Bernie Sanders',
1869 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1871 'live_status': 'not_live',
1872 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1873 'comment_count': int,
1874 'channel_follower_count': int,
1876 'uploader': 'Bernie Sanders',
1877 'uploader_url': 'https://www.youtube.com/@BernieSanders',
1878 'uploader_id': '@BernieSanders',
1881 'skip_download': True,
1885 'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;v=V36LpHqtcDY',
1886 'only_matching': True,
1889 # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1890 'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1891 'only_matching': True,
1894 # Rental video preview
1895 'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1897 'id': 'uGpuVWrhIzE',
1899 'title': 'Piku - Trailer',
1900 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1901 'upload_date': '20150811',
1902 'license': 'Standard YouTube License',
1905 'skip_download': True,
1907 'skip': 'This video is not available.',
1910 # YouTube Red video with episode data
1911 'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1913 'id': 'iqKdEhx-dD4',
1915 'title': 'Isolation - Mind Field (Ep 1)',
1916 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1918 'upload_date': '20170118',
1919 'series': 'Mind Field',
1921 'episode_number': 1,
1922 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1925 'availability': 'public',
1927 'channel': 'Vsauce',
1928 'episode': 'Episode 1',
1929 'categories': ['Entertainment'],
1930 'season': 'Season 1',
1931 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
1932 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
1934 'playable_in_embed': True,
1935 'live_status': 'not_live',
1936 'channel_follower_count': int,
1937 'uploader': 'Vsauce',
1938 'uploader_url': 'https://www.youtube.com/@Vsauce',
1939 'uploader_id': '@Vsauce',
1942 'skip_download': True,
1944 'expected_warnings': [
1945 'Skipping DASH manifest',
1949 # The following content has been identified by the YouTube community
1950 # as inappropriate or offensive to some audiences.
1951 'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
1953 'id': '6SJNVb0GnPI',
1955 'title': 'Race Differences in Intelligence',
1956 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
1958 'upload_date': '20140124',
1961 'skip_download': True,
1963 'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
1967 'url': '1t24XAntNCY',
1968 'only_matching': True,
1971 # geo restricted to JP
1972 'url': 'sJL6WA-aGkQ',
1973 'only_matching': True,
1976 'url': 'https://invidio.us/watch?v=BaW_jenozKc',
1977 'only_matching': True,
1980 'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
1981 'only_matching': True,
1984 # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
1985 'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
1986 'only_matching': True,
1990 'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
1991 'only_matching': True,
1994 # Video with unsupported adaptive stream type formats
1995 'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
1997 'id': 'Z4Vy8R84T1U',
1999 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
2000 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
2002 'upload_date': '20130923',
2003 'formats': 'maxcount:10',
2006 'skip_download': True,
2007 'youtube_include_dash_manifest': False,
2009 'skip': 'not actual anymore',
2012 # Youtube Music Auto-generated description
2013 # TODO: fix metadata extraction
2014 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2016 'id': 'MgNrAu2pzNs',
2018 'title': 'Voyeur Girl',
2019 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
2020 'upload_date': '20190312',
2021 'artist': 'Stephen',
2022 'track': 'Voyeur Girl',
2023 'album': 'it\'s too much love to know my dear',
2024 'release_date': '20190313',
2025 'release_year': 2019,
2026 'alt_title': 'Voyeur Girl',
2028 'playable_in_embed': True,
2030 'categories': ['Music'],
2031 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
2032 'channel': 'Stephen', # TODO: should be "Stephen - Topic"
2033 'uploader': 'Stephen',
2034 'availability': 'public',
2035 'creator': 'Stephen',
2037 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
2039 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
2041 'live_status': 'not_live',
2042 'channel_follower_count': int
2045 'skip_download': True,
2049 'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
2050 'only_matching': True,
2053 # invalid -> valid video id redirection
2054 'url': 'DJztXj2GPfl',
2056 'id': 'DJztXj2GPfk',
2058 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
2059 'description': 'md5:bf577a41da97918e94fa9798d9228825',
2060 'upload_date': '20090125',
2061 'artist': 'Panjabi MC',
2062 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
2063 'album': 'Beware of the Boys (Mundian To Bach Ke)',
2066 'skip_download': True,
2068 'skip': 'Video unavailable',
2071 # empty description results in an empty string
2072 'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
2074 'id': 'x41yOUIvK2k',
2076 'title': 'IMG 3456',
2078 'upload_date': '20170613',
2080 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
2082 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
2084 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
2085 'availability': 'public',
2087 'categories': ['Pets & Animals'],
2089 'playable_in_embed': True,
2090 'live_status': 'not_live',
2091 'channel': 'l\'Or Vert asbl',
2092 'channel_follower_count': int,
2093 'uploader': 'l\'Or Vert asbl',
2094 'uploader_url': 'https://www.youtube.com/@ElevageOrVert',
2095 'uploader_id': '@ElevageOrVert',
2098 'skip_download': True,
2102 # with '};' inside yt initial data (see [1])
2103 # see [2] for an example with '};' inside ytInitialPlayerResponse
2104 # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
2105 # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
2106 'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
2108 'id': 'CHqg6qOn4no',
2110 'title': 'Part 77 Sort a list of simple types in c#',
2111 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
2112 'upload_date': '20130831',
2113 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
2115 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
2116 'live_status': 'not_live',
2117 'categories': ['Education'],
2118 'availability': 'public',
2119 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
2121 'playable_in_embed': True,
2125 'channel': 'kudvenkat',
2126 'comment_count': int,
2127 'channel_follower_count': int,
2129 'uploader': 'kudvenkat',
2130 'uploader_url': 'https://www.youtube.com/@Csharp-video-tutorialsBlogspot',
2131 'uploader_id': '@Csharp-video-tutorialsBlogspot',
2134 'skip_download': True,
2138 # another example of '};' in ytInitialData
2139 'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
2140 'only_matching': True,
2143 'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
2144 'only_matching': True,
2147 # https://github.com/ytdl-org/youtube-dl/pull/28094
2148 'url': 'OtqTfy26tG0',
2150 'id': 'OtqTfy26tG0',
2152 'title': 'Burn Out',
2153 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
2154 'upload_date': '20141120',
2155 'artist': 'The Cinematic Orchestra',
2156 'track': 'Burn Out',
2157 'album': 'Every Day',
2159 'live_status': 'not_live',
2160 'alt_title': 'Burn Out',
2164 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2165 'creator': 'The Cinematic Orchestra',
2166 'channel': 'The Cinematic Orchestra',
2167 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
2168 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2169 'availability': 'public',
2170 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
2171 'categories': ['Music'],
2172 'playable_in_embed': True,
2173 'channel_follower_count': int,
2174 'uploader': 'The Cinematic Orchestra',
2175 'comment_count': int,
2178 'skip_download': True,
2182 # controversial video, only works with bpctr when authenticated with cookies
2183 'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
2184 'only_matching': True,
2187 # controversial video, requires bpctr/contentCheckOk
2188 'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
2190 'id': 'SZJvDhaSDnc',
2192 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
2193 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
2194 'upload_date': '20140716',
2195 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
2197 'categories': ['News & Politics'],
2199 'channel': 'CBS Mornings',
2200 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
2201 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
2203 'availability': 'needs_auth',
2204 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
2206 'live_status': 'not_live',
2207 'playable_in_embed': True,
2208 'channel_follower_count': int,
2209 'uploader': 'CBS Mornings',
2210 'uploader_url': 'https://www.youtube.com/@CBSMornings',
2211 'uploader_id': '@CBSMornings',
2215 # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
2216 'url': 'cBvYw8_A0vQ',
2218 'id': 'cBvYw8_A0vQ',
2220 'title': '4K Ueno Okachimachi Street Scenes 上野御徒町歩き',
2221 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
2222 'upload_date': '20201120',
2224 'categories': ['Travel & Events'],
2225 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2227 'channel': 'Walk around Japan',
2228 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
2229 'thumbnail': 'https://i.ytimg.com/vi_webp/cBvYw8_A0vQ/hqdefault.webp',
2231 'availability': 'public',
2232 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2233 'live_status': 'not_live',
2234 'playable_in_embed': True,
2235 'channel_follower_count': int,
2236 'uploader': 'Walk around Japan',
2237 'uploader_url': 'https://www.youtube.com/@walkaroundjapan7124',
2238 'uploader_id': '@walkaroundjapan7124',
2241 'skip_download': True,
2244 # Has multiple audio streams
2245 'url': 'WaOKSUlf4TM',
2246 'only_matching': True
2248 # Requires Premium: has format 141 when requested using YTM url
2249 'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2250 'only_matching': True
2252 # multiple subtitles with same lang_code
2253 'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2254 'only_matching': True,
2256 # Force use android client fallback
2257 'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2259 'id': 'YOelRv7fMxY',
2260 'title': 'DIGGING A SECRET TUNNEL Part 1',
2262 'upload_date': '20210624',
2263 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2264 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2265 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2267 'categories': ['Entertainment'],
2269 'channel': 'colinfurze',
2270 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2271 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2273 'availability': 'public',
2275 'live_status': 'not_live',
2276 'playable_in_embed': True,
2277 'channel_follower_count': int,
2279 'uploader': 'colinfurze',
2280 'uploader_url': 'https://www.youtube.com/@colinfurze',
2281 'uploader_id': '@colinfurze',
2284 'format': '17', # 3gp format available on android
2285 'extractor_args': {'youtube': {'player_client': ['android']}},
2289 # Skip download of additional client configs (remix client config in this case)
2290 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2291 'only_matching': True,
2293 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2297 'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2298 'only_matching': True,
2300 'note': 'Storyboards',
2301 'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2303 'id': '5KLPxDtMqe8',
2306 'title': 'Your Brain is Plastic',
2307 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2308 'upload_date': '20140324',
2310 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2311 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2313 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2314 'playable_in_embed': True,
2316 'availability': 'public',
2317 'channel': 'SciShow',
2318 'live_status': 'not_live',
2320 'categories': ['Education'],
2322 'channel_follower_count': int,
2324 'uploader': 'SciShow',
2325 'uploader_url': 'https://www.youtube.com/@SciShow',
2326 'uploader_id': '@SciShow',
2327 }, 'params': {'format': 'mhtml', 'skip_download': True}
2329 # Ensure video upload_date is in UTC timezone (video was uploaded 1641170939)
2330 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2332 'id': '2NUZ8W2llS4',
2334 'title': 'The NP that test your phone performance 🙂',
2335 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2336 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2337 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2341 'categories': ['Gaming'],
2343 'playable_in_embed': True,
2344 'live_status': 'not_live',
2345 'upload_date': '20220103',
2347 'availability': 'public',
2348 'channel': 'Leon Nguyen',
2349 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2350 'comment_count': int,
2351 'channel_follower_count': int,
2352 'uploader': 'Leon Nguyen',
2353 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2354 'uploader_id': '@LeonNguyen',
2357 # Same video as above, but with --compat-opt no-youtube-prefer-utc-upload-date
2358 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2360 'id': '2NUZ8W2llS4',
2362 'title': 'The NP that test your phone performance 🙂',
2363 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2364 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2365 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2369 'categories': ['Gaming'],
2371 'playable_in_embed': True,
2372 'live_status': 'not_live',
2373 'upload_date': '20220102',
2375 'availability': 'public',
2376 'channel': 'Leon Nguyen',
2377 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2378 'comment_count': int,
2379 'channel_follower_count': int,
2380 'uploader': 'Leon Nguyen',
2381 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2382 'uploader_id': '@LeonNguyen',
2384 'params': {'compat_opts': ['no-youtube-prefer-utc-upload-date']}
2386 # date text is premiered video, ensure upload date in UTC (published 1641172509)
2387 'url': 'https://www.youtube.com/watch?v=mzZzzBU6lrM',
2389 'id': 'mzZzzBU6lrM',
2391 'title': 'I Met GeorgeNotFound In Real Life...',
2392 'description': 'md5:978296ec9783a031738b684d4ebf302d',
2393 'channel_id': 'UC_8NknAFiyhOUaZqHR3lq3Q',
2394 'channel_url': 'https://www.youtube.com/channel/UC_8NknAFiyhOUaZqHR3lq3Q',
2398 'categories': ['Entertainment'],
2400 'playable_in_embed': True,
2401 'live_status': 'not_live',
2402 'release_timestamp': 1641172509,
2403 'release_date': '20220103',
2404 'upload_date': '20220103',
2406 'availability': 'public',
2407 'channel': 'Quackity',
2408 'thumbnail': 'https://i.ytimg.com/vi/mzZzzBU6lrM/maxresdefault.jpg',
2409 'channel_follower_count': int,
2410 'uploader': 'Quackity',
2411 'uploader_id': '@Quackity',
2412 'uploader_url': 'https://www.youtube.com/@Quackity',
2415 { # continuous livestream. Microformat upload date should be preferred.
2416 # Upload date was 2021-06-19 (not UTC), while stream start is 2021-11-27
2417 'url': 'https://www.youtube.com/watch?v=kgx4WGK0oNU',
2419 'id': 'kgx4WGK0oNU',
2420 'title': r're:jazz\/lofi hip hop radio🌱chill beats to relax\/study to \[LIVE 24\/7\] \d{4}-\d{2}-\d{2} \d{2}:\d{2}',
2422 'channel_id': 'UC84whx2xxsiA1gXHXXqKGOA',
2423 'availability': 'public',
2425 'release_timestamp': 1637975704,
2426 'upload_date': '20210619',
2427 'channel_url': 'https://www.youtube.com/channel/UC84whx2xxsiA1gXHXXqKGOA',
2428 'live_status': 'is_live',
2429 'thumbnail': 'https://i.ytimg.com/vi/kgx4WGK0oNU/maxresdefault.jpg',
2430 'channel': 'Abao in Tokyo',
2431 'channel_follower_count': int,
2432 'release_date': '20211127',
2434 'categories': ['People & Blogs'],
2437 'playable_in_embed': True,
2438 'description': 'md5:2ef1d002cad520f65825346e2084e49d',
2439 'concurrent_view_count': int,
2440 'uploader': 'Abao in Tokyo',
2441 'uploader_url': 'https://www.youtube.com/@abaointokyo',
2442 'uploader_id': '@abaointokyo',
2444 'params': {'skip_download': True}
2446 # Story. Requires specific player params to work.
2447 'url': 'https://www.youtube.com/watch?v=vv8qTUWmulI',
2449 'id': 'vv8qTUWmulI',
2451 'availability': 'unlisted',
2453 'channel_id': 'UCzIZ8HrzDgc-pNQDUG6avBA',
2454 'upload_date': '20220526',
2455 'categories': ['Education'],
2457 'channel': 'IT\'S HISTORY',
2460 'playable_in_embed': True,
2462 'live_status': 'not_live',
2464 'thumbnail': 'https://i.ytimg.com/vi_webp/vv8qTUWmulI/maxresdefault.webp',
2465 'channel_url': 'https://www.youtube.com/channel/UCzIZ8HrzDgc-pNQDUG6avBA',
2467 'skip': 'stories get removed after some period of time',
2469 'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2471 'id': 'tjjjtzRLHvA',
2473 'title': 'ハッシュタグ無し };if window.ytcsi',
2474 'upload_date': '20220323',
2476 'availability': 'unlisted',
2477 'channel': 'Lesmiscore',
2478 'thumbnail': r're:^https?://.*\.jpg',
2480 'categories': ['Music'],
2483 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2484 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2485 'live_status': 'not_live',
2486 'playable_in_embed': True,
2487 'channel_follower_count': int,
2490 'uploader_id': '@lesmiscore',
2491 'uploader': 'Lesmiscore',
2492 'uploader_url': 'https://www.youtube.com/@lesmiscore',
2495 # Prefer primary title+description language metadata by default
2496 # Do not prefer translated description if primary is empty
2497 'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2499 'id': 'el3E4MbxRqQ',
2501 'title': 'dlp test video 2 - primary sv no desc',
2503 'channel': 'cole-dlp-test-acc',
2506 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2508 'playable_in_embed': True,
2509 'availability': 'unlisted',
2510 'thumbnail': r're:^https?://.*\.jpg',
2513 'live_status': 'not_live',
2514 'upload_date': '20220908',
2515 'categories': ['People & Blogs'],
2516 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2517 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2518 'uploader_id': '@coletdjnz',
2519 'uploader': 'cole-dlp-test-acc',
2521 'params': {'skip_download': True}
2523 # Extractor argument: prefer translated title+description
2524 'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2526 'id': 'gHKT4uU8Zng',
2528 'channel': 'cole-dlp-test-acc',
2531 'live_status': 'not_live',
2532 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2533 'upload_date': '20220728',
2535 'categories': ['People & Blogs'],
2536 'thumbnail': r're:^https?://.*\.jpg',
2537 'title': 'dlp test video title translated (fr)',
2538 'availability': 'public',
2540 'description': 'dlp test video description translated (fr)',
2541 'playable_in_embed': True,
2542 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2543 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2544 'uploader_id': '@coletdjnz',
2545 'uploader': 'cole-dlp-test-acc',
2547 'params': {'skip_download': True, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2548 'expected_warnings': [r'Preferring "fr" translated fields'],
2550 'note': '6 channel audio',
2551 'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2552 'only_matching': True,
2554 'note': 'Multiple HLS formats with same itag',
2555 'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2557 'id': 'kX3nB4PpJko',
2559 'categories': ['Entertainment'],
2560 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2561 'live_status': 'not_live',
2563 'channel_follower_count': int,
2564 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2565 'title': 'Last To Take Hand Off Jet, Keeps It!',
2566 'channel': 'MrBeast',
2567 'playable_in_embed': True,
2569 'upload_date': '20221112',
2570 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2572 'availability': 'public',
2573 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2576 'uploader': 'MrBeast',
2577 'uploader_url': 'https://www.youtube.com/@MrBeast',
2578 'uploader_id': '@MrBeast',
2580 'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2582 'note': 'Audio formats with Dynamic Range Compression',
2583 'url': 'https://www.youtube.com/watch?v=Tq92D6wQ1mg',
2585 'id': 'Tq92D6wQ1mg',
2587 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
2588 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
2589 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
2590 'channel_follower_count': int,
2591 'description': 'md5:17eccca93a786d51bc67646756894066',
2592 'upload_date': '20191228',
2593 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
2594 'playable_in_embed': True,
2596 'categories': ['Entertainment'],
2597 'thumbnail': 'https://i.ytimg.com/vi/Tq92D6wQ1mg/sddefault.jpg',
2599 'channel': 'Projekt Melody',
2601 'availability': 'needs_auth',
2602 'comment_count': int,
2603 'live_status': 'not_live',
2605 'uploader': 'Projekt Melody',
2606 'uploader_id': '@ProjektMelody',
2607 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
2609 'params': {'extractor_args': {'youtube': {'player_client': ['tv_embedded']}}, 'format': '251-drc'},
2612 'url': 'https://www.youtube.com/live/qVv6vCqciTM',
2614 'id': 'qVv6vCqciTM',
2617 'comment_count': int,
2618 'chapters': 'count:13',
2619 'upload_date': '20221223',
2620 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
2621 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
2623 'release_date': '20221223',
2624 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
2625 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
2627 'playable_in_embed': True,
2629 'availability': 'public',
2630 'channel_follower_count': int,
2631 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
2632 'categories': ['Entertainment'],
2633 'live_status': 'was_live',
2634 'release_timestamp': 1671793345,
2635 'channel': 'さなちゃんねる',
2636 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
2637 'uploader': 'さなちゃんねる',
2638 'uploader_url': 'https://www.youtube.com/@sana_natori',
2639 'uploader_id': '@sana_natori',
2643 # Fallbacks when webpage and web client is unavailable
2644 'url': 'https://www.youtube.com/watch?v=wSSmNUl9Snw',
2646 'id': 'wSSmNUl9Snw',
2648 # 'categories': ['Science & Technology'],
2650 'chapters': 'count:2',
2651 'channel': 'Scott Manley',
2654 # 'availability': 'public',
2655 'channel_follower_count': int,
2656 'live_status': 'not_live',
2657 'upload_date': '20170831',
2660 'uploader_url': 'https://www.youtube.com/@scottmanley',
2661 'description': 'md5:f4bed7b200404b72a394c2f97b782c02',
2662 'uploader': 'Scott Manley',
2663 'uploader_id': '@scottmanley',
2664 'title': 'The Computer Hack That Saved Apollo 14',
2665 'channel_id': 'UCxzC4EngIsMrPmbm6Nxvb-A',
2666 'thumbnail': r're:^https?://.*\.webp',
2667 'channel_url': 'https://www.youtube.com/channel/UCxzC4EngIsMrPmbm6Nxvb-A',
2668 'playable_in_embed': True,
2671 'extractor_args': {'youtube': {'player_client': ['android'], 'player_skip': ['webpage']}},
2677 # YouTube <object> embed
2679 'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2680 'md5': '873c81d308b979f0e23ee7e620b312a3',
2682 'id': 'msN87y-iEx0',
2684 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2685 'upload_date': '20080526',
2686 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2688 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2689 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2690 'playable_in_embed': True,
2691 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2693 'comment_count': int,
2694 'channel': 'Christopher Sykes',
2695 'live_status': 'not_live',
2696 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2697 'availability': 'public',
2700 'categories': ['Science & Technology'],
2701 'channel_follower_count': int,
2702 'uploader': 'Christopher Sykes',
2703 'uploader_url': 'https://www.youtube.com/@ChristopherSykesDocumentaries',
2704 'uploader_id': '@ChristopherSykesDocumentaries',
2707 'skip_download': True,
2713 def suitable(cls, url):
2714 from ..utils import parse_qs
2717 if qs.get('list', [None])[0]:
2719 return super().suitable(url)
2721 def __init__(self, *args, **kwargs):
2722 super().__init__(*args, **kwargs)
2723 self._code_cache = {}
2724 self._player_cache = {}
2726 def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2727 lock = threading.Lock()
2728 start_time = time.time()
2729 formats = [f for f in formats if f.get('is_from_start')]
2731 def refetch_manifest(format_id, delay):
2732 nonlocal formats, start_time, is_live
2733 if time.time() <= start_time + delay:
2736 _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2737 video_details = traverse_obj(prs, (..., 'videoDetails'), expected_type=dict)
2738 microformats = traverse_obj(
2739 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2741 _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2742 is_live = live_status == 'is_live'
2743 start_time = time.time()
2745 def mpd_feed(format_id, delay):
2747 @returns (manifest_url, manifest_stream_number, is_live) or None
2749 for retry in self.RetryManager(fatal=False):
2751 refetch_manifest(format_id, delay)
2753 f = next((f for f in formats if f['format_id'] == format_id), None)
2756 retry.error = f'{video_id}: Video is no longer live'
2758 retry.error = f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}'
2760 return f['manifest_url'], f['manifest_stream_number'], is_live
2764 f['is_live'] = is_live
2765 gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2766 live_start_time, mpd_feed, not is_live and f.copy())
2768 f['fragments'] = gen
2769 f['protocol'] = 'http_dash_segments_generator'
2771 f['fragments'] = LazyList(gen({}))
2772 del f['is_from_start']
2774 def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2775 FETCH_SPAN, MAX_DURATION = 5, 432000
2777 mpd_url, stream_number, is_live = None, None, True
2780 download_start_time = ctx.get('start') or time.time()
2782 lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2783 if lack_early_segments:
2784 self.report_warning(bug_reports_message(
2785 'Starting download from the last 120 hours of the live stream since '
2786 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2787 lack_early_segments = True
2789 known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2790 fragments, fragment_base_url = None, None
2792 def _extract_sequence_from_mpd(refresh_sequence, immediate):
2793 nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2794 # Obtain from MPD's maximum seq value
2795 old_mpd_url = mpd_url
2796 last_error = ctx.pop('last_error', None)
2797 expire_fast = immediate or last_error and isinstance(last_error, urllib.error.HTTPError) and last_error.code == 403
2798 mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2799 or (mpd_url, stream_number, False))
2800 if not refresh_sequence:
2801 if expire_fast and not is_live:
2802 return False, last_seq
2803 elif old_mpd_url == mpd_url:
2804 return True, last_seq
2805 if manifestless_orig_fmt:
2806 fmt_info = manifestless_orig_fmt
2809 fmts, _ = self._extract_mpd_formats_and_subtitles(
2810 mpd_url, None, note=False, errnote=False, fatal=False)
2811 except ExtractorError:
2814 no_fragment_score += 2
2815 return False, last_seq
2816 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2817 fragments = fmt_info['fragments']
2818 fragment_base_url = fmt_info['fragment_base_url']
2819 assert fragment_base_url
2821 _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2822 return True, _last_seq
2824 self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2826 fetch_time = time.time()
2827 if no_fragment_score > 30:
2829 if last_segment_url:
2830 # Obtain from "X-Head-Seqnum" header value from each segment
2832 urlh = self._request_webpage(
2833 last_segment_url, None, note=False, errnote=False, fatal=False)
2834 except ExtractorError:
2836 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2837 if last_seq is None:
2838 no_fragment_score += 2
2839 last_segment_url = None
2842 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2843 no_fragment_score += 2
2844 if not should_continue:
2847 if known_idx > last_seq:
2848 last_segment_url = None
2853 if begin_index < 0 and known_idx < 0:
2854 # skip from the start when it's negative value
2855 known_idx = last_seq + begin_index
2856 if lack_early_segments:
2857 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2859 for idx in range(known_idx, last_seq):
2860 # do not update sequence here or you'll get skipped some part of it
2861 should_continue, _ = _extract_sequence_from_mpd(False, False)
2862 if not should_continue:
2864 raise ExtractorError('breaking out of outer loop')
2865 last_segment_url = urljoin(fragment_base_url, 'sq/%d' % idx)
2867 'url': last_segment_url,
2868 'fragment_count': last_seq,
2870 if known_idx == last_seq:
2871 no_fragment_score += 5
2873 no_fragment_score = 0
2874 known_idx = last_seq
2875 except ExtractorError:
2878 if manifestless_orig_fmt:
2879 # Stop at the first iteration if running for post-live manifestless;
2880 # fragment count no longer increase since it starts
2883 time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2885 def _extract_player_url(self, *ytcfgs, webpage=None):
2886 player_url = traverse_obj(
2887 ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2888 get_all=False, expected_type=str)
2891 return urljoin('https://www.youtube.com', player_url)
2893 def _download_player_url(self, video_id, fatal=False):
2894 res = self._download_webpage(
2895 'https://www.youtube.com/iframe_api',
2896 note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2898 player_version = self._search_regex(
2899 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2901 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2903 def _signature_cache_id(self, example_sig):
2904 """ Return a string representation of a signature """
2905 return '.'.join(str(len(part)) for part in example_sig.split('.'))
2908 def _extract_player_info(cls, player_url):
2909 for player_re in cls._PLAYER_INFO_RE:
2910 id_m = re.search(player_re, player_url)
2914 raise ExtractorError('Cannot identify player %r' % player_url)
2915 return id_m.group('id')
2917 def _load_player(self, video_id, player_url, fatal=True):
2918 player_id = self._extract_player_info(player_url)
2919 if player_id not in self._code_cache:
2920 code = self._download_webpage(
2921 player_url, video_id, fatal=fatal,
2922 note='Downloading player ' + player_id,
2923 errnote='Download of %s failed' % player_url)
2925 self._code_cache[player_id] = code
2926 return self._code_cache.get(player_id)
2928 def _extract_signature_function(self, video_id, player_url, example_sig):
2929 player_id = self._extract_player_info(player_url)
2931 # Read from filesystem cache
2932 func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2933 assert os.path.basename(func_id) == func_id
2935 self.write_debug(f'Extracting signature function {func_id}')
2936 cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
2939 code = self._load_player(video_id, player_url)
2941 res = self._parse_sig_js(code)
2942 test_string = ''.join(map(chr, range(len(example_sig))))
2943 cache_spec = [ord(c) for c in res(test_string)]
2944 self.cache.store('youtube-sigfuncs', func_id, cache_spec)
2946 return lambda s: ''.join(s[i] for i in cache_spec)
2948 def _print_sig_code(self, func, example_sig):
2949 if not self.get_param('youtube_print_sig_code'):
2952 def gen_sig_code(idxs):
2953 def _genslice(start, end, step):
2954 starts = '' if start == 0 else str(start)
2955 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
2956 steps = '' if step == 1 else (':%d' % step)
2957 return f's[{starts}{ends}{steps}]'
2960 # Quelch pyflakes warnings - start will be set when step is set
2961 start = '(Never used)'
2962 for i, prev in zip(idxs[1:], idxs[:-1]):
2963 if step is not None:
2964 if i - prev == step:
2966 yield _genslice(start, prev, step)
2969 if i - prev in [-1, 1]:
2974 yield 's[%d]' % prev
2978 yield _genslice(start, i, step)
2980 test_string = ''.join(map(chr, range(len(example_sig))))
2981 cache_res = func(test_string)
2982 cache_spec = [ord(c) for c in cache_res]
2983 expr_code = ' + '.join(gen_sig_code(cache_spec))
2984 signature_id_tuple = '(%s)' % (
2985 ', '.join(str(len(p)) for p in example_sig.split('.')))
2986 code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
2987 ' return %s\n') % (signature_id_tuple, expr_code)
2988 self.to_screen('Extracted signature function:\n' + code)
2990 def _parse_sig_js(self, jscode):
2991 funcname = self._search_regex(
2992 (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2993 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2994 r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
2995 r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
2996 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+\))?',
2997 r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
2999 r'("|\')signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3000 r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
3001 r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3002 r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3003 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3004 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
3005 jscode, 'Initial JS player signature function name', group='sig')
3007 jsi = JSInterpreter(jscode)
3008 initial_function = jsi.extract_function(funcname)
3009 return lambda s: initial_function([s])
3011 def _cached(self, func, *cache_id):
3012 def inner(*args, **kwargs):
3013 if cache_id not in self._player_cache:
3015 self._player_cache[cache_id] = func(*args, **kwargs)
3016 except ExtractorError as e:
3017 self._player_cache[cache_id] = e
3018 except Exception as e:
3019 self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
3021 ret = self._player_cache[cache_id]
3022 if isinstance(ret, Exception):
3027 def _decrypt_signature(self, s, video_id, player_url):
3028 """Turn the encrypted s field into a working signature"""
3029 extract_sig = self._cached(
3030 self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
3031 func = extract_sig(video_id, player_url, s)
3032 self._print_sig_code(func, s)
3035 def _decrypt_nsig(self, s, video_id, player_url):
3036 """Turn the encrypted n field into a working signature"""
3037 if player_url is None:
3038 raise ExtractorError('Cannot decrypt nsig without player_url')
3039 player_url = urljoin('https://www.youtube.com', player_url)
3042 jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
3043 except ExtractorError as e:
3044 raise ExtractorError('Unable to extract nsig function code', cause=e)
3045 if self.get_param('youtube_print_sig_code'):
3046 self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
3049 extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
3050 ret = extract_nsig(jsi, func_code)(s)
3051 except JSInterpreter.Exception as e:
3053 jsi = PhantomJSwrapper(self, timeout=5000)
3054 except ExtractorError:
3056 self.report_warning(
3057 f'Native nsig extraction failed: Trying with PhantomJS\n'
3058 f' n = {s} ; player = {player_url}', video_id)
3059 self.write_debug(e, only_once=True)
3061 args, func_body = func_code
3063 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
3064 video_id=video_id, note='Executing signature code').strip()
3066 self.write_debug(f'Decrypted nsig {s} => {ret}')
3069 def _extract_n_function_name(self, jscode):
3070 funcname, idx = self._search_regex(
3071 r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
3072 jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
3076 return json.loads(js_to_json(self._search_regex(
3077 rf'var {re.escape(funcname)}\s*=\s*(\[.+?\]);', jscode,
3078 f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
3080 def _extract_n_function_code(self, video_id, player_url):
3081 player_id = self._extract_player_info(player_url)
3082 func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
3083 jscode = func_code or self._load_player(video_id, player_url)
3084 jsi = JSInterpreter(jscode)
3087 return jsi, player_id, func_code
3089 func_name = self._extract_n_function_name(jscode)
3092 func_code = self._search_regex(
3093 r'''(?xs
)%s\s
*=\s
*function\s
*\
((?P
<var
>[\w$
]+)\
)\s
*
3094 # NB: The end of the regex is intentionally kept strict
3095 {(?P<code>.+?}\s
*return\
[\w$
]+.join\
(""\
))};''' % func_name,
3096 jscode, 'nsig function', group=('var', 'code'), default=None)
3098 func_code = ([func_code[0]], func_code[1])
3100 self.write_debug('Extracting nsig function with jsinterp')
3101 func_code = jsi.extract_function_code(func_name)
3103 self.cache.store('youtube-nsig', player_id, func_code)
3104 return jsi, player_id, func_code
3106 def _extract_n_function_from_code(self, jsi, func_code):
3107 func = jsi.extract_function_from_code(*func_code)
3109 def extract_nsig(s):
3112 except JSInterpreter.Exception:
3114 except Exception as e:
3115 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
3117 if ret.startswith('enhanced_except_'):
3118 raise JSInterpreter.Exception('Signature function returned an exception')
3123 def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3125 Extract signatureTimestamp (sts)
3126 Required to tell API what sig/player version is in use.
3129 if isinstance(ytcfg, dict):
3130 sts = int_or_none(ytcfg.get('STS'))
3133 # Attempt to extract from player
3134 if player_url is None:
3135 error_msg = 'Cannot extract signature timestamp without player_url.'
3137 raise ExtractorError(error_msg)
3138 self.report_warning(error_msg)
3140 code = self._load_player(video_id, player_url, fatal=fatal)
3142 sts = int_or_none(self._search_regex(
3143 r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3144 'JS player signature timestamp', group='sts', fatal=fatal))
3147 def _mark_watched(self, video_id, player_responses):
3148 for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3149 label = 'fully ' if is_full else ''
3150 url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3151 expected_type=url_or_none)
3153 self.report_warning(f'Unable to mark {label}watched')
3155 parsed_url = urllib.parse.urlparse(url)
3156 qs = urllib.parse.parse_qs(parsed_url.query)
3158 # cpn generation algorithm is reverse engineered from base.js.
3159 # In fact it works even with dummy cpn.
3160 CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3161 cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16))
3163 # # more consistent results setting it to right before the end
3164 video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3169 'cmt': video_length,
3170 'el': 'detailpage', # otherwise defaults to "shorts"
3174 # these seem to mark watchtime "history" in the real world
3175 # they're required, so send in a single value
3181 url = urllib.parse.urlunparse(
3182 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3184 self._download_webpage(
3185 url, video_id, f'Marking {label}watched',
3186 'Unable to mark watched', fatal=False)
3189 def _extract_from_webpage(cls, url, webpage):
3190 # Invidious Instances
3191 # https://github.com/yt-dlp/yt-dlp/issues/195
3192 # https://github.com/iv-org/invidious/pull/1730
3194 r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3197 yield cls.url_result(mobj.group('url'), cls)
3198 raise cls.StopExtraction()
3200 yield from super()._extract_from_webpage(url, webpage)
3202 # lazyYT YouTube embed
3203 for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3204 yield cls.url_result(unescapeHTML(id_), cls, id_)
3206 # Wordpress "YouTube Video Importer" plugin
3207 for m in re.findall(r'''(?x
)<div
[^
>]+
3208 class=(?P
<q1
>[\'"])[^\'"]*\byvii
_single
_video
_player
\b[^
\'"]*(?P=q1)[^>]+
3209 data-video_id=(?P<q2>[\'"])([^
\'"]+)(?P=q2)''', webpage):
3210 yield cls.url_result(m[-1], cls, m[-1])
3213 def extract_id(cls, url):
3214 video_id = cls.get_temp_id(url)
3216 raise ExtractorError(f'Invalid URL: {url}')
3219 def _extract_chapters_from_json(self, data, duration):
3220 chapter_list = traverse_obj(
3222 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3223 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters'
3224 ), expected_type=list)
3226 return self._extract_chapters_helper(
3228 start_function=lambda chapter: float_or_none(
3229 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3230 title_function=lambda chapter: traverse_obj(
3231 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3234 def _extract_chapters_from_engagement_panel(self, data, duration):
3235 content_list = traverse_obj(
3237 ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3239 chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3240 chapter_title = lambda chapter: self._get_text(chapter, 'title')
3242 return next(filter(None, (
3243 self._extract_chapters_helper(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3244 chapter_time, chapter_title, duration)
3245 for contents in content_list)), [])
3247 def _extract_comment(self, comment_renderer, parent=None):
3248 comment_id = comment_renderer.get('commentId')
3252 text = self._get_text(comment_renderer, 'contentText')
3254 # Timestamp is an estimate calculated from the current time and time_text
3255 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3256 timestamp = self._parse_time_text(time_text)
3258 author = self._get_text(comment_renderer, 'authorText')
3259 author_id = try_get(comment_renderer,
3260 lambda x: x['authorEndpoint']['browseEndpoint']['browseId'], str)
3262 votes = parse_count(try_get(comment_renderer, (lambda x: x['voteCount']['simpleText'],
3263 lambda x: x['likeCount']), str)) or 0
3264 author_thumbnail = try_get(comment_renderer,
3265 lambda x: x['authorThumbnail']['thumbnails'][-1]['url'], str)
3267 author_is_uploader = try_get(comment_renderer, lambda x: x['authorIsChannelOwner'], bool)
3268 is_favorited = 'creatorHeart' in (try_get(
3269 comment_renderer, lambda x: x['actionButtons']['commentActionButtonsRenderer'], dict) or {})
3273 'timestamp': timestamp,
3274 'time_text': time_text,
3275 'like_count': votes,
3276 'is_favorited': is_favorited,
3278 'author_id': author_id,
3279 'author_thumbnail': author_thumbnail,
3280 'author_is_uploader': author_is_uploader,
3281 'parent': parent or 'root'
3284 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3286 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3288 def extract_header(contents):
3289 _continuation = None
3290 for content in contents:
3291 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3292 expected_comment_count = self._get_count(
3293 comments_header_renderer, 'countText', 'commentsCount')
3295 if expected_comment_count:
3296 tracker['est_total'] = expected_comment_count
3297 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3298 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3300 sort_menu_item = try_get(
3301 comments_header_renderer,
3302 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3303 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3305 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3306 if not _continuation:
3309 sort_text = str_or_none(sort_menu_item.get('title'))
3311 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3312 self.to_screen('Sorting comments by %s' % sort_text.lower())
3314 return _continuation
3316 def extract_thread(contents):
3318 tracker['current_page_thread'] = 0
3319 for content in contents:
3320 if not parent and tracker['total_parent_comments'] >= max_parents:
3322 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3323 comment_renderer = get_first(
3324 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3325 expected_type=dict, default={})
3327 comment = self._extract_comment(comment_renderer, parent)
3330 is_pinned = bool(traverse_obj(comment_renderer, 'pinnedCommentBadge'))
3331 comment_id = comment['id']
3333 tracker['pinned_comment_ids'].add(comment_id)
3334 # Sometimes YouTube may break and give us infinite looping comments.
3335 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3336 if comment_id in tracker['seen_comment_ids']:
3337 if comment_id in tracker['pinned_comment_ids'] and not is_pinned:
3338 # Pinned comments may appear a second time in newest first sort
3339 # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3341 self.report_warning('Detected YouTube comments looping. Stopping comment extraction as we probably cannot get any more.')
3344 tracker['seen_comment_ids'].add(comment['id'])
3346 tracker['running_total'] += 1
3347 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3350 # Attempt to get the replies
3351 comment_replies_renderer = try_get(
3352 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3354 if comment_replies_renderer:
3355 tracker['current_page_thread'] += 1
3356 comment_entries_iter = self._comment_entries(
3357 comment_replies_renderer, ytcfg, video_id,
3358 parent=comment.get('id'), tracker=tracker)
3359 yield from itertools.islice(comment_entries_iter, min(
3360 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3362 # Keeps track of counts across recursive calls
3367 current_page_thread=0,
3368 total_parent_comments=0,
3369 total_reply_comments=0,
3370 seen_comment_ids=set(),
3371 pinned_comment_ids=set()
3375 # YouTube comments have a max depth of 2
3376 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3378 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3379 'Set max replies in the max-comments extractor argument instead')
3380 if max_depth == 1 and parent:
3383 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
3384 lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
3386 continuation = self._extract_continuation(root_continuation_data)
3389 is_forced_continuation = False
3390 is_first_continuation = parent is None
3391 if is_first_continuation and not continuation:
3392 # Sometimes you can get comments by generating the continuation yourself,
3393 # even if YouTube initially reports them being disabled - e.g. stories comments.
3394 # Note: if the comment section is actually disabled, YouTube may return a response with
3395 # required check_get_keys missing. So we will disable that check initially in this case.
3396 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3397 is_forced_continuation = True
3399 for page_num in itertools.count(0):
3400 if not continuation:
3402 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3403 comment_prog_str = f"({tracker['running_total']}
/{tracker['est_total']}
)"
3405 if is_first_continuation:
3406 note_prefix = 'Downloading comment section API JSON'
3408 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3409 tracker['current_page_thread'], comment_prog_str)
3411 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
3412 ' ' if parent else '', ' replies' if parent else '',
3413 page_num, comment_prog_str)
3415 response = self._extract_response(
3416 item_id=None, query=continuation,
3417 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3418 check_get_keys='onResponseReceivedEndpoints' if not is_forced_continuation else None)
3419 except ExtractorError as e:
3420 # Ignore incomplete data error for replies if retries didn't work.
3421 # This is to allow any other parent comments and comment threads to be downloaded.
3422 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3423 if 'incomplete data' in str(e).lower() and parent and self.get_param('ignoreerrors') is True:
3424 self.report_warning(
3425 'Received incomplete data for a comment reply thread and retrying did not help. '
3426 'Ignoring to let other comments be downloaded.')
3429 is_forced_continuation = False
3430 continuation_contents = traverse_obj(
3431 response, 'onResponseReceivedEndpoints', expected_type=list, default=[])
3434 for continuation_section in continuation_contents:
3435 continuation_items = traverse_obj(
3436 continuation_section,
3437 (('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems'),
3438 get_all=False, expected_type=list) or []
3439 if is_first_continuation:
3440 continuation = extract_header(continuation_items)
3441 is_first_continuation = False
3446 for entry in extract_thread(continuation_items):
3450 continuation = self._extract_continuation({'contents': continuation_items})
3454 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3455 if message and not parent and tracker['running_total'] == 0:
3456 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3457 raise self.CommentsDisabled
3460 def _generate_comment_continuation(video_id):
3462 Generates initial comment section continuation token from given video id
3464 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3465 return base64.b64encode(token.encode()).decode()
3467 def _get_comments(self, ytcfg, video_id, contents, webpage):
3468 """Entry for comment extraction"""
3469 def _real_comment_extract(contents):
3471 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3472 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3473 yield from self._comment_entries(renderer, ytcfg, video_id)
3475 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3476 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3479 def _get_checkok_params():
3480 return {'contentCheckOk': True, 'racyCheckOk': True}
3483 def _generate_player_context(cls, sts=None):
3485 'html5Preference': 'HTML5_PREF_WANTS',
3488 context['signatureTimestamp'] = sts
3490 'playbackContext': {
3491 'contentPlaybackContext': context
3493 **cls._get_checkok_params()
3497 def _is_agegated(player_response):
3498 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3501 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3502 AGE_GATE_REASONS = (
3503 'confirm your age', 'age-restricted', 'inappropriate', # reason
3504 'age_verification_required', 'age_check_required', # status
3506 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3509 def _is_unplayable(player_response):
3510 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3512 _STORY_PLAYER_PARAMS = '8AEB'
3514 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3516 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3517 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3518 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3519 headers = self.generate_api_headers(
3520 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3523 'videoId': video_id,
3525 if smuggled_data.get('is_story') or _split_innertube_client(client)[0] == 'android':
3526 yt_query['params'] = self._STORY_PLAYER_PARAMS
3528 yt_query.update(self._generate_player_context(sts))
3529 return self._extract_response(
3530 item_id=video_id, ep='player', query=yt_query,
3531 ytcfg=player_ytcfg, headers=headers, fatal=True,
3532 default_client=client,
3533 note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
3536 def _get_requested_clients(self, url, smuggled_data):
3537 requested_clients = []
3538 default = ['android', 'web']
3539 allowed_clients = sorted(
3540 (client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'),
3541 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3542 for client in self._configuration_arg('player_client'):
3543 if client in allowed_clients:
3544 requested_clients.append(client)
3545 elif client == 'default':
3546 requested_clients.extend(default)
3547 elif client == 'all':
3548 requested_clients.extend(allowed_clients)
3550 self.report_warning(f'Skipping unsupported client {client}')
3551 if not requested_clients:
3552 requested_clients = default
3554 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3555 requested_clients.extend(
3556 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3558 return orderedSet(requested_clients)
3560 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3563 initial_pr = self._search_json(
3564 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3566 all_clients = set(clients)
3567 clients = clients[::-1]
3570 def append_client(*client_names):
3571 """ Append the first client name that exists but not already used """
3572 for client_name in client_names:
3573 actual_client = _split_innertube_client(client_name)[0]
3574 if actual_client in INNERTUBE_CLIENTS:
3575 if actual_client not in all_clients:
3576 clients.append(client_name)
3577 all_clients.add(actual_client)
3580 # Android player_response does not have microFormats which are needed for
3581 # extraction of some data. So we return the initial_pr with formats
3582 # stripped out even if not requested by the user
3583 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3585 pr = dict(initial_pr)
3586 pr['streamingData'] = None
3590 tried_iframe_fallback = False
3593 client, base_client, variant = _split_innertube_client(clients.pop())
3594 player_ytcfg = master_ytcfg if client == 'web' else {}
3595 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3596 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3598 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3599 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3600 if 'js' in self._configuration_arg('player_skip'):
3601 require_js_player = False
3604 if not player_url and not tried_iframe_fallback and require_js_player:
3605 player_url = self._download_player_url(video_id)
3606 tried_iframe_fallback = True
3609 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3610 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3611 except ExtractorError as e:
3613 self.report_warning(last_error)
3618 # YouTube may return a different video player response than expected.
3619 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3620 pr_video_id = traverse_obj(pr, ('videoDetails', 'videoId'))
3621 if pr_video_id and pr_video_id != video_id:
3622 self.report_warning(
3623 f'Skipping player response from {client} client (got player response for video "{pr_video_id}
" instead of "{video_id}
")' + bug_reports_message())
3625 # Save client name for introspection later
3626 name = short_client_name(client)
3627 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3628 sd[STREAMING_DATA_CLIENT_NAME] = name
3629 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3630 f[STREAMING_DATA_CLIENT_NAME] = name
3633 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3634 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3635 append_client(f'{base_client}_creator')
3636 elif self._is_agegated(pr):
3637 if variant == 'tv_embedded':
3638 append_client(f'{base_client}_embedded')
3640 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3645 self.report_warning(last_error)
3646 return prs, player_url
3648 def _needs_live_processing(self, live_status, duration):
3649 if (live_status == 'is_live' and self.get_param('live_from_start')
3650 or live_status == 'post_live' and (duration or 0) > 4 * 3600):
3653 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3654 CHUNK_SIZE = 10 << 20
3655 itags, stream_ids = collections.defaultdict(set), []
3656 itag_qualities, res_qualities = {}, {0: None}
3658 # Normally tiny is the smallest video-only formats. But
3659 # audio-only formats with unknown quality may get tagged as tiny
3661 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3662 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
3664 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3665 all_formats = self._configuration_arg('include_duplicate_formats')
3667 def build_fragments(f):
3669 'url': update_url_query(f['url'], {
3670 'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}'
3672 } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3674 for fmt in streaming_formats:
3675 if fmt.get('targetDurationSec'):
3678 itag = str_or_none(fmt.get('itag'))
3679 audio_track = fmt.get('audioTrack') or {}
3680 stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3682 if stream_id in stream_ids:
3685 quality = fmt.get('quality')
3686 height = int_or_none(fmt.get('height'))
3687 if quality == 'tiny' or not quality:
3688 quality = fmt.get('audioQuality', '').lower() or quality
3689 # The 3gp format (17) in android client has a quality of "small
",
3690 # but is actually worse than other formats
3695 itag_qualities[itag] = quality
3697 res_qualities[height] = quality
3698 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3699 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3700 # number of fragment that would subsequently requested with (`&sq=N`)
3701 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3704 fmt_url = fmt.get('url')
3706 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3707 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3708 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3709 if not all((sc, fmt_url, player_url, encrypted_sig)):
3712 fmt_url += '&%s=%s' % (
3713 traverse_obj(sc, ('sp', -1)) or 'signature',
3714 self._decrypt_signature(encrypted_sig, video_id, player_url)
3716 except ExtractorError as e:
3717 self.report_warning('Signature extraction failed: Some formats may be missing',
3718 video_id=video_id, only_once=True)
3719 self.write_debug(e, only_once=True)
3722 query = parse_qs(fmt_url)
3726 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3727 fmt_url = update_url_query(fmt_url, {
3728 'n': decrypt_nsig(query['n'][0], video_id, player_url)
3730 except ExtractorError as e:
3732 if isinstance(e, JSInterpreter.Exception):
3733 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3734 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3736 self.report_warning(
3737 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3738 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3739 self.write_debug(e, only_once=True)
3741 self.report_warning(
3742 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3743 video_id=video_id, only_once=True)
3746 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3747 language_preference = (
3748 10 if audio_track.get('audioIsDefault') and 10
3749 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3751 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3752 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3753 # Make sure to avoid false positives with small duration differences.
3754 # E.g. __2ABJjxzNo, ySuUZEjARPY
3755 is_damaged = try_get(fmt, lambda x: float(x['approxDurationMs']) / duration < 500)
3757 self.report_warning(
3758 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3760 client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3762 'asr': int_or_none(fmt.get('audioSampleRate')),
3763 'filesize': int_or_none(fmt.get('contentLength')),
3764 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3765 'format_note': join_nonempty(
3766 join_nonempty(audio_track.get('displayName'),
3767 language_preference > 0 and ' (default)', delim=''),
3768 fmt.get('qualityLabel') or quality.replace('audio_quality_', ''),
3769 fmt.get('isDrc') and 'DRC',
3770 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3771 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3772 throttled and 'THROTTLED', is_damaged and 'DAMAGED',
3773 (self.get_param('verbose') or all_formats) and client_name,
3775 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3776 'source_preference': -10 if throttled else -5 if itag == '22' else -1,
3777 'fps': int_or_none(fmt.get('fps')) or None,
3778 'audio_channels': fmt.get('audioChannels'),
3780 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3781 'has_drm': bool(fmt.get('drmFamilies')),
3784 'width': int_or_none(fmt.get('width')),
3785 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3786 'desc' if language_preference < -1 else '') or None,
3787 'language_preference': language_preference,
3788 # Strictly de-prioritize damaged and 3gp formats
3789 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3791 mime_mobj = re.match(
3792 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3794 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3795 dct.update(parse_codecs(mime_mobj.group(2)))
3797 itags[itag].add(('https
', dct.get('language
')))
3798 stream_ids.append(stream_id)
3799 single_stream = 'none
' in (dct.get('acodec
'), dct.get('vcodec
'))
3800 if single_stream and dct.get('ext
'):
3801 dct['container
'] = dct['ext
'] + '_dash
'
3803 if all_formats and dct['filesize
']:
3806 'format_id
': f'{dct["format_id"]}
-dashy
' if all_formats else dct['format_id
'],
3807 'protocol
': 'http_dash_segments
',
3808 'fragments
': build_fragments(dct),
3810 dct['downloader_options
'] = {'http_chunk_size': CHUNK_SIZE}
3813 needs_live_processing = self._needs_live_processing(live_status, duration)
3814 skip_bad_formats = not self._configuration_arg('include_incomplete_formats
')
3816 skip_manifests = set(self._configuration_arg('skip
'))
3817 if (not self.get_param('youtube_include_hls_manifest
', True)
3818 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3819 or needs_live_processing and skip_bad_formats):
3820 skip_manifests.add('hls
')
3822 if not self.get_param('youtube_include_dash_manifest
', True):
3823 skip_manifests.add('dash
')
3824 if self._configuration_arg('include_live_dash
'):
3825 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3826 'Use include_incomplete_formats extractor argument instead
')
3827 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3828 skip_manifests.add('dash
')
3830 def process_manifest_format(f, proto, client_name, itag):
3831 key = (proto, f.get('language
'))
3832 if not all_formats and key in itags[itag]:
3834 itags[itag].add(key)
3836 if itag and all_formats:
3837 f['format_id
'] = f'{itag}
-{proto}
'
3838 elif any(p != proto for p, _ in itags[itag]):
3839 f['format_id
'] = f'{itag}
-{proto}
'
3841 f['format_id
'] = itag
3843 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
3844 if f['quality
'] == -1 and f.get('height
'):
3845 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
3846 if self.get_param('verbose
'):
3847 f['format_note
'] = join_nonempty(f.get('format_note
'), client_name, delim=', ')
3851 for sd in streaming_data:
3852 client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
3854 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
3855 if hls_manifest_url:
3856 fmts, subs = self._extract_m3u8_formats_and_subtitles(
3857 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
3858 subtitles = self._merge_subtitles(subs, subtitles)
3860 if process_manifest_format(f, 'hls
', client_name, self._search_regex(
3861 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
3864 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
3865 if dash_manifest_url:
3866 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
3867 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
3869 if process_manifest_format(f, 'dash
', client_name, f['format_id
']):
3870 f['filesize
'] = int_or_none(self._search_regex(
3871 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
3872 if needs_live_processing:
3873 f['is_from_start
'] = True
3878 def _extract_storyboard(self, player_responses, duration):
3880 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
3881 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
3885 for i, args in enumerate(spec):
3886 args = args.split('#')
3887 counts
= list(map(int_or_none
, args
[:5]))
3888 if len(args
) != 8 or not all(counts
):
3889 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
3891 width
, height
, frame_count
, cols
, rows
= counts
3894 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
3895 fragment_count
= frame_count
/ (cols
* rows
)
3896 fragment_duration
= duration
/ fragment_count
3898 'format_id': f
'sb{i}',
3899 'format_note': 'storyboard',
3901 'protocol': 'mhtml',
3907 'fps': frame_count
/ duration
,
3911 'url': url
.replace('$M', str(j
)),
3912 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
3913 } for j
in range(math
.ceil(fragment_count
))],
3916 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
3918 if 'webpage' not in self
._configuration
_arg
('player_skip'):
3919 query
= {'bpctr': '9999999999', 'has_verified': '1'}
3920 if smuggled_data
.get('is_story'):
3921 query
['pp'] = self
._STORY
_PLAYER
_PARAMS
3922 webpage
= self
._download
_webpage
(
3923 webpage_url
, video_id
, fatal
=False, query
=query
)
3925 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
3927 player_responses
, player_url
= self
._extract
_player
_responses
(
3928 self
._get
_requested
_clients
(url
, smuggled_data
),
3929 video_id
, webpage
, master_ytcfg
, smuggled_data
)
3931 return webpage
, master_ytcfg
, player_responses
, player_url
3933 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
3934 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
3935 is_live
= get_first(video_details
, 'isLive')
3937 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
3938 live_content
= get_first(video_details
, 'isLiveContent')
3939 is_upcoming
= get_first(video_details
, 'isUpcoming')
3940 post_live
= get_first(video_details
, 'isPostLiveDvr')
3941 live_status
= ('post_live' if post_live
3942 else 'is_live' if is_live
3943 else 'is_upcoming' if is_upcoming
3944 else 'was_live' if live_content
3945 else 'not_live' if False in (is_live
, live_content
)
3947 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'))
3948 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
3950 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
3952 def _real_extract(self
, url
):
3953 url
, smuggled_data
= unsmuggle_url(url
, {})
3954 video_id
= self
._match
_id
(url
)
3956 base_url
= self
.http_scheme() + '//www.youtube.com/'
3957 webpage_url
= base_url
+ 'watch?v=' + video_id
3959 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
3961 playability_statuses
= traverse_obj(
3962 player_responses
, (..., 'playabilityStatus'), expected_type
=dict)
3964 trailer_video_id
= get_first(
3965 playability_statuses
,
3966 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
3968 if trailer_video_id
:
3969 return self
.url_result(
3970 trailer_video_id
, self
.ie_key(), trailer_video_id
)
3972 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
3973 if webpage
else (lambda x
: None))
3975 video_details
= traverse_obj(player_responses
, (..., 'videoDetails'), expected_type
=dict)
3976 microformats
= traverse_obj(
3977 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
3980 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
3981 video_title
= (self
._preferred
_lang
and translated_title
3982 or get_first(video_details
, 'title') # primary
3984 or search_meta(['og:title', 'twitter:title', 'title']))
3985 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
3986 original_description
= get_first(video_details
, 'shortDescription')
3987 video_description
= (
3988 self
._preferred
_lang
and translated_description
3989 # If original description is blank, it will be an empty string.
3990 # Do not prefer translated description in this case.
3991 or original_description
if original_description
is not None else translated_description
)
3993 multifeed_metadata_list
= get_first(
3995 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
3997 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
3998 if self
.get_param('noplaylist'):
3999 self
.to_screen('Downloading just video %s because of --no-playlist' % video_id
)
4003 for feed
in multifeed_metadata_list
.split(','):
4004 # Unquote should take place before split on comma (,) since textual
4005 # fields may contain comma as well (see
4006 # https://github.com/ytdl-org/youtube-dl/issues/8536)
4007 feed_data
= urllib
.parse
.parse_qs(
4008 urllib
.parse
.unquote_plus(feed
))
4010 def feed_entry(name
):
4012 feed_data
, lambda x
: x
[name
][0], str)
4014 feed_id
= feed_entry('id')
4017 feed_title
= feed_entry('title')
4020 title
+= ' (%s)' % feed_title
4022 '_type': 'url_transparent',
4023 'ie_key': 'Youtube',
4025 '%swatch?v=%s' % (base_url
, feed_data
['id'][0]),
4026 {'force_singlefeed': True}
),
4029 feed_ids
.append(feed_id
)
4031 'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
4032 % (', '.join(feed_ids
), video_id
))
4033 return self
.playlist_result(
4034 entries
, video_id
, video_title
, video_description
)
4036 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
4037 or int_or_none(get_first(microformats
, 'lengthSeconds'))
4038 or parse_duration(search_meta('duration')) or None)
4040 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
4041 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
4042 if live_status
== 'post_live':
4043 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
4046 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
4047 self
.report_drm(video_id
)
4049 playability_statuses
,
4050 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
4051 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
4052 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
4054 if subreason
== 'The uploader has not made this video available in your country.':
4055 countries
= get_first(microformats
, 'availableCountries')
4057 regions_allowed
= search_meta('regionsAllowed')
4058 countries
= regions_allowed
.split(',') if regions_allowed
else None
4059 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
4060 reason
+= f
'. {subreason}'
4062 self
.raise_no_formats(reason
, expected
=True)
4064 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
4065 if not keywords
and webpage
:
4067 unescapeHTML(m
.group('content'))
4068 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
4069 for keyword
in keywords
:
4070 if keyword
.startswith('yt:stretch='):
4071 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
4073 # NB: float is intentional for forcing float division
4074 w
, h
= (float(v
) for v
in mobj
.groups())
4078 if f
.get('vcodec') != 'none':
4079 f
['stretched_ratio'] = ratio
4081 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
4082 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
4085 'url': thumbnail_url
,
4087 original_thumbnails
= thumbnails
.copy()
4089 # The best resolution thumbnails sometimes does not appear in the webpage
4090 # See: https://github.com/yt-dlp/yt-dlp/issues/340
4091 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4093 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4094 # in resolution, these are not the custom thumbnail. So de-prioritize them
4095 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4096 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3'
4098 n_thumbnail_names
= len(thumbnail_names
)
4100 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4101 video_id
=video_id
, name
=name
, ext
=ext
,
4102 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
4103 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
4104 for thumb
in thumbnails
:
4105 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
4106 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
4107 self
._remove
_duplicate
_formats
(thumbnails
)
4108 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
4110 category
= get_first(microformats
, 'category') or search_meta('genre')
4111 channel_id
= self
.ucid_or_none(str_or_none(
4112 get_first(video_details
, 'channelId')
4113 or get_first(microformats
, 'externalChannelId')
4114 or search_meta('channelId')))
4115 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
4117 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
4118 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
4119 if not duration
and live_end_time
and live_start_time
:
4120 duration
= live_end_time
- live_start_time
4122 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
4124 def is_bad_format(fmt
):
4125 if needs_live_processing
and not fmt
.get('is_from_start'):
4127 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
4128 and fmt
.get('protocol') == 'http_dash_segments'):
4131 for fmt
in filter(is_bad_format
, formats
):
4132 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4133 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 4 hours)', delim
=' ')
4135 if needs_live_processing
:
4136 self
._prepare
_live
_from
_start
_formats
(
4137 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4139 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4141 channel_handle
= self
.handle_from_url(owner_profile_url
)
4145 'title': video_title
,
4147 'thumbnails': thumbnails
,
4148 # The best thumbnail that we are sure exists. Prevents unnecessary
4149 # URL checking if user don't care about getting the best possible thumbnail
4150 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4151 'description': video_description
,
4152 'channel_id': channel_id
,
4153 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None),
4154 'duration': duration
,
4155 'view_count': int_or_none(
4156 get_first((video_details
, microformats
), (..., 'viewCount'))
4157 or search_meta('interactionCount')),
4158 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4159 'age_limit': 18 if (
4160 get_first(microformats
, 'isFamilySafe') is False
4161 or search_meta('isFamilyFriendly') == 'false'
4162 or search_meta('og:restrictions:age') == '18+') else 0,
4163 'webpage_url': webpage_url
,
4164 'categories': [category
] if category
else None,
4166 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4167 'live_status': live_status
,
4168 'release_timestamp': live_start_time
,
4169 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4170 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto')
4174 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4176 def get_lang_code(track
):
4177 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4178 or track
.get('languageCode'))
4180 # Converted into dicts to remove duplicates
4182 get_lang_code(sub
): sub
4183 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...))}
4184 translation_languages
= {
4185 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4186 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...))}
4188 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4189 lang_subs
= container
.setdefault(lang_code
, [])
4190 for fmt
in self
._SUBTITLE
_FORMATS
:
4196 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4200 # NB: Constructing the full subtitle dictionary is slow
4201 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4202 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4203 for lang_code
, caption_track
in captions
.items():
4204 base_url
= caption_track
.get('baseUrl')
4205 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4208 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4209 if caption_track
.get('kind') != 'asr':
4213 subtitles
, base_url
, lang_code
, lang_name
, {})
4214 if not caption_track
.get('isTranslatable'):
4216 for trans_code
, trans_name
in translation_languages
.items():
4219 orig_trans_code
= trans_code
4220 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4221 if not get_translated_subs
:
4223 trans_code
+= f
'-{lang_code}'
4224 trans_name
+= format_field(lang_name
, None, ' from %s')
4225 # Add an "-orig" label to the original language so that it can be distinguished.
4226 # The subs are returned without "-orig" as well for compatibility
4227 if lang_code
== f
'a-{orig_trans_code}':
4229 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4230 # Setting tlang=lang returns damaged subtitles.
4231 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4232 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4234 info
['automatic_captions'] = automatic_captions
4235 info
['subtitles'] = subtitles
4237 parsed_url
= urllib
.parse
.urlparse(url
)
4238 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4239 query
= urllib
.parse
.parse_qs(component
)
4240 for k
, v
in query
.items():
4241 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4243 if d_k
not in info
and k
in s_ks
:
4244 info
[d_k
] = parse_duration(query
[k
][0])
4246 # Youtube Music Auto-generated description
4247 if video_description
:
4250 (?P<track>[^·\n]+)·(?P<artist>[^\n]+)\n+
4252 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4253 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4254 (.+?\nArtist\s*:\s*(?P<clean_artist>[^\n]+))?
4255 .+\nAuto-generated\ by\ YouTube\.\s*$
4256 ''', video_description
)
4258 release_year
= mobj
.group('release_year')
4259 release_date
= mobj
.group('release_date')
4261 release_date
= release_date
.replace('-', '')
4262 if not release_year
:
4263 release_year
= release_date
[:4]
4265 'album': mobj
.group('album'.strip()),
4266 'artist': mobj
.group('clean_artist') or ', '.join(a
.strip() for a
in mobj
.group('artist').split('·')),
4267 'track': mobj
.group('track').strip(),
4268 'release_date': release_date
,
4269 'release_year': int_or_none(release_year
),
4274 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4275 if not traverse_obj(initial_data
, 'contents'):
4276 self
.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4278 if not initial_data
:
4279 query
= {'videoId': video_id}
4280 query
.update(self
._get
_checkok
_params
())
4281 initial_data
= self
._extract
_response
(
4282 item_id
=video_id
, ep
='next', fatal
=False,
4283 ytcfg
=master_ytcfg
, query
=query
, check_get_keys
='contents',
4284 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4285 note
='Downloading initial data API JSON')
4287 info
['comment_count'] = traverse_obj(initial_data
, (
4288 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4289 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount'
4291 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4292 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo'
4293 ), expected_type
=self
._get
_count
, get_all
=False)
4295 try: # This will error if there is no livechat
4296 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4297 except (KeyError, IndexError, TypeError):
4300 info
.setdefault('subtitles', {})['live_chat'] = [{
4301 # url is needed to set cookies
4302 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4303 'video_id': video_id
,
4305 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4306 else 'youtube_live_chat_replay'),
4310 info
['chapters'] = (
4311 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4312 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4313 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4316 contents
= traverse_obj(
4317 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4318 expected_type
=list, default
=[])
4320 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4322 stl
= vpir
.get('superTitleLink')
4324 stl
= self
._get
_text
(stl
)
4327 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4328 info
['location'] = stl
4330 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4333 'series': mobj
.group(1),
4334 'season_number': int(mobj
.group(2)),
4335 'episode_number': int(mobj
.group(3)),
4337 for tlb
in (try_get(
4339 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4343 tlb
, ('toggleButtonRenderer', ...),
4344 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4346 for getter
, regex
in [(
4347 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4348 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4349 lambda x
: x
['accessibility'],
4350 lambda x
: x
['accessibilityData']['accessibilityData'],
4351 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4352 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4354 mobj
= re
.match(regex
, label
)
4356 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4358 sbr_tooltip
= try_get(
4359 vpir
, lambda x
: x
['sentimentBar']['sentimentBarRenderer']['tooltip'])
4361 like_count
, dislike_count
= sbr_tooltip
.split(' / ')
4363 'like_count': str_to_int(like_count
),
4364 'dislike_count': str_to_int(dislike_count
),
4366 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4368 vc
= self
._get
_count
(vcr
, 'viewCount')
4369 # Upcoming premieres with waiting count are treated as live here
4370 if vcr
.get('isLive'):
4371 info
['concurrent_view_count'] = vc
4372 elif info
.get('view_count') is None:
4373 info
['view_count'] = vc
4375 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4377 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4379 'channel': self
._get
_text
(vor
, 'title'),
4380 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4382 if not channel_handle
:
4383 channel_handle
= self
.handle_from_url(
4385 ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4386 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4387 {str}
), get_all
=False))
4391 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4393 multiple_songs
= False
4395 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4396 multiple_songs
= True
4399 mrr
= row
.get('metadataRowRenderer') or {}
4400 mrr_title
= mrr
.get('title')
4403 mrr_title
= self
._get
_text
(mrr
, 'title')
4404 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4405 if mrr_title
== 'License':
4406 info
['license'] = mrr_contents_text
4407 elif not multiple_songs
:
4408 if mrr_title
== 'Album':
4409 info
['album'] = mrr_contents_text
4410 elif mrr_title
== 'Artist':
4411 info
['artist'] = mrr_contents_text
4412 elif mrr_title
== 'Song':
4413 info
['track'] = mrr_contents_text
4416 'uploader': info
.get('channel'),
4417 'uploader_id': channel_handle
,
4418 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4420 # The upload date for scheduled, live and past live streams / premieres in microformats
4421 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4422 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4424 unified_strdate(get_first(microformats
, 'uploadDate'))
4425 or unified_strdate(search_meta('uploadDate')))
4426 if not upload_date
or (
4427 live_status
in ('not_live', None)
4428 and 'no-youtube-prefer-utc-upload-date' not in self
.get_param('compat_opts', [])
4430 upload_date
= strftime_or_none(
4431 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText')), '%Y%m%d') or upload_date
4432 info
['upload_date'] = upload_date
4434 for s_k
, d_k
in [('artist', 'creator'), ('track', 'alt_title')]:
4439 badges
= self
._extract
_badges
(traverse_obj(contents
, (..., 'videoPrimaryInfoRenderer'), get_all
=False))
4441 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4442 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4444 info
['availability'] = (
4445 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4446 else self
._availability
(
4447 is_private
=is_private
,
4449 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4450 or False if initial_data
and is_private
is not None else None),
4451 needs_subscription
=(
4452 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4453 or False if initial_data
and is_private
is not None else None),
4454 needs_auth
=info
['age_limit'] >= 18,
4455 is_unlisted
=None if is_private
is None else (
4456 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4457 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4459 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4461 self
.mark_watched(video_id
, player_responses
)
4466 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4468 def passthrough_smuggled_data(func
):
4469 def _smuggle(info
, smuggled_data
):
4470 if info
.get('_type') not in ('url', 'url_transparent'):
4472 if smuggled_data
.get('is_music_url'):
4473 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4474 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4475 smuggled_data
.pop('is_music_url')
4476 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4478 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4481 @functools.wraps(func
)
4482 def wrapper(self
, url
):
4483 url
, smuggled_data
= unsmuggle_url(url
, {})
4484 if self
.is_music_url(url
):
4485 smuggled_data
['is_music_url'] = True
4486 info_dict
= func(self
, url
, smuggled_data
)
4488 _smuggle(info_dict
, smuggled_data
)
4489 if info_dict
.get('entries'):
4490 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4495 def _extract_basic_item_renderer(item
):
4496 # Modified from _extract_grid_item_renderer
4497 known_basic_renderers
= (
4498 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer'
4500 for key
, renderer
in item
.items():
4501 if not isinstance(renderer
, dict):
4503 elif key
in known_basic_renderers
:
4505 elif key
.startswith('grid') and key
.endswith('Renderer'):
4508 def _extract_channel_renderer(self
, renderer
):
4509 channel_id
= self
.ucid_or_none(renderer
['channelId'])
4510 title
= self
._get
_text
(renderer
, 'title')
4511 channel_url
= format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None)
4512 # As of 2023-03-01 YouTube doesn't use the channel handles on these renderers yet.
4513 # However we can expect them to change that in the future.
4514 channel_handle
= self
.handle_from_url(
4515 traverse_obj(renderer
, (
4516 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4517 ('browseEndpoint', 'canonicalBaseUrl')),
4518 {str}
), get_all
=False))
4523 'ie_key': YoutubeTabIE
.ie_key(),
4526 'channel_id': channel_id
,
4527 'channel_url': channel_url
,
4529 'uploader_id': channel_handle
,
4530 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4531 'channel_follower_count': self
._get
_count
(renderer
, 'subscriberCountText'),
4532 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
4533 'playlist_count': self
._get
_count
(renderer
, 'videoCountText'),
4534 'description': self
._get
_text
(renderer
, 'descriptionSnippet'),
4537 def _grid_entries(self
, grid_renderer
):
4538 for item
in grid_renderer
['items']:
4539 if not isinstance(item
, dict):
4541 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4542 if not isinstance(renderer
, dict):
4544 title
= self
._get
_text
(renderer
, 'title')
4547 playlist_id
= renderer
.get('playlistId')
4549 yield self
.url_result(
4550 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4551 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4555 video_id
= renderer
.get('videoId')
4557 yield self
._extract
_video
(renderer
)
4560 channel_id
= renderer
.get('channelId')
4562 yield self
._extract
_channel
_renderer
(renderer
)
4564 # generic endpoint URL support
4565 ep_url
= urljoin('https://www.youtube.com/', try_get(
4566 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4569 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4570 if ie
.suitable(ep_url
):
4571 yield self
.url_result(
4572 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4575 def _music_reponsive_list_entry(self
, renderer
):
4576 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4578 title
= traverse_obj(renderer
, (
4579 'flexColumns', 0, 'musicResponsiveListItemFlexColumnRenderer',
4580 'text', 'runs', 0, 'text'))
4581 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4582 ie
=YoutubeIE
.ie_key(), video_id
=video_id
, title
=title
)
4583 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4585 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4587 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4588 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4589 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4590 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4591 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4593 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4594 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4596 def _shelf_entries_from_content(self
, shelf_renderer
):
4597 content
= shelf_renderer
.get('content')
4598 if not isinstance(content
, dict):
4600 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4602 # TODO: add support for nested playlists so each shelf is processed
4603 # as separate playlist
4604 # TODO: this includes only first N items
4605 yield from self
._grid
_entries
(renderer
)
4606 renderer
= content
.get('horizontalListRenderer')
4611 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4613 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4615 shelf_url
= urljoin('https://www.youtube.com', ep
)
4617 # Skipping links to another channels, note that checking for
4618 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4620 if skip_channels
and '/channels?' in shelf_url
:
4622 title
= self
._get
_text
(shelf_renderer
, 'title')
4623 yield self
.url_result(shelf_url
, video_title
=title
)
4624 # Shelf may not contain shelf URL, fallback to extraction from content
4625 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4627 def _playlist_entries(self
, video_list_renderer
):
4628 for content
in video_list_renderer
['contents']:
4629 if not isinstance(content
, dict):
4631 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4632 if not isinstance(renderer
, dict):
4634 video_id
= renderer
.get('videoId')
4637 yield self
._extract
_video
(renderer
)
4639 def _rich_entries(self
, rich_grid_renderer
):
4640 renderer
= traverse_obj(
4642 ('content', ('videoRenderer', 'reelItemRenderer', 'playlistRenderer')), get_all
=False) or {}
4643 video_id
= renderer
.get('videoId')
4645 yield self
._extract
_video
(renderer
)
4647 playlist_id
= renderer
.get('playlistId')
4649 yield self
.url_result(
4650 f
'https://www.youtube.com/playlist?list={playlist_id}',
4651 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4652 video_title
=self
._get
_text
(renderer
, 'title'))
4655 def _video_entry(self
, video_renderer
):
4656 video_id
= video_renderer
.get('videoId')
4658 return self
._extract
_video
(video_renderer
)
4660 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4661 url
= urljoin('https://youtube.com', traverse_obj(
4662 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4664 return self
.url_result(
4665 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4667 def _post_thread_entries(self
, post_thread_renderer
):
4668 post_renderer
= try_get(
4669 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4670 if not post_renderer
:
4673 video_renderer
= try_get(
4674 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4675 video_id
= video_renderer
.get('videoId')
4677 entry
= self
._extract
_video
(video_renderer
)
4680 # playlist attachment
4681 playlist_id
= try_get(
4682 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4684 yield self
.url_result(
4685 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4686 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4687 # inline video links
4688 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4690 if not isinstance(run
, dict):
4693 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4696 if not YoutubeIE
.suitable(ep_url
):
4698 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4699 if video_id
== ep_video_id
:
4701 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4703 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4704 contents
= post_thread_continuation
.get('contents')
4705 if not isinstance(contents
, list):
4707 for content
in contents
:
4708 renderer
= content
.get('backstagePostThreadRenderer')
4709 if isinstance(renderer
, dict):
4710 yield from self
._post
_thread
_entries
(renderer
)
4712 renderer
= content
.get('videoRenderer')
4713 if isinstance(renderer
, dict):
4714 yield self
._video
_entry
(renderer
)
4717 def _rich_grid_entries(self, contents):
4718 for content in contents:
4719 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4721 entry = self._video_entry(video_renderer)
4726 def _report_history_entries(self
, renderer
):
4727 for url
in traverse_obj(renderer
, (
4728 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4729 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4730 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4731 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4733 def _extract_entries(self
, parent_renderer
, continuation_list
):
4734 # continuation_list is modified in-place with continuation_list = [continuation_token]
4735 continuation_list
[:] = [None]
4736 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4737 for content
in contents
:
4738 if not isinstance(content
, dict):
4740 is_renderer
= traverse_obj(
4741 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4744 if content
.get('richItemRenderer'):
4745 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4747 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4748 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4749 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4750 yield from self
._report
_history
_entries
(table
)
4751 continuation_list
[0] = self
._extract
_continuation
(table
)
4754 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4755 for isr_content
in isr_contents
:
4756 if not isinstance(isr_content
, dict):
4760 'playlistVideoListRenderer': self
._playlist
_entries
,
4761 'gridRenderer': self
._grid
_entries
,
4762 'reelShelfRenderer': self
._grid
_entries
,
4763 'shelfRenderer': self
._shelf
_entries
,
4764 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4765 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4766 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4767 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4768 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4769 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)]
4771 for key
, renderer
in isr_content
.items():
4772 if key
not in known_renderers
:
4774 for entry
in known_renderers
[key
](renderer
):
4777 continuation_list
[0] = self
._extract
_continuation
(renderer
)
4780 if not continuation_list
[0]:
4781 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
4783 if not continuation_list
[0]:
4784 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4786 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
4787 continuation_list
= [None]
4788 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
4789 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
4793 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
4794 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
4795 yield from extract_entries(parent_renderer
)
4796 continuation
= continuation_list
[0]
4798 for page_num
in itertools
.count(1):
4799 if not continuation
:
4801 headers
= self
.generate_api_headers(
4802 ytcfg
=ytcfg
, account_syncid
=account_syncid
, visitor_data
=visitor_data
)
4803 response
= self
._extract
_response
(
4804 item_id
=f
'{item_id} page {page_num}',
4805 query
=continuation
, headers
=headers
, ytcfg
=ytcfg
,
4806 check_get_keys
=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4810 # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
4811 # See: https://github.com/ytdl-org/youtube-dl/issues/28702
4812 visitor_data
= self
._extract
_visitor
_data
(response
) or visitor_data
4815 'videoRenderer': (self
._grid
_entries
, 'items'), # for membership tab
4816 'gridPlaylistRenderer': (self
._grid
_entries
, 'items'),
4817 'gridVideoRenderer': (self
._grid
_entries
, 'items'),
4818 'gridChannelRenderer': (self
._grid
_entries
, 'items'),
4819 'playlistVideoRenderer': (self
._playlist
_entries
, 'contents'),
4820 'itemSectionRenderer': (extract_entries
, 'contents'), # for feeds
4821 'richItemRenderer': (extract_entries
, 'contents'), # for hashtag
4822 'backstagePostThreadRenderer': (self
._post
_thread
_continuation
_entries
, 'contents'),
4823 'reportHistoryTableRowRenderer': (self
._report
_history
_entries
, 'rows'),
4824 'playlistVideoListContinuation': (self
._playlist
_entries
, None),
4825 'gridContinuation': (self
._grid
_entries
, None),
4826 'itemSectionContinuation': (self
._post
_thread
_continuation
_entries
, None),
4827 'sectionListContinuation': (extract_entries
, None), # for feeds
4830 continuation_items
= traverse_obj(response
, (
4831 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
4832 'appendContinuationItemsAction', 'continuationItems'
4833 ), 'continuationContents', get_all
=False)
4834 continuation_item
= traverse_obj(continuation_items
, 0, None, expected_type
=dict, default
={})
4836 video_items_renderer
= None
4837 for key
in continuation_item
.keys():
4838 if key
not in known_renderers
:
4840 func
, parent_key
= known_renderers
[key
]
4841 video_items_renderer
= {parent_key: continuation_items}
if parent_key
else continuation_items
4842 continuation_list
= [None]
4843 yield from func(video_items_renderer
)
4844 continuation
= continuation_list
[0] or self
._extract
_continuation
(video_items_renderer
)
4846 if not video_items_renderer
:
4850 def _extract_selected_tab(tabs
, fatal
=True):
4851 for tab_renderer
in tabs
:
4852 if tab_renderer
.get('selected'):
4855 raise ExtractorError('Unable to find selected tab')
4858 def _extract_tab_renderers(response
):
4859 return traverse_obj(
4860 response
, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type
=dict)
4862 def _extract_from_tabs(self
, item_id
, ytcfg
, data
, tabs
):
4863 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
4865 selected_tab
= self
._extract
_selected
_tab
(tabs
)
4866 metadata
['title'] += format_field(selected_tab
, 'title', ' - %s')
4867 metadata
['title'] += format_field(selected_tab
, 'expandedText', ' - %s')
4869 return self
.playlist_result(
4871 selected_tab
, metadata
['id'], ytcfg
,
4872 self
._extract
_account
_syncid
(ytcfg
, data
),
4873 self
._extract
_visitor
_data
(data
, ytcfg
)),
4876 def _extract_metadata_from_tabs(self
, item_id
, data
):
4877 info
= {'id': item_id}
4879 metadata_renderer
= traverse_obj(data
, ('metadata', 'channelMetadataRenderer'), expected_type
=dict)
4880 if metadata_renderer
:
4881 channel_id
= traverse_obj(metadata_renderer
, ('externalId', {self.ucid_or_none}
),
4882 ('channelUrl', {self.ucid_from_url}
))
4884 'channel': metadata_renderer
.get('title'),
4885 'channel_id': channel_id
,
4887 if info
['channel_id']:
4888 info
['id'] = info
['channel_id']
4890 metadata_renderer
= traverse_obj(data
, ('metadata', 'playlistMetadataRenderer'), expected_type
=dict)
4892 # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
4893 # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
4894 def _get_uncropped(url
):
4895 return url_or_none((url
or '').split('=')[0] + '=s0')
4897 avatar_thumbnails
= self
._extract
_thumbnails
(metadata_renderer
, 'avatar')
4898 if avatar_thumbnails
:
4899 uncropped_avatar
= _get_uncropped(avatar_thumbnails
[0]['url'])
4900 if uncropped_avatar
:
4901 avatar_thumbnails
.append({
4902 'url': uncropped_avatar
,
4903 'id': 'avatar_uncropped',
4907 channel_banners
= self
._extract
_thumbnails
(
4908 data
, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
4909 for banner
in channel_banners
:
4910 banner
['preference'] = -10
4913 uncropped_banner
= _get_uncropped(channel_banners
[0]['url'])
4914 if uncropped_banner
:
4915 channel_banners
.append({
4916 'url': uncropped_banner
,
4917 'id': 'banner_uncropped',
4921 # Deprecated - remove primary_sidebar_renderer when layout discontinued
4922 primary_sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer')
4923 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer'), expected_type
=dict)
4925 primary_thumbnails
= self
._extract
_thumbnails
(
4926 primary_sidebar_renderer
, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
4927 playlist_thumbnails
= self
._extract
_thumbnails
(
4928 playlist_header_renderer
, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
4931 'title': (traverse_obj(metadata_renderer
, 'title')
4932 or self
._get
_text
(data
, ('header', 'hashtagHeaderRenderer', 'hashtag'))
4934 'availability': self
._extract
_availability
(data
),
4935 'channel_follower_count': self
._get
_count
(data
, ('header', ..., 'subscriberCountText')),
4936 'description': try_get(metadata_renderer
, lambda x
: x
.get('description', '')),
4937 'tags': try_get(metadata_renderer
or {}, lambda x
: x
.get('keywords', '').split()),
4938 'thumbnails': (primary_thumbnails
or playlist_thumbnails
) + avatar_thumbnails
+ channel_banners
,
4942 traverse_obj(metadata_renderer
, (('vanityChannelUrl', ('ownerUrls', ...)), {self.handle_from_url}
), get_all
=False)
4943 or traverse_obj(data
, ('header', ..., 'channelHandleText', {self.handle_or_none}
), get_all
=False))
4947 'uploader_id': channel_handle
,
4948 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4950 # Playlist stats is a text runs array containing [video count, view count, last updated].
4951 # last updated or (view count and last updated) may be missing.
4952 playlist_stats
= get_first(
4953 (primary_sidebar_renderer
, playlist_header_renderer
), (('stats', 'briefStats', 'numVideosText'), ))
4955 last_updated_unix
= self
._parse
_time
_text
(
4956 self
._get
_text
(playlist_stats
, 2) # deprecated, remove when old layout discontinued
4957 or self
._get
_text
(playlist_header_renderer
, ('byline', 1, 'playlistBylineRenderer', 'text')))
4958 info
['modified_date'] = strftime_or_none(last_updated_unix
, '%Y%m%d')
4960 info
['view_count'] = self
._get
_count
(playlist_stats
, 1)
4961 if info
['view_count'] is None: # 0 is allowed
4962 info
['view_count'] = self
._get
_count
(playlist_header_renderer
, 'viewCountText')
4963 if info
['view_count'] is None:
4964 info
['view_count'] = self
._get
_count
(data
, (
4965 'contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., 'tabRenderer', 'content', 'sectionListRenderer',
4966 'contents', ..., 'itemSectionRenderer', 'contents', ..., 'channelAboutFullMetadataRenderer', 'viewCountText'))
4968 info
['playlist_count'] = self
._get
_count
(playlist_stats
, 0)
4969 if info
['playlist_count'] is None: # 0 is allowed
4970 info
['playlist_count'] = self
._get
_count
(playlist_header_renderer
, ('byline', 0, 'playlistBylineRenderer', 'text'))
4972 if not info
.get('channel_id'):
4973 owner
= traverse_obj(playlist_header_renderer
, 'ownerText')
4974 if not owner
: # Deprecated
4975 owner
= traverse_obj(
4976 self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarSecondaryInfoRenderer'),
4977 ('videoOwner', 'videoOwnerRenderer', 'title'))
4978 owner_text
= self
._get
_text
(owner
)
4979 browse_ep
= traverse_obj(owner
, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
4981 'channel': self
._search
_regex
(r
'^by (.+) and \d+ others?$', owner_text
, 'uploader', default
=owner_text
),
4982 'channel_id': self
.ucid_or_none(browse_ep
.get('browseId')),
4983 'uploader_id': self
.handle_from_url(urljoin('https://www.youtube.com', browse_ep
.get('canonicalBaseUrl')))
4987 'uploader': info
['channel'],
4988 'channel_url': format_field(info
.get('channel_id'), None, 'https://www.youtube.com/channel/%s', default
=None),
4989 'uploader_url': format_field(info
.get('uploader_id'), None, 'https://www.youtube.com/%s', default
=None),
4994 def _extract_inline_playlist(self
, playlist
, playlist_id
, data
, ytcfg
):
4995 first_id
= last_id
= response
= None
4996 for page_num
in itertools
.count(1):
4997 videos
= list(self
._playlist
_entries
(playlist
))
5000 start
= next((i
for i
, v
in enumerate(videos
) if v
['id'] == last_id
), -1) + 1
5001 if start
>= len(videos
):
5003 yield from videos
[start
:]
5004 first_id
= first_id
or videos
[0]['id']
5005 last_id
= videos
[-1]['id']
5006 watch_endpoint
= try_get(
5007 playlist
, lambda x
: x
['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
5008 headers
= self
.generate_api_headers(
5009 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5010 visitor_data
=self
._extract
_visitor
_data
(response
, data
, ytcfg
))
5012 'playlistId': playlist_id
,
5013 'videoId': watch_endpoint
.get('videoId') or last_id
,
5014 'index': watch_endpoint
.get('index') or len(videos
),
5015 'params': watch_endpoint
.get('params') or 'OAE%3D'
5017 response
= self
._extract
_response
(
5018 item_id
='%s page %d' % (playlist_id
, page_num
),
5019 query
=query
, ep
='next', headers
=headers
, ytcfg
=ytcfg
,
5020 check_get_keys
='contents'
5023 response
, lambda x
: x
['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
5025 def _extract_from_playlist(self
, item_id
, url
, data
, playlist
, ytcfg
):
5026 title
= playlist
.get('title') or try_get(
5027 data
, lambda x
: x
['titleText']['simpleText'], str)
5028 playlist_id
= playlist
.get('playlistId') or item_id
5030 # Delegating everything except mix playlists to regular tab-based playlist URL
5031 playlist_url
= urljoin(url
, try_get(
5032 playlist
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
5035 # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
5036 # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
5037 is_known_unviewable
= re
.fullmatch(r
'MLCT|RLTD[\w-]{22}', playlist_id
)
5039 if playlist_url
and playlist_url
!= url
and not is_known_unviewable
:
5040 return self
.url_result(
5041 playlist_url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
5044 return self
.playlist_result(
5045 self
._extract
_inline
_playlist
(playlist
, playlist_id
, data
, ytcfg
),
5046 playlist_id
=playlist_id
, playlist_title
=title
)
5048 def _extract_availability(self
, data
):
5050 Gets the availability of a given playlist/tab.
5051 Note: Unless YouTube tells us explicitly, we do not assume it is public
5052 @param data: response
5054 sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer') or {}
5055 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer')) or {}
5056 player_header_privacy
= playlist_header_renderer
.get('privacy')
5058 badges
= self
._extract
_badges
(sidebar_renderer
)
5060 # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
5061 privacy_setting_icon
= get_first(
5062 (playlist_header_renderer
, sidebar_renderer
),
5063 ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
5064 lambda _
, v
: v
['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
5067 microformats_is_unlisted
= traverse_obj(
5068 data
, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type
=bool)
5072 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
5073 or player_header_privacy
== 'PUBLIC'
5074 or privacy_setting_icon
== 'PRIVACY_PUBLIC')
5075 else self
._availability
(
5077 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
5078 or player_header_privacy
== 'PRIVATE' if player_header_privacy
is not None
5079 else privacy_setting_icon
== 'PRIVACY_PRIVATE' if privacy_setting_icon
is not None else None),
5081 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
5082 or player_header_privacy
== 'UNLISTED' if player_header_privacy
is not None
5083 else privacy_setting_icon
== 'PRIVACY_UNLISTED' if privacy_setting_icon
is not None
5084 else microformats_is_unlisted
if microformats_is_unlisted
is not None else None),
5085 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
5086 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
5090 def _extract_sidebar_info_renderer(data
, info_renderer
, expected_type
=dict):
5091 sidebar_renderer
= try_get(
5092 data
, lambda x
: x
['sidebar']['playlistSidebarRenderer']['items'], list) or []
5093 for item
in sidebar_renderer
:
5094 renderer
= try_get(item
, lambda x
: x
[info_renderer
], expected_type
)
5098 def _reload_with_unavailable_videos(self
, item_id
, data
, ytcfg
):
5100 Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
5102 is_playlist
= bool(traverse_obj(
5103 data
, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
5106 headers
= self
.generate_api_headers(
5107 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5108 visitor_data
=self
._extract
_visitor
_data
(data
, ytcfg
))
5110 'params': 'wgYCCAA=',
5111 'browseId': f
'VL{item_id}'
5113 return self
._extract
_response
(
5114 item_id
=item_id
, headers
=headers
, query
=query
,
5115 check_get_keys
='contents', fatal
=False, ytcfg
=ytcfg
,
5116 note
='Redownloading playlist API JSON with unavailable videos')
5118 @functools.cached_property
5119 def skip_webpage(self
):
5120 return 'webpage' in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key())
5122 def _extract_webpage(self
, url
, item_id
, fatal
=True):
5123 webpage
, data
= None, None
5124 for retry
in self
.RetryManager(fatal
=fatal
):
5126 webpage
= self
._download
_webpage
(url
, item_id
, note
='Downloading webpage')
5127 data
= self
.extract_yt_initial_data(item_id
, webpage
or '', fatal
=fatal
) or {}
5128 except ExtractorError
as e
:
5129 if isinstance(e
.cause
, network_exceptions
):
5130 if not isinstance(e
.cause
, urllib
.error
.HTTPError
) or e
.cause
.code
not in (403, 429):
5133 self
._error
_or
_warning
(e
, fatal
=fatal
)
5137 self
._extract
_and
_report
_alerts
(data
)
5138 except ExtractorError
as e
:
5139 self
._error
_or
_warning
(e
, fatal
=fatal
)
5142 # Sometimes youtube returns a webpage with incomplete ytInitialData
5143 # See: https://github.com/yt-dlp/yt-dlp/issues/116
5144 if not traverse_obj(data
, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
5145 retry
.error
= ExtractorError('Incomplete yt initial data received')
5148 return webpage
, data
5150 def _report_playlist_authcheck(self
, ytcfg
, fatal
=True):
5151 """Use if failed to extract ytcfg (and data) from initial webpage"""
5152 if not ytcfg
and self
.is_authenticated
:
5153 msg
= 'Playlists that require authentication may not extract correctly without a successful webpage download'
5154 if 'authcheck' not in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key()) and fatal
:
5155 raise ExtractorError(
5156 f
'{msg}. If you are not downloading private content, or '
5157 'your cookies are only for the first account and channel,'
5158 ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
5160 self
.report_warning(msg
, only_once
=True)
5162 def _extract_data(self
, url
, item_id
, ytcfg
=None, fatal
=True, webpage_fatal
=False, default_client
='web'):
5164 if not self
.skip_webpage
:
5165 webpage
, data
= self
._extract
_webpage
(url
, item_id
, fatal
=webpage_fatal
)
5166 ytcfg
= ytcfg
or self
.extract_ytcfg(item_id
, webpage
)
5167 # Reject webpage data if redirected to home page without explicitly requesting
5168 selected_tab
= self
._extract
_selected
_tab
(self
._extract
_tab
_renderers
(data
), fatal
=False) or {}
5169 if (url
!= 'https://www.youtube.com/feed/recommended'
5170 and selected_tab
.get('tabIdentifier') == 'FEwhat_to_watch' # Home page
5171 and 'no-youtube-channel-redirect' not in self
.get_param('compat_opts', [])):
5172 msg
= 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
5174 raise ExtractorError(msg
, expected
=True)
5175 self
.report_warning(msg
, only_once
=True)
5177 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=fatal
)
5178 data
= self
._extract
_tab
_endpoint
(url
, item_id
, ytcfg
, fatal
=fatal
, default_client
=default_client
)
5181 def _extract_tab_endpoint(self
, url
, item_id
, ytcfg
=None, fatal
=True, default_client
='web'):
5182 headers
= self
.generate_api_headers(ytcfg
=ytcfg
, default_client
=default_client
)
5183 resolve_response
= self
._extract
_response
(
5184 item_id
=item_id
, query
={'url': url}
, check_get_keys
='endpoint', headers
=headers
, ytcfg
=ytcfg
, fatal
=fatal
,
5185 ep
='navigation/resolve_url', note
='Downloading API parameters API JSON', default_client
=default_client
)
5186 endpoints
= {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5187 for ep_key
, ep
in endpoints
.items():
5188 params
= try_get(resolve_response
, lambda x
: x
['endpoint'][ep_key
], dict)
5190 return self
._extract
_response
(
5191 item_id
=item_id
, query
=params
, ep
=ep
, headers
=headers
,
5192 ytcfg
=ytcfg
, fatal
=fatal
, default_client
=default_client
,
5193 check_get_keys
=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5194 err_note
= 'Failed to resolve url (does the playlist exist?)'
5196 raise ExtractorError(err_note
, expected
=True)
5197 self
.report_warning(err_note
, item_id
)
5199 _SEARCH_PARAMS
= None
5201 def _search_results(self
, query
, params
=NO_DEFAULT
, default_client
='web'):
5202 data
= {'query': query}
5203 if params
is NO_DEFAULT
:
5204 params
= self
._SEARCH
_PARAMS
5206 data
['params'] = params
5209 ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5210 ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5212 ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5213 ('continuationContents', ),
5215 display_id
= f
'query "{query}"'
5216 check_get_keys
= tuple({keys[0] for keys in content_keys}
)
5217 ytcfg
= self
._download
_ytcfg
(default_client
, display_id
) if not self
.skip_webpage
else {}
5218 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=False)
5220 continuation_list
= [None]
5222 for page_num
in itertools
.count(1):
5223 data
.update(continuation_list
[0] or {})
5224 headers
= self
.generate_api_headers(
5225 ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(search
), default_client
=default_client
)
5226 search
= self
._extract
_response
(
5227 item_id
=f
'{display_id} page {page_num}', ep
='search', query
=data
,
5228 default_client
=default_client
, check_get_keys
=check_get_keys
, ytcfg
=ytcfg
, headers
=headers
)
5229 slr_contents
= traverse_obj(search
, *content_keys
)
5230 yield from self
._extract
_entries
({'contents': list(variadic(slr_contents))}
, continuation_list
)
5231 if not continuation_list
[0]:
5235 class YoutubeTabIE(YoutubeTabBaseInfoExtractor
):
5236 IE_DESC
= 'YouTube Tabs'
5237 _VALID_URL
= r
'''(?x:
5239 (?!consent\.)(?:\w+\.)?
5241 youtube(?:kids)?\.com|
5245 (?P<channel_type>channel|c|user|browse)/|
5248 (?:playlist|watch)\?.*?\blist=
5250 (?!(?:%(reserved_names)s)\b) # Direct URLs
5254 'reserved_names': YoutubeBaseInfoExtractor
._RESERVED
_NAMES
,
5255 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
5257 IE_NAME
= 'youtube:tab'
5260 'note': 'playlists, multipage',
5261 'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5262 'playlist_mincount': 94,
5264 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5265 'title': 'Igor Kleiner - Playlists',
5266 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5267 'uploader': 'Igor Kleiner',
5268 'uploader_id': '@IgorDataScience',
5269 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5270 'channel': 'Igor Kleiner',
5271 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5272 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5273 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5274 'channel_follower_count': int
5277 'note': 'playlists, multipage, different order',
5278 'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5279 'playlist_mincount': 94,
5281 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5282 'title': 'Igor Kleiner - Playlists',
5283 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5284 'uploader': 'Igor Kleiner',
5285 'uploader_id': '@IgorDataScience',
5286 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5287 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5288 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5289 'channel': 'Igor Kleiner',
5290 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5291 'channel_follower_count': int
5294 'note': 'playlists, series',
5295 'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5296 'playlist_mincount': 5,
5298 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5299 'title': '3Blue1Brown - Playlists',
5300 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5301 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5302 'channel': '3Blue1Brown',
5303 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5304 'uploader_id': '@3blue1brown',
5305 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5306 'uploader': '3Blue1Brown',
5307 'tags': ['Mathematics'],
5308 'channel_follower_count': int
5311 'note': 'playlists, singlepage',
5312 'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5313 'playlist_mincount': 4,
5315 'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5316 'title': 'ThirstForScience - Playlists',
5317 'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5318 'uploader': 'ThirstForScience',
5319 'uploader_url': 'https://www.youtube.com/@ThirstForScience',
5320 'uploader_id': '@ThirstForScience',
5321 'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5322 'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5324 'channel': 'ThirstForScience',
5325 'channel_follower_count': int
5328 'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5329 'only_matching': True,
5331 'note': 'basic, single video playlist',
5332 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5334 'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5335 'title': 'youtube-dl public playlist',
5339 'modified_date': '20201130',
5340 'channel': 'Sergey M.',
5341 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5342 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5343 'availability': 'public',
5344 'uploader': 'Sergey M.',
5345 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5346 'uploader_id': '@sergeym.6173',
5348 'playlist_count': 1,
5350 'note': 'empty playlist',
5351 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5353 'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5354 'title': 'youtube-dl empty playlist',
5356 'channel': 'Sergey M.',
5358 'modified_date': '20160902',
5359 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5360 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5361 'availability': 'public',
5362 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5363 'uploader_id': '@sergeym.6173',
5364 'uploader': 'Sergey M.',
5366 'playlist_count': 0,
5369 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5371 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5372 'title': 'lex will - Home',
5373 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5374 'uploader': 'lex will',
5375 'uploader_id': '@lexwill718',
5376 'channel': 'lex will',
5377 'tags': ['bible', 'history', 'prophesy'],
5378 'uploader_url': 'https://www.youtube.com/@lexwill718',
5379 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5380 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5381 'channel_follower_count': int
5383 'playlist_mincount': 2,
5385 'note': 'Videos tab',
5386 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5388 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5389 'title': 'lex will - Videos',
5390 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5391 'uploader': 'lex will',
5392 'uploader_id': '@lexwill718',
5393 'tags': ['bible', 'history', 'prophesy'],
5394 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5395 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5396 'uploader_url': 'https://www.youtube.com/@lexwill718',
5397 'channel': 'lex will',
5398 'channel_follower_count': int
5400 'playlist_mincount': 975,
5402 'note': 'Videos tab, sorted by popular',
5403 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5405 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5406 'title': 'lex will - Videos',
5407 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5408 'uploader': 'lex will',
5409 'uploader_id': '@lexwill718',
5410 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5411 'uploader_url': 'https://www.youtube.com/@lexwill718',
5412 'channel': 'lex will',
5413 'tags': ['bible', 'history', 'prophesy'],
5414 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5415 'channel_follower_count': int
5417 'playlist_mincount': 199,
5419 'note': 'Playlists tab',
5420 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5422 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5423 'title': 'lex will - Playlists',
5424 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5425 'uploader': 'lex will',
5426 'uploader_id': '@lexwill718',
5427 'uploader_url': 'https://www.youtube.com/@lexwill718',
5428 'channel': 'lex will',
5429 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5430 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5431 'tags': ['bible', 'history', 'prophesy'],
5432 'channel_follower_count': int
5434 'playlist_mincount': 17,
5436 'note': 'Community tab',
5437 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5439 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5440 'title': 'lex will - Community',
5441 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5442 'channel': 'lex will',
5443 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5444 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5445 'tags': ['bible', 'history', 'prophesy'],
5446 'channel_follower_count': int,
5447 'uploader_url': 'https://www.youtube.com/@lexwill718',
5448 'uploader_id': '@lexwill718',
5449 'uploader': 'lex will',
5451 'playlist_mincount': 18,
5453 'note': 'Channels tab',
5454 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5456 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5457 'title': 'lex will - Channels',
5458 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5459 'channel': 'lex will',
5460 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5461 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5462 'tags': ['bible', 'history', 'prophesy'],
5463 'channel_follower_count': int,
5464 'uploader_url': 'https://www.youtube.com/@lexwill718',
5465 'uploader_id': '@lexwill718',
5466 'uploader': 'lex will',
5468 'playlist_mincount': 12,
5470 'note': 'Search tab',
5471 'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5472 'playlist_mincount': 40,
5474 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5475 'title': '3Blue1Brown - Search - linear algebra',
5476 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5477 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5478 'tags': ['Mathematics'],
5479 'channel': '3Blue1Brown',
5480 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5481 'channel_follower_count': int,
5482 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5483 'uploader_id': '@3blue1brown',
5484 'uploader': '3Blue1Brown',
5487 'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5488 'only_matching': True,
5490 'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5491 'only_matching': True,
5493 'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5494 'only_matching': True,
5496 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5497 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5499 'title': '29C3: Not my department',
5500 'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5501 'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5504 'modified_date': '20150605',
5505 'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5506 'channel_url': 'https://www.youtube.com/channel/UCEPzS1rYsrkqzSLNp76nrcg',
5507 'channel': 'Christiaan008',
5508 'availability': 'public',
5509 'uploader_id': '@ChRiStIaAn008',
5510 'uploader': 'Christiaan008',
5511 'uploader_url': 'https://www.youtube.com/@ChRiStIaAn008',
5513 'playlist_count': 96,
5515 'note': 'Large playlist',
5516 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5518 'title': 'Uploads from Cauchemar',
5519 'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5520 'channel_url': 'https://www.youtube.com/channel/UCBABnxM4Ar9ten8Mdjj1j0Q',
5522 'modified_date': r
're:\d{8}',
5523 'channel': 'Cauchemar',
5526 'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5527 'availability': 'public',
5528 'uploader_id': '@Cauchemar89',
5529 'uploader': 'Cauchemar',
5530 'uploader_url': 'https://www.youtube.com/@Cauchemar89',
5532 'playlist_mincount': 1123,
5533 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5535 'note': 'even larger playlist, 8832 videos',
5536 'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5537 'only_matching': True,
5539 'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5540 'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5542 'title': 'Uploads from Interstellar Movie',
5543 'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5546 'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5547 'channel_url': 'https://www.youtube.com/channel/UCXw-G3eDE9trcvY2sBMM_aA',
5548 'channel': 'Interstellar Movie',
5550 'modified_date': r
're:\d{8}',
5551 'availability': 'public',
5552 'uploader_id': '@InterstellarMovie',
5553 'uploader': 'Interstellar Movie',
5554 'uploader_url': 'https://www.youtube.com/@InterstellarMovie',
5556 'playlist_mincount': 21,
5558 'note': 'Playlist with "show unavailable videos" button',
5559 'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5561 'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5562 'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5564 'channel': 'Phim Siêu Nhân Nhật Bản',
5567 'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5568 'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5569 'modified_date': r
're:\d{8}',
5570 'availability': 'public',
5571 'uploader_url': 'https://www.youtube.com/@phimsieunhannhatban',
5572 'uploader_id': '@phimsieunhannhatban',
5573 'uploader': 'Phim Siêu Nhân Nhật Bản',
5575 'playlist_mincount': 200,
5576 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5578 'note': 'Playlist with unavailable videos in page 7',
5579 'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5581 'title': 'Uploads from BlankTV',
5582 'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5583 'channel': 'BlankTV',
5584 'channel_url': 'https://www.youtube.com/channel/UC8l9frL61Yl5KFOl87nIm2w',
5585 'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5588 'modified_date': r
're:\d{8}',
5590 'availability': 'public',
5591 'uploader_id': '@blanktv',
5592 'uploader': 'BlankTV',
5593 'uploader_url': 'https://www.youtube.com/@blanktv',
5595 'playlist_mincount': 1000,
5596 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5598 'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5599 'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5601 'title': 'Data Analysis with Dr Mike Pound',
5602 'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5603 'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5606 'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5607 'channel_url': 'https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA',
5608 'channel': 'Computerphile',
5609 'availability': 'public',
5610 'modified_date': '20190712',
5611 'uploader_id': '@Computerphile',
5612 'uploader': 'Computerphile',
5613 'uploader_url': 'https://www.youtube.com/@Computerphile',
5615 'playlist_mincount': 11,
5617 'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5618 'only_matching': True,
5620 'note': 'Playlist URL that does not actually serve a playlist',
5621 'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5623 'id': 'FqZTN594JQw',
5625 'title': "Smiley's People 01 detective, Adventure Series, Action",
5626 'upload_date': '20150526',
5627 'license': 'Standard YouTube License',
5628 'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5629 'categories': ['People & Blogs'],
5635 'skip_download': True,
5637 'skip': 'This video is not available.',
5638 'add_ie': [YoutubeIE
.ie_key()],
5640 'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5641 'only_matching': True,
5643 'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5644 'only_matching': True,
5646 'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5648 'id': 'AlTsmyW4auo', # This will keep changing
5651 'upload_date': r
're:\d{8}',
5653 'categories': ['News & Politics'],
5656 'release_timestamp': int,
5657 'channel': 'Sky News',
5658 'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5661 'thumbnail': r
're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5662 'playable_in_embed': True,
5663 'release_date': r
're:\d+',
5664 'availability': 'public',
5665 'live_status': 'is_live',
5666 'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5667 'channel_follower_count': int,
5668 'concurrent_view_count': int,
5669 'uploader_url': 'https://www.youtube.com/@SkyNews',
5670 'uploader_id': '@SkyNews',
5671 'uploader': 'Sky News',
5674 'skip_download': True,
5676 'expected_warnings': ['Ignoring subtitle tracks found in '],
5678 'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5680 'id': 'a48o2S1cPoo',
5682 'title': 'The Young Turks - Live Main Show',
5683 'upload_date': '20150715',
5684 'license': 'Standard YouTube License',
5685 'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5686 'categories': ['News & Politics'],
5687 'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5691 'skip_download': True,
5693 'only_matching': True,
5695 'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5696 'only_matching': True,
5698 'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5699 'only_matching': True,
5701 'note': 'A channel that is not live. Should raise error',
5702 'url': 'https://www.youtube.com/user/numberphile/live',
5703 'only_matching': True,
5705 'url': 'https://www.youtube.com/feed/trending',
5706 'only_matching': True,
5708 'url': 'https://www.youtube.com/feed/library',
5709 'only_matching': True,
5711 'url': 'https://www.youtube.com/feed/history',
5712 'only_matching': True,
5714 'url': 'https://www.youtube.com/feed/subscriptions',
5715 'only_matching': True,
5717 'url': 'https://www.youtube.com/feed/watch_later',
5718 'only_matching': True,
5720 'note': 'Recommended - redirects to home page.',
5721 'url': 'https://www.youtube.com/feed/recommended',
5722 'only_matching': True,
5724 'note': 'inline playlist with not always working continuations',
5725 'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5726 'only_matching': True,
5728 'url': 'https://www.youtube.com/course',
5729 'only_matching': True,
5731 'url': 'https://www.youtube.com/zsecurity',
5732 'only_matching': True,
5734 'url': 'http://www.youtube.com/NASAgovVideo/videos',
5735 'only_matching': True,
5737 'url': 'https://www.youtube.com/TheYoungTurks/live',
5738 'only_matching': True,
5740 'url': 'https://www.youtube.com/hashtag/cctv9',
5746 'playlist_mincount': 300, # not consistent but should be over 300
5748 'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
5749 'only_matching': True,
5751 'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
5752 'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5753 'only_matching': True
5755 'note': '/browse/ should redirect to /channel/',
5756 'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
5757 'only_matching': True
5759 'note': 'VLPL, should redirect to playlist?list=PL...',
5760 'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5762 'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5763 'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
5764 'title': 'NCS : All Releases 💿',
5765 'channel_url': 'https://www.youtube.com/channel/UC_aEa8K-EOJ3D6gOs7HcyNg',
5766 'modified_date': r
're:\d{8}',
5768 'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
5770 'channel': 'NoCopyrightSounds',
5771 'availability': 'public',
5772 'uploader_url': 'https://www.youtube.com/@NoCopyrightSounds',
5773 'uploader': 'NoCopyrightSounds',
5774 'uploader_id': '@NoCopyrightSounds',
5776 'playlist_mincount': 166,
5777 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden', 'YouTube Music is not directly supported'],
5779 # TODO: fix 'unviewable' issue with this playlist when reloading with unavailable videos
5780 'note': 'Topic, should redirect to playlist?list=UU...',
5781 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5783 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5784 'title': 'Uploads from Royalty Free Music - Topic',
5786 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5787 'channel': 'Royalty Free Music - Topic',
5789 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5790 'modified_date': r
're:\d{8}',
5792 'availability': 'public',
5793 'uploader': 'Royalty Free Music - Topic',
5795 'playlist_mincount': 101,
5796 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5798 # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
5799 # Treat as a general feed
5800 'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
5802 'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
5803 'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
5806 'playlist_mincount': 9,
5808 'note': 'Youtube music Album',
5809 'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
5811 'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
5812 'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
5816 'availability': 'unlisted',
5817 'modified_date': r
're:\d{8}',
5819 'playlist_count': 50,
5820 'expected_warnings': ['YouTube Music is not directly supported'],
5822 'note': 'unlisted single video playlist',
5823 'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5825 'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5826 'title': 'yt-dlp unlisted playlist test',
5827 'availability': 'unlisted',
5829 'modified_date': '20220418',
5830 'channel': 'colethedj',
5833 'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5834 'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5835 'uploader_url': 'https://www.youtube.com/@colethedj1894',
5836 'uploader_id': '@colethedj1894',
5837 'uploader': 'colethedj',
5839 'playlist_count': 1,
5841 'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
5842 'url': 'https://www.youtube.com/feed/recommended',
5844 'id': 'recommended',
5845 'title': 'recommended',
5848 'playlist_mincount': 50,
5850 'skip_download': True,
5851 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5854 'note': 'API Fallback: /videos tab, sorted by oldest first',
5855 'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
5857 'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5858 'title': 'Cody\'sLab - Videos',
5859 'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
5860 'channel': 'Cody\'sLab',
5861 'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5863 'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
5864 'channel_follower_count': int
5866 'playlist_mincount': 650,
5868 'skip_download': True,
5869 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5871 'skip': 'Query for sorting no longer works',
5873 'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
5874 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5876 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5877 'title': 'Uploads from Royalty Free Music - Topic',
5878 'modified_date': r
're:\d{8}',
5879 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5881 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5883 'channel': 'Royalty Free Music - Topic',
5885 'availability': 'public',
5886 'uploader': 'Royalty Free Music - Topic',
5888 'playlist_mincount': 101,
5890 'skip_download': True,
5891 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5893 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5895 'note': 'non-standard redirect to regional channel',
5896 'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
5897 'only_matching': True
5899 'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
5900 'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
5902 'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
5903 'modified_date': '20220407',
5904 'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
5906 'availability': 'unlisted',
5907 'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
5908 'channel': 'pukkandan',
5909 'description': 'Test for collaborative playlist',
5910 'title': 'yt-dlp test - collaborative playlist',
5912 'uploader_url': 'https://www.youtube.com/@pukkandan',
5913 'uploader_id': '@pukkandan',
5914 'uploader': 'pukkandan',
5916 'playlist_mincount': 2
5918 'note': 'translated tab name',
5919 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
5921 'id': 'UCiu-3thuViMebBjw_5nWYrA',
5923 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
5924 'description': 'test description',
5925 'title': 'cole-dlp-test-acc - 再生リスト',
5926 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
5927 'channel': 'cole-dlp-test-acc',
5928 'uploader_url': 'https://www.youtube.com/@coletdjnz',
5929 'uploader_id': '@coletdjnz',
5930 'uploader': 'cole-dlp-test-acc',
5932 'playlist_mincount': 1,
5933 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
5934 'expected_warnings': ['Preferring "ja"'],
5936 # XXX: this should really check flat playlist entries, but the test suite doesn't support that
5937 'note': 'preferred lang set with playlist with translated video titles',
5938 'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
5940 'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
5943 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
5944 'channel': 'cole-dlp-test-acc',
5945 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
5946 'description': 'test',
5947 'title': 'dlp test playlist',
5948 'availability': 'public',
5949 'uploader_url': 'https://www.youtube.com/@coletdjnz',
5950 'uploader_id': '@coletdjnz',
5951 'uploader': 'cole-dlp-test-acc',
5953 'playlist_mincount': 1,
5954 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
5955 'expected_warnings': ['Preferring "ja"'],
5957 # shorts audio pivot for 2GtVksBMYFM.
5958 'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
5960 'id': 'sfv_audio_pivot',
5961 'title': 'sfv_audio_pivot',
5964 'playlist_mincount': 50,
5967 # Channel with a real live tab (not to be mistaken with streams tab)
5968 # Do not treat like it should redirect to live stream
5969 'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
5971 'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
5972 'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
5975 'playlist_mincount': 20,
5977 # Tab name is not the same as tab id
5978 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
5980 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
5981 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
5984 'playlist_mincount': 8,
5986 # Home tab id is literally home. Not to get mistaken with featured
5987 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
5989 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
5990 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
5993 'playlist_mincount': 8,
5995 # Should get three playlists for videos, shorts and streams tabs
5996 'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
5998 'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
5999 'title': 'Polka Ch. 尾丸ポルカ',
6000 'channel_follower_count': int,
6001 'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6002 'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6003 'description': 'md5:e56b74b5bb7e9c701522162e9abfb822',
6004 'channel': 'Polka Ch. 尾丸ポルカ',
6006 'uploader_url': 'https://www.youtube.com/@OmaruPolka',
6007 'uploader': 'Polka Ch. 尾丸ポルカ',
6008 'uploader_id': '@OmaruPolka',
6010 'playlist_count': 3,
6012 # Shorts tab with channel with handle
6013 # TODO: fix channel description
6014 'url': 'https://www.youtube.com/@NotJustBikes/shorts',
6016 'id': 'UC0intLFzLaudFG-xAvUEO-A',
6017 'title': 'Not Just Bikes - Shorts',
6019 'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
6020 'description': 'md5:26bc55af26855a608a5cf89dfa595c8d',
6021 'channel_follower_count': int,
6022 'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
6023 'channel': 'Not Just Bikes',
6024 'uploader_url': 'https://www.youtube.com/@NotJustBikes',
6025 'uploader': 'Not Just Bikes',
6026 'uploader_id': '@NotJustBikes',
6028 'playlist_mincount': 10,
6031 'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
6033 'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6034 'title': '中村悠一 - Live',
6036 'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6037 'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
6039 'channel_follower_count': int,
6040 'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
6041 'uploader_url': 'https://www.youtube.com/@Yuichi-Nakamura',
6042 'uploader_id': '@Yuichi-Nakamura',
6045 'playlist_mincount': 60,
6047 # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
6048 # See test_youtube_lists
6049 'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
6050 'only_matching': True,
6052 # No uploads and no UCID given. Should fail with no uploads error
6053 # See test_youtube_lists
6054 'url': 'https://www.youtube.com/news',
6055 'only_matching': True
6057 # No videos tab but has a shorts tab
6058 'url': 'https://www.youtube.com/c/TKFShorts',
6060 'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6061 'title': 'Shorts Break - Shorts',
6063 'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6064 'channel': 'Shorts Break',
6065 'description': 'md5:6de33c5e7ba686e5f3efd4e19c7ef499',
6066 'channel_follower_count': int,
6067 'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
6068 'uploader_url': 'https://www.youtube.com/@ShortsBreak_Official',
6069 'uploader': 'Shorts Break',
6070 'uploader_id': '@ShortsBreak_Official',
6072 'playlist_mincount': 30,
6074 # Trending Now Tab. tab id is empty
6075 'url': 'https://www.youtube.com/feed/trending',
6078 'title': 'trending - Now',
6081 'playlist_mincount': 30,
6083 # Trending Gaming Tab. tab id is empty
6084 'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
6087 'title': 'trending - Gaming',
6090 'playlist_mincount': 30,
6092 # Shorts url result in shorts tab
6093 # TODO: Fix channel id extraction
6094 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
6096 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6097 'title': 'cole-dlp-test-acc - Shorts',
6098 'channel': 'cole-dlp-test-acc',
6099 'description': 'test description',
6100 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6101 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6103 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6104 'uploader_id': '@coletdjnz',
6105 'uploader': 'cole-dlp-test-acc',
6109 # Channel data is not currently available for short renderers (as of 2023-03-01)
6111 'ie_key': 'Youtube',
6112 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
6113 'id': 'sSM9J5YH_60',
6114 'title': 'SHORT short',
6119 'params': {'extract_flat': True}
,
6121 # Live video status should be extracted
6122 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
6124 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6125 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live', # TODO, should be Minecraft - Live or Minecraft - Topic - Live
6131 'ie_key': 'Youtube',
6132 'url': 'startswith:https://www.youtube.com/watch?v=',
6135 'live_status': 'is_live',
6138 'concurrent_view_count': int,
6142 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6143 'playlist_mincount': 1
6145 # Channel renderer metadata. Contains number of videos on the channel
6146 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/channels',
6148 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6149 'title': 'cole-dlp-test-acc - Channels',
6150 'channel': 'cole-dlp-test-acc',
6151 'description': 'test description',
6152 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6153 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6155 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6156 'uploader_id': '@coletdjnz',
6157 'uploader': 'cole-dlp-test-acc',
6162 'ie_key': 'YoutubeTab',
6163 'url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6164 'id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6165 'channel_id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6166 'title': 'PewDiePie',
6167 'channel': 'PewDiePie',
6168 'channel_url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6170 'channel_follower_count': int,
6171 'playlist_count': int,
6172 'uploader': 'PewDiePie',
6173 'uploader_url': 'https://www.youtube.com/@PewDiePie',
6174 'uploader_id': '@PewDiePie',
6177 'params': {'extract_flat': True}
,
6179 'url': 'https://www.youtube.com/@3blue1brown/about',
6181 'id': 'UCYO_jab_esuFRV4b17AJtAw',
6182 'tags': ['Mathematics'],
6183 'title': '3Blue1Brown - About',
6184 'channel_follower_count': int,
6185 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
6186 'channel': '3Blue1Brown',
6188 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
6189 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
6190 'uploader_url': 'https://www.youtube.com/@3blue1brown',
6191 'uploader_id': '@3blue1brown',
6192 'uploader': '3Blue1Brown',
6194 'playlist_count': 0,
6196 # Podcasts tab, with rich entry playlistRenderers
6197 'url': 'https://www.youtube.com/@99percentinvisiblepodcast/podcasts',
6199 'id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6200 'channel_id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6201 'uploader_url': 'https://www.youtube.com/@99percentinvisiblepodcast',
6202 'description': 'md5:3a0ed38f1ad42a68ef0428c04a15695c',
6203 'title': '99 Percent Invisible - Podcasts',
6204 'uploader': '99 Percent Invisible',
6205 'channel_follower_count': int,
6206 'channel_url': 'https://www.youtube.com/channel/UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6208 'channel': '99 Percent Invisible',
6209 'uploader_id': '@99percentinvisiblepodcast',
6211 'playlist_count': 1,
6213 # Releases tab, with rich entry playlistRenderers (same as Podcasts tab)
6214 'url': 'https://www.youtube.com/@AHimitsu/releases',
6216 'id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6217 'channel': 'A Himitsu',
6218 'uploader_url': 'https://www.youtube.com/@AHimitsu',
6219 'title': 'A Himitsu - Releases',
6220 'uploader_id': '@AHimitsu',
6221 'uploader': 'A Himitsu',
6222 'channel_id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6224 'description': 'I make music',
6225 'channel_url': 'https://www.youtube.com/channel/UCgFwu-j5-xNJml2FtTrrB3A',
6226 'channel_follower_count': int,
6228 'playlist_mincount': 10,
6232 def suitable(cls
, url
):
6233 return False if YoutubeIE
.suitable(url
) else super().suitable(url
)
6235 _URL_RE
= re
.compile(rf
'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
6237 def _get_url_mobj(self
, url
):
6238 mobj
= self
._URL
_RE
.match(url
).groupdict()
6239 mobj
.update((k
, '') for k
, v
in mobj
.items() if v
is None)
6242 def _extract_tab_id_and_name(self
, tab
, base_url
='https://www.youtube.com'):
6243 tab_name
= (tab
.get('title') or '').lower()
6244 tab_url
= urljoin(base_url
, traverse_obj(
6245 tab
, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
6247 tab_id
= (tab_url
and self
._get
_url
_mobj
(tab_url
)['tab'][1:]
6248 or traverse_obj(tab
, 'tabIdentifier', expected_type
=str))
6251 'TAB_ID_SPONSORSHIPS': 'membership',
6252 }.get(tab_id
, tab_id
), tab_name
6254 # Fallback to tab name if we cannot get the tab id.
6255 # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6256 # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6258 self
.write_debug(f
'Falling back to selected tab name: {tab_name}')
6262 }.get(tab_name
, tab_name
), tab_name
6264 def _has_tab(self
, tabs
, tab_id
):
6265 return any(self
._extract
_tab
_id
_and
_name
(tab
)[0] == tab_id
for tab
in tabs
)
6267 @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6268 def _real_extract(self
, url
, smuggled_data
):
6269 item_id
= self
._match
_id
(url
)
6270 url
= urllib
.parse
.urlunparse(
6271 urllib
.parse
.urlparse(url
)._replace
(netloc
='www.youtube.com'))
6272 compat_opts
= self
.get_param('compat_opts', [])
6274 mobj
= self
._get
_url
_mobj
(url
)
6275 pre
, tab
, post
, is_channel
= mobj
['pre'], mobj
['tab'], mobj
['post'], not mobj
['not_channel']
6276 if is_channel
and smuggled_data
.get('is_music_url'):
6277 if item_id
[:2] == 'VL': # Youtube music VL channels have an equivalent playlist
6278 return self
.url_result(
6279 f
'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE
, item_id
[2:])
6280 elif item_id
[:2] == 'MP': # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6281 mdata
= self
._extract
_tab
_endpoint
(
6282 f
'https://music.youtube.com/channel/{item_id}', item_id
, default_client
='web_music')
6283 murl
= traverse_obj(mdata
, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6284 get_all
=False, expected_type
=str)
6286 raise ExtractorError('Failed to resolve album to playlist')
6287 return self
.url_result(murl
, YoutubeTabIE
)
6288 elif mobj
['channel_type'] == 'browse': # Youtube music /browse/ should be changed to /channel/
6289 return self
.url_result(
6290 f
'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE
, item_id
)
6292 original_tab_id
, display_id
= tab
[1:], f
'{item_id}{tab}'
6293 if is_channel
and not tab
and 'no-youtube-channel-redirect' not in compat_opts
:
6294 url
= f
'{pre}/videos{post}'
6295 if smuggled_data
.get('is_music_url'):
6296 self
.report_warning(f
'YouTube Music is not directly supported. Redirecting to {url}')
6298 # Handle both video/playlist URLs
6300 video_id
, playlist_id
= [traverse_obj(qs
, (key
, 0)) for key
in ('v', 'list')]
6301 if not video_id
and mobj
['not_channel'].startswith('watch'):
6303 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6304 raise ExtractorError('A video URL was given without video ID', expected
=True)
6305 # Common mistake: https://www.youtube.com/watch?list=playlist_id
6306 self
.report_warning(f
'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6307 return self
.url_result(
6308 f
'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE
, playlist_id
)
6310 if not self
._yes
_playlist
(playlist_id
, video_id
):
6311 return self
.url_result(
6312 f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6314 data
, ytcfg
= self
._extract
_data
(url
, display_id
)
6316 # YouTube may provide a non-standard redirect to the regional channel
6317 # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6318 # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6319 redirect_url
= traverse_obj(
6320 data
, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all
=False)
6321 if redirect_url
and 'no-youtube-channel-redirect' not in compat_opts
:
6322 redirect_url
= ''.join((urljoin('https://www.youtube.com', redirect_url
), tab
, post
))
6323 self
.to_screen(f
'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6324 return self
.url_result(redirect_url
, YoutubeTabIE
)
6326 tabs
, extra_tabs
= self
._extract
_tab
_renderers
(data
), []
6327 if is_channel
and tabs
and 'no-youtube-channel-redirect' not in compat_opts
:
6328 selected_tab
= self
._extract
_selected
_tab
(tabs
)
6329 selected_tab_id
, selected_tab_name
= self
._extract
_tab
_id
_and
_name
(selected_tab
, url
) # NB: Name may be translated
6330 self
.write_debug(f
'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6332 if not original_tab_id
and selected_tab_name
:
6333 self
.to_screen('Downloading all uploads of the channel. '
6334 'To download only the videos in a specific tab, pass the tab\'s URL')
6335 if self
._has
_tab
(tabs
, 'streams'):
6336 extra_tabs
.append(''.join((pre
, '/streams', post
)))
6337 if self
._has
_tab
(tabs
, 'shorts'):
6338 extra_tabs
.append(''.join((pre
, '/shorts', post
)))
6339 # XXX: Members-only tab should also be extracted
6341 if not extra_tabs
and selected_tab_id
!= 'videos':
6342 # Channel does not have streams, shorts or videos tabs
6343 if item_id
[:2] != 'UC':
6344 raise ExtractorError('This channel has no uploads', expected
=True)
6346 # Topic channels don't have /videos. Use the equivalent playlist instead
6347 pl_id
= f
'UU{item_id[2:]}'
6348 pl_url
= f
'https://www.youtube.com/playlist?list={pl_id}'
6350 data
, ytcfg
= self
._extract
_data
(pl_url
, pl_id
, ytcfg
=ytcfg
, fatal
=True, webpage_fatal
=True)
6351 except ExtractorError
:
6352 raise ExtractorError('This channel has no uploads', expected
=True)
6354 item_id
, url
= pl_id
, pl_url
6356 f
'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6358 elif extra_tabs
and selected_tab_id
!= 'videos':
6359 # When there are shorts/live tabs but not videos tab
6360 url
, data
= f
'{pre}{post}', None
6362 elif (original_tab_id
or 'videos') != selected_tab_id
:
6363 if original_tab_id
== 'live':
6364 # Live tab should have redirected to the video
6365 # Except in the case the channel has an actual live tab
6366 # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6367 raise UserNotLive(video_id
=item_id
)
6368 elif selected_tab_name
:
6369 raise ExtractorError(f
'This channel does not have a {original_tab_id} tab', expected
=True)
6371 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6372 url
= f
'{pre}{post}'
6374 # YouTube sometimes provides a button to reload playlist with unavailable videos.
6375 if 'no-youtube-unavailable-videos' not in compat_opts
:
6376 data
= self
._reload
_with
_unavailable
_videos
(display_id
, data
, ytcfg
) or data
6377 self
._extract
_and
_report
_alerts
(data
, only_once
=True)
6379 tabs
, entries
= self
._extract
_tab
_renderers
(data
), []
6381 entries
= [self
._extract
_from
_tabs
(item_id
, ytcfg
, data
, tabs
)]
6383 'extractor_key': YoutubeTabIE
.ie_key(),
6384 'extractor': YoutubeTabIE
.IE_NAME
,
6387 if self
.get_param('playlist_items') == '0':
6388 entries
.extend(self
.url_result(u
, YoutubeTabIE
) for u
in extra_tabs
)
6389 else: # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6390 entries
.extend(map(self
._real
_extract
, extra_tabs
))
6392 if len(entries
) == 1:
6395 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
6396 uploads_url
= 'the Uploads (UU) playlist URL'
6397 if try_get(metadata
, lambda x
: x
['channel_id'].startswith('UC')):
6398 uploads_url
= f
'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6400 'Downloading as multiple playlists, separated by tabs. '
6401 f
'To download as a single playlist instead, pass {uploads_url}')
6402 return self
.playlist_result(entries
, item_id
, **metadata
)
6405 playlist
= traverse_obj(
6406 data
, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type
=dict)
6408 return self
._extract
_from
_playlist
(item_id
, url
, data
, playlist
, ytcfg
)
6410 video_id
= traverse_obj(
6411 data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str) or video_id
6413 if tab
!= '/live': # live tab is expected to redirect to video
6414 self
.report_warning(f
'Unable to recognize playlist. Downloading just video {video_id}')
6415 return self
.url_result(f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6417 raise ExtractorError('Unable to recognize tab page')
6420 class YoutubePlaylistIE(InfoExtractor
):
6421 IE_DESC
= 'YouTube playlists'
6422 _VALID_URL
= r
'''(?x)(?:
6427 youtube(?:kids)?\.com|
6432 (?P<id>%(playlist_id)s)
6434 'playlist_id': YoutubeBaseInfoExtractor
._PLAYLIST
_ID
_RE
,
6435 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
6437 IE_NAME
= 'youtube:playlist'
6439 'note': 'issue #673',
6440 'url': 'PLBB231211A4F62143',
6442 'title': '[OLD]Team Fortress 2 (Class-based LP)',
6443 'id': 'PLBB231211A4F62143',
6444 'uploader': 'Wickman',
6445 'uploader_id': '@WickmanVT',
6446 'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6448 'uploader_url': 'https://www.youtube.com/@WickmanVT',
6449 'modified_date': r
're:\d{8}',
6450 'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6451 'channel': 'Wickman',
6453 'channel_url': 'https://www.youtube.com/channel/UCKSpbfbl5kRQpTdL7kMc-1Q',
6454 'availability': 'public',
6456 'playlist_mincount': 29,
6458 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6460 'title': 'YDL_safe_search',
6461 'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6463 'playlist_count': 2,
6464 'skip': 'This playlist is private',
6467 'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6468 'playlist_count': 4,
6471 'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6472 'uploader': 'milan',
6473 'uploader_id': '@milan5503',
6475 'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6477 'modified_date': '20140919',
6480 'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6481 'uploader_url': 'https://www.youtube.com/@milan5503',
6482 'availability': 'public',
6484 'expected_warnings': [r
'[Uu]navailable videos? (is|are|will be) hidden'],
6486 'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6487 'playlist_mincount': 455,
6489 'title': '2018 Chinese New Singles (11/6 updated)',
6490 'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6492 'uploader_id': '@music_king',
6493 'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6496 'channel_url': 'https://www.youtube.com/channel/UC21nz3_MesPLqtDqwdvnoxA',
6498 'uploader_url': 'https://www.youtube.com/@music_king',
6499 'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6500 'modified_date': r
're:\d{8}',
6501 'availability': 'public',
6503 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6505 'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6506 'only_matching': True,
6508 # music album playlist
6509 'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6510 'only_matching': True,
6514 def suitable(cls
, url
):
6515 if YoutubeTabIE
.suitable(url
):
6517 from ..utils
import parse_qs
6519 if qs
.get('v', [None])[0]:
6521 return super().suitable(url
)
6523 def _real_extract(self
, url
):
6524 playlist_id
= self
._match
_id
(url
)
6525 is_music_url
= YoutubeBaseInfoExtractor
.is_music_url(url
)
6526 url
= update_url_query(
6527 'https://www.youtube.com/playlist',
6528 parse_qs(url
) or {'list': playlist_id}
)
6530 url
= smuggle_url(url
, {'is_music_url': True}
)
6531 return self
.url_result(url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6534 class YoutubeYtBeIE(InfoExtractor
):
6535 IE_DESC
= 'youtu.be'
6536 _VALID_URL
= r
'https?://youtu\.be/(?P<id>[0-9A-Za-z_-]{11})/*?.*?\blist=(?P<playlist_id>%(playlist_id)s)' % {'playlist_id': YoutubeBaseInfoExtractor._PLAYLIST_ID_RE}
6538 'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6540 'id': 'yeWKywCrFtk',
6542 'title': 'Small Scale Baler and Braiding Rugs',
6543 'uploader': 'Backus-Page House Museum',
6544 'uploader_id': '@backuspagemuseum',
6545 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/@backuspagemuseum',
6546 'upload_date': '20161008',
6547 'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6548 'categories': ['Nonprofits & Activism'],
6552 'playable_in_embed': True,
6553 'thumbnail': r
're:^https?://.*\.webp',
6554 'channel': 'Backus-Page House Museum',
6555 'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6556 'live_status': 'not_live',
6558 'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6559 'availability': 'public',
6561 'comment_count': int,
6562 'channel_follower_count': int
6566 'skip_download': True,
6569 'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6570 'only_matching': True,
6573 def _real_extract(self
, url
):
6574 mobj
= self
._match
_valid
_url
(url
)
6575 video_id
= mobj
.group('id')
6576 playlist_id
= mobj
.group('playlist_id')
6577 return self
.url_result(
6578 update_url_query('https://www.youtube.com/watch', {
6580 'list': playlist_id
,
6581 'feature': 'youtu.be',
6582 }), ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6585 class YoutubeLivestreamEmbedIE(InfoExtractor
):
6586 IE_DESC
= 'YouTube livestream embeds'
6587 _VALID_URL
= r
'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6589 'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6590 'only_matching': True,
6593 def _real_extract(self
, url
):
6594 channel_id
= self
._match
_id
(url
)
6595 return self
.url_result(
6596 f
'https://www.youtube.com/channel/{channel_id}/live',
6597 ie
=YoutubeTabIE
.ie_key(), video_id
=channel_id
)
6600 class YoutubeYtUserIE(InfoExtractor
):
6601 IE_DESC
= 'YouTube user videos; "ytuser:" prefix'
6602 IE_NAME
= 'youtube:user'
6603 _VALID_URL
= r
'ytuser:(?P<id>.+)'
6605 'url': 'ytuser:phihag',
6606 'only_matching': True,
6609 def _real_extract(self
, url
):
6610 user_id
= self
._match
_id
(url
)
6611 return self
.url_result(f
'https://www.youtube.com/user/{user_id}', YoutubeTabIE
, user_id
)
6614 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor
):
6615 IE_NAME
= 'youtube:favorites'
6616 IE_DESC
= 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6617 _VALID_URL
= r
':ytfav(?:ou?rite)?s?'
6618 _LOGIN_REQUIRED
= True
6621 'only_matching': True,
6623 'url': ':ytfavorites',
6624 'only_matching': True,
6627 def _real_extract(self
, url
):
6628 return self
.url_result(
6629 'https://www.youtube.com/playlist?list=LL',
6630 ie
=YoutubeTabIE
.ie_key())
6633 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor
):
6634 IE_NAME
= 'youtube:notif'
6635 IE_DESC
= 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6636 _VALID_URL
= r
':ytnotif(?:ication)?s?'
6637 _LOGIN_REQUIRED
= True
6640 'only_matching': True,
6642 'url': ':ytnotifications',
6643 'only_matching': True,
6646 def _extract_notification_menu(self
, response
, continuation_list
):
6647 notification_list
= traverse_obj(
6649 ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6650 ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6651 expected_type
=list) or []
6652 continuation_list
[0] = None
6653 for item
in notification_list
:
6654 entry
= self
._extract
_notification
_renderer
(item
.get('notificationRenderer'))
6657 continuation
= item
.get('continuationItemRenderer')
6659 continuation_list
[0] = continuation
6661 def _extract_notification_renderer(self
, notification
):
6662 video_id
= traverse_obj(
6663 notification
, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str)
6664 url
= f
'https://www.youtube.com/watch?v={video_id}'
6667 browse_ep
= traverse_obj(
6668 notification
, ('navigationEndpoint', 'browseEndpoint'), expected_type
=dict)
6669 channel_id
= self
.ucid_or_none(traverse_obj(browse_ep
, 'browseId', expected_type
=str))
6670 post_id
= self
._search
_regex
(
6671 r
'/post/(.+)', traverse_obj(browse_ep
, 'canonicalBaseUrl', expected_type
=str),
6672 'post id', default
=None)
6673 if not channel_id
or not post_id
:
6675 # The direct /post url redirects to this in the browser
6676 url
= f
'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
6678 channel
= traverse_obj(
6679 notification
, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
6681 notification_title
= self
._get
_text
(notification
, 'shortMessage')
6682 if notification_title
:
6683 notification_title
= notification_title
.replace('\xad', '') # remove soft hyphens
6684 # TODO: handle recommended videos
6685 title
= self
._search
_regex
(
6686 rf
'{re.escape(channel or "")}[^:]+: (.+)', notification_title
,
6687 'video title', default
=None)
6688 timestamp
= (self
._parse
_time
_text
(self
._get
_text
(notification
, 'sentTimeText'))
6689 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
6694 'ie_key': (YoutubeIE
if video_id
else YoutubeTabIE
).ie_key(),
6695 'video_id': video_id
,
6697 'channel_id': channel_id
,
6699 'uploader': channel
,
6700 'thumbnails': self
._extract
_thumbnails
(notification
, 'videoThumbnail'),
6701 'timestamp': timestamp
,
6704 def _notification_menu_entries(self
, ytcfg
):
6705 continuation_list
= [None]
6707 for page
in itertools
.count(1):
6708 ctoken
= traverse_obj(
6709 continuation_list
, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type
=str)
6710 response
= self
._extract
_response
(
6711 item_id
=f
'page {page}', query
={'ctoken': ctoken}
if ctoken
else {}, ytcfg
=ytcfg
,
6712 ep
='notification/get_notification_menu', check_get_keys
='actions',
6713 headers
=self
.generate_api_headers(ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(response
)))
6714 yield from self
._extract
_notification
_menu
(response
, continuation_list
)
6715 if not continuation_list
[0]:
6718 def _real_extract(self
, url
):
6719 display_id
= 'notifications'
6720 ytcfg
= self
._download
_ytcfg
('web', display_id
) if not self
.skip_webpage
else {}
6721 self
._report
_playlist
_authcheck
(ytcfg
)
6722 return self
.playlist_result(self
._notification
_menu
_entries
(ytcfg
), display_id
, display_id
)
6725 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6726 IE_DESC
= 'YouTube search'
6727 IE_NAME
= 'youtube:search'
6728 _SEARCH_KEY
= 'ytsearch'
6729 _SEARCH_PARAMS
= 'EgIQAQ%3D%3D' # Videos only
6731 'url': 'ytsearch5:youtube-dl test video',
6732 'playlist_count': 5,
6734 'id': 'youtube-dl test video',
6735 'title': 'youtube-dl test video',
6740 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6741 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ ':date'
6742 _SEARCH_KEY
= 'ytsearchdate'
6743 IE_DESC
= 'YouTube search, newest videos first'
6744 _SEARCH_PARAMS
= 'CAISAhAB' # Videos only, sorted by date
6746 'url': 'ytsearchdate5:youtube-dl test video',
6747 'playlist_count': 5,
6749 'id': 'youtube-dl test video',
6750 'title': 'youtube-dl test video',
6755 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor
):
6756 IE_DESC
= 'YouTube search URLs with sorting and filter support'
6757 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ '_url'
6758 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6760 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
6761 'playlist_mincount': 5,
6763 'id': 'youtube-dl test video',
6764 'title': 'youtube-dl test video',
6767 'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
6768 'playlist_mincount': 5,
6774 'url': 'https://www.youtube.com/results?search_query=%23cats',
6775 'playlist_mincount': 1,
6779 # The test suite does not have support for nested playlists
6781 # 'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
6787 'url': 'https://www.youtube.com/results?search_query=kurzgesagt&sp=EgIQAg%253D%253D',
6790 'title': 'kurzgesagt',
6795 'id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6796 'url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6797 'ie_key': 'YoutubeTab',
6798 'channel': 'Kurzgesagt – In a Nutshell',
6799 'description': 'md5:4ae48dfa9505ffc307dad26342d06bfc',
6800 'title': 'Kurzgesagt – In a Nutshell',
6801 'channel_id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6802 'playlist_count': int, # XXX: should have a way of saying > 1
6803 'channel_url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6805 'uploader_id': '@kurzgesagt',
6806 'uploader_url': 'https://www.youtube.com/@kurzgesagt',
6807 'uploader': 'Kurzgesagt – In a Nutshell',
6810 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6811 'playlist_mincount': 1,
6813 'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
6814 'only_matching': True,
6817 def _real_extract(self
, url
):
6819 query
= (qs
.get('search_query') or qs
.get('q'))[0]
6820 return self
.playlist_result(self
._search
_results
(query
, qs
.get('sp', (None,))[0]), query
, query
)
6823 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor
):
6824 IE_DESC
= 'YouTube music search URLs with selectable sections, e.g. #songs'
6825 IE_NAME
= 'youtube:music:search_url'
6826 _VALID_URL
= r
'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6828 'url': 'https://music.youtube.com/search?q=royalty+free+music',
6829 'playlist_count': 16,
6831 'id': 'royalty free music',
6832 'title': 'royalty free music',
6835 'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
6836 'playlist_mincount': 30,
6838 'id': 'royalty free music - songs',
6839 'title': 'royalty free music - songs',
6841 'params': {'extract_flat': 'in_playlist'}
6843 'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
6844 'playlist_mincount': 30,
6846 'id': 'royalty free music - community playlists',
6847 'title': 'royalty free music - community playlists',
6849 'params': {'extract_flat': 'in_playlist'}
6853 'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
6854 'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
6855 'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
6856 'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
6857 'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
6858 'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
6861 def _real_extract(self
, url
):
6863 query
= (qs
.get('search_query') or qs
.get('q'))[0]
6864 params
= qs
.get('sp', (None,))[0]
6866 section
= next((k
for k
, v
in self
._SECTIONS
.items() if v
== params
), params
)
6868 section
= urllib
.parse
.unquote_plus((url
.split('#') + [''])[1]).lower()
6869 params
= self
._SECTIONS
.get(section
)
6872 title
= join_nonempty(query
, section
, delim
=' - ')
6873 return self
.playlist_result(self
._search
_results
(query
, params
, default_client
='web_music'), title
, title
)
6876 class YoutubeFeedsInfoExtractor(InfoExtractor
):
6878 Base class for feed extractors
6879 Subclasses must re-define the _FEED_NAME property.
6881 _LOGIN_REQUIRED
= True
6882 _FEED_NAME
= 'feeds'
6884 def _real_initialize(self
):
6885 YoutubeBaseInfoExtractor
._check
_login
_required
(self
)
6889 return f
'youtube:{self._FEED_NAME}'
6891 def _real_extract(self
, url
):
6892 return self
.url_result(
6893 f
'https://www.youtube.com/feed/{self._FEED_NAME}', ie
=YoutubeTabIE
.ie_key())
6896 class YoutubeWatchLaterIE(InfoExtractor
):
6897 IE_NAME
= 'youtube:watchlater'
6898 IE_DESC
= 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
6899 _VALID_URL
= r
':ytwatchlater'
6901 'url': ':ytwatchlater',
6902 'only_matching': True,
6905 def _real_extract(self
, url
):
6906 return self
.url_result(
6907 'https://www.youtube.com/playlist?list=WL', ie
=YoutubeTabIE
.ie_key())
6910 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor
):
6911 IE_DESC
= 'YouTube recommended videos; ":ytrec" keyword'
6912 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
6913 _FEED_NAME
= 'recommended'
6914 _LOGIN_REQUIRED
= False
6917 'only_matching': True,
6919 'url': ':ytrecommended',
6920 'only_matching': True,
6922 'url': 'https://youtube.com',
6923 'only_matching': True,
6927 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor
):
6928 IE_DESC
= 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
6929 _VALID_URL
= r
':ytsub(?:scription)?s?'
6930 _FEED_NAME
= 'subscriptions'
6933 'only_matching': True,
6935 'url': ':ytsubscriptions',
6936 'only_matching': True,
6940 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor
):
6941 IE_DESC
= 'Youtube watch history; ":ythis" keyword (requires cookies)'
6942 _VALID_URL
= r
':ythis(?:tory)?'
6943 _FEED_NAME
= 'history'
6945 'url': ':ythistory',
6946 'only_matching': True,
6950 class YoutubeStoriesIE(InfoExtractor
):
6951 IE_DESC
= 'YouTube channel stories; "ytstories:" prefix'
6952 IE_NAME
= 'youtube:stories'
6953 _VALID_URL
= r
'ytstories:UC(?P<id>[A-Za-z0-9_-]{21}[AQgw])$'
6955 'url': 'ytstories:UCwFCb4jeqaKWnciAYM-ZVHg',
6956 'only_matching': True,
6959 def _real_extract(self
, url
):
6960 playlist_id
= f
'RLTD{self._match_id(url)}'
6961 return self
.url_result(
6962 smuggle_url(f
'https://www.youtube.com/playlist?list={playlist_id}&playnext=1', {'is_story': True}
),
6963 ie
=YoutubeTabIE
, video_id
=playlist_id
)
6966 class YoutubeShortsAudioPivotIE(InfoExtractor
):
6967 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
6968 IE_NAME
= 'youtube:shorts:pivot:audio'
6969 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
6971 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
6972 'only_matching': True,
6976 def _generate_audio_pivot_params(video_id
):
6978 Generates sfv_audio_pivot browse params for this video id
6980 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
6981 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
6983 def _real_extract(self
, url
):
6984 video_id
= self
._match
_id
(url
)
6985 return self
.url_result(
6986 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
6990 class YoutubeTruncatedURLIE(InfoExtractor
):
6991 IE_NAME
= 'youtube:truncated_url'
6992 IE_DESC
= False # Do not list
6993 _VALID_URL
= r
'''(?x)
6995 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
6998 annotation_id=annotation_[^&]+|
7004 attribution_link\?a=[^&]+
7010 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
7011 'only_matching': True,
7013 'url': 'https://www.youtube.com/watch?',
7014 'only_matching': True,
7016 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
7017 'only_matching': True,
7019 'url': 'https://www.youtube.com/watch?feature=foo',
7020 'only_matching': True,
7022 'url': 'https://www.youtube.com/watch?hl=en-GB',
7023 'only_matching': True,
7025 'url': 'https://www.youtube.com/watch?t=2372',
7026 'only_matching': True,
7029 def _real_extract(self
, url
):
7030 raise ExtractorError(
7031 'Did you forget to quote the URL? Remember that & is a meta '
7032 'character in most shells, so you want to put the URL in quotes, '
7034 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
7035 ' or simply youtube-dl BaW_jenozKc .',
7039 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
7040 IE_NAME
= 'youtube:clip'
7041 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7043 # FIXME: Other metadata should be extracted from the clip, not from the base video
7044 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7046 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7048 'section_start': 29.0,
7049 'section_end': 39.7,
7052 'availability': 'public',
7053 'categories': ['Gaming'],
7054 'channel': 'Scott The Woz',
7055 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7056 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7057 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7059 'playable_in_embed': True,
7061 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7062 'title': 'Mobile Games on Console - Scott The Woz',
7063 'upload_date': '20210920',
7064 'uploader': 'Scott The Woz',
7065 'uploader_id': '@ScottTheWoz',
7066 'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7068 'live_status': 'not_live',
7069 'channel_follower_count': int,
7070 'chapters': 'count:20',
7074 def _real_extract(self
, url
):
7075 clip_id
= self
._match
_id
(url
)
7076 _
, data
= self
._extract
_webpage
(url
, clip_id
)
7078 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7080 raise ExtractorError('Unable to find video ID')
7082 clip_data
= traverse_obj(data
, (
7083 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7084 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7085 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7086 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
7089 '_type': 'url_transparent',
7090 'url': f
'https://www.youtube.com/watch?v={video_id}',
7091 'ie_key': YoutubeIE
.ie_key(),
7093 'section_start': int(clip_data
['startTimeMs']) / 1000,
7094 'section_end': int(clip_data
['endTimeMs']) / 1000,
7098 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor
):
7099 IE_NAME
= 'youtube:consent'
7100 IE_DESC
= False # Do not list
7101 _VALID_URL
= r
'https?://consent\.youtube\.com/m\?'
7103 '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',
7105 'id': 'qVv6vCqciTM',
7108 'uploader_id': '@sana_natori',
7109 'comment_count': int,
7110 'chapters': 'count:13',
7111 'upload_date': '20221223',
7112 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7113 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7114 'uploader_url': 'https://www.youtube.com/@sana_natori',
7116 'release_date': '20221223',
7117 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7118 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7120 'playable_in_embed': True,
7122 'availability': 'public',
7123 'channel_follower_count': int,
7124 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7125 'categories': ['Entertainment'],
7126 'live_status': 'was_live',
7127 'release_timestamp': 1671793345,
7128 'channel': 'さなちゃんねる',
7129 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7130 'uploader': 'さなちゃんねる',
7132 'add_ie': ['Youtube'],
7133 'params': {'skip_download': 'Youtube'}
,
7136 def _real_extract(self
, url
):
7137 redirect_url
= url_or_none(parse_qs(url
).get('continue', [None])[-1])
7138 if not redirect_url
:
7139 raise ExtractorError('Invalid cookie consent redirect URL', expected
=True)
7140 return self
.url_result(redirect_url
)
7143 class YoutubeTruncatedIDIE(InfoExtractor
):
7144 IE_NAME
= 'youtube:truncated_id'
7145 IE_DESC
= False # Do not list
7146 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7149 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7150 'only_matching': True,
7153 def _real_extract(self
, url
):
7154 video_id
= self
._match
_id
(url
)
7155 raise ExtractorError(
7156 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',