Exceptions

Exception
└── ExtractionException
    ├── ParsingException
    │   ├── ContentNotAvailableException
    │   │   ├── AgeRestrictedContentException
    │   │   ├── GeographicRestrictionException
    │   │   ├── PaidContentException
    │   │   ├── PrivateContentException
    │   │   ├── AccountTerminatedException
    │   │   ├── YoutubeMusicPremiumContentException
    │   │   ├── SoundCloudGoPlusContentException
    │   │   └── UnsupportedContentInCountryException
    │   ├── ContentNotSupportedException
    │   ├── FoundAdException
    │   └── SignInConfirmNotBotException
    └── ReCaptchaException

UnsupportedOperationException
└── UnsupportedTabException

throw new ExtractionException("Failed to extract video information");

throw new ExtractionException(ioException);

throw new ExtractionException("Failed to parse JSON", jsonException);

if (response.responseCode() == 429) {
    throw new ReCaptchaException(
        "CAPTCHA required",
        "https://www.google.com/recaptcha/..."
    );
}

try {
    // Extraction code
} catch (ReCaptchaException e) {
    String captchaUrl = e.getUrl();
    // Redirect user to solve CAPTCHA
}

throw new ParsingException("Could not extract video ID from URL");

try {
    int viewCount = Integer.parseInt(viewCountStr);
} catch (NumberFormatException e) {
    throw new ParsingException("Invalid view count format", e);
}

throw new ContentNotSupportedException("Shorts are not supported");

if (isAd(item)) {
    throw new FoundAdException("Item is an advertisement");
}

if (requiresSignIn) {
    throw new SignInConfirmNotBotException(
        "Service requires sign-in to verify you're not a bot"
    );
}

throw new ContentNotAvailableException("Video has been removed");

if (isAgeRestricted) {
    throw new AgeRestrictedContentException(
        "This video is age-restricted"
    );
}

throw new GeographicRestrictionException(
    "This video is not available in your country"
);

throw new UnsupportedContentInCountryException(
    "This content type is not available in this region"
);

if (requiresPurchase) {
    throw new PaidContentException(
        "This content requires payment"
    );
}

if (isPrivate) {
    throw new PrivateContentException(
        "This video is private"
    );
}

throw new YoutubeMusicPremiumContentException();

throw new YoutubeMusicPremiumContentException(cause);

throw new SoundCloudGoPlusContentException();

throw new SoundCloudGoPlusContentException(cause);

throw new AccountTerminatedException(
    "This account has been terminated"
);

throw new AccountTerminatedException(
    "Account terminated for community guidelines violation",
    AccountTerminatedException.Reason.VIOLATION
);

try {
    // Extract content
} catch (AccountTerminatedException e) {
    AccountTerminatedException.Reason reason = e.getReason();
    if (reason == AccountTerminatedException.Reason.VIOLATION) {
        System.out.println("Account terminated for violations");
    }
}

if (!supportedTabs.contains(tabName)) {
    throw new UnsupportedTabException(tabName);
}

import org.schabi.newpipe.extractor.exceptions.*;

public void extractVideo(String url) {
    try {
        StreamExtractor extractor = service.getStreamExtractor(url);
        extractor.fetchPage();
        String title = extractor.getName();
        
    } catch (AgeRestrictedContentException e) {
        System.err.println("Age-restricted: " + e.getMessage());
        
    } catch (GeographicRestrictionException e) {
        System.err.println("Geo-blocked: " + e.getMessage());
        
    } catch (PrivateContentException e) {
        System.err.println("Private video: " + e.getMessage());
        
    } catch (ContentNotAvailableException e) {
        System.err.println("Content unavailable: " + e.getMessage());
        
    } catch (ParsingException e) {
        System.err.println("Parse error: " + e.getMessage());
        
    } catch (ReCaptchaException e) {
        System.err.println("CAPTCHA required at: " + e.getUrl());
        
    } catch (ExtractionException e) {
        System.err.println("Extraction failed: " + e.getMessage());
    }
}

public void extractYouTubeVideo(String url) {
    try {
        StreamExtractor extractor = YouTube.getStreamExtractor(url);
        extractor.fetchPage();
        
    } catch (YoutubeMusicPremiumContentException e) {
        System.err.println("Requires YouTube Music Premium");
        // Offer user option to subscribe
        
    } catch (AccountTerminatedException e) {
        if (e.getReason() == AccountTerminatedException.Reason.VIOLATION) {
            System.err.println("Channel terminated for violations");
        } else {
            System.err.println("Channel no longer available");
        }
    }
}

public void extractSoundCloudTrack(String url) {
    try {
        StreamExtractor extractor = SoundCloud.getStreamExtractor(url);
        extractor.fetchPage();
        
    } catch (SoundCloudGoPlusContentException e) {
        System.err.println("Requires SoundCloud Go+ subscription");
    }
}

public enum ExtractionErrorType {
    UNAVAILABLE,
    PARSING_ERROR,
    CAPTCHA_REQUIRED,
    UNSUPPORTED,
    NETWORK_ERROR
}

public ExtractionErrorType categorizeError(Exception e) {
    if (e instanceof ContentNotAvailableException) {
        return ExtractionErrorType.UNAVAILABLE;
    } else if (e instanceof ReCaptchaException) {
        return ExtractionErrorType.CAPTCHA_REQUIRED;
    } else if (e instanceof ContentNotSupportedException) {
        return ExtractionErrorType.UNSUPPORTED;
    } else if (e instanceof ParsingException) {
        return ExtractionErrorType.PARSING_ERROR;
    } else if (e instanceof IOException) {
        return ExtractionErrorType.NETWORK_ERROR;
    }
    return ExtractionErrorType.PARSING_ERROR;
}

public void extractWithRetry(String url, int maxRetries) {
    int attempt = 0;
    
    while (attempt < maxRetries) {
        try {
            StreamExtractor extractor = service.getStreamExtractor(url);
            extractor.fetchPage();
            return; // Success
            
        } catch (ReCaptchaException e) {
            System.err.println("CAPTCHA detected, cannot retry");
            throw e; // Can't recover automatically
            
        } catch (ContentNotAvailableException e) {
            System.err.println("Content unavailable, cannot retry");
            throw e; // Can't recover
            
        } catch (ParsingException e) {
            attempt++;
            if (attempt >= maxRetries) {
                throw e;
            }
            System.err.println("Parse error, retrying... (" + attempt + ")");
            
        } catch (IOException e) {
            attempt++;
            if (attempt >= maxRetries) {
                throw e;
            }
            System.err.println("Network error, retrying... (" + attempt + ")");
            try {
                Thread.sleep(1000 * attempt); // Exponential backoff
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(ie);
            }
        }
    }
}

try {
    // Extraction code
} catch (AgeRestrictedContentException e) {
    // Handle age restriction
} catch (ContentNotAvailableException e) {
    // Handle other availability issues
} catch (ParsingException e) {
    // Handle parsing errors
} catch (ExtractionException e) {
    // Handle any other extraction error
}

try {
    String title = extractor.getName();
} catch (ParsingException e) {
    throw new ParsingException(
        "Failed to extract video title from URL: " + url,
        e
    );
}

try {
    // Extract content
} catch (FoundAdException e) {
    // Ads are expected, log at debug level
    logger.debug("Skipping ad item");
} catch (ContentNotAvailableException e) {
    // Availability issues are common, log at info level
    logger.info("Content not available: " + e.getMessage());
} catch (ParsingException e) {
    // Parsing errors are more serious, log at warning level
    logger.warn("Failed to parse content", e);
}