☰

Auto Skip YouTube Ads @ Gurveer

Automatically skip YouTube ads instantly with minimal detection risk. Features configurable settings, update notifications, robust error handling, and fixes for mute state restoration.

  1. // ==UserScript==
  2. // @name               Auto Skip YouTube Ads @ Gurveer
  3. // @name:ar            تخطي إعلانات YouTube تلقائيًا @ Gurveer
  4. // @name:bg            Пропускане на YouTube-реклами
  5. // @name:es            Saltar Automáticamente Anuncios De YouTube @ Gurveer
  6. // @name:fr            Ignorer Automatiquement Les Publicités YouTube
  7. // @name:hi            YouTube विज्ञापन स्वचालित रूप से छोड़ें
  8. // @name:id            Lewati Otomatis Iklan YouTube
  9. // @name:ja            YouTube 広告を自動スキップ
  10. // @name:ko            YouTube 광고 자동 건너뛰기
  11. // @name:nl            YouTube-Advertenties Automatisch Overslaan
  12. // @name:pt-BR         Pular Automaticamente Anúncios Do YouTube
  13. // @name:ru            Автоматический Пропуск Рекламы На YouTube
  14. // @name:vi            Tự Động Bỏ Qua Quảng Cáo YouTube
  15. // @name:zh-CN         自动跳过 YouTube 广告
  16. // @name:zh-TW         自動跳過 YouTube 廣告
  17. // @namespace          https://github.com/gurr-i/browser-scripts
  18. // @version            8.0.1
  19. // @description        Automatically skip YouTube ads instantly with minimal detection risk. Features configurable settings, update notifications, robust error handling, and fixes for mute state restoration.
  20. // @description:bg        Automatically skip YouTube ads instantly with minimal detection risk. Features configurable settings, update notifications, robust error handling, and fixes for mute state restoration.
  21. // @description:en        Automatically skip YouTube ads instantly with minimal detection risk. Features configurable settings, update notifications, robust error handling, and fixes for mute state restoration.
  22. // @description:ar     تخطي إعلانات YouTube تلقائيًا على الفور مع الحد الأدنى من مخاطر الكشف. يتضمن إعدادات قابلة للتخصيص، إشعارات التحديث، ومعالجة قوية للأخطاء، وإصلاحات لاستعادة حالة كتم الصوت.
  23. // @description:es     Omite automáticamente los anuncios de YouTube al instante con un riesgo mínimo de detección. Incluye configuraciones personalizables, notificaciones de actualización, manejo robusto de errores y correcciones para la restauración del estado de silencio.
  24. // @description:fr     Ignorez automatiquement et instantanément les publicités YouTube avec un risque minimal de détection. Comprend des paramètres configurables, des notifications de mise à jour, une gestion robuste des erreurs et des corrections pour la restauration de l'état muet.
  25. // @description:hi     YouTube विज्ञापनों को तुरंत स्वचालित रूप से छोड़ दें, जिसमें न्यूनतम पता लगाने का जोखिम हो। इसमें कॉन्फ़िगर करने योग्य सेटिंग्स, अपडेट सूचनाएं, मजबूत त्रुटि हैंडलिंग और म्यूट स्थिति बहाली के लिए सुधार शामिल हैं।
  26. // @description:id     Lewati iklan YouTube secara otomatis secara instan dengan risiko deteksi minimal. Termasuk pengaturan yang dapat dikonfigurasi, pemberitahuan pembaruan, penanganan kesalahan yang kuat, dan perbaikan untuk pemulihan status bisu.
  27. // @description:ja     YouTube 広告を即座に自動的にスキップし、検出リスクを最小限に抑えます。カスタマイズ可能な設定、更新通知、堅牢なエラーハンドリング、ミュート状態の復元修正を備えています。
  28. // @description:ko     YouTube 광고를 즉시 자동으로 건너뛰며 탐지 위험이 최소화됩니다。구성 가능한 설정, 업데이트 알림, 강력한 오류 처리 및 음소거 상태 복원 수정이 포함됩니다.
  29. // @description:nl     Sla YouTube-advertenties direct automatisch over met minimaal detectierisico. Bevat configureerbare instellingen, updatemeldingen, robuuste foutafhandeling en fixes voor het herstellen van de mute-status.
  30. // @description:pt-BR  Pule anúncios do YouTube instantaneamente com risco mínimo de detecção. Inclui configurações personalizáveis, notificações de atualização, tratamento robusto de erros e correções para restauração do estado de mudo.
  31. // @description:ru     Автоматически пропускать рекламу YouTube мгновенно с минимальным риском обнаружения. Включает настраиваемые параметры, уведомления об обновлениях, надежную обработку ошибок и исправления для восстановления состояния звука.
  32. // @description:vi     Tự động bỏ qua quảng cáo YouTube ngay lập tức với rủi ro phát hiện tối thiểu. Bao gồm cài đặt có thể tùy chỉnh, thông báo cập nhật, xử lý lỗi mạnh mẽ và sửa lỗi cho việc khôi phục trạng thái tắt tiếng.
  33. // @description:zh-CN  立即自动跳过 YouTube 广告，检测风险最小。包括可配置设置、更新通知、强大的错误处理和修复静音状态恢复。
  34. // @description:zh-TW  立即自動跳過 YouTube 廣告，偵測風險極低。包括可配置設定、更新通知、強大的錯誤處理和修復靜音狀態恢復。
  35. // @author             Gurveer
  36. // @icon               https://raw.githubusercontent.com/gurr-i/browser-scripts/main/assets/icons/youtube-ads-skipper.png
  37. // @match              https://www.youtube.com/*
  38. // @match              https://m.youtube.com/*
  39. // @match              https://music.youtube.com/*
  40. // @exclude            https://studio.youtube.com/*
  41. // @grant              none
  42. // @license            MIT
  43. // @compatible         firefox
  44. // @compatible         chrome
  45. // @compatible         opera
  46. // @compatible         safari
  47. // @compatible         edge
  48. // @noframes
  49. // @homepage           https://github.com/gurr-i/browser-scripts/tree/main/scripts/Auto-Skip-YouTube-Ads
  50. // ==/UserScript==
  51.  
  52. (function () {
  53.     'use strict';
  54.   
  55.     // Configuration settings with UI controls and selectors
  56.     const defaultConfig = {
  57.       debug: false,
  58.       updateCheckInterval: 24 * 60 * 60 * 1000,
  59.       maxRetries: 3,
  60.       retryDelay: 1000,
  61.       randomizationDelay: 200,
  62.       aggressiveAdRemoval: true,
  63.       skipOverlayAds: true,
  64.       skipVideoAds: true,
  65.       muteAds: true,
  66.       autoUpdateCheck: true,
  67.       selectors: {
  68.         adShowing: '.ad-showing, .ytp-ad-player-overlay',
  69.         pieCountdown: '.ytp-ad-timed-pie-countdown-container, .ytp-ad-duration-remaining',
  70.         surveyQuestions: '.ytp-ad-survey-questions, .ytp-ad-survey-interstitial',
  71.         player: '#ytd-player, #movie_player',
  72.         mobilePlayer: '#movie_player, #player-container-id',
  73.         adVideo: '#ytd-player video.html5-main-video, #song-video video.html5-main-video, .video-stream.html5-main-video',
  74.         skipButton: '.ytp-ad-skip-button, .ytp-ad-skip-button-modern',
  75.         muteButton: '.ytp-mute-button',
  76.         ads: [
  77.           '#player-ads',
  78.           '#panels > ytd-engagement-panel-section-list-renderer[target-id="engagement-panel-ads"]',
  79.           '#masthead-ad',
  80.           '.yt-mealbar-promo-renderer',
  81.           '.ytp-ad-overlay-container',
  82.           '.ytp-ad-overlay-slot',
  83.           '.ytp-ad-text-overlay',
  84.           '.ytp-ad-preview-text-overlay',
  85.           '.ytp-ad-preview-container',
  86.           '.video-ads.ytp-ad-module',
  87.           '.ytp-featured-product',
  88.           'ytd-merch-shelf-renderer',
  89.           'ytmusic-mealbar-promo-renderer',
  90.           'ytmusic-statement-banner-renderer',
  91.           '.ytd-promoted-sparkles-web-renderer',
  92.           '.ytd-display-ad-renderer',
  93.           '.ytd-statement-banner-renderer',
  94.           '.ytd-in-feed-ad-layout-renderer',
  95.         ],
  96.         adElements: [
  97.           ['ytd-reel-video-renderer', '.ytd-ad-slot-renderer'],
  98.           ['tp-yt-paper-dialog', '#feedback.ytd-enforcement-message-view-model'],
  99.           ['tp-yt-paper-dialog', ':scope > ytd-checkbox-survey-renderer'],
  100.           ['tp-yt-paper-dialog', ':scope > ytd-single-option-survey-renderer'],
  101.         ],
  102.       },
  103.       githubRepo: 'https://github.com/gurr-i/browser-scripts',
  104.     };
  105.   
  106.     // Load saved configuration or use defaults
  107.     const config = {
  108.       ...defaultConfig,
  109.       ...JSON.parse(localStorage.getItem('AutoSkipYouTubeAds_Config') || '{}'),
  110.     };
  111.   
  112.     // UI Module for settings
  113.     const settingsUI = {
  114.       createSettingsPanel() {
  115.         const panel = document.createElement('div');
  116.         panel.className = 'auto-skip-settings';
  117.         panel.style.cssText =
  118.           'position:fixed;top:10px;right:10px;background:#fff;padding:10px;border-radius:5px;box-shadow:0 2px 10px rgba(0,0,0,0.1);z-index:9999;display:none;';
  119.   
  120.         const title = document.createElement('h3');
  121.         title.textContent = 'Auto Skip Settings';
  122.         title.style.margin = '0 0 10px';
  123.         panel.appendChild(title);
  124.   
  125.         const settings = [
  126.           { key: 'debug', label: 'Debug Mode', type: 'checkbox' },
  127.           { key: 'skipOverlayAds', label: 'Skip Overlay Ads', type: 'checkbox' },
  128.           { key: 'skipVideoAds', label: 'Skip Video Ads', type: 'checkbox' },
  129.           { key: 'muteAds', label: 'Mute Ads', type: 'checkbox' },
  130.           { key: 'aggressiveAdRemoval', label: 'Aggressive Ad Removal', type: 'checkbox' },
  131.           { key: 'autoUpdateCheck', label: 'Auto Update Check', type: 'checkbox' },
  132.         ];
  133.   
  134.         settings.forEach((setting) => {
  135.           const container = document.createElement('div');
  136.           container.style.marginBottom = '5px';
  137.   
  138.           const input = document.createElement('input');
  139.           input.type = setting.type;
  140.           input.id = `auto-skip-${setting.key}`;
  141.           input.checked = config[setting.key];
  142.           input.addEventListener('change', () => {
  143.             config[setting.key] = input.checked;
  144.             localStorage.setItem('AutoSkipYouTubeAds_Config', JSON.stringify(config));
  145.           });
  146.   
  147.           const label = document.createElement('label');
  148.           label.htmlFor = input.id;
  149.           label.textContent = setting.label;
  150.           label.style.marginLeft = '5px';
  151.   
  152.           container.appendChild(input);
  153.           container.appendChild(label);
  154.           panel.appendChild(container);
  155.         });
  156.   
  157.         document.body.appendChild(panel);
  158.         return panel;
  159.       },
  160.   
  161.       init() {
  162.         const panel = this.createSettingsPanel();
  163.         const toggleBtn = document.createElement('button');
  164.         toggleBtn.textContent = '⚙️';
  165.         toggleBtn.style.cssText =
  166.           'position:fixed;top:10px;right:10px;z-index:9999;background:none;border:none;font-size:20px;cursor:pointer;';
  167.         toggleBtn.addEventListener('click', () => {
  168.           panel.style.display = panel.style.display === 'none' ? 'block' : 'none';
  169.         });
  170.         document.body.appendChild(toggleBtn);
  171.       },
  172.     };
  173.   
  174.     // Environment detection
  175.     const isYouTubeMobile = location.hostname === 'm.youtube.com';
  176.     const isYouTubeMusic = location.hostname === 'music.youtube.com';
  177.     const isYouTubeVideo = !isYouTubeMusic;
  178.   
  179.     // Utility module
  180.     const utils = {
  181.       log(...args) {
  182.         if (config.debug) console.log('[AutoSkipYouTubeAds]', ...args);
  183.       },
  184.       getCurrentTimeString() {
  185.         return new Date().toTimeString().split(' ', 1)[0];
  186.       },
  187.       checkIsYouTubeShorts() {
  188.         return location.pathname.startsWith('/shorts/');
  189.       },
  190.       randomDelay(max = config.randomizationDelay) {
  191.         return Math.random() * max;
  192.       },
  193.       async sleep(ms) {
  194.         return new Promise((resolve) => setTimeout(resolve, ms));
  195.       },
  196.     };
  197.   
  198.     // Ad hiding module
  199.     const adHider = {
  200.       addCss() {
  201.         const validSelectors = config.selectors.ads.filter((selector) =>
  202.           /^[a-zA-Z0-9\-#.>[\]=:,\s]+$/.test(selector)
  203.         );
  204.         if (!validSelectors.length) return;
  205.         const css = `${validSelectors.join(',')} { display: none !important; }`;
  206.         const style = document.createElement('style');
  207.         style.textContent = css;
  208.         document.head.appendChild(style);
  209.         utils.log('CSS styles applied for ad hiding');
  210.       },
  211.       removeAdElements() {
  212.         try {
  213.           if (!config.aggressiveAdRemoval) return;
  214.           for (const [parentSelector, childSelector] of config.selectors.adElements) {
  215.             const parent = document.querySelector(parentSelector);
  216.             if (!parent) continue;
  217.             const child = parent.querySelector(childSelector);
  218.             if (!child) continue;
  219.             parent.remove();
  220.             utils.log(`Removed ad element: ${parentSelector} > ${childSelector}`);
  221.           }
  222.         } catch (error) {
  223.           console.error('Error removing ad elements:', error);
  224.         }
  225.       },
  226.     };
  227.   
  228.     // Ad skipping module with enhanced mute state handling
  229.     const adSkipper = {
  230.       wasVideoMuted: null, // Store original mute state (null if not set)
  231.   
  232.       async restoreMuteState(player) {
  233.         try {
  234.           if (this.wasVideoMuted === null) return; // No mute state to restore
  235.           const isMuted = player.isMuted?.() ?? false;
  236.           if (isMuted !== this.wasVideoMuted) {
  237.             if (this.wasVideoMuted) {
  238.               player.mute?.();
  239.             } else {
  240.               player.unMute?.();
  241.             }
  242.             utils.log(`Restored mute state to: ${this.wasVideoMuted ? 'muted' : 'unmuted'}`);
  243.           }
  244.         } catch (error) {
  245.           console.error('Error restoring mute state:', error);
  246.         }
  247.       },
  248.   
  249.       async skipAd(retryCount = 0) {
  250.         try {
  251.           if (utils.checkIsYouTubeShorts()) return;
  252.   
  253.           const adShowing = document.querySelector(config.selectors.adShowing);
  254.           const pieCountdown = document.querySelector(config.selectors.pieCountdown);
  255.           const surveyQuestions = document.querySelector(config.selectors.surveyQuestions);
  256.           const skipButton = document.querySelector(config.selectors.skipButton);
  257.   
  258.           const playerSelector = isYouTubeMobile || isYouTubeMusic ? config.selectors.mobilePlayer : config.selectors.player;
  259.           const playerEl = document.querySelector(playerSelector);
  260.           const player = isYouTubeMobile || isYouTubeMusic ? playerEl : playerEl?.getPlayer?.();
  261.   
  262.           if (!playerEl || !player) {
  263.             utils.log({ message: 'Player not found', timeStamp: utils.getCurrentTimeString() });
  264.             if (retryCount < config.maxRetries) {
  265.               await utils.sleep(config.retryDelay);
  266.               return this.skipAd(retryCount + 1);
  267.             }
  268.             return;
  269.           }
  270.   
  271.           // Check if no ad is showing and restore mute state
  272.           if (!adShowing && !pieCountdown && !surveyQuestions && !skipButton) {
  273.             if (config.muteAds) {
  274.               await this.restoreMuteState(player);
  275.             }
  276.             return;
  277.           }
  278.   
  279.           // Try to click skip button first if available
  280.           if (skipButton && config.skipVideoAds) {
  281.             skipButton.click();
  282.             utils.log({ message: 'Skip button clicked', timeStamp: utils.getCurrentTimeString() });
  283.             // Schedule mute state restoration after skip
  284.             if (config.muteAds) {
  285.               await utils.sleep(500); // Wait for video to load
  286.               await this.restoreMuteState(player);
  287.             }
  288.             return;
  289.           }
  290.   
  291.           // Store original mute state before muting ads
  292.           if (config.muteAds && this.wasVideoMuted === null) {
  293.             this.wasVideoMuted = player.isMuted?.() ?? false;
  294.             utils.log(`Stored original mute state: ${this.wasVideoMuted ? 'muted' : 'unmuted'}`);
  295.           }
  296.   
  297.           // Mute ads if enabled
  298.           if (config.muteAds && !player.isMuted?.()) {
  299.             player.mute?.();
  300.             utils.log('Ad muted');
  301.           }
  302.   
  303.           let adVideo = null;
  304.           if (!pieCountdown && !surveyQuestions) {
  305.             adVideo = document.querySelector(config.selectors.adVideo);
  306.             if (!adVideo || !adVideo.src || adVideo.paused || isNaN(adVideo.duration)) {
  307.               utils.log('Invalid ad video state');
  308.               return;
  309.             }
  310.             utils.log({ message: 'Ad video detected', timeStamp: utils.getCurrentTimeString() });
  311.           }
  312.   
  313.           // Simulate user-like behavior with random delay
  314.           await utils.sleep(utils.randomDelay());
  315.   
  316.           if (isYouTubeMusic && adVideo) {
  317.             adVideo.currentTime = adVideo.duration;
  318.             utils.log({
  319.               message: 'Ad skipped (YouTube Music)',
  320.               timeStamp: utils.getCurrentTimeString(),
  321.               adShowing: !!adShowing,
  322.               pieCountdown: !!pieCountdown,
  323.               surveyQuestions: !!surveyQuestions,
  324.             });
  325.             // Schedule mute state restoration
  326.             if (config.muteAds) {
  327.               await utils.sleep(500); // Wait for video to load
  328.               await this.restoreMuteState(player);
  329.             }
  330.           } else {
  331.             const videoData = player.getVideoData?.() || {};
  332.             const videoId = videoData.video_id;
  333.             if (!videoId) {
  334.               utils.log('Video ID not found');
  335.               if (retryCount < config.maxRetries) {
  336.                 await utils.sleep(config.retryDelay);
  337.                 return this.skipAd(retryCount + 1);
  338.               }
  339.               return;
  340.             }
  341.             const start = Math.floor(player.getCurrentTime?.() || 0);
  342.             const loadMethod = playerEl.loadVideoWithPlayerVars ? 'loadVideoWithPlayerVars' : 'loadVideoByPlayerVars';
  343.             playerEl[loadMethod]?.({ videoId, start });
  344.             utils.log({
  345.               message: 'Ad skipped',
  346.               videoId,
  347.               start,
  348.               title: videoData.title || 'Unknown',
  349.               timeStamp: utils.getCurrentTimeString(),
  350.               adShowing: !!adShowing,
  351.               pieCountdown: !!pieCountdown,
  352.               surveyQuestions: !!surveyQuestions,
  353.             });
  354.             // Schedule mute state restoration
  355.             if (config.muteAds) {
  356.               await utils.sleep(500); // Wait for video to load
  357.               await this.restoreMuteState(player);
  358.             }
  359.           }
  360.         } catch (error) {
  361.           console.error('Error in skipAd:', error);
  362.           if (retryCount < config.maxRetries) {
  363.             await utils.sleep(config.retryDelay);
  364.             return this.skipAd(retryCount + 1);
  365.           }
  366.         }
  367.       },
  368.   
  369.       setupObserver() {
  370.         const observer = new MutationObserver((mutations) => {
  371.           if (
  372.             mutations.some(
  373.               (mutation) =>
  374.                 mutation.target.matches(config.selectors.adShowing) ||
  375.                 mutation.target.querySelector(config.selectors.adShowing)
  376.             )
  377.           ) {
  378.             this.skipAd();
  379.           }
  380.         });
  381.         observer.observe(document.body, {
  382.           attributes: true,
  383.           attributeFilter: ['class'],
  384.           childList: true,
  385.           subtree: true,
  386.         });
  387.         utils.log('MutationObserver initialized');
  388.         return observer;
  389.       },
  390.     };
  391.   
  392.     // Update checker module
  393.     const updater = {
  394.       async checkForUpdates() {
  395.         try {
  396.           const lastCheck = localStorage.getItem('AutoSkipYouTubeAds_LastUpdateCheck');
  397.           const now = Date.now();
  398.           if (lastCheck && now - parseInt(lastCheck) < config.updateCheckInterval) return;
  399.   
  400.           const response = await fetch('https://api.github.com/repos/gurr-i/browser-scripts/releases/latest', {
  401.             headers: { Accept: 'application/vnd.github.v3+json' },
  402.           });
  403.           const data = await response.json();
  404.           if (data.tag_name && data.tag_name > '8.0.1') {
  405.             const message = `Auto Skip YouTube Ads: New version ${data.tag_name} available! Update at ${config.githubRepo}`;
  406.             console.warn(message);
  407.             if (Notification.permission === 'granted') {
  408.               new Notification(message);
  409.             } else if (Notification.permission !== 'denied') {
  410.               Notification.requestPermission().then((permission) => {
  411.                 if (permission === 'granted') new Notification(message);
  412.               });
  413.             }
  414.           }
  415.           localStorage.setItem('AutoSkipYouTubeAds_LastUpdateCheck', now.toString());
  416.         } catch (error) {
  417.           utils.log('Update check failed:', error);
  418.         }
  419.       },
  420.     };
  421.   
  422.     // Initialize script
  423.     function init() {
  424.       settingsUI.init();
  425.       adHider.addCss();
  426.       if (isYouTubeVideo && config.aggressiveAdRemoval) {
  427.         adHider.removeAdElements();
  428.         adSkipper.setupObserver();
  429.       }
  430.       if (config.skipVideoAds || config.skipOverlayAds) {
  431.         adSkipper.skipAd();
  432.       }
  433.       if (config.autoUpdateCheck) {
  434.         updater.checkForUpdates();
  435.       }
  436.       utils.log('Auto Skip YouTube Ads initialized with settings:', config);
  437.     }
  438.   
  439.     // Run initialization
  440.     init();
  441.   })();