21 from .common
import InfoExtractor
, SearchInfoExtractor
22 from .openload
import PhantomJSwrapper
23 from ..compat
import functools
24 from ..jsinterp
import JSInterpreter
69 # any clients starting with _ cannot be explicitly requested by the user
72 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
73 'INNERTUBE_CONTEXT': {
76 'clientVersion': '2.20220801.00.00',
79 'INNERTUBE_CONTEXT_CLIENT_NAME': 1
82 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
83 'INNERTUBE_CONTEXT': {
85 'clientName': 'WEB_EMBEDDED_PLAYER',
86 'clientVersion': '1.20220731.00.00',
89 'INNERTUBE_CONTEXT_CLIENT_NAME': 56
92 'INNERTUBE_API_KEY': 'AIzaSyC9XL3ZjWddXya6X74dJoCTL-WEYFDNX30',
93 'INNERTUBE_HOST': 'music.youtube.com',
94 'INNERTUBE_CONTEXT': {
96 'clientName': 'WEB_REMIX',
97 'clientVersion': '1.20220727.01.00',
100 'INNERTUBE_CONTEXT_CLIENT_NAME': 67,
103 'INNERTUBE_API_KEY': 'AIzaSyBUPetSUmoZL-OhlxA7wSac5XinrygCqMo',
104 'INNERTUBE_CONTEXT': {
106 'clientName': 'WEB_CREATOR',
107 'clientVersion': '1.20220726.00.00',
110 'INNERTUBE_CONTEXT_CLIENT_NAME': 62,
113 'INNERTUBE_API_KEY': 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w',
114 'INNERTUBE_CONTEXT': {
116 'clientName': 'ANDROID',
117 'clientVersion': '17.31.35',
118 'androidSdkVersion': 30,
119 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
122 'INNERTUBE_CONTEXT_CLIENT_NAME': 3,
123 'REQUIRE_JS_PLAYER': False
125 'android_embedded': {
126 'INNERTUBE_API_KEY': 'AIzaSyCjc_pVEDi4qsv5MtC2dMXzpIaDoRFLsxw',
127 'INNERTUBE_CONTEXT': {
129 'clientName': 'ANDROID_EMBEDDED_PLAYER',
130 'clientVersion': '17.31.35',
131 'androidSdkVersion': 30,
132 'userAgent': 'com.google.android.youtube/17.31.35 (Linux; U; Android 11) gzip'
135 'INNERTUBE_CONTEXT_CLIENT_NAME': 55,
136 'REQUIRE_JS_PLAYER': False
139 'INNERTUBE_API_KEY': 'AIzaSyAOghZGza2MQSZkY_zfZ370N-PUdXEo8AI',
140 'INNERTUBE_CONTEXT': {
142 'clientName': 'ANDROID_MUSIC',
143 'clientVersion': '5.16.51',
144 'androidSdkVersion': 30,
145 'userAgent': 'com.google.android.apps.youtube.music/5.16.51 (Linux; U; Android 11) gzip'
148 'INNERTUBE_CONTEXT_CLIENT_NAME': 21,
149 'REQUIRE_JS_PLAYER': False
152 'INNERTUBE_API_KEY': 'AIzaSyD_qjV8zaaUMehtLkrKFgVeSX_Iqbtyws8',
153 'INNERTUBE_CONTEXT': {
155 'clientName': 'ANDROID_CREATOR',
156 'clientVersion': '22.30.100',
157 'androidSdkVersion': 30,
158 'userAgent': 'com.google.android.apps.youtube.creator/22.30.100 (Linux; U; Android 11) gzip'
161 'INNERTUBE_CONTEXT_CLIENT_NAME': 14,
162 'REQUIRE_JS_PLAYER': False
164 # iOS clients have HLS live streams. Setting device model to get 60fps formats.
165 # See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/680#issuecomment-1002724558
167 'INNERTUBE_API_KEY': 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc',
168 'INNERTUBE_CONTEXT': {
171 'clientVersion': '17.33.2',
172 'deviceModel': 'iPhone14,3',
173 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
176 'INNERTUBE_CONTEXT_CLIENT_NAME': 5,
177 'REQUIRE_JS_PLAYER': False
180 'INNERTUBE_CONTEXT': {
182 'clientName': 'IOS_MESSAGES_EXTENSION',
183 'clientVersion': '17.33.2',
184 'deviceModel': 'iPhone14,3',
185 'userAgent': 'com.google.ios.youtube/17.33.2 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
188 'INNERTUBE_CONTEXT_CLIENT_NAME': 66,
189 'REQUIRE_JS_PLAYER': False
192 'INNERTUBE_API_KEY': 'AIzaSyBAETezhkwP0ZWA02RsqT1zu78Fpt0bC_s',
193 'INNERTUBE_CONTEXT': {
195 'clientName': 'IOS_MUSIC',
196 'clientVersion': '5.21',
197 'deviceModel': 'iPhone14,3',
198 'userAgent': 'com.google.ios.youtubemusic/5.21 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
201 'INNERTUBE_CONTEXT_CLIENT_NAME': 26,
202 'REQUIRE_JS_PLAYER': False
205 'INNERTUBE_CONTEXT': {
207 'clientName': 'IOS_CREATOR',
208 'clientVersion': '22.33.101',
209 'deviceModel': 'iPhone14,3',
210 'userAgent': 'com.google.ios.ytcreator/22.33.101 (iPhone14,3; U; CPU iOS 15_6 like Mac OS X)'
213 'INNERTUBE_CONTEXT_CLIENT_NAME': 15,
214 'REQUIRE_JS_PLAYER': False
216 # mweb has 'ultralow' formats
217 # See: https://github.com/yt-dlp/yt-dlp/pull/557
219 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
220 'INNERTUBE_CONTEXT': {
222 'clientName': 'MWEB',
223 'clientVersion': '2.20220801.00.00',
226 'INNERTUBE_CONTEXT_CLIENT_NAME': 2
228 # This client can access age restricted videos (unless the uploader has disabled the 'allow embedding' option)
229 # See: https://github.com/zerodytrash/YouTube-Internal-Clients
231 'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
232 'INNERTUBE_CONTEXT': {
234 'clientName': 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
235 'clientVersion': '2.0',
238 'INNERTUBE_CONTEXT_CLIENT_NAME': 85
243 def _split_innertube_client(client_name
):
244 variant
, *base
= client_name
.rsplit('.', 1)
246 return variant
, base
[0], variant
247 base
, *variant
= client_name
.split('_', 1)
248 return client_name
, base
, variant
[0] if variant
else None
251 def build_innertube_clients():
253 'embedUrl': 'https://www.youtube.com/', # Can be any valid URL
255 BASE_CLIENTS
= ('android', 'web', 'tv', 'ios', 'mweb')
256 priority
= qualities(BASE_CLIENTS
[::-1])
258 for client
, ytcfg
in tuple(INNERTUBE_CLIENTS
.items()):
259 ytcfg
.setdefault('INNERTUBE_API_KEY', 'AIzaSyDCU8hByM-4DrUqRUYnGn-3llEO78bcxq8')
260 ytcfg
.setdefault('INNERTUBE_HOST', 'www.youtube.com')
261 ytcfg
.setdefault('REQUIRE_JS_PLAYER', True)
262 ytcfg
['INNERTUBE_CONTEXT']['client'].setdefault('hl', 'en')
264 _
, base_client
, variant
= _split_innertube_client(client
)
265 ytcfg
['priority'] = 10 * priority(base_client
)
268 INNERTUBE_CLIENTS
[f
'{client}_embedscreen'] = embedscreen
= copy
.deepcopy(ytcfg
)
269 embedscreen
['INNERTUBE_CONTEXT']['client']['clientScreen'] = 'EMBED'
270 embedscreen
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
271 embedscreen
['priority'] -= 3
272 elif variant
== 'embedded':
273 ytcfg
['INNERTUBE_CONTEXT']['thirdParty'] = THIRD_PARTY
274 ytcfg
['priority'] -= 2
276 ytcfg
['priority'] -= 3
279 build_innertube_clients()
282 class BadgeType(enum
.Enum
):
283 AVAILABILITY_UNLISTED
= enum
.auto()
284 AVAILABILITY_PRIVATE
= enum
.auto()
285 AVAILABILITY_PUBLIC
= enum
.auto()
286 AVAILABILITY_PREMIUM
= enum
.auto()
287 AVAILABILITY_SUBSCRIPTION
= enum
.auto()
288 LIVE_NOW
= enum
.auto()
291 class YoutubeBaseInfoExtractor(InfoExtractor
):
292 """Provide base functions for Youtube extractors"""
295 r
'channel|c|user|playlist|watch|w|v|embed|e|watch_popup|clip|'
296 r
'shorts|movies|results|search|shared|hashtag|trending|explore|feed|feeds|'
297 r
'browse|oembed|get_video_info|iframe_api|s/player|source|'
298 r
'storefront|oops|index|account|t/terms|about|upload|signin|logout')
300 _PLAYLIST_ID_RE
= r
'(?:(?:PL|LL|EC|UU|FL|RD|UL|TL|PU|OLAK5uy_)[0-9A-Za-z-_]{10,}|RDMM|WL|LL|LM)'
302 # _NETRC_MACHINE = 'youtube'
304 # If True it will raise an error if no login info is provided
305 _LOGIN_REQUIRED
= False
308 # invidious-redirect websites
309 r
'(?:www\.)?redirect\.invidious\.io',
310 r
'(?:(?:www|dev)\.)?invidio\.us',
311 # Invidious instances taken from https://github.com/iv-org/documentation/blob/master/docs/instances.md
312 r
'(?:www\.)?invidious\.pussthecat\.org',
313 r
'(?:www\.)?invidious\.zee\.li',
314 r
'(?:www\.)?invidious\.ethibox\.fr',
315 r
'(?:www\.)?invidious\.3o7z6yfxhbw7n3za4rss6l434kmv55cgw2vuziwuigpwegswvwzqipyd\.onion',
316 r
'(?:www\.)?osbivz6guyeahrwp2lnwyjk2xos342h4ocsxyqrlaopqjuhwn2djiiyd\.onion',
317 r
'(?:www\.)?u2cvlit75owumwpy4dj2hsmvkq7nvrclkpht7xgyye2pyoxhpmclkrad\.onion',
318 # youtube-dl invidious instances list
319 r
'(?:(?:www|no)\.)?invidiou\.sh',
320 r
'(?:(?:www|fi)\.)?invidious\.snopyta\.org',
321 r
'(?:www\.)?invidious\.kabi\.tk',
322 r
'(?:www\.)?invidious\.mastodon\.host',
323 r
'(?:www\.)?invidious\.zapashcanon\.fr',
324 r
'(?:www\.)?(?:invidious(?:-us)?|piped)\.kavin\.rocks',
325 r
'(?:www\.)?invidious\.tinfoil-hat\.net',
326 r
'(?:www\.)?invidious\.himiko\.cloud',
327 r
'(?:www\.)?invidious\.reallyancient\.tech',
328 r
'(?:www\.)?invidious\.tube',
329 r
'(?:www\.)?invidiou\.site',
330 r
'(?:www\.)?invidious\.site',
331 r
'(?:www\.)?invidious\.xyz',
332 r
'(?:www\.)?invidious\.nixnet\.xyz',
333 r
'(?:www\.)?invidious\.048596\.xyz',
334 r
'(?:www\.)?invidious\.drycat\.fr',
335 r
'(?:www\.)?inv\.skyn3t\.in',
336 r
'(?:www\.)?tube\.poal\.co',
337 r
'(?:www\.)?tube\.connect\.cafe',
338 r
'(?:www\.)?vid\.wxzm\.sx',
339 r
'(?:www\.)?vid\.mint\.lgbt',
340 r
'(?:www\.)?vid\.puffyan\.us',
341 r
'(?:www\.)?yewtu\.be',
342 r
'(?:www\.)?yt\.elukerio\.org',
343 r
'(?:www\.)?yt\.lelux\.fi',
344 r
'(?:www\.)?invidious\.ggc-project\.de',
345 r
'(?:www\.)?yt\.maisputain\.ovh',
346 r
'(?:www\.)?ytprivate\.com',
347 r
'(?:www\.)?invidious\.13ad\.de',
348 r
'(?:www\.)?invidious\.toot\.koeln',
349 r
'(?:www\.)?invidious\.fdn\.fr',
350 r
'(?:www\.)?watch\.nettohikari\.com',
351 r
'(?:www\.)?invidious\.namazso\.eu',
352 r
'(?:www\.)?invidious\.silkky\.cloud',
353 r
'(?:www\.)?invidious\.exonip\.de',
354 r
'(?:www\.)?invidious\.riverside\.rocks',
355 r
'(?:www\.)?invidious\.blamefran\.net',
356 r
'(?:www\.)?invidious\.moomoo\.de',
357 r
'(?:www\.)?ytb\.trom\.tf',
358 r
'(?:www\.)?yt\.cyberhost\.uk',
359 r
'(?:www\.)?kgg2m7yk5aybusll\.onion',
360 r
'(?:www\.)?qklhadlycap4cnod\.onion',
361 r
'(?:www\.)?axqzx4s6s54s32yentfqojs3x5i7faxza6xo3ehd4bzzsg2ii4fv2iid\.onion',
362 r
'(?:www\.)?c7hqkpkpemu6e7emz5b4vyz7idjgdvgaaa3dyimmeojqbgpea3xqjoid\.onion',
363 r
'(?:www\.)?fz253lmuao3strwbfbmx46yu7acac2jz27iwtorgmbqlkurlclmancad\.onion',
364 r
'(?:www\.)?invidious\.l4qlywnpwqsluw65ts7md3khrivpirse744un3x7mlskqauz5pyuzgqd\.onion',
365 r
'(?:www\.)?owxfohz4kjyv25fvlqilyxast7inivgiktls3th44jhk3ej3i7ya\.b32\.i2p',
366 r
'(?:www\.)?4l2dgddgsrkf2ous66i6seeyi6etzfgrue332grh2n7madpwopotugyd\.onion',
367 r
'(?:www\.)?w6ijuptxiku4xpnnaetxvnkc5vqcdu7mgns2u77qefoixi63vbvnpnqd\.onion',
368 r
'(?:www\.)?kbjggqkzv65ivcqj6bumvp337z6264huv5kpkwuv6gu5yjiskvan7fad\.onion',
369 r
'(?:www\.)?grwp24hodrefzvjjuccrkw3mjq4tzhaaq32amf33dzpmuxe7ilepcmad\.onion',
370 r
'(?:www\.)?hpniueoejy4opn7bc4ftgazyqjoeqwlvh2uiku2xqku6zpoa4bf5ruid\.onion',
371 # piped instances from https://github.com/TeamPiped/Piped/wiki/Instances
372 r
'(?:www\.)?piped\.kavin\.rocks',
373 r
'(?:www\.)?piped\.tokhmi\.xyz',
374 r
'(?:www\.)?piped\.syncpundit\.io',
375 r
'(?:www\.)?piped\.mha\.fi',
376 r
'(?:www\.)?watch\.whatever\.social',
377 r
'(?:www\.)?piped\.garudalinux\.org',
378 r
'(?:www\.)?piped\.rivo\.lol',
379 r
'(?:www\.)?piped-libre\.kavin\.rocks',
380 r
'(?:www\.)?yt\.jae\.fi',
381 r
'(?:www\.)?piped\.mint\.lgbt',
383 r
'(?:www\.)?piped\.esmailelbob\.xyz',
384 r
'(?:www\.)?piped\.projectsegfau\.lt',
385 r
'(?:www\.)?piped\.privacydev\.net',
386 r
'(?:www\.)?piped\.palveluntarjoaja\.eu',
387 r
'(?:www\.)?piped\.smnz\.de',
388 r
'(?:www\.)?piped\.adminforge\.de',
389 r
'(?:www\.)?watch\.whatevertinfoil\.de',
390 r
'(?:www\.)?piped\.qdi\.fi',
391 r
'(?:www\.)?piped\.video',
392 r
'(?:www\.)?piped\.aeong\.one',
395 # extracted from account/account_menu ep
396 # XXX: These are the supported YouTube UI and API languages,
397 # which is slightly different from languages supported for translation in YouTube studio
398 _SUPPORTED_LANG_CODES
= [
399 'af', 'az', 'id', 'ms', 'bs', 'ca', 'cs', 'da', 'de', 'et', 'en-IN', 'en-GB', 'en', 'es',
400 'es-419', 'es-US', 'eu', 'fil', 'fr', 'fr-CA', 'gl', 'hr', 'zu', 'is', 'it', 'sw', 'lv',
401 'lt', 'hu', 'nl', 'no', 'uz', 'pl', 'pt-PT', 'pt', 'ro', 'sq', 'sk', 'sl', 'sr-Latn', 'fi',
402 'sv', 'vi', 'tr', 'be', 'bg', 'ky', 'kk', 'mk', 'mn', 'ru', 'sr', 'uk', 'el', 'hy', 'iw',
403 'ur', 'ar', 'fa', 'ne', 'mr', 'hi', 'as', 'bn', 'pa', 'gu', 'or', 'ta', 'te', 'kn', 'ml',
404 'si', 'th', 'lo', 'my', 'ka', 'am', 'km', 'zh-CN', 'zh-TW', 'zh-HK', 'ja', 'ko'
407 _IGNORED_WARNINGS
= {'Unavailable videos will be hidden during playback'}
409 @functools.cached_property
410 def _preferred_lang(self
):
412 Returns a language code supported by YouTube for the user preferred language.
413 Returns None if no preferred language set.
415 preferred_lang
= self
._configuration
_arg
('lang', ie_key
='Youtube', casesense
=True, default
=[''])[0]
416 if not preferred_lang
:
418 if preferred_lang
not in self
._SUPPORTED
_LANG
_CODES
:
419 raise ExtractorError(
420 f
'Unsupported language code: {preferred_lang}. Supported language codes (case-sensitive): {join_nonempty(*self._SUPPORTED_LANG_CODES, delim=", ")}.',
422 elif preferred_lang
!= 'en':
424 f
'Preferring "{preferred_lang}" translated fields. Note that some metadata extraction may fail or be incorrect.')
425 return preferred_lang
427 def _initialize_consent(self
):
428 cookies
= self
._get
_cookies
('https://www.youtube.com/')
429 if cookies
.get('__Secure-3PSID'):
432 consent
= cookies
.get('CONSENT')
434 if 'YES' in consent
.value
:
436 consent_id
= self
._search
_regex
(
437 r
'PENDING\+(\d+)', consent
.value
, 'consent', default
=None)
439 consent_id
= random
.randint(100, 999)
440 self
._set
_cookie
('.youtube.com', 'CONSENT', 'YES+cb.20210328-17-p0.en+FX+%s' % consent_id
)
442 def _initialize_pref(self
):
443 cookies
= self
._get
_cookies
('https://www.youtube.com/')
444 pref_cookie
= cookies
.get('PREF')
448 pref
= dict(urllib
.parse
.parse_qsl(pref_cookie
.value
))
450 self
.report_warning('Failed to parse user PREF cookie' + bug_reports_message())
451 pref
.update({'hl': self._preferred_lang or 'en', 'tz': 'UTC'}
)
452 self
._set
_cookie
('.youtube.com', name
='PREF', value
=urllib
.parse
.urlencode(pref
))
454 def _real_initialize(self
):
455 self
._initialize
_pref
()
456 self
._initialize
_consent
()
457 self
._check
_login
_required
()
459 def _check_login_required(self
):
460 if self
._LOGIN
_REQUIRED
and not self
._cookies
_passed
:
461 self
.raise_login_required('Login details are needed to download this content', method
='cookies')
463 _YT_INITIAL_DATA_RE
= r
'(?:window\s*\[\s*["\']ytInitialData
["\']\s*\]|ytInitialData)\s*='
464 _YT_INITIAL_PLAYER_RESPONSE_RE = r'ytInitialPlayerResponse\s*='
466 def _get_default_ytcfg(self, client='web'):
467 return copy.deepcopy(INNERTUBE_CLIENTS[client])
469 def _get_innertube_host(self, client='web'):
470 return INNERTUBE_CLIENTS[client]['INNERTUBE_HOST']
472 def _ytcfg_get_safe(self, ytcfg, getter, expected_type=None, default_client='web'):
473 # try_get but with fallback to default ytcfg client values when present
474 _func = lambda y: try_get(y, getter, expected_type)
475 return _func(ytcfg) or _func(self._get_default_ytcfg(default_client))
477 def _extract_client_name(self, ytcfg, default_client='web'):
478 return self._ytcfg_get_safe(
479 ytcfg, (lambda x: x['INNERTUBE_CLIENT_NAME'],
480 lambda x: x['INNERTUBE_CONTEXT']['client']['clientName']), str, default_client)
482 def _extract_client_version(self, ytcfg, default_client='web'):
483 return self._ytcfg_get_safe(
484 ytcfg, (lambda x: x['INNERTUBE_CLIENT_VERSION'],
485 lambda x: x['INNERTUBE_CONTEXT']['client']['clientVersion']), str, default_client)
487 def _select_api_hostname(self, req_api_hostname, default_client=None):
488 return (self._configuration_arg('innertube_host', [''], ie_key=YoutubeIE.ie_key())[0]
489 or req_api_hostname or self._get_innertube_host(default_client or 'web'))
491 def _extract_api_key(self, ytcfg=None, default_client='web'):
492 return self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_API_KEY'], str, default_client)
494 def _extract_context(self, ytcfg=None, default_client='web'):
496 (ytcfg, self._get_default_ytcfg(default_client)), 'INNERTUBE_CONTEXT', expected_type=dict)
497 # Enforce language and tz for extraction
498 client_context = traverse_obj(context, 'client', expected_type=dict, default={})
499 client_context.update({'hl': self._preferred_lang or 'en', 'timeZone': 'UTC', 'utcOffsetMinutes': 0})
504 def _generate_sapisidhash_header(self, origin='https://www.youtube.com'):
505 time_now = round(time.time())
506 if self._SAPISID is None:
507 yt_cookies = self._get_cookies('https://www.youtube.com')
508 # Sometimes SAPISID cookie isn't present but __Secure-3PAPISID is.
509 # See: https://github.com/yt-dlp/yt-dlp/issues/393
510 sapisid_cookie = dict_get(
511 yt_cookies, ('__Secure-3PAPISID', 'SAPISID'))
512 if sapisid_cookie and sapisid_cookie.value:
513 self._SAPISID = sapisid_cookie.value
514 self.write_debug('Extracted SAPISID cookie')
515 # SAPISID cookie is required if not already present
516 if not yt_cookies.get('SAPISID'):
517 self.write_debug('Copying __Secure-3PAPISID cookie to SAPISID cookie')
519 '.youtube.com', 'SAPISID', self._SAPISID, secure=True, expire_time=time_now + 3600)
521 self._SAPISID = False
522 if not self._SAPISID:
524 # SAPISIDHASH algorithm from https://stackoverflow.com/a/32065323
525 sapisidhash = hashlib.sha1(
526 f'{time_now} {self._SAPISID} {origin}'.encode()).hexdigest()
527 return f'SAPISIDHASH {time_now}_{sapisidhash}'
529 def _call_api(self, ep, query, video_id, fatal=True, headers=None,
530 note='Downloading API JSON', errnote='Unable to download API page',
531 context=None, api_key=None, api_hostname=None, default_client='web'):
533 data = {'context': context} if context else {'context': self._extract_context(default_client=default_client)}
535 real_headers = self.generate_api_headers(default_client=default_client)
536 real_headers.update({'content-type': 'application/json'})
538 real_headers.update(headers)
539 api_key = (self._configuration_arg('innertube_key', [''], ie_key=YoutubeIE.ie_key(), casesense=True)[0]
540 or api_key or self._extract_api_key(default_client=default_client))
541 return self._download_json(
542 f'https://{self._select_api_hostname(api_hostname, default_client)}/youtubei/v1/{ep}',
543 video_id=video_id, fatal=fatal, note=note, errnote=errnote,
544 data=json.dumps(data).encode('utf8'), headers=real_headers,
545 query={'key': api_key, 'prettyPrint': 'false'})
547 def extract_yt_initial_data(self, item_id, webpage, fatal=True):
548 return self._search_json(self._YT_INITIAL_DATA_RE, webpage, 'yt initial data', item_id, fatal=fatal)
551 def _extract_session_index(*data):
553 Index of current account in account list.
554 See: https://github.com/yt-dlp/yt-dlp/pull/519
557 session_index = int_or_none(try_get(ytcfg, lambda x: x['SESSION_INDEX']))
558 if session_index is not None:
562 def _extract_identity_token(self, ytcfg=None, webpage=None):
564 token = try_get(ytcfg, lambda x: x['ID_TOKEN'], str)
568 return self._search_regex(
569 r'\bID_TOKEN["\']\s
*:\s
*["\'](.+?)["\']', webpage,
570 'identity token
', default=None, fatal=False)
573 def _extract_account_syncid(*args):
575 Extract syncId required to download private playlists of secondary channels
576 @params response and/or ytcfg
579 # ytcfg includes channel_syncid if on secondary channel
580 delegated_sid = try_get(data, lambda x: x['DELEGATED_SESSION_ID
'], str)
584 data, (lambda x: x['responseContext
']['mainAppWebResponseContext
']['datasyncId
'],
585 lambda x: x['DATASYNC_ID
']), str) or '').split('||
')
586 if len(sync_ids) >= 2 and sync_ids[1]:
587 # datasyncid is of the form "channel_syncid||user_syncid" for secondary channel
588 # and just "user_syncid||" for primary channel. We only want the channel_syncid
592 def _extract_visitor_data(*args):
594 Extracts visitorData from an API response or ytcfg
595 Appears to be used to track session state
598 args, [('VISITOR_DATA
', ('INNERTUBE_CONTEXT
', 'client
', 'visitorData
'), ('responseContext
', 'visitorData
'))],
601 @functools.cached_property
602 def is_authenticated(self):
603 return bool(self._generate_sapisidhash_header())
605 def extract_ytcfg(self, video_id, webpage):
608 return self._parse_json(
610 r'ytcfg\
.set\s
*\
(\s
*({.+?}
)\s
*\
)\s
*;', webpage, 'ytcfg
',
611 default='{}'), video_id, fatal=False) or {}
613 def generate_api_headers(
614 self
, *, ytcfg
=None, account_syncid
=None, session_index
=None,
615 visitor_data
=None, identity_token
=None, api_hostname
=None, default_client
='web'):
617 origin
= 'https://' + (self
._select
_api
_hostname
(api_hostname
, default_client
))
619 'X-YouTube-Client-Name': str(
620 self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT_CLIENT_NAME'], default_client
=default_client
)),
621 'X-YouTube-Client-Version': self
._extract
_client
_version
(ytcfg
, default_client
),
623 'X-Youtube-Identity-Token': identity_token
or self
._extract
_identity
_token
(ytcfg
),
624 'X-Goog-PageId': account_syncid
or self
._extract
_account
_syncid
(ytcfg
),
625 'X-Goog-Visitor-Id': visitor_data
or self
._extract
_visitor
_data
(ytcfg
),
626 'User-Agent': self
._ytcfg
_get
_safe
(ytcfg
, lambda x
: x
['INNERTUBE_CONTEXT']['client']['userAgent'], default_client
=default_client
)
628 if session_index
is None:
629 session_index
= self
._extract
_session
_index
(ytcfg
)
630 if account_syncid
or session_index
is not None:
631 headers
['X-Goog-AuthUser'] = session_index
if session_index
is not None else 0
633 auth
= self
._generate
_sapisidhash
_header
(origin
)
635 headers
['Authorization'] = auth
636 headers
['X-Origin'] = origin
637 return filter_dict(headers
)
639 def _download_ytcfg(self
, client
, video_id
):
641 'web': 'https://www.youtube.com',
642 'web_music': 'https://music.youtube.com',
643 'web_embedded': f
'https://www.youtube.com/embed/{video_id}?html5=1'
647 webpage
= self
._download
_webpage
(
648 url
, video_id
, fatal
=False, note
=f
'Downloading {client.replace("_", " ").strip()} client config')
649 return self
.extract_ytcfg(video_id
, webpage
) or {}
652 def _build_api_continuation_query(continuation
, ctp
=None):
654 'continuation': continuation
656 # TODO: Inconsistency with clickTrackingParams.
657 # Currently we have a fixed ctp contained within context (from ytcfg)
658 # and a ctp in root query for continuation.
660 query
['clickTracking'] = {'clickTrackingParams': ctp}
664 def _extract_next_continuation_data(cls
, renderer
):
665 next_continuation
= try_get(
666 renderer
, (lambda x
: x
['continuations'][0]['nextContinuationData'],
667 lambda x
: x
['continuation']['reloadContinuationData']), dict)
668 if not next_continuation
:
670 continuation
= next_continuation
.get('continuation')
673 ctp
= next_continuation
.get('clickTrackingParams')
674 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
677 def _extract_continuation_ep_data(cls
, continuation_ep
: dict):
678 if isinstance(continuation_ep
, dict):
679 continuation
= try_get(
680 continuation_ep
, lambda x
: x
['continuationCommand']['token'], str)
683 ctp
= continuation_ep
.get('clickTrackingParams')
684 return cls
._build
_api
_continuation
_query
(continuation
, ctp
)
687 def _extract_continuation(cls
, renderer
):
688 next_continuation
= cls
._extract
_next
_continuation
_data
(renderer
)
689 if next_continuation
:
690 return next_continuation
692 return traverse_obj(renderer
, (
693 ('contents', 'items', 'rows'), ..., 'continuationItemRenderer',
694 ('continuationEndpoint', ('button', 'buttonRenderer', 'command'))
695 ), get_all
=False, expected_type
=cls
._extract
_continuation
_ep
_data
)
698 def _extract_alerts(cls
, data
):
699 for alert_dict
in try_get(data
, lambda x
: x
['alerts'], list) or []:
700 if not isinstance(alert_dict
, dict):
702 for alert
in alert_dict
.values():
703 alert_type
= alert
.get('type')
706 message
= cls
._get
_text
(alert
, 'text')
708 yield alert_type
, message
710 def _report_alerts(self
, alerts
, expected
=True, fatal
=True, only_once
=False):
711 errors
, warnings
= [], []
712 for alert_type
, alert_message
in alerts
:
713 if alert_type
.lower() == 'error' and fatal
:
714 errors
.append([alert_type
, alert_message
])
715 elif alert_message
not in self
._IGNORED
_WARNINGS
:
716 warnings
.append([alert_type
, alert_message
])
718 for alert_type
, alert_message
in (warnings
+ errors
[:-1]):
719 self
.report_warning(f
'YouTube said: {alert_type} - {alert_message}', only_once
=only_once
)
721 raise ExtractorError('YouTube said: %s' % errors
[-1][1], expected
=expected
)
723 def _extract_and_report_alerts(self
, data
, *args
, **kwargs
):
724 return self
._report
_alerts
(self
._extract
_alerts
(data
), *args
, **kwargs
)
726 def _extract_badges(self
, renderer
: dict):
728 'PRIVACY_UNLISTED': BadgeType
.AVAILABILITY_UNLISTED
,
729 'PRIVACY_PRIVATE': BadgeType
.AVAILABILITY_PRIVATE
,
730 'PRIVACY_PUBLIC': BadgeType
.AVAILABILITY_PUBLIC
734 'BADGE_STYLE_TYPE_MEMBERS_ONLY': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
735 'BADGE_STYLE_TYPE_PREMIUM': BadgeType
.AVAILABILITY_PREMIUM
,
736 'BADGE_STYLE_TYPE_LIVE_NOW': BadgeType
.LIVE_NOW
740 'unlisted': BadgeType
.AVAILABILITY_UNLISTED
,
741 'private': BadgeType
.AVAILABILITY_PRIVATE
,
742 'members only': BadgeType
.AVAILABILITY_SUBSCRIPTION
,
743 'live': BadgeType
.LIVE_NOW
,
744 'premium': BadgeType
.AVAILABILITY_PREMIUM
748 for badge
in traverse_obj(renderer
, ('badges', ..., 'metadataBadgeRenderer'), default
=[]):
750 privacy_icon_map
.get(traverse_obj(badge
, ('icon', 'iconType'), expected_type
=str))
751 or badge_style_map
.get(traverse_obj(badge
, 'style'))
754 badges
.append({'type': badge_type}
)
757 # fallback, won't work in some languages
758 label
= traverse_obj(badge
, 'label', expected_type
=str, default
='')
759 for match
, label_badge_type
in label_map
.items():
760 if match
in label
.lower():
761 badges
.append({'type': badge_type}
)
767 def _has_badge(badges
, badge_type
):
768 return bool(traverse_obj(badges
, lambda _
, v
: v
['type'] == badge_type
))
771 def _get_text(data
, *path_list
, max_runs
=None):
772 for path
in path_list
or [None]:
776 obj
= traverse_obj(data
, path
, default
=[])
777 if not any(key
is ... or isinstance(key
, (list, tuple)) for key
in variadic(path
)):
780 text
= try_get(item
, lambda x
: x
['simpleText'], str)
783 runs
= try_get(item
, lambda x
: x
['runs'], list) or []
784 if not runs
and isinstance(item
, list):
787 runs
= runs
[:min(len(runs
), max_runs
or len(runs
))]
788 text
= ''.join(traverse_obj(runs
, (..., 'text'), expected_type
=str, default
=[]))
792 def _get_count(self
, data
, *path_list
):
793 count_text
= self
._get
_text
(data
, *path_list
) or ''
794 count
= parse_count(count_text
)
797 self
._search
_regex
(r
'^([\d,]+)', re
.sub(r
'\s', '', count_text
), 'count', default
=None))
801 def _extract_thumbnails(data
, *path_list
):
803 Extract thumbnails from thumbnails dict
804 @param path_list: path list to level that contains 'thumbnails' key
807 for path
in path_list
or [()]:
808 for thumbnail
in traverse_obj(data
, (*variadic(path
), 'thumbnails', ...), default
=[]):
809 thumbnail_url
= url_or_none(thumbnail
.get('url'))
810 if not thumbnail_url
:
812 # Sometimes youtube gives a wrong thumbnail URL. See:
813 # https://github.com/yt-dlp/yt-dlp/issues/233
814 # https://github.com/ytdl-org/youtube-dl/issues/28023
815 if 'maxresdefault' in thumbnail_url
:
816 thumbnail_url
= thumbnail_url
.split('?')[0]
818 'url': thumbnail_url
,
819 'height': int_or_none(thumbnail
.get('height')),
820 'width': int_or_none(thumbnail
.get('width')),
825 def extract_relative_time(relative_time_text
):
827 Extracts a relative time from string and converts to dt object
828 e.g. 'streamed 6 days ago', '5 seconds ago (edited)', 'updated today'
830 mobj
= re
.search(r
'(?P<start>today|yesterday|now)|(?P<time>\d+)\s*(?P<unit>microsecond|second|minute|hour|day|week|month|year)s?\s*ago', relative_time_text
)
832 start
= mobj
.group('start')
834 return datetime_from_str(start
)
836 return datetime_from_str('now-%s%s' % (mobj
.group('time'), mobj
.group('unit')))
840 def _parse_time_text(self
, text
):
843 dt
= self
.extract_relative_time(text
)
845 if isinstance(dt
, datetime
.datetime
):
846 timestamp
= calendar
.timegm(dt
.timetuple())
848 if timestamp
is None:
850 unified_timestamp(text
) or unified_timestamp(
852 (r
'([a-z]+\s*\d{1,2},?\s*20\d{2})', r
'(?:.+|^)(?:live|premieres|ed|ing)(?:\s*(?:on|for))?\s*(.+\d)'),
853 text
.lower(), 'time text', default
=None)))
855 if text
and timestamp
is None and self
._preferred
_lang
in (None, 'en'):
857 f
'Cannot parse localized time text "{text}"', only_once
=True)
860 def _extract_response(self
, item_id
, query
, note
='Downloading API JSON', headers
=None,
861 ytcfg
=None, check_get_keys
=None, ep
='browse', fatal
=True, api_hostname
=None,
862 default_client
='web'):
863 for retry
in self
.RetryManager():
865 response
= self
._call
_api
(
866 ep
=ep
, fatal
=True, headers
=headers
,
867 video_id
=item_id
, query
=query
, note
=note
,
868 context
=self
._extract
_context
(ytcfg
, default_client
),
869 api_key
=self
._extract
_api
_key
(ytcfg
, default_client
),
870 api_hostname
=api_hostname
, default_client
=default_client
)
871 except ExtractorError
as e
:
872 if not isinstance(e
.cause
, network_exceptions
):
873 return self
._error
_or
_warning
(e
, fatal
=fatal
)
874 elif not isinstance(e
.cause
, urllib
.error
.HTTPError
):
878 first_bytes
= e
.cause
.read(512)
879 if not is_html(first_bytes
):
882 self
._webpage
_read
_content
(e
.cause
, None, item_id
, prefix
=first_bytes
) or '{}', item_id
, fatal
=False),
883 lambda x
: x
['error']['message'], str)
885 self
._report
_alerts
([('ERROR', yt_error
)], fatal
=False)
886 # Downloading page may result in intermittent 5xx HTTP error
887 # Sometimes a 404 is also recieved. See: https://github.com/ytdl-org/youtube-dl/issues/28289
888 # We also want to catch all other network exceptions since errors in later pages can be troublesome
889 # See https://github.com/yt-dlp/yt-dlp/issues/507#issuecomment-880188210
890 if e
.cause
.code
not in (403, 429):
893 return self
._error
_or
_warning
(e
, fatal
=fatal
)
896 self
._extract
_and
_report
_alerts
(response
, only_once
=True)
897 except ExtractorError
as e
:
898 # YouTube servers may return errors we want to retry on in a 200 OK response
899 # See: https://github.com/yt-dlp/yt-dlp/issues/839
900 if 'unknown error' in e
.msg
.lower():
903 return self
._error
_or
_warning
(e
, fatal
=fatal
)
904 # Youtube sometimes sends incomplete data
905 # See: https://github.com/ytdl-org/youtube-dl/issues/28194
906 if not traverse_obj(response
, *variadic(check_get_keys
)):
907 retry
.error
= ExtractorError('Incomplete data received', expected
=True)
913 def is_music_url(url
):
914 return re
.match(r
'https?://music\.youtube\.com/', url
) is not None
916 def _extract_video(self
, renderer
):
917 video_id
= renderer
.get('videoId')
919 reel_header_renderer
= traverse_obj(renderer
, (
920 'navigationEndpoint', 'reelWatchEndpoint', 'overlay', 'reelPlayerOverlayRenderer',
921 'reelPlayerHeaderSupportedRenderers', 'reelPlayerHeaderRenderer'))
923 title
= self
._get
_text
(renderer
, 'title', 'headline') or self
._get
_text
(reel_header_renderer
, 'reelTitleText')
924 description
= self
._get
_text
(renderer
, 'descriptionSnippet')
926 duration
= int_or_none(renderer
.get('lengthSeconds'))
928 duration
= parse_duration(self
._get
_text
(
929 renderer
, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
931 # XXX: should write a parser to be more general to support more cases (e.g. shorts in shorts tab)
932 duration
= parse_duration(self
._search
_regex
(
933 r
'(?i)(ago)(?!.*\1)\s+(?P<duration>[a-z0-9 ,]+?)(?:\s+[\d,]+\s+views)?(?:\s+-\s+play\s+short)?$',
934 traverse_obj(renderer
, ('title', 'accessibility', 'accessibilityData', 'label'), default
='', expected_type
=str),
935 video_id
, default
=None, group
='duration'))
937 channel_id
= traverse_obj(
938 renderer
, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'),
939 expected_type
=str, get_all
=False)
941 channel_id
= traverse_obj(reel_header_renderer
, ('channelNavigationEndpoint', 'browseEndpoint', 'browseId'))
943 overlay_style
= traverse_obj(
944 renderer
, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'),
945 get_all
=False, expected_type
=str)
946 badges
= self
._extract
_badges
(renderer
)
948 navigation_url
= urljoin('https://www.youtube.com/', traverse_obj(
949 renderer
, ('navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url'),
950 expected_type
=str)) or ''
951 url
= f
'https://www.youtube.com/watch?v={video_id}'
952 if overlay_style
== 'SHORTS' or '/shorts/' in navigation_url
:
953 url
= f
'https://www.youtube.com/shorts/{video_id}'
955 time_text
= (self
._get
_text
(renderer
, 'publishedTimeText', 'videoInfo')
956 or self
._get
_text
(reel_header_renderer
, 'timestampText') or '')
957 scheduled_timestamp
= str_to_int(traverse_obj(renderer
, ('upcomingEventData', 'startTime'), get_all
=False))
960 'is_upcoming' if scheduled_timestamp
is not None
961 else 'was_live' if 'streamed' in time_text
.lower()
962 else 'is_live' if overlay_style
== 'LIVE' or self
._has
_badge
(badges
, BadgeType
.LIVE_NOW
)
965 # videoInfo is a string like '50K views • 10 years ago'.
966 view_count_text
= self
._get
_text
(renderer
, 'viewCountText', 'shortViewCountText', 'videoInfo') or ''
967 view_count
= (0 if 'no views' in view_count_text
.lower()
968 else self
._get
_count
({'simpleText': view_count_text}
))
969 view_count_field
= 'concurrent_view_count' if live_status
in ('is_live', 'is_upcoming') else 'view_count'
973 'ie_key': YoutubeIE
.ie_key(),
977 'description': description
,
978 'duration': duration
,
979 'channel_id': channel_id
,
980 'channel': (self
._get
_text
(renderer
, 'ownerText', 'shortBylineText')
981 or self
._get
_text
(reel_header_renderer
, 'channelTitleText')),
982 'channel_url': f
'https://www.youtube.com/channel/{channel_id}' if channel_id
else None,
983 'thumbnails': self
._extract
_thumbnails
(renderer
, 'thumbnail'),
984 'timestamp': (self
._parse
_time
_text
(time_text
)
985 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
987 'release_timestamp': scheduled_timestamp
,
989 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
990 else self
._availability
(
991 is_private
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
) or None,
992 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
993 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
994 is_unlisted
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
) or None),
995 view_count_field
: view_count
,
996 'live_status': live_status
1000 class YoutubeIE(YoutubeBaseInfoExtractor
):
1002 _VALID_URL
= r
"""(?x)^
1004 (?:https?://|//) # http(s):// or protocol-independent URL
1005 (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
1006 (?:www\.)?deturl\.com/www\.youtube\.com|
1007 (?:www\.)?pwnyoutube\.com|
1008 (?:www\.)?hooktube\.com|
1009 (?:www\.)?yourepeat\.com|
1010 tube\.majestyc\.net|
1012 youtube\.googleapis\.com)/ # the various hostnames, with wildcard subdomains
1013 (?:.*?\#/)? # handle anchor (#/) redirect urls
1014 (?: # the various things that can precede the ID:
1015 (?:(?:v|embed|e|shorts)/(?!videoseries|live_stream)) # v/ or embed/ or e/ or shorts/
1016 |(?: # or the v= param in all its forms
1017 (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
1018 (?:\?|\#!?) # the params delimiter ? or # or #!
1019 (?:.*?[&;])?? # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&v=V36LpHqtcDY)
1024 youtu\.be| # just youtu.be/xxxx
1025 vid\.plus| # or vid.plus/xxxx
1026 zwearz\.com/watch| # or zwearz.com/watch/xxxx
1029 |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
1031 )? # all until now is optional -> you can pass the naked ID
1032 (?P<id>[0-9A-Za-z_-]{11}) # here is it! the YouTube video ID
1033 (?(1).+)? # if we found the ID, everything can follow
1035 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
1040 <(?:[0-9A-Za-z-]+?)?iframe[^>]+?src=|
1048 (?P
<url
>(?
:https?
:)?
//(?
:www\
.)?
youtube(?
:-nocookie
)?\
.com
/
1049 (?
:embed|v|p
)/[0-9A
-Za
-z_
-]{11}
.*?
)
1051 # https://wordpress.org/plugins/lazy-load-for-videos/
1053 <a\s
[^
>]*\bhref
="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"
1054 \s
[^
>]*\bclass
="[^"]*\blazy
-load
-youtube
''',
1056 _RETURN_TYPE = 'video' # XXX: How to handle multifeed?
1059 r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
1060 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$',
1061 r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
1064 '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1065 '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
1066 '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
1067 '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
1068 '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
1069 '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1070 '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1071 '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1072 # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
1073 '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
1074 '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1075 '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
1076 '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1077 '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
1078 '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1079 '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
1080 '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1081 '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
1085 '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1086 '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
1087 '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1088 '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
1089 '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
1090 '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1091 '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
1093 # Apple HTTP Live Streaming
1094 '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1095 '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1096 '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1097 '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
1098 '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1099 '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
1100 '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
1101 '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
1104 '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
1105 '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
1106 '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1107 '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
1108 '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
1109 '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'}, # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
1110 '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
1111 '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
1112 '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
1113 '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1114 '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
1115 '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
1118 '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
1119 '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
1120 '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
1121 '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1122 '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
1123 '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
1124 '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
1127 '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1128 '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1129 '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1130 '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1131 '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1132 '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
1133 '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
1134 '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1135 '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1136 '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1137 '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1138 '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1139 '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1140 '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1141 '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1142 # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
1143 '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1144 '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1145 '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1146 '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1147 '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
1148 '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
1151 '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
1152 '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
1154 # Dash webm audio with opus inside
1155 '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
1156 '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
1157 '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
1160 '_rtmp': {'protocol': 'rtmp'},
1162 # av01 video only formats sometimes served with "unknown" codecs
1163 '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1164 '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1165 '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1166 '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1167 '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1168 '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1169 '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1170 '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1172 _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1179 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1181 'id': 'BaW_jenozKc',
1183 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1184 'uploader': 'Philipp Hagemeister',
1185 'uploader_id': 'phihag',
1186 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/phihag',
1187 'channel': 'Philipp Hagemeister',
1188 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1189 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1190 'upload_date': '20121002',
1191 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1192 'categories': ['Science & Technology'],
1193 'tags': ['youtube-dl'],
1197 'availability': 'public',
1198 'playable_in_embed': True,
1199 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1200 'live_status': 'not_live',
1204 'comment_count': int,
1205 'channel_follower_count': int
1209 'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1210 'note': 'Embed-only video (#1746)',
1212 'id': 'yZIXLfi8CZQ',
1214 'upload_date': '20120608',
1215 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1216 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1217 'uploader': 'SET India',
1218 'uploader_id': 'setindia',
1219 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/setindia',
1222 'skip': 'Private video',
1225 'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1226 'note': 'Use the first video ID in the URL',
1228 'id': 'BaW_jenozKc',
1230 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1231 'uploader': 'Philipp Hagemeister',
1232 'uploader_id': 'phihag',
1233 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/phihag',
1234 'channel': 'Philipp Hagemeister',
1235 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1236 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1237 'upload_date': '20121002',
1238 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1239 'categories': ['Science & Technology'],
1240 'tags': ['youtube-dl'],
1244 'availability': 'public',
1245 'playable_in_embed': True,
1246 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1247 'live_status': 'not_live',
1249 'comment_count': int,
1250 'channel_follower_count': int
1253 'skip_download': True,
1257 'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1258 'note': '256k DASH audio (format 141) via DASH manifest',
1260 'id': 'a9LDPn-MO4I',
1262 'upload_date': '20121002',
1263 'uploader_id': '8KVIDEO',
1264 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/8KVIDEO',
1266 'uploader': '8KVIDEO',
1267 'title': 'UHDTV TEST 8K VIDEO.mp4'
1270 'youtube_include_dash_manifest': True,
1273 'skip': 'format 141 not served anymore',
1275 # DASH manifest with encrypted signature
1277 'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1279 'id': 'IB3lcPjvWLA',
1281 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1282 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1284 'uploader': 'AfrojackVEVO',
1285 'uploader_id': 'AfrojackVEVO',
1286 'upload_date': '20131011',
1289 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1290 'playable_in_embed': True,
1291 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1293 'track': 'The Spark',
1294 'live_status': 'not_live',
1295 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1296 'channel': 'Afrojack',
1297 'uploader_url': 'http://www.youtube.com/user/AfrojackVEVO',
1299 'availability': 'public',
1300 'categories': ['Music'],
1302 'alt_title': 'The Spark',
1303 'channel_follower_count': int
1306 'youtube_include_dash_manifest': True,
1307 'format': '141/bestaudio[ext=m4a]',
1310 # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1312 'note': 'Embed allowed age-gate video',
1313 'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1315 'id': 'HtVdAasjOgU',
1317 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1318 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1320 'uploader': 'The Witcher',
1321 'uploader_id': 'WitcherGame',
1322 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/WitcherGame',
1323 'upload_date': '20140605',
1325 'categories': ['Gaming'],
1326 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1327 'availability': 'needs_auth',
1328 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1330 'channel': 'The Witcher',
1331 'live_status': 'not_live',
1333 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1334 'playable_in_embed': True,
1336 'channel_follower_count': int
1340 'note': 'Age-gate video with embed allowed in public site',
1341 'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1343 'id': 'HsUATh_Nc2U',
1345 'title': 'Godzilla 2 (Official Video)',
1346 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1347 'upload_date': '20200408',
1348 'uploader_id': 'FlyingKitty900',
1349 'uploader': 'FlyingKitty',
1351 'availability': 'needs_auth',
1352 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1353 'uploader_url': 'http://www.youtube.com/user/FlyingKitty900',
1354 'channel': 'FlyingKitty',
1355 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1357 'categories': ['Entertainment'],
1358 'live_status': 'not_live',
1359 'tags': ['Flyingkitty', 'godzilla 2'],
1360 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1363 'playable_in_embed': True,
1364 'channel_follower_count': int
1368 'note': 'Age-gate video embedable only with clientScreen=EMBED',
1369 'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1371 'id': 'Tq92D6wQ1mg',
1372 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1374 'upload_date': '20191228',
1375 'uploader_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1376 'uploader': 'Projekt Melody',
1377 'description': 'md5:17eccca93a786d51bc67646756894066',
1380 'availability': 'needs_auth',
1381 'uploader_url': 'http://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1382 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1384 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1385 'channel': 'Projekt Melody',
1386 'live_status': 'not_live',
1387 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1388 'playable_in_embed': True,
1389 'categories': ['Entertainment'],
1391 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1392 'comment_count': int,
1393 'channel_follower_count': int
1397 'note': 'Non-Agegated non-embeddable video',
1398 'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1400 'id': 'MeJVWBSsPAY',
1402 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1403 'uploader': 'Herr Lurik',
1404 'uploader_id': 'st3in234',
1405 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1406 'upload_date': '20130730',
1407 'track': 'Such mich find mich',
1409 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1411 'playable_in_embed': False,
1412 'creator': 'OOMPH!',
1413 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1415 'alt_title': 'Such mich find mich',
1417 'channel': 'Herr Lurik',
1418 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1419 'categories': ['Music'],
1420 'availability': 'public',
1421 'uploader_url': 'http://www.youtube.com/user/st3in234',
1422 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1423 'live_status': 'not_live',
1425 'channel_follower_count': int
1429 'note': 'Non-bypassable age-gated video',
1430 'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1431 'only_matching': True,
1433 # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1434 # YouTube Red ad is not captured for creator
1436 'url': '__2ABJjxzNo',
1438 'id': '__2ABJjxzNo',
1441 'upload_date': '20100430',
1442 'uploader_id': 'deadmau5',
1443 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/deadmau5',
1444 'creator': 'deadmau5',
1445 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1446 'uploader': 'deadmau5',
1447 'title': 'Deadmau5 - Some Chords (HD)',
1448 'alt_title': 'Some Chords',
1449 'availability': 'public',
1451 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1453 'live_status': 'not_live',
1454 'channel': 'deadmau5',
1455 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1457 'track': 'Some Chords',
1458 'artist': 'deadmau5',
1459 'playable_in_embed': True,
1461 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1462 'categories': ['Music'],
1463 'album': 'Some Chords',
1464 'channel_follower_count': int
1466 'expected_warnings': [
1467 'DASH manifest missing',
1470 # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1472 'url': 'lqQg6PlCWgI',
1474 'id': 'lqQg6PlCWgI',
1477 'upload_date': '20150827',
1478 'uploader_id': 'olympic',
1479 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/olympic',
1480 'description': 'md5:04bbbf3ccceb6795947572ca36f45904',
1481 'uploader': 'Olympics',
1482 'title': 'Hockey - Women - GER-AUS - London 2012 Olympic Games',
1484 'release_timestamp': 1343767800,
1485 'playable_in_embed': True,
1486 'categories': ['Sports'],
1487 'release_date': '20120731',
1488 'channel': 'Olympics',
1489 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1490 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1491 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1493 'availability': 'public',
1494 'live_status': 'was_live',
1496 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1497 'channel_follower_count': int
1500 'skip_download': 'requires avconv',
1505 'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1507 'id': '_b-2C3KPAM0',
1509 'stretched_ratio': 16 / 9.,
1511 'upload_date': '20110310',
1512 'uploader_id': 'AllenMeow',
1513 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/AllenMeow',
1514 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1516 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1517 'playable_in_embed': True,
1521 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1522 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1523 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1525 'categories': ['People & Blogs'],
1527 'live_status': 'not_live',
1528 'availability': 'unlisted',
1529 'comment_count': int,
1530 'channel_follower_count': int
1533 # url_encoded_fmt_stream_map is empty string
1535 'url': 'qEJwOuvDf7I',
1537 'id': 'qEJwOuvDf7I',
1539 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1541 'upload_date': '20150404',
1542 'uploader_id': 'spbelect',
1543 'uploader': 'Наблюдатели Петербурга',
1546 'skip_download': 'requires avconv',
1548 'skip': 'This live event has ended.',
1550 # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1552 'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1554 'id': 'FIl7x6_3R5Y',
1556 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1557 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1559 'upload_date': '20150625',
1560 'uploader_id': 'dorappi2000',
1561 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/dorappi2000',
1562 'uploader': 'dorappi2000',
1563 'formats': 'mincount:31',
1565 'skip': 'not actual anymore',
1567 # DASH manifest with segment_list
1569 'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1570 'md5': '8ce563a1d667b599d21064e982ab9e31',
1572 'id': 'CsmdDsKjzN8',
1574 'upload_date': '20150501', # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1575 'uploader': 'Airtek',
1576 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1577 'uploader_id': 'UCzTzUmjXxxacNnL8I3m4LnQ',
1578 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1581 'youtube_include_dash_manifest': True,
1582 'format': '135', # bestvideo
1584 'skip': 'This live event has ended.',
1587 # Multifeed videos (multiple cameras), URL can be of any Camera
1588 'url': 'https://www.youtube.com/watch?v=zaPI8MvL8pg',
1590 'id': 'zaPI8MvL8pg',
1591 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04',
1592 'description': 'md5:563ccbc698b39298481ca3c571169519',
1596 'id': 'j5yGuxZ8lLU',
1598 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Chris)',
1599 'uploader': 'WiiLikeToPlay',
1600 'description': 'md5:563ccbc698b39298481ca3c571169519',
1601 'uploader_url': 'http://www.youtube.com/user/WiiRikeToPray',
1603 'channel_follower_count': int,
1604 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1605 'availability': 'public',
1606 'playable_in_embed': True,
1607 'upload_date': '20131105',
1608 'uploader_id': 'WiiRikeToPray',
1609 'categories': ['Gaming'],
1610 'live_status': 'was_live',
1612 'release_timestamp': 1383701910,
1613 'thumbnail': 'https://i.ytimg.com/vi/j5yGuxZ8lLU/maxresdefault.jpg',
1614 'comment_count': int,
1617 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1618 'channel': 'WiiLikeToPlay',
1620 'release_date': '20131106',
1624 'id': 'zaPI8MvL8pg',
1626 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Tyson)',
1627 'uploader_id': 'WiiRikeToPray',
1628 'availability': 'public',
1629 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1630 'channel': 'WiiLikeToPlay',
1631 'uploader_url': 'http://www.youtube.com/user/WiiRikeToPray',
1632 'channel_follower_count': int,
1633 'description': 'md5:563ccbc698b39298481ca3c571169519',
1638 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1639 'uploader': 'WiiLikeToPlay',
1640 'release_timestamp': 1383701915,
1641 'comment_count': int,
1642 'upload_date': '20131105',
1643 'thumbnail': 'https://i.ytimg.com/vi/zaPI8MvL8pg/maxresdefault.jpg',
1644 'release_date': '20131106',
1645 'playable_in_embed': True,
1646 'live_status': 'was_live',
1647 'categories': ['Gaming'],
1652 'id': 'R7r3vfO7Hao',
1654 'title': 'Terraria 1.2 Live Stream | Let\'s Play - Part 04 (Spencer)',
1655 'thumbnail': 'https://i.ytimg.com/vi/R7r3vfO7Hao/maxresdefault.jpg',
1656 'channel_id': 'UCN2XePorRokPB9TEgRZpddg',
1658 'availability': 'public',
1659 'playable_in_embed': True,
1660 'upload_date': '20131105',
1661 'description': 'md5:563ccbc698b39298481ca3c571169519',
1662 'uploader_id': 'WiiRikeToPray',
1663 'uploader_url': 'http://www.youtube.com/user/WiiRikeToPray',
1664 'channel_follower_count': int,
1666 'release_date': '20131106',
1667 'uploader': 'WiiLikeToPlay',
1668 'comment_count': int,
1669 'channel_url': 'https://www.youtube.com/channel/UCN2XePorRokPB9TEgRZpddg',
1670 'channel': 'WiiLikeToPlay',
1671 'categories': ['Gaming'],
1672 'release_timestamp': 1383701914,
1673 'live_status': 'was_live',
1679 'params': {'skip_download': True},
1682 # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1683 'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1685 'id': 'gVfLd0zydlo',
1686 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1688 'playlist_count': 2,
1689 'skip': 'Not multifeed anymore',
1692 'url': 'https://vid.plus/FlRa-iH7PGw',
1693 'only_matching': True,
1696 'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1697 'only_matching': True,
1700 # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1701 # Also tests cut-off URL expansion in video description (see
1702 # https://github.com/ytdl-org/youtube-dl/issues/1892,
1703 # https://github.com/ytdl-org/youtube-dl/issues/8164)
1704 'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1706 'id': 'lsguqyKfVQg',
1708 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1709 'alt_title': 'Dark Walk',
1710 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1712 'upload_date': '20151119',
1713 'uploader_id': 'IronSoulElf',
1714 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/IronSoulElf',
1715 'uploader': 'IronSoulElf',
1716 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1717 'track': 'Dark Walk',
1718 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1719 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1720 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1721 'categories': ['Film & Animation'],
1723 'live_status': 'not_live',
1724 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1725 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1727 'availability': 'public',
1728 'channel': 'IronSoulElf',
1729 'playable_in_embed': True,
1732 'channel_follower_count': int
1735 'skip_download': True,
1739 # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1740 'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1741 'only_matching': True,
1744 # Video with yt:stretch=17:0
1745 'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1747 'id': 'Q39EVAstoRM',
1749 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1750 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1751 'upload_date': '20151107',
1752 'uploader_id': 'UCCr7TALkRbo3EtFzETQF1LA',
1753 'uploader': 'CH GAMER DROID',
1756 'skip_download': True,
1758 'skip': 'This video does not exist.',
1761 # Video with incomplete 'yt:stretch=16:'
1762 'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1763 'only_matching': True,
1766 # Video licensed under Creative Commons
1767 'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1769 'id': 'M4gD1WSo5mA',
1771 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1772 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1774 'upload_date': '20150128',
1775 'uploader_id': 'BerkmanCenter',
1776 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/BerkmanCenter',
1777 'uploader': 'The Berkman Klein Center for Internet & Society',
1778 'license': 'Creative Commons Attribution license (reuse allowed)',
1779 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1780 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1783 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1784 'channel': 'The Berkman Klein Center for Internet & Society',
1785 'availability': 'public',
1787 'categories': ['Education'],
1788 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1789 'live_status': 'not_live',
1790 'playable_in_embed': True,
1791 'comment_count': int,
1792 'channel_follower_count': int,
1796 'skip_download': True,
1800 # Channel-like uploader_url
1801 'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1803 'id': 'eQcmzGIKrzg',
1805 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1806 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1808 'upload_date': '20151120',
1809 'uploader': 'Bernie Sanders',
1810 'uploader_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1811 'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1812 'license': 'Creative Commons Attribution license (reuse allowed)',
1813 'playable_in_embed': True,
1816 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1818 'availability': 'public',
1819 'categories': ['News & Politics'],
1820 'channel': 'Bernie Sanders',
1821 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1823 'live_status': 'not_live',
1824 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1825 'comment_count': int,
1826 'channel_follower_count': int,
1830 'skip_download': True,
1834 'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;v=V36LpHqtcDY',
1835 'only_matching': True,
1838 # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1839 'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1840 'only_matching': True,
1843 # Rental video preview
1844 'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1846 'id': 'uGpuVWrhIzE',
1848 'title': 'Piku - Trailer',
1849 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1850 'upload_date': '20150811',
1851 'uploader': 'FlixMatrix',
1852 'uploader_id': 'FlixMatrixKaravan',
1853 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/FlixMatrixKaravan',
1854 'license': 'Standard YouTube License',
1857 'skip_download': True,
1859 'skip': 'This video is not available.',
1862 # YouTube Red video with episode data
1863 'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1865 'id': 'iqKdEhx-dD4',
1867 'title': 'Isolation - Mind Field (Ep 1)',
1868 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1870 'upload_date': '20170118',
1871 'uploader': 'Vsauce',
1872 'uploader_id': 'Vsauce',
1873 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/Vsauce',
1874 'series': 'Mind Field',
1876 'episode_number': 1,
1877 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1880 'availability': 'public',
1882 'channel': 'Vsauce',
1883 'episode': 'Episode 1',
1884 'categories': ['Entertainment'],
1885 'season': 'Season 1',
1886 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
1887 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
1889 'playable_in_embed': True,
1890 'live_status': 'not_live',
1891 'channel_follower_count': int
1894 'skip_download': True,
1896 'expected_warnings': [
1897 'Skipping DASH manifest',
1901 # The following content has been identified by the YouTube community
1902 # as inappropriate or offensive to some audiences.
1903 'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
1905 'id': '6SJNVb0GnPI',
1907 'title': 'Race Differences in Intelligence',
1908 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
1910 'upload_date': '20140124',
1911 'uploader': 'New Century Foundation',
1912 'uploader_id': 'UCEJYpZGqgUob0zVVEaLhvVg',
1913 'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UCEJYpZGqgUob0zVVEaLhvVg',
1916 'skip_download': True,
1918 'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
1922 'url': '1t24XAntNCY',
1923 'only_matching': True,
1926 # geo restricted to JP
1927 'url': 'sJL6WA-aGkQ',
1928 'only_matching': True,
1931 'url': 'https://invidio.us/watch?v=BaW_jenozKc',
1932 'only_matching': True,
1935 'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
1936 'only_matching': True,
1939 # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
1940 'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
1941 'only_matching': True,
1945 'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
1946 'only_matching': True,
1949 # Video with unsupported adaptive stream type formats
1950 'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
1952 'id': 'Z4Vy8R84T1U',
1954 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
1955 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
1957 'upload_date': '20130923',
1958 'uploader': 'Amelia Putri Harwita',
1959 'uploader_id': 'UCpOxM49HJxmC1qCalXyB3_Q',
1960 'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UCpOxM49HJxmC1qCalXyB3_Q',
1961 'formats': 'maxcount:10',
1964 'skip_download': True,
1965 'youtube_include_dash_manifest': False,
1967 'skip': 'not actual anymore',
1970 # Youtube Music Auto-generated description
1971 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
1973 'id': 'MgNrAu2pzNs',
1975 'title': 'Voyeur Girl',
1976 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
1977 'upload_date': '20190312',
1978 'uploader': 'Stephen - Topic',
1979 'uploader_id': 'UC-pWHpBjdGG69N9mM2auIAA',
1980 'artist': 'Stephen',
1981 'track': 'Voyeur Girl',
1982 'album': 'it\'s too much love to know my dear',
1983 'release_date': '20190313',
1984 'release_year': 2019,
1985 'alt_title': 'Voyeur Girl',
1987 'uploader_url': 'http://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
1988 'playable_in_embed': True,
1990 'categories': ['Music'],
1991 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
1992 'channel': 'Stephen',
1993 'availability': 'public',
1994 'creator': 'Stephen',
1996 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
1998 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
2000 'live_status': 'not_live',
2001 'channel_follower_count': int
2004 'skip_download': True,
2008 'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
2009 'only_matching': True,
2012 # invalid -> valid video id redirection
2013 'url': 'DJztXj2GPfl',
2015 'id': 'DJztXj2GPfk',
2017 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
2018 'description': 'md5:bf577a41da97918e94fa9798d9228825',
2019 'upload_date': '20090125',
2020 'uploader': 'Prochorowka',
2021 'uploader_id': 'Prochorowka',
2022 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/Prochorowka',
2023 'artist': 'Panjabi MC',
2024 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
2025 'album': 'Beware of the Boys (Mundian To Bach Ke)',
2028 'skip_download': True,
2030 'skip': 'Video unavailable',
2033 # empty description results in an empty string
2034 'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
2036 'id': 'x41yOUIvK2k',
2038 'title': 'IMG 3456',
2040 'upload_date': '20170613',
2041 'uploader_id': 'ElevageOrVert',
2042 'uploader': 'ElevageOrVert',
2044 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
2045 'uploader_url': 'http://www.youtube.com/user/ElevageOrVert',
2047 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
2049 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
2050 'availability': 'public',
2052 'categories': ['Pets & Animals'],
2054 'playable_in_embed': True,
2055 'live_status': 'not_live',
2056 'channel': 'ElevageOrVert',
2057 'channel_follower_count': int
2060 'skip_download': True,
2064 # with '};' inside yt initial data (see [1])
2065 # see [2] for an example with '};' inside ytInitialPlayerResponse
2066 # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
2067 # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
2068 'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
2070 'id': 'CHqg6qOn4no',
2072 'title': 'Part 77 Sort a list of simple types in c#',
2073 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
2074 'upload_date': '20130831',
2075 'uploader_id': 'kudvenkat',
2076 'uploader': 'kudvenkat',
2077 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
2079 'uploader_url': 'http://www.youtube.com/user/kudvenkat',
2080 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
2081 'live_status': 'not_live',
2082 'categories': ['Education'],
2083 'availability': 'public',
2084 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
2086 'playable_in_embed': True,
2090 'channel': 'kudvenkat',
2091 'comment_count': int,
2092 'channel_follower_count': int,
2096 'skip_download': True,
2100 # another example of '};' in ytInitialData
2101 'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
2102 'only_matching': True,
2105 'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
2106 'only_matching': True,
2109 # https://github.com/ytdl-org/youtube-dl/pull/28094
2110 'url': 'OtqTfy26tG0',
2112 'id': 'OtqTfy26tG0',
2114 'title': 'Burn Out',
2115 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
2116 'upload_date': '20141120',
2117 'uploader': 'The Cinematic Orchestra - Topic',
2118 'uploader_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2119 'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2120 'artist': 'The Cinematic Orchestra',
2121 'track': 'Burn Out',
2122 'album': 'Every Day',
2124 'live_status': 'not_live',
2125 'alt_title': 'Burn Out',
2129 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
2130 'creator': 'The Cinematic Orchestra',
2131 'channel': 'The Cinematic Orchestra',
2132 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
2133 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
2134 'availability': 'public',
2135 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
2136 'categories': ['Music'],
2137 'playable_in_embed': True,
2138 'channel_follower_count': int
2141 'skip_download': True,
2145 # controversial video, only works with bpctr when authenticated with cookies
2146 'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
2147 'only_matching': True,
2150 # controversial video, requires bpctr/contentCheckOk
2151 'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
2153 'id': 'SZJvDhaSDnc',
2155 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
2156 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
2157 'uploader': 'CBS Mornings',
2158 'uploader_id': 'CBSThisMorning',
2159 'upload_date': '20140716',
2160 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
2162 'categories': ['News & Politics'],
2163 'uploader_url': 'http://www.youtube.com/user/CBSThisMorning',
2165 'channel': 'CBS Mornings',
2166 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
2167 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
2169 'availability': 'needs_auth',
2170 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
2172 'live_status': 'not_live',
2173 'playable_in_embed': True,
2174 'channel_follower_count': int
2178 # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
2179 'url': 'cBvYw8_A0vQ',
2181 'id': 'cBvYw8_A0vQ',
2183 'title': '4K Ueno Okachimachi Street Scenes 上野御徒町歩き',
2184 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
2185 'upload_date': '20201120',
2186 'uploader': 'Walk around Japan',
2187 'uploader_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2188 'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2190 'categories': ['Travel & Events'],
2191 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
2193 'channel': 'Walk around Japan',
2194 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
2195 'thumbnail': 'https://i.ytimg.com/vi_webp/cBvYw8_A0vQ/hqdefault.webp',
2197 'availability': 'public',
2198 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
2199 'live_status': 'not_live',
2200 'playable_in_embed': True,
2201 'channel_follower_count': int
2204 'skip_download': True,
2207 # Has multiple audio streams
2208 'url': 'WaOKSUlf4TM',
2209 'only_matching': True
2211 # Requires Premium: has format 141 when requested using YTM url
2212 'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2213 'only_matching': True
2215 # multiple subtitles with same lang_code
2216 'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2217 'only_matching': True,
2219 # Force use android client fallback
2220 'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2222 'id': 'YOelRv7fMxY',
2223 'title': 'DIGGING A SECRET TUNNEL Part 1',
2225 'upload_date': '20210624',
2226 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2227 'uploader': 'colinfurze',
2228 'uploader_id': 'colinfurze',
2229 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2230 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2232 'categories': ['Entertainment'],
2233 'uploader_url': 'http://www.youtube.com/user/colinfurze',
2235 'channel': 'colinfurze',
2236 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2237 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2239 'availability': 'public',
2241 'live_status': 'not_live',
2242 'playable_in_embed': True,
2243 'channel_follower_count': int,
2247 'format': '17', # 3gp format available on android
2248 'extractor_args': {'youtube': {'player_client': ['android']}},
2252 # Skip download of additional client configs (remix client config in this case)
2253 'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2254 'only_matching': True,
2256 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2260 'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2261 'only_matching': True,
2263 'note': 'Storyboards',
2264 'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2266 'id': '5KLPxDtMqe8',
2269 'title': 'Your Brain is Plastic',
2270 'uploader_id': 'scishow',
2271 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2272 'upload_date': '20140324',
2273 'uploader': 'SciShow',
2275 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2276 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2278 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2279 'playable_in_embed': True,
2281 'uploader_url': 'http://www.youtube.com/user/scishow',
2282 'availability': 'public',
2283 'channel': 'SciShow',
2284 'live_status': 'not_live',
2286 'categories': ['Education'],
2288 'channel_follower_count': int,
2290 }, 'params': {'format': 'mhtml', 'skip_download': True}
2292 # Ensure video upload_date is in UTC timezone (video was uploaded 1641170939)
2293 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2295 'id': '2NUZ8W2llS4',
2297 'title': 'The NP that test your phone performance 🙂',
2298 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2299 'uploader': 'Leon Nguyen',
2300 'uploader_id': 'VNSXIII',
2301 'uploader_url': 'http://www.youtube.com/user/VNSXIII',
2302 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2303 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2307 'categories': ['Gaming'],
2309 'playable_in_embed': True,
2310 'live_status': 'not_live',
2311 'upload_date': '20220103',
2313 'availability': 'public',
2314 'channel': 'Leon Nguyen',
2315 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2316 'comment_count': int,
2317 'channel_follower_count': int
2320 # Same video as above, but with --compat-opt no-youtube-prefer-utc-upload-date
2321 'url': 'https://www.youtube.com/watch?v=2NUZ8W2llS4',
2323 'id': '2NUZ8W2llS4',
2325 'title': 'The NP that test your phone performance 🙂',
2326 'description': 'md5:144494b24d4f9dfacb97c1bbef5de84d',
2327 'uploader': 'Leon Nguyen',
2328 'uploader_id': 'VNSXIII',
2329 'uploader_url': 'http://www.youtube.com/user/VNSXIII',
2330 'channel_id': 'UCRqNBSOHgilHfAczlUmlWHA',
2331 'channel_url': 'https://www.youtube.com/channel/UCRqNBSOHgilHfAczlUmlWHA',
2335 'categories': ['Gaming'],
2337 'playable_in_embed': True,
2338 'live_status': 'not_live',
2339 'upload_date': '20220102',
2341 'availability': 'public',
2342 'channel': 'Leon Nguyen',
2343 'thumbnail': 'https://i.ytimg.com/vi_webp/2NUZ8W2llS4/maxresdefault.webp',
2344 'comment_count': int,
2345 'channel_follower_count': int
2347 'params': {'compat_opts': ['no-youtube-prefer-utc-upload-date']}
2349 # date text is premiered video, ensure upload date in UTC (published 1641172509)
2350 'url': 'https://www.youtube.com/watch?v=mzZzzBU6lrM',
2352 'id': 'mzZzzBU6lrM',
2354 'title': 'I Met GeorgeNotFound In Real Life...',
2355 'description': 'md5:cca98a355c7184e750f711f3a1b22c84',
2356 'uploader': 'Quackity',
2357 'uploader_id': 'QuackityHQ',
2358 'uploader_url': 'http://www.youtube.com/user/QuackityHQ',
2359 'channel_id': 'UC_8NknAFiyhOUaZqHR3lq3Q',
2360 'channel_url': 'https://www.youtube.com/channel/UC_8NknAFiyhOUaZqHR3lq3Q',
2364 'categories': ['Entertainment'],
2366 'playable_in_embed': True,
2367 'live_status': 'not_live',
2368 'release_timestamp': 1641172509,
2369 'release_date': '20220103',
2370 'upload_date': '20220103',
2372 'availability': 'public',
2373 'channel': 'Quackity',
2374 'thumbnail': 'https://i.ytimg.com/vi/mzZzzBU6lrM/maxresdefault.jpg',
2375 'channel_follower_count': int
2378 { # continuous livestream. Microformat upload date should be preferred.
2379 # Upload date was 2021-06-19 (not UTC), while stream start is 2021-11-27
2380 'url': 'https://www.youtube.com/watch?v=kgx4WGK0oNU',
2382 'id': 'kgx4WGK0oNU',
2383 '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}',
2385 'channel_id': 'UC84whx2xxsiA1gXHXXqKGOA',
2386 'availability': 'public',
2388 'release_timestamp': 1637975704,
2389 'upload_date': '20210619',
2390 'channel_url': 'https://www.youtube.com/channel/UC84whx2xxsiA1gXHXXqKGOA',
2391 'live_status': 'is_live',
2392 'thumbnail': 'https://i.ytimg.com/vi/kgx4WGK0oNU/maxresdefault.jpg',
2393 'uploader': '阿鲍Abao',
2394 'uploader_url': 'http://www.youtube.com/channel/UC84whx2xxsiA1gXHXXqKGOA',
2395 'channel': 'Abao in Tokyo',
2396 'channel_follower_count': int,
2397 'release_date': '20211127',
2399 'categories': ['People & Blogs'],
2401 'uploader_id': 'UC84whx2xxsiA1gXHXXqKGOA',
2403 'playable_in_embed': True,
2404 'description': 'md5:2ef1d002cad520f65825346e2084e49d',
2405 'concurrent_view_count': int,
2407 'params': {'skip_download': True}
2409 # Story. Requires specific player params to work.
2410 'url': 'https://www.youtube.com/watch?v=vv8qTUWmulI',
2412 'id': 'vv8qTUWmulI',
2414 'availability': 'unlisted',
2416 'channel_id': 'UCzIZ8HrzDgc-pNQDUG6avBA',
2417 'upload_date': '20220526',
2418 'categories': ['Education'],
2420 'channel': 'IT\'S HISTORY',
2422 'uploader_id': 'BlastfromthePast',
2424 'uploader': 'IT\'S HISTORY',
2425 'playable_in_embed': True,
2427 'live_status': 'not_live',
2429 'thumbnail': 'https://i.ytimg.com/vi_webp/vv8qTUWmulI/maxresdefault.webp',
2430 'uploader_url': 'http://www.youtube.com/user/BlastfromthePast',
2431 'channel_url': 'https://www.youtube.com/channel/UCzIZ8HrzDgc-pNQDUG6avBA',
2433 'skip': 'stories get removed after some period of time',
2435 'url': 'https://www.youtube.com/watch?v=tjjjtzRLHvA',
2437 'id': 'tjjjtzRLHvA',
2439 'title': 'ハッシュタグ無し };if window.ytcsi',
2440 'upload_date': '20220323',
2442 'availability': 'unlisted',
2443 'channel': 'nao20010128nao',
2444 'thumbnail': 'https://i.ytimg.com/vi_webp/tjjjtzRLHvA/maxresdefault.webp',
2446 'uploader': 'nao20010128nao',
2447 'uploader_id': 'nao20010128nao',
2448 'categories': ['Music'],
2451 'channel_url': 'https://www.youtube.com/channel/UCdqltm_7iv1Vs6kp6Syke5A',
2452 'channel_id': 'UCdqltm_7iv1Vs6kp6Syke5A',
2453 'live_status': 'not_live',
2454 'playable_in_embed': True,
2455 'channel_follower_count': int,
2458 'uploader_url': 'http://www.youtube.com/user/nao20010128nao',
2461 # Prefer primary title+description language metadata by default
2462 # Do not prefer translated description if primary is empty
2463 'url': 'https://www.youtube.com/watch?v=el3E4MbxRqQ',
2465 'id': 'el3E4MbxRqQ',
2467 'title': 'dlp test video 2 - primary sv no desc',
2469 'channel': 'cole-dlp-test-acc',
2472 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2474 'playable_in_embed': True,
2475 'availability': 'unlisted',
2476 'thumbnail': 'https://i.ytimg.com/vi_webp/el3E4MbxRqQ/maxresdefault.webp',
2479 'uploader_id': 'UCiu-3thuViMebBjw_5nWYrA',
2480 'uploader_url': 'http://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2481 'live_status': 'not_live',
2482 'upload_date': '20220908',
2483 'categories': ['People & Blogs'],
2484 'uploader': 'cole-dlp-test-acc',
2485 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2487 'params': {'skip_download': True}
2489 # Extractor argument: prefer translated title+description
2490 'url': 'https://www.youtube.com/watch?v=gHKT4uU8Zng',
2492 'id': 'gHKT4uU8Zng',
2494 'channel': 'cole-dlp-test-acc',
2497 'live_status': 'not_live',
2498 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
2499 'upload_date': '20220728',
2500 'uploader_id': 'UCiu-3thuViMebBjw_5nWYrA',
2502 'categories': ['People & Blogs'],
2503 'thumbnail': 'https://i.ytimg.com/vi_webp/gHKT4uU8Zng/maxresdefault.webp',
2504 'title': 'dlp test video title translated (fr)',
2505 'availability': 'public',
2506 'uploader': 'cole-dlp-test-acc',
2508 'description': 'dlp test video description translated (fr)',
2509 'playable_in_embed': True,
2510 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2511 'uploader_url': 'http://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
2513 'params': {'skip_download': True, 'extractor_args': {'youtube': {'lang': ['fr']}}},
2514 'expected_warnings': [r'Preferring "fr" translated fields'],
2516 'note': '6 channel audio',
2517 'url': 'https://www.youtube.com/watch?v=zgdo7-RRjgo',
2518 'only_matching': True,
2520 'note': 'Multiple HLS formats with same itag',
2521 'url': 'https://www.youtube.com/watch?v=kX3nB4PpJko',
2523 'id': 'kX3nB4PpJko',
2525 'categories': ['Entertainment'],
2526 'description': 'md5:e8031ff6e426cdb6a77670c9b81f6fa6',
2527 'uploader_url': 'http://www.youtube.com/user/MrBeast6000',
2528 'live_status': 'not_live',
2530 'channel_follower_count': int,
2531 'thumbnail': 'https://i.ytimg.com/vi_webp/kX3nB4PpJko/maxresdefault.webp',
2532 'title': 'Last To Take Hand Off Jet, Keeps It!',
2533 'channel': 'MrBeast',
2534 'playable_in_embed': True,
2536 'upload_date': '20221112',
2537 'uploader': 'MrBeast',
2538 'uploader_id': 'MrBeast6000',
2539 'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA',
2541 'availability': 'public',
2542 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA',
2546 'params': {'extractor_args': {'youtube': {'player_client': ['ios']}}, 'format': '233-1'},
2551 # YouTube <object> embed
2553 'url': 'http://www.improbable.com/2017/04/03/untrained-modern-youths-and-ancient-masters-in-selfie-portraits/',
2554 'md5': '873c81d308b979f0e23ee7e620b312a3',
2556 'id': 'msN87y-iEx0',
2558 'title': 'Feynman: Mirrors FUN TO IMAGINE 6',
2559 'upload_date': '20080526',
2560 'description': 'md5:873c81d308b979f0e23ee7e620b312a3',
2561 'uploader': 'Christopher Sykes',
2562 'uploader_id': 'ChristopherJSykes',
2564 'tags': ['feynman', 'mirror', 'science', 'physics', 'imagination', 'fun', 'cool', 'puzzle'],
2565 'channel_id': 'UCCeo--lls1vna5YJABWAcVA',
2566 'playable_in_embed': True,
2567 'thumbnail': 'https://i.ytimg.com/vi/msN87y-iEx0/hqdefault.jpg',
2569 'comment_count': int,
2570 'channel': 'Christopher Sykes',
2571 'live_status': 'not_live',
2572 'channel_url': 'https://www.youtube.com/channel/UCCeo--lls1vna5YJABWAcVA',
2573 'availability': 'public',
2576 'categories': ['Science & Technology'],
2577 'channel_follower_count': int,
2578 'uploader_url': 'http://www.youtube.com/user/ChristopherJSykes',
2581 'skip_download': True,
2587 def suitable(cls, url):
2588 from ..utils import parse_qs
2591 if qs.get('list', [None])[0]:
2593 return super().suitable(url)
2595 def __init__(self, *args, **kwargs):
2596 super().__init__(*args, **kwargs)
2597 self._code_cache = {}
2598 self._player_cache = {}
2600 def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data, is_live):
2601 lock = threading.Lock()
2602 start_time = time.time()
2603 formats = [f for f in formats if f.get('is_from_start')]
2605 def refetch_manifest(format_id, delay):
2606 nonlocal formats, start_time, is_live
2607 if time.time() <= start_time + delay:
2610 _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2611 video_details = traverse_obj(
2612 prs, (..., 'videoDetails'), expected_type=dict, default=[])
2613 microformats = traverse_obj(
2614 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2615 expected_type=dict, default=[])
2616 _, live_status, _, formats, _ = self._list_formats(video_id, microformats, video_details, prs, player_url)
2617 is_live = live_status == 'is_live'
2618 start_time = time.time()
2620 def mpd_feed(format_id, delay):
2622 @returns (manifest_url, manifest_stream_number, is_live) or None
2625 refetch_manifest(format_id, delay)
2627 f = next((f for f in formats if f['format_id'] == format_id), None)
2630 self.to_screen(f'{video_id}: Video is no longer live')
2632 self.report_warning(
2633 f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}')
2635 return f['manifest_url'], f['manifest_stream_number'], is_live
2638 f['is_live'] = is_live
2639 gen = functools.partial(self._live_dash_fragments, video_id, f['format_id'],
2640 live_start_time, mpd_feed, not is_live and f.copy())
2642 f['fragments'] = gen
2643 f['protocol'] = 'http_dash_segments_generator'
2645 f['fragments'] = LazyList(gen({}))
2646 del f['is_from_start']
2648 def _live_dash_fragments(self, video_id, format_id, live_start_time, mpd_feed, manifestless_orig_fmt, ctx):
2649 FETCH_SPAN, MAX_DURATION = 5, 432000
2651 mpd_url, stream_number, is_live = None, None, True
2654 download_start_time = ctx.get('start') or time.time()
2656 lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2657 if lack_early_segments:
2658 self.report_warning(bug_reports_message(
2659 'Starting download from the last 120 hours of the live stream since '
2660 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2661 lack_early_segments = True
2663 known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2664 fragments, fragment_base_url = None, None
2666 def _extract_sequence_from_mpd(refresh_sequence, immediate):
2667 nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2668 # Obtain from MPD's maximum seq value
2669 old_mpd_url = mpd_url
2670 last_error = ctx.pop('last_error', None)
2671 expire_fast = immediate or last_error and isinstance(last_error, urllib.error.HTTPError) and last_error.code == 403
2672 mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2673 or (mpd_url, stream_number, False))
2674 if not refresh_sequence:
2675 if expire_fast and not is_live:
2676 return False, last_seq
2677 elif old_mpd_url == mpd_url:
2678 return True, last_seq
2679 if manifestless_orig_fmt:
2680 fmt_info = manifestless_orig_fmt
2683 fmts, _ = self._extract_mpd_formats_and_subtitles(
2684 mpd_url, None, note=False, errnote=False, fatal=False)
2685 except ExtractorError:
2688 no_fragment_score += 2
2689 return False, last_seq
2690 fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2691 fragments = fmt_info['fragments']
2692 fragment_base_url = fmt_info['fragment_base_url']
2693 assert fragment_base_url
2695 _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2696 return True, _last_seq
2698 self.write_debug(f'[{video_id}] Generating fragments for format {format_id}')
2700 fetch_time = time.time()
2701 if no_fragment_score > 30:
2703 if last_segment_url:
2704 # Obtain from "X-Head-Seqnum" header value from each segment
2706 urlh = self._request_webpage(
2707 last_segment_url, None, note=False, errnote=False, fatal=False)
2708 except ExtractorError:
2710 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2711 if last_seq is None:
2712 no_fragment_score += 2
2713 last_segment_url = None
2716 should_continue, last_seq = _extract_sequence_from_mpd(True, no_fragment_score > 15)
2717 no_fragment_score += 2
2718 if not should_continue:
2721 if known_idx > last_seq:
2722 last_segment_url = None
2727 if begin_index < 0 and known_idx < 0:
2728 # skip from the start when it's negative value
2729 known_idx = last_seq + begin_index
2730 if lack_early_segments:
2731 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2733 for idx in range(known_idx, last_seq):
2734 # do not update sequence here or you'll get skipped some part of it
2735 should_continue, _ = _extract_sequence_from_mpd(False, False)
2736 if not should_continue:
2738 raise ExtractorError('breaking out of outer loop')
2739 last_segment_url = urljoin(fragment_base_url, 'sq/%d' % idx)
2741 'url': last_segment_url,
2742 'fragment_count': last_seq,
2744 if known_idx == last_seq:
2745 no_fragment_score += 5
2747 no_fragment_score = 0
2748 known_idx = last_seq
2749 except ExtractorError:
2752 if manifestless_orig_fmt:
2753 # Stop at the first iteration if running for post-live manifestless;
2754 # fragment count no longer increase since it starts
2757 time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2759 def _extract_player_url(self, *ytcfgs, webpage=None):
2760 player_url = traverse_obj(
2761 ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2762 get_all=False, expected_type=str)
2765 return urljoin('https://www.youtube.com', player_url)
2767 def _download_player_url(self, video_id, fatal=False):
2768 res = self._download_webpage(
2769 'https://www.youtube.com/iframe_api',
2770 note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2772 player_version = self._search_regex(
2773 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2775 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2777 def _signature_cache_id(self, example_sig):
2778 """ Return a string representation of a signature """
2779 return '.'.join(str(len(part)) for part in example_sig.split('.'))
2782 def _extract_player_info(cls, player_url):
2783 for player_re in cls._PLAYER_INFO_RE:
2784 id_m = re.search(player_re, player_url)
2788 raise ExtractorError('Cannot identify player %r' % player_url)
2789 return id_m.group('id')
2791 def _load_player(self, video_id, player_url, fatal=True):
2792 player_id = self._extract_player_info(player_url)
2793 if player_id not in self._code_cache:
2794 code = self._download_webpage(
2795 player_url, video_id, fatal=fatal,
2796 note='Downloading player ' + player_id,
2797 errnote='Download of %s failed' % player_url)
2799 self._code_cache[player_id] = code
2800 return self._code_cache.get(player_id)
2802 def _extract_signature_function(self, video_id, player_url, example_sig):
2803 player_id = self._extract_player_info(player_url)
2805 # Read from filesystem cache
2806 func_id = f'js_{player_id}_{self._signature_cache_id(example_sig)}'
2807 assert os.path.basename(func_id) == func_id
2809 self.write_debug(f'Extracting signature function {func_id}')
2810 cache_spec, code = self.cache.load('youtube-sigfuncs', func_id), None
2813 code = self._load_player(video_id, player_url)
2815 res = self._parse_sig_js(code)
2816 test_string = ''.join(map(chr, range(len(example_sig))))
2817 cache_spec = [ord(c) for c in res(test_string)]
2818 self.cache.store('youtube-sigfuncs', func_id, cache_spec)
2820 return lambda s: ''.join(s[i] for i in cache_spec)
2822 def _print_sig_code(self, func, example_sig):
2823 if not self.get_param('youtube_print_sig_code'):
2826 def gen_sig_code(idxs):
2827 def _genslice(start, end, step):
2828 starts = '' if start == 0 else str(start)
2829 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
2830 steps = '' if step == 1 else (':%d' % step)
2831 return f's[{starts}{ends}{steps}]'
2834 # Quelch pyflakes warnings - start will be set when step is set
2835 start = '(Never used)'
2836 for i, prev in zip(idxs[1:], idxs[:-1]):
2837 if step is not None:
2838 if i - prev == step:
2840 yield _genslice(start, prev, step)
2843 if i - prev in [-1, 1]:
2848 yield 's[%d]' % prev
2852 yield _genslice(start, i, step)
2854 test_string = ''.join(map(chr, range(len(example_sig))))
2855 cache_res = func(test_string)
2856 cache_spec = [ord(c) for c in cache_res]
2857 expr_code = ' + '.join(gen_sig_code(cache_spec))
2858 signature_id_tuple = '(%s)' % (
2859 ', '.join(str(len(p)) for p in example_sig.split('.')))
2860 code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
2861 ' return %s\n') % (signature_id_tuple, expr_code)
2862 self.to_screen('Extracted signature function:\n' + code)
2864 def _parse_sig_js(self, jscode):
2865 funcname = self._search_regex(
2866 (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2867 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2868 r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
2869 r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
2870 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+\)',
2871 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*\)',
2872 r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
2874 r'(["\'])signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2875 r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
2876 r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2877 r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2878 r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2879 r'\bc\s*&&\s*a\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2880 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2881 r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
2882 jscode, 'Initial JS player signature function name', group='sig')
2884 jsi = JSInterpreter(jscode)
2885 initial_function = jsi.extract_function(funcname)
2886 return lambda s: initial_function([s])
2888 def _cached(self, func, *cache_id):
2889 def inner(*args, **kwargs):
2890 if cache_id not in self._player_cache:
2892 self._player_cache[cache_id] = func(*args, **kwargs)
2893 except ExtractorError as e:
2894 self._player_cache[cache_id] = e
2895 except Exception as e:
2896 self._player_cache[cache_id] = ExtractorError(traceback.format_exc(), cause=e)
2898 ret = self._player_cache[cache_id]
2899 if isinstance(ret, Exception):
2904 def _decrypt_signature(self, s, video_id, player_url):
2905 """Turn the encrypted s field into a working signature"""
2906 extract_sig = self._cached(
2907 self._extract_signature_function, 'sig', player_url, self._signature_cache_id(s))
2908 func = extract_sig(video_id, player_url, s)
2909 self._print_sig_code(func, s)
2912 def _decrypt_nsig(self, s, video_id, player_url):
2913 """Turn the encrypted n field into a working signature"""
2914 if player_url is None:
2915 raise ExtractorError('Cannot decrypt nsig without player_url')
2916 player_url = urljoin('https://www.youtube.com', player_url)
2919 jsi, player_id, func_code = self._extract_n_function_code(video_id, player_url)
2920 except ExtractorError as e:
2921 raise ExtractorError('Unable to extract nsig function code', cause=e)
2922 if self.get_param('youtube_print_sig_code'):
2923 self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
2926 extract_nsig = self._cached(self._extract_n_function_from_code, 'nsig func', player_url)
2927 ret = extract_nsig(jsi, func_code)(s)
2928 except JSInterpreter.Exception as e:
2930 jsi = PhantomJSwrapper(self, timeout=5000)
2931 except ExtractorError:
2933 self.report_warning(
2934 f'Native nsig extraction failed: Trying with PhantomJS\n'
2935 f' n = {s} ; player = {player_url}', video_id)
2936 self.write_debug(e, only_once=True)
2938 args, func_body = func_code
2940 f'console.log(function({", ".join(args)}) {{ {func_body} }}({s!r}));',
2941 video_id=video_id, note='Executing signature code').strip()
2943 self.write_debug(f'Decrypted nsig {s} => {ret}')
2946 def _extract_n_function_name(self, jscode):
2947 funcname, idx = self._search_regex(
2948 r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]+)(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
2949 jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
2953 return json.loads(js_to_json(self._search_regex(
2954 rf'var {re.escape(funcname)}\s*=\s*(\[.+?\]);', jscode,
2955 f'Initial JS player n function list ({funcname}.{idx})')))[int(idx)]
2957 def _extract_n_function_code(self, video_id, player_url):
2958 player_id = self._extract_player_info(player_url)
2959 func_code = self.cache.load('youtube-nsig', player_id, min_ver='2022.09.1')
2960 jscode = func_code or self._load_player(video_id, player_url)
2961 jsi = JSInterpreter(jscode)
2964 return jsi, player_id, func_code
2966 func_name = self._extract_n_function_name(jscode)
2969 func_code = self._search_regex(
2970 r'''(?xs
)%s\s
*=\s
*function\s
*\
((?P
<var
>[\w$
]+)\
)\s
*
2971 # NB: The end of the regex is intentionally kept strict
2972 {(?P<code>.+?}\s
*return\
[\w$
]+.join\
(""\
))};''' % func_name,
2973 jscode, 'nsig function', group=('var', 'code'), default=None)
2975 func_code = ([func_code[0]], func_code[1])
2977 self.write_debug('Extracting nsig function with jsinterp')
2978 func_code = jsi.extract_function_code(func_name)
2980 self.cache.store('youtube-nsig', player_id, func_code)
2981 return jsi, player_id, func_code
2983 def _extract_n_function_from_code(self, jsi, func_code):
2984 func = jsi.extract_function_from_code(*func_code)
2986 def extract_nsig(s):
2989 except JSInterpreter.Exception:
2991 except Exception as e:
2992 raise JSInterpreter.Exception(traceback.format_exc(), cause=e)
2994 if ret.startswith('enhanced_except_'):
2995 raise JSInterpreter.Exception('Signature function returned an exception')
3000 def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
3002 Extract signatureTimestamp (sts)
3003 Required to tell API what sig/player version is in use.
3006 if isinstance(ytcfg, dict):
3007 sts = int_or_none(ytcfg.get('STS'))
3010 # Attempt to extract from player
3011 if player_url is None:
3012 error_msg = 'Cannot extract signature timestamp without player_url.'
3014 raise ExtractorError(error_msg)
3015 self.report_warning(error_msg)
3017 code = self._load_player(video_id, player_url, fatal=fatal)
3019 sts = int_or_none(self._search_regex(
3020 r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
3021 'JS player signature timestamp', group='sts', fatal=fatal))
3024 def _mark_watched(self, video_id, player_responses):
3025 for is_full, key in enumerate(('videostatsPlaybackUrl', 'videostatsWatchtimeUrl')):
3026 label = 'fully ' if is_full else ''
3027 url = get_first(player_responses, ('playbackTracking', key, 'baseUrl'),
3028 expected_type=url_or_none)
3030 self.report_warning(f'Unable to mark {label}watched')
3032 parsed_url = urllib.parse.urlparse(url)
3033 qs = urllib.parse.parse_qs(parsed_url.query)
3035 # cpn generation algorithm is reverse engineered from base.js.
3036 # In fact it works even with dummy cpn.
3037 CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
3038 cpn = ''.join(CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16))
3040 # # more consistent results setting it to right before the end
3041 video_length = [str(float((qs.get('len') or ['1.5'])[0]) - 1)]
3046 'cmt': video_length,
3047 'el': 'detailpage', # otherwise defaults to "shorts"
3051 # these seem to mark watchtime "history" in the real world
3052 # they're required, so send in a single value
3058 url = urllib.parse.urlunparse(
3059 parsed_url._replace(query=urllib.parse.urlencode(qs, True)))
3061 self._download_webpage(
3062 url, video_id, f'Marking {label}watched',
3063 'Unable to mark watched', fatal=False)
3066 def _extract_from_webpage(cls, url, webpage):
3067 # Invidious Instances
3068 # https://github.com/yt-dlp/yt-dlp/issues/195
3069 # https://github.com/iv-org/invidious/pull/1730
3071 r'<link rel="alternate" href="(?P<url>https://www\.youtube\.com/watch\?v=[0-9A-Za-z_-]{11})"',
3074 yield cls.url_result(mobj.group('url'), cls)
3075 raise cls.StopExtraction()
3077 yield from super()._extract_from_webpage(url, webpage)
3079 # lazyYT YouTube embed
3080 for id_ in re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage):
3081 yield cls.url_result(unescapeHTML(id_), cls, id_)
3083 # Wordpress "YouTube Video Importer" plugin
3084 for m in re.findall(r'''(?x
)<div
[^
>]+
3085 class=(?P
<q1
>[\'"])[^\'"]*\byvii
_single
_video
_player
\b[^
\'"]*(?P=q1)[^>]+
3086 data-video_id=(?P<q2>[\'"])([^
\'"]+)(?P=q2)''', webpage):
3087 yield cls.url_result(m[-1], cls, m[-1])
3090 def extract_id(cls, url):
3091 video_id = cls.get_temp_id(url)
3093 raise ExtractorError(f'Invalid URL: {url}')
3096 def _extract_chapters_from_json(self, data, duration):
3097 chapter_list = traverse_obj(
3099 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
3100 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters'
3101 ), expected_type=list)
3103 return self._extract_chapters(
3105 chapter_time=lambda chapter: float_or_none(
3106 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
3107 chapter_title=lambda chapter: traverse_obj(
3108 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
3111 def _extract_chapters_from_engagement_panel(self, data, duration):
3112 content_list = traverse_obj(
3114 ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
3115 expected_type=list, default=[])
3116 chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
3117 chapter_title = lambda chapter: self._get_text(chapter, 'title')
3119 return next(filter(None, (
3120 self._extract_chapters(traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
3121 chapter_time, chapter_title, duration)
3122 for contents in content_list)), [])
3124 def _extract_chapters_from_description(self, description, duration):
3125 duration_re = r'(?:\d+:)?\d{1,2}:\d{2}'
3126 sep_re = r'(?m)^\s*(%s)\b\W*\s(%s)\s*$'
3127 return self._extract_chapters(
3128 re.findall(sep_re % (duration_re, r'.+?'), description or ''),
3129 chapter_time=lambda x: parse_duration(x[0]), chapter_title=lambda x: x[1],
3130 duration=duration, strict=False) or self._extract_chapters(
3131 re.findall(sep_re % (r'.+?', duration_re), description or ''),
3132 chapter_time=lambda x: parse_duration(x[1]), chapter_title=lambda x: x[0],
3133 duration=duration, strict=False)
3135 def _extract_chapters(self, chapter_list, chapter_time, chapter_title, duration, strict=True):
3139 'start_time': chapter_time(chapter),
3140 'title': chapter_title(chapter),
3141 } for chapter in chapter_list or []]
3143 chapter_list.sort(key=lambda c: c['start_time'] or 0)
3145 chapters = [{'start_time': 0}]
3146 for idx, chapter in enumerate(chapter_list):
3147 if chapter['start_time'] is None:
3148 self.report_warning(f'Incomplete chapter {idx}')
3149 elif chapters[-1]['start_time'] <= chapter['start_time'] <= duration:
3150 chapters.append(chapter)
3151 elif chapter not in chapters:
3152 self.report_warning(
3153 f'Invalid start time ({chapter["start_time"]} < {chapters[-1]["start_time"]}) for chapter "{chapter["title"]}
"')
3156 def _extract_comment(self, comment_renderer, parent=None):
3157 comment_id = comment_renderer.get('commentId')
3161 text = self._get_text(comment_renderer, 'contentText')
3163 # Timestamp is an estimate calculated from the current time and time_text
3164 time_text = self._get_text(comment_renderer, 'publishedTimeText') or ''
3165 timestamp = self._parse_time_text(time_text)
3167 author = self._get_text(comment_renderer, 'authorText')
3168 author_id = try_get(comment_renderer,
3169 lambda x: x['authorEndpoint']['browseEndpoint']['browseId'], str)
3171 votes = parse_count(try_get(comment_renderer, (lambda x: x['voteCount']['simpleText'],
3172 lambda x: x['likeCount']), str)) or 0
3173 author_thumbnail = try_get(comment_renderer,
3174 lambda x: x['authorThumbnail']['thumbnails'][-1]['url'], str)
3176 author_is_uploader = try_get(comment_renderer, lambda x: x['authorIsChannelOwner'], bool)
3177 is_favorited = 'creatorHeart' in (try_get(
3178 comment_renderer, lambda x: x['actionButtons']['commentActionButtonsRenderer'], dict) or {})
3182 'timestamp': timestamp,
3183 'time_text': time_text,
3184 'like_count': votes,
3185 'is_favorited': is_favorited,
3187 'author_id': author_id,
3188 'author_thumbnail': author_thumbnail,
3189 'author_is_uploader': author_is_uploader,
3190 'parent': parent or 'root'
3193 def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
3195 get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
3197 def extract_header(contents):
3198 _continuation = None
3199 for content in contents:
3200 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
3201 expected_comment_count = self._get_count(
3202 comments_header_renderer, 'countText', 'commentsCount')
3204 if expected_comment_count:
3205 tracker['est_total'] = expected_comment_count
3206 self.to_screen(f'Downloading ~{expected_comment_count} comments')
3207 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top') # 1 = new, 0 = top
3209 sort_menu_item = try_get(
3210 comments_header_renderer,
3211 lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
3212 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
3214 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
3215 if not _continuation:
3218 sort_text = str_or_none(sort_menu_item.get('title'))
3220 sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
3221 self.to_screen('Sorting comments by %s' % sort_text.lower())
3223 return _continuation
3225 def extract_thread(contents):
3227 tracker['current_page_thread'] = 0
3228 for content in contents:
3229 if not parent and tracker['total_parent_comments'] >= max_parents:
3231 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
3232 comment_renderer = get_first(
3233 (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
3234 expected_type=dict, default={})
3236 comment = self._extract_comment(comment_renderer, parent)
3240 tracker['running_total'] += 1
3241 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
3244 # Attempt to get the replies
3245 comment_replies_renderer = try_get(
3246 comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
3248 if comment_replies_renderer:
3249 tracker['current_page_thread'] += 1
3250 comment_entries_iter = self._comment_entries(
3251 comment_replies_renderer, ytcfg, video_id,
3252 parent=comment.get('id'), tracker=tracker)
3253 yield from itertools.islice(comment_entries_iter, min(
3254 max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments'])))
3256 # Keeps track of counts across recursive calls
3261 current_page_thread=0,
3262 total_parent_comments=0,
3263 total_reply_comments=0)
3266 # YouTube comments have a max depth of 2
3267 max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
3269 self._downloader.deprecated_feature('[youtube] max_comment_depth extractor argument is deprecated. '
3270 'Set max replies in the max-comments extractor argument instead')
3271 if max_depth == 1 and parent:
3274 max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
3275 lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
3277 continuation = self._extract_continuation(root_continuation_data)
3280 is_forced_continuation = False
3281 is_first_continuation = parent is None
3282 if is_first_continuation and not continuation:
3283 # Sometimes you can get comments by generating the continuation yourself,
3284 # even if YouTube initially reports them being disabled - e.g. stories comments.
3285 # Note: if the comment section is actually disabled, YouTube may return a response with
3286 # required check_get_keys missing. So we will disable that check initially in this case.
3287 continuation = self._build_api_continuation_query(self._generate_comment_continuation(video_id))
3288 is_forced_continuation = True
3290 for page_num in itertools.count(0):
3291 if not continuation:
3293 headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
3294 comment_prog_str = f"({tracker['running_total']}
/{tracker['est_total']}
)"
3296 if is_first_continuation:
3297 note_prefix = 'Downloading comment section API JSON'
3299 note_prefix = ' Downloading comment API JSON reply thread %d %s' % (
3300 tracker['current_page_thread'], comment_prog_str)
3302 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
3303 ' ' if parent else '', ' replies' if parent else '',
3304 page_num, comment_prog_str)
3306 response = self._extract_response(
3307 item_id=None, query=continuation,
3308 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
3309 check_get_keys='onResponseReceivedEndpoints' if not is_forced_continuation else None)
3310 except ExtractorError as e:
3311 # Ignore incomplete data error for replies if retries didn't work.
3312 # This is to allow any other parent comments and comment threads to be downloaded.
3313 # See: https://github.com/yt-dlp/yt-dlp/issues/4669
3314 if 'incomplete data' in str(e).lower() and parent and self.get_param('ignoreerrors') is True:
3315 self.report_warning(
3316 'Received incomplete data for a comment reply thread and retrying did not help. '
3317 'Ignoring to let other comments be downloaded.')
3320 is_forced_continuation = False
3321 continuation_contents = traverse_obj(
3322 response, 'onResponseReceivedEndpoints', expected_type=list, default=[])
3325 for continuation_section in continuation_contents:
3326 continuation_items = traverse_obj(
3327 continuation_section,
3328 (('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems'),
3329 get_all=False, expected_type=list) or []
3330 if is_first_continuation:
3331 continuation = extract_header(continuation_items)
3332 is_first_continuation = False
3337 for entry in extract_thread(continuation_items):
3341 continuation = self._extract_continuation({'contents': continuation_items})
3345 message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
3346 if message and not parent and tracker['running_total'] == 0:
3347 self.report_warning(f'Youtube said: {message}', video_id=video_id, only_once=True)
3348 raise self.CommentsDisabled
3351 def _generate_comment_continuation(video_id):
3353 Generates initial comment section continuation token from given video id
3355 token = f'\x12\r\x12\x0b{video_id}\x18\x062\'"\x11"\x0b{video_id}0\x00x\x020\x00B\x10comments-section'
3356 return base64.b64encode(token.encode()).decode()
3358 def _get_comments(self, ytcfg, video_id, contents, webpage):
3359 """Entry for comment extraction"""
3360 def _real_comment_extract(contents):
3362 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
3363 if item.get('sectionIdentifier') == 'comment-item-section'), None)
3364 yield from self._comment_entries(renderer, ytcfg, video_id)
3366 max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
3367 return itertools.islice(_real_comment_extract(contents), 0, max_comments)
3370 def _get_checkok_params():
3371 return {'contentCheckOk': True, 'racyCheckOk': True}
3374 def _generate_player_context(cls, sts=None):
3376 'html5Preference': 'HTML5_PREF_WANTS',
3379 context['signatureTimestamp'] = sts
3381 'playbackContext': {
3382 'contentPlaybackContext': context
3384 **cls._get_checkok_params()
3388 def _is_agegated(player_response):
3389 if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
3392 reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')), default=[])
3393 AGE_GATE_REASONS = (
3394 'confirm your age', 'age-restricted', 'inappropriate', # reason
3395 'age_verification_required', 'age_check_required', # status
3397 return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
3400 def _is_unplayable(player_response):
3401 return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
3403 _STORY_PLAYER_PARAMS = '8AEB'
3405 def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr, smuggled_data):
3407 session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
3408 syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
3409 sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
3410 headers = self.generate_api_headers(
3411 ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
3414 'videoId': video_id,
3416 if smuggled_data.get('is_story') or _split_innertube_client(client)[0] == 'android':
3417 yt_query['params'] = self._STORY_PLAYER_PARAMS
3419 yt_query.update(self._generate_player_context(sts))
3420 return self._extract_response(
3421 item_id=video_id, ep='player', query=yt_query,
3422 ytcfg=player_ytcfg, headers=headers, fatal=True,
3423 default_client=client,
3424 note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
3427 def _get_requested_clients(self, url, smuggled_data):
3428 requested_clients = []
3429 default = ['android', 'web']
3430 allowed_clients = sorted(
3431 (client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'),
3432 key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
3433 for client in self._configuration_arg('player_client'):
3434 if client in allowed_clients:
3435 requested_clients.append(client)
3436 elif client == 'default':
3437 requested_clients.extend(default)
3438 elif client == 'all':
3439 requested_clients.extend(allowed_clients)
3441 self.report_warning(f'Skipping unsupported client {client}')
3442 if not requested_clients:
3443 requested_clients = default
3445 if smuggled_data.get('is_music_url') or self.is_music_url(url):
3446 requested_clients.extend(
3447 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
3449 return orderedSet(requested_clients)
3451 def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg, smuggled_data):
3454 initial_pr = self._search_json(
3455 self._YT_INITIAL_PLAYER_RESPONSE_RE, webpage, 'initial player response', video_id, fatal=False)
3457 all_clients = set(clients)
3458 clients = clients[::-1]
3461 def append_client(*client_names):
3462 """ Append the first client name that exists but not already used """
3463 for client_name in client_names:
3464 actual_client = _split_innertube_client(client_name)[0]
3465 if actual_client in INNERTUBE_CLIENTS:
3466 if actual_client not in all_clients:
3467 clients.append(client_name)
3468 all_clients.add(actual_client)
3471 # Android player_response does not have microFormats which are needed for
3472 # extraction of some data. So we return the initial_pr with formats
3473 # stripped out even if not requested by the user
3474 # See: https://github.com/yt-dlp/yt-dlp/issues/501
3476 pr = dict(initial_pr)
3477 pr['streamingData'] = None
3481 tried_iframe_fallback = False
3484 client, base_client, variant = _split_innertube_client(clients.pop())
3485 player_ytcfg = master_ytcfg if client == 'web' else {}
3486 if 'configs' not in self._configuration_arg('player_skip') and client != 'web':
3487 player_ytcfg = self._download_ytcfg(client, video_id) or player_ytcfg
3489 player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
3490 require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
3491 if 'js' in self._configuration_arg('player_skip'):
3492 require_js_player = False
3495 if not player_url and not tried_iframe_fallback and require_js_player:
3496 player_url = self._download_player_url(video_id)
3497 tried_iframe_fallback = True
3500 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
3501 client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr, smuggled_data)
3502 except ExtractorError as e:
3504 self.report_warning(last_error)
3509 # YouTube may return a different video player response than expected.
3510 # See: https://github.com/TeamNewPipe/NewPipe/issues/8713
3511 pr_video_id = traverse_obj(pr, ('videoDetails', 'videoId'))
3512 if pr_video_id and pr_video_id != video_id:
3513 self.report_warning(
3514 f'Skipping player response from {client} client (got player response for video "{pr_video_id}
" instead of "{video_id}
")' + bug_reports_message())
3518 # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
3519 if variant == 'embedded' and self._is_unplayable(pr) and self.is_authenticated:
3520 append_client(f'{base_client}_creator')
3521 elif self._is_agegated(pr):
3522 if variant == 'tv_embedded':
3523 append_client(f'{base_client}_embedded')
3525 append_client(f'tv_embedded.{base_client}', f'{base_client}_embedded')
3530 self.report_warning(last_error)
3531 return prs, player_url
3533 def _needs_live_processing(self, live_status, duration):
3534 if (live_status == 'is_live' and self.get_param('live_from_start')
3535 or live_status == 'post_live' and (duration or 0) > 4 * 3600):
3538 def _extract_formats_and_subtitles(self, streaming_data, video_id, player_url, live_status, duration):
3539 itags, stream_ids = collections.defaultdict(set), []
3540 itag_qualities, res_qualities = {}, {0: None}
3542 # Normally tiny is the smallest video-only formats. But
3543 # audio-only formats with unknown quality may get tagged as tiny
3545 'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high', # Audio only formats
3546 'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
3548 streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...), default=[])
3550 for fmt in streaming_formats:
3551 if fmt.get('targetDurationSec'):
3554 itag = str_or_none(fmt.get('itag'))
3555 audio_track = fmt.get('audioTrack') or {}
3556 stream_id = '%s.%s' % (itag or '', audio_track.get('id', ''))
3557 if stream_id in stream_ids:
3560 quality = fmt.get('quality')
3561 height = int_or_none(fmt.get('height'))
3562 if quality == 'tiny' or not quality:
3563 quality = fmt.get('audioQuality', '').lower() or quality
3564 # The 3gp format (17) in android client has a quality of "small
",
3565 # but is actually worse than other formats
3570 itag_qualities[itag] = quality
3572 res_qualities[height] = quality
3573 # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
3574 # (adding `&sq=0` to the URL) and parsing emsg box to determine the
3575 # number of fragment that would subsequently requested with (`&sq=N`)
3576 if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
3579 fmt_url = fmt.get('url')
3581 sc = urllib.parse.parse_qs(fmt.get('signatureCipher'))
3582 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
3583 encrypted_sig = try_get(sc, lambda x: x['s'][0])
3584 if not all((sc, fmt_url, player_url, encrypted_sig)):
3587 fmt_url += '&%s=%s' % (
3588 traverse_obj(sc, ('sp', -1)) or 'signature',
3589 self._decrypt_signature(encrypted_sig, video_id, player_url)
3591 except ExtractorError as e:
3592 self.report_warning('Signature extraction failed: Some formats may be missing',
3593 video_id=video_id, only_once=True)
3594 self.write_debug(e, only_once=True)
3597 query = parse_qs(fmt_url)
3601 decrypt_nsig = self._cached(self._decrypt_nsig, 'nsig', query['n'][0])
3602 fmt_url = update_url_query(fmt_url, {
3603 'n': decrypt_nsig(query['n'][0], video_id, player_url)
3605 except ExtractorError as e:
3607 if isinstance(e, JSInterpreter.Exception):
3608 phantomjs_hint = (f' Install {self._downloader._format_err("PhantomJS", self._downloader.Styles.EMPHASIS)} '
3609 f'to workaround the issue. {PhantomJSwrapper.INSTALL_HINT}\n')
3611 self.report_warning(
3612 f'nsig extraction failed: You may experience throttling for some formats\n{phantomjs_hint}'
3613 f' n = {query["n"][0]} ; player = {player_url}', video_id=video_id, only_once=True)
3614 self.write_debug(e, only_once=True)
3616 self.report_warning(
3617 'Cannot decrypt nsig without player_url: You may experience throttling for some formats',
3618 video_id=video_id, only_once=True)
3621 tbr = float_or_none(fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3622 language_preference = (
3623 10 if audio_track.get('audioIsDefault') and 10
3624 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3626 # Some formats may have much smaller duration than others (possibly damaged during encoding)
3627 # E.g. 2-nOtRESiUc Ref: https://github.com/yt-dlp/yt-dlp/issues/2823
3628 # Make sure to avoid false positives with small duration differences.
3629 # E.g. __2ABJjxzNo, ySuUZEjARPY
3630 is_damaged = try_get(fmt, lambda x: float(x['approxDurationMs']) / duration < 500)
3632 self.report_warning(
3633 f'{video_id}: Some formats are possibly damaged. They will be deprioritized', only_once=True)
3635 'asr': int_or_none(fmt.get('audioSampleRate')),
3636 'filesize': int_or_none(fmt.get('contentLength')),
3638 'format_note': join_nonempty(
3639 '%s%s' % (audio_track.get('displayName') or '',
3640 ' (default)' if language_preference > 0 else ''),
3641 fmt.get('qualityLabel') or quality.replace('audio_quality_', ''),
3642 try_get(fmt, lambda x: x['projectionType'].replace('RECTANGULAR', '').lower()),
3643 try_get(fmt, lambda x: x['spatialAudioType'].replace('SPATIAL_AUDIO_TYPE_', '').lower()),
3644 throttled and 'THROTTLED', is_damaged and 'DAMAGED', delim=', '),
3645 # Format 22 is likely to be damaged. See https://github.com/yt-dlp/yt-dlp/issues/3372
3646 'source_preference': -10 if throttled else -5 if itag == '22' else -1,
3647 'fps': int_or_none(fmt.get('fps')) or None,
3648 'audio_channels': fmt.get('audioChannels'),
3650 'quality': q(quality),
3651 'has_drm': bool(fmt.get('drmFamilies')),
3654 'width': int_or_none(fmt.get('width')),
3655 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3656 'desc' if language_preference < -1 else ''),
3657 'language_preference': language_preference,
3658 # Strictly de-prioritize damaged and 3gp formats
3659 'preference': -10 if is_damaged else -2 if itag == '17' else None,
3661 mime_mobj = re.match(
3662 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^
"]+)")?
', fmt.get('mimeType
') or '')
3664 dct['ext
'] = mimetype2ext(mime_mobj.group(1))
3665 dct.update(parse_codecs(mime_mobj.group(2)))
3666 no_audio = dct.get('acodec
') == 'none
'
3667 no_video = dct.get('vcodec
') == 'none
'
3672 if no_audio or no_video:
3673 dct['downloader_options
'] = {
3674 # Youtube throttles chunks >~10M
3675 'http_chunk_size
': 10485760,
3678 dct['container
'] = dct['ext
'] + '_dash
'
3681 itags[itag].add(('https
', dct.get('language
')))
3682 stream_ids.append(stream_id)
3685 needs_live_processing = self._needs_live_processing(live_status, duration)
3686 skip_bad_formats = not self._configuration_arg('include_incomplete_formats
')
3688 skip_manifests = set(self._configuration_arg('skip
'))
3689 if (not self.get_param('youtube_include_hls_manifest
', True)
3690 or needs_live_processing == 'is_live
' # These will be filtered out by YoutubeDL anyway
3691 or needs_live_processing and skip_bad_formats):
3692 skip_manifests.add('hls
')
3694 if not self.get_param('youtube_include_dash_manifest
', True):
3695 skip_manifests.add('dash
')
3696 if self._configuration_arg('include_live_dash
'):
3697 self._downloader.deprecated_feature('[youtube
] include_live_dash extractor argument
is deprecated
. '
3698 'Use include_incomplete_formats extractor argument instead
')
3699 elif skip_bad_formats and live_status == 'is_live
' and needs_live_processing != 'is_live
':
3700 skip_manifests.add('dash
')
3702 def process_manifest_format(f, proto, itag):
3703 key = (proto, f.get('language
'))
3704 if key in itags[itag]:
3706 itags[itag].add(key)
3708 if any(p != proto for p, _ in itags[itag]):
3709 f['format_id
'] = f'{itag}
-{proto}
'
3711 f['format_id
'] = itag
3713 f['quality
'] = q(itag_qualities.get(try_get(f, lambda f: f['format_id
'].split('-')[0]), -1))
3714 if f['quality
'] == -1 and f.get('height
'):
3715 f['quality
'] = q(res_qualities[min(res_qualities, key=lambda x: abs(x - f['height
']))])
3719 for sd in streaming_data:
3720 hls_manifest_url = 'hls
' not in skip_manifests and sd.get('hlsManifestUrl
')
3721 if hls_manifest_url:
3722 fmts, subs = self._extract_m3u8_formats_and_subtitles(
3723 hls_manifest_url, video_id, 'mp4
', fatal=False, live=live_status == 'is_live
')
3724 subtitles = self._merge_subtitles(subs, subtitles)
3726 if process_manifest_format(f, 'hls
', self._search_regex(
3727 r'/itag
/(\d
+)', f['url
'], 'itag
', default=None)):
3730 dash_manifest_url = 'dash
' not in skip_manifests and sd.get('dashManifestUrl
')
3731 if dash_manifest_url:
3732 formats, subs = self._extract_mpd_formats_and_subtitles(dash_manifest_url, video_id, fatal=False)
3733 subtitles = self._merge_subtitles(subs, subtitles) # Prioritize HLS subs over DASH
3735 if process_manifest_format(f, 'dash
', f['format_id
']):
3736 f['filesize
'] = int_or_none(self._search_regex(
3737 r'/clen
/(\d
+)', f.get('fragment_base_url
') or f['url
'], 'file size
', default=None))
3738 if needs_live_processing:
3739 f['is_from_start
'] = True
3744 def _extract_storyboard(self, player_responses, duration):
3746 player_responses, ('storyboards
', 'playerStoryboardSpecRenderer
', 'spec
'), default='').split('|
')[::-1]
3747 base_url = url_or_none(urljoin('https
://i
.ytimg
.com
/', spec.pop() or None))
3751 for i, args in enumerate(spec):
3752 args = args.split('#')
3753 counts
= list(map(int_or_none
, args
[:5]))
3754 if len(args
) != 8 or not all(counts
):
3755 self
.report_warning(f
'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
3757 width
, height
, frame_count
, cols
, rows
= counts
3760 url
= base_url
.replace('$L', str(L
- i
)).replace('$N', N
) + f
'&sigh={sigh}'
3761 fragment_count
= frame_count
/ (cols
* rows
)
3762 fragment_duration
= duration
/ fragment_count
3764 'format_id': f
'sb{i}',
3765 'format_note': 'storyboard',
3767 'protocol': 'mhtml',
3773 'fps': frame_count
/ duration
,
3777 'url': url
.replace('$M', str(j
)),
3778 'duration': min(fragment_duration
, duration
- (j
* fragment_duration
)),
3779 } for j
in range(math
.ceil(fragment_count
))],
3782 def _download_player_responses(self
, url
, smuggled_data
, video_id
, webpage_url
):
3784 if 'webpage' not in self
._configuration
_arg
('player_skip'):
3785 query
= {'bpctr': '9999999999', 'has_verified': '1'}
3786 if smuggled_data
.get('is_story'):
3787 query
['pp'] = self
._STORY
_PLAYER
_PARAMS
3788 webpage
= self
._download
_webpage
(
3789 webpage_url
, video_id
, fatal
=False, query
=query
)
3791 master_ytcfg
= self
.extract_ytcfg(video_id
, webpage
) or self
._get
_default
_ytcfg
()
3793 player_responses
, player_url
= self
._extract
_player
_responses
(
3794 self
._get
_requested
_clients
(url
, smuggled_data
),
3795 video_id
, webpage
, master_ytcfg
, smuggled_data
)
3797 return webpage
, master_ytcfg
, player_responses
, player_url
3799 def _list_formats(self
, video_id
, microformats
, video_details
, player_responses
, player_url
, duration
=None):
3800 live_broadcast_details
= traverse_obj(microformats
, (..., 'liveBroadcastDetails'))
3801 is_live
= get_first(video_details
, 'isLive')
3803 is_live
= get_first(live_broadcast_details
, 'isLiveNow')
3804 live_content
= get_first(video_details
, 'isLiveContent')
3805 is_upcoming
= get_first(video_details
, 'isUpcoming')
3806 post_live
= get_first(video_details
, 'isPostLiveDvr')
3807 live_status
= ('post_live' if post_live
3808 else 'is_live' if is_live
3809 else 'is_upcoming' if is_upcoming
3810 else 'was_live' if live_content
3811 else 'not_live' if False in (is_live
, live_content
)
3813 streaming_data
= traverse_obj(player_responses
, (..., 'streamingData'), default
=[])
3814 *formats
, subtitles
= self
._extract
_formats
_and
_subtitles
(streaming_data
, video_id
, player_url
, live_status
, duration
)
3816 return live_broadcast_details
, live_status
, streaming_data
, formats
, subtitles
3818 def _real_extract(self
, url
):
3819 url
, smuggled_data
= unsmuggle_url(url
, {})
3820 video_id
= self
._match
_id
(url
)
3822 base_url
= self
.http_scheme() + '//www.youtube.com/'
3823 webpage_url
= base_url
+ 'watch?v=' + video_id
3825 webpage
, master_ytcfg
, player_responses
, player_url
= self
._download
_player
_responses
(url
, smuggled_data
, video_id
, webpage_url
)
3827 playability_statuses
= traverse_obj(
3828 player_responses
, (..., 'playabilityStatus'), expected_type
=dict, default
=[])
3830 trailer_video_id
= get_first(
3831 playability_statuses
,
3832 ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
3834 if trailer_video_id
:
3835 return self
.url_result(
3836 trailer_video_id
, self
.ie_key(), trailer_video_id
)
3838 search_meta
= ((lambda x
: self
._html
_search
_meta
(x
, webpage
, default
=None))
3839 if webpage
else (lambda x
: None))
3841 video_details
= traverse_obj(
3842 player_responses
, (..., 'videoDetails'), expected_type
=dict, default
=[])
3843 microformats
= traverse_obj(
3844 player_responses
, (..., 'microformat', 'playerMicroformatRenderer'),
3845 expected_type
=dict, default
=[])
3847 translated_title
= self
._get
_text
(microformats
, (..., 'title'))
3848 video_title
= (self
._preferred
_lang
and translated_title
3849 or get_first(video_details
, 'title') # primary
3851 or search_meta(['og:title', 'twitter:title', 'title']))
3852 translated_description
= self
._get
_text
(microformats
, (..., 'description'))
3853 original_description
= get_first(video_details
, 'shortDescription')
3854 video_description
= (
3855 self
._preferred
_lang
and translated_description
3856 # If original description is blank, it will be an empty string.
3857 # Do not prefer translated description in this case.
3858 or original_description
if original_description
is not None else translated_description
)
3860 multifeed_metadata_list
= get_first(
3862 ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
3864 if multifeed_metadata_list
and not smuggled_data
.get('force_singlefeed'):
3865 if self
.get_param('noplaylist'):
3866 self
.to_screen('Downloading just video %s because of --no-playlist' % video_id
)
3870 for feed
in multifeed_metadata_list
.split(','):
3871 # Unquote should take place before split on comma (,) since textual
3872 # fields may contain comma as well (see
3873 # https://github.com/ytdl-org/youtube-dl/issues/8536)
3874 feed_data
= urllib
.parse
.parse_qs(
3875 urllib
.parse
.unquote_plus(feed
))
3877 def feed_entry(name
):
3879 feed_data
, lambda x
: x
[name
][0], str)
3881 feed_id
= feed_entry('id')
3884 feed_title
= feed_entry('title')
3887 title
+= ' (%s)' % feed_title
3889 '_type': 'url_transparent',
3890 'ie_key': 'Youtube',
3892 '%swatch?v=%s' % (base_url
, feed_data
['id'][0]),
3893 {'force_singlefeed': True}
),
3896 feed_ids
.append(feed_id
)
3898 'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
3899 % (', '.join(feed_ids
), video_id
))
3900 return self
.playlist_result(
3901 entries
, video_id
, video_title
, video_description
)
3903 duration
= (int_or_none(get_first(video_details
, 'lengthSeconds'))
3904 or int_or_none(get_first(microformats
, 'lengthSeconds'))
3905 or parse_duration(search_meta('duration')) or None)
3907 live_broadcast_details
, live_status
, streaming_data
, formats
, automatic_captions
= \
3908 self
._list
_formats
(video_id
, microformats
, video_details
, player_responses
, player_url
, duration
)
3909 if live_status
== 'post_live':
3910 self
.write_debug(f
'{video_id}: Video is in Post-Live Manifestless mode')
3913 if not self
.get_param('allow_unplayable_formats') and traverse_obj(streaming_data
, (..., 'licenseInfos')):
3914 self
.report_drm(video_id
)
3916 playability_statuses
,
3917 ('errorScreen', 'playerErrorMessageRenderer'), expected_type
=dict) or {}
3918 reason
= self
._get
_text
(pemr
, 'reason') or get_first(playability_statuses
, 'reason')
3919 subreason
= clean_html(self
._get
_text
(pemr
, 'subreason') or '')
3921 if subreason
== 'The uploader has not made this video available in your country.':
3922 countries
= get_first(microformats
, 'availableCountries')
3924 regions_allowed
= search_meta('regionsAllowed')
3925 countries
= regions_allowed
.split(',') if regions_allowed
else None
3926 self
.raise_geo_restricted(subreason
, countries
, metadata_available
=True)
3927 reason
+= f
'. {subreason}'
3929 self
.raise_no_formats(reason
, expected
=True)
3931 keywords
= get_first(video_details
, 'keywords', expected_type
=list) or []
3932 if not keywords
and webpage
:
3934 unescapeHTML(m
.group('content'))
3935 for m
in re
.finditer(self
._meta
_regex
('og:video:tag'), webpage
)]
3936 for keyword
in keywords
:
3937 if keyword
.startswith('yt:stretch='):
3938 mobj
= re
.search(r
'(\d+)\s*:\s*(\d+)', keyword
)
3940 # NB: float is intentional for forcing float division
3941 w
, h
= (float(v
) for v
in mobj
.groups())
3945 if f
.get('vcodec') != 'none':
3946 f
['stretched_ratio'] = ratio
3948 thumbnails
= self
._extract
_thumbnails
((video_details
, microformats
), (..., ..., 'thumbnail'))
3949 thumbnail_url
= search_meta(['og:image', 'twitter:image'])
3952 'url': thumbnail_url
,
3954 original_thumbnails
= thumbnails
.copy()
3956 # The best resolution thumbnails sometimes does not appear in the webpage
3957 # See: https://github.com/yt-dlp/yt-dlp/issues/340
3958 # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
3960 # While the *1,*2,*3 thumbnails are just below their corresponding "*default" variants
3961 # in resolution, these are not the custom thumbnail. So de-prioritize them
3962 'maxresdefault', 'hq720', 'sddefault', 'hqdefault', '0', 'mqdefault', 'default',
3963 'sd1', 'sd2', 'sd3', 'hq1', 'hq2', 'hq3', 'mq1', 'mq2', 'mq3', '1', '2', '3'
3965 n_thumbnail_names
= len(thumbnail_names
)
3967 'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
3968 video_id
=video_id
, name
=name
, ext
=ext
,
3969 webp
='_webp' if ext
== 'webp' else '', live
='_live' if live_status
== 'is_live' else ''),
3970 } for name
in thumbnail_names
for ext
in ('webp', 'jpg'))
3971 for thumb
in thumbnails
:
3972 i
= next((i
for i
, t
in enumerate(thumbnail_names
) if f
'/{video_id}/{t}' in thumb
['url']), n_thumbnail_names
)
3973 thumb
['preference'] = (0 if '.webp' in thumb
['url'] else -1) - (2 * i
)
3974 self
._remove
_duplicate
_formats
(thumbnails
)
3975 self
._downloader
._sort
_thumbnails
(original_thumbnails
)
3977 category
= get_first(microformats
, 'category') or search_meta('genre')
3978 channel_id
= str_or_none(
3979 get_first(video_details
, 'channelId')
3980 or get_first(microformats
, 'externalChannelId')
3981 or search_meta('channelId'))
3982 owner_profile_url
= get_first(microformats
, 'ownerProfileUrl')
3984 live_start_time
= parse_iso8601(get_first(live_broadcast_details
, 'startTimestamp'))
3985 live_end_time
= parse_iso8601(get_first(live_broadcast_details
, 'endTimestamp'))
3986 if not duration
and live_end_time
and live_start_time
:
3987 duration
= live_end_time
- live_start_time
3989 needs_live_processing
= self
._needs
_live
_processing
(live_status
, duration
)
3991 def is_bad_format(fmt
):
3992 if needs_live_processing
and not fmt
.get('is_from_start'):
3994 elif (live_status
== 'is_live' and needs_live_processing
!= 'is_live'
3995 and fmt
.get('protocol') == 'http_dash_segments'):
3998 for fmt
in filter(is_bad_format
, formats
):
3999 fmt
['preference'] = (fmt
.get('preference') or -1) - 10
4000 fmt
['format_note'] = join_nonempty(fmt
.get('format_note'), '(Last 4 hours)', delim
=' ')
4002 if needs_live_processing
:
4003 self
._prepare
_live
_from
_start
_formats
(
4004 formats
, video_id
, live_start_time
, url
, webpage_url
, smuggled_data
, live_status
== 'is_live')
4006 formats
.extend(self
._extract
_storyboard
(player_responses
, duration
))
4010 'title': video_title
,
4012 'thumbnails': thumbnails
,
4013 # The best thumbnail that we are sure exists. Prevents unnecessary
4014 # URL checking if user don't care about getting the best possible thumbnail
4015 'thumbnail': traverse_obj(original_thumbnails
, (-1, 'url')),
4016 'description': video_description
,
4017 'uploader': get_first(video_details
, 'author'),
4018 'uploader_id': self
._search
_regex
(r
'/(?:channel|user)/([^/?&#]+)', owner_profile_url
, 'uploader id') if owner_profile_url
else None,
4019 'uploader_url': owner_profile_url
,
4020 'channel_id': channel_id
,
4021 'channel_url': format_field(channel_id
, None, 'https://www.youtube.com/channel/%s'),
4022 'duration': duration
,
4023 'view_count': int_or_none(
4024 get_first((video_details
, microformats
), (..., 'viewCount'))
4025 or search_meta('interactionCount')),
4026 'average_rating': float_or_none(get_first(video_details
, 'averageRating')),
4027 'age_limit': 18 if (
4028 get_first(microformats
, 'isFamilySafe') is False
4029 or search_meta('isFamilyFriendly') == 'false'
4030 or search_meta('og:restrictions:age') == '18+') else 0,
4031 'webpage_url': webpage_url
,
4032 'categories': [category
] if category
else None,
4034 'playable_in_embed': get_first(playability_statuses
, 'playableInEmbed'),
4035 'live_status': live_status
,
4036 'release_timestamp': live_start_time
,
4037 '_format_sort_fields': ( # source_preference is lower for throttled/potentially damaged formats
4038 'quality', 'res', 'fps', 'hdr:12', 'source', 'vcodec:vp9.2', 'channels', 'acodec', 'lang', 'proto')
4042 pctr
= traverse_obj(player_responses
, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type
=dict)
4044 def get_lang_code(track
):
4045 return (remove_start(track
.get('vssId') or '', '.').replace('.', '-')
4046 or track
.get('languageCode'))
4048 # Converted into dicts to remove duplicates
4050 get_lang_code(sub
): sub
4051 for sub
in traverse_obj(pctr
, (..., 'captionTracks', ...), default
=[])}
4052 translation_languages
= {
4053 lang
.get('languageCode'): self
._get
_text
(lang
.get('languageName'), max_runs
=1)
4054 for lang
in traverse_obj(pctr
, (..., 'translationLanguages', ...), default
=[])}
4056 def process_language(container
, base_url
, lang_code
, sub_name
, query
):
4057 lang_subs
= container
.setdefault(lang_code
, [])
4058 for fmt
in self
._SUBTITLE
_FORMATS
:
4064 'url': urljoin('https://www.youtube.com', update_url_query(base_url
, query
)),
4068 # NB: Constructing the full subtitle dictionary is slow
4069 get_translated_subs
= 'translated_subs' not in self
._configuration
_arg
('skip') and (
4070 self
.get_param('writeautomaticsub', False) or self
.get_param('listsubtitles'))
4071 for lang_code
, caption_track
in captions
.items():
4072 base_url
= caption_track
.get('baseUrl')
4073 orig_lang
= parse_qs(base_url
).get('lang', [None])[-1]
4076 lang_name
= self
._get
_text
(caption_track
, 'name', max_runs
=1)
4077 if caption_track
.get('kind') != 'asr':
4081 subtitles
, base_url
, lang_code
, lang_name
, {})
4082 if not caption_track
.get('isTranslatable'):
4084 for trans_code
, trans_name
in translation_languages
.items():
4087 orig_trans_code
= trans_code
4088 if caption_track
.get('kind') != 'asr' and trans_code
!= 'und':
4089 if not get_translated_subs
:
4091 trans_code
+= f
'-{lang_code}'
4092 trans_name
+= format_field(lang_name
, None, ' from %s')
4093 # Add an "-orig" label to the original language so that it can be distinguished.
4094 # The subs are returned without "-orig" as well for compatibility
4095 if lang_code
== f
'a-{orig_trans_code}':
4097 automatic_captions
, base_url
, f
'{trans_code}-orig', f
'{trans_name} (Original)', {})
4098 # Setting tlang=lang returns damaged subtitles.
4099 process_language(automatic_captions
, base_url
, trans_code
, trans_name
,
4100 {} if orig_lang == orig_trans_code else {'tlang': trans_code}
)
4102 info
['automatic_captions'] = automatic_captions
4103 info
['subtitles'] = subtitles
4105 parsed_url
= urllib
.parse
.urlparse(url
)
4106 for component
in [parsed_url
.fragment
, parsed_url
.query
]:
4107 query
= urllib
.parse
.parse_qs(component
)
4108 for k
, v
in query
.items():
4109 for d_k
, s_ks
in [('start', ('start', 't')), ('end', ('end',))]:
4111 if d_k
not in info
and k
in s_ks
:
4112 info
[d_k
] = parse_duration(query
[k
][0])
4114 # Youtube Music Auto-generated description
4115 if video_description
:
4118 (?P<track>[^·\n]+)·(?P<artist>[^\n]+)\n+
4120 (?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?
4121 (?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?
4122 (.+?\nArtist\s*:\s*(?P<clean_artist>[^\n]+))?
4123 .+\nAuto-generated\ by\ YouTube\.\s*$
4124 ''', video_description
)
4126 release_year
= mobj
.group('release_year')
4127 release_date
= mobj
.group('release_date')
4129 release_date
= release_date
.replace('-', '')
4130 if not release_year
:
4131 release_year
= release_date
[:4]
4133 'album': mobj
.group('album'.strip()),
4134 'artist': mobj
.group('clean_artist') or ', '.join(a
.strip() for a
in mobj
.group('artist').split('·')),
4135 'track': mobj
.group('track').strip(),
4136 'release_date': release_date
,
4137 'release_year': int_or_none(release_year
),
4142 initial_data
= self
.extract_yt_initial_data(video_id
, webpage
, fatal
=False)
4143 if not initial_data
:
4144 query
= {'videoId': video_id}
4145 query
.update(self
._get
_checkok
_params
())
4146 initial_data
= self
._extract
_response
(
4147 item_id
=video_id
, ep
='next', fatal
=False,
4148 ytcfg
=master_ytcfg
, query
=query
,
4149 headers
=self
.generate_api_headers(ytcfg
=master_ytcfg
),
4150 note
='Downloading initial data API JSON')
4152 info
['comment_count'] = traverse_obj(initial_data
, (
4153 'contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents', ..., 'itemSectionRenderer',
4154 'contents', ..., 'commentsEntryPointHeaderRenderer', 'commentCount', 'simpleText'
4156 'engagementPanels', lambda _
, v
: v
['engagementPanelSectionListRenderer']['panelIdentifier'] == 'comment-item-section',
4157 'engagementPanelSectionListRenderer', 'header', 'engagementPanelTitleHeaderRenderer', 'contextualInfo', 'runs', ..., 'text'
4158 ), expected_type
=int_or_none
, get_all
=False)
4160 try: # This will error if there is no livechat
4161 initial_data
['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
4162 except (KeyError, IndexError, TypeError):
4165 info
.setdefault('subtitles', {})['live_chat'] = [{
4166 # url is needed to set cookies
4167 'url': f
'https://www.youtube.com/watch?v={video_id}&bpctr=9999999999&has_verified=1',
4168 'video_id': video_id
,
4170 'protocol': ('youtube_live_chat' if live_status
in ('is_live', 'is_upcoming')
4171 else 'youtube_live_chat_replay'),
4175 info
['chapters'] = (
4176 self
._extract
_chapters
_from
_json
(initial_data
, duration
)
4177 or self
._extract
_chapters
_from
_engagement
_panel
(initial_data
, duration
)
4178 or self
._extract
_chapters
_from
_description
(video_description
, duration
)
4181 contents
= traverse_obj(
4182 initial_data
, ('contents', 'twoColumnWatchNextResults', 'results', 'results', 'contents'),
4183 expected_type
=list, default
=[])
4185 vpir
= get_first(contents
, 'videoPrimaryInfoRenderer')
4187 stl
= vpir
.get('superTitleLink')
4189 stl
= self
._get
_text
(stl
)
4192 lambda x
: x
['superTitleIcon']['iconType']) == 'LOCATION_PIN':
4193 info
['location'] = stl
4195 mobj
= re
.search(r
'(.+?)\s*S(\d+)\s*•?\s*E(\d+)', stl
)
4198 'series': mobj
.group(1),
4199 'season_number': int(mobj
.group(2)),
4200 'episode_number': int(mobj
.group(3)),
4202 for tlb
in (try_get(
4204 lambda x
: x
['videoActions']['menuRenderer']['topLevelButtons'],
4208 tlb
, 'toggleButtonRenderer',
4209 ('segmentedLikeDislikeButtonRenderer', ..., 'toggleButtonRenderer'),
4212 for getter
, regex
in [(
4213 lambda x
: x
['defaultText']['accessibility']['accessibilityData'],
4214 r
'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
4215 lambda x
: x
['accessibility'],
4216 lambda x
: x
['accessibilityData']['accessibilityData'],
4217 ], r
'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
4218 label
= (try_get(tbr
, getter
, dict) or {}).get('label')
4220 mobj
= re
.match(regex
, label
)
4222 info
[mobj
.group('type') + '_count'] = str_to_int(mobj
.group('count'))
4224 sbr_tooltip
= try_get(
4225 vpir
, lambda x
: x
['sentimentBar']['sentimentBarRenderer']['tooltip'])
4227 like_count
, dislike_count
= sbr_tooltip
.split(' / ')
4229 'like_count': str_to_int(like_count
),
4230 'dislike_count': str_to_int(dislike_count
),
4232 vcr
= traverse_obj(vpir
, ('viewCount', 'videoViewCountRenderer'))
4234 vc
= self
._get
_count
(vcr
, 'viewCount')
4235 # Upcoming premieres with waiting count are treated as live here
4236 if vcr
.get('isLive'):
4237 info
['concurrent_view_count'] = vc
4238 elif info
.get('view_count') is None:
4239 info
['view_count'] = vc
4241 vsir
= get_first(contents
, 'videoSecondaryInfoRenderer')
4243 vor
= traverse_obj(vsir
, ('owner', 'videoOwnerRenderer'))
4245 'channel': self
._get
_text
(vor
, 'title'),
4246 'channel_follower_count': self
._get
_count
(vor
, 'subscriberCountText')})
4250 lambda x
: x
['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
4252 multiple_songs
= False
4254 if try_get(row
, lambda x
: x
['metadataRowRenderer']['hasDividerLine']) is True:
4255 multiple_songs
= True
4258 mrr
= row
.get('metadataRowRenderer') or {}
4259 mrr_title
= mrr
.get('title')
4262 mrr_title
= self
._get
_text
(mrr
, 'title')
4263 mrr_contents_text
= self
._get
_text
(mrr
, ('contents', 0))
4264 if mrr_title
== 'License':
4265 info
['license'] = mrr_contents_text
4266 elif not multiple_songs
:
4267 if mrr_title
== 'Album':
4268 info
['album'] = mrr_contents_text
4269 elif mrr_title
== 'Artist':
4270 info
['artist'] = mrr_contents_text
4271 elif mrr_title
== 'Song':
4272 info
['track'] = mrr_contents_text
4275 'channel': 'uploader',
4276 'channel_id': 'uploader_id',
4277 'channel_url': 'uploader_url',
4280 # The upload date for scheduled, live and past live streams / premieres in microformats
4281 # may be different from the stream date. Although not in UTC, we will prefer it in this case.
4282 # See: https://github.com/yt-dlp/yt-dlp/pull/2223#issuecomment-1008485139
4284 unified_strdate(get_first(microformats
, 'uploadDate'))
4285 or unified_strdate(search_meta('uploadDate')))
4286 if not upload_date
or (
4287 live_status
in ('not_live', None)
4288 and 'no-youtube-prefer-utc-upload-date' not in self
.get_param('compat_opts', [])
4290 upload_date
= strftime_or_none(
4291 self
._parse
_time
_text
(self
._get
_text
(vpir
, 'dateText')), '%Y%m%d') or upload_date
4292 info
['upload_date'] = upload_date
4294 for to
, frm
in fallbacks
.items():
4295 if not info
.get(to
):
4296 info
[to
] = info
.get(frm
)
4298 for s_k
, d_k
in [('artist', 'creator'), ('track', 'alt_title')]:
4303 badges
= self
._extract
_badges
(traverse_obj(contents
, (..., 'videoPrimaryInfoRenderer'), get_all
=False))
4305 is_private
= (self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4306 or get_first(video_details
, 'isPrivate', expected_type
=bool))
4308 info
['availability'] = (
4309 'public' if self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4310 else self
._availability
(
4311 is_private
=is_private
,
4313 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
)
4314 or False if initial_data
and is_private
is not None else None),
4315 needs_subscription
=(
4316 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
)
4317 or False if initial_data
and is_private
is not None else None),
4318 needs_auth
=info
['age_limit'] >= 18,
4319 is_unlisted
=None if is_private
is None else (
4320 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4321 or get_first(microformats
, 'isUnlisted', expected_type
=bool))))
4323 info
['__post_extractor'] = self
.extract_comments(master_ytcfg
, video_id
, contents
, webpage
)
4325 self
.mark_watched(video_id
, player_responses
)
4330 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor
):
4332 def passthrough_smuggled_data(func
):
4333 def _smuggle(info
, smuggled_data
):
4334 if info
.get('_type') not in ('url', 'url_transparent'):
4336 if smuggled_data
.get('is_music_url'):
4337 parsed_url
= urllib
.parse
.urlparse(info
['url'])
4338 if parsed_url
.netloc
in ('www.youtube.com', 'music.youtube.com'):
4339 smuggled_data
.pop('is_music_url')
4340 info
['url'] = urllib
.parse
.urlunparse(parsed_url
._replace
(netloc
='music.youtube.com'))
4342 info
['url'] = smuggle_url(info
['url'], smuggled_data
)
4345 @functools.wraps(func
)
4346 def wrapper(self
, url
):
4347 url
, smuggled_data
= unsmuggle_url(url
, {})
4348 if self
.is_music_url(url
):
4349 smuggled_data
['is_music_url'] = True
4350 info_dict
= func(self
, url
, smuggled_data
)
4352 _smuggle(info_dict
, smuggled_data
)
4353 if info_dict
.get('entries'):
4354 info_dict
['entries'] = (_smuggle(i
, smuggled_data
.copy()) for i
in info_dict
['entries'])
4358 def _extract_channel_id(self
, webpage
):
4359 channel_id
= self
._html
_search
_meta
(
4360 'channelId', webpage
, 'channel id', default
=None)
4363 channel_url
= self
._html
_search
_meta
(
4364 ('og:url', 'al:ios:url', 'al:android:url', 'al:web:url',
4365 'twitter:url', 'twitter:app:url:iphone', 'twitter:app:url:ipad',
4366 'twitter:app:url:googleplay'), webpage
, 'channel url')
4367 return self
._search
_regex
(
4368 r
'https?://(?:www\.)?youtube\.com/channel/([^/?#&])+',
4369 channel_url
, 'channel id')
4372 def _extract_basic_item_renderer(item
):
4373 # Modified from _extract_grid_item_renderer
4374 known_basic_renderers
= (
4375 'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer', 'reelItemRenderer'
4377 for key
, renderer
in item
.items():
4378 if not isinstance(renderer
, dict):
4380 elif key
in known_basic_renderers
:
4382 elif key
.startswith('grid') and key
.endswith('Renderer'):
4385 def _grid_entries(self
, grid_renderer
):
4386 for item
in grid_renderer
['items']:
4387 if not isinstance(item
, dict):
4389 renderer
= self
._extract
_basic
_item
_renderer
(item
)
4390 if not isinstance(renderer
, dict):
4392 title
= self
._get
_text
(renderer
, 'title')
4395 playlist_id
= renderer
.get('playlistId')
4397 yield self
.url_result(
4398 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4399 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4403 video_id
= renderer
.get('videoId')
4405 yield self
._extract
_video
(renderer
)
4408 channel_id
= renderer
.get('channelId')
4410 yield self
.url_result(
4411 'https://www.youtube.com/channel/%s' % channel_id
,
4412 ie
=YoutubeTabIE
.ie_key(), video_title
=title
)
4414 # generic endpoint URL support
4415 ep_url
= urljoin('https://www.youtube.com/', try_get(
4416 renderer
, lambda x
: x
['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
4419 for ie
in (YoutubeTabIE
, YoutubePlaylistIE
, YoutubeIE
):
4420 if ie
.suitable(ep_url
):
4421 yield self
.url_result(
4422 ep_url
, ie
=ie
.ie_key(), video_id
=ie
._match
_id
(ep_url
), video_title
=title
)
4425 def _music_reponsive_list_entry(self
, renderer
):
4426 video_id
= traverse_obj(renderer
, ('playlistItemData', 'videoId'))
4428 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}',
4429 ie
=YoutubeIE
.ie_key(), video_id
=video_id
)
4430 playlist_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
4432 video_id
= traverse_obj(renderer
, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
4434 return self
.url_result(f
'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
4435 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4436 return self
.url_result(f
'https://music.youtube.com/playlist?list={playlist_id}',
4437 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4438 browse_id
= traverse_obj(renderer
, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
4440 return self
.url_result(f
'https://music.youtube.com/browse/{browse_id}',
4441 ie
=YoutubeTabIE
.ie_key(), video_id
=browse_id
)
4443 def _shelf_entries_from_content(self
, shelf_renderer
):
4444 content
= shelf_renderer
.get('content')
4445 if not isinstance(content
, dict):
4447 renderer
= content
.get('gridRenderer') or content
.get('expandedShelfContentsRenderer')
4449 # TODO: add support for nested playlists so each shelf is processed
4450 # as separate playlist
4451 # TODO: this includes only first N items
4452 yield from self
._grid
_entries
(renderer
)
4453 renderer
= content
.get('horizontalListRenderer')
4458 def _shelf_entries(self
, shelf_renderer
, skip_channels
=False):
4460 shelf_renderer
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4462 shelf_url
= urljoin('https://www.youtube.com', ep
)
4464 # Skipping links to another channels, note that checking for
4465 # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
4467 if skip_channels
and '/channels?' in shelf_url
:
4469 title
= self
._get
_text
(shelf_renderer
, 'title')
4470 yield self
.url_result(shelf_url
, video_title
=title
)
4471 # Shelf may not contain shelf URL, fallback to extraction from content
4472 yield from self
._shelf
_entries
_from
_content
(shelf_renderer
)
4474 def _playlist_entries(self
, video_list_renderer
):
4475 for content
in video_list_renderer
['contents']:
4476 if not isinstance(content
, dict):
4478 renderer
= content
.get('playlistVideoRenderer') or content
.get('playlistPanelVideoRenderer')
4479 if not isinstance(renderer
, dict):
4481 video_id
= renderer
.get('videoId')
4484 yield self
._extract
_video
(renderer
)
4486 def _rich_entries(self
, rich_grid_renderer
):
4487 renderer
= traverse_obj(
4488 rich_grid_renderer
, ('content', ('videoRenderer', 'reelItemRenderer')), get_all
=False) or {}
4489 video_id
= renderer
.get('videoId')
4492 yield self
._extract
_video
(renderer
)
4494 def _video_entry(self
, video_renderer
):
4495 video_id
= video_renderer
.get('videoId')
4497 return self
._extract
_video
(video_renderer
)
4499 def _hashtag_tile_entry(self
, hashtag_tile_renderer
):
4500 url
= urljoin('https://youtube.com', traverse_obj(
4501 hashtag_tile_renderer
, ('onTapCommand', 'commandMetadata', 'webCommandMetadata', 'url')))
4503 return self
.url_result(
4504 url
, ie
=YoutubeTabIE
.ie_key(), title
=self
._get
_text
(hashtag_tile_renderer
, 'hashtag'))
4506 def _post_thread_entries(self
, post_thread_renderer
):
4507 post_renderer
= try_get(
4508 post_thread_renderer
, lambda x
: x
['post']['backstagePostRenderer'], dict)
4509 if not post_renderer
:
4512 video_renderer
= try_get(
4513 post_renderer
, lambda x
: x
['backstageAttachment']['videoRenderer'], dict) or {}
4514 video_id
= video_renderer
.get('videoId')
4516 entry
= self
._extract
_video
(video_renderer
)
4519 # playlist attachment
4520 playlist_id
= try_get(
4521 post_renderer
, lambda x
: x
['backstageAttachment']['playlistRenderer']['playlistId'], str)
4523 yield self
.url_result(
4524 'https://www.youtube.com/playlist?list=%s' % playlist_id
,
4525 ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
4526 # inline video links
4527 runs
= try_get(post_renderer
, lambda x
: x
['contentText']['runs'], list) or []
4529 if not isinstance(run
, dict):
4532 run
, lambda x
: x
['navigationEndpoint']['urlEndpoint']['url'], str)
4535 if not YoutubeIE
.suitable(ep_url
):
4537 ep_video_id
= YoutubeIE
._match
_id
(ep_url
)
4538 if video_id
== ep_video_id
:
4540 yield self
.url_result(ep_url
, ie
=YoutubeIE
.ie_key(), video_id
=ep_video_id
)
4542 def _post_thread_continuation_entries(self
, post_thread_continuation
):
4543 contents
= post_thread_continuation
.get('contents')
4544 if not isinstance(contents
, list):
4546 for content
in contents
:
4547 renderer
= content
.get('backstagePostThreadRenderer')
4548 if isinstance(renderer
, dict):
4549 yield from self
._post
_thread
_entries
(renderer
)
4551 renderer
= content
.get('videoRenderer')
4552 if isinstance(renderer
, dict):
4553 yield self
._video
_entry
(renderer
)
4556 def _rich_grid_entries(self, contents):
4557 for content in contents:
4558 video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
4560 entry = self._video_entry(video_renderer)
4565 def _report_history_entries(self
, renderer
):
4566 for url
in traverse_obj(renderer
, (
4567 'rows', ..., 'reportHistoryTableRowRenderer', 'cells', ...,
4568 'reportHistoryTableCellRenderer', 'cell', 'reportHistoryTableTextCellRenderer', 'text', 'runs', ...,
4569 'navigationEndpoint', 'commandMetadata', 'webCommandMetadata', 'url')):
4570 yield self
.url_result(urljoin('https://www.youtube.com', url
), YoutubeIE
)
4572 def _extract_entries(self
, parent_renderer
, continuation_list
):
4573 # continuation_list is modified in-place with continuation_list = [continuation_token]
4574 continuation_list
[:] = [None]
4575 contents
= try_get(parent_renderer
, lambda x
: x
['contents'], list) or []
4576 for content
in contents
:
4577 if not isinstance(content
, dict):
4579 is_renderer
= traverse_obj(
4580 content
, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
4583 if content
.get('richItemRenderer'):
4584 for entry
in self
._rich
_entries
(content
['richItemRenderer']):
4586 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4587 elif content
.get('reportHistorySectionRenderer'): # https://www.youtube.com/reporthistory
4588 table
= traverse_obj(content
, ('reportHistorySectionRenderer', 'table', 'tableRenderer'))
4589 yield from self
._report
_history
_entries
(table
)
4590 continuation_list
[0] = self
._extract
_continuation
(table
)
4593 isr_contents
= try_get(is_renderer
, lambda x
: x
['contents'], list) or []
4594 for isr_content
in isr_contents
:
4595 if not isinstance(isr_content
, dict):
4599 'playlistVideoListRenderer': self
._playlist
_entries
,
4600 'gridRenderer': self
._grid
_entries
,
4601 'reelShelfRenderer': self
._grid
_entries
,
4602 'shelfRenderer': self
._shelf
_entries
,
4603 'musicResponsiveListItemRenderer': lambda x
: [self
._music
_reponsive
_list
_entry
(x
)],
4604 'backstagePostThreadRenderer': self
._post
_thread
_entries
,
4605 'videoRenderer': lambda x
: [self
._video
_entry
(x
)],
4606 'playlistRenderer': lambda x
: self
._grid
_entries
({'items': [{'playlistRenderer': x}
]}),
4607 'channelRenderer': lambda x
: self
._grid
_entries
({'items': [{'channelRenderer': x}
]}),
4608 'hashtagTileRenderer': lambda x
: [self
._hashtag
_tile
_entry
(x
)]
4610 for key
, renderer
in isr_content
.items():
4611 if key
not in known_renderers
:
4613 for entry
in known_renderers
[key
](renderer
):
4616 continuation_list
[0] = self
._extract
_continuation
(renderer
)
4619 if not continuation_list
[0]:
4620 continuation_list
[0] = self
._extract
_continuation
(is_renderer
)
4622 if not continuation_list
[0]:
4623 continuation_list
[0] = self
._extract
_continuation
(parent_renderer
)
4625 def _entries(self
, tab
, item_id
, ytcfg
, account_syncid
, visitor_data
):
4626 continuation_list
= [None]
4627 extract_entries
= lambda x
: self
._extract
_entries
(x
, continuation_list
)
4628 tab_content
= try_get(tab
, lambda x
: x
['content'], dict)
4632 try_get(tab_content
, lambda x
: x
['sectionListRenderer'], dict)
4633 or try_get(tab_content
, lambda x
: x
['richGridRenderer'], dict) or {})
4634 yield from extract_entries(parent_renderer
)
4635 continuation
= continuation_list
[0]
4637 for page_num
in itertools
.count(1):
4638 if not continuation
:
4640 headers
= self
.generate_api_headers(
4641 ytcfg
=ytcfg
, account_syncid
=account_syncid
, visitor_data
=visitor_data
)
4642 response
= self
._extract
_response
(
4643 item_id
=f
'{item_id} page {page_num}',
4644 query
=continuation
, headers
=headers
, ytcfg
=ytcfg
,
4645 check_get_keys
=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
4649 # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
4650 # See: https://github.com/ytdl-org/youtube-dl/issues/28702
4651 visitor_data
= self
._extract
_visitor
_data
(response
) or visitor_data
4654 'videoRenderer': (self
._grid
_entries
, 'items'), # for membership tab
4655 'gridPlaylistRenderer': (self
._grid
_entries
, 'items'),
4656 'gridVideoRenderer': (self
._grid
_entries
, 'items'),
4657 'gridChannelRenderer': (self
._grid
_entries
, 'items'),
4658 'playlistVideoRenderer': (self
._playlist
_entries
, 'contents'),
4659 'itemSectionRenderer': (extract_entries
, 'contents'), # for feeds
4660 'richItemRenderer': (extract_entries
, 'contents'), # for hashtag
4661 'backstagePostThreadRenderer': (self
._post
_thread
_continuation
_entries
, 'contents'),
4662 'reportHistoryTableRowRenderer': (self
._report
_history
_entries
, 'rows'),
4663 'playlistVideoListContinuation': (self
._playlist
_entries
, None),
4664 'gridContinuation': (self
._grid
_entries
, None),
4665 'itemSectionContinuation': (self
._post
_thread
_continuation
_entries
, None),
4666 'sectionListContinuation': (extract_entries
, None), # for feeds
4669 continuation_items
= traverse_obj(response
, (
4670 ('onResponseReceivedActions', 'onResponseReceivedEndpoints'), ...,
4671 'appendContinuationItemsAction', 'continuationItems'
4672 ), 'continuationContents', get_all
=False)
4673 continuation_item
= traverse_obj(continuation_items
, 0, None, expected_type
=dict, default
={})
4675 video_items_renderer
= None
4676 for key
in continuation_item
.keys():
4677 if key
not in known_renderers
:
4679 func
, parent_key
= known_renderers
[key
]
4680 video_items_renderer
= {parent_key: continuation_items}
if parent_key
else continuation_items
4681 continuation_list
= [None]
4682 yield from func(video_items_renderer
)
4683 continuation
= continuation_list
[0] or self
._extract
_continuation
(video_items_renderer
)
4685 if not video_items_renderer
:
4689 def _extract_selected_tab(tabs
, fatal
=True):
4690 for tab_renderer
in tabs
:
4691 if tab_renderer
.get('selected'):
4694 raise ExtractorError('Unable to find selected tab')
4697 def _extract_tab_renderers(response
):
4698 return traverse_obj(
4699 response
, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs', ..., ('tabRenderer', 'expandableTabRenderer')), expected_type
=dict)
4701 def _extract_from_tabs(self
, item_id
, ytcfg
, data
, tabs
):
4702 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
4704 selected_tab
= self
._extract
_selected
_tab
(tabs
)
4705 metadata
['title'] += format_field(selected_tab
, 'title', ' - %s')
4706 metadata
['title'] += format_field(selected_tab
, 'expandedText', ' - %s')
4708 return self
.playlist_result(
4710 selected_tab
, metadata
['id'], ytcfg
,
4711 self
._extract
_account
_syncid
(ytcfg
, data
),
4712 self
._extract
_visitor
_data
(data
, ytcfg
)),
4715 def _extract_metadata_from_tabs(self
, item_id
, data
):
4716 info
= {'id': item_id}
4718 metadata_renderer
= traverse_obj(data
, ('metadata', 'channelMetadataRenderer'), expected_type
=dict)
4719 if metadata_renderer
:
4721 'uploader': metadata_renderer
.get('title'),
4722 'uploader_id': metadata_renderer
.get('externalId'),
4723 'uploader_url': metadata_renderer
.get('channelUrl'),
4725 if info
['uploader_id']:
4726 info
['id'] = info
['uploader_id']
4728 metadata_renderer
= traverse_obj(data
, ('metadata', 'playlistMetadataRenderer'), expected_type
=dict)
4730 # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
4731 # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
4732 def _get_uncropped(url
):
4733 return url_or_none((url
or '').split('=')[0] + '=s0')
4735 avatar_thumbnails
= self
._extract
_thumbnails
(metadata_renderer
, 'avatar')
4736 if avatar_thumbnails
:
4737 uncropped_avatar
= _get_uncropped(avatar_thumbnails
[0]['url'])
4738 if uncropped_avatar
:
4739 avatar_thumbnails
.append({
4740 'url': uncropped_avatar
,
4741 'id': 'avatar_uncropped',
4745 channel_banners
= self
._extract
_thumbnails
(
4746 data
, ('header', ..., ('banner', 'mobileBanner', 'tvBanner')))
4747 for banner
in channel_banners
:
4748 banner
['preference'] = -10
4751 uncropped_banner
= _get_uncropped(channel_banners
[0]['url'])
4752 if uncropped_banner
:
4753 channel_banners
.append({
4754 'url': uncropped_banner
,
4755 'id': 'banner_uncropped',
4759 # Deprecated - remove primary_sidebar_renderer when layout discontinued
4760 primary_sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer')
4761 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer'), expected_type
=dict)
4763 primary_thumbnails
= self
._extract
_thumbnails
(
4764 primary_sidebar_renderer
, ('thumbnailRenderer', ('playlistVideoThumbnailRenderer', 'playlistCustomThumbnailRenderer'), 'thumbnail'))
4765 playlist_thumbnails
= self
._extract
_thumbnails
(
4766 playlist_header_renderer
, ('playlistHeaderBanner', 'heroPlaylistThumbnailRenderer', 'thumbnail'))
4769 'title': (traverse_obj(metadata_renderer
, 'title')
4770 or self
._get
_text
(data
, ('header', 'hashtagHeaderRenderer', 'hashtag'))
4772 'availability': self
._extract
_availability
(data
),
4773 'channel_follower_count': self
._get
_count
(data
, ('header', ..., 'subscriberCountText')),
4774 'description': try_get(metadata_renderer
, lambda x
: x
.get('description', '')),
4775 'tags': try_get(metadata_renderer
or {}, lambda x
: x
.get('keywords', '').split()),
4776 'thumbnails': (primary_thumbnails
or playlist_thumbnails
) + avatar_thumbnails
+ channel_banners
,
4779 # Playlist stats is a text runs array containing [video count, view count, last updated].
4780 # last updated or (view count and last updated) may be missing.
4781 playlist_stats
= get_first(
4782 (primary_sidebar_renderer
, playlist_header_renderer
), (('stats', 'briefStats', 'numVideosText'), ))
4784 last_updated_unix
= self
._parse
_time
_text
(
4785 self
._get
_text
(playlist_stats
, 2) # deprecated, remove when old layout discontinued
4786 or self
._get
_text
(playlist_header_renderer
, ('byline', 1, 'playlistBylineRenderer', 'text')))
4787 info
['modified_date'] = strftime_or_none(last_updated_unix
, '%Y%m%d')
4789 info
['view_count'] = self
._get
_count
(playlist_stats
, 1)
4790 if info
['view_count'] is None: # 0 is allowed
4791 info
['view_count'] = self
._get
_count
(playlist_header_renderer
, 'viewCountText')
4793 info
['playlist_count'] = self
._get
_count
(playlist_stats
, 0)
4794 if info
['playlist_count'] is None: # 0 is allowed
4795 info
['playlist_count'] = self
._get
_count
(playlist_header_renderer
, ('byline', 0, 'playlistBylineRenderer', 'text'))
4797 if not info
.get('uploader_id'):
4798 owner
= traverse_obj(playlist_header_renderer
, 'ownerText')
4799 if not owner
: # Deprecated
4800 owner
= traverse_obj(
4801 self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarSecondaryInfoRenderer'),
4802 ('videoOwner', 'videoOwnerRenderer', 'title'))
4803 owner_text
= self
._get
_text
(owner
)
4804 browse_ep
= traverse_obj(owner
, ('runs', 0, 'navigationEndpoint', 'browseEndpoint')) or {}
4806 'uploader': self
._search
_regex
(r
'^by (.+) and \d+ others?$', owner_text
, 'uploader', default
=owner_text
),
4807 'uploader_id': browse_ep
.get('browseId'),
4808 'uploader_url': urljoin('https://www.youtube.com', browse_ep
.get('canonicalBaseUrl'))
4812 'channel': info
['uploader'],
4813 'channel_id': info
['uploader_id'],
4814 'channel_url': info
['uploader_url']
4818 def _extract_inline_playlist(self
, playlist
, playlist_id
, data
, ytcfg
):
4819 first_id
= last_id
= response
= None
4820 for page_num
in itertools
.count(1):
4821 videos
= list(self
._playlist
_entries
(playlist
))
4824 start
= next((i
for i
, v
in enumerate(videos
) if v
['id'] == last_id
), -1) + 1
4825 if start
>= len(videos
):
4827 yield from videos
[start
:]
4828 first_id
= first_id
or videos
[0]['id']
4829 last_id
= videos
[-1]['id']
4830 watch_endpoint
= try_get(
4831 playlist
, lambda x
: x
['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
4832 headers
= self
.generate_api_headers(
4833 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
4834 visitor_data
=self
._extract
_visitor
_data
(response
, data
, ytcfg
))
4836 'playlistId': playlist_id
,
4837 'videoId': watch_endpoint
.get('videoId') or last_id
,
4838 'index': watch_endpoint
.get('index') or len(videos
),
4839 'params': watch_endpoint
.get('params') or 'OAE%3D'
4841 response
= self
._extract
_response
(
4842 item_id
='%s page %d' % (playlist_id
, page_num
),
4843 query
=query
, ep
='next', headers
=headers
, ytcfg
=ytcfg
,
4844 check_get_keys
='contents'
4847 response
, lambda x
: x
['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
4849 def _extract_from_playlist(self
, item_id
, url
, data
, playlist
, ytcfg
):
4850 title
= playlist
.get('title') or try_get(
4851 data
, lambda x
: x
['titleText']['simpleText'], str)
4852 playlist_id
= playlist
.get('playlistId') or item_id
4854 # Delegating everything except mix playlists to regular tab-based playlist URL
4855 playlist_url
= urljoin(url
, try_get(
4856 playlist
, lambda x
: x
['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4859 # Some playlists are unviewable but YouTube still provides a link to the (broken) playlist page [1]
4860 # [1] MLCT, RLTDwFCb4jeqaKWnciAYM-ZVHg
4861 is_known_unviewable
= re
.fullmatch(r
'MLCT|RLTD[\w-]{22}', playlist_id
)
4863 if playlist_url
and playlist_url
!= url
and not is_known_unviewable
:
4864 return self
.url_result(
4865 playlist_url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
,
4868 return self
.playlist_result(
4869 self
._extract
_inline
_playlist
(playlist
, playlist_id
, data
, ytcfg
),
4870 playlist_id
=playlist_id
, playlist_title
=title
)
4872 def _extract_availability(self
, data
):
4874 Gets the availability of a given playlist/tab.
4875 Note: Unless YouTube tells us explicitly, we do not assume it is public
4876 @param data: response
4878 sidebar_renderer
= self
._extract
_sidebar
_info
_renderer
(data
, 'playlistSidebarPrimaryInfoRenderer') or {}
4879 playlist_header_renderer
= traverse_obj(data
, ('header', 'playlistHeaderRenderer')) or {}
4880 player_header_privacy
= playlist_header_renderer
.get('privacy')
4882 badges
= self
._extract
_badges
(sidebar_renderer
)
4884 # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
4885 privacy_setting_icon
= get_first(
4886 (playlist_header_renderer
, sidebar_renderer
),
4887 ('privacyForm', 'dropdownFormFieldRenderer', 'dropdown', 'dropdownRenderer', 'entries',
4888 lambda _
, v
: v
['privacyDropdownItemRenderer']['isSelected'], 'privacyDropdownItemRenderer', 'icon', 'iconType'),
4891 microformats_is_unlisted
= traverse_obj(
4892 data
, ('microformat', 'microformatDataRenderer', 'unlisted'), expected_type
=bool)
4896 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PUBLIC
)
4897 or player_header_privacy
== 'PUBLIC'
4898 or privacy_setting_icon
== 'PRIVACY_PUBLIC')
4899 else self
._availability
(
4901 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PRIVATE
)
4902 or player_header_privacy
== 'PRIVATE' if player_header_privacy
is not None
4903 else privacy_setting_icon
== 'PRIVACY_PRIVATE' if privacy_setting_icon
is not None else None),
4905 self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_UNLISTED
)
4906 or player_header_privacy
== 'UNLISTED' if player_header_privacy
is not None
4907 else privacy_setting_icon
== 'PRIVACY_UNLISTED' if privacy_setting_icon
is not None
4908 else microformats_is_unlisted
if microformats_is_unlisted
is not None else None),
4909 needs_subscription
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_SUBSCRIPTION
) or None,
4910 needs_premium
=self
._has
_badge
(badges
, BadgeType
.AVAILABILITY_PREMIUM
) or None,
4914 def _extract_sidebar_info_renderer(data
, info_renderer
, expected_type
=dict):
4915 sidebar_renderer
= try_get(
4916 data
, lambda x
: x
['sidebar']['playlistSidebarRenderer']['items'], list) or []
4917 for item
in sidebar_renderer
:
4918 renderer
= try_get(item
, lambda x
: x
[info_renderer
], expected_type
)
4922 def _reload_with_unavailable_videos(self
, item_id
, data
, ytcfg
):
4924 Reload playlists with unavailable videos (e.g. private videos, region blocked, etc.)
4926 is_playlist
= bool(traverse_obj(
4927 data
, ('metadata', 'playlistMetadataRenderer'), ('header', 'playlistHeaderRenderer')))
4930 headers
= self
.generate_api_headers(
4931 ytcfg
=ytcfg
, account_syncid
=self
._extract
_account
_syncid
(ytcfg
, data
),
4932 visitor_data
=self
._extract
_visitor
_data
(data
, ytcfg
))
4934 'params': 'wgYCCAA=',
4935 'browseId': f
'VL{item_id}'
4937 return self
._extract
_response
(
4938 item_id
=item_id
, headers
=headers
, query
=query
,
4939 check_get_keys
='contents', fatal
=False, ytcfg
=ytcfg
,
4940 note
='Redownloading playlist API JSON with unavailable videos')
4942 @functools.cached_property
4943 def skip_webpage(self
):
4944 return 'webpage' in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key())
4946 def _extract_webpage(self
, url
, item_id
, fatal
=True):
4947 webpage
, data
= None, None
4948 for retry
in self
.RetryManager(fatal
=fatal
):
4950 webpage
= self
._download
_webpage
(url
, item_id
, note
='Downloading webpage')
4951 data
= self
.extract_yt_initial_data(item_id
, webpage
or '', fatal
=fatal
) or {}
4952 except ExtractorError
as e
:
4953 if isinstance(e
.cause
, network_exceptions
):
4954 if not isinstance(e
.cause
, urllib
.error
.HTTPError
) or e
.cause
.code
not in (403, 429):
4957 self
._error
_or
_warning
(e
, fatal
=fatal
)
4961 self
._extract
_and
_report
_alerts
(data
)
4962 except ExtractorError
as e
:
4963 self
._error
_or
_warning
(e
, fatal
=fatal
)
4966 # Sometimes youtube returns a webpage with incomplete ytInitialData
4967 # See: https://github.com/yt-dlp/yt-dlp/issues/116
4968 if not traverse_obj(data
, 'contents', 'currentVideoEndpoint', 'onResponseReceivedActions'):
4969 retry
.error
= ExtractorError('Incomplete yt initial data received')
4972 return webpage
, data
4974 def _report_playlist_authcheck(self
, ytcfg
, fatal
=True):
4975 """Use if failed to extract ytcfg (and data) from initial webpage"""
4976 if not ytcfg
and self
.is_authenticated
:
4977 msg
= 'Playlists that require authentication may not extract correctly without a successful webpage download'
4978 if 'authcheck' not in self
._configuration
_arg
('skip', ie_key
=YoutubeTabIE
.ie_key()) and fatal
:
4979 raise ExtractorError(
4980 f
'{msg}. If you are not downloading private content, or '
4981 'your cookies are only for the first account and channel,'
4982 ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
4984 self
.report_warning(msg
, only_once
=True)
4986 def _extract_data(self
, url
, item_id
, ytcfg
=None, fatal
=True, webpage_fatal
=False, default_client
='web'):
4988 if not self
.skip_webpage
:
4989 webpage
, data
= self
._extract
_webpage
(url
, item_id
, fatal
=webpage_fatal
)
4990 ytcfg
= ytcfg
or self
.extract_ytcfg(item_id
, webpage
)
4991 # Reject webpage data if redirected to home page without explicitly requesting
4992 selected_tab
= self
._extract
_selected
_tab
(self
._extract
_tab
_renderers
(data
), fatal
=False) or {}
4993 if (url
!= 'https://www.youtube.com/feed/recommended'
4994 and selected_tab
.get('tabIdentifier') == 'FEwhat_to_watch' # Home page
4995 and 'no-youtube-channel-redirect' not in self
.get_param('compat_opts', [])):
4996 msg
= 'The channel/playlist does not exist and the URL redirected to youtube.com home page'
4998 raise ExtractorError(msg
, expected
=True)
4999 self
.report_warning(msg
, only_once
=True)
5001 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=fatal
)
5002 data
= self
._extract
_tab
_endpoint
(url
, item_id
, ytcfg
, fatal
=fatal
, default_client
=default_client
)
5005 def _extract_tab_endpoint(self
, url
, item_id
, ytcfg
=None, fatal
=True, default_client
='web'):
5006 headers
= self
.generate_api_headers(ytcfg
=ytcfg
, default_client
=default_client
)
5007 resolve_response
= self
._extract
_response
(
5008 item_id
=item_id
, query
={'url': url}
, check_get_keys
='endpoint', headers
=headers
, ytcfg
=ytcfg
, fatal
=fatal
,
5009 ep
='navigation/resolve_url', note
='Downloading API parameters API JSON', default_client
=default_client
)
5010 endpoints
= {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
5011 for ep_key
, ep
in endpoints
.items():
5012 params
= try_get(resolve_response
, lambda x
: x
['endpoint'][ep_key
], dict)
5014 return self
._extract
_response
(
5015 item_id
=item_id
, query
=params
, ep
=ep
, headers
=headers
,
5016 ytcfg
=ytcfg
, fatal
=fatal
, default_client
=default_client
,
5017 check_get_keys
=('contents', 'currentVideoEndpoint', 'onResponseReceivedActions'))
5018 err_note
= 'Failed to resolve url (does the playlist exist?)'
5020 raise ExtractorError(err_note
, expected
=True)
5021 self
.report_warning(err_note
, item_id
)
5023 _SEARCH_PARAMS
= None
5025 def _search_results(self
, query
, params
=NO_DEFAULT
, default_client
='web'):
5026 data
= {'query': query}
5027 if params
is NO_DEFAULT
:
5028 params
= self
._SEARCH
_PARAMS
5030 data
['params'] = params
5033 ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
5034 ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
5036 ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
5037 ('continuationContents', ),
5039 display_id
= f
'query "{query}"'
5040 check_get_keys
= tuple({keys[0] for keys in content_keys}
)
5041 ytcfg
= self
._download
_ytcfg
(default_client
, display_id
) if not self
.skip_webpage
else {}
5042 self
._report
_playlist
_authcheck
(ytcfg
, fatal
=False)
5044 continuation_list
= [None]
5046 for page_num
in itertools
.count(1):
5047 data
.update(continuation_list
[0] or {})
5048 headers
= self
.generate_api_headers(
5049 ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(search
), default_client
=default_client
)
5050 search
= self
._extract
_response
(
5051 item_id
=f
'{display_id} page {page_num}', ep
='search', query
=data
,
5052 default_client
=default_client
, check_get_keys
=check_get_keys
, ytcfg
=ytcfg
, headers
=headers
)
5053 slr_contents
= traverse_obj(search
, *content_keys
)
5054 yield from self
._extract
_entries
({'contents': list(variadic(slr_contents))}
, continuation_list
)
5055 if not continuation_list
[0]:
5059 class YoutubeTabIE(YoutubeTabBaseInfoExtractor
):
5060 IE_DESC
= 'YouTube Tabs'
5061 _VALID_URL
= r
'''(?x:
5065 youtube(?:kids)?\.com|
5069 (?P<channel_type>channel|c|user|browse)/|
5072 (?:playlist|watch)\?.*?\blist=
5074 (?!(?:%(reserved_names)s)\b) # Direct URLs
5078 'reserved_names': YoutubeBaseInfoExtractor
._RESERVED
_NAMES
,
5079 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
5081 IE_NAME
= 'youtube:tab'
5084 'note': 'playlists, multipage',
5085 'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
5086 'playlist_mincount': 94,
5088 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5089 'title': 'Igor Kleiner - Playlists',
5090 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5091 'uploader': 'Igor Kleiner',
5092 'uploader_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5093 'channel': 'Igor Kleiner',
5094 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5095 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5096 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5097 'uploader_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5098 'channel_follower_count': int
5101 'note': 'playlists, multipage, different order',
5102 'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
5103 'playlist_mincount': 94,
5105 'id': 'UCqj7Cz7revf5maW9g5pgNcg',
5106 'title': 'Igor Kleiner - Playlists',
5107 'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
5108 'uploader_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5109 'uploader': 'Igor Kleiner',
5110 'uploader_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5111 'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
5112 'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
5113 'channel': 'Igor Kleiner',
5114 'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
5115 'channel_follower_count': int
5118 'note': 'playlists, series',
5119 'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
5120 'playlist_mincount': 5,
5122 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5123 'title': '3Blue1Brown - Playlists',
5124 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5125 'uploader_id': 'UCYO_jab_esuFRV4b17AJtAw',
5126 'uploader': '3Blue1Brown',
5127 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5128 'uploader_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5129 'channel': '3Blue1Brown',
5130 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5131 'tags': ['Mathematics'],
5132 'channel_follower_count': int
5135 'note': 'playlists, singlepage',
5136 'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
5137 'playlist_mincount': 4,
5139 'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5140 'title': 'ThirstForScience - Playlists',
5141 'description': 'md5:609399d937ea957b0f53cbffb747a14c',
5142 'uploader': 'ThirstForScience',
5143 'uploader_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5144 'uploader_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5145 'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
5146 'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
5148 'channel': 'ThirstForScience',
5149 'channel_follower_count': int
5152 'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
5153 'only_matching': True,
5155 'note': 'basic, single video playlist',
5156 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5158 'uploader_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5159 'uploader': 'Sergey M.',
5160 'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5161 'title': 'youtube-dl public playlist',
5165 'modified_date': '20201130',
5166 'channel': 'Sergey M.',
5167 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5168 'uploader_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5169 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5170 'availability': 'public',
5172 'playlist_count': 1,
5174 'note': 'empty playlist',
5175 'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5177 'uploader_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5178 'uploader': 'Sergey M.',
5179 'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
5180 'title': 'youtube-dl empty playlist',
5182 'channel': 'Sergey M.',
5184 'modified_date': '20160902',
5185 'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
5186 'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5187 'uploader_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5188 'availability': 'public',
5190 'playlist_count': 0,
5193 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
5195 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5196 'title': 'lex will - Home',
5197 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5198 'uploader': 'lex will',
5199 'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5200 'channel': 'lex will',
5201 'tags': ['bible', 'history', 'prophesy'],
5202 'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5203 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5204 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5205 'channel_follower_count': int
5207 'playlist_mincount': 2,
5209 'note': 'Videos tab',
5210 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
5212 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5213 'title': 'lex will - Videos',
5214 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5215 'uploader': 'lex will',
5216 'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5217 'tags': ['bible', 'history', 'prophesy'],
5218 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5219 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5220 'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5221 'channel': 'lex will',
5222 'channel_follower_count': int
5224 'playlist_mincount': 975,
5226 'note': 'Videos tab, sorted by popular',
5227 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
5229 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5230 'title': 'lex will - Videos',
5231 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5232 'uploader': 'lex will',
5233 'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5234 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5235 'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5236 'channel': 'lex will',
5237 'tags': ['bible', 'history', 'prophesy'],
5238 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5239 'channel_follower_count': int
5241 'playlist_mincount': 199,
5243 'note': 'Playlists tab',
5244 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
5246 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5247 'title': 'lex will - Playlists',
5248 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5249 'uploader': 'lex will',
5250 'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5251 'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5252 'channel': 'lex will',
5253 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5254 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5255 'tags': ['bible', 'history', 'prophesy'],
5256 'channel_follower_count': int
5258 'playlist_mincount': 17,
5260 'note': 'Community tab',
5261 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
5263 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5264 'title': 'lex will - Community',
5265 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5266 'uploader': 'lex will',
5267 'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5268 'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5269 'channel': 'lex will',
5270 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5271 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5272 'tags': ['bible', 'history', 'prophesy'],
5273 'channel_follower_count': int
5275 'playlist_mincount': 18,
5277 'note': 'Channels tab',
5278 'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
5280 'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5281 'title': 'lex will - Channels',
5282 'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
5283 'uploader': 'lex will',
5284 'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5285 'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5286 'channel': 'lex will',
5287 'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
5288 'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
5289 'tags': ['bible', 'history', 'prophesy'],
5290 'channel_follower_count': int
5292 'playlist_mincount': 12,
5294 'note': 'Search tab',
5295 'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
5296 'playlist_mincount': 40,
5298 'id': 'UCYO_jab_esuFRV4b17AJtAw',
5299 'title': '3Blue1Brown - Search - linear algebra',
5300 'description': 'md5:e1384e8a133307dd10edee76e875d62f',
5301 'uploader': '3Blue1Brown',
5302 'uploader_id': 'UCYO_jab_esuFRV4b17AJtAw',
5303 'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5304 'uploader_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
5305 'tags': ['Mathematics'],
5306 'channel': '3Blue1Brown',
5307 'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
5308 'channel_follower_count': int
5311 'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5312 'only_matching': True,
5314 'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5315 'only_matching': True,
5317 'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
5318 'only_matching': True,
5320 'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
5321 'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5323 'title': '29C3: Not my department',
5324 'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
5325 'uploader': 'Christiaan008',
5326 'uploader_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5327 'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
5329 'uploader_url': 'https://www.youtube.com/c/ChRiStIaAn008',
5331 'modified_date': '20150605',
5332 'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
5333 'channel_url': 'https://www.youtube.com/c/ChRiStIaAn008',
5334 'channel': 'Christiaan008',
5335 'availability': 'public',
5337 'playlist_count': 96,
5339 'note': 'Large playlist',
5340 'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
5342 'title': 'Uploads from Cauchemar',
5343 'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
5344 'uploader': 'Cauchemar',
5345 'uploader_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5346 'channel_url': 'https://www.youtube.com/c/Cauchemar89',
5348 'modified_date': r
're:\d{8}',
5349 'channel': 'Cauchemar',
5350 'uploader_url': 'https://www.youtube.com/c/Cauchemar89',
5353 'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
5354 'availability': 'public',
5356 'playlist_mincount': 1123,
5357 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5359 'note': 'even larger playlist, 8832 videos',
5360 'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
5361 'only_matching': True,
5363 'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
5364 'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
5366 'title': 'Uploads from Interstellar Movie',
5367 'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
5368 'uploader': 'Interstellar Movie',
5369 'uploader_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5370 'uploader_url': 'https://www.youtube.com/c/InterstellarMovie',
5373 'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
5374 'channel_url': 'https://www.youtube.com/c/InterstellarMovie',
5375 'channel': 'Interstellar Movie',
5377 'modified_date': r
're:\d{8}',
5378 'availability': 'public',
5380 'playlist_mincount': 21,
5382 'note': 'Playlist with "show unavailable videos" button',
5383 'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
5385 'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
5386 'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
5387 'uploader': 'Phim Siêu Nhân Nhật Bản',
5388 'uploader_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5390 'channel': 'Phim Siêu Nhân Nhật Bản',
5392 'uploader_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5394 'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
5395 'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
5396 'modified_date': r
're:\d{8}',
5397 'availability': 'public',
5399 'playlist_mincount': 200,
5400 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5402 'note': 'Playlist with unavailable videos in page 7',
5403 'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
5405 'title': 'Uploads from BlankTV',
5406 'id': 'UU8l9frL61Yl5KFOl87nIm2w',
5407 'uploader': 'BlankTV',
5408 'uploader_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5409 'channel': 'BlankTV',
5410 'channel_url': 'https://www.youtube.com/c/blanktv',
5411 'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
5414 'uploader_url': 'https://www.youtube.com/c/blanktv',
5415 'modified_date': r
're:\d{8}',
5417 'availability': 'public',
5419 'playlist_mincount': 1000,
5420 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5422 'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
5423 'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5425 'title': 'Data Analysis with Dr Mike Pound',
5426 'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
5427 'uploader_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5428 'uploader': 'Computerphile',
5429 'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
5430 'uploader_url': 'https://www.youtube.com/user/Computerphile',
5433 'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
5434 'channel_url': 'https://www.youtube.com/user/Computerphile',
5435 'channel': 'Computerphile',
5436 'availability': 'public',
5437 'modified_date': '20190712',
5439 'playlist_mincount': 11,
5441 'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
5442 'only_matching': True,
5444 'note': 'Playlist URL that does not actually serve a playlist',
5445 'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
5447 'id': 'FqZTN594JQw',
5449 'title': "Smiley's People 01 detective, Adventure Series, Action",
5450 'uploader': 'STREEM',
5451 'uploader_id': 'UCyPhqAZgwYWZfxElWVbVJng',
5452 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/channel/UCyPhqAZgwYWZfxElWVbVJng',
5453 'upload_date': '20150526',
5454 'license': 'Standard YouTube License',
5455 'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
5456 'categories': ['People & Blogs'],
5462 'skip_download': True,
5464 'skip': 'This video is not available.',
5465 'add_ie': [YoutubeIE
.ie_key()],
5467 'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
5468 'only_matching': True,
5470 'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
5471 'only_matching': True,
5473 'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
5475 'id': 'Wq15eF5vCbI', # This will keep changing
5478 'uploader': 'Sky News',
5479 'uploader_id': 'skynews',
5480 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/user/skynews',
5481 'upload_date': r
're:\d{8}',
5483 'categories': ['News & Politics'],
5486 'release_timestamp': int,
5487 'channel': 'Sky News',
5488 'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
5491 'thumbnail': r
're:https?://i\.ytimg\.com/vi/[^/]+/maxresdefault(?:_live)?\.jpg',
5492 'playable_in_embed': True,
5493 'release_date': r
're:\d+',
5494 'availability': 'public',
5495 'live_status': 'is_live',
5496 'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
5497 'channel_follower_count': int,
5498 'concurrent_view_count': int,
5501 'skip_download': True,
5503 'expected_warnings': ['Ignoring subtitle tracks found in '],
5505 'url': 'https://www.youtube.com/user/TheYoungTurks/live',
5507 'id': 'a48o2S1cPoo',
5509 'title': 'The Young Turks - Live Main Show',
5510 'uploader': 'The Young Turks',
5511 'uploader_id': 'TheYoungTurks',
5512 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/user/TheYoungTurks',
5513 'upload_date': '20150715',
5514 'license': 'Standard YouTube License',
5515 'description': 'md5:438179573adcdff3c97ebb1ee632b891',
5516 'categories': ['News & Politics'],
5517 'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
5521 'skip_download': True,
5523 'only_matching': True,
5525 'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
5526 'only_matching': True,
5528 'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
5529 'only_matching': True,
5531 'note': 'A channel that is not live. Should raise error',
5532 'url': 'https://www.youtube.com/user/numberphile/live',
5533 'only_matching': True,
5535 'url': 'https://www.youtube.com/feed/trending',
5536 'only_matching': True,
5538 'url': 'https://www.youtube.com/feed/library',
5539 'only_matching': True,
5541 'url': 'https://www.youtube.com/feed/history',
5542 'only_matching': True,
5544 'url': 'https://www.youtube.com/feed/subscriptions',
5545 'only_matching': True,
5547 'url': 'https://www.youtube.com/feed/watch_later',
5548 'only_matching': True,
5550 'note': 'Recommended - redirects to home page.',
5551 'url': 'https://www.youtube.com/feed/recommended',
5552 'only_matching': True,
5554 'note': 'inline playlist with not always working continuations',
5555 'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
5556 'only_matching': True,
5558 'url': 'https://www.youtube.com/course',
5559 'only_matching': True,
5561 'url': 'https://www.youtube.com/zsecurity',
5562 'only_matching': True,
5564 'url': 'http://www.youtube.com/NASAgovVideo/videos',
5565 'only_matching': True,
5567 'url': 'https://www.youtube.com/TheYoungTurks/live',
5568 'only_matching': True,
5570 'url': 'https://www.youtube.com/hashtag/cctv9',
5576 'playlist_mincount': 300, # not consistent but should be over 300
5578 'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
5579 'only_matching': True,
5581 'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
5582 'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5583 'only_matching': True
5585 'note': '/browse/ should redirect to /channel/',
5586 'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
5587 'only_matching': True
5589 'note': 'VLPL, should redirect to playlist?list=PL...',
5590 'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5592 'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
5593 'uploader': 'NoCopyrightSounds',
5594 'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
5595 'uploader_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
5596 'title': 'NCS : All Releases 💿',
5597 'uploader_url': 'https://www.youtube.com/c/NoCopyrightSounds',
5598 'channel_url': 'https://www.youtube.com/c/NoCopyrightSounds',
5599 'modified_date': r
're:\d{8}',
5601 'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
5603 'channel': 'NoCopyrightSounds',
5604 'availability': 'public',
5606 'playlist_mincount': 166,
5607 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
5609 'note': 'Topic, should redirect to playlist?list=UU...',
5610 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5612 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5613 'uploader_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5614 'title': 'Uploads from Royalty Free Music - Topic',
5615 'uploader': 'Royalty Free Music - Topic',
5617 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5618 'channel': 'Royalty Free Music - Topic',
5620 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5621 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5622 'modified_date': r
're:\d{8}',
5623 'uploader_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5625 'availability': 'public',
5627 'playlist_mincount': 101,
5629 # Destination channel with only a hidden self tab (tab id is UCtFRv9O2AHqOZjjynzrv-xg)
5630 # Treat as a general feed
5631 'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
5633 'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
5634 'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
5637 'playlist_mincount': 9,
5639 'note': 'Youtube music Album',
5640 'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
5642 'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
5643 'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
5647 'availability': 'unlisted',
5648 'modified_date': r
're:\d{8}',
5650 'playlist_count': 50,
5652 'note': 'unlisted single video playlist',
5653 'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5655 'uploader_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5656 'uploader': 'colethedj',
5657 'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
5658 'title': 'yt-dlp unlisted playlist test',
5659 'availability': 'unlisted',
5661 'modified_date': '20220418',
5662 'channel': 'colethedj',
5665 'uploader_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5666 'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
5667 'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
5669 'playlist_count': 1,
5671 'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
5672 'url': 'https://www.youtube.com/feed/recommended',
5674 'id': 'recommended',
5675 'title': 'recommended',
5678 'playlist_mincount': 50,
5680 'skip_download': True,
5681 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5684 'note': 'API Fallback: /videos tab, sorted by oldest first',
5685 'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
5687 'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5688 'title': 'Cody\'sLab - Videos',
5689 'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
5690 'uploader': 'Cody\'sLab',
5691 'uploader_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5692 'channel': 'Cody\'sLab',
5693 'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
5695 'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
5696 'uploader_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
5697 'channel_follower_count': int
5699 'playlist_mincount': 650,
5701 'skip_download': True,
5702 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5704 'skip': 'Query for sorting no longer works',
5706 'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
5707 'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
5709 'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
5710 'uploader_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5711 'title': 'Uploads from Royalty Free Music - Topic',
5712 'uploader': 'Royalty Free Music - Topic',
5713 'modified_date': r
're:\d{8}',
5714 'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
5716 'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5718 'channel': 'Royalty Free Music - Topic',
5720 'uploader_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
5721 'availability': 'public',
5723 'playlist_mincount': 101,
5725 'skip_download': True,
5726 'extractor_args': {'youtubetab': {'skip': ['webpage']}
}
5729 'note': 'non-standard redirect to regional channel',
5730 'url': 'https://www.youtube.com/channel/UCwVVpHQ2Cs9iGJfpdFngePQ',
5731 'only_matching': True
5733 'note': 'collaborative playlist (uploader name in the form "by <uploader> and x other(s)")',
5734 'url': 'https://www.youtube.com/playlist?list=PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
5736 'id': 'PLx-_-Kk4c89oOHEDQAojOXzEzemXxoqx6',
5737 'modified_date': '20220407',
5738 'channel_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
5740 'uploader_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
5741 'uploader': 'pukkandan',
5742 'availability': 'unlisted',
5743 'channel_id': 'UCKcqXmCcyqnhgpA5P0oHH_Q',
5744 'channel': 'pukkandan',
5745 'description': 'Test for collaborative playlist',
5746 'title': 'yt-dlp test - collaborative playlist',
5748 'uploader_url': 'https://www.youtube.com/channel/UCKcqXmCcyqnhgpA5P0oHH_Q',
5750 'playlist_mincount': 2
5752 'note': 'translated tab name',
5753 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/playlists',
5755 'id': 'UCiu-3thuViMebBjw_5nWYrA',
5757 'uploader_id': 'UCiu-3thuViMebBjw_5nWYrA',
5758 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
5759 'description': 'test description',
5760 'title': 'cole-dlp-test-acc - 再生リスト',
5761 'uploader_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
5762 'uploader': 'cole-dlp-test-acc',
5763 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
5764 'channel': 'cole-dlp-test-acc',
5765 'channel_follower_count': int,
5767 'playlist_mincount': 1,
5768 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
5769 'expected_warnings': ['Preferring "ja"'],
5771 # XXX: this should really check flat playlist entries, but the test suite doesn't support that
5772 'note': 'preferred lang set with playlist with translated video titles',
5773 'url': 'https://www.youtube.com/playlist?list=PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
5775 'id': 'PLt5yu3-wZAlQAaPZ5Z-rJoTdbT-45Q7c0',
5778 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
5779 'uploader': 'cole-dlp-test-acc',
5780 'uploader_id': 'UCiu-3thuViMebBjw_5nWYrA',
5781 'channel': 'cole-dlp-test-acc',
5782 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
5783 'description': 'test',
5784 'uploader_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
5785 'title': 'dlp test playlist',
5786 'availability': 'public',
5788 'playlist_mincount': 1,
5789 'params': {'extractor_args': {'youtube': {'lang': ['ja']}
}},
5790 'expected_warnings': ['Preferring "ja"'],
5792 # shorts audio pivot for 2GtVksBMYFM.
5793 'url': 'https://www.youtube.com/feed/sfv_audio_pivot?bp=8gUrCikSJwoLMkd0VmtzQk1ZRk0SCzJHdFZrc0JNWUZNGgsyR3RWa3NCTVlGTQ==',
5795 'id': 'sfv_audio_pivot',
5796 'title': 'sfv_audio_pivot',
5799 'playlist_mincount': 50,
5802 # Channel with a real live tab (not to be mistaken with streams tab)
5803 # Do not treat like it should redirect to live stream
5804 'url': 'https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live',
5806 'id': 'UCEH7P7kyJIkS_gJf93VYbmg',
5807 'title': 'UCEH7P7kyJIkS_gJf93VYbmg - Live',
5810 'playlist_mincount': 20,
5812 # Tab name is not the same as tab id
5813 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/letsplay',
5815 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
5816 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Let\'s play',
5819 'playlist_mincount': 8,
5821 # Home tab id is literally home. Not to get mistaken with featured
5822 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/home',
5824 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
5825 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Home',
5828 'playlist_mincount': 8,
5830 # Should get three playlists for videos, shorts and streams tabs
5831 'url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
5833 'id': 'UCK9V2B22uJYu3N7eR_BT9QA',
5834 'title': 'Polka Ch. 尾丸ポルカ',
5835 'channel_follower_count': int,
5836 'channel_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
5837 'channel_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
5838 'uploader': 'Polka Ch. 尾丸ポルカ',
5839 'description': 'md5:3b8df1ac5af337aa206e37ee3d181ec9',
5840 'channel': 'Polka Ch. 尾丸ポルカ',
5842 'uploader_url': 'https://www.youtube.com/channel/UCK9V2B22uJYu3N7eR_BT9QA',
5843 'uploader_id': 'UCK9V2B22uJYu3N7eR_BT9QA',
5845 'playlist_count': 3,
5847 # Shorts tab with channel with handle
5848 'url': 'https://www.youtube.com/@NotJustBikes/shorts',
5850 'id': 'UC0intLFzLaudFG-xAvUEO-A',
5851 'title': 'Not Just Bikes - Shorts',
5853 'uploader': 'Not Just Bikes',
5854 'channel_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
5855 'description': 'md5:7513148b1f02b924783157d84c4ea555',
5856 'channel_follower_count': int,
5857 'uploader_id': 'UC0intLFzLaudFG-xAvUEO-A',
5858 'channel_id': 'UC0intLFzLaudFG-xAvUEO-A',
5859 'uploader_url': 'https://www.youtube.com/channel/UC0intLFzLaudFG-xAvUEO-A',
5860 'channel': 'Not Just Bikes',
5862 'playlist_mincount': 10,
5865 'url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig/streams',
5867 'id': 'UC3eYAvjCVwNHgkaGbXX3sig',
5868 'title': '中村悠一 - Live',
5870 'channel_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
5871 'channel_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
5872 'uploader_id': 'UC3eYAvjCVwNHgkaGbXX3sig',
5874 'uploader_url': 'https://www.youtube.com/channel/UC3eYAvjCVwNHgkaGbXX3sig',
5875 'channel_follower_count': int,
5877 'description': 'md5:e744f6c93dafa7a03c0c6deecb157300',
5879 'playlist_mincount': 60,
5881 # Channel with no uploads and hence no videos, streams, shorts tabs or uploads playlist. This should fail.
5882 # See test_youtube_lists
5883 'url': 'https://www.youtube.com/channel/UC2yXPzFejc422buOIzn_0CA',
5884 'only_matching': True,
5886 # No uploads and no UCID given. Should fail with no uploads error
5887 # See test_youtube_lists
5888 'url': 'https://www.youtube.com/news',
5889 'only_matching': True
5891 # No videos tab but has a shorts tab
5892 'url': 'https://www.youtube.com/c/TKFShorts',
5894 'id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
5895 'title': 'Shorts Break - Shorts',
5897 'channel_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
5898 'channel': 'Shorts Break',
5899 'description': 'md5:a6c234cf3d50d878ef8721e34457cd11',
5900 'uploader': 'Shorts Break',
5901 'channel_follower_count': int,
5902 'uploader_id': 'UCgJ5_1F6yJhYLnyMszUdmUg',
5903 'uploader_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
5904 'channel_url': 'https://www.youtube.com/channel/UCgJ5_1F6yJhYLnyMszUdmUg',
5906 'playlist_mincount': 30,
5908 # Trending Now Tab. tab id is empty
5909 'url': 'https://www.youtube.com/feed/trending',
5912 'title': 'trending - Now',
5915 'playlist_mincount': 30,
5917 # Trending Gaming Tab. tab id is empty
5918 'url': 'https://www.youtube.com/feed/trending?bp=4gIcGhpnYW1pbmdfY29ycHVzX21vc3RfcG9wdWxhcg%3D%3D',
5921 'title': 'trending - Gaming',
5924 'playlist_mincount': 30,
5926 # Shorts url result in shorts tab
5927 'url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA/shorts',
5929 'id': 'UCiu-3thuViMebBjw_5nWYrA',
5930 'title': 'cole-dlp-test-acc - Shorts',
5931 'uploader_id': 'UCiu-3thuViMebBjw_5nWYrA',
5932 'channel': 'cole-dlp-test-acc',
5933 'channel_follower_count': int,
5934 'description': 'test description',
5935 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
5936 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
5938 'uploader': 'cole-dlp-test-acc',
5939 'uploader_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
5945 'ie_key': 'Youtube',
5946 'url': 'https://www.youtube.com/shorts/sSM9J5YH_60',
5947 'id': 'sSM9J5YH_60',
5948 'channel_id': 'UCiu-3thuViMebBjw_5nWYrA',
5949 'title': 'SHORT short',
5950 'channel': 'cole-dlp-test-acc',
5951 'channel_url': 'https://www.youtube.com/channel/UCiu-3thuViMebBjw_5nWYrA',
5956 'params': {'extract_flat': True}
,
5958 # Live video status should be extracted
5959 'url': 'https://www.youtube.com/channel/UCQvWX73GQygcwXOTSf_VDVg/live',
5961 'id': 'UCQvWX73GQygcwXOTSf_VDVg',
5962 'title': 'UCQvWX73GQygcwXOTSf_VDVg - Live', # TODO, should be Minecraft - Live or Minecraft - Topic - Live
5968 'ie_key': 'Youtube',
5969 'url': 'startswith:https://www.youtube.com/watch?v=',
5972 'live_status': 'is_live',
5975 'concurrent_view_count': int,
5979 'params': {'extract_flat': True}
,
5980 'playlist_mincount': 1
5984 def suitable(cls
, url
):
5985 return False if YoutubeIE
.suitable(url
) else super().suitable(url
)
5987 _URL_RE
= re
.compile(rf
'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/[^?#/]+))?(?P<post>.*)$')
5989 def _get_url_mobj(self
, url
):
5990 mobj
= self
._URL
_RE
.match(url
).groupdict()
5991 mobj
.update((k
, '') for k
, v
in mobj
.items() if v
is None)
5994 def _extract_tab_id_and_name(self
, tab
, base_url
='https://www.youtube.com'):
5995 tab_name
= (tab
.get('title') or '').lower()
5996 tab_url
= urljoin(base_url
, traverse_obj(
5997 tab
, ('endpoint', 'commandMetadata', 'webCommandMetadata', 'url')))
5999 tab_id
= (tab_url
and self
._get
_url
_mobj
(tab_url
)['tab'][1:]
6000 or traverse_obj(tab
, 'tabIdentifier', expected_type
=str))
6003 'TAB_ID_SPONSORSHIPS': 'membership',
6004 }.get(tab_id
, tab_id
), tab_name
6006 # Fallback to tab name if we cannot get the tab id.
6007 # XXX: should we strip non-ascii letters? e.g. in case of 'let's play' tab example on special gaming channel
6008 # Note that in the case of translated tab name this may result in an empty string, which we don't want.
6010 self
.write_debug(f
'Falling back to selected tab name: {tab_name}')
6014 }.get(tab_name
, tab_name
), tab_name
6016 def _has_tab(self
, tabs
, tab_id
):
6017 return any(self
._extract
_tab
_id
_and
_name
(tab
)[0] == tab_id
for tab
in tabs
)
6019 @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
6020 def _real_extract(self
, url
, smuggled_data
):
6021 item_id
= self
._match
_id
(url
)
6022 url
= urllib
.parse
.urlunparse(
6023 urllib
.parse
.urlparse(url
)._replace
(netloc
='www.youtube.com'))
6024 compat_opts
= self
.get_param('compat_opts', [])
6026 mobj
= self
._get
_url
_mobj
(url
)
6027 pre
, tab
, post
, is_channel
= mobj
['pre'], mobj
['tab'], mobj
['post'], not mobj
['not_channel']
6028 if is_channel
and smuggled_data
.get('is_music_url'):
6029 if item_id
[:2] == 'VL': # Youtube music VL channels have an equivalent playlist
6030 return self
.url_result(
6031 f
'https://music.youtube.com/playlist?list={item_id[2:]}', YoutubeTabIE
, item_id
[2:])
6032 elif item_id
[:2] == 'MP': # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
6033 mdata
= self
._extract
_tab
_endpoint
(
6034 f
'https://music.youtube.com/channel/{item_id}', item_id
, default_client
='web_music')
6035 murl
= traverse_obj(mdata
, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
6036 get_all
=False, expected_type
=str)
6038 raise ExtractorError('Failed to resolve album to playlist')
6039 return self
.url_result(murl
, YoutubeTabIE
)
6040 elif mobj
['channel_type'] == 'browse': # Youtube music /browse/ should be changed to /channel/
6041 return self
.url_result(
6042 f
'https://music.youtube.com/channel/{item_id}{tab}{post}', YoutubeTabIE
, item_id
)
6044 original_tab_id
, display_id
= tab
[1:], f
'{item_id}{tab}'
6045 if is_channel
and not tab
and 'no-youtube-channel-redirect' not in compat_opts
:
6046 url
= f
'{pre}/videos{post}'
6048 # Handle both video/playlist URLs
6050 video_id
, playlist_id
= [traverse_obj(qs
, (key
, 0)) for key
in ('v', 'list')]
6051 if not video_id
and mobj
['not_channel'].startswith('watch'):
6053 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
6054 raise ExtractorError('A video URL was given without video ID', expected
=True)
6055 # Common mistake: https://www.youtube.com/watch?list=playlist_id
6056 self
.report_warning(f
'A video URL was given without video ID. Trying to download playlist {playlist_id}')
6057 return self
.url_result(
6058 f
'https://www.youtube.com/playlist?list={playlist_id}', YoutubeTabIE
, playlist_id
)
6060 if not self
._yes
_playlist
(playlist_id
, video_id
):
6061 return self
.url_result(
6062 f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6064 data
, ytcfg
= self
._extract
_data
(url
, display_id
)
6066 # YouTube may provide a non-standard redirect to the regional channel
6067 # See: https://github.com/yt-dlp/yt-dlp/issues/2694
6068 # https://support.google.com/youtube/answer/2976814#zippy=,conditional-redirects
6069 redirect_url
= traverse_obj(
6070 data
, ('onResponseReceivedActions', ..., 'navigateAction', 'endpoint', 'commandMetadata', 'webCommandMetadata', 'url'), get_all
=False)
6071 if redirect_url
and 'no-youtube-channel-redirect' not in compat_opts
:
6072 redirect_url
= ''.join((urljoin('https://www.youtube.com', redirect_url
), tab
, post
))
6073 self
.to_screen(f
'This playlist is likely not available in your region. Following conditional redirect to {redirect_url}')
6074 return self
.url_result(redirect_url
, YoutubeTabIE
)
6076 tabs
, extra_tabs
= self
._extract
_tab
_renderers
(data
), []
6077 if is_channel
and tabs
and 'no-youtube-channel-redirect' not in compat_opts
:
6078 selected_tab
= self
._extract
_selected
_tab
(tabs
)
6079 selected_tab_id
, selected_tab_name
= self
._extract
_tab
_id
_and
_name
(selected_tab
, url
) # NB: Name may be translated
6080 self
.write_debug(f
'Selected tab: {selected_tab_id!r} ({selected_tab_name}), Requested tab: {original_tab_id!r}')
6082 if not original_tab_id
and selected_tab_name
:
6083 self
.to_screen('Downloading all uploads of the channel. '
6084 'To download only the videos in a specific tab, pass the tab\'s URL')
6085 if self
._has
_tab
(tabs
, 'streams'):
6086 extra_tabs
.append(''.join((pre
, '/streams', post
)))
6087 if self
._has
_tab
(tabs
, 'shorts'):
6088 extra_tabs
.append(''.join((pre
, '/shorts', post
)))
6089 # XXX: Members-only tab should also be extracted
6091 if not extra_tabs
and selected_tab_id
!= 'videos':
6092 # Channel does not have streams, shorts or videos tabs
6093 if item_id
[:2] != 'UC':
6094 raise ExtractorError('This channel has no uploads', expected
=True)
6096 # Topic channels don't have /videos. Use the equivalent playlist instead
6097 pl_id
= f
'UU{item_id[2:]}'
6098 pl_url
= f
'https://www.youtube.com/playlist?list={pl_id}'
6100 data
, ytcfg
= self
._extract
_data
(pl_url
, pl_id
, ytcfg
=ytcfg
, fatal
=True, webpage_fatal
=True)
6101 except ExtractorError
:
6102 raise ExtractorError('This channel has no uploads', expected
=True)
6104 item_id
, url
= pl_id
, pl_url
6106 f
'The channel does not have a videos, shorts, or live tab. Redirecting to playlist {pl_id} instead')
6108 elif extra_tabs
and selected_tab_id
!= 'videos':
6109 # When there are shorts/live tabs but not videos tab
6110 url
, data
= f
'{pre}{post}', None
6112 elif (original_tab_id
or 'videos') != selected_tab_id
:
6113 if original_tab_id
== 'live':
6114 # Live tab should have redirected to the video
6115 # Except in the case the channel has an actual live tab
6116 # Example: https://www.youtube.com/channel/UCEH7P7kyJIkS_gJf93VYbmg/live
6117 raise UserNotLive(video_id
=item_id
)
6118 elif selected_tab_name
:
6119 raise ExtractorError(f
'This channel does not have a {original_tab_id} tab', expected
=True)
6121 # For channels such as https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg
6122 url
= f
'{pre}{post}'
6124 # YouTube sometimes provides a button to reload playlist with unavailable videos.
6125 if 'no-youtube-unavailable-videos' not in compat_opts
:
6126 data
= self
._reload
_with
_unavailable
_videos
(display_id
, data
, ytcfg
) or data
6127 self
._extract
_and
_report
_alerts
(data
, only_once
=True)
6129 tabs
, entries
= self
._extract
_tab
_renderers
(data
), []
6131 entries
= [self
._extract
_from
_tabs
(item_id
, ytcfg
, data
, tabs
)]
6133 'extractor_key': YoutubeTabIE
.ie_key(),
6134 'extractor': YoutubeTabIE
.IE_NAME
,
6137 if self
.get_param('playlist_items') == '0':
6138 entries
.extend(self
.url_result(u
, YoutubeTabIE
) for u
in extra_tabs
)
6139 else: # Users expect to get all `video_id`s even with `--flat-playlist`. So don't return `url_result`
6140 entries
.extend(map(self
._real
_extract
, extra_tabs
))
6142 if len(entries
) == 1:
6145 metadata
= self
._extract
_metadata
_from
_tabs
(item_id
, data
)
6146 uploads_url
= 'the Uploads (UU) playlist URL'
6147 if try_get(metadata
, lambda x
: x
['channel_id'].startswith('UC')):
6148 uploads_url
= f
'https://www.youtube.com/playlist?list=UU{metadata["channel_id"][2:]}'
6150 'Downloading as multiple playlists, separated by tabs. '
6151 f
'To download as a single playlist instead, pass {uploads_url}')
6152 return self
.playlist_result(entries
, item_id
, **metadata
)
6155 playlist
= traverse_obj(
6156 data
, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type
=dict)
6158 return self
._extract
_from
_playlist
(item_id
, url
, data
, playlist
, ytcfg
)
6160 video_id
= traverse_obj(
6161 data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str) or video_id
6163 if tab
!= '/live': # live tab is expected to redirect to video
6164 self
.report_warning(f
'Unable to recognize playlist. Downloading just video {video_id}')
6165 return self
.url_result(f
'https://www.youtube.com/watch?v={video_id}', YoutubeIE
, video_id
)
6167 raise ExtractorError('Unable to recognize tab page')
6170 class YoutubePlaylistIE(InfoExtractor
):
6171 IE_DESC
= 'YouTube playlists'
6172 _VALID_URL
= r
'''(?x)(?:
6177 youtube(?:kids)?\.com|
6182 (?P<id>%(playlist_id)s)
6184 'playlist_id': YoutubeBaseInfoExtractor
._PLAYLIST
_ID
_RE
,
6185 'invidious': '|'.join(YoutubeBaseInfoExtractor
._INVIDIOUS
_SITES
),
6187 IE_NAME
= 'youtube:playlist'
6189 'note': 'issue #673',
6190 'url': 'PLBB231211A4F62143',
6192 'title': '[OLD]Team Fortress 2 (Class-based LP)',
6193 'id': 'PLBB231211A4F62143',
6194 'uploader': 'Wickman',
6195 'uploader_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6196 'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
6198 'uploader_url': 'https://www.youtube.com/c/WickmanVT',
6199 'modified_date': r
're:\d{8}',
6200 'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
6201 'channel': 'Wickman',
6203 'channel_url': 'https://www.youtube.com/c/WickmanVT',
6204 'availability': 'public',
6206 'playlist_mincount': 29,
6208 'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6210 'title': 'YDL_safe_search',
6211 'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
6213 'playlist_count': 2,
6214 'skip': 'This playlist is private',
6217 'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6218 'playlist_count': 4,
6221 'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
6222 'uploader': 'milan',
6223 'uploader_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6225 'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6227 'modified_date': '20140919',
6230 'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
6231 'uploader_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
6232 'availability': 'public',
6234 'expected_warnings': [r
'[Uu]navailable videos? (is|are|will be) hidden'],
6236 'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6237 'playlist_mincount': 455,
6239 'title': '2018 Chinese New Singles (11/6 updated)',
6240 'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
6242 'uploader_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6243 'description': 'md5:da521864744d60a198e3a88af4db0d9d',
6246 'channel_url': 'https://www.youtube.com/c/愛低音的國王',
6248 'uploader_url': 'https://www.youtube.com/c/愛低音的國王',
6249 'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
6250 'modified_date': r
're:\d{8}',
6251 'availability': 'public',
6253 'expected_warnings': [r
'[Uu]navailable videos (are|will be) hidden'],
6255 'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
6256 'only_matching': True,
6258 # music album playlist
6259 'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
6260 'only_matching': True,
6264 def suitable(cls
, url
):
6265 if YoutubeTabIE
.suitable(url
):
6267 from ..utils
import parse_qs
6269 if qs
.get('v', [None])[0]:
6271 return super().suitable(url
)
6273 def _real_extract(self
, url
):
6274 playlist_id
= self
._match
_id
(url
)
6275 is_music_url
= YoutubeBaseInfoExtractor
.is_music_url(url
)
6276 url
= update_url_query(
6277 'https://www.youtube.com/playlist',
6278 parse_qs(url
) or {'list': playlist_id}
)
6280 url
= smuggle_url(url
, {'is_music_url': True}
)
6281 return self
.url_result(url
, ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6284 class YoutubeYtBeIE(InfoExtractor
):
6285 IE_DESC
= 'youtu.be'
6286 _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}
6288 'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
6290 'id': 'yeWKywCrFtk',
6292 'title': 'Small Scale Baler and Braiding Rugs',
6293 'uploader': 'Backus-Page House Museum',
6294 'uploader_id': 'backuspagemuseum',
6295 'uploader_url': r
're:https?://(?:www\.)?youtube\.com/user/backuspagemuseum',
6296 'upload_date': '20161008',
6297 'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
6298 'categories': ['Nonprofits & Activism'],
6302 'playable_in_embed': True,
6303 'thumbnail': 'https://i.ytimg.com/vi_webp/yeWKywCrFtk/maxresdefault.webp',
6304 'channel': 'Backus-Page House Museum',
6305 'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
6306 'live_status': 'not_live',
6308 'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
6309 'availability': 'public',
6311 'comment_count': int,
6312 'channel_follower_count': int
6316 'skip_download': True,
6319 'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
6320 'only_matching': True,
6323 def _real_extract(self
, url
):
6324 mobj
= self
._match
_valid
_url
(url
)
6325 video_id
= mobj
.group('id')
6326 playlist_id
= mobj
.group('playlist_id')
6327 return self
.url_result(
6328 update_url_query('https://www.youtube.com/watch', {
6330 'list': playlist_id
,
6331 'feature': 'youtu.be',
6332 }), ie
=YoutubeTabIE
.ie_key(), video_id
=playlist_id
)
6335 class YoutubeLivestreamEmbedIE(InfoExtractor
):
6336 IE_DESC
= 'YouTube livestream embeds'
6337 _VALID_URL
= r
'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
6339 'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
6340 'only_matching': True,
6343 def _real_extract(self
, url
):
6344 channel_id
= self
._match
_id
(url
)
6345 return self
.url_result(
6346 f
'https://www.youtube.com/channel/{channel_id}/live',
6347 ie
=YoutubeTabIE
.ie_key(), video_id
=channel_id
)
6350 class YoutubeYtUserIE(InfoExtractor
):
6351 IE_DESC
= 'YouTube user videos; "ytuser:" prefix'
6352 IE_NAME
= 'youtube:user'
6353 _VALID_URL
= r
'ytuser:(?P<id>.+)'
6355 'url': 'ytuser:phihag',
6356 'only_matching': True,
6359 def _real_extract(self
, url
):
6360 user_id
= self
._match
_id
(url
)
6361 return self
.url_result(f
'https://www.youtube.com/user/{user_id}', YoutubeTabIE
, user_id
)
6364 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor
):
6365 IE_NAME
= 'youtube:favorites'
6366 IE_DESC
= 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
6367 _VALID_URL
= r
':ytfav(?:ou?rite)?s?'
6368 _LOGIN_REQUIRED
= True
6371 'only_matching': True,
6373 'url': ':ytfavorites',
6374 'only_matching': True,
6377 def _real_extract(self
, url
):
6378 return self
.url_result(
6379 'https://www.youtube.com/playlist?list=LL',
6380 ie
=YoutubeTabIE
.ie_key())
6383 class YoutubeNotificationsIE(YoutubeTabBaseInfoExtractor
):
6384 IE_NAME
= 'youtube:notif'
6385 IE_DESC
= 'YouTube notifications; ":ytnotif" keyword (requires cookies)'
6386 _VALID_URL
= r
':ytnotif(?:ication)?s?'
6387 _LOGIN_REQUIRED
= True
6390 'only_matching': True,
6392 'url': ':ytnotifications',
6393 'only_matching': True,
6396 def _extract_notification_menu(self
, response
, continuation_list
):
6397 notification_list
= traverse_obj(
6399 ('actions', 0, 'openPopupAction', 'popup', 'multiPageMenuRenderer', 'sections', 0, 'multiPageMenuNotificationSectionRenderer', 'items'),
6400 ('actions', 0, 'appendContinuationItemsAction', 'continuationItems'),
6401 expected_type
=list) or []
6402 continuation_list
[0] = None
6403 for item
in notification_list
:
6404 entry
= self
._extract
_notification
_renderer
(item
.get('notificationRenderer'))
6407 continuation
= item
.get('continuationItemRenderer')
6409 continuation_list
[0] = continuation
6411 def _extract_notification_renderer(self
, notification
):
6412 video_id
= traverse_obj(
6413 notification
, ('navigationEndpoint', 'watchEndpoint', 'videoId'), expected_type
=str)
6414 url
= f
'https://www.youtube.com/watch?v={video_id}'
6417 browse_ep
= traverse_obj(
6418 notification
, ('navigationEndpoint', 'browseEndpoint'), expected_type
=dict)
6419 channel_id
= traverse_obj(browse_ep
, 'browseId', expected_type
=str)
6420 post_id
= self
._search
_regex
(
6421 r
'/post/(.+)', traverse_obj(browse_ep
, 'canonicalBaseUrl', expected_type
=str),
6422 'post id', default
=None)
6423 if not channel_id
or not post_id
:
6425 # The direct /post url redirects to this in the browser
6426 url
= f
'https://www.youtube.com/channel/{channel_id}/community?lb={post_id}'
6428 channel
= traverse_obj(
6429 notification
, ('contextualMenu', 'menuRenderer', 'items', 1, 'menuServiceItemRenderer', 'text', 'runs', 1, 'text'),
6431 notification_title
= self
._get
_text
(notification
, 'shortMessage')
6432 if notification_title
:
6433 notification_title
= notification_title
.replace('\xad', '') # remove soft hyphens
6434 # TODO: handle recommended videos
6435 title
= self
._search
_regex
(
6436 rf
'{re.escape(channel or "")}[^:]+: (.+)', notification_title
,
6437 'video title', default
=None)
6438 timestamp
= (self
._parse
_time
_text
(self
._get
_text
(notification
, 'sentTimeText'))
6439 if self
._configuration
_arg
('approximate_date', ie_key
=YoutubeTabIE
)
6444 'ie_key': (YoutubeIE
if video_id
else YoutubeTabIE
).ie_key(),
6445 'video_id': video_id
,
6447 'channel_id': channel_id
,
6449 'thumbnails': self
._extract
_thumbnails
(notification
, 'videoThumbnail'),
6450 'timestamp': timestamp
,
6453 def _notification_menu_entries(self
, ytcfg
):
6454 continuation_list
= [None]
6456 for page
in itertools
.count(1):
6457 ctoken
= traverse_obj(
6458 continuation_list
, (0, 'continuationEndpoint', 'getNotificationMenuEndpoint', 'ctoken'), expected_type
=str)
6459 response
= self
._extract
_response
(
6460 item_id
=f
'page {page}', query
={'ctoken': ctoken}
if ctoken
else {}, ytcfg
=ytcfg
,
6461 ep
='notification/get_notification_menu', check_get_keys
='actions',
6462 headers
=self
.generate_api_headers(ytcfg
=ytcfg
, visitor_data
=self
._extract
_visitor
_data
(response
)))
6463 yield from self
._extract
_notification
_menu
(response
, continuation_list
)
6464 if not continuation_list
[0]:
6467 def _real_extract(self
, url
):
6468 display_id
= 'notifications'
6469 ytcfg
= self
._download
_ytcfg
('web', display_id
) if not self
.skip_webpage
else {}
6470 self
._report
_playlist
_authcheck
(ytcfg
)
6471 return self
.playlist_result(self
._notification
_menu
_entries
(ytcfg
), display_id
, display_id
)
6474 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6475 IE_DESC
= 'YouTube search'
6476 IE_NAME
= 'youtube:search'
6477 _SEARCH_KEY
= 'ytsearch'
6478 _SEARCH_PARAMS
= 'EgIQAQ%3D%3D' # Videos only
6480 'url': 'ytsearch5:youtube-dl test video',
6481 'playlist_count': 5,
6483 'id': 'youtube-dl test video',
6484 'title': 'youtube-dl test video',
6489 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor
, SearchInfoExtractor
):
6490 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ ':date'
6491 _SEARCH_KEY
= 'ytsearchdate'
6492 IE_DESC
= 'YouTube search, newest videos first'
6493 _SEARCH_PARAMS
= 'CAISAhAB' # Videos only, sorted by date
6495 'url': 'ytsearchdate5:youtube-dl test video',
6496 'playlist_count': 5,
6498 'id': 'youtube-dl test video',
6499 'title': 'youtube-dl test video',
6504 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor
):
6505 IE_DESC
= 'YouTube search URLs with sorting and filter support'
6506 IE_NAME
= YoutubeSearchIE
.IE_NAME
+ '_url'
6507 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6509 'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
6510 'playlist_mincount': 5,
6512 'id': 'youtube-dl test video',
6513 'title': 'youtube-dl test video',
6516 'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
6517 'playlist_mincount': 5,
6523 'url': 'https://www.youtube.com/results?search_query=%23cats',
6524 'playlist_mincount': 1,
6528 # The test suite does not have support for nested playlists
6530 # 'url': r're:https://(www\.)?youtube\.com/hashtag/cats',
6535 'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
6536 'only_matching': True,
6539 def _real_extract(self
, url
):
6541 query
= (qs
.get('search_query') or qs
.get('q'))[0]
6542 return self
.playlist_result(self
._search
_results
(query
, qs
.get('sp', (None,))[0]), query
, query
)
6545 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor
):
6546 IE_DESC
= 'YouTube music search URLs with selectable sections, e.g. #songs'
6547 IE_NAME
= 'youtube:music:search_url'
6548 _VALID_URL
= r
'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
6550 'url': 'https://music.youtube.com/search?q=royalty+free+music',
6551 'playlist_count': 16,
6553 'id': 'royalty free music',
6554 'title': 'royalty free music',
6557 'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
6558 'playlist_mincount': 30,
6560 'id': 'royalty free music - songs',
6561 'title': 'royalty free music - songs',
6563 'params': {'extract_flat': 'in_playlist'}
6565 'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
6566 'playlist_mincount': 30,
6568 'id': 'royalty free music - community playlists',
6569 'title': 'royalty free music - community playlists',
6571 'params': {'extract_flat': 'in_playlist'}
6575 'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
6576 'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
6577 'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
6578 'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
6579 'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
6580 'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
6583 def _real_extract(self
, url
):
6585 query
= (qs
.get('search_query') or qs
.get('q'))[0]
6586 params
= qs
.get('sp', (None,))[0]
6588 section
= next((k
for k
, v
in self
._SECTIONS
.items() if v
== params
), params
)
6590 section
= urllib
.parse
.unquote_plus((url
.split('#') + [''])[1]).lower()
6591 params
= self
._SECTIONS
.get(section
)
6594 title
= join_nonempty(query
, section
, delim
=' - ')
6595 return self
.playlist_result(self
._search
_results
(query
, params
, default_client
='web_music'), title
, title
)
6598 class YoutubeFeedsInfoExtractor(InfoExtractor
):
6600 Base class for feed extractors
6601 Subclasses must re-define the _FEED_NAME property.
6603 _LOGIN_REQUIRED
= True
6604 _FEED_NAME
= 'feeds'
6606 def _real_initialize(self
):
6607 YoutubeBaseInfoExtractor
._check
_login
_required
(self
)
6611 return f
'youtube:{self._FEED_NAME}'
6613 def _real_extract(self
, url
):
6614 return self
.url_result(
6615 f
'https://www.youtube.com/feed/{self._FEED_NAME}', ie
=YoutubeTabIE
.ie_key())
6618 class YoutubeWatchLaterIE(InfoExtractor
):
6619 IE_NAME
= 'youtube:watchlater'
6620 IE_DESC
= 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
6621 _VALID_URL
= r
':ytwatchlater'
6623 'url': ':ytwatchlater',
6624 'only_matching': True,
6627 def _real_extract(self
, url
):
6628 return self
.url_result(
6629 'https://www.youtube.com/playlist?list=WL', ie
=YoutubeTabIE
.ie_key())
6632 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor
):
6633 IE_DESC
= 'YouTube recommended videos; ":ytrec" keyword'
6634 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
6635 _FEED_NAME
= 'recommended'
6636 _LOGIN_REQUIRED
= False
6639 'only_matching': True,
6641 'url': ':ytrecommended',
6642 'only_matching': True,
6644 'url': 'https://youtube.com',
6645 'only_matching': True,
6649 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor
):
6650 IE_DESC
= 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
6651 _VALID_URL
= r
':ytsub(?:scription)?s?'
6652 _FEED_NAME
= 'subscriptions'
6655 'only_matching': True,
6657 'url': ':ytsubscriptions',
6658 'only_matching': True,
6662 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor
):
6663 IE_DESC
= 'Youtube watch history; ":ythis" keyword (requires cookies)'
6664 _VALID_URL
= r
':ythis(?:tory)?'
6665 _FEED_NAME
= 'history'
6667 'url': ':ythistory',
6668 'only_matching': True,
6672 class YoutubeStoriesIE(InfoExtractor
):
6673 IE_DESC
= 'YouTube channel stories; "ytstories:" prefix'
6674 IE_NAME
= 'youtube:stories'
6675 _VALID_URL
= r
'ytstories:UC(?P<id>[A-Za-z0-9_-]{21}[AQgw])$'
6677 'url': 'ytstories:UCwFCb4jeqaKWnciAYM-ZVHg',
6678 'only_matching': True,
6681 def _real_extract(self
, url
):
6682 playlist_id
= f
'RLTD{self._match_id(url)}'
6683 return self
.url_result(
6684 smuggle_url(f
'https://www.youtube.com/playlist?list={playlist_id}&playnext=1', {'is_story': True}
),
6685 ie
=YoutubeTabIE
, video_id
=playlist_id
)
6688 class YoutubeShortsAudioPivotIE(InfoExtractor
):
6689 IE_DESC
= 'YouTube Shorts audio pivot (Shorts using audio of a given video)'
6690 IE_NAME
= 'youtube:shorts:pivot:audio'
6691 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/source/(?P<id>[\w-]{11})/shorts'
6693 'url': 'https://www.youtube.com/source/Lyj-MZSAA9o/shorts',
6694 'only_matching': True,
6698 def _generate_audio_pivot_params(video_id
):
6700 Generates sfv_audio_pivot browse params for this video id
6702 pb_params
= b
'\xf2\x05+\n)\x12\'\n\x0b%b\x12\x0b%b\x1a\x0b%b' % ((video_id
.encode(),) * 3)
6703 return urllib
.parse
.quote(base64
.b64encode(pb_params
).decode())
6705 def _real_extract(self
, url
):
6706 video_id
= self
._match
_id
(url
)
6707 return self
.url_result(
6708 f
'https://www.youtube.com/feed/sfv_audio_pivot?bp={self._generate_audio_pivot_params(video_id)}',
6712 class YoutubeTruncatedURLIE(InfoExtractor
):
6713 IE_NAME
= 'youtube:truncated_url'
6714 IE_DESC
= False # Do not list
6715 _VALID_URL
= r
'''(?x)
6717 (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
6720 annotation_id=annotation_[^&]+|
6726 attribution_link\?a=[^&]+
6732 'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
6733 'only_matching': True,
6735 'url': 'https://www.youtube.com/watch?',
6736 'only_matching': True,
6738 'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
6739 'only_matching': True,
6741 'url': 'https://www.youtube.com/watch?feature=foo',
6742 'only_matching': True,
6744 'url': 'https://www.youtube.com/watch?hl=en-GB',
6745 'only_matching': True,
6747 'url': 'https://www.youtube.com/watch?t=2372',
6748 'only_matching': True,
6751 def _real_extract(self
, url
):
6752 raise ExtractorError(
6753 'Did you forget to quote the URL? Remember that & is a meta '
6754 'character in most shells, so you want to put the URL in quotes, '
6756 '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
6757 ' or simply youtube-dl BaW_jenozKc .',
6761 class YoutubeClipIE(YoutubeTabBaseInfoExtractor
):
6762 IE_NAME
= 'youtube:clip'
6763 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/clip/(?P<id>[^/?#]+)'
6765 # FIXME: Other metadata should be extracted from the clip, not from the base video
6766 'url': 'https://www.youtube.com/clip/UgytZKpehg-hEMBSn3F4AaABCQ',
6768 'id': 'UgytZKpehg-hEMBSn3F4AaABCQ',
6770 'section_start': 29.0,
6771 'section_end': 39.7,
6774 'availability': 'public',
6775 'categories': ['Gaming'],
6776 'channel': 'Scott The Woz',
6777 'channel_id': 'UC4rqhyiTs7XyuODcECvuiiQ',
6778 'channel_url': 'https://www.youtube.com/channel/UC4rqhyiTs7XyuODcECvuiiQ',
6779 'description': 'md5:7a4517a17ea9b4bd98996399d8bb36e7',
6781 'playable_in_embed': True,
6783 'thumbnail': 'https://i.ytimg.com/vi_webp/ScPX26pdQik/maxresdefault.webp',
6784 'title': 'Mobile Games on Console - Scott The Woz',
6785 'upload_date': '20210920',
6786 'uploader': 'Scott The Woz',
6787 'uploader_id': 'scottthewoz',
6788 'uploader_url': 'http://www.youtube.com/user/scottthewoz',
6790 'live_status': 'not_live',
6791 'channel_follower_count': int
6795 def _real_extract(self
, url
):
6796 clip_id
= self
._match
_id
(url
)
6797 _
, data
= self
._extract
_webpage
(url
, clip_id
)
6799 video_id
= traverse_obj(data
, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'))
6801 raise ExtractorError('Unable to find video ID')
6803 clip_data
= traverse_obj(data
, (
6804 'engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'clipSectionRenderer',
6805 'contents', ..., 'clipAttributionRenderer', 'onScrubExit', 'commandExecutorCommand', 'commands', ...,
6806 'openPopupAction', 'popup', 'notificationActionRenderer', 'actionButton', 'buttonRenderer', 'command',
6807 'commandExecutorCommand', 'commands', ..., 'loopCommand'), get_all
=False)
6810 '_type': 'url_transparent',
6811 'url': f
'https://www.youtube.com/watch?v={video_id}',
6812 'ie_key': YoutubeIE
.ie_key(),
6814 'section_start': int(clip_data
['startTimeMs']) / 1000,
6815 'section_end': int(clip_data
['endTimeMs']) / 1000,
6819 class YoutubeTruncatedIDIE(InfoExtractor
):
6820 IE_NAME
= 'youtube:truncated_id'
6821 IE_DESC
= False # Do not list
6822 _VALID_URL
= r
'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
6825 'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
6826 'only_matching': True,
6829 def _real_extract(self
, url
):
6830 video_id
= self
._match
_id
(url
)
6831 raise ExtractorError(
6832 f
'Incomplete YouTube ID {video_id}. URL {url} looks truncated.',