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()
295 VERIFIED
= enum
.auto()
298 class YoutubeBaseInfoExtractor(InfoExtractor
):
299 """Provide base functions for Youtube extractors"""
302 r
'channel|c|user|playlist|watch|w|v|embed|e|live|watch_popup|clip|'
303 r
'shorts|movies|results|search|shared|hashtag|trending|explore|feed|feeds|'
304 r
'browse|oembed|get_video_info|iframe_api|s/player|source|'
305 r
'storefront|oops|index|account|t/terms|about|upload|signin|logout')
307 _PLAYLIST_ID_RE
= r
'(?:(?:PL|LL|EC|UU|FL|RD|UL|TL|PU|OLAK5uy_)[0-9A-Za-z-_]{10,}|RDMM|WL|LL|LM)'
309 # _NETRC_MACHINE = 'youtube'
311 # If True it will raise an error if no login info is provided
312 _LOGIN_REQUIRED
= False
315 # invidious-redirect websites
316 r
'(?:www\.)?redirect\.invidious\.io',
317 r
'(?:(?:www|dev)\.)?invidio\.us',
318 # Invidious instances taken from https://github.com/iv-org/documentation/blob/master/docs/instances.md
319 r
'(?:www\.)?invidious\.pussthecat\.org',
320 r
'(?:www\.)?invidious\.zee\.li',
321 r
'(?:www\.)?invidious\.ethibox\.fr',
322 r
'(?:www\.)?iv\.ggtyler\.dev',
323 r
'(?:www\.)?inv\.vern\.i2p',
324 r
'(?:www\.)?am74vkcrjp2d5v36lcdqgsj2m6x36tbrkhsruoegwfcizzabnfgf5zyd\.onion',
325 r
'(?:www\.)?inv\.riverside\.rocks',
326 r
'(?:www\.)?invidious\.silur\.me',
327 r
'(?:www\.)?inv\.bp\.projectsegfau\.lt',
328 r
'(?:www\.)?invidious\.g4c3eya4clenolymqbpgwz3q3tawoxw56yhzk4vugqrl6dtu3ejvhjid\.onion',
329 r
'(?:www\.)?invidious\.slipfox\.xyz',
330 r
'(?:www\.)?invidious\.esmail5pdn24shtvieloeedh7ehz3nrwcdivnfhfcedl7gf4kwddhkqd\.onion',
331 r
'(?:www\.)?inv\.vernccvbvyi5qhfzyqengccj7lkove6bjot2xhh5kajhwvidqafczrad\.onion',
332 r
'(?:www\.)?invidious\.tiekoetter\.com',
333 r
'(?:www\.)?iv\.odysfvr23q5wgt7i456o5t3trw2cw5dgn56vbjfbq2m7xsc5vqbqpcyd\.onion',
334 r
'(?:www\.)?invidious\.nerdvpn\.de',
335 r
'(?:www\.)?invidious\.weblibre\.org',
336 r
'(?:www\.)?inv\.odyssey346\.dev',
337 r
'(?:www\.)?invidious\.dhusch\.de',
338 r
'(?:www\.)?iv\.melmac\.space',
339 r
'(?:www\.)?watch\.thekitty\.zone',
340 r
'(?:www\.)?invidious\.privacydev\.net',
341 r
'(?:www\.)?ng27owmagn5amdm7l5s3rsqxwscl5ynppnis5dqcasogkyxcfqn7psid\.onion',
342 r
'(?:www\.)?invidious\.drivet\.xyz',
343 r
'(?:www\.)?vid\.priv\.au',
344 r
'(?:www\.)?euxxcnhsynwmfidvhjf6uzptsmh4dipkmgdmcmxxuo7tunp3ad2jrwyd\.onion',
345 r
'(?:www\.)?inv\.vern\.cc',
346 r
'(?:www\.)?invidious\.esmailelbob\.xyz',
347 r
'(?:www\.)?invidious\.sethforprivacy\.com',
348 r
'(?:www\.)?yt\.oelrichsgarcia\.de',
349 r
'(?:www\.)?yt\.artemislena\.eu',
350 r
'(?:www\.)?invidious\.flokinet\.to',
351 r
'(?:www\.)?invidious\.baczek\.me',
352 r
'(?:www\.)?y\.com\.sb',
353 r
'(?:www\.)?invidious\.epicsite\.xyz',
354 r
'(?:www\.)?invidious\.lidarshield\.cloud',
355 r
'(?:www\.)?yt\.funami\.tech',
356 r
'(?:www\.)?invidious\.3o7z6yfxhbw7n3za4rss6l434kmv55cgw2vuziwuigpwegswvwzqipyd\.onion',
357 r
'(?:www\.)?osbivz6guyeahrwp2lnwyjk2xos342h4ocsxyqrlaopqjuhwn2djiiyd\.onion',
358 r
'(?:www\.)?u2cvlit75owumwpy4dj2hsmvkq7nvrclkpht7xgyye2pyoxhpmclkrad\.onion',
359 # youtube-dl invidious instances list
360 r
'(?:(?:www|no)\.)?invidiou\.sh',
361 r
'(?:(?:www|fi)\.)?invidious\.snopyta\.org',
362 r
'(?:www\.)?invidious\.kabi\.tk',
363 r
'(?:www\.)?invidious\.mastodon\.host',
364 r
'(?:www\.)?invidious\.zapashcanon\.fr',
365 r
'(?:www\.)?(?:invidious(?:-us)?|piped)\.kavin\.rocks',
366 r
'(?:www\.)?invidious\.tinfoil-hat\.net',
367 r
'(?:www\.)?invidious\.himiko\.cloud',
368 r
'(?:www\.)?invidious\.reallyancient\.tech',
369 r
'(?:www\.)?invidious\.tube',
370 r
'(?:www\.)?invidiou\.site',
371 r
'(?:www\.)?invidious\.site',
372 r
'(?:www\.)?invidious\.xyz',
373 r
'(?:www\.)?invidious\.nixnet\.xyz',
374 r
'(?:www\.)?invidious\.048596\.xyz',
375 r
'(?:www\.)?invidious\.drycat\.fr',
376 r
'(?:www\.)?inv\.skyn3t\.in',
377 r
'(?:www\.)?tube\.poal\.co',
378 r
'(?:www\.)?tube\.connect\.cafe',
379 r
'(?:www\.)?vid\.wxzm\.sx',
380 r
'(?:www\.)?vid\.mint\.lgbt',
381 r
'(?:www\.)?vid\.puffyan\.us',
382 r
'(?:www\.)?yewtu\.be',
383 r
'(?:www\.)?yt\.elukerio\.org',
384 r
'(?:www\.)?yt\.lelux\.fi',
385 r
'(?:www\.)?invidious\.ggc-project\.de',
386 r
'(?:www\.)?yt\.maisputain\.ovh',
387 r
'(?:www\.)?ytprivate\.com',
388 r
'(?:www\.)?invidious\.13ad\.de',
389 r
'(?:www\.)?invidious\.toot\.koeln',
390 r
'(?:www\.)?invidious\.fdn\.fr',
391 r
'(?:www\.)?watch\.nettohikari\.com',
392 r
'(?:www\.)?invidious\.namazso\.eu',
393 r
'(?:www\.)?invidious\.silkky\.cloud',
394 r
'(?:www\.)?invidious\.exonip\.de',
395 r
'(?:www\.)?invidious\.riverside\.rocks',
396 r
'(?:www\.)?invidious\.blamefran\.net',
397 r
'(?:www\.)?invidious\.moomoo\.de',
398 r
'(?:www\.)?ytb\.trom\.tf',
399 r
'(?:www\.)?yt\.cyberhost\.uk',
400 r
'(?:www\.)?kgg2m7yk5aybusll\.onion',
401 r
'(?:www\.)?qklhadlycap4cnod\.onion',
402 r
'(?:www\.)?axqzx4s6s54s32yentfqojs3x5i7faxza6xo3ehd4bzzsg2ii4fv2iid\.onion',
403 r
'(?:www\.)?c7hqkpkpemu6e7emz5b4vyz7idjgdvgaaa3dyimmeojqbgpea3xqjoid\.onion',
404 r
'(?:www\.)?fz253lmuao3strwbfbmx46yu7acac2jz27iwtorgmbqlkurlclmancad\.onion',
405 r
'(?:www\.)?invidious\.l4qlywnpwqsluw65ts7md3khrivpirse744un3x7mlskqauz5pyuzgqd\.onion',
406 r
'(?:www\.)?owxfohz4kjyv25fvlqilyxast7inivgiktls3th44jhk3ej3i7ya\.b32\.i2p',
407 r
'(?:www\.)?4l2dgddgsrkf2ous66i6seeyi6etzfgrue332grh2n7madpwopotugyd\.onion',
408 r
'(?:www\.)?w6ijuptxiku4xpnnaetxvnkc5vqcdu7mgns2u77qefoixi63vbvnpnqd\.onion',
409 r
'(?:www\.)?kbjggqkzv65ivcqj6bumvp337z6264huv5kpkwuv6gu5yjiskvan7fad\.onion',
410 r
'(?:www\.)?grwp24hodrefzvjjuccrkw3mjq4tzhaaq32amf33dzpmuxe7ilepcmad\.onion',
411 r
'(?:www\.)?hpniueoejy4opn7bc4ftgazyqjoeqwlvh2uiku2xqku6zpoa4bf5ruid\.onion',
412 # piped instances from https://github.com/TeamPiped/Piped/wiki/Instances
413 r
'(?:www\.)?piped\.kavin\.rocks',
414 r
'(?:www\.)?piped\.tokhmi\.xyz',
415 r
'(?:www\.)?piped\.syncpundit\.io',
416 r
'(?:www\.)?piped\.mha\.fi',
417 r
'(?:www\.)?watch\.whatever\.social',
418 r
'(?:www\.)?piped\.garudalinux\.org',
419 r
'(?:www\.)?piped\.rivo\.lol',
420 r
'(?:www\.)?piped-libre\.kavin\.rocks',
421 r
'(?:www\.)?yt\.jae\.fi',
422 r
'(?:www\.)?piped\.mint\.lgbt',
424 r
'(?:www\.)?piped\.esmailelbob\.xyz',
425 r
'(?:www\.)?piped\.projectsegfau\.lt',
426 r
'(?:www\.)?piped\.privacydev\.net',
427 r
'(?:www\.)?piped\.palveluntarjoaja\.eu',
428 r
'(?:www\.)?piped\.smnz\.de',
429 r
'(?:www\.)?piped\.adminforge\.de',
430 r
'(?:www\.)?watch\.whatevertinfoil\.de',
431 r
'(?:www\.)?piped\.qdi\.fi',
432 r
'(?:www\.)?piped\.video',
433 r
'(?:www\.)?piped\.aeong\.one',
434 r
'(?:www\.)?piped\.moomoo\.me',
435 r
'(?:www\.)?piped\.chauvet\.pro',
436 r
'(?:www\.)?watch\.leptons\.xyz',
437 r
'(?:www\.)?pd\.vern\.cc',
438 r
'(?:www\.)?piped\.hostux\.net',
439 r
'(?:www\.)?piped\.lunar\.icu',
440 # Hyperpipe instances from https://hyperpipe.codeberg.page/
441 r
'(?:www\.)?hyperpipe\.surge\.sh',
442 r
'(?:www\.)?hyperpipe\.esmailelbob\.xyz',
443 r
'(?:www\.)?listen\.whatever\.social',
444 r
'(?:www\.)?music\.adminforge\.de',
447 # extracted from account/account_menu ep
448 # XXX: These are the supported YouTube UI and API languages,
449 # which is slightly different from languages supported for translation in YouTube studio
450 _SUPPORTED_LANG_CODES
= [
451 'af', 'az', 'id', 'ms', 'bs', 'ca', 'cs', 'da', 'de', 'et', 'en-IN', 'en-GB', 'en', 'es',
452 'es-419', 'es-US', 'eu', 'fil', 'fr', 'fr-CA', 'gl', 'hr', 'zu', 'is', 'it', 'sw', 'lv',
453 'lt', 'hu', 'nl', 'no', 'uz', 'pl', 'pt-PT', 'pt', 'ro', 'sq', 'sk', 'sl', 'sr-Latn', 'fi',
454 'sv', 'vi', 'tr', 'be', 'bg', 'ky', 'kk', 'mk', 'mn', 'ru', 'sr', 'uk', 'el', 'hy', 'iw',
455 'ur', 'ar', 'fa', 'ne', 'mr', 'hi', 'as', 'bn', 'pa', 'gu', 'or', 'ta', 'te', 'kn', 'ml',
456 'si', 'th', 'lo', 'my', 'ka', 'am', 'km', 'zh-CN', 'zh-TW', 'zh-HK', 'ja', 'ko'
459 _IGNORED_WARNINGS
= {'Unavailable videos will be hidden during playback'}
461 _YT_HANDLE_RE
= r
'@[\w.-]{3,30}' # https://support.google.com/youtube/answer/11585688?hl=en
462 _YT_CHANNEL_UCID_RE
= r
'UC[\w-]{22}'
464 def ucid_or_none(self
, ucid
):
465 return self
._search
_regex
(rf
'^({self._YT_CHANNEL_UCID_RE})$', ucid
, 'UC-id', default
=None)
467 def handle_or_none(self
, handle
):
468 return self
._search
_regex
(rf
'^({self._YT_HANDLE_RE})$', handle
, '@-handle', default
=None)
470 def handle_from_url(self
, url
):
471 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_HANDLE_RE})',
472 url
, 'channel handle', default
=None)
474 def ucid_from_url(self
, url
):
475 return self
._search
_regex
(rf
'^(?:https?://(?:www\.)?youtube\.com)?/({self._YT_CHANNEL_UCID_RE})',
476 url
, 'channel id', default
=None)
478 @functools.cached_property
479 def _preferred_lang(self
):
481 Returns a language code supported by YouTube for the user preferred language.
482 Returns None if no preferred language set.
484 preferred_lang
= self
._configuration
_arg
('lang', ie_key
='Youtube', casesense
=True, default
=[''])[0]
485 if not preferred_lang
:
487 if preferred_lang
not in self
._SUPPORTED
_LANG
_CODES
:
488 raise ExtractorError(
489 f
'Unsupported language code: {preferred_lang}. Supported language codes (case-sensitive): {join_nonempty(*self._SUPPORTED_LANG_CODES, delim=", ")}.',
491 elif preferred_lang
!= 'en':
493 f
'Preferring "{preferred_lang}" translated fields. Note that some metadata extraction may fail or be incorrect.')
494 return preferred_lang
496 def _initialize_consent(self
):
497 cookies
= self
._get
_cookies
('https://www.youtube.com/')
498 if cookies
.get('__Secure-3PSID'):
501 consent
= cookies
.get('CONSENT')
503 if 'YES' in consent
.value
:
505 consent_id
= self
._search
_regex
(
506 r
'PENDING\+(\d+)', consent
.value
, 'consent', default
=None)
508 consent_id
= random
.randint(100, 999)
509 self
._set
_cookie
('.youtube.com', 'CONSENT', 'YES+cb.20210328-17-p0.en+FX+%s' % consent_id
)
511 def _initialize_pref(self
):
512 cookies
= self
._get
_cookies
('https://www.youtube.com/')
513 pref_cookie
= cookies
.get('PREF')
517 pref
= dict(urllib
.parse
.parse_qsl(pref_cookie
.value
))
519 self
.report_warning('Failed to parse user PREF cookie' + bug_reports_message())
520 pref
.update({'hl': self._preferred_lang or 'en', 'tz': 'UTC'}
)
521 self
._set
_cookie
('.youtube.com', name
='PREF', value
=urllib
.parse
.urlencode(pref
))
523 def _real_initialize(self
):
524 self
._initialize
_pref
()
525 self
._initialize
_consent
()
526 self
._check
_login
_required
()
528 def _check_login_required(self
):
529 if self
._LOGIN
_REQUIRED
and not self
._cookies
_passed
:
530 self
.raise_login_required('Login details are needed to download this content', method
='cookies')
532 _YT_INITIAL_DATA_RE
= r
'(?:window\s*\[\s*["\']ytInitialData
["\']\s*\]|ytInitialData)\s*='
533 _YT_INITIAL_PLAYER_RESPONSE_RE = r'ytInitialPlayerResponse\s*='
535 def _get_default_ytcfg(self, client='web'):
536 return copy.deepcopy(INNERTUBE_CLIENTS[client])
538 def _get_innertube_host(self, client='web'):
539 return INNERTUBE_CLIENTS[client]['INNERTUBE_HOST']
541 def _ytcfg_get_safe(self, ytcfg, getter, expected_type=None, default_client='web'):
542 # try_get but with fallback to default ytcfg client values when present
543 _func = lambda y: try_get(y, getter, expected_type)
544 return _func(ytcfg) or _func(self._get_default_ytcfg(default_client))
546 def _extract_client_name(self, ytcfg, default_client='web'):
547 return self._ytcfg_get_safe(
548 ytcfg, (lambda x: x['INNERTUBE_CLIENT_NAME'],
549 lambda x: x['INNERTUBE_CONTEXT']['client']['clientName']), str, default_client)
551 def _extract_client_version(self, ytcfg, default_client='web'):
552 return self._ytcfg_get_safe(
553 ytcfg, (lambda x: x['INNERTUBE_CLIENT_VERSION'],
554 lambda x: x['INNERTUBE_CONTEXT']['client']['clientVersion']), str, default_client)
556 def _select_api_hostname(self, req_api_hostname, default_client=None):
557 return (self._configuration_arg('innertube_host', [''], ie_key=YoutubeIE.ie_key())[0]
558 or req_api_hostname or self._get_innertube_host(default_client or 'web'))
560 def _extract_api_key(self, ytcfg=None, default_client='web'):
561 return self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_API_KEY'], str, default_client)
563 def _extract_context(self, ytcfg=None, default_client='web'):
565 (ytcfg, self._get_default_ytcfg(default_client)), 'INNERTUBE_CONTEXT', expected_type=dict)
566 # Enforce language and tz for extraction
567 client_context = traverse_obj(context, 'client', expected_type=dict, default={})
568 client_context.update({'hl': self._preferred_lang or 'en', 'timeZone': 'UTC', 'utcOffsetMinutes': 0})
573 def _generate_sapisidhash_header(self, origin='https://www.youtube.com'):
574 time_now = round(time.time())
575 if self._SAPISID is None:
576 yt_cookies = self._get_cookies('https://www.youtube.com')
577 # Sometimes SAPISID cookie isn't present but __Secure-3PAPISID is.
578 # See: https://github.com/yt-dlp/yt-dlp/issues/393
579 sapisid_cookie = dict_get(
580 yt_cookies, ('__Secure-3PAPISID', 'SAPISID'))
581 if sapisid_cookie and sapisid_cookie.value:
582 self._SAPISID = sapisid_cookie.value
583 self.write_debug('Extracted SAPISID cookie')
584 # SAPISID cookie is required if not already present
585 if not yt_cookies.get('SAPISID'):
586 self.write_debug('Copying __Secure-3PAPISID cookie to SAPISID cookie')
588 '.youtube.com', 'SAPISID', self._SAPISID, secure=True, expire_time=time_now + 3600)
590 self._SAPISID = False
591 if not self._SAPISID:
593 # SAPISIDHASH algorithm from https://stackoverflow.com/a/32065323
594 sapisidhash = hashlib.sha1(
595 f'{time_now} {self._SAPISID} {origin}'.encode()).hexdigest()
596 return f'SAPISIDHASH {time_now}_{sapisidhash}'
598 def _call_api(self, ep, query, video_id, fatal=True, headers=None,
599 note='Downloading API JSON', errnote='Unable to download API page',
600 context=None, api_key=None, api_hostname=None, default_client='web'):
602 data = {'context': context} if context else {'context': self._extract_context(default_client=default_client)}
604 real_headers = self.generate_api_headers(default_client=default_client)
605 real_headers.update({'content-type': 'application/json'})
607 real_headers.update(headers)
608 api_key = (self._configuration_arg('innertube_key', [''], ie_key=YoutubeIE.ie_key(), casesense=True)[0]
609 or api_key or self._extract_api_key(default_client=default_client))
610 return self._download_json(
611 f'https://{self._select_api_hostname(api_hostname, default_client)}/youtubei/v1/{ep}',
612 video_id=video_id, fatal=fatal, note=note, errnote=errnote,
613 data=json.dumps(data).encode('utf8'), headers=real_headers,
614 query={'key': api_key, 'prettyPrint': 'false'})
616 def extract_yt_initial_data(self, item_id, webpage, fatal=True):
617 return self._search_json(self._YT_INITIAL_DATA_RE, webpage, 'yt initial data', item_id, fatal=fatal)
620 def _extract_session_index(*data):
622 Index of current account in account list.
623 See: https://github.com/yt-dlp/yt-dlp/pull/519
626 session_index = int_or_none(try_get(ytcfg, lambda x: x['SESSION_INDEX']))
627 if session_index is not None:
631 def _extract_identity_token(self, ytcfg=None, webpage=None):
633 token = try_get(ytcfg, lambda x: x['ID_TOKEN'], str)
637 return self._search_regex(
638 r'\bID_TOKEN["\']\s
*:\s
*["\'](.+?)["\']', webpage,
639 'identity token
', default=None, fatal=False)
642 def _extract_account_syncid(*args):
644 Extract syncId required to download private playlists of secondary channels
645 @params response and/or ytcfg
648 # ytcfg includes channel_syncid if on secondary channel
649 delegated_sid = try_get(data, lambda x: x['DELEGATED_SESSION_ID
'], str)
653 data, (lambda x: x['responseContext
']['mainAppWebResponseContext
']['datasyncId
'],
654 lambda x: x['DATASYNC_ID
']), str) or '').split('||
')
655 if len(sync_ids) >= 2 and sync_ids[1]:
656 # datasyncid is of the form "channel_syncid||user_syncid" for secondary channel
657 # and just "user_syncid||" for primary channel. We only want the channel_syncid
661 def _extract_visitor_data(*args):
663 Extracts visitorData from an API response or ytcfg
664 Appears to be used to track session state
667 args, [('VISITOR_DATA
', ('INNERTUBE_CONTEXT
', 'client
', 'visitorData
'), ('responseContext
', 'visitorData
'))],
670 @functools.cached_property
671 def is_authenticated(self):
672 return bool(self._generate_sapisidhash_header())
674 def extract_ytcfg(self, video_id, webpage):
677 return self._parse_json(
679 r'ytcfg\
.set\s
*\
(\s
*({.+?}
)\s
*\
)\s
*;', webpage, 'ytcfg
',
680 default='{}'), video_id, fatal=False) or {}
682 def generate_api_headers(
683 self
, *, ytcfg
=None, account_syncid
=None, session_index
=None,
684 visitor_data
=None, identity_token
=None, api_hostname
=None, default_client
='web'):
686 origin
= 'https://' + (self
._select
_api
_hostname
(api_hostname
, default_client
))
688 'X-YouTube-Client-Name': str(
689 self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT_CLIENT_NAME'], default_client
=default_client
)),
690 'X-YouTube-Client-Version': self
._extract
_client
_version
(ytcfg
, default_client
),
692 'X-Youtube-Identity-Token': identity_token
or self
._extract
_identity
_token
(ytcfg
),
693 'X-Goog-PageId': account_syncid
or self
._extract
_account
_syncid
(ytcfg
),
694 'X-Goog-Visitor-Id': visitor_data
or self
._extract
_visitor
_data
(ytcfg
),
695 'User-Agent': self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT']['client']['userAgent'], default_client
=default_client
)
697 if session_index
is None:
698 session_index
= self
._extract
_session
_index
(ytcfg
)
699 if account_syncid
or session_index
is not None:
700 headers
['X-Goog-AuthUser'] = session_index
if session_index
is not None else 0
702 auth
= self
._generate
_sapisidhash
_header
(origin
)
704 headers
['Authorization'] = auth
705 headers
['X-Origin'] = origin
706 return filter_dict(headers
)
708 def _download_ytcfg(self
, client
, video_id
):
710 'web': 'https://www.youtube.com',
711 'web_music': 'https://music.youtube.com',
712 'web_embedded': f
'https://www.youtube.com/embed/{video_id}?html5=1'
716 webpage
= self
._download
_webpage
(
717 url
, video_id
, fatal
=False, note
=f
'Downloading {client.replace("_", " ").strip()} client config')
718 return self
.extract_ytcfg(video_id
, webpage
) or {}
721 def _build_api_continuation_query(continuation
, ctp
=None):
723 'continuation': continuation
725 # TODO: Inconsistency with clickTrackingParams.
726 # Currently we have a fixed ctp contained within context (from ytcfg)
727 # and a ctp in root query for continuation.
729 query
['clickTracking'] = {'clickTrackingParams': ctp}
733 def _extract_next_continuation_data(cls
, renderer
):
734 next_continuation
= try_get(
735 renderer
, (lambda x
: x
['continuations'][0]['nextContinuationData'],
736 lambda x
: x
['continuation']['reloadContinuationData']), dict)
737 if not next_continuation
:
739 continuation
= next_continuation
.get('continuation')
742 ctp
= next_continuation
.get('clickTrackingParams')
743 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
746 def _extract_continuation_ep_data(cls
, continuation_ep
: dict):
747 if isinstance(continuation_ep
, dict):
748 continuation
= try_get(
749 continuation_ep
, lambda x
: x
['continuationCommand']['token'], str)
752 ctp
= continuation_ep
.get('clickTrackingParams')
753 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
756 def _extract_continuation(cls
, renderer
):
757 next_continuation
= cls
._extract
_next
_continuation
_data
(renderer
)
758 if next_continuation
:
759 return next_continuation
761 return traverse_obj(renderer
, (
762 ('contents', 'items', 'rows'), ..., 'continuationItemRenderer',
763 ('continuationEndpoint', ('button', 'buttonRenderer', 'command'))
764 ), get_all
=False, expected_type
=cls
._extract
_continuation
_ep
_data
)
767 def _extract_alerts(cls
, data
):
768 for alert_dict
in try_get(data
, lambda x
: x
['alerts'], list) or []:
769 if not isinstance(alert_dict
, dict):
771 for alert
in alert_dict
.values():
772 alert_type
= alert
.get('type')
775 message
= cls
._get
_text
(alert
, 'text')
777 yield alert_type
, message
779 def _report_alerts(self
, alerts
, expected
=True, fatal
=True, only_once
=False):
780 errors
, warnings
= [], []
781 for alert_type
, alert_message
in alerts
:
782 if alert_type
.lower() == 'error' and fatal
:
783 errors
.append([alert_type
, alert_message
])
784 elif alert_message
not in self
._IGNORED
_WARNINGS
:
785 warnings
.append([alert_type
, alert_message
])
787 for alert_type
, alert_message
in (warnings
+ errors
[:-1]):
788 self
.report_warning(f
'YouTube said: {alert_type} - {alert_message}', only_once
=only_once
)
790 raise ExtractorError('YouTube said: %s' % errors
[-1][1], expected
=expected
)
792 def _extract_and_report_alerts(self
, data
, *args
, **kwargs
):
793 return self
._report
_alerts
(self
._extract
_alerts
(data
), *args
, **kwargs
)
795 def _extract_badges(self
, badge_list
: list):
797 Extract known BadgeType's from a list of badge renderers.
798 @returns [{'type': BadgeType}]
801 'PRIVACY_UNLISTED': BadgeType
.AVAILABILITY_UNLISTED
,
802 'PRIVACY_PRIVATE': BadgeType
.AVAILABILITY_PRIVATE
,
803 'PRIVACY_PUBLIC': BadgeType
.AVAILABILITY_PUBLIC
,
804 'CHECK_CIRCLE_THICK': BadgeType
.VERIFIED
,
805 'OFFICIAL_ARTIST_BADGE': BadgeType
.VERIFIED
,
809 'BADGE_STYLE_TYPE_MEMBERS_ONLY': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
810 'BADGE_STYLE_TYPE_PREMIUM': BadgeType
.AVAILABILITY_PREMIUM
,
811 'BADGE_STYLE_TYPE_LIVE_NOW': BadgeType
.LIVE_NOW
,
815 'unlisted': BadgeType
.AVAILABILITY_UNLISTED
,
816 'private': BadgeType
.AVAILABILITY_PRIVATE
,
817 'members only': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
818 'live': BadgeType
.LIVE_NOW
,
819 'premium': BadgeType
.AVAILABILITY_PREMIUM
,
823 for badge
in traverse_obj(badge_list
, (..., lambda key
, _
: re
.search(r
'[bB]adgeRenderer$', key
))):
825 icon_type_map
.get(traverse_obj(badge
, ('icon', 'iconType'), expected_type
=str))
826 or badge_style_map
.get(traverse_obj(badge
, 'style'))
829 badges
.append({'type': badge_type}
)
832 # fallback, won't work in some languages
833 label
= traverse_obj(
834 badge
, 'label', ('accessibilityData', 'label'), 'tooltip', 'iconTooltip', get_all
=False, expected_type
=str, default
='')
835 for match
, label_badge_type
in label_map
.items():
836 if match
in label
.lower():
837 badges
.append({'type': label_badge_type}
)
843 def _has_badge(badges
, badge_type
):
844 return bool(traverse_obj(badges
, lambda _
, v
: v
['type'] == badge_type
))
847 def _get_text(data
, *path_list
, max_runs
=None):
848 for path
in path_list
or [None]:
852 obj
= traverse_obj(data
, path
, default
=[])
853 if not any(key
is ... or isinstance(key
, (list, tuple)) for key
in variadic(path
)):
856 text
= try_get(item
, lambda x
: x
['simpleText'], str)
859 runs
= try_get(item
, lambda x
: x
['runs'], list) or []
860 if not runs
and isinstance(item
, list):
863 runs
= runs
[:min(len(runs
), max_runs
or len(runs
))]
864 text
= ''.join(traverse_obj(runs
, (..., 'text'), expected_type
=str))
868 def _get_count(self
, data
, *path_list
):
869 count_text
= self
._get
_text
(data
, *path_list
) or ''
870 count
= parse_count(count_text
)
873 self
._search
_regex
(r
'^([\d,]+)', re
.sub(r
'\s', '', count_text
), 'count', default
=None))
877 def _extract_thumbnails(data
, *path_list
):
879 Extract thumbnails from thumbnails dict
880 @param path_list: path list to level that contains 'thumbnails' key
883 for path
in path_list
or [()]:
884 for thumbnail
in traverse_obj(data
, (*variadic(path
), 'thumbnails', ...)):
885 thumbnail_url
= url_or_none(thumbnail
.get('url'))
886 if not thumbnail_url
:
888 # Sometimes youtube gives a wrong thumbnail URL. See:
889 # https://github.com/yt-dlp/yt-dlp/issues/233
890 # https://github.com/ytdl-org/youtube-dl/issues/28023
891 if 'maxresdefault' in thumbnail_url
:
892 thumbnail_url
= thumbnail_url
.split('?')[0]
894 'url': thumbnail_url
,
895 'height': int_or_none(thumbnail
.get('height')),
896 'width': int_or_none(thumbnail
.get('width')),
901 def extract_relative_time(relative_time_text
):
903 Extracts a relative time from string and converts to dt object
904 e.g. 'streamed 6 days ago', '5 seconds ago (edited)', 'updated today', '8 yr ago'
907 # XXX: this could be moved to a general function in utils.py
908 # The relative time text strings are roughly the same as what
909 # Javascript's Intl.RelativeTimeFormat function generates.
910 # See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
912 r
'(?P<start>today|yesterday|now)|(?P<time>\d+)\s*(?P<unit>sec(?:ond)?|s|min(?:ute)?|h(?:our|r)?|d(?:ay)?|w(?:eek|k)?|mo(?:nth)?|y(?:ear|r)?)s?\s*ago',
915 start
= mobj
.group('start')
917 return datetime_from_str(start
)
919 return datetime_from_str('now-%s%s' % (mobj
.group('time'), mobj
.group('unit')))
923 def _parse_time_text(self
, text
):
926 dt
= self
.extract_relative_time(text
)
928 if isinstance(dt
, datetime
.datetime
):
929 timestamp
= calendar
.timegm(dt
.timetuple())
931 if timestamp
is None:
933 unified_timestamp(text
) or unified_timestamp(
935 (r
'([a-z]+\s*\d{1,2},?\s*20\d{2})', r
'(?:.+|^)(?:live|premieres|ed|ing)(?:\s*(?:on|for))?\s*(.+\d)'),
936 text
.lower(), 'time text', default
=None)))
938 if text
and timestamp
is None and self
._preferred
_lang
in (None, 'en'):
940 f
'Cannot parse localized time text "{text}"', only_once
=True)
943 def _extract_response(self
, item_id
, query
, note
='Downloading API JSON', headers
=None,
944 ytcfg
=None, check_get_keys
=None, ep
='browse', fatal
=True, api_hostname
=None,
945 default_client
='web'):
946 for retry
in self
.RetryManager():
948 response
= self
._call
_api
(
949 ep
=ep
, fatal
=True, headers
=headers
,
950 video_id
=item_id
, query
=query
, note
=note
,
951 context
=self
._extract
_context
(ytcfg
, default_client
),
952 api_key
=self
._extract
_api
_key
(ytcfg
, default_client
),
953 api_hostname
=api_hostname
, default_client
=default_client
)
954 except ExtractorError
as e
:
955 if not isinstance(e
.cause
, network_exceptions
):
956 return self
._error
_or
_warning
(e
, fatal
=fatal
)
957 elif not isinstance(e
.cause
, urllib
.error
.HTTPError
):
961 first_bytes
= e
.cause
.read(512)
962 if not is_html(first_bytes
):
965 self
._webpage
_read
_content
(e
.cause
, None, item_id
, prefix
=first_bytes
) or '{}', item_id
, fatal
=False),
966 lambda x
: x
['error']['message'], str)
968 self
._report
_alerts
([('ERROR', yt_error
)], fatal
=False)
969 # Downloading page may result in intermittent 5xx HTTP error
970 # Sometimes a 404 is also recieved. See: https://github.com/ytdl-org/youtube-dl/issues/28289
971 # We also want to catch all other network exceptions since errors in later pages can be troublesome
972 # See https://github.com/yt-dlp/yt-dlp/issues/507#issuecomment-880188210
973 if e
.cause
.code
not in (403, 429):
976 return self
._error
_or
_warning
(e
, fatal
=fatal
)
979 self
._extract
_and
_report
_alerts
(response
, only_once
=True)
980 except ExtractorError
as e
:
981 # YouTube servers may return errors we want to retry on in a 200 OK response
982 # See: https://github.com/yt-dlp/yt-dlp/issues/839
983 if 'unknown error' in e
.msg
.lower():
986 return self
._error
_or
_warning
(e
, fatal
=fatal
)
987 # Youtube sometimes sends incomplete data
988 # See: https://github.com/ytdl-org/youtube-dl/issues/28194
989 if not traverse_obj(response
, *variadic(check_get_keys
)):
990 retry
.error
= ExtractorError('Incomplete data received', expected
=True)
996 def is_music_url(url
):
997 return re
.match(r
'(https?://)?music\.youtube\.com/', url
) is not None
999 def _extract_video(self
, renderer
):
1000 video_id
= renderer
.get('videoId')
1002 reel_header_renderer
= traverse_obj(renderer
, (
1003 'navigationEndpoint', 'reelWatchEndpoint', 'overlay', 'reelPlayerOverlayRenderer',
1004 'reelPlayerHeaderSupportedRenderers', 'reelPlayerHeaderRenderer'))
1006 title
= self
._get
_text
(renderer
, 'title', 'headline') or self
._get
_text
(reel_header_renderer
, 'reelTitleText')
1007 description
= self
._get
_text
(renderer
, 'descriptionSnippet')
1009 duration
= int_or_none(renderer
.get('lengthSeconds'))
1010 if duration
is None:
1011 duration
= parse_duration(self
._get
_text
(
1012 renderer
, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
1013 if duration
is None:
1014 # XXX: should write a parser to be more general to support more cases (e.g. shorts in shorts tab)
1015 duration
= parse_duration(self
._search
_regex
(
1016 r
'(?i)(ago)(?!.*\1)\s+(?P<duration>[a-z0-9 ,]+?)(?:\s+[\d,]+\s+views)?(?:\s+-\s+play\s+short)?$',
1017 traverse_obj(renderer
, ('title', 'accessibility', 'accessibilityData', 'label'), default
='', expected_type
=str),
1018 video_id
, default
=None, group
='duration'))
1020 channel_id
= traverse_obj(
1021 renderer
, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'),
1022 expected_type
=str, get_all
=False)
1024 channel_id
= traverse_obj(reel_header_renderer
, ('channelNavigationEndpoint', 'browseEndpoint', 'browseId'))
1026 channel_id
= self
.ucid_or_none(channel_id
)
1028 overlay_style
= traverse_obj(
1029 renderer
, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'),
1030 get_all
=False, expected_type
=str)
1031 badges
= self
._extract
_badges
(traverse_obj(renderer
, 'badges'))
1032 navigation_url
= urljoin('https://www.youtube.com/', traverse_obj(
1033 renderer
, ('navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url'),
1034 expected_type
=str)) or ''
1035 url
= f
'https://www.youtube.com/watch?v={video_id}'
1036 if overlay_style
== 'SHORTS' or '/shorts/' in navigation_url
:
1037 url
= f
'https://www.youtube.com/shorts/{video_id}'
1039 time_text
= (self
._get
_text
(renderer
, 'publishedTimeText', 'videoInfo')
1040 or self
._get
_text
(reel_header_renderer
, 'timestampText') or '')
1041 scheduled_timestamp
= str_to_int(traverse_obj(renderer
, ('upcomingEventData', 'startTime'), get_all
=False))
1044 'is_upcoming' if scheduled_timestamp
is not None
1045 else 'was_live' if 'streamed' in time_text
.lower()
1046 else 'is_live' if overlay_style
== 'LIVE' or self
._has
_badge
(badges
, BadgeType
.LIVE_NOW
)
1049 # videoInfo is a string like '50K views • 10 years ago'.
1050 view_count_text
= self
._get
_text
(renderer
, 'viewCountText', 'shortViewCountText', 'videoInfo') or ''
1051 view_count
= (0 if 'no views' in view_count_text
.lower()
1052 else self
._get
_count
({'simpleText': view_count_text}
))
1053 view_count_field
= 'concurrent_view_count' if live_status
in ('is_live', 'is_upcoming') else 'view_count'
1055 channel
= (self
._get
_text
(renderer
, 'ownerText', 'shortBylineText')
1056 or self
._get
_text
(reel_header_renderer
, 'channelTitleText'))
1058 channel_handle
= traverse_obj(renderer
, (
1059 'shortBylineText', 'runs', ..., 'navigationEndpoint',
1060 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl'))),
1061 expected_type
=self
.handle_from_url
, get_all
=False)
1064 'ie_key': YoutubeIE
.ie_key(),
1068 'description': description
,
1069 'duration': duration
,
1070 'channel_id': channel_id
,
1072 'channel_url': f
'https://www.youtube.com/channel/{channel_id}' if channel_id
else None,
1073 'uploader': channel
,
1074 'uploader_id': channel_handle
,
1075 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
1076 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
1077 'timestamp': (self
._parse
_time
_text
(time_text
)
1078 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
1080 'release_timestamp': scheduled_timestamp
,
1082 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
1083 else self
._availability
(
1084 is_private
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
) or None,
1085 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
1086 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
1087 is_unlisted
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
) or None),
1088 view_count_field
: view_count
,
1089 'live_status': live_status
,
1093 class YoutubeIE(YoutubeBaseInfoExtractor
):
1095 _VALID_URL
= r
"""(?x)^
1097 (?:https?://|//) # http(s):// or protocol-independent URL
1098 (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
1099 (?:www\.)?deturl\.com/www\.youtube\.com|
1100 (?:www\.)?pwnyoutube\.com|
1101 (?:www\.)?hooktube\.com|
1102 (?:www\.)?yourepeat\.com|
1103 tube\.majestyc\.net|
1105 youtube\.googleapis\.com)/ # the various hostnames, with wildcard subdomains
1106 (?:.*?\#/)? # handle anchor (#/) redirect urls
1107 (?: # the various things that can precede the ID:
1108 (?:(?:v|embed|e|shorts|live)/(?!videoseries|live_stream)) # v/ or embed/ or e/ or shorts/
1109 |(?: # or the v= param in all its forms
1110 (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
1111 (?:\?|\#!?) # the params delimiter ? or # or #!
1112 (?:.*?[&;])?? # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&v=V36LpHqtcDY)
1117 youtu\.be| # just youtu.be/xxxx
1118 vid\.plus| # or vid.plus/xxxx
1119 zwearz\.com/watch| # or zwearz.com/watch/xxxx
1122 |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
1124 )? # all until now is optional -> you can pass the naked ID
1125 (?P<id>[0-9A-Za-z_-]{11}) # here is it! the YouTube video ID
1126 (?(1).+)? # if we found the ID, everything can follow
1128 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
1133 <(?:[0-9A-Za-z-]+?)?iframe[^>]+?src=|
1141 (?P
<url
>(?
:https?
:)?
//(?
:www\
.)?
youtube(?
:-nocookie
)?\
.com
/
1142 (?
:embed|v|p
)/[0-9A
-Za
-z_
-]{11}
.*?
)
1144 # https://wordpress.org/plugins/lazy-load-for-videos/
1146 <a\s
[^
>]*\bhref
="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"
1147 \s
[^
>]*\bclass
="[^"]*\blazy
-load
-youtube
''',
1149 _RETURN_TYPE = 'video' # XXX: How to handle multifeed?
1152 r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
1153 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$',
1154 r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
1157 '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1158 '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1159 '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
1160 '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
1161 '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
1162 '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1163 '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1164 '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1165 # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
1166 '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
1167 '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1168 '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1169 '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1170 '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1171 '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1172 '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1173 '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1174 '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1178 '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1179 '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1180 '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1181 '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1182 '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
1183 '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1184 '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1186 # Apple HTTP Live Streaming
1187 '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1188 '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1189 '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1190 '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1191 '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1192 '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1193 '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1194 '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
1197 '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
1198 '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
1199 '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1200 '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
1201 '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
1202 '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'}, # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
1203 '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
1204 '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1205 '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
1206 '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1207 '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1208 '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
1211 '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
1212 '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
1213 '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
1214 '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1215 '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1216 '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
1217 '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
1220 '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1221 '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1222 '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1223 '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1224 '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1225 '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1226 '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
1227 '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1228 '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1229 '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1230 '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1231 '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1232 '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1233 '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1234 '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1235 # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
1236 '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1237 '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1238 '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1239 '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1240 '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1241 '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1244 '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
1245 '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
1247 # Dash webm audio with opus inside
1248 '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
1249 '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
1250 '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
1253 '_rtmp': {'protocol': 'rtmp'},
1255 # av01 video only formats sometimes served with "unknown" codecs
1256 '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1257 '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1258 '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1259 '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1260 '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1261 '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1262 '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1263 '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1265 _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1272 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1274 'id': 'BaW_jenozKc',
1276 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1277 'channel': 'Philipp Hagemeister',
1278 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1279 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1280 'upload_date': '20121002',
1281 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1282 'categories': ['Science & Technology'],
1283 'tags': ['youtube-dl'],
1287 'availability': 'public',
1288 'playable_in_embed': True,
1289 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1290 'live_status': 'not_live',
1294 'comment_count': int,
1295 'channel_follower_count': int,
1296 'uploader': 'Philipp Hagemeister',
1297 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1298 'uploader_id': '@PhilippHagemeister',
1299 'heatmap': 'count:100',
1303 'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1304 'note': 'Embed-only video (#1746)',
1306 'id': 'yZIXLfi8CZQ',
1308 'upload_date': '20120608',
1309 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1310 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1313 'skip': 'Private video',
1316 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1317 'note': 'Use the first video ID in the URL',
1319 'id': 'BaW_jenozKc',
1321 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1322 'channel': 'Philipp Hagemeister',
1323 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1324 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1325 'upload_date': '20121002',
1326 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1327 'categories': ['Science & Technology'],
1328 'tags': ['youtube-dl'],
1332 'availability': 'public',
1333 'playable_in_embed': True,
1334 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1335 'live_status': 'not_live',
1337 'comment_count': int,
1338 'channel_follower_count': int,
1339 'uploader': 'Philipp Hagemeister',
1340 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
1341 'uploader_id': '@PhilippHagemeister',
1342 'heatmap': 'count:100',
1345 'skip_download': True,
1349 'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1350 'note': '256k DASH audio (format 141) via DASH manifest',
1352 'id': 'a9LDPn-MO4I',
1354 'upload_date': '20121002',
1356 'title': 'UHDTV TEST 8K VIDEO.mp4'
1359 'youtube_include_dash_manifest': True,
1362 'skip': 'format 141 not served anymore',
1364 # DASH manifest with encrypted signature
1366 'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1368 'id': 'IB3lcPjvWLA',
1370 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1371 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1373 'upload_date': '20131011',
1376 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1377 'playable_in_embed': True,
1378 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1380 'track': 'The Spark',
1381 'live_status': 'not_live',
1382 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1383 'channel': 'Afrojack',
1385 'availability': 'public',
1386 'categories': ['Music'],
1388 'alt_title': 'The Spark',
1389 'channel_follower_count': int,
1390 'uploader': 'Afrojack',
1391 'uploader_url': 'https://www.youtube.com/@Afrojack',
1392 'uploader_id': '@Afrojack',
1395 'youtube_include_dash_manifest': True,
1396 'format': '141/bestaudio[ext=m4a]',
1399 # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1401 'note': 'Embed allowed age-gate video',
1402 'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1404 'id': 'HtVdAasjOgU',
1406 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1407 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1409 'upload_date': '20140605',
1411 'categories': ['Gaming'],
1412 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1413 'availability': 'needs_auth',
1414 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1416 'channel': 'The Witcher',
1417 'live_status': 'not_live',
1419 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1420 'playable_in_embed': True,
1422 'channel_follower_count': int,
1423 'uploader': 'The Witcher',
1424 'uploader_url': 'https://www.youtube.com/@thewitcher',
1425 'uploader_id': '@thewitcher',
1426 'comment_count': int,
1427 'heatmap': 'count:100',
1431 'note': 'Age-gate video with embed allowed in public site',
1432 'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1434 'id': 'HsUATh_Nc2U',
1436 'title': 'Godzilla 2 (Official Video)',
1437 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1438 'upload_date': '20200408',
1440 'availability': 'needs_auth',
1441 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1442 'channel': 'FlyingKitty',
1443 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1445 'categories': ['Entertainment'],
1446 'live_status': 'not_live',
1447 'tags': ['Flyingkitty', 'godzilla 2'],
1448 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1451 'playable_in_embed': True,
1452 'channel_follower_count': int,
1453 'uploader': 'FlyingKitty',
1454 'uploader_url': 'https://www.youtube.com/@FlyingKitty900',
1455 'uploader_id': '@FlyingKitty900',
1456 'comment_count': int,
1460 'note': 'Age-gate video embedable only with clientScreen=EMBED',
1461 'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1463 'id': 'Tq92D6wQ1mg',
1464 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1466 'upload_date': '20191228',
1467 'description': 'md5:17eccca93a786d51bc67646756894066',
1470 'availability': 'needs_auth',
1471 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1473 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1474 'channel': 'Projekt Melody',
1475 'live_status': 'not_live',
1476 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1477 'playable_in_embed': True,
1478 'categories': ['Entertainment'],
1480 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1481 'comment_count': int,
1482 'channel_follower_count': int,
1483 'uploader': 'Projekt Melody',
1484 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
1485 'uploader_id': '@ProjektMelody',
1489 'note': 'Non-Agegated non-embeddable video',
1490 'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1492 'id': 'MeJVWBSsPAY',
1494 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1495 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1496 'upload_date': '20130730',
1497 'track': 'Such mich find mich',
1499 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1501 'playable_in_embed': False,
1502 'creator': 'OOMPH!',
1503 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1505 'alt_title': 'Such mich find mich',
1507 'channel': 'Herr Lurik',
1508 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1509 'categories': ['Music'],
1510 'availability': 'public',
1511 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1512 'live_status': 'not_live',
1514 'channel_follower_count': int,
1515 'uploader': 'Herr Lurik',
1516 'uploader_url': 'https://www.youtube.com/@HerrLurik',
1517 'uploader_id': '@HerrLurik',
1521 'note': 'Non-bypassable age-gated video',
1522 'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1523 'only_matching': True,
1525 # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1526 # YouTube Red ad is not captured for creator
1528 'url': '__2ABJjxzNo',
1530 'id': '__2ABJjxzNo',
1533 'upload_date': '20100430',
1534 'creator': 'deadmau5',
1535 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1536 'title': 'Deadmau5 - Some Chords (HD)',
1537 'alt_title': 'Some Chords',
1538 'availability': 'public',
1540 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1542 'live_status': 'not_live',
1543 'channel': 'deadmau5',
1544 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1546 'track': 'Some Chords',
1547 'artist': 'deadmau5',
1548 'playable_in_embed': True,
1550 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1551 'categories': ['Music'],
1552 'album': 'Some Chords',
1553 'channel_follower_count': int,
1554 'uploader': 'deadmau5',
1555 'uploader_url': 'https://www.youtube.com/@deadmau5',
1556 'uploader_id': '@deadmau5',
1558 'expected_warnings': [
1559 'DASH manifest missing',
1562 # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1564 'url': 'lqQg6PlCWgI',
1566 'id': 'lqQg6PlCWgI',
1569 'upload_date': '20150827',
1570 'description': 'md5:04bbbf3ccceb6795947572ca36f45904',
1571 'title': 'Hockey - Women - GER-AUS - London 2012 Olympic Games',
1573 'release_timestamp': 1343767800,
1574 'playable_in_embed': True,
1575 'categories': ['Sports'],
1576 'release_date': '20120731',
1577 'channel': 'Olympics',
1578 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1579 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1580 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1582 'availability': 'public',
1583 'live_status': 'was_live',
1585 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1586 'channel_follower_count': int,
1587 'uploader': 'Olympics',
1588 'uploader_url': 'https://www.youtube.com/@Olympics',
1589 'uploader_id': '@Olympics',
1592 'skip_download': 'requires avconv',
1597 'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1599 'id': '_b-2C3KPAM0',
1601 'stretched_ratio': 16 / 9.,
1603 'upload_date': '20110310',
1604 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1605 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1606 'playable_in_embed': True,
1610 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1611 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1612 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1614 'categories': ['People & Blogs'],
1616 'live_status': 'not_live',
1617 'availability': 'unlisted',
1618 'comment_count': int,
1619 'channel_follower_count': int,
1621 'uploader_url': 'https://www.youtube.com/@AllenMeow',
1622 'uploader_id': '@AllenMeow',
1625 # url_encoded_fmt_stream_map is empty string
1627 'url': 'qEJwOuvDf7I',
1629 'id': 'qEJwOuvDf7I',
1631 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1633 'upload_date': '20150404',
1636 'skip_download': 'requires avconv',
1638 'skip': 'This live event has ended.',
1640 # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1642 'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1644 'id': 'FIl7x6_3R5Y',
1646 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1647 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1649 'upload_date': '20150625',
1650 'formats': 'mincount:31',
1652 'skip': 'not actual anymore',
1654 # DASH manifest with segment_list
1656 'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1657 'md5': '8ce563a1d667b599d21064e982ab9e31',
1659 'id': 'CsmdDsKjzN8',
1661 'upload_date': '20150501', # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1662 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1663 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1666 'youtube_include_dash_manifest': True,
1667 'format': '135', # bestvideo
1669 'skip': 'This live event has ended.',
1672 # Multifeed videos (multiple cameras), URL can be of any Camera
1673 # TODO: fix multifeed titles
1674 'url': 'https://www.youtube.com/watch?v=zaPI8MvL8pg',
1676 'id': 'zaPI8MvL8pg',
1677 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04',
1678 'description': 'md5:563ccbc698b39298481ca3c571169519',
1682 'id': 'j5yGuxZ8lLU',
1684 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Chris)',
1685 'description': 'md5:563ccbc698b39298481ca3c571169519',
1687 'channel_follower_count': int,
1688 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1689 'availability': 'public',
1690 'playable_in_embed': True,
1691 'upload_date': '20131105',
1692 'categories': ['Gaming'],
1693 'live_status': 'was_live',
1695 'release_timestamp': 1383701910,
1696 'thumbnail': 'https://i.ytimg.com/vi/j5yGuxZ8lLU/maxresdefault.jpg',
1697 'comment_count': int,
1700 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1701 'channel': 'WiiLikeToPlay',
1703 'release_date': '20131106',
1704 'uploader': 'WiiLikeToPlay',
1705 'uploader_id': '@WLTP',
1706 'uploader_url': 'https://www.youtube.com/@WLTP',
1710 'id': 'zaPI8MvL8pg',
1712 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Tyson)',
1713 'availability': 'public',
1714 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1715 'channel': 'WiiLikeToPlay',
1716 'channel_follower_count': int,
1717 'description': 'md5:563ccbc698b39298481ca3c571169519',
1722 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1723 'release_timestamp': 1383701915,
1724 'comment_count': int,
1725 'upload_date': '20131105',
1726 'thumbnail': 'https://i.ytimg.com/vi/zaPI8MvL8pg/maxresdefault.jpg',
1727 'release_date': '20131106',
1728 'playable_in_embed': True,
1729 'live_status': 'was_live',
1730 'categories': ['Gaming'],
1732 'uploader': 'WiiLikeToPlay',
1733 'uploader_id': '@WLTP',
1734 'uploader_url': 'https://www.youtube.com/@WLTP',
1738 'id': 'R7r3vfO7Hao',
1740 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Spencer)',
1741 'thumbnail': 'https://i.ytimg.com/vi/R7r3vfO7Hao/maxresdefault.jpg',
1742 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1744 'availability': 'public',
1745 'playable_in_embed': True,
1746 'upload_date': '20131105',
1747 'description': 'md5:563ccbc698b39298481ca3c571169519',
1748 'channel_follower_count': int,
1750 'release_date': '20131106',
1751 'comment_count': int,
1752 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1753 'channel': 'WiiLikeToPlay',
1754 'categories': ['Gaming'],
1755 'release_timestamp': 1383701914,
1756 'live_status': 'was_live',
1760 'uploader': 'WiiLikeToPlay',
1761 'uploader_id': '@WLTP',
1762 'uploader_url': 'https://www.youtube.com/@WLTP',
1765 'params': {'skip_download': True},
1768 # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1769 'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1771 'id': 'gVfLd0zydlo',
1772 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1774 'playlist_count': 2,
1775 'skip': 'Not multifeed anymore',
1778 'url': 'https://vid.plus/FlRa-iH7PGw',
1779 'only_matching': True,
1782 'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1783 'only_matching': True,
1786 # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1787 # Also tests cut-off URL expansion in video description (see
1788 # https://github.com/ytdl-org/youtube-dl/issues/1892,
1789 # https://github.com/ytdl-org/youtube-dl/issues/8164)
1790 'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1792 'id': 'lsguqyKfVQg',
1794 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1795 'alt_title': 'Dark Walk',
1796 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1798 'upload_date': '20151119',
1799 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1800 'track': 'Dark Walk',
1801 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1802 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1803 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1804 'categories': ['Film & Animation'],
1806 'live_status': 'not_live',
1807 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1808 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1810 'availability': 'public',
1811 'channel': 'IronSoulElf',
1812 'playable_in_embed': True,
1815 'channel_follower_count': int
1818 'skip_download': True,
1822 # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1823 'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1824 'only_matching': True,
1827 # Video with yt:stretch=17:0
1828 'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1830 'id': 'Q39EVAstoRM',
1832 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1833 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1834 'upload_date': '20151107',
1837 'skip_download': True,
1839 'skip': 'This video does not exist.',
1842 # Video with incomplete 'yt:stretch=16:'
1843 'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1844 'only_matching': True,
1847 # Video licensed under Creative Commons
1848 'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1850 'id': 'M4gD1WSo5mA',
1852 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1853 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1855 'upload_date': '20150128',
1856 'license': 'Creative Commons Attribution license (reuse allowed)',
1857 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1858 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1861 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1862 'channel': 'The Berkman Klein Center for Internet & Society',
1863 'availability': 'public',
1865 'categories': ['Education'],
1866 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1867 'live_status': 'not_live',
1868 'playable_in_embed': True,
1869 'channel_follower_count': int,
1871 'uploader': 'The Berkman Klein Center for Internet & Society',
1872 'uploader_id': '@BKCHarvard',
1873 'uploader_url': 'https://www.youtube.com/@BKCHarvard',
1876 'skip_download': True,
1880 'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1882 'id': 'eQcmzGIKrzg',
1884 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1885 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1887 'upload_date': '20151120',
1888 'license': 'Creative Commons Attribution license (reuse allowed)',
1889 'playable_in_embed': True,
1892 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1894 'availability': 'public',
1895 'categories': ['News & Politics'],
1896 'channel': 'Bernie Sanders',
1897 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1899 'live_status': 'not_live',
1900 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1901 'comment_count': int,
1902 'channel_follower_count': int,
1904 'uploader': 'Bernie Sanders',
1905 'uploader_url': 'https://www.youtube.com/@BernieSanders',
1906 'uploader_id': '@BernieSanders',
1907 'heatmap': 'count:100',
1910 'skip_download': True,
1914 'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;v=V36LpHqtcDY',
1915 'only_matching': True,
1918 # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1919 'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1920 'only_matching': True,
1923 # Rental video preview
1924 'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1926 'id': 'uGpuVWrhIzE',
1928 'title': 'Piku - Trailer',
1929 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1930 'upload_date': '20150811',
1931 'license': 'Standard YouTube License',
1934 'skip_download': True,
1936 'skip': 'This video is not available.',
1939 # YouTube Red video with episode data
1940 'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1942 'id': 'iqKdEhx-dD4',
1944 'title': 'Isolation - Mind Field (Ep 1)',
1945 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1947 'upload_date': '20170118',
1948 'series': 'Mind Field',
1950 'episode_number': 1,
1951 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1954 'availability': 'public',
1956 'channel': 'Vsauce',
1957 'episode': 'Episode 1',
1958 'categories': ['Entertainment'],
1959 'season': 'Season 1',
1960 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
1961 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
1963 'playable_in_embed': True,
1964 'live_status': 'not_live',
1965 'channel_follower_count': int,
1966 'uploader': 'Vsauce',
1967 'uploader_url': 'https://www.youtube.com/@Vsauce',
1968 'uploader_id': '@Vsauce',
1969 'comment_count': int,
1972 'skip_download': True,
1974 'expected_warnings': [
1975 'Skipping DASH manifest',
1979 # The following content has been identified by the YouTube community
1980 # as inappropriate or offensive to some audiences.
1981 'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
1983 'id': '6SJNVb0GnPI',
1985 'title': 'Race Differences in Intelligence',
1986 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
1988 'upload_date': '20140124',
1991 'skip_download': True,
1993 'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
1997 'url': '1t24XAntNCY',
1998 'only_matching': True,
2001 # geo restricted to JP
2002 'url': 'sJL6WA-aGkQ',
2003 'only_matching': True,
2006 'url': 'https://invidio.us/watch?v=BaW_jenozKc',
2007 'only_matching': True,
2010 'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
2011 'only_matching': True,
2014 # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
2015 'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
2016 'only_matching': True,
2020 'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
2021 'only_matching': True,
2024 # Video with unsupported adaptive stream type formats
2025 'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
2027 'id': 'Z4Vy8R84T1U',
2029 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
2030 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
2032 'upload_date': '20130923',
2033 'formats': 'maxcount:10',
2036 'skip_download': True,
2037 'youtube_include_dash_manifest': False,
2039 'skip': 'not actual anymore',
2042 # Youtube Music Auto-generated description
2043 # TODO: fix metadata extraction
2044 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2046 'id': 'MgNrAu2pzNs',
2048 'title': 'Voyeur Girl',
2049 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
2050 'upload_date': '20190312',
2051 'artist': 'Stephen',
2052 'track': 'Voyeur Girl',
2053 'album': 'it\'s too much love to know my dear',
2054 'release_date': '20190313',
2055 'release_year': 2019,
2056 'alt_title': 'Voyeur Girl',
2058 'playable_in_embed': True,
2060 'categories': ['Music'],
2061 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
2062 'channel': 'Stephen', # TODO: should be "Stephen - Topic"
2063 'uploader': 'Stephen',
2064 'availability': 'public',
2065 'creator': 'Stephen',
2067 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
2069 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
2071 'live_status': 'not_live',
2072 'channel_follower_count': int
2075 'skip_download': True,
2079 'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
2080 'only_matching': True,
2083 # invalid -> valid video id redirection
2084 'url': 'DJztXj2GPfl',
2086 'id': 'DJztXj2GPfk',
2088 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
2089 'description': 'md5:bf577a41da97918e94fa9798d9228825',
2090 'upload_date': '20090125',
2091 'artist': 'Panjabi MC',
2092 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
2093 'album': 'Beware of the Boys (Mundian To Bach Ke)',
2096 'skip_download': True,
2098 'skip': 'Video unavailable',
2101 # empty description results in an empty string
2102 'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
2104 'id': 'x41yOUIvK2k',
2106 'title': 'IMG 3456',
2108 'upload_date': '20170613',
2110 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
2112 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
2114 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
2115 'availability': 'public',
2117 'categories': ['Pets & Animals'],
2119 'playable_in_embed': True,
2120 'live_status': 'not_live',
2121 'channel': 'l\'Or Vert asbl',
2122 'channel_follower_count': int,
2123 'uploader': 'l\'Or Vert asbl',
2124 'uploader_url': 'https://www.youtube.com/@ElevageOrVert',
2125 'uploader_id': '@ElevageOrVert',
2128 'skip_download': True,
2132 # with '};' inside yt initial data (see [1])
2133 # see [2] for an example with '};' inside ytInitialPlayerResponse
2134 # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
2135 # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
2136 'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
2138 'id': 'CHqg6qOn4no',
2140 'title': 'Part 77 Sort a list of simple types in c#',
2141 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
2142 'upload_date': '20130831',
2143 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
2145 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
2146 'live_status': 'not_live',
2147 'categories': ['Education'],
2148 'availability': 'public',
2149 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
2151 'playable_in_embed': True,
2155 'channel': 'kudvenkat',
2156 'comment_count': int,
2157 'channel_follower_count': int,
2159 'uploader': 'kudvenkat',
2160 'uploader_url': 'https://www.youtube.com/@Csharp-video-tutorialsBlogspot',
2161 'uploader_id': '@Csharp-video-tutorialsBlogspot',
2162 'heatmap': 'count:100',
2165 'skip_download': True,
2169 # another example of '};' in ytInitialData
2170 'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
2171 'only_matching': True,
2174 'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
2175 'only_matching': True,
2178 # https://github.com/ytdl-org/youtube-dl/pull/28094
2179 'url': 'OtqTfy26tG0',
2181 'id': 'OtqTfy26tG0',
2183 'title': 'Burn Out',
2184 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
2185 'upload_date': '20141120',
2186 'artist': 'The Cinematic Orchestra',
2187 'track': 'Burn Out',
2188 'album': 'Every Day',
2190 'live_status': 'not_live',
2191 'alt_title': 'Burn Out',
2195 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2196 'creator': 'The Cinematic Orchestra',
2197 'channel': 'The Cinematic Orchestra',
2198 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
2199 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2200 'availability': 'public',
2201 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
2202 'categories': ['Music'],
2203 'playable_in_embed': True,
2204 'channel_follower_count': int,
2205 'uploader': 'The Cinematic Orchestra',
2206 'comment_count': int,
2209 'skip_download': True,
2213 # controversial video, only works with bpctr when authenticated with cookies
2214 'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
2215 'only_matching': True,
2218 # controversial video, requires bpctr/contentCheckOk
2219 'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
2221 'id': 'SZJvDhaSDnc',
2223 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
2224 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
2225 'upload_date': '20140716',
2226 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
2228 'categories': ['News & Politics'],
2230 'channel': 'CBS Mornings',
2231 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
2232 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
2234 'availability': 'needs_auth',
2235 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
2237 'live_status': 'not_live',
2238 'playable_in_embed': True,
2239 'channel_follower_count': int,
2240 'uploader': 'CBS Mornings',
2241 'uploader_url': 'https://www.youtube.com/@CBSMornings',
2242 'uploader_id': '@CBSMornings',
2243 'comment_count': int,
2247 # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
2248 'url': 'cBvYw8_A0vQ',
2250 'id': 'cBvYw8_A0vQ',
2252 'title': '4K Ueno Okachimachi Street Scenes 上野御徒町歩き',
2253 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
2254 'upload_date': '20201120',
2256 'categories': ['Travel & Events'],
2257 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2259 'channel': 'Walk around Japan',
2260 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
2261 'thumbnail': 'https://i.ytimg.com/vi_webp/cBvYw8_A0vQ/hqdefault.webp',
2263 'availability': 'public',
2264 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2265 'live_status': 'not_live',
2266 'playable_in_embed': True,
2267 'channel_follower_count': int,
2268 'uploader': 'Walk around Japan',
2269 'uploader_url': 'https://www.youtube.com/@walkaroundjapan7124',
2270 'uploader_id': '@walkaroundjapan7124',
2273 'skip_download': True,
2276 # Has multiple audio streams
2277 'url': 'WaOKSUlf4TM',
2278 'only_matching': True
2280 # Requires Premium: has format 141 when requested using YTM url
2281 'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2282 'only_matching': True
2284 # multiple subtitles with same lang_code
2285 'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2286 'only_matching': True,
2288 # Force use android client fallback
2289 'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2291 'id': 'YOelRv7fMxY',
2292 'title': 'DIGGING A SECRET TUNNEL Part 1',
2294 'upload_date': '20210624',
2295 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2296 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2297 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2299 'categories': ['Entertainment'],
2301 'channel': 'colinfurze',
2302 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2303 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2305 'availability': 'public',
2307 'live_status': 'not_live',
2308 'playable_in_embed': True,
2309 'channel_follower_count': int,
2311 'uploader': 'colinfurze',
2312 'uploader_url': 'https://www.youtube.com/@colinfurze',
2313 'uploader_id': '@colinfurze',
2314 'comment_count': int,
2315 'heatmap': 'count:100',
2318 'format': '17', # 3gp format available on android
2319 'extractor_args': {'youtube': {'player_client': ['android']}},
2323 # Skip download of additional client configs (remix client config in this case)
2324 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2325 'only_matching': True,
2327 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2331 'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2332 'only_matching': True,
2334 'note': 'Storyboards',
2335 'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2337 'id': '5KLPxDtMqe8',
2340 'title': 'Your Brain is Plastic',
2341 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2342 'upload_date': '20140324',
2344 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2345 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2347 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2348 'playable_in_embed': True,
2350 'availability': 'public',
2351 'channel': 'SciShow',
2352 'live_status': 'not_live',
2354 'categories': ['Education'],
2356 'channel_follower_count': int,
2358 'uploader': 'SciShow',
2359 'uploader_url': 'https://www.youtube.com/@SciShow',
2360 'uploader_id': '@SciShow',
2361 'comment_count': int,
2362 'heatmap': 'count:100',
2363 }, 'params': {'format': 'mhtml', 'skip_download': True}
2365 # Ensure video upload_date is in UTC timezone (video was uploaded 1641170939)
2366 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2368 'id': '2NUZ8W2llS4',
2370 'title': 'The NP that test your phone performance 🙂',
2371 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2372 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2373 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2377 'categories': ['Gaming'],
2379 'playable_in_embed': True,
2380 'live_status': 'not_live',
2381 'upload_date': '20220103',
2383 'availability': 'public',
2384 'channel': 'Leon Nguyen',
2385 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2386 'comment_count': int,
2387 'channel_follower_count': int,
2388 'uploader': 'Leon Nguyen',
2389 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2390 'uploader_id': '@LeonNguyen',
2391 'heatmap': 'count:100',
2394 # Same video as above, but with --compat-opt no-youtube-prefer-utc-upload-date
2395 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2397 'id': '2NUZ8W2llS4',
2399 'title': 'The NP that test your phone performance 🙂',
2400 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2401 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2402 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2406 'categories': ['Gaming'],
2408 'playable_in_embed': True,
2409 'live_status': 'not_live',
2410 'upload_date': '20220102',
2412 'availability': 'public',
2413 'channel': 'Leon Nguyen',
2414 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2415 'comment_count': int,
2416 'channel_follower_count': int,
2417 'uploader': 'Leon Nguyen',
2418 'uploader_url': 'https://www.youtube.com/@LeonNguyen',
2419 'uploader_id': '@LeonNguyen',
2420 'heatmap': 'count:100',
2422 'params': {'compat_opts': ['no-youtube-prefer-utc-upload-date']}
2424 # date text is premiered video, ensure upload date in UTC (published 1641172509)
2425 'url': 'https://www.youtube.com/watch?v=mzZzzBU6lrM',
2427 'id': 'mzZzzBU6lrM',
2429 'title': 'I Met GeorgeNotFound In Real Life...',
2430 'description': 'md5:978296ec9783a031738b684d4ebf302d',
2431 'channel_id': 'UC_8NknAFiyhOUaZqHR3lq3Q',
2432 'channel_url': 'https://www.youtube.com/channel/UC_8NknAFiyhOUaZqHR3lq3Q',
2436 'categories': ['Entertainment'],
2438 'playable_in_embed': True,
2439 'live_status': 'not_live',
2440 'release_timestamp': 1641172509,
2441 'release_date': '20220103',
2442 'upload_date': '20220103',
2444 'availability': 'public',
2445 'channel': 'Quackity',
2446 'thumbnail': 'https://i.ytimg.com/vi/mzZzzBU6lrM/maxresdefault.jpg',
2447 'channel_follower_count': int,
2448 'uploader': 'Quackity',
2449 'uploader_id': '@Quackity',
2450 'uploader_url': 'https://www.youtube.com/@Quackity',
2451 'comment_count': int,
2452 'heatmap': 'count:100',
2455 { # continuous livestream. Microformat upload date should be preferred.
2456 # Upload date was 2021-06-19 (not UTC), while stream start is 2021-11-27
2457 'url': 'https://www.youtube.com/watch?v=kgx4WGK0oNU',
2459 'id': 'kgx4WGK0oNU',
2460 '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}',
2462 'channel_id': 'UC84whx2xxsiA1gXHXXqKGOA',
2463 'availability': 'public',
2465 'release_timestamp': 1637975704,
2466 'upload_date': '20210619',
2467 'channel_url': 'https://www.youtube.com/channel/UC84whx2xxsiA1gXHXXqKGOA',
2468 'live_status': 'is_live',
2469 'thumbnail': 'https://i.ytimg.com/vi/kgx4WGK0oNU/maxresdefault.jpg',
2470 'channel': 'Abao in Tokyo',
2471 'channel_follower_count': int,
2472 'release_date': '20211127',
2474 'categories': ['People & Blogs'],
2477 'playable_in_embed': True,
2478 'description': 'md5:2ef1d002cad520f65825346e2084e49d',
2479 'concurrent_view_count': int,
2480 'uploader': 'Abao in Tokyo',
2481 'uploader_url': 'https://www.youtube.com/@abaointokyo',
2482 'uploader_id': '@abaointokyo',
2484 'params': {'skip_download': True}
2486 # Story. Requires specific player params to work.
2487 'url': 'https://www.youtube.com/watch?v=vv8qTUWmulI',
2489 'id': 'vv8qTUWmulI',
2491 'availability': 'unlisted',
2493 'channel_id': 'UCzIZ8HrzDgc-pNQDUG6avBA',
2494 'upload_date': '20220526',
2495 'categories': ['Education'],
2497 'channel': 'IT\'S HISTORY',
2500 'playable_in_embed': True,
2502 'live_status': 'not_live',
2504 'thumbnail': 'https://i.ytimg.com/vi_webp/vv8qTUWmulI/maxresdefault.webp',
2505 'channel_url': 'https://www.youtube.com/channel/UCzIZ8HrzDgc-pNQDUG6avBA',
2507 'skip': 'stories get removed after some period of time',
2509 'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2511 'id': 'tjjjtzRLHvA',
2513 'title': 'ハッシュタグ無し };if window.ytcsi',
2514 'upload_date': '20220323',
2516 'availability': 'unlisted',
2517 'channel': 'Lesmiscore',
2518 'thumbnail': r're:^https?://.*\.jpg',
2520 'categories': ['Music'],
2523 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2524 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2525 'live_status': 'not_live',
2526 'playable_in_embed': True,
2527 'channel_follower_count': int,
2530 'uploader_id': '@lesmiscore',
2531 'uploader': 'Lesmiscore',
2532 'uploader_url': 'https://www.youtube.com/@lesmiscore',
2535 # Prefer primary title+description language metadata by default
2536 # Do not prefer translated description if primary is empty
2537 'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2539 'id': 'el3E4MbxRqQ',
2541 'title': 'dlp test video 2 - primary sv no desc',
2543 'channel': 'cole-dlp-test-acc',
2546 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2548 'playable_in_embed': True,
2549 'availability': 'unlisted',
2550 'thumbnail': r're:^https?://.*\.jpg',
2553 'live_status': 'not_live',
2554 'upload_date': '20220908',
2555 'categories': ['People & Blogs'],
2556 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2557 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2558 'uploader_id': '@coletdjnz',
2559 'uploader': 'cole-dlp-test-acc',
2561 'params': {'skip_download': True}
2563 # Extractor argument: prefer translated title+description
2564 'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2566 'id': 'gHKT4uU8Zng',
2568 'channel': 'cole-dlp-test-acc',
2571 'live_status': 'not_live',
2572 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2573 'upload_date': '20220728',
2575 'categories': ['People & Blogs'],
2576 'thumbnail': r're:^https?://.*\.jpg',
2577 'title': 'dlp test video title translated (fr)',
2578 'availability': 'public',
2580 'description': 'dlp test video description translated (fr)',
2581 'playable_in_embed': True,
2582 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2583 'uploader_url': 'https://www.youtube.com/@coletdjnz',
2584 'uploader_id': '@coletdjnz',
2585 'uploader': 'cole-dlp-test-acc',
2587 'params': {'skip_download': True, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2588 'expected_warnings': [r'Preferring "fr" translated fields'],
2590 'note': '6 channel audio',
2591 'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2592 'only_matching': True,
2594 'note': 'Multiple HLS formats with same itag',
2595 'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2597 'id': 'kX3nB4PpJko',
2599 'categories': ['Entertainment'],
2600 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2601 'live_status': 'not_live',
2603 'channel_follower_count': int,
2604 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2605 'title': 'Last To Take Hand Off Jet, Keeps It!',
2606 'channel': 'MrBeast',
2607 'playable_in_embed': True,
2609 'upload_date': '20221112',
2610 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2612 'availability': 'public',
2613 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2616 'uploader': 'MrBeast',
2617 'uploader_url': 'https://www.youtube.com/@MrBeast',
2618 'uploader_id': '@MrBeast',
2619 'comment_count': int,
2620 'heatmap': 'count:100',
2622 'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2624 'note': 'Audio formats with Dynamic Range Compression',
2625 'url': 'https://www.youtube.com/watch?v=Tq92D6wQ1mg',
2627 'id': 'Tq92D6wQ1mg',
2629 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
2630 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
2631 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
2632 'channel_follower_count': int,
2633 'description': 'md5:17eccca93a786d51bc67646756894066',
2634 'upload_date': '20191228',
2635 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
2636 'playable_in_embed': True,
2638 'categories': ['Entertainment'],
2639 'thumbnail': 'https://i.ytimg.com/vi/Tq92D6wQ1mg/sddefault.jpg',
2641 'channel': 'Projekt Melody',
2643 'availability': 'needs_auth',
2644 'comment_count': int,
2645 'live_status': 'not_live',
2647 'uploader': 'Projekt Melody',
2648 'uploader_id': '@ProjektMelody',
2649 'uploader_url': 'https://www.youtube.com/@ProjektMelody',
2651 'params': {'extractor_args': {'youtube': {'player_client': ['tv_embedded']}}, 'format': '251-drc'},
2654 'url': 'https://www.youtube.com/live/qVv6vCqciTM',
2656 'id': 'qVv6vCqciTM',
2659 'comment_count': int,
2660 'chapters': 'count:13',
2661 'upload_date': '20221223',
2662 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
2663 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
2665 'release_date': '20221223',
2666 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
2667 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
2669 'playable_in_embed': True,
2671 'availability': 'public',
2672 'channel_follower_count': int,
2673 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
2674 'categories': ['Entertainment'],
2675 'live_status': 'was_live',
2676 'release_timestamp': 1671793345,
2677 'channel': 'さなちゃんねる',
2678 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
2679 'uploader': 'さなちゃんねる',
2680 'uploader_url': 'https://www.youtube.com/@sana_natori',
2681 'uploader_id': '@sana_natori',
2682 'heatmap': 'count:100',
2686 # Fallbacks when webpage and web client is unavailable
2687 'url': 'https://www.youtube.com/watch?v=wSSmNUl9Snw',
2689 'id': 'wSSmNUl9Snw',
2691 # 'categories': ['Science & Technology'],
2693 'chapters': 'count:2',
2694 'channel': 'Scott Manley',
2697 # 'availability': 'public',
2698 'channel_follower_count': int,
2699 'live_status': 'not_live',
2700 'upload_date': '20170831',
2703 'uploader_url': 'https://www.youtube.com/@scottmanley',
2704 'description': 'md5:f4bed7b200404b72a394c2f97b782c02',
2705 'uploader': 'Scott Manley',
2706 'uploader_id': '@scottmanley',
2707 'title': 'The Computer Hack That Saved Apollo 14',
2708 'channel_id': 'UCxzC4EngIsMrPmbm6Nxvb-A',
2709 'thumbnail': r're:^https?://.*\.webp',
2710 'channel_url': 'https://www.youtube.com/channel/UCxzC4EngIsMrPmbm6Nxvb-A',
2711 'playable_in_embed': True,
2712 'comment_count': int,
2713 'heatmap': 'count:100',
2716 'extractor_args': {'youtube': {'player_client': ['android'], 'player_skip': ['webpage']}},
2722 # YouTube <object> embed
2724 'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2725 'md5': '873c81d308b979f0e23ee7e620b312a3',
2727 'id': 'msN87y-iEx0',
2729 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2730 'upload_date': '20080526',
2731 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2733 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2734 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2735 'playable_in_embed': True,
2736 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2738 'comment_count': int,
2739 'channel': 'Christopher Sykes',
2740 'live_status': 'not_live',
2741 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2742 'availability': 'public',
2745 'categories': ['Science & Technology'],
2746 'channel_follower_count': int,
2747 'uploader': 'Christopher Sykes',
2748 'uploader_url': 'https://www.youtube.com/@ChristopherSykesDocumentaries',
2749 'uploader_id': '@ChristopherSykesDocumentaries',
2750 'heatmap': 'count:100',
2753 'skip_download': True,
2759 def suitable(cls, url):
2760 from ..utils import parse_qs
2763 if qs.get('list', [None])[0]:
2765 return super().suitable(url)
2767 def __init__(self, *args, **kwargs):
2768 super().__init__(*args, **kwargs)
2769 self._code_cache = {}
2770 self._player_cache = {}
2772 def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2773 lock = threading.Lock()
2774 start_time = time.time()
2775 formats = [f for f in formats if f.get('is_from_start')]
2777 def refetch_manifest(format_id, delay):
2778 nonlocal formats, start_time, is_live
2779 if time.time() <= start_time + delay:
2782 _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2783 video_details = traverse_obj(prs, (..., 'videoDetails'), expected_type=dict)
2784 microformats = traverse_obj(
2785 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2787 _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2788 is_live = live_status == 'is_live'
2789 start_time = time.time()
2791 def mpd_feed(format_id, delay):
2793 @returns (manifest_url, manifest_stream_number, is_live) or None
2795 for retry in self.RetryManager(fatal=False):
2797 refetch_manifest(format_id, delay)
2799 f = next((f for f in formats if f['format_id'] == format_id), None)
2802 retry.error = f'{video_id}: Video is no longer live'
2804 retry.error = f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}'
2806 return f['manifest_url'], f['manifest_stream_number'], is_live
2810 f['is_live'] = is_live
2811 gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2812 live_start_time, mpd_feed, not is_live and f.copy())
2814 f['fragments'] = gen
2815 f['protocol'] = 'http_dash_segments_generator'
2817 f['fragments'] = LazyList(gen({}))
2818 del f['is_from_start']
2820 def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2821 FETCH_SPAN, MAX_DURATION = 5, 432000
2823 mpd_url, stream_number, is_live = None, None, True
2826 download_start_time = ctx.get('start') or time.time()
2828 lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2829 if lack_early_segments:
2830 self.report_warning(bug_reports_message(
2831 'Starting download from the last 120 hours of the live stream since '
2832 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2833 lack_early_segments = True
2835 known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2836 fragments, fragment_base_url = None, None
2838 def _extract_sequence_from_mpd(refresh_sequence, immediate):
2839 nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2840 # Obtain from MPD's maximum seq value
2841 old_mpd_url = mpd_url
2842 last_error = ctx.pop('last_error', None)
2843 expire_fast = immediate or last_error and isinstance(last_error, urllib.error.HTTPError) and last_error.code == 403
2844 mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2845 or (mpd_url, stream_number, False))
2846 if not refresh_sequence:
2847 if expire_fast and not is_live:
2848 return False, last_seq
2849 elif old_mpd_url == mpd_url:
2850 return True, last_seq
2851 if manifestless_orig_fmt:
2852 fmt_info = manifestless_orig_fmt
2855 fmts, _ = self._extract_mpd_formats_and_subtitles(
2856 mpd_url, None, note=False, errnote=False, fatal=False)
2857 except ExtractorError:
2860 no_fragment_score += 2
2861 return False, last_seq
2862 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2863 fragments = fmt_info['fragments']
2864 fragment_base_url = fmt_info['fragment_base_url']
2865 assert fragment_base_url
2867 _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2868 return True, _last_seq
2870 self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2872 fetch_time = time.time()
2873 if no_fragment_score > 30:
2875 if last_segment_url:
2876 # Obtain from "X-Head-Seqnum" header value from each segment
2878 urlh = self._request_webpage(
2879 last_segment_url, None, note=False, errnote=False, fatal=False)
2880 except ExtractorError:
2882 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2883 if last_seq is None:
2884 no_fragment_score += 2
2885 last_segment_url = None
2888 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2889 no_fragment_score += 2
2890 if not should_continue:
2893 if known_idx > last_seq:
2894 last_segment_url = None
2899 if begin_index < 0 and known_idx < 0:
2900 # skip from the start when it's negative value
2901 known_idx = last_seq + begin_index
2902 if lack_early_segments:
2903 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2905 for idx in range(known_idx, last_seq):
2906 # do not update sequence here or you'll get skipped some part of it
2907 should_continue, _ = _extract_sequence_from_mpd(False, False)
2908 if not should_continue:
2910 raise ExtractorError('breaking out of outer loop')
2911 last_segment_url = urljoin(fragment_base_url, 'sq/%d' % idx)
2913 'url': last_segment_url,
2914 'fragment_count': last_seq,
2916 if known_idx == last_seq:
2917 no_fragment_score += 5
2919 no_fragment_score = 0
2920 known_idx = last_seq
2921 except ExtractorError:
2924 if manifestless_orig_fmt:
2925 # Stop at the first iteration if running for post-live manifestless;
2926 # fragment count no longer increase since it starts
2929 time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2931 def _extract_player_url(self, *ytcfgs, webpage=None):
2932 player_url = traverse_obj(
2933 ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2934 get_all=False, expected_type=str)
2937 return urljoin('https://www.youtube.com', player_url)
2939 def _download_player_url(self, video_id, fatal=False):
2940 res = self._download_webpage(
2941 'https://www.youtube.com/iframe_api',
2942 note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2944 player_version = self._search_regex(
2945 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2947 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2949 def _signature_cache_id(self, example_sig):
2950 """ Return a string representation of a signature """
2951 return '.'.join(str(len(part)) for part in example_sig.split('.'))
2954 def _extract_player_info(cls, player_url):
2955 for player_re in cls._PLAYER_INFO_RE:
2956 id_m = re.search(player_re, player_url)
2960 raise ExtractorError('Cannot identify player %r' % player_url)
2961 return id_m.group('id')
2963 def _load_player(self, video_id, player_url, fatal=True):
2964 player_id = self._extract_player_info(player_url)
2965 if player_id not in self._code_cache:
2966 code = self._download_webpage(
2967 player_url, video_id, fatal=fatal,
2968 note='Downloading player ' + player_id,
2969 errnote='Download of %s failed' % player_url)
2971 self._code_cache[player_id] = code
2972 return self._code_cache.get(player_id)
2974 def _extract_signature_function(self, video_id, player_url, example_sig):
2975 player_id = self._extract_player_info(player_url)
2977 # Read from filesystem cache
2978 func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2979 assert os.path.basename(func_id) == func_id
2981 self.write_debug(f'Extracting signature function {func_id}')
2982 cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
2985 code = self._load_player(video_id, player_url)
2987 res = self._parse_sig_js(code)
2988 test_string = ''.join(map(chr, range(len(example_sig))))
2989 cache_spec = [ord(c) for c in res(test_string)]
2990 self.cache.store('youtube-sigfuncs', func_id, cache_spec)
2992 return lambda s: ''.join(s[i] for i in cache_spec)
2994 def _print_sig_code(self, func, example_sig):
2995 if not self.get_param('youtube_print_sig_code'):
2998 def gen_sig_code(idxs):
2999 def _genslice(start, end, step):
3000 starts = '' if start == 0 else str(start)
3001 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
3002 steps = '' if step == 1 else (':%d' % step)
3003 return f's[{starts}{ends}{steps}]'
3006 # Quelch pyflakes warnings - start will be set when step is set
3007 start = '(Never used)'
3008 for i, prev in zip(idxs[1:], idxs[:-1]):
3009 if step is not None:
3010 if i - prev == step:
3012 yield _genslice(start, prev, step)
3015 if i - prev in [-1, 1]:
3020 yield 's[%d]' % prev
3024 yield _genslice(start, i, step)
3026 test_string = ''.join(map(chr, range(len(example_sig))))
3027 cache_res = func(test_string)
3028 cache_spec = [ord(c) for c in cache_res]
3029 expr_code = ' + '.join(gen_sig_code(cache_spec))
3030 signature_id_tuple = '(%s)' % (
3031 ', '.join(str(len(p)) for p in example_sig.split('.')))
3032 code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
3033 ' return %s\n') % (signature_id_tuple, expr_code)
3034 self.to_screen('Extracted signature function:\n' + code)
3036 def _parse_sig_js(self, jscode):
3037 funcname = self._search_regex(
3038 (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3039 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3040 r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
3041 r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
3042 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+\))?',
3043 r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
3045 r'("|\')signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3046 r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
3047 r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3048 r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3049 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
3050 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
3051 jscode, 'Initial JS player signature function name', group='sig')
3053 jsi = JSInterpreter(jscode)
3054 initial_function = jsi.extract_function(funcname)
3055 return lambda s: initial_function([s])
3057 def _cached(self, func, *cache_id):
3058 def inner(*args, **kwargs):
3059 if cache_id not in self._player_cache:
3061 self._player_cache[cache_id] = func(*args, **kwargs)
3062 except ExtractorError as e:
3063 self._player_cache[cache_id] = e
3064 except Exception as e:
3065 self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
3067 ret = self._player_cache[cache_id]
3068 if isinstance(ret, Exception):
3073 def _decrypt_signature(self, s, video_id, player_url):
3074 """Turn the encrypted s field into a working signature"""
3075 extract_sig = self._cached(
3076 self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
3077 func = extract_sig(video_id, player_url, s)
3078 self._print_sig_code(func, s)
3081 def _decrypt_nsig(self, s, video_id, player_url):
3082 """Turn the encrypted n field into a working signature"""
3083 if player_url is None:
3084 raise ExtractorError('Cannot decrypt nsig without player_url')
3085 player_url = urljoin('https://www.youtube.com', player_url)
3088 jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
3089 except ExtractorError as e:
3090 raise ExtractorError('Unable to extract nsig function code', cause=e)
3091 if self.get_param('youtube_print_sig_code'):
3092 self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
3095 extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
3096 ret = extract_nsig(jsi, func_code)(s)
3097 except JSInterpreter.Exception as e:
3099 jsi = PhantomJSwrapper(self, timeout=5000)
3100 except ExtractorError:
3102 self.report_warning(
3103 f'Native nsig extraction failed: Trying with PhantomJS\n'
3104 f' n = {s} ; player = {player_url}', video_id)
3105 self.write_debug(e, only_once=True)
3107 args, func_body = func_code
3109 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
3110 video_id=video_id, note='Executing signature code').strip()
3112 self.write_debug(f'Decrypted nsig {s} => {ret}')
3115 def _extract_n_function_name(self, jscode):
3116 funcname, idx = self._search_regex(
3117 r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
3118 jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
3122 return json.loads(js_to_json(self._search_regex(
3123 rf'var {re.escape(funcname)}\s*=\s*(\[.+?\]);', jscode,
3124 f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
3126 def _extract_n_function_code(self, video_id, player_url):
3127 player_id = self._extract_player_info(player_url)
3128 func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
3129 jscode = func_code or self._load_player(video_id, player_url)
3130 jsi = JSInterpreter(jscode)
3133 return jsi, player_id, func_code
3135 func_name = self._extract_n_function_name(jscode)
3138 func_code = self._search_regex(
3139 r'''(?xs
)%s\s
*=\s
*function\s
*\
((?P
<var
>[\w$
]+)\
)\s
*
3140 # NB: The end of the regex is intentionally kept strict
3141 {(?P<code>.+?}\s
*return\
[\w$
]+.join\
(""\
))};''' % func_name,
3142 jscode, 'nsig function', group=('var', 'code'), default=None)
3144 func_code = ([func_code[0]], func_code[1])
3146 self.write_debug('Extracting nsig function with jsinterp')
3147 func_code = jsi.extract_function_code(func_name)
3149 self.cache.store('youtube-nsig', player_id, func_code)
3150 return jsi, player_id, func_code
3152 def _extract_n_function_from_code(self, jsi, func_code):
3153 func = jsi.extract_function_from_code(*func_code)
3155 def extract_nsig(s):
3158 except JSInterpreter.Exception:
3160 except Exception as e:
3161 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
3163 if ret.startswith('enhanced_except_'):
3164 raise JSInterpreter.Exception('Signature function returned an exception')
3169 def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3171 Extract signatureTimestamp (sts)
3172 Required to tell API what sig/player version is in use.
3175 if isinstance(ytcfg, dict):
3176 sts = int_or_none(ytcfg.get('STS'))
3179 # Attempt to extract from player
3180 if player_url is None:
3181 error_msg = 'Cannot extract signature timestamp without player_url.'
3183 raise ExtractorError(error_msg)
3184 self.report_warning(error_msg)
3186 code = self._load_player(video_id, player_url, fatal=fatal)
3188 sts = int_or_none(self._search_regex(
3189 r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3190 'JS player signature timestamp', group='sts', fatal=fatal))
3193 def _mark_watched(self, video_id, player_responses):
3194 for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3195 label = 'fully ' if is_full else ''
3196 url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3197 expected_type=url_or_none)
3199 self.report_warning(f'Unable to mark {label}watched')
3201 parsed_url = urllib.parse.urlparse(url)
3202 qs = urllib.parse.parse_qs(parsed_url.query)
3204 # cpn generation algorithm is reverse engineered from base.js.
3205 # In fact it works even with dummy cpn.
3206 CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3207 cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16))
3209 # # more consistent results setting it to right before the end
3210 video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3215 'cmt': video_length,
3216 'el': 'detailpage', # otherwise defaults to "shorts"
3220 # these seem to mark watchtime "history" in the real world
3221 # they're required, so send in a single value
3227 url = urllib.parse.urlunparse(
3228 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3230 self._download_webpage(
3231 url, video_id, f'Marking {label}watched',
3232 'Unable to mark watched', fatal=False)
3235 def _extract_from_webpage(cls, url, webpage):
3236 # Invidious Instances
3237 # https://github.com/yt-dlp/yt-dlp/issues/195
3238 # https://github.com/iv-org/invidious/pull/1730
3240 r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3243 yield cls.url_result(mobj.group('url'), cls)
3244 raise cls.StopExtraction()
3246 yield from super()._extract_from_webpage(url, webpage)
3248 # lazyYT YouTube embed
3249 for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3250 yield cls.url_result(unescapeHTML(id_), cls, id_)
3252 # Wordpress "YouTube Video Importer" plugin
3253 for m in re.findall(r'''(?x
)<div
[^
>]+
3254 class=(?P
<q1
>[\'"])[^\'"]*\byvii
_single
_video
_player
\b[^
\'"]*(?P=q1)[^>]+
3255 data-video_id=(?P<q2>[\'"])([^
\'"]+)(?P=q2)''', webpage):
3256 yield cls.url_result(m[-1], cls, m[-1])
3259 def extract_id(cls, url):
3260 video_id = cls.get_temp_id(url)
3262 raise ExtractorError(f'Invalid URL: {url}')
3265 def _extract_chapters_from_json(self, data, duration):
3266 chapter_list = traverse_obj(
3268 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3269 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters'
3270 ), expected_type=list)
3272 return self._extract_chapters_helper(
3274 start_function=lambda chapter: float_or_none(
3275 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3276 title_function=lambda chapter: traverse_obj(
3277 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3280 def _extract_chapters_from_engagement_panel(self, data, duration):
3281 content_list = traverse_obj(
3283 ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3285 chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3286 chapter_title = lambda chapter: self._get_text(chapter, 'title')
3288 return next(filter(None, (
3289 self._extract_chapters_helper(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3290 chapter_time, chapter_title, duration)
3291 for contents in content_list)), [])
3293 def _extract_heatmap_from_player_overlay(self, data):
3294 content_list = traverse_obj(data, (
3295 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer', 'decoratedPlayerBarRenderer', 'playerBar',
3296 'multiMarkersPlayerBarRenderer', 'markersMap', ..., 'value', 'heatmap', 'heatmapRenderer', 'heatMarkers', {list}))
3297 return next(filter(None, (
3298 traverse_obj(contents, (..., 'heatMarkerRenderer', {
3299 'start_time': ('timeRangeStartMillis', {functools.partial(float_or_none, scale=1000)}),
3300 'end_time': {lambda x: (x['timeRangeStartMillis'] + x['markerDurationMillis']) / 1000},
3301 'value': ('heatMarkerIntensityScoreNormalized', {float_or_none}),
3302 })) for contents in content_list)), None)
3304 def _extract_comment(self, comment_renderer, parent=None):
3305 comment_id = comment_renderer.get('commentId')
3311 'text': self._get_text(comment_renderer, 'contentText'),
3312 'like_count': self._get_count(comment_renderer, 'voteCount'),
3313 'author_id': traverse_obj(comment_renderer, ('authorEndpoint', 'browseEndpoint', 'browseId', {self.ucid_or_none})),
3314 'author': self._get_text(comment_renderer, 'authorText'),
3315 'author_thumbnail': traverse_obj(comment_renderer, ('authorThumbnail', 'thumbnails', -1, 'url', {url_or_none})),
3316 'parent': parent or 'root',
3319 # Timestamp is an estimate calculated from the current time and time_text
3320 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3321 timestamp = self._parse_time_text(time_text)
3324 # FIXME: non-standard, but we need a way of showing that it is an estimate.
3325 '_time_text': time_text,
3326 'timestamp': timestamp,
3329 info['author_url'] = urljoin(
3330 'https://www.youtube.com', traverse_obj(comment_renderer, ('authorEndpoint', (
3331 ('browseEndpoint', 'canonicalBaseUrl'), ('commandMetadata', 'webCommandMetadata', 'url'))),
3332 expected_type=str, get_all=False))
3334 author_is_uploader = traverse_obj(comment_renderer, 'authorIsChannelOwner')
3335 if author_is_uploader is not None:
3336 info['author_is_uploader'] = author_is_uploader
3338 comment_abr = traverse_obj(
3339 comment_renderer, ('actionsButtons', 'commentActionButtonsRenderer'), expected_type=dict)
3340 if comment_abr is not None:
3341 info['is_favorited'] = 'creatorHeart' in comment_abr
3343 badges = self._extract_badges([traverse_obj(comment_renderer, 'authorCommentBadge')])
3344 if self._has_badge(badges, BadgeType.VERIFIED):
3345 info['author_is_verified'] = True
3347 is_pinned = traverse_obj(comment_renderer, 'pinnedCommentBadge')
3349 info['is_pinned'] = True
3353 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3355 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3357 def extract_header(contents):
3358 _continuation = None
3359 for content in contents:
3360 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3361 expected_comment_count = self._get_count(
3362 comments_header_renderer, 'countText', 'commentsCount')
3364 if expected_comment_count is not None:
3365 tracker['est_total'] = expected_comment_count
3366 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3367 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3369 sort_menu_item = try_get(
3370 comments_header_renderer,
3371 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3372 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3374 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3375 if not _continuation:
3378 sort_text = str_or_none(sort_menu_item.get('title'))
3380 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3381 self.to_screen('Sorting comments by %s' % sort_text.lower())
3383 return _continuation
3385 def extract_thread(contents):
3387 tracker['current_page_thread'] = 0
3388 for content in contents:
3389 if not parent and tracker['total_parent_comments'] >= max_parents:
3391 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3392 comment_renderer = get_first(
3393 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3394 expected_type=dict, default={})
3396 comment = self._extract_comment(comment_renderer, parent)
3399 comment_id = comment['id']
3400 if comment.get('is_pinned'):
3401 tracker['pinned_comment_ids'].add(comment_id)
3402 # Sometimes YouTube may break and give us infinite looping comments.
3403 # See: https://github.com/yt-dlp/yt-dlp/issues/6290
3404 if comment_id in tracker['seen_comment_ids']:
3405 if comment_id in tracker['pinned_comment_ids'] and not comment.get('is_pinned'):
3406 # Pinned comments may appear a second time in newest first sort
3407 # See: https://github.com/yt-dlp/yt-dlp/issues/6712
3409 self.report_warning('Detected YouTube comments looping. Stopping comment extraction as we probably cannot get any more.')
3412 tracker['seen_comment_ids'].add(comment['id'])
3414 tracker['running_total'] += 1
3415 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3418 # Attempt to get the replies
3419 comment_replies_renderer = try_get(
3420 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3422 if comment_replies_renderer:
3423 tracker['current_page_thread'] += 1
3424 comment_entries_iter = self._comment_entries(
3425 comment_replies_renderer, ytcfg, video_id,
3426 parent=comment.get('id'), tracker=tracker)
3427 yield from itertools.islice(comment_entries_iter, min(
3428 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3430 # Keeps track of counts across recursive calls
3435 current_page_thread=0,
3436 total_parent_comments=0,
3437 total_reply_comments=0,
3438 seen_comment_ids=set(),
3439 pinned_comment_ids=set()
3443 # YouTube comments have a max depth of 2
3444 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3446 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3447 'Set max replies in the max-comments extractor argument instead')
3448 if max_depth == 1 and parent:
3451 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
3452 lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
3454 continuation = self._extract_continuation(root_continuation_data)
3457 is_forced_continuation = False
3458 is_first_continuation = parent is None
3459 if is_first_continuation and not continuation:
3460 # Sometimes you can get comments by generating the continuation yourself,
3461 # even if YouTube initially reports them being disabled - e.g. stories comments.
3462 # Note: if the comment section is actually disabled, YouTube may return a response with
3463 # required check_get_keys missing. So we will disable that check initially in this case.
3464 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3465 is_forced_continuation = True
3467 continuation_items_path = (
3468 'onResponseReceivedEndpoints', ..., ('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems')
3469 for page_num in itertools.count(0):
3470 if not continuation:
3472 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3473 comment_prog_str = f"({tracker['running_total']}
/~{tracker['est_total']}
)"
3475 if is_first_continuation:
3476 note_prefix = 'Downloading comment section API JSON'
3478 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3479 tracker['current_page_thread'], comment_prog_str)
3481 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
3482 ' ' if parent else '', ' replies' if parent else '',
3483 page_num, comment_prog_str)
3485 # Do a deep check for incomplete data as sometimes YouTube may return no comments for a continuation
3486 # Ignore check if YouTube says the comment count is 0.
3487 check_get_keys = None
3488 if not is_forced_continuation and not (tracker['est_total'] == 0 and tracker['running_total'] == 0):
3489 check_get_keys = [[*continuation_items_path, ..., (
3490 'commentsHeaderRenderer' if is_first_continuation else ('commentThreadRenderer', 'commentRenderer'))]]
3492 response = self._extract_response(
3493 item_id=None, query=continuation,
3494 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3495 check_get_keys=check_get_keys)
3496 except ExtractorError as e:
3497 # Ignore incomplete data error for replies if retries didn't work.
3498 # This is to allow any other parent comments and comment threads to be downloaded.
3499 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3500 if 'incomplete data' in str(e).lower() and parent and self.get_param('ignoreerrors') is True:
3501 self.report_warning(
3502 'Received incomplete data for a comment reply thread and retrying did not help. '
3503 'Ignoring to let other comments be downloaded.')
3506 is_forced_continuation = False
3508 for continuation_items in traverse_obj(response, continuation_items_path, expected_type=list, default=[]):
3509 if is_first_continuation:
3510 continuation = extract_header(continuation_items)
3511 is_first_continuation = False
3516 for entry in extract_thread(continuation_items):
3520 continuation = self._extract_continuation({'contents': continuation_items})
3524 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3525 if message and not parent and tracker['running_total'] == 0:
3526 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3527 raise self.CommentsDisabled
3530 def _generate_comment_continuation(video_id):
3532 Generates initial comment section continuation token from given video id
3534 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3535 return base64.b64encode(token.encode()).decode()
3537 def _get_comments(self, ytcfg, video_id, contents, webpage):
3538 """Entry for comment extraction"""
3539 def _real_comment_extract(contents):
3541 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3542 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3543 yield from self._comment_entries(renderer, ytcfg, video_id)
3545 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3546 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3549 def _get_checkok_params():
3550 return {'contentCheckOk': True, 'racyCheckOk': True}
3553 def _generate_player_context(cls, sts=None):
3555 'html5Preference': 'HTML5_PREF_WANTS',
3558 context['signatureTimestamp'] = sts
3560 'playbackContext': {
3561 'contentPlaybackContext': context
3563 **cls._get_checkok_params()
3567 def _is_agegated(player_response):
3568 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3571 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')))
3572 AGE_GATE_REASONS = (
3573 'confirm your age', 'age-restricted', 'inappropriate', # reason
3574 'age_verification_required', 'age_check_required', # status
3576 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3579 def _is_unplayable(player_response):
3580 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3582 _STORY_PLAYER_PARAMS = '8AEB'
3584 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3586 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3587 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3588 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3589 headers = self.generate_api_headers(
3590 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3593 'videoId': video_id,
3595 if smuggled_data.get('is_story') or _split_innertube_client(client)[0] == 'android':
3596 yt_query['params'] = self._STORY_PLAYER_PARAMS
3598 yt_query.update(self._generate_player_context(sts))
3599 return self._extract_response(
3600 item_id=video_id, ep='player', query=yt_query,
3601 ytcfg=player_ytcfg, headers=headers, fatal=True,
3602 default_client=client,
3603 note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
3606 def _get_requested_clients(self, url, smuggled_data):
3607 requested_clients = []
3608 default = ['android', 'web']
3609 allowed_clients = sorted(
3610 (client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'),
3611 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3612 for client in self._configuration_arg('player_client'):
3613 if client in allowed_clients:
3614 requested_clients.append(client)
3615 elif client == 'default':
3616 requested_clients.extend(default)
3617 elif client == 'all':
3618 requested_clients.extend(allowed_clients)
3620 self.report_warning(f'Skipping unsupported client {client}')
3621 if not requested_clients:
3622 requested_clients = default
3624 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3625 requested_clients.extend(
3626 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3628 return orderedSet(requested_clients)
3630 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3633 initial_pr = self._search_json(
3634 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3636 all_clients = set(clients)
3637 clients = clients[::-1]
3640 def append_client(*client_names):
3641 """ Append the first client name that exists but not already used """
3642 for client_name in client_names:
3643 actual_client = _split_innertube_client(client_name)[0]
3644 if actual_client in INNERTUBE_CLIENTS:
3645 if actual_client not in all_clients:
3646 clients.append(client_name)
3647 all_clients.add(actual_client)
3650 # Android player_response does not have microFormats which are needed for
3651 # extraction of some data. So we return the initial_pr with formats
3652 # stripped out even if not requested by the user
3653 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3655 pr = dict(initial_pr)
3656 pr['streamingData'] = None
3660 tried_iframe_fallback = False
3663 client, base_client, variant = _split_innertube_client(clients.pop())
3664 player_ytcfg = master_ytcfg if client == 'web' else {}
3665 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3666 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3668 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3669 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3670 if 'js' in self._configuration_arg('player_skip'):
3671 require_js_player = False
3674 if not player_url and not tried_iframe_fallback and require_js_player:
3675 player_url = self._download_player_url(video_id)
3676 tried_iframe_fallback = True
3679 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3680 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3681 except ExtractorError as e:
3683 self.report_warning(last_error)
3688 # YouTube may return a different video player response than expected.
3689 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3690 pr_video_id = traverse_obj(pr, ('videoDetails', 'videoId'))
3691 if pr_video_id and pr_video_id != video_id:
3692 self.report_warning(
3693 f'Skipping player response from {client} client (got player response for video "{pr_video_id}
" instead of "{video_id}
")' + bug_reports_message())
3695 # Save client name for introspection later
3696 name = short_client_name(client)
3697 sd = traverse_obj(pr, ('streamingData', {dict})) or {}
3698 sd[STREAMING_DATA_CLIENT_NAME] = name
3699 for f in traverse_obj(sd, (('formats', 'adaptiveFormats'), ..., {dict})):
3700 f[STREAMING_DATA_CLIENT_NAME] = name
3703 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3704 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3705 append_client(f'{base_client}_creator')
3706 elif self._is_agegated(pr):
3707 if variant == 'tv_embedded':
3708 append_client(f'{base_client}_embedded')
3710 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3715 self.report_warning(last_error)
3716 return prs, player_url
3718 def _needs_live_processing(self, live_status, duration):
3719 if (live_status == 'is_live' and self.get_param('live_from_start')
3720 or live_status == 'post_live' and (duration or 0) > 4 * 3600):
3723 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3724 CHUNK_SIZE = 10 << 20
3725 itags, stream_ids = collections.defaultdict(set), []
3726 itag_qualities, res_qualities = {}, {0: None}
3728 # Normally tiny is the smallest video-only formats. But
3729 # audio-only formats with unknown quality may get tagged as tiny
3731 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3732 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
3734 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...))
3735 all_formats = self._configuration_arg('include_duplicate_formats')
3737 def build_fragments(f):
3739 'url': update_url_query(f['url'], {
3740 'range': f'{range_start}-{min(range_start + CHUNK_SIZE - 1, f["filesize"])}'
3742 } for range_start in range(0, f['filesize'], CHUNK_SIZE))
3744 for fmt in streaming_formats:
3745 if fmt.get('targetDurationSec'):
3748 itag = str_or_none(fmt.get('itag'))
3749 audio_track = fmt.get('audioTrack') or {}
3750 stream_id = (itag, audio_track.get('id'), fmt.get('isDrc'))
3752 if stream_id in stream_ids:
3755 quality = fmt.get('quality')
3756 height = int_or_none(fmt.get('height'))
3757 if quality == 'tiny' or not quality:
3758 quality = fmt.get('audioQuality', '').lower() or quality
3759 # The 3gp format (17) in android client has a quality of "small
",
3760 # but is actually worse than other formats
3765 itag_qualities[itag] = quality
3767 res_qualities[height] = quality
3768 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3769 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3770 # number of fragment that would subsequently requested with (`&sq=N`)
3771 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3774 fmt_url = fmt.get('url')
3776 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3777 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3778 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3779 if not all((sc, fmt_url, player_url, encrypted_sig)):
3782 fmt_url += '&%s=%s' % (
3783 traverse_obj(sc, ('sp', -1)) or 'signature',
3784 self._decrypt_signature(encrypted_sig, video_id, player_url)
3786 except ExtractorError as e:
3787 self.report_warning('Signature extraction failed: Some formats may be missing',
3788 video_id=video_id, only_once=True)
3789 self.write_debug(e, only_once=True)
3792 query = parse_qs(fmt_url)
3796 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3797 fmt_url = update_url_query(fmt_url, {
3798 'n': decrypt_nsig(query['n'][0], video_id, player_url)
3800 except ExtractorError as e:
3802 if isinstance(e, JSInterpreter.Exception):
3803 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3804 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3806 self.report_warning(
3807 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3808 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3809 self.write_debug(e, only_once=True)
3811 self.report_warning(
3812 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3813 video_id=video_id, only_once=True)
3816 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3817 language_preference = (
3818 10 if audio_track.get('audioIsDefault') and 10
3819 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3821 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3822 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3823 # Make sure to avoid false positives with small duration differences.
3824 # E.g. __2ABJjxzNo, ySuUZEjARPY
3825 is_damaged = try_get(fmt, lambda x: float(x['approxDurationMs']) / duration < 500)
3827 self.report_warning(
3828 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3830 client_name = fmt.get(STREAMING_DATA_CLIENT_NAME)
3832 'asr': int_or_none(fmt.get('audioSampleRate')),
3833 'filesize': int_or_none(fmt.get('contentLength')),
3834 'format_id': f'{itag}{"-drc" if fmt.get("isDrc") else ""}',
3835 'format_note': join_nonempty(
3836 join_nonempty(audio_track.get('displayName'),
3837 language_preference > 0 and ' (default)', delim=''),
3838 fmt.get('qualityLabel') or quality.replace('audio_quality_', ''),
3839 fmt.get('isDrc') and 'DRC',
3840 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3841 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3842 throttled and 'THROTTLED', is_damaged and 'DAMAGED',
3843 (self.get_param('verbose') or all_formats) and client_name,
3845 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3846 'source_preference': -10 if throttled else -5 if itag == '22' else -1,
3847 'fps': int_or_none(fmt.get('fps')) or None,
3848 'audio_channels': fmt.get('audioChannels'),
3850 'quality': q(quality) - bool(fmt.get('isDrc')) / 2,
3851 'has_drm': bool(fmt.get('drmFamilies')),
3854 'width': int_or_none(fmt.get('width')),
3855 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3856 'desc' if language_preference < -1 else '') or None,
3857 'language_preference': language_preference,
3858 # Strictly de-prioritize damaged and 3gp formats
3859 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3861 mime_mobj = re.match(
3862 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3864 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3865 dct.update(parse_codecs(mime_mobj.group(2)))
3867 itags[itag].add(('https
', dct.get('language
')))
3868 stream_ids.append(stream_id)
3869 single_stream = 'none
' in (dct.get('acodec
'), dct.get('vcodec
'))
3870 if single_stream and dct.get('ext
'):
3871 dct['container
'] = dct['ext
'] + '_dash
'
3873 if all_formats and dct['filesize
']:
3876 'format_id
': f'{dct["format_id"]}
-dashy
' if all_formats else dct['format_id
'],
3877 'protocol
': 'http_dash_segments
',
3878 'fragments
': build_fragments(dct),
3880 dct['downloader_options
'] = {'http_chunk_size': CHUNK_SIZE}
3883 needs_live_processing = self._needs_live_processing(live_status, duration)
3884 skip_bad_formats = not self._configuration_arg('include_incomplete_formats
')
3886 skip_manifests = set(self._configuration_arg('skip
'))
3887 if (not self.get_param('youtube_include_hls_manifest
', True)
3888 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3889 or needs_live_processing and skip_bad_formats):
3890 skip_manifests.add('hls
')
3892 if not self.get_param('youtube_include_dash_manifest
', True):
3893 skip_manifests.add('dash
')
3894 if self._configuration_arg('include_live_dash
'):
3895 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3896 'Use include_incomplete_formats extractor argument instead
')
3897 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3898 skip_manifests.add('dash
')
3900 def process_manifest_format(f, proto, client_name, itag):
3901 key = (proto, f.get('language
'))
3902 if not all_formats and key in itags[itag]:
3904 itags[itag].add(key)
3906 if itag and all_formats:
3907 f['format_id
'] = f'{itag}
-{proto}
'
3908 elif any(p != proto for p, _ in itags[itag]):
3909 f['format_id
'] = f'{itag}
-{proto}
'
3911 f['format_id
'] = itag
3913 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
3914 if f['quality
'] == -1 and f.get('height
'):
3915 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
3916 if self.get_param('verbose
'):
3917 f['format_note
'] = join_nonempty(f.get('format_note
'), client_name, delim=', ')
3921 for sd in streaming_data:
3922 client_name = sd.get(STREAMING_DATA_CLIENT_NAME)
3924 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
3925 if hls_manifest_url:
3926 fmts, subs = self._extract_m3u8_formats_and_subtitles(
3927 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
3928 subtitles = self._merge_subtitles(subs, subtitles)
3930 if process_manifest_format(f, 'hls
', client_name, self._search_regex(
3931 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
3934 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
3935 if dash_manifest_url:
3936 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
3937 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
3939 if process_manifest_format(f, 'dash
', client_name, f['format_id
']):
3940 f['filesize
'] = int_or_none(self._search_regex(
3941 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
3942 if needs_live_processing:
3943 f['is_from_start
'] = True
3948 def _extract_storyboard(self, player_responses, duration):
3950 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
3951 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
3955 for i, args in enumerate(spec):
3956 args = args.split('#')
3957 counts
= list(map(int_or_none
, args
[:5]))
3958 if len(args
) != 8 or not all(counts
):
3959 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
3961 width
, height
, frame_count
, cols
, rows
= counts
3964 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
3965 fragment_count
= frame_count
/ (cols
* rows
)
3966 fragment_duration
= duration
/ fragment_count
3968 'format_id': f
'sb{i}',
3969 'format_note': 'storyboard',
3971 'protocol': 'mhtml',
3977 'fps': frame_count
/ duration
,
3981 'url': url
.replace('$M', str(j
)),
3982 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
3983 } for j
in range(math
.ceil(fragment_count
))],
3986 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
3988 if 'webpage' not in self
._configuration
_arg
('player_skip'):
3989 query
= {'bpctr': '9999999999', 'has_verified': '1'}
3990 if smuggled_data
.get('is_story'):
3991 query
['pp'] = self
._STORY
_PLAYER
_PARAMS
3992 webpage
= self
._download
_webpage
(
3993 webpage_url
, video_id
, fatal
=False, query
=query
)
3995 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
3997 player_responses
, player_url
= self
._extract
_player
_responses
(
3998 self
._get
_requested
_clients
(url
, smuggled_data
),
3999 video_id
, webpage
, master_ytcfg
, smuggled_data
)
4001 return webpage
, master_ytcfg
, player_responses
, player_url
4003 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
4004 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
4005 is_live
= get_first(video_details
, 'isLive')
4007 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
4008 live_content
= get_first(video_details
, 'isLiveContent')
4009 is_upcoming
= get_first(video_details
, 'isUpcoming')
4010 post_live
= get_first(video_details
, 'isPostLiveDvr')
4011 live_status
= ('post_live' if post_live
4012 else 'is_live' if is_live
4013 else 'is_upcoming' if is_upcoming
4014 else 'was_live' if live_content
4015 else 'not_live' if False in (is_live
, live_content
)
4017 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'))
4018 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
4020 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
4022 def _real_extract(self
, url
):
4023 url
, smuggled_data
= unsmuggle_url(url
, {})
4024 video_id
= self
._match
_id
(url
)
4026 base_url
= self
.http_scheme() + '//www.youtube.com/'
4027 webpage_url
= base_url
+ 'watch?v=' + video_id
4029 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
4031 playability_statuses
= traverse_obj(
4032 player_responses
, (..., 'playabilityStatus'), expected_type
=dict)
4034 trailer_video_id
= get_first(
4035 playability_statuses
,
4036 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
4038 if trailer_video_id
:
4039 return self
.url_result(
4040 trailer_video_id
, self
.ie_key(), trailer_video_id
)
4042 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
4043 if webpage
else (lambda x
: None))
4045 video_details
= traverse_obj(player_responses
, (..., 'videoDetails'), expected_type
=dict)
4046 microformats
= traverse_obj(
4047 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
4050 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
4051 video_title
= (self
._preferred
_lang
and translated_title
4052 or get_first(video_details
, 'title') # primary
4054 or search_meta(['og:title', 'twitter:title', 'title']))
4055 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
4056 original_description
= get_first(video_details
, 'shortDescription')
4057 video_description
= (
4058 self
._preferred
_lang
and translated_description
4059 # If original description is blank, it will be an empty string.
4060 # Do not prefer translated description in this case.
4061 or original_description
if original_description
is not None else translated_description
)
4063 multifeed_metadata_list
= get_first(
4065 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
4067 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
4068 if self
.get_param('noplaylist'):
4069 self
.to_screen('Downloading just video %s because of --no-playlist' % video_id
)
4073 for feed
in multifeed_metadata_list
.split(','):
4074 # Unquote should take place before split on comma (,) since textual
4075 # fields may contain comma as well (see
4076 # https://github.com/ytdl-org/youtube-dl/issues/8536)
4077 feed_data
= urllib
.parse
.parse_qs(
4078 urllib
.parse
.unquote_plus(feed
))
4080 def feed_entry(name
):
4082 feed_data
, lambda x
: x
[name
][0], str)
4084 feed_id
= feed_entry('id')
4087 feed_title
= feed_entry('title')
4090 title
+= ' (%s)' % feed_title
4092 '_type': 'url_transparent',
4093 'ie_key': 'Youtube',
4095 '%swatch?v=%s' % (base_url
, feed_data
['id'][0]),
4096 {'force_singlefeed': True}
),
4099 feed_ids
.append(feed_id
)
4101 'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
4102 % (', '.join(feed_ids
), video_id
))
4103 return self
.playlist_result(
4104 entries
, video_id
, video_title
, video_description
)
4106 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
4107 or int_or_none(get_first(microformats
, 'lengthSeconds'))
4108 or parse_duration(search_meta('duration')) or None)
4110 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
4111 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
4112 if live_status
== 'post_live':
4113 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
4116 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
4117 self
.report_drm(video_id
)
4119 playability_statuses
,
4120 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
4121 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
4122 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
4124 if subreason
== 'The uploader has not made this video available in your country.':
4125 countries
= get_first(microformats
, 'availableCountries')
4127 regions_allowed
= search_meta('regionsAllowed')
4128 countries
= regions_allowed
.split(',') if regions_allowed
else None
4129 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
4130 reason
+= f
'. {subreason}'
4132 self
.raise_no_formats(reason
, expected
=True)
4134 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
4135 if not keywords
and webpage
:
4137 unescapeHTML(m
.group('content'))
4138 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
4139 for keyword
in keywords
:
4140 if keyword
.startswith('yt:stretch='):
4141 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
4143 # NB: float is intentional for forcing float division
4144 w
, h
= (float(v
) for v
in mobj
.groups())
4148 if f
.get('vcodec') != 'none':
4149 f
['stretched_ratio'] = ratio
4151 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
4152 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
4155 'url': thumbnail_url
,
4157 original_thumbnails
= thumbnails
.copy()
4159 # The best resolution thumbnails sometimes does not appear in the webpage
4160 # See: https://github.com/yt-dlp/yt-dlp/issues/340
4161 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
4163 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
4164 # in resolution, these are not the custom thumbnail. So de-prioritize them
4165 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
4166 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3'
4168 n_thumbnail_names
= len(thumbnail_names
)
4170 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
4171 video_id
=video_id
, name
=name
, ext
=ext
,
4172 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
4173 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
4174 for thumb
in thumbnails
:
4175 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
4176 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
4177 self
._remove
_duplicate
_formats
(thumbnails
)
4178 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
4180 category
= get_first(microformats
, 'category') or search_meta('genre')
4181 channel_id
= self
.ucid_or_none(str_or_none(
4182 get_first(video_details
, 'channelId')
4183 or get_first(microformats
, 'externalChannelId')
4184 or search_meta('channelId')))
4185 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
4187 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
4188 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
4189 if not duration
and live_end_time
and live_start_time
:
4190 duration
= live_end_time
- live_start_time
4192 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
4194 def is_bad_format(fmt
):
4195 if needs_live_processing
and not fmt
.get('is_from_start'):
4197 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
4198 and fmt
.get('protocol') == 'http_dash_segments'):
4201 for fmt
in filter(is_bad_format
, formats
):
4202 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4203 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 4 hours)', delim
=' ')
4205 if needs_live_processing
:
4206 self
._prepare
_live
_from
_start
_formats
(
4207 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4209 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4211 channel_handle
= self
.handle_from_url(owner_profile_url
)
4215 'title': video_title
,
4217 'thumbnails': thumbnails
,
4218 # The best thumbnail that we are sure exists. Prevents unnecessary
4219 # URL checking if user don't care about getting the best possible thumbnail
4220 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4221 'description': video_description
,
4222 'channel_id': channel_id
,
4223 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None),
4224 'duration': duration
,
4225 'view_count': int_or_none(
4226 get_first((video_details
, microformats
), (..., 'viewCount'))
4227 or search_meta('interactionCount')),
4228 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4229 'age_limit': 18 if (
4230 get_first(microformats
, 'isFamilySafe') is False
4231 or search_meta('isFamilyFriendly') == 'false'
4232 or search_meta('og:restrictions:age') == '18+') else 0,
4233 'webpage_url': webpage_url
,
4234 'categories': [category
] if category
else None,
4236 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4237 'live_status': live_status
,
4238 'release_timestamp': live_start_time
,
4239 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4240 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto')
4244 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4246 def get_lang_code(track
):
4247 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4248 or track
.get('languageCode'))
4250 # Converted into dicts to remove duplicates
4252 get_lang_code(sub
): sub
4253 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...))}
4254 translation_languages
= {
4255 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4256 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...))}
4258 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4259 lang_subs
= container
.setdefault(lang_code
, [])
4260 for fmt
in self
._SUBTITLE
_FORMATS
:
4266 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4270 # NB: Constructing the full subtitle dictionary is slow
4271 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4272 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4273 for lang_code
, caption_track
in captions
.items():
4274 base_url
= caption_track
.get('baseUrl')
4275 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4278 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4279 if caption_track
.get('kind') != 'asr':
4283 subtitles
, base_url
, lang_code
, lang_name
, {})
4284 if not caption_track
.get('isTranslatable'):
4286 for trans_code
, trans_name
in translation_languages
.items():
4289 orig_trans_code
= trans_code
4290 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4291 if not get_translated_subs
:
4293 trans_code
+= f
'-{lang_code}'
4294 trans_name
+= format_field(lang_name
, None, ' from %s')
4295 # Add an "-orig" label to the original language so that it can be distinguished.
4296 # The subs are returned without "-orig" as well for compatibility
4297 if lang_code
== f
'a-{orig_trans_code}':
4299 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4300 # Setting tlang=lang returns damaged subtitles.
4301 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4302 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4304 info
['automatic_captions'] = automatic_captions
4305 info
['subtitles'] = subtitles
4307 parsed_url
= urllib
.parse
.urlparse(url
)
4308 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4309 query
= urllib
.parse
.parse_qs(component
)
4310 for k
, v
in query
.items():
4311 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4313 if d_k
not in info
and k
in s_ks
:
4314 info
[d_k
] = parse_duration(query
[k
][0])
4316 # Youtube Music Auto-generated description
4317 if video_description
:
4320 (?P<track>[^·\n]+)·(?P<artist>[^\n]+)\n+
4322 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4323 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4324 (.+?\nArtist\s*:\s*(?P<clean_artist>[^\n]+))?
4325 .+\nAuto-generated\ by\ YouTube\.\s*$
4326 ''', video_description
)
4328 release_year
= mobj
.group('release_year')
4329 release_date
= mobj
.group('release_date')
4331 release_date
= release_date
.replace('-', '')
4332 if not release_year
:
4333 release_year
= release_date
[:4]
4335 'album': mobj
.group('album'.strip()),
4336 'artist': mobj
.group('clean_artist') or ', '.join(a
.strip() for a
in mobj
.group('artist').split('·')),
4337 'track': mobj
.group('track').strip(),
4338 'release_date': release_date
,
4339 'release_year': int_or_none(release_year
),
4344 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4345 if not traverse_obj(initial_data
, 'contents'):
4346 self
.report_warning('Incomplete data received in embedded initial data; re-fetching using API.')
4348 if not initial_data
:
4349 query
= {'videoId': video_id}
4350 query
.update(self
._get
_checkok
_params
())
4351 initial_data
= self
._extract
_response
(
4352 item_id
=video_id
, ep
='next', fatal
=False,
4353 ytcfg
=master_ytcfg
, query
=query
, check_get_keys
='contents',
4354 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4355 note
='Downloading initial data API JSON')
4357 info
['comment_count'] = traverse_obj(initial_data
, (
4358 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4359 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount'
4361 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4362 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo'
4363 ), expected_type
=self
._get
_count
, get_all
=False)
4365 try: # This will error if there is no livechat
4366 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4367 except (KeyError, IndexError, TypeError):
4370 info
.setdefault('subtitles', {})['live_chat'] = [{
4371 # url is needed to set cookies
4372 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4373 'video_id': video_id
,
4375 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4376 else 'youtube_live_chat_replay'),
4380 info
['chapters'] = (
4381 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4382 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4383 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4386 info
['heatmap'] = self
._extract
_heatmap
_from
_player
_overlay
(initial_data
)
4388 contents
= traverse_obj(
4389 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4390 expected_type
=list, default
=[])
4392 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4394 stl
= vpir
.get('superTitleLink')
4396 stl
= self
._get
_text
(stl
)
4399 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4400 info
['location'] = stl
4402 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4405 'series': mobj
.group(1),
4406 'season_number': int(mobj
.group(2)),
4407 'episode_number': int(mobj
.group(3)),
4409 for tlb
in (try_get(
4411 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4415 tlb
, ('toggleButtonRenderer', ...),
4416 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer')))
4418 for getter
, regex
in [(
4419 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4420 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4421 lambda x
: x
['accessibility'],
4422 lambda x
: x
['accessibilityData']['accessibilityData'],
4423 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4424 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4426 mobj
= re
.match(regex
, label
)
4428 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4430 sbr_tooltip
= try_get(
4431 vpir
, lambda x
: x
['sentimentBar']['sentimentBarRenderer']['tooltip'])
4433 like_count
, dislike_count
= sbr_tooltip
.split(' / ')
4435 'like_count': str_to_int(like_count
),
4436 'dislike_count': str_to_int(dislike_count
),
4438 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4440 vc
= self
._get
_count
(vcr
, 'viewCount')
4441 # Upcoming premieres with waiting count are treated as live here
4442 if vcr
.get('isLive'):
4443 info
['concurrent_view_count'] = vc
4444 elif info
.get('view_count') is None:
4445 info
['view_count'] = vc
4447 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4449 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4451 'channel': self
._get
_text
(vor
, 'title'),
4452 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4454 if not channel_handle
:
4455 channel_handle
= self
.handle_from_url(
4457 ('navigationEndpoint', ('title', 'runs', ..., 'navigationEndpoint')),
4458 (('commandMetadata', 'webCommandMetadata', 'url'), ('browseEndpoint', 'canonicalBaseUrl')),
4459 {str}
), get_all
=False))
4463 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4465 multiple_songs
= False
4467 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4468 multiple_songs
= True
4471 mrr
= row
.get('metadataRowRenderer') or {}
4472 mrr_title
= mrr
.get('title')
4475 mrr_title
= self
._get
_text
(mrr
, 'title')
4476 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4477 if mrr_title
== 'License':
4478 info
['license'] = mrr_contents_text
4479 elif not multiple_songs
:
4480 if mrr_title
== 'Album':
4481 info
['album'] = mrr_contents_text
4482 elif mrr_title
== 'Artist':
4483 info
['artist'] = mrr_contents_text
4484 elif mrr_title
== 'Song':
4485 info
['track'] = mrr_contents_text
4488 'uploader': info
.get('channel'),
4489 'uploader_id': channel_handle
,
4490 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4492 # The upload date for scheduled, live and past live streams / premieres in microformats
4493 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4494 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4496 unified_strdate(get_first(microformats
, 'uploadDate'))
4497 or unified_strdate(search_meta('uploadDate')))
4498 if not upload_date
or (
4499 live_status
in ('not_live', None)
4500 and 'no-youtube-prefer-utc-upload-date' not in self
.get_param('compat_opts', [])
4502 upload_date
= strftime_or_none(
4503 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText')), '%Y%m%d') or upload_date
4504 info
['upload_date'] = upload_date
4506 for s_k
, d_k
in [('artist', 'creator'), ('track', 'alt_title')]:
4511 badges
= self
._extract
_badges
(traverse_obj(vpir
, 'badges'))
4513 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4514 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4516 info
['availability'] = (
4517 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4518 else self
._availability
(
4519 is_private
=is_private
,
4521 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4522 or False if initial_data
and is_private
is not None else None),
4523 needs_subscription
=(
4524 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4525 or False if initial_data
and is_private
is not None else None),
4526 needs_auth
=info
['age_limit'] >= 18,
4527 is_unlisted
=None if is_private
is None else (
4528 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4529 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4531 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4533 self
.mark_watched(video_id
, player_responses
)
4538 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4540 def passthrough_smuggled_data(func
):
4541 def _smuggle(info
, smuggled_data
):
4542 if info
.get('_type') not in ('url', 'url_transparent'):
4544 if smuggled_data
.get('is_music_url'):
4545 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4546 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4547 smuggled_data
.pop('is_music_url')
4548 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4550 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4553 @functools.wraps(func
)
4554 def wrapper(self
, url
):
4555 url
, smuggled_data
= unsmuggle_url(url
, {})
4556 if self
.is_music_url(url
):
4557 smuggled_data
['is_music_url'] = True
4558 info_dict
= func(self
, url
, smuggled_data
)
4560 _smuggle(info_dict
, smuggled_data
)
4561 if info_dict
.get('entries'):
4562 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4567 def _extract_basic_item_renderer(item
):
4568 # Modified from _extract_grid_item_renderer
4569 known_basic_renderers
= (
4570 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer'
4572 for key
, renderer
in item
.items():
4573 if not isinstance(renderer
, dict):
4575 elif key
in known_basic_renderers
:
4577 elif key
.startswith('grid') and key
.endswith('Renderer'):
4580 def _extract_channel_renderer(self
, renderer
):
4581 channel_id
= self
.ucid_or_none(renderer
['channelId'])
4582 title
= self
._get
_text
(renderer
, 'title')
4583 channel_url
= format_field(channel_id
, None, 'https://www.youtube.com/channel/%s', default
=None)
4584 channel_handle
= self
.handle_from_url(
4585 traverse_obj(renderer
, (
4586 'navigationEndpoint', (('commandMetadata', 'webCommandMetadata', 'url'),
4587 ('browseEndpoint', 'canonicalBaseUrl')),
4588 {str}
), get_all
=False))
4589 if not channel_handle
:
4590 # As of 2023-06-01, YouTube sets subscriberCountText to the handle in search
4591 channel_handle
= self
.handle_or_none(self
._get
_text
(renderer
, 'subscriberCountText'))
4596 'ie_key': YoutubeTabIE
.ie_key(),
4599 'channel_id': channel_id
,
4600 'channel_url': channel_url
,
4602 'uploader_id': channel_handle
,
4603 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
4604 # See above. YouTube sets videoCountText to the subscriber text in search channel renderers.
4605 # However, in feed/channels this is set correctly to the subscriber count
4606 'channel_follower_count': traverse_obj(
4607 renderer
, 'subscriberCountText', 'videoCountText', expected_type
=self
._get
_count
),
4608 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
4610 # videoCountText may be the subscriber count
4611 self
._get
_count
(renderer
, 'videoCountText')
4612 if self
._get
_count
(renderer
, 'subscriberCountText') is not None else None),
4613 'description': self
._get
_text
(renderer
, 'descriptionSnippet'),
4616 def _grid_entries(self
, grid_renderer
):
4617 for item
in grid_renderer
['items']:
4618 if not isinstance(item
, dict):
4620 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4621 if not isinstance(renderer
, dict):
4623 title
= self
._get
_text
(renderer
, 'title')
4626 playlist_id
= renderer
.get('playlistId')
4628 yield self
.url_result(
4629 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4630 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4634 video_id
= renderer
.get('videoId')
4636 yield self
._extract
_video
(renderer
)
4639 channel_id
= renderer
.get('channelId')
4641 yield self
._extract
_channel
_renderer
(renderer
)
4643 # generic endpoint URL support
4644 ep_url
= urljoin('https://www.youtube.com/', try_get(
4645 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4648 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4649 if ie
.suitable(ep_url
):
4650 yield self
.url_result(
4651 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4654 def _music_reponsive_list_entry(self
, renderer
):
4655 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4657 title
= traverse_obj(renderer
, (
4658 'flexColumns', 0, 'musicResponsiveListItemFlexColumnRenderer',
4659 'text', 'runs', 0, 'text'))
4660 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4661 ie
=YoutubeIE
.ie_key(), video_id
=video_id
, title
=title
)
4662 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4664 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4666 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4667 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4668 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4669 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4670 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4672 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4673 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4675 def _shelf_entries_from_content(self
, shelf_renderer
):
4676 content
= shelf_renderer
.get('content')
4677 if not isinstance(content
, dict):
4679 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4681 # TODO: add support for nested playlists so each shelf is processed
4682 # as separate playlist
4683 # TODO: this includes only first N items
4684 yield from self
._grid
_entries
(renderer
)
4685 renderer
= content
.get('horizontalListRenderer')
4690 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4692 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4694 shelf_url
= urljoin('https://www.youtube.com', ep
)
4696 # Skipping links to another channels, note that checking for
4697 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4699 if skip_channels
and '/channels?' in shelf_url
:
4701 title
= self
._get
_text
(shelf_renderer
, 'title')
4702 yield self
.url_result(shelf_url
, video_title
=title
)
4703 # Shelf may not contain shelf URL, fallback to extraction from content
4704 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4706 def _playlist_entries(self
, video_list_renderer
):
4707 for content
in video_list_renderer
['contents']:
4708 if not isinstance(content
, dict):
4710 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4711 if not isinstance(renderer
, dict):
4713 video_id
= renderer
.get('videoId')
4716 yield self
._extract
_video
(renderer
)
4718 def _rich_entries(self
, rich_grid_renderer
):
4719 renderer
= traverse_obj(
4721 ('content', ('videoRenderer', 'reelItemRenderer', 'playlistRenderer')), get_all
=False) or {}
4722 video_id
= renderer
.get('videoId')
4724 yield self
._extract
_video
(renderer
)
4726 playlist_id
= renderer
.get('playlistId')
4728 yield self
.url_result(
4729 f
'https://www.youtube.com/playlist?list={playlist_id}',
4730 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4731 video_title
=self
._get
_text
(renderer
, 'title'))
4734 def _video_entry(self
, video_renderer
):
4735 video_id
= video_renderer
.get('videoId')
4737 return self
._extract
_video
(video_renderer
)
4739 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4740 url
= urljoin('https://youtube.com', traverse_obj(
4741 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4743 return self
.url_result(
4744 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4746 def _post_thread_entries(self
, post_thread_renderer
):
4747 post_renderer
= try_get(
4748 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4749 if not post_renderer
:
4752 video_renderer
= try_get(
4753 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4754 video_id
= video_renderer
.get('videoId')
4756 entry
= self
._extract
_video
(video_renderer
)
4759 # playlist attachment
4760 playlist_id
= try_get(
4761 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4763 yield self
.url_result(
4764 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4765 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4766 # inline video links
4767 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4769 if not isinstance(run
, dict):
4772 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4775 if not YoutubeIE
.suitable(ep_url
):
4777 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4778 if video_id
== ep_video_id
:
4780 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4782 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4783 contents
= post_thread_continuation
.get('contents')
4784 if not isinstance(contents
, list):
4786 for content
in contents
:
4787 renderer
= content
.get('backstagePostThreadRenderer')
4788 if isinstance(renderer
, dict):
4789 yield from self
._post
_thread
_entries
(renderer
)
4791 renderer
= content
.get('videoRenderer')
4792 if isinstance(renderer
, dict):
4793 yield self
._video
_entry
(renderer
)
4796 def _rich_grid_entries(self, contents):
4797 for content in contents:
4798 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4800 entry = self._video_entry(video_renderer)
4805 def _report_history_entries(self
, renderer
):
4806 for url
in traverse_obj(renderer
, (
4807 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4808 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4809 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4810 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4812 def _extract_entries(self
, parent_renderer
, continuation_list
):
4813 # continuation_list is modified in-place with continuation_list = [continuation_token]
4814 continuation_list
[:] = [None]
4815 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4816 for content
in contents
:
4817 if not isinstance(content
, dict):
4819 is_renderer
= traverse_obj(
4820 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4823 if content
.get('richItemRenderer'):
4824 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4826 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4827 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4828 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4829 yield from self
._report
_history
_entries
(table
)
4830 continuation_list
[0] = self
._extract
_continuation
(table
)
4833 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4834 for isr_content
in isr_contents
:
4835 if not isinstance(isr_content
, dict):
4839 'playlistVideoListRenderer': self
._playlist
_entries
,
4840 'gridRenderer': self
._grid
_entries
,
4841 'reelShelfRenderer': self
._grid
_entries
,
4842 'shelfRenderer': self
._shelf
_entries
,
4843 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4844 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4845 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4846 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4847 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4848 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)]
4850 for key
, renderer
in isr_content
.items():
4851 if key
not in known_renderers
:
4853 for entry
in known_renderers
[key
](renderer
):
4856 continuation_list
[0] = self
._extract
_continuation
(renderer
)
4859 if not continuation_list
[0]:
4860 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
4862 if not continuation_list
[0]:
4863 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4865 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
4866 continuation_list
= [None]
4867 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
4868 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
4872 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
4873 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
4874 yield from extract_entries(parent_renderer
)
4875 continuation
= continuation_list
[0]
4877 for page_num
in itertools
.count(1):
4878 if not continuation
:
4880 headers
= self
.generate_api_headers(
4881 ytcfg
=ytcfg
, account_syncid
=account_syncid
, visitor_data
=visitor_data
)
4882 response
= self
._extract
_response
(
4883 item_id
=f
'{item_id} page {page_num}',
4884 query
=continuation
, headers
=headers
, ytcfg
=ytcfg
,
4885 check_get_keys
=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4889 # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
4890 # See: https://github.com/ytdl-org/youtube-dl/issues/28702
4891 visitor_data
= self
._extract
_visitor
_data
(response
) or visitor_data
4894 'videoRenderer': (self
._grid
_entries
, 'items'), # for membership tab
4895 'gridPlaylistRenderer': (self
._grid
_entries
, 'items'),
4896 'gridVideoRenderer': (self
._grid
_entries
, 'items'),
4897 'gridChannelRenderer': (self
._grid
_entries
, 'items'),
4898 'playlistVideoRenderer': (self
._playlist
_entries
, 'contents'),
4899 'itemSectionRenderer': (extract_entries
, 'contents'), # for feeds
4900 'richItemRenderer': (extract_entries
, 'contents'), # for hashtag
4901 'backstagePostThreadRenderer': (self
._post
_thread
_continuation
_entries
, 'contents'),
4902 'reportHistoryTableRowRenderer': (self
._report
_history
_entries
, 'rows'),
4903 'playlistVideoListContinuation': (self
._playlist
_entries
, None),
4904 'gridContinuation': (self
._grid
_entries
, None),
4905 'itemSectionContinuation': (self
._post
_thread
_continuation
_entries
, None),
4906 'sectionListContinuation': (extract_entries
, None), # for feeds
4909 continuation_items
= traverse_obj(response
, (
4910 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
4911 'appendContinuationItemsAction', 'continuationItems'
4912 ), 'continuationContents', get_all
=False)
4913 continuation_item
= traverse_obj(continuation_items
, 0, None, expected_type
=dict, default
={})
4915 video_items_renderer
= None
4916 for key
in continuation_item
.keys():
4917 if key
not in known_renderers
:
4919 func
, parent_key
= known_renderers
[key
]
4920 video_items_renderer
= {parent_key: continuation_items}
if parent_key
else continuation_items
4921 continuation_list
= [None]
4922 yield from func(video_items_renderer
)
4923 continuation
= continuation_list
[0] or self
._extract
_continuation
(video_items_renderer
)
4925 if not video_items_renderer
:
4929 def _extract_selected_tab(tabs
, fatal
=True):
4930 for tab_renderer
in tabs
:
4931 if tab_renderer
.get('selected'):
4934 raise ExtractorError('Unable to find selected tab')
4937 def _extract_tab_renderers(response
):
4938 return traverse_obj(
4939 response
, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type
=dict)
4941 def _extract_from_tabs(self
, item_id
, ytcfg
, data
, tabs
):
4942 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
4944 selected_tab
= self
._extract
_selected
_tab
(tabs
)
4945 metadata
['title'] += format_field(selected_tab
, 'title', ' - %s')
4946 metadata
['title'] += format_field(selected_tab
, 'expandedText', ' - %s')
4948 return self
.playlist_result(
4950 selected_tab
, metadata
['id'], ytcfg
,
4951 self
._extract
_account
_syncid
(ytcfg
, data
),
4952 self
._extract
_visitor
_data
(data
, ytcfg
)),
4955 def _extract_metadata_from_tabs(self
, item_id
, data
):
4956 info
= {'id': item_id}
4958 metadata_renderer
= traverse_obj(data
, ('metadata', 'channelMetadataRenderer'), expected_type
=dict)
4959 if metadata_renderer
:
4960 channel_id
= traverse_obj(metadata_renderer
, ('externalId', {self.ucid_or_none}
),
4961 ('channelUrl', {self.ucid_from_url}
))
4963 'channel': metadata_renderer
.get('title'),
4964 'channel_id': channel_id
,
4966 if info
['channel_id']:
4967 info
['id'] = info
['channel_id']
4969 metadata_renderer
= traverse_obj(data
, ('metadata', 'playlistMetadataRenderer'), expected_type
=dict)
4971 # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
4972 # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
4973 def _get_uncropped(url
):
4974 return url_or_none((url
or '').split('=')[0] + '=s0')
4976 avatar_thumbnails
= self
._extract
_thumbnails
(metadata_renderer
, 'avatar')
4977 if avatar_thumbnails
:
4978 uncropped_avatar
= _get_uncropped(avatar_thumbnails
[0]['url'])
4979 if uncropped_avatar
:
4980 avatar_thumbnails
.append({
4981 'url': uncropped_avatar
,
4982 'id': 'avatar_uncropped',
4986 channel_banners
= self
._extract
_thumbnails
(
4987 data
, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
4988 for banner
in channel_banners
:
4989 banner
['preference'] = -10
4992 uncropped_banner
= _get_uncropped(channel_banners
[0]['url'])
4993 if uncropped_banner
:
4994 channel_banners
.append({
4995 'url': uncropped_banner
,
4996 'id': 'banner_uncropped',
5000 # Deprecated - remove primary_sidebar_renderer when layout discontinued
5001 primary_sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer')
5002 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer'), expected_type
=dict)
5004 primary_thumbnails
= self
._extract
_thumbnails
(
5005 primary_sidebar_renderer
, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
5006 playlist_thumbnails
= self
._extract
_thumbnails
(
5007 playlist_header_renderer
, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
5010 'title': (traverse_obj(metadata_renderer
, 'title')
5011 or self
._get
_text
(data
, ('header', 'hashtagHeaderRenderer', 'hashtag'))
5013 'availability': self
._extract
_availability
(data
),
5014 'channel_follower_count': self
._get
_count
(data
, ('header', ..., 'subscriberCountText')),
5015 'description': try_get(metadata_renderer
, lambda x
: x
.get('description', '')),
5016 'tags': try_get(metadata_renderer
or {}, lambda x
: x
.get('keywords', '').split()),
5017 'thumbnails': (primary_thumbnails
or playlist_thumbnails
) + avatar_thumbnails
+ channel_banners
,
5021 traverse_obj(metadata_renderer
, (('vanityChannelUrl', ('ownerUrls', ...)), {self.handle_from_url}
), get_all
=False)
5022 or traverse_obj(data
, ('header', ..., 'channelHandleText', {self.handle_or_none}
), get_all
=False))
5026 'uploader_id': channel_handle
,
5027 'uploader_url': format_field(channel_handle
, None, 'https://www.youtube.com/%s', default
=None),
5029 # Playlist stats is a text runs array containing [video count, view count, last updated].
5030 # last updated or (view count and last updated) may be missing.
5031 playlist_stats
= get_first(
5032 (primary_sidebar_renderer
, playlist_header_renderer
), (('stats', 'briefStats', 'numVideosText'), ))
5034 last_updated_unix
= self
._parse
_time
_text
(
5035 self
._get
_text
(playlist_stats
, 2) # deprecated, remove when old layout discontinued
5036 or self
._get
_text
(playlist_header_renderer
, ('byline', 1, 'playlistBylineRenderer', 'text')))
5037 info
['modified_date'] = strftime_or_none(last_updated_unix
, '%Y%m%d')
5039 info
['view_count'] = self
._get
_count
(playlist_stats
, 1)
5040 if info
['view_count'] is None: # 0 is allowed
5041 info
['view_count'] = self
._get
_count
(playlist_header_renderer
, 'viewCountText')
5042 if info
['view_count'] is None:
5043 info
['view_count'] = self
._get
_count
(data
, (
5044 'contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., 'tabRenderer', 'content', 'sectionListRenderer',
5045 'contents', ..., 'itemSectionRenderer', 'contents', ..., 'channelAboutFullMetadataRenderer', 'viewCountText'))
5047 info
['playlist_count'] = self
._get
_count
(playlist_stats
, 0)
5048 if info
['playlist_count'] is None: # 0 is allowed
5049 info
['playlist_count'] = self
._get
_count
(playlist_header_renderer
, ('byline', 0, 'playlistBylineRenderer', 'text'))
5051 if not info
.get('channel_id'):
5052 owner
= traverse_obj(playlist_header_renderer
, 'ownerText')
5053 if not owner
: # Deprecated
5054 owner
= traverse_obj(
5055 self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarSecondaryInfoRenderer'),
5056 ('videoOwner', 'videoOwnerRenderer', 'title'))
5057 owner_text
= self
._get
_text
(owner
)
5058 browse_ep
= traverse_obj(owner
, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
5060 'channel': self
._search
_regex
(r
'^by (.+) and \d+ others?$', owner_text
, 'uploader', default
=owner_text
),
5061 'channel_id': self
.ucid_or_none(browse_ep
.get('browseId')),
5062 'uploader_id': self
.handle_from_url(urljoin('https://www.youtube.com', browse_ep
.get('canonicalBaseUrl')))
5066 'uploader': info
['channel'],
5067 'channel_url': format_field(info
.get('channel_id'), None, 'https://www.youtube.com/channel/%s', default
=None),
5068 'uploader_url': format_field(info
.get('uploader_id'), None, 'https://www.youtube.com/%s', default
=None),
5073 def _extract_inline_playlist(self
, playlist
, playlist_id
, data
, ytcfg
):
5074 first_id
= last_id
= response
= None
5075 for page_num
in itertools
.count(1):
5076 videos
= list(self
._playlist
_entries
(playlist
))
5079 start
= next((i
for i
, v
in enumerate(videos
) if v
['id'] == last_id
), -1) + 1
5080 if start
>= len(videos
):
5082 yield from videos
[start
:]
5083 first_id
= first_id
or videos
[0]['id']
5084 last_id
= videos
[-1]['id']
5085 watch_endpoint
= try_get(
5086 playlist
, lambda x
: x
['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
5087 headers
= self
.generate_api_headers(
5088 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5089 visitor_data
=self
._extract
_visitor
_data
(response
, data
, ytcfg
))
5091 'playlistId': playlist_id
,
5092 'videoId': watch_endpoint
.get('videoId') or last_id
,
5093 'index': watch_endpoint
.get('index') or len(videos
),
5094 'params': watch_endpoint
.get('params') or 'OAE%3D'
5096 response
= self
._extract
_response
(
5097 item_id
='%s page %d' % (playlist_id
, page_num
),
5098 query
=query
, ep
='next', headers
=headers
, ytcfg
=ytcfg
,
5099 check_get_keys
='contents'
5102 response
, lambda x
: x
['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
5104 def _extract_from_playlist(self
, item_id
, url
, data
, playlist
, ytcfg
):
5105 title
= playlist
.get('title') or try_get(
5106 data
, lambda x
: x
['titleText']['simpleText'], str)
5107 playlist_id
= playlist
.get('playlistId') or item_id
5109 # Delegating everything except mix playlists to regular tab-based playlist URL
5110 playlist_url
= urljoin(url
, try_get(
5111 playlist
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
5114 # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
5115 # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
5116 is_known_unviewable
= re
.fullmatch(r
'MLCT|RLTD[\w-]{22}', playlist_id
)
5118 if playlist_url
and playlist_url
!= url
and not is_known_unviewable
:
5119 return self
.url_result(
5120 playlist_url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
5123 return self
.playlist_result(
5124 self
._extract
_inline
_playlist
(playlist
, playlist_id
, data
, ytcfg
),
5125 playlist_id
=playlist_id
, playlist_title
=title
)
5127 def _extract_availability(self
, data
):
5129 Gets the availability of a given playlist/tab.
5130 Note: Unless YouTube tells us explicitly, we do not assume it is public
5131 @param data: response
5133 sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer') or {}
5134 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer')) or {}
5135 player_header_privacy
= playlist_header_renderer
.get('privacy')
5137 badges
= self
._extract
_badges
(traverse_obj(sidebar_renderer
, 'badges'))
5139 # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
5140 privacy_setting_icon
= get_first(
5141 (playlist_header_renderer
, sidebar_renderer
),
5142 ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
5143 lambda _
, v
: v
['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
5146 microformats_is_unlisted
= traverse_obj(
5147 data
, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type
=bool)
5151 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
5152 or player_header_privacy
== 'PUBLIC'
5153 or privacy_setting_icon
== 'PRIVACY_PUBLIC')
5154 else self
._availability
(
5156 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
5157 or player_header_privacy
== 'PRIVATE' if player_header_privacy
is not None
5158 else privacy_setting_icon
== 'PRIVACY_PRIVATE' if privacy_setting_icon
is not None else None),
5160 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
5161 or player_header_privacy
== 'UNLISTED' if player_header_privacy
is not None
5162 else privacy_setting_icon
== 'PRIVACY_UNLISTED' if privacy_setting_icon
is not None
5163 else microformats_is_unlisted
if microformats_is_unlisted
is not None else None),
5164 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
5165 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
5169 def _extract_sidebar_info_renderer(data
, info_renderer
, expected_type
=dict):
5170 sidebar_renderer
= try_get(
5171 data
, lambda x
: x
['sidebar']['playlistSidebarRenderer']['items'], list) or []
5172 for item
in sidebar_renderer
:
5173 renderer
= try_get(item
, lambda x
: x
[info_renderer
], expected_type
)
5177 def _reload_with_unavailable_videos(self
, item_id
, data
, ytcfg
):
5179 Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
5181 is_playlist
= bool(traverse_obj(
5182 data
, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
5185 headers
= self
.generate_api_headers(
5186 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
5187 visitor_data
=self
._extract
_visitor
_data
(data
, ytcfg
))
5189 'params': 'wgYCCAA=',
5190 'browseId': f
'VL{item_id}'
5192 return self
._extract
_response
(
5193 item_id
=item_id
, headers
=headers
, query
=query
,
5194 check_get_keys
='contents', fatal
=False, ytcfg
=ytcfg
,
5195 note
='Redownloading playlist API JSON with unavailable videos')
5197 @functools.cached_property
5198 def skip_webpage(self
):
5199 return 'webpage' in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key())
5201 def _extract_webpage(self
, url
, item_id
, fatal
=True):
5202 webpage
, data
= None, None
5203 for retry
in self
.RetryManager(fatal
=fatal
):
5205 webpage
= self
._download
_webpage
(url
, item_id
, note
='Downloading webpage')
5206 data
= self
.extract_yt_initial_data(item_id
, webpage
or '', fatal
=fatal
) or {}
5207 except ExtractorError
as e
:
5208 if isinstance(e
.cause
, network_exceptions
):
5209 if not isinstance(e
.cause
, urllib
.error
.HTTPError
) or e
.cause
.code
not in (403, 429):
5212 self
._error
_or
_warning
(e
, fatal
=fatal
)
5216 self
._extract
_and
_report
_alerts
(data
)
5217 except ExtractorError
as e
:
5218 self
._error
_or
_warning
(e
, fatal
=fatal
)
5221 # Sometimes youtube returns a webpage with incomplete ytInitialData
5222 # See: https://github.com/yt-dlp/yt-dlp/issues/116
5223 if not traverse_obj(data
, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
5224 retry
.error
= ExtractorError('Incomplete yt initial data received')
5227 return webpage
, data
5229 def _report_playlist_authcheck(self
, ytcfg
, fatal
=True):
5230 """Use if failed to extract ytcfg (and data) from initial webpage"""
5231 if not ytcfg
and self
.is_authenticated
:
5232 msg
= 'Playlists that require authentication may not extract correctly without a successful webpage download'
5233 if 'authcheck' not in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key()) and fatal
:
5234 raise ExtractorError(
5235 f
'{msg}. If you are not downloading private content, or '
5236 'your cookies are only for the first account and channel,'
5237 ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
5239 self
.report_warning(msg
, only_once
=True)
5241 def _extract_data(self
, url
, item_id
, ytcfg
=None, fatal
=True, webpage_fatal
=False, default_client
='web'):
5243 if not self
.skip_webpage
:
5244 webpage
, data
= self
._extract
_webpage
(url
, item_id
, fatal
=webpage_fatal
)
5245 ytcfg
= ytcfg
or self
.extract_ytcfg(item_id
, webpage
)
5246 # Reject webpage data if redirected to home page without explicitly requesting
5247 selected_tab
= self
._extract
_selected
_tab
(self
._extract
_tab
_renderers
(data
), fatal
=False) or {}
5248 if (url
!= 'https://www.youtube.com/feed/recommended'
5249 and selected_tab
.get('tabIdentifier') == 'FEwhat_to_watch' # Home page
5250 and 'no-youtube-channel-redirect' not in self
.get_param('compat_opts', [])):
5251 msg
= 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
5253 raise ExtractorError(msg
, expected
=True)
5254 self
.report_warning(msg
, only_once
=True)
5256 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=fatal
)
5257 data
= self
._extract
_tab
_endpoint
(url
, item_id
, ytcfg
, fatal
=fatal
, default_client
=default_client
)
5260 def _extract_tab_endpoint(self
, url
, item_id
, ytcfg
=None, fatal
=True, default_client
='web'):
5261 headers
= self
.generate_api_headers(ytcfg
=ytcfg
, default_client
=default_client
)
5262 resolve_response
= self
._extract
_response
(
5263 item_id
=item_id
, query
={'url': url}
, check_get_keys
='endpoint', headers
=headers
, ytcfg
=ytcfg
, fatal
=fatal
,
5264 ep
='navigation/resolve_url', note
='Downloading API parameters API JSON', default_client
=default_client
)
5265 endpoints
= {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5266 for ep_key
, ep
in endpoints
.items():
5267 params
= try_get(resolve_response
, lambda x
: x
['endpoint'][ep_key
], dict)
5269 return self
._extract
_response
(
5270 item_id
=item_id
, query
=params
, ep
=ep
, headers
=headers
,
5271 ytcfg
=ytcfg
, fatal
=fatal
, default_client
=default_client
,
5272 check_get_keys
=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5273 err_note
= 'Failed to resolve url (does the playlist exist?)'
5275 raise ExtractorError(err_note
, expected
=True)
5276 self
.report_warning(err_note
, item_id
)
5278 _SEARCH_PARAMS
= None
5280 def _search_results(self
, query
, params
=NO_DEFAULT
, default_client
='web'):
5281 data
= {'query': query}
5282 if params
is NO_DEFAULT
:
5283 params
= self
._SEARCH
_PARAMS
5285 data
['params'] = params
5288 ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5289 ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5291 ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5292 ('continuationContents', ),
5294 display_id
= f
'query "{query}"'
5295 check_get_keys
= tuple({keys[0] for keys in content_keys}
)
5296 ytcfg
= self
._download
_ytcfg
(default_client
, display_id
) if not self
.skip_webpage
else {}
5297 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=False)
5299 continuation_list
= [None]
5301 for page_num
in itertools
.count(1):
5302 data
.update(continuation_list
[0] or {})
5303 headers
= self
.generate_api_headers(
5304 ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(search
), default_client
=default_client
)
5305 search
= self
._extract
_response
(
5306 item_id
=f
'{display_id} page {page_num}', ep
='search', query
=data
,
5307 default_client
=default_client
, check_get_keys
=check_get_keys
, ytcfg
=ytcfg
, headers
=headers
)
5308 slr_contents
= traverse_obj(search
, *content_keys
)
5309 yield from self
._extract
_entries
({'contents': list(variadic(slr_contents))}
, continuation_list
)
5310 if not continuation_list
[0]:
5314 class YoutubeTabIE(YoutubeTabBaseInfoExtractor
):
5315 IE_DESC
= 'YouTube Tabs'
5316 _VALID_URL
= r
'''(?x:
5318 (?!consent\.)(?:\w+\.)?
5320 youtube(?:kids)?\.com|
5324 (?P<channel_type>channel|c|user|browse)/|
5327 (?:playlist|watch)\?.*?\blist=
5329 (?!(?:%(reserved_names)s)\b) # Direct URLs
5333 'reserved_names': YoutubeBaseInfoExtractor
._RESERVED
_NAMES
,
5334 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
5336 IE_NAME
= 'youtube:tab'
5339 'note': 'playlists, multipage',
5340 'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5341 'playlist_mincount': 94,
5343 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5344 'title': 'Igor Kleiner - Playlists',
5345 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5346 'uploader': 'Igor Kleiner',
5347 'uploader_id': '@IgorDataScience',
5348 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5349 'channel': 'Igor Kleiner',
5350 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5351 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5352 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5353 'channel_follower_count': int
5356 'note': 'playlists, multipage, different order',
5357 'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5358 'playlist_mincount': 94,
5360 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5361 'title': 'Igor Kleiner - Playlists',
5362 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5363 'uploader': 'Igor Kleiner',
5364 'uploader_id': '@IgorDataScience',
5365 'uploader_url': 'https://www.youtube.com/@IgorDataScience',
5366 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5367 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5368 'channel': 'Igor Kleiner',
5369 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5370 'channel_follower_count': int
5373 'note': 'playlists, series',
5374 'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5375 'playlist_mincount': 5,
5377 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5378 'title': '3Blue1Brown - Playlists',
5379 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5380 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5381 'channel': '3Blue1Brown',
5382 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5383 'uploader_id': '@3blue1brown',
5384 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5385 'uploader': '3Blue1Brown',
5386 'tags': ['Mathematics'],
5387 'channel_follower_count': int,
5390 'note': 'playlists, singlepage',
5391 'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5392 'playlist_mincount': 4,
5394 'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5395 'title': 'ThirstForScience - Playlists',
5396 'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5397 'uploader': 'ThirstForScience',
5398 'uploader_url': 'https://www.youtube.com/@ThirstForScience',
5399 'uploader_id': '@ThirstForScience',
5400 'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5401 'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5403 'channel': 'ThirstForScience',
5404 'channel_follower_count': int
5407 'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5408 'only_matching': True,
5410 'note': 'basic, single video playlist',
5411 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5413 'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5414 'title': 'youtube-dl public playlist',
5418 'modified_date': '20201130',
5419 'channel': 'Sergey M.',
5420 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5421 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5422 'availability': 'public',
5423 'uploader': 'Sergey M.',
5424 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5425 'uploader_id': '@sergeym.6173',
5427 'playlist_count': 1,
5429 'note': 'empty playlist',
5430 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5432 'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5433 'title': 'youtube-dl empty playlist',
5435 'channel': 'Sergey M.',
5437 'modified_date': '20160902',
5438 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5439 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5440 'availability': 'public',
5441 'uploader_url': 'https://www.youtube.com/@sergeym.6173',
5442 'uploader_id': '@sergeym.6173',
5443 'uploader': 'Sergey M.',
5445 'playlist_count': 0,
5448 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5450 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5451 'title': 'lex will - Home',
5452 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5453 'uploader': 'lex will',
5454 'uploader_id': '@lexwill718',
5455 'channel': 'lex will',
5456 'tags': ['bible', 'history', 'prophesy'],
5457 'uploader_url': 'https://www.youtube.com/@lexwill718',
5458 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5459 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5460 'channel_follower_count': int
5462 'playlist_mincount': 2,
5464 'note': 'Videos tab',
5465 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5467 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5468 'title': 'lex will - Videos',
5469 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5470 'uploader': 'lex will',
5471 'uploader_id': '@lexwill718',
5472 'tags': ['bible', 'history', 'prophesy'],
5473 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5474 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5475 'uploader_url': 'https://www.youtube.com/@lexwill718',
5476 'channel': 'lex will',
5477 'channel_follower_count': int
5479 'playlist_mincount': 975,
5481 'note': 'Videos tab, sorted by popular',
5482 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5484 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5485 'title': 'lex will - Videos',
5486 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5487 'uploader': 'lex will',
5488 'uploader_id': '@lexwill718',
5489 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5490 'uploader_url': 'https://www.youtube.com/@lexwill718',
5491 'channel': 'lex will',
5492 'tags': ['bible', 'history', 'prophesy'],
5493 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5494 'channel_follower_count': int
5496 'playlist_mincount': 199,
5498 'note': 'Playlists tab',
5499 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5501 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5502 'title': 'lex will - Playlists',
5503 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5504 'uploader': 'lex will',
5505 'uploader_id': '@lexwill718',
5506 'uploader_url': 'https://www.youtube.com/@lexwill718',
5507 'channel': 'lex will',
5508 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5509 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5510 'tags': ['bible', 'history', 'prophesy'],
5511 'channel_follower_count': int
5513 'playlist_mincount': 17,
5515 'note': 'Community tab',
5516 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5518 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5519 'title': 'lex will - Community',
5520 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5521 'channel': 'lex will',
5522 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5523 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5524 'tags': ['bible', 'history', 'prophesy'],
5525 'channel_follower_count': int,
5526 'uploader_url': 'https://www.youtube.com/@lexwill718',
5527 'uploader_id': '@lexwill718',
5528 'uploader': 'lex will',
5530 'playlist_mincount': 18,
5532 'note': 'Channels tab',
5533 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5535 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5536 'title': 'lex will - Channels',
5537 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5538 'channel': 'lex will',
5539 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5540 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5541 'tags': ['bible', 'history', 'prophesy'],
5542 'channel_follower_count': int,
5543 'uploader_url': 'https://www.youtube.com/@lexwill718',
5544 'uploader_id': '@lexwill718',
5545 'uploader': 'lex will',
5547 'playlist_mincount': 12,
5549 'note': 'Search tab',
5550 'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5551 'playlist_mincount': 40,
5553 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5554 'title': '3Blue1Brown - Search - linear algebra',
5555 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5556 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5557 'tags': ['Mathematics'],
5558 'channel': '3Blue1Brown',
5559 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5560 'channel_follower_count': int,
5561 'uploader_url': 'https://www.youtube.com/@3blue1brown',
5562 'uploader_id': '@3blue1brown',
5563 'uploader': '3Blue1Brown',
5566 'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5567 'only_matching': True,
5569 'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5570 'only_matching': True,
5572 'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5573 'only_matching': True,
5575 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5576 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5578 'title': '29C3: Not my department',
5579 'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5580 'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5583 'modified_date': '20150605',
5584 'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5585 'channel_url': 'https://www.youtube.com/channel/UCEPzS1rYsrkqzSLNp76nrcg',
5586 'channel': 'Christiaan008',
5587 'availability': 'public',
5588 'uploader_id': '@ChRiStIaAn008',
5589 'uploader': 'Christiaan008',
5590 'uploader_url': 'https://www.youtube.com/@ChRiStIaAn008',
5592 'playlist_count': 96,
5594 'note': 'Large playlist',
5595 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5597 'title': 'Uploads from Cauchemar',
5598 'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5599 'channel_url': 'https://www.youtube.com/channel/UCBABnxM4Ar9ten8Mdjj1j0Q',
5601 'modified_date': r
're:\d{8}',
5602 'channel': 'Cauchemar',
5605 'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5606 'availability': 'public',
5607 'uploader_id': '@Cauchemar89',
5608 'uploader': 'Cauchemar',
5609 'uploader_url': 'https://www.youtube.com/@Cauchemar89',
5611 'playlist_mincount': 1123,
5612 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5614 'note': 'even larger playlist, 8832 videos',
5615 'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5616 'only_matching': True,
5618 'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5619 'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5621 'title': 'Uploads from Interstellar Movie',
5622 'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5625 'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5626 'channel_url': 'https://www.youtube.com/channel/UCXw-G3eDE9trcvY2sBMM_aA',
5627 'channel': 'Interstellar Movie',
5629 'modified_date': r
're:\d{8}',
5630 'availability': 'public',
5631 'uploader_id': '@InterstellarMovie',
5632 'uploader': 'Interstellar Movie',
5633 'uploader_url': 'https://www.youtube.com/@InterstellarMovie',
5635 'playlist_mincount': 21,
5637 'note': 'Playlist with "show unavailable videos" button',
5638 'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5640 'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5641 'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5643 'channel': 'Phim Siêu Nhân Nhật Bản',
5646 'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5647 'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5648 'modified_date': r
're:\d{8}',
5649 'availability': 'public',
5650 'uploader_url': 'https://www.youtube.com/@phimsieunhannhatban',
5651 'uploader_id': '@phimsieunhannhatban',
5652 'uploader': 'Phim Siêu Nhân Nhật Bản',
5654 'playlist_mincount': 200,
5655 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5657 'note': 'Playlist with unavailable videos in page 7',
5658 'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5660 'title': 'Uploads from BlankTV',
5661 'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5662 'channel': 'BlankTV',
5663 'channel_url': 'https://www.youtube.com/channel/UC8l9frL61Yl5KFOl87nIm2w',
5664 'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5667 'modified_date': r
're:\d{8}',
5669 'availability': 'public',
5670 'uploader_id': '@blanktv',
5671 'uploader': 'BlankTV',
5672 'uploader_url': 'https://www.youtube.com/@blanktv',
5674 'playlist_mincount': 1000,
5675 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5677 'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5678 'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5680 'title': 'Data Analysis with Dr Mike Pound',
5681 'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5682 'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5685 'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5686 'channel_url': 'https://www.youtube.com/channel/UC9-y-6csu5WGm29I7JiwpnA',
5687 'channel': 'Computerphile',
5688 'availability': 'public',
5689 'modified_date': '20190712',
5690 'uploader_id': '@Computerphile',
5691 'uploader': 'Computerphile',
5692 'uploader_url': 'https://www.youtube.com/@Computerphile',
5694 'playlist_mincount': 11,
5696 'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5697 'only_matching': True,
5699 'note': 'Playlist URL that does not actually serve a playlist',
5700 'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5702 'id': 'FqZTN594JQw',
5704 'title': "Smiley's People 01 detective, Adventure Series, Action",
5705 'upload_date': '20150526',
5706 'license': 'Standard YouTube License',
5707 'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5708 'categories': ['People & Blogs'],
5714 'skip_download': True,
5716 'skip': 'This video is not available.',
5717 'add_ie': [YoutubeIE
.ie_key()],
5719 'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5720 'only_matching': True,
5722 'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5723 'only_matching': True,
5725 'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5727 'id': 'hGkQjiJLjWQ', # This will keep changing
5730 'upload_date': r
're:\d{8}',
5732 'categories': ['News & Politics'],
5735 'release_timestamp': int,
5736 'channel': 'Sky News',
5737 'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5740 'thumbnail': r
're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5741 'playable_in_embed': True,
5742 'release_date': r
're:\d+',
5743 'availability': 'public',
5744 'live_status': 'is_live',
5745 'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5746 'channel_follower_count': int,
5747 'concurrent_view_count': int,
5748 'uploader_url': 'https://www.youtube.com/@SkyNews',
5749 'uploader_id': '@SkyNews',
5750 'uploader': 'Sky News',
5753 'skip_download': True,
5755 'expected_warnings': ['Ignoring subtitle tracks found in '],
5757 'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5759 'id': 'a48o2S1cPoo',
5761 'title': 'The Young Turks - Live Main Show',
5762 'upload_date': '20150715',
5763 'license': 'Standard YouTube License',
5764 'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5765 'categories': ['News & Politics'],
5766 'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5770 'skip_download': True,
5772 'only_matching': True,
5774 'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5775 'only_matching': True,
5777 'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5778 'only_matching': True,
5780 'note': 'A channel that is not live. Should raise error',
5781 'url': 'https://www.youtube.com/user/numberphile/live',
5782 'only_matching': True,
5784 'url': 'https://www.youtube.com/feed/trending',
5785 'only_matching': True,
5787 'url': 'https://www.youtube.com/feed/library',
5788 'only_matching': True,
5790 'url': 'https://www.youtube.com/feed/history',
5791 'only_matching': True,
5793 'url': 'https://www.youtube.com/feed/subscriptions',
5794 'only_matching': True,
5796 'url': 'https://www.youtube.com/feed/watch_later',
5797 'only_matching': True,
5799 'note': 'Recommended - redirects to home page.',
5800 'url': 'https://www.youtube.com/feed/recommended',
5801 'only_matching': True,
5803 'note': 'inline playlist with not always working continuations',
5804 'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5805 'only_matching': True,
5807 'url': 'https://www.youtube.com/course',
5808 'only_matching': True,
5810 'url': 'https://www.youtube.com/zsecurity',
5811 'only_matching': True,
5813 'url': 'http://www.youtube.com/NASAgovVideo/videos',
5814 'only_matching': True,
5816 'url': 'https://www.youtube.com/TheYoungTurks/live',
5817 'only_matching': True,
5819 'url': 'https://www.youtube.com/hashtag/cctv9',
5825 'playlist_mincount': 300, # not consistent but should be over 300
5827 'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
5828 'only_matching': True,
5830 'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
5831 'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5832 'only_matching': True
5834 'note': '/browse/ should redirect to /channel/',
5835 'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
5836 'only_matching': True
5838 'note': 'VLPL, should redirect to playlist?list=PL...',
5839 'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5841 'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5842 'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
5843 'title': 'NCS : All Releases 💿',
5844 'channel_url': 'https://www.youtube.com/channel/UC_aEa8K-EOJ3D6gOs7HcyNg',
5845 'modified_date': r
're:\d{8}',
5847 'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
5849 'channel': 'NoCopyrightSounds',
5850 'availability': 'public',
5851 'uploader_url': 'https://www.youtube.com/@NoCopyrightSounds',
5852 'uploader': 'NoCopyrightSounds',
5853 'uploader_id': '@NoCopyrightSounds',
5855 'playlist_mincount': 166,
5856 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden', 'YouTube Music is not directly supported'],
5858 # TODO: fix 'unviewable' issue with this playlist when reloading with unavailable videos
5859 'note': 'Topic, should redirect to playlist?list=UU...',
5860 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5862 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5863 'title': 'Uploads from Royalty Free Music - Topic',
5865 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5866 'channel': 'Royalty Free Music - Topic',
5868 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5869 'modified_date': r
're:\d{8}',
5871 'availability': 'public',
5872 'uploader': 'Royalty Free Music - Topic',
5874 'playlist_mincount': 101,
5875 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5877 # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
5878 # Treat as a general feed
5879 'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
5881 'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
5882 'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
5885 'playlist_mincount': 9,
5887 'note': 'Youtube music Album',
5888 'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
5890 'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
5891 'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
5895 'availability': 'unlisted',
5896 'modified_date': r
're:\d{8}',
5898 'playlist_count': 50,
5899 'expected_warnings': ['YouTube Music is not directly supported'],
5901 'note': 'unlisted single video playlist',
5902 'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5904 'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5905 'title': 'yt-dlp unlisted playlist test',
5906 'availability': 'unlisted',
5908 'modified_date': '20220418',
5909 'channel': 'colethedj',
5912 'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5913 'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5914 'uploader_url': 'https://www.youtube.com/@colethedj1894',
5915 'uploader_id': '@colethedj1894',
5916 'uploader': 'colethedj',
5920 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
5921 'id': 'BaW_jenozKc',
5923 'ie_key': 'Youtube',
5925 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
5926 'channel_url': 'https://www.youtube.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
5928 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc',
5929 'channel': 'Philipp Hagemeister',
5930 'uploader_id': '@PhilippHagemeister',
5931 'uploader_url': 'https://www.youtube.com/@PhilippHagemeister',
5932 'uploader': 'Philipp Hagemeister',
5935 'playlist_count': 1,
5936 'params': {'extract_flat': True}
,
5938 'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
5939 'url': 'https://www.youtube.com/feed/recommended',
5941 'id': 'recommended',
5942 'title': 'recommended',
5945 'playlist_mincount': 50,
5947 'skip_download': True,
5948 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5951 'note': 'API Fallback: /videos tab, sorted by oldest first',
5952 'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
5954 'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5955 'title': 'Cody\'sLab - Videos',
5956 'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
5957 'channel': 'Cody\'sLab',
5958 'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5960 'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
5961 'channel_follower_count': int
5963 'playlist_mincount': 650,
5965 'skip_download': True,
5966 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5968 'skip': 'Query for sorting no longer works',
5970 'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
5971 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5973 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5974 'title': 'Uploads from Royalty Free Music - Topic',
5975 'modified_date': r
're:\d{8}',
5976 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5978 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5980 'channel': 'Royalty Free Music - Topic',
5982 'availability': 'public',
5983 'uploader': 'Royalty Free Music - Topic',
5985 'playlist_mincount': 101,
5987 'skip_download': True,
5988 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5990 'expected_warnings': ['YouTube Music is not directly supported', r
'[Uu]navailable videos (are|will be) hidden'],
5992 'note': 'non-standard redirect to regional channel',
5993 'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
5994 'only_matching': True
5996 'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
5997 'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
5999 'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
6000 'modified_date': '20220407',
6001 'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
6003 'availability': 'unlisted',
6004 'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
6005 'channel': 'pukkandan',
6006 'description': 'Test for collaborative playlist',
6007 'title': 'yt-dlp test - collaborative playlist',
6009 'uploader_url': 'https://www.youtube.com/@pukkandan',
6010 'uploader_id': '@pukkandan',
6011 'uploader': 'pukkandan',
6013 'playlist_mincount': 2
6015 'note': 'translated tab name',
6016 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
6018 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6020 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6021 'description': 'test description',
6022 'title': 'cole-dlp-test-acc - 再生リスト',
6023 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6024 'channel': 'cole-dlp-test-acc',
6025 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6026 'uploader_id': '@coletdjnz',
6027 'uploader': 'cole-dlp-test-acc',
6029 'playlist_mincount': 1,
6030 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6031 'expected_warnings': ['Preferring "ja"'],
6033 # XXX: this should really check flat playlist entries, but the test suite doesn't support that
6034 'note': 'preferred lang set with playlist with translated video titles',
6035 'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6037 'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
6040 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6041 'channel': 'cole-dlp-test-acc',
6042 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6043 'description': 'test',
6044 'title': 'dlp test playlist',
6045 'availability': 'public',
6046 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6047 'uploader_id': '@coletdjnz',
6048 'uploader': 'cole-dlp-test-acc',
6050 'playlist_mincount': 1,
6051 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
6052 'expected_warnings': ['Preferring "ja"'],
6054 # shorts audio pivot for 2GtVksBMYFM.
6055 'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
6057 'id': 'sfv_audio_pivot',
6058 'title': 'sfv_audio_pivot',
6061 'playlist_mincount': 50,
6064 # Channel with a real live tab (not to be mistaken with streams tab)
6065 # Do not treat like it should redirect to live stream
6066 'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
6068 'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
6069 'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
6072 'playlist_mincount': 20,
6074 # Tab name is not the same as tab id
6075 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
6077 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6078 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
6081 'playlist_mincount': 8,
6083 # Home tab id is literally home. Not to get mistaken with featured
6084 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
6086 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6087 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
6090 'playlist_mincount': 8,
6092 # Should get three playlists for videos, shorts and streams tabs
6093 'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6095 'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6096 'title': 'Polka Ch. 尾丸ポルカ',
6097 'channel_follower_count': int,
6098 'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
6099 'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
6100 'description': 'md5:e56b74b5bb7e9c701522162e9abfb822',
6101 'channel': 'Polka Ch. 尾丸ポルカ',
6103 'uploader_url': 'https://www.youtube.com/@OmaruPolka',
6104 'uploader': 'Polka Ch. 尾丸ポルカ',
6105 'uploader_id': '@OmaruPolka',
6107 'playlist_count': 3,
6109 # Shorts tab with channel with handle
6110 # TODO: fix channel description
6111 'url': 'https://www.youtube.com/@NotJustBikes/shorts',
6113 'id': 'UC0intLFzLaudFG-xAvUEO-A',
6114 'title': 'Not Just Bikes - Shorts',
6116 'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
6117 'description': 'md5:26bc55af26855a608a5cf89dfa595c8d',
6118 'channel_follower_count': int,
6119 'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
6120 'channel': 'Not Just Bikes',
6121 'uploader_url': 'https://www.youtube.com/@NotJustBikes',
6122 'uploader': 'Not Just Bikes',
6123 'uploader_id': '@NotJustBikes',
6125 'playlist_mincount': 10,
6128 'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
6130 'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6131 'title': '中村悠一 - Live',
6133 'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
6134 'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
6136 'channel_follower_count': int,
6137 'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
6138 'uploader_url': 'https://www.youtube.com/@Yuichi-Nakamura',
6139 'uploader_id': '@Yuichi-Nakamura',
6142 'playlist_mincount': 60,
6144 # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
6145 # See test_youtube_lists
6146 'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
6147 'only_matching': True,
6149 # No uploads and no UCID given. Should fail with no uploads error
6150 # See test_youtube_lists
6151 'url': 'https://www.youtube.com/news',
6152 'only_matching': True
6154 # No videos tab but has a shorts tab
6155 'url': 'https://www.youtube.com/c/TKFShorts',
6157 'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6158 'title': 'Shorts Break - Shorts',
6160 'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
6161 'channel': 'Shorts Break',
6162 'description': 'md5:6de33c5e7ba686e5f3efd4e19c7ef499',
6163 'channel_follower_count': int,
6164 'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
6165 'uploader_url': 'https://www.youtube.com/@ShortsBreak_Official',
6166 'uploader': 'Shorts Break',
6167 'uploader_id': '@ShortsBreak_Official',
6169 'playlist_mincount': 30,
6171 # Trending Now Tab. tab id is empty
6172 'url': 'https://www.youtube.com/feed/trending',
6175 'title': 'trending - Now',
6178 'playlist_mincount': 30,
6180 # Trending Gaming Tab. tab id is empty
6181 'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
6184 'title': 'trending - Gaming',
6187 'playlist_mincount': 30,
6189 # Shorts url result in shorts tab
6190 # TODO: Fix channel id extraction
6191 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
6193 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6194 'title': 'cole-dlp-test-acc - Shorts',
6195 'channel': 'cole-dlp-test-acc',
6196 'description': 'test description',
6197 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6198 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6200 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6201 'uploader_id': '@coletdjnz',
6202 'uploader': 'cole-dlp-test-acc',
6206 # Channel data is not currently available for short renderers (as of 2023-03-01)
6208 'ie_key': 'Youtube',
6209 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
6210 'id': 'sSM9J5YH_60',
6211 'title': 'SHORT short',
6216 'params': {'extract_flat': True}
,
6218 # Live video status should be extracted
6219 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
6221 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
6222 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live', # TODO, should be Minecraft - Live or Minecraft - Topic - Live
6228 'ie_key': 'Youtube',
6229 'url': 'startswith:https://www.youtube.com/watch?v=',
6232 'live_status': 'is_live',
6235 'concurrent_view_count': int,
6238 'uploader_url': str,
6242 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6243 'playlist_mincount': 1
6245 # Channel renderer metadata. Contains number of videos on the channel
6246 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/channels',
6248 'id': 'UCiu-3thuViMebBjw_5nWYrA',
6249 'title': 'cole-dlp-test-acc - Channels',
6250 'channel': 'cole-dlp-test-acc',
6251 'description': 'test description',
6252 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
6253 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
6255 'uploader_url': 'https://www.youtube.com/@coletdjnz',
6256 'uploader_id': '@coletdjnz',
6257 'uploader': 'cole-dlp-test-acc',
6262 'ie_key': 'YoutubeTab',
6263 'url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6264 'id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6265 'channel_id': 'UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6266 'title': 'PewDiePie',
6267 'channel': 'PewDiePie',
6268 'channel_url': 'https://www.youtube.com/channel/UC-lHJZR3Gqxm24_Vd_AJ5Yw',
6270 'channel_follower_count': int,
6271 'playlist_count': int,
6272 'uploader': 'PewDiePie',
6273 'uploader_url': 'https://www.youtube.com/@PewDiePie',
6274 'uploader_id': '@PewDiePie',
6277 'params': {'extract_flat': True}
,
6279 'url': 'https://www.youtube.com/@3blue1brown/about',
6281 'id': 'UCYO_jab_esuFRV4b17AJtAw',
6282 'tags': ['Mathematics'],
6283 'title': '3Blue1Brown - About',
6284 'channel_follower_count': int,
6285 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
6286 'channel': '3Blue1Brown',
6288 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
6289 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
6290 'uploader_url': 'https://www.youtube.com/@3blue1brown',
6291 'uploader_id': '@3blue1brown',
6292 'uploader': '3Blue1Brown',
6294 'playlist_count': 0,
6296 # Podcasts tab, with rich entry playlistRenderers
6297 'url': 'https://www.youtube.com/@99percentinvisiblepodcast/podcasts',
6299 'id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6300 'channel_id': 'UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6301 'uploader_url': 'https://www.youtube.com/@99percentinvisiblepodcast',
6302 'description': 'md5:3a0ed38f1ad42a68ef0428c04a15695c',
6303 'title': '99 Percent Invisible - Podcasts',
6304 'uploader': '99 Percent Invisible',
6305 'channel_follower_count': int,
6306 'channel_url': 'https://www.youtube.com/channel/UCVMF2HD4ZgC0QHpU9Yq5Xrw',
6308 'channel': '99 Percent Invisible',
6309 'uploader_id': '@99percentinvisiblepodcast',
6311 'playlist_count': 1,
6313 # Releases tab, with rich entry playlistRenderers (same as Podcasts tab)
6314 'url': 'https://www.youtube.com/@AHimitsu/releases',
6316 'id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6317 'channel': 'A Himitsu',
6318 'uploader_url': 'https://www.youtube.com/@AHimitsu',
6319 'title': 'A Himitsu - Releases',
6320 'uploader_id': '@AHimitsu',
6321 'uploader': 'A Himitsu',
6322 'channel_id': 'UCgFwu-j5-xNJml2FtTrrB3A',
6324 'description': 'I make music',
6325 'channel_url': 'https://www.youtube.com/channel/UCgFwu-j5-xNJml2FtTrrB3A',
6326 'channel_follower_count': int,
6328 'playlist_mincount': 10,
6332 def suitable(cls
, url
):
6333 return False if YoutubeIE
.suitable(url
) else super().suitable(url
)
6335 _URL_RE
= re
.compile(rf
'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
6337 def _get_url_mobj(self
, url
):
6338 mobj
= self
._URL
_RE
.match(url
).groupdict()
6339 mobj
.update((k
, '') for k
, v
in mobj
.items() if v
is None)
6342 def _extract_tab_id_and_name(self
, tab
, base_url
='https://www.youtube.com'):
6343 tab_name
= (tab
.get('title') or '').lower()
6344 tab_url
= urljoin(base_url
, traverse_obj(
6345 tab
, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
6347 tab_id
= (tab_url
and self
._get
_url
_mobj
(tab_url
)['tab'][1:]
6348 or traverse_obj(tab
, 'tabIdentifier', expected_type
=str))
6351 'TAB_ID_SPONSORSHIPS': 'membership',
6352 }.get(tab_id
, tab_id
), tab_name
6354 # Fallback to tab name if we cannot get the tab id.
6355 # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6356 # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6358 self
.write_debug(f
'Falling back to selected tab name: {tab_name}')
6362 }.get(tab_name
, tab_name
), tab_name
6364 def _has_tab(self
, tabs
, tab_id
):
6365 return any(self
._extract
_tab
_id
_and
_name
(tab
)[0] == tab_id
for tab
in tabs
)
6367 @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6368 def _real_extract(self
, url
, smuggled_data
):
6369 item_id
= self
._match
_id
(url
)
6370 url
= urllib
.parse
.urlunparse(
6371 urllib
.parse
.urlparse(url
)._replace
(netloc
='www.youtube.com'))
6372 compat_opts
= self
.get_param('compat_opts', [])
6374 mobj
= self
._get
_url
_mobj
(url
)
6375 pre
, tab
, post
, is_channel
= mobj
['pre'], mobj
['tab'], mobj
['post'], not mobj
['not_channel']
6376 if is_channel
and smuggled_data
.get('is_music_url'):
6377 if item_id
[:2] == 'VL': # Youtube music VL channels have an equivalent playlist
6378 return self
.url_result(
6379 f
'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE
, item_id
[2:])
6380 elif item_id
[:2] == 'MP': # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6381 mdata
= self
._extract
_tab
_endpoint
(
6382 f
'https://music.youtube.com/channel/{item_id}', item_id
, default_client
='web_music')
6383 murl
= traverse_obj(mdata
, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6384 get_all
=False, expected_type
=str)
6386 raise ExtractorError('Failed to resolve album to playlist')
6387 return self
.url_result(murl
, YoutubeTabIE
)
6388 elif mobj
['channel_type'] == 'browse': # Youtube music /browse/ should be changed to /channel/
6389 return self
.url_result(
6390 f
'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE
, item_id
)
6392 original_tab_id
, display_id
= tab
[1:], f
'{item_id}{tab}'
6393 if is_channel
and not tab
and 'no-youtube-channel-redirect' not in compat_opts
:
6394 url
= f
'{pre}/videos{post}'
6395 if smuggled_data
.get('is_music_url'):
6396 self
.report_warning(f
'YouTube Music is not directly supported. Redirecting to {url}')
6398 # Handle both video/playlist URLs
6400 video_id
, playlist_id
= [traverse_obj(qs
, (key
, 0)) for key
in ('v', 'list')]
6401 if not video_id
and mobj
['not_channel'].startswith('watch'):
6403 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6404 raise ExtractorError('A video URL was given without video ID', expected
=True)
6405 # Common mistake: https://www.youtube.com/watch?list=playlist_id
6406 self
.report_warning(f
'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6407 return self
.url_result(
6408 f
'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE
, playlist_id
)
6410 if not self
._yes
_playlist
(playlist_id
, video_id
):
6411 return self
.url_result(
6412 f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6414 data
, ytcfg
= self
._extract
_data
(url
, display_id
)
6416 # YouTube may provide a non-standard redirect to the regional channel
6417 # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6418 # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6419 redirect_url
= traverse_obj(
6420 data
, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all
=False)
6421 if redirect_url
and 'no-youtube-channel-redirect' not in compat_opts
:
6422 redirect_url
= ''.join((urljoin('https://www.youtube.com', redirect_url
), tab
, post
))
6423 self
.to_screen(f
'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6424 return self
.url_result(redirect_url
, YoutubeTabIE
)
6426 tabs
, extra_tabs
= self
._extract
_tab
_renderers
(data
), []
6427 if is_channel
and tabs
and 'no-youtube-channel-redirect' not in compat_opts
:
6428 selected_tab
= self
._extract
_selected
_tab
(tabs
)
6429 selected_tab_id
, selected_tab_name
= self
._extract
_tab
_id
_and
_name
(selected_tab
, url
) # NB: Name may be translated
6430 self
.write_debug(f
'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6432 if not original_tab_id
and selected_tab_name
:
6433 self
.to_screen('Downloading all uploads of the channel. '
6434 'To download only the videos in a specific tab, pass the tab\'s URL')
6435 if self
._has
_tab
(tabs
, 'streams'):
6436 extra_tabs
.append(''.join((pre
, '/streams', post
)))
6437 if self
._has
_tab
(tabs
, 'shorts'):
6438 extra_tabs
.append(''.join((pre
, '/shorts', post
)))
6439 # XXX: Members-only tab should also be extracted
6441 if not extra_tabs
and selected_tab_id
!= 'videos':
6442 # Channel does not have streams, shorts or videos tabs
6443 if item_id
[:2] != 'UC':
6444 raise ExtractorError('This channel has no uploads', expected
=True)
6446 # Topic channels don't have /videos. Use the equivalent playlist instead
6447 pl_id
= f
'UU{item_id[2:]}'
6448 pl_url
= f
'https://www.youtube.com/playlist?list={pl_id}'
6450 data
, ytcfg
= self
._extract
_data
(pl_url
, pl_id
, ytcfg
=ytcfg
, fatal
=True, webpage_fatal
=True)
6451 except ExtractorError
:
6452 raise ExtractorError('This channel has no uploads', expected
=True)
6454 item_id
, url
= pl_id
, pl_url
6456 f
'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6458 elif extra_tabs
and selected_tab_id
!= 'videos':
6459 # When there are shorts/live tabs but not videos tab
6460 url
, data
= f
'{pre}{post}', None
6462 elif (original_tab_id
or 'videos') != selected_tab_id
:
6463 if original_tab_id
== 'live':
6464 # Live tab should have redirected to the video
6465 # Except in the case the channel has an actual live tab
6466 # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6467 raise UserNotLive(video_id
=item_id
)
6468 elif selected_tab_name
:
6469 raise ExtractorError(f
'This channel does not have a {original_tab_id} tab', expected
=True)
6471 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6472 url
= f
'{pre}{post}'
6474 # YouTube sometimes provides a button to reload playlist with unavailable videos.
6475 if 'no-youtube-unavailable-videos' not in compat_opts
:
6476 data
= self
._reload
_with
_unavailable
_videos
(display_id
, data
, ytcfg
) or data
6477 self
._extract
_and
_report
_alerts
(data
, only_once
=True)
6479 tabs
, entries
= self
._extract
_tab
_renderers
(data
), []
6481 entries
= [self
._extract
_from
_tabs
(item_id
, ytcfg
, data
, tabs
)]
6483 'extractor_key': YoutubeTabIE
.ie_key(),
6484 'extractor': YoutubeTabIE
.IE_NAME
,
6487 if self
.get_param('playlist_items') == '0':
6488 entries
.extend(self
.url_result(u
, YoutubeTabIE
) for u
in extra_tabs
)
6489 else: # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6490 entries
.extend(map(self
._real
_extract
, extra_tabs
))
6492 if len(entries
) == 1:
6495 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
6496 uploads_url
= 'the Uploads (UU) playlist URL'
6497 if try_get(metadata
, lambda x
: x
['channel_id'].startswith('UC')):
6498 uploads_url
= f
'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6500 'Downloading as multiple playlists, separated by tabs. '
6501 f
'To download as a single playlist instead, pass {uploads_url}')
6502 return self
.playlist_result(entries
, item_id
, **metadata
)
6505 playlist
= traverse_obj(
6506 data
, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type
=dict)
6508 return self
._extract
_from
_playlist
(item_id
, url
, data
, playlist
, ytcfg
)
6510 video_id
= traverse_obj(
6511 data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str) or video_id
6513 if tab
!= '/live': # live tab is expected to redirect to video
6514 self
.report_warning(f
'Unable to recognize playlist. Downloading just video {video_id}')
6515 return self
.url_result(f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6517 raise ExtractorError('Unable to recognize tab page')
6520 class YoutubePlaylistIE(InfoExtractor
):
6521 IE_DESC
= 'YouTube playlists'
6522 _VALID_URL
= r
'''(?x)(?:
6527 youtube(?:kids)?\.com|
6532 (?P<id>%(playlist_id)s)
6534 'playlist_id': YoutubeBaseInfoExtractor
._PLAYLIST
_ID
_RE
,
6535 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
6537 IE_NAME
= 'youtube:playlist'
6539 'note': 'issue #673',
6540 'url': 'PLBB231211A4F62143',
6542 'title': '[OLD]Team Fortress 2 (Class-based LP)',
6543 'id': 'PLBB231211A4F62143',
6544 'uploader': 'Wickman',
6545 'uploader_id': '@WickmanVT',
6546 'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6548 'uploader_url': 'https://www.youtube.com/@WickmanVT',
6549 'modified_date': r
're:\d{8}',
6550 'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6551 'channel': 'Wickman',
6553 'channel_url': 'https://www.youtube.com/channel/UCKSpbfbl5kRQpTdL7kMc-1Q',
6554 'availability': 'public',
6556 'playlist_mincount': 29,
6558 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6560 'title': 'YDL_safe_search',
6561 'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6563 'playlist_count': 2,
6564 'skip': 'This playlist is private',
6567 'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6568 'playlist_count': 4,
6571 'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6572 'uploader': 'milan',
6573 'uploader_id': '@milan5503',
6575 'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6577 'modified_date': '20140919',
6580 'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6581 'uploader_url': 'https://www.youtube.com/@milan5503',
6582 'availability': 'public',
6584 'expected_warnings': [r
'[Uu]navailable videos? (is|are|will be) hidden'],
6586 'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6587 'playlist_mincount': 455,
6589 'title': '2018 Chinese New Singles (11/6 updated)',
6590 'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6592 'uploader_id': '@music_king',
6593 'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6596 'channel_url': 'https://www.youtube.com/channel/UC21nz3_MesPLqtDqwdvnoxA',
6598 'uploader_url': 'https://www.youtube.com/@music_king',
6599 'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6600 'modified_date': r
're:\d{8}',
6601 'availability': 'public',
6603 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6605 'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6606 'only_matching': True,
6608 # music album playlist
6609 'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6610 'only_matching': True,
6614 def suitable(cls
, url
):
6615 if YoutubeTabIE
.suitable(url
):
6617 from ..utils
import parse_qs
6619 if qs
.get('v', [None])[0]:
6621 return super().suitable(url
)
6623 def _real_extract(self
, url
):
6624 playlist_id
= self
._match
_id
(url
)
6625 is_music_url
= YoutubeBaseInfoExtractor
.is_music_url(url
)
6626 url
= update_url_query(
6627 'https://www.youtube.com/playlist',
6628 parse_qs(url
) or {'list': playlist_id}
)
6630 url
= smuggle_url(url
, {'is_music_url': True}
)
6631 return self
.url_result(url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6634 class YoutubeYtBeIE(InfoExtractor
):
6635 IE_DESC
= 'youtu.be'
6636 _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}
6638 'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6640 'id': 'yeWKywCrFtk',
6642 'title': 'Small Scale Baler and Braiding Rugs',
6643 'uploader': 'Backus-Page House Museum',
6644 'uploader_id': '@backuspagemuseum',
6645 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/@backuspagemuseum',
6646 'upload_date': '20161008',
6647 'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6648 'categories': ['Nonprofits & Activism'],
6652 'playable_in_embed': True,
6653 'thumbnail': r
're:^https?://.*\.webp',
6654 'channel': 'Backus-Page House Museum',
6655 'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6656 'live_status': 'not_live',
6658 'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6659 'availability': 'public',
6661 'comment_count': int,
6662 'channel_follower_count': int
6666 'skip_download': True,
6669 'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6670 'only_matching': True,
6673 def _real_extract(self
, url
):
6674 mobj
= self
._match
_valid
_url
(url
)
6675 video_id
= mobj
.group('id')
6676 playlist_id
= mobj
.group('playlist_id')
6677 return self
.url_result(
6678 update_url_query('https://www.youtube.com/watch', {
6680 'list': playlist_id
,
6681 'feature': 'youtu.be',
6682 }), ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6685 class YoutubeLivestreamEmbedIE(InfoExtractor
):
6686 IE_DESC
= 'YouTube livestream embeds'
6687 _VALID_URL
= r
'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6689 'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6690 'only_matching': True,
6693 def _real_extract(self
, url
):
6694 channel_id
= self
._match
_id
(url
)
6695 return self
.url_result(
6696 f
'https://www.youtube.com/channel/{channel_id}/live',
6697 ie
=YoutubeTabIE
.ie_key(), video_id
=channel_id
)
6700 class YoutubeYtUserIE(InfoExtractor
):
6701 IE_DESC
= 'YouTube user videos; "ytuser:" prefix'
6702 IE_NAME
= 'youtube:user'
6703 _VALID_URL
= r
'ytuser:(?P<id>.+)'
6705 'url': 'ytuser:phihag',
6706 'only_matching': True,
6709 def _real_extract(self
, url
):
6710 user_id
= self
._match
_id
(url
)
6711 return self
.url_result(f
'https://www.youtube.com/user/{user_id}', YoutubeTabIE
, user_id
)
6714 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor
):
6715 IE_NAME
= 'youtube:favorites'
6716 IE_DESC
= 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6717 _VALID_URL
= r
':ytfav(?:ou?rite)?s?'
6718 _LOGIN_REQUIRED
= True
6721 'only_matching': True,
6723 'url': ':ytfavorites',
6724 'only_matching': True,
6727 def _real_extract(self
, url
):
6728 return self
.url_result(
6729 'https://www.youtube.com/playlist?list=LL',
6730 ie
=YoutubeTabIE
.ie_key())
6733 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor
):
6734 IE_NAME
= 'youtube:notif'
6735 IE_DESC
= 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6736 _VALID_URL
= r
':ytnotif(?:ication)?s?'
6737 _LOGIN_REQUIRED
= True
6740 'only_matching': True,
6742 'url': ':ytnotifications',
6743 'only_matching': True,
6746 def _extract_notification_menu(self
, response
, continuation_list
):
6747 notification_list
= traverse_obj(
6749 ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6750 ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6751 expected_type
=list) or []
6752 continuation_list
[0] = None
6753 for item
in notification_list
:
6754 entry
= self
._extract
_notification
_renderer
(item
.get('notificationRenderer'))
6757 continuation
= item
.get('continuationItemRenderer')
6759 continuation_list
[0] = continuation
6761 def _extract_notification_renderer(self
, notification
):
6762 video_id
= traverse_obj(
6763 notification
, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str)
6764 url
= f
'https://www.youtube.com/watch?v={video_id}'
6767 browse_ep
= traverse_obj(
6768 notification
, ('navigationEndpoint', 'browseEndpoint'), expected_type
=dict)
6769 channel_id
= self
.ucid_or_none(traverse_obj(browse_ep
, 'browseId', expected_type
=str))
6770 post_id
= self
._search
_regex
(
6771 r
'/post/(.+)', traverse_obj(browse_ep
, 'canonicalBaseUrl', expected_type
=str),
6772 'post id', default
=None)
6773 if not channel_id
or not post_id
:
6775 # The direct /post url redirects to this in the browser
6776 url
= f
'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
6778 channel
= traverse_obj(
6779 notification
, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
6781 notification_title
= self
._get
_text
(notification
, 'shortMessage')
6782 if notification_title
:
6783 notification_title
= notification_title
.replace('\xad', '') # remove soft hyphens
6784 # TODO: handle recommended videos
6785 title
= self
._search
_regex
(
6786 rf
'{re.escape(channel or "")}[^:]+: (.+)', notification_title
,
6787 'video title', default
=None)
6788 timestamp
= (self
._parse
_time
_text
(self
._get
_text
(notification
, 'sentTimeText'))
6789 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
6794 'ie_key': (YoutubeIE
if video_id
else YoutubeTabIE
).ie_key(),
6795 'video_id': video_id
,
6797 'channel_id': channel_id
,
6799 'uploader': channel
,
6800 'thumbnails': self
._extract
_thumbnails
(notification
, 'videoThumbnail'),
6801 'timestamp': timestamp
,
6804 def _notification_menu_entries(self
, ytcfg
):
6805 continuation_list
= [None]
6807 for page
in itertools
.count(1):
6808 ctoken
= traverse_obj(
6809 continuation_list
, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type
=str)
6810 response
= self
._extract
_response
(
6811 item_id
=f
'page {page}', query
={'ctoken': ctoken}
if ctoken
else {}, ytcfg
=ytcfg
,
6812 ep
='notification/get_notification_menu', check_get_keys
='actions',
6813 headers
=self
.generate_api_headers(ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(response
)))
6814 yield from self
._extract
_notification
_menu
(response
, continuation_list
)
6815 if not continuation_list
[0]:
6818 def _real_extract(self
, url
):
6819 display_id
= 'notifications'
6820 ytcfg
= self
._download
_ytcfg
('web', display_id
) if not self
.skip_webpage
else {}
6821 self
._report
_playlist
_authcheck
(ytcfg
)
6822 return self
.playlist_result(self
._notification
_menu
_entries
(ytcfg
), display_id
, display_id
)
6825 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6826 IE_DESC
= 'YouTube search'
6827 IE_NAME
= 'youtube:search'
6828 _SEARCH_KEY
= 'ytsearch'
6829 _SEARCH_PARAMS
= 'EgIQAQ%3D%3D' # Videos only
6831 'url': 'ytsearch5:youtube-dl test video',
6832 'playlist_count': 5,
6834 'id': 'youtube-dl test video',
6835 'title': 'youtube-dl test video',
6840 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6841 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ ':date'
6842 _SEARCH_KEY
= 'ytsearchdate'
6843 IE_DESC
= 'YouTube search, newest videos first'
6844 _SEARCH_PARAMS
= 'CAISAhAB' # Videos only, sorted by date
6846 'url': 'ytsearchdate5:youtube-dl test video',
6847 'playlist_count': 5,
6849 'id': 'youtube-dl test video',
6850 'title': 'youtube-dl test video',
6855 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor
):
6856 IE_DESC
= 'YouTube search URLs with sorting and filter support'
6857 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ '_url'
6858 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6860 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
6861 'playlist_mincount': 5,
6863 'id': 'youtube-dl test video',
6864 'title': 'youtube-dl test video',
6867 'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
6868 'playlist_mincount': 5,
6874 'url': 'https://www.youtube.com/results?search_query=%23cats',
6875 'playlist_mincount': 1,
6879 # The test suite does not have support for nested playlists
6881 # 'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
6887 'url': 'https://www.youtube.com/results?search_query=kurzgesagt&sp=EgIQAg%253D%253D',
6890 'title': 'kurzgesagt',
6895 'id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6896 'url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6897 'ie_key': 'YoutubeTab',
6898 'channel': 'Kurzgesagt – In a Nutshell',
6899 'description': 'md5:4ae48dfa9505ffc307dad26342d06bfc',
6900 'title': 'Kurzgesagt – In a Nutshell',
6901 'channel_id': 'UCsXVk37bltHxD1rDPwtNM8Q',
6902 # No longer available for search as it is set to the handle.
6903 # 'playlist_count': int,
6904 'channel_url': 'https://www.youtube.com/channel/UCsXVk37bltHxD1rDPwtNM8Q',
6906 'uploader_id': '@kurzgesagt',
6907 'uploader_url': 'https://www.youtube.com/@kurzgesagt',
6908 'uploader': 'Kurzgesagt – In a Nutshell',
6909 'channel_follower_count': int,
6912 'params': {'extract_flat': True, 'playlist_items': '1'}
,
6913 'playlist_mincount': 1,
6915 'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
6916 'only_matching': True,
6919 def _real_extract(self
, url
):
6921 query
= (qs
.get('search_query') or qs
.get('q'))[0]
6922 return self
.playlist_result(self
._search
_results
(query
, qs
.get('sp', (None,))[0]), query
, query
)
6925 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor
):
6926 IE_DESC
= 'YouTube music search URLs with selectable sections, e.g. #songs'
6927 IE_NAME
= 'youtube:music:search_url'
6928 _VALID_URL
= r
'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6930 'url': 'https://music.youtube.com/search?q=royalty+free+music',
6931 'playlist_count': 16,
6933 'id': 'royalty free music',
6934 'title': 'royalty free music',
6937 'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
6938 'playlist_mincount': 30,
6940 'id': 'royalty free music - songs',
6941 'title': 'royalty free music - songs',
6943 'params': {'extract_flat': 'in_playlist'}
6945 'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
6946 'playlist_mincount': 30,
6948 'id': 'royalty free music - community playlists',
6949 'title': 'royalty free music - community playlists',
6951 'params': {'extract_flat': 'in_playlist'}
6955 'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
6956 'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
6957 'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
6958 'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
6959 'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
6960 'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
6963 def _real_extract(self
, url
):
6965 query
= (qs
.get('search_query') or qs
.get('q'))[0]
6966 params
= qs
.get('sp', (None,))[0]
6968 section
= next((k
for k
, v
in self
._SECTIONS
.items() if v
== params
), params
)
6970 section
= urllib
.parse
.unquote_plus((url
.split('#') + [''])[1]).lower()
6971 params
= self
._SECTIONS
.get(section
)
6974 title
= join_nonempty(query
, section
, delim
=' - ')
6975 return self
.playlist_result(self
._search
_results
(query
, params
, default_client
='web_music'), title
, title
)
6978 class YoutubeFeedsInfoExtractor(InfoExtractor
):
6980 Base class for feed extractors
6981 Subclasses must re-define the _FEED_NAME property.
6983 _LOGIN_REQUIRED
= True
6984 _FEED_NAME
= 'feeds'
6986 def _real_initialize(self
):
6987 YoutubeBaseInfoExtractor
._check
_login
_required
(self
)
6991 return f
'youtube:{self._FEED_NAME}'
6993 def _real_extract(self
, url
):
6994 return self
.url_result(
6995 f
'https://www.youtube.com/feed/{self._FEED_NAME}', ie
=YoutubeTabIE
.ie_key())
6998 class YoutubeWatchLaterIE(InfoExtractor
):
6999 IE_NAME
= 'youtube:watchlater'
7000 IE_DESC
= 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
7001 _VALID_URL
= r
':ytwatchlater'
7003 'url': ':ytwatchlater',
7004 'only_matching': True,
7007 def _real_extract(self
, url
):
7008 return self
.url_result(
7009 'https://www.youtube.com/playlist?list=WL', ie
=YoutubeTabIE
.ie_key())
7012 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor
):
7013 IE_DESC
= 'YouTube recommended videos; ":ytrec" keyword'
7014 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
7015 _FEED_NAME
= 'recommended'
7016 _LOGIN_REQUIRED
= False
7019 'only_matching': True,
7021 'url': ':ytrecommended',
7022 'only_matching': True,
7024 'url': 'https://youtube.com',
7025 'only_matching': True,
7029 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor
):
7030 IE_DESC
= 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
7031 _VALID_URL
= r
':ytsub(?:scription)?s?'
7032 _FEED_NAME
= 'subscriptions'
7035 'only_matching': True,
7037 'url': ':ytsubscriptions',
7038 'only_matching': True,
7042 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor
):
7043 IE_DESC
= 'Youtube watch history; ":ythis" keyword (requires cookies)'
7044 _VALID_URL
= r
':ythis(?:tory)?'
7045 _FEED_NAME
= 'history'
7047 'url': ':ythistory',
7048 'only_matching': True,
7052 class YoutubeStoriesIE(InfoExtractor
):
7053 IE_DESC
= 'YouTube channel stories; "ytstories:" prefix'
7054 IE_NAME
= 'youtube:stories'
7055 _VALID_URL
= r
'ytstories:UC(?P<id>[A-Za-z0-9_-]{21}[AQgw])$'
7057 'url': 'ytstories:UCwFCb4jeqaKWnciAYM-ZVHg',
7058 'only_matching': True,
7061 def _real_extract(self
, url
):
7062 playlist_id
= f
'RLTD{self._match_id(url)}'
7063 return self
.url_result(
7064 smuggle_url(f
'https://www.youtube.com/playlist?list={playlist_id}&playnext=1', {'is_story': True}
),
7065 ie
=YoutubeTabIE
, video_id
=playlist_id
)
7068 class YoutubeShortsAudioPivotIE(InfoExtractor
):
7069 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
7070 IE_NAME
= 'youtube:shorts:pivot:audio'
7071 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
7073 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
7074 'only_matching': True,
7078 def _generate_audio_pivot_params(video_id
):
7080 Generates sfv_audio_pivot browse params for this video id
7082 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
7083 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
7085 def _real_extract(self
, url
):
7086 video_id
= self
._match
_id
(url
)
7087 return self
.url_result(
7088 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
7092 class YoutubeTruncatedURLIE(InfoExtractor
):
7093 IE_NAME
= 'youtube:truncated_url'
7094 IE_DESC
= False # Do not list
7095 _VALID_URL
= r
'''(?x)
7097 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
7100 annotation_id=annotation_[^&]+|
7106 attribution_link\?a=[^&]+
7112 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
7113 'only_matching': True,
7115 'url': 'https://www.youtube.com/watch?',
7116 'only_matching': True,
7118 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
7119 'only_matching': True,
7121 'url': 'https://www.youtube.com/watch?feature=foo',
7122 'only_matching': True,
7124 'url': 'https://www.youtube.com/watch?hl=en-GB',
7125 'only_matching': True,
7127 'url': 'https://www.youtube.com/watch?t=2372',
7128 'only_matching': True,
7131 def _real_extract(self
, url
):
7132 raise ExtractorError(
7133 'Did you forget to quote the URL? Remember that & is a meta '
7134 'character in most shells, so you want to put the URL in quotes, '
7136 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
7137 ' or simply youtube-dl BaW_jenozKc .',
7141 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
7142 IE_NAME
= 'youtube:clip'
7143 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
7145 # FIXME: Other metadata should be extracted from the clip, not from the base video
7146 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
7148 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
7150 'section_start': 29.0,
7151 'section_end': 39.7,
7154 'availability': 'public',
7155 'categories': ['Gaming'],
7156 'channel': 'Scott The Woz',
7157 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
7158 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
7159 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
7161 'playable_in_embed': True,
7163 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
7164 'title': 'Mobile Games on Console - Scott The Woz',
7165 'upload_date': '20210920',
7166 'uploader': 'Scott The Woz',
7167 'uploader_id': '@ScottTheWoz',
7168 'uploader_url': 'https://www.youtube.com/@ScottTheWoz',
7170 'live_status': 'not_live',
7171 'channel_follower_count': int,
7172 'chapters': 'count:20',
7173 'comment_count': int,
7174 'heatmap': 'count:100',
7178 def _real_extract(self
, url
):
7179 clip_id
= self
._match
_id
(url
)
7180 _
, data
= self
._extract
_webpage
(url
, clip_id
)
7182 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
7184 raise ExtractorError('Unable to find video ID')
7186 clip_data
= traverse_obj(data
, (
7187 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
7188 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
7189 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
7190 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
7193 '_type': 'url_transparent',
7194 'url': f
'https://www.youtube.com/watch?v={video_id}',
7195 'ie_key': YoutubeIE
.ie_key(),
7197 'section_start': int(clip_data
['startTimeMs']) / 1000,
7198 'section_end': int(clip_data
['endTimeMs']) / 1000,
7202 class YoutubeConsentRedirectIE(YoutubeBaseInfoExtractor
):
7203 IE_NAME
= 'youtube:consent'
7204 IE_DESC
= False # Do not list
7205 _VALID_URL
= r
'https?://consent\.youtube\.com/m\?'
7207 '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',
7209 'id': 'qVv6vCqciTM',
7212 'uploader_id': '@sana_natori',
7213 'comment_count': int,
7214 'chapters': 'count:13',
7215 'upload_date': '20221223',
7216 'thumbnail': 'https://i.ytimg.com/vi/qVv6vCqciTM/maxresdefault.jpg',
7217 'channel_url': 'https://www.youtube.com/channel/UCIdEIHpS0TdkqRkHL5OkLtA',
7218 'uploader_url': 'https://www.youtube.com/@sana_natori',
7220 'release_date': '20221223',
7221 'tags': ['Vtuber', '月ノ美兎', '名取さな', 'にじさんじ', 'クリスマス', '3D配信'],
7222 'title': '【 #インターネット女クリスマス 】3Dで歌ってはしゃぐインターネットの女たち【月ノ美兎/名取さな】',
7224 'playable_in_embed': True,
7226 'availability': 'public',
7227 'channel_follower_count': int,
7228 'channel_id': 'UCIdEIHpS0TdkqRkHL5OkLtA',
7229 'categories': ['Entertainment'],
7230 'live_status': 'was_live',
7231 'release_timestamp': 1671793345,
7232 'channel': 'さなちゃんねる',
7233 'description': 'md5:6aebf95cc4a1d731aebc01ad6cc9806d',
7234 'uploader': 'さなちゃんねる',
7235 'heatmap': 'count:100',
7237 'add_ie': ['Youtube'],
7238 'params': {'skip_download': 'Youtube'}
,
7241 def _real_extract(self
, url
):
7242 redirect_url
= url_or_none(parse_qs(url
).get('continue', [None])[-1])
7243 if not redirect_url
:
7244 raise ExtractorError('Invalid cookie consent redirect URL', expected
=True)
7245 return self
.url_result(redirect_url
)
7248 class YoutubeTruncatedIDIE(InfoExtractor
):
7249 IE_NAME
= 'youtube:truncated_id'
7250 IE_DESC
= False # Do not list
7251 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
7254 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
7255 'only_matching': True,
7258 def _real_extract(self
, url
):
7259 video_id
= self
._match
_id
(url
)
7260 raise ExtractorError(
7261 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',