Update main.py

main.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-Enhanced FastAPI YouTube Video Downloader with Anti-Bot Measures
-Implements strategies to bypass YouTube's rate limiting and bot detection
+Cookie-Enhanced FastAPI YouTube Video Downloader
+Addresses common cookie issues and provides robust cookie handling
 """
 
 import os
@@ -18,7 +18,7 @@ from typing import Optional, Dict, Any, List
 from datetime import datetime
 from concurrent.futures import ThreadPoolExecutor
 
-from fastapi import FastAPI, HTTPException, BackgroundTasks, Request
+from fastapi import FastAPI, HTTPException, BackgroundTasks, Request, UploadFile, File, Form
 from fastapi.responses import FileResponse, HTMLResponse
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, HttpUrl
@@ -31,11 +31,13 @@ logger = logging.getLogger(__name__)
 # Pydantic models
 class VideoInfoRequest(BaseModel):
     url: HttpUrl
+    use_cookies: bool = False
     
 class DownloadRequest(BaseModel):
     url: HttpUrl
     quality: str = "best"
     audio_only: bool = False
+    use_cookies: bool = False
 
 class VideoInfo(BaseModel):
     title: str
@@ -61,13 +63,14 @@ class HealthResponse(BaseModel):
     status: str
     yt_dlp_available: bool
     timestamp: str
+    cookie_file_exists: bool
     strategies_enabled: List[str]
 
 # Initialize FastAPI app
 app = FastAPI(
-    title="Enhanced YouTube Video Downloader",
-    description="Download YouTube videos with anti-bot measures and rate limiting bypass",
-    version="2.0.0",
+    title="Cookie-Enhanced YouTube Video Downloader",
+    description="Download YouTube videos with proper cookie support and troubleshooting",
+    version="3.0.0",
     docs_url="/docs",
     redoc_url="/redoc"
 )
@@ -82,88 +85,99 @@ app.add_middleware(
 )
 
 # Thread pool for background tasks
-executor = ThreadPoolExecutor(max_workers=2)  # Reduced to avoid overwhelming YouTube
+executor = ThreadPoolExecutor(max_workers=2)
 
-class AntiDetectionManager:
-    """Manages anti-detection strategies for YouTube downloading"""
+class CookieManager:
+    """Manages cookie files and validation"""
     
-    def __init__(self):
-        self.user_agents = [
-            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
-            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:121.0) Gecko/20100101 Firefox/121.0',
-            'Mozilla/5.0 (X11; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0',
-            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Edge/120.0.0.0 Safari/537.36',
-            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15'
-        ]
-        
-        self.sleep_intervals = [1, 2, 3, 5]  # Random sleep intervals
-        self.last_request_time = 0
-        self.request_count = 0
-        self.max_requests_per_minute = 10
-        
-    def get_random_user_agent(self) -> str:
-        """Get a random user agent"""
-        return random.choice(self.user_agents)
-    
-    def get_sleep_interval(self) -> int:
-        """Get a random sleep interval"""
-        return random.choice(self.sleep_intervals)
-    
-    def should_rate_limit(self) -> bool:
-        """Check if we should rate limit requests"""
-        current_time = time.time()
-        
-        # Reset counter every minute
-        if current_time - self.last_request_time > 60:
-            self.request_count = 0
-            self.last_request_time = current_time
+    def __init__(self, cookie_dir: str = None):
+        if cookie_dir is None:
+            if os.path.exists('/data'):
+                cookie_dir = '/data/cookies'
+            else:
+                cookie_dir = '/tmp/cookies'
         
-        self.request_count += 1
+        self.cookie_dir = Path(cookie_dir)
+        self.cookie_dir.mkdir(parents=True, exist_ok=True)
+        self.cookie_file = self.cookie_dir / "youtube_cookies.txt"
         
-        # Rate limit if too many requests
-        if self.request_count > self.max_requests_per_minute:
+    def save_cookies(self, cookie_content: str) -> bool:
+        """Save cookie content to file with validation"""
+        try:
+            # Basic validation - check if it looks like Netscape format
+            lines = cookie_content.strip().split('\n')
+            
+            # Remove comments and empty lines for validation
+            data_lines = [line for line in lines if line.strip() and not line.startswith('#')]
+            
+            if not data_lines:
+                logger.error("Cookie file appears to be empty or contains only comments")
+                return False
+            
+            # Check if any line contains youtube.com
+            has_youtube = any('youtube.com' in line for line in data_lines)
+            if not has_youtube:
+                logger.warning("Cookie file doesn't contain youtube.com entries")
+            
+            # Save the file
+            with open(self.cookie_file, 'w', encoding='utf-8') as f:
+                f.write(cookie_content)
+            
+            logger.info(f"Cookies saved to {self.cookie_file}")
             return True
-        
-        return False
+            
+        except Exception as e:
+            logger.error(f"Failed to save cookies: {e}")
+            return False
     
-    def get_enhanced_command(self, base_cmd: List[str]) -> List[str]:
-        """Enhance yt-dlp command with anti-detection measures"""
-        enhanced_cmd = base_cmd.copy()
-        
-        # Add user agent
-        enhanced_cmd.extend(['--user-agent', self.get_random_user_agent()])
-        
-        # Add sleep interval
-        enhanced_cmd.extend(['--sleep-interval', str(self.get_sleep_interval())])
-        
-        # Add retry options
-        enhanced_cmd.extend(['--retries', '3'])
-        enhanced_cmd.extend(['--fragment-retries', '3'])
-        
-        # Add socket timeout
-        enhanced_cmd.extend(['--socket-timeout', '30'])
-        
-        # Disable certificate checking (sometimes helps)
-        enhanced_cmd.extend(['--no-check-certificates'])
-        
-        # Add geo bypass
-        enhanced_cmd.extend(['--geo-bypass'])
+    def validate_cookies(self) -> Dict[str, Any]:
+        """Validate existing cookie file"""
+        if not self.cookie_file.exists():
+            return {"valid": False, "reason": "Cookie file does not exist"}
         
-        # Add additional headers to look more like a browser
-        enhanced_cmd.extend(['--add-header', 'Accept:text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'])
-        enhanced_cmd.extend(['--add-header', 'Accept-Language:en-US,en;q=0.5'])
-        enhanced_cmd.extend(['--add-header', 'Accept-Encoding:gzip, deflate'])
-        enhanced_cmd.extend(['--add-header', 'DNT:1'])
-        enhanced_cmd.extend(['--add-header', 'Connection:keep-alive'])
-        enhanced_cmd.extend(['--add-header', 'Upgrade-Insecure-Requests:1'])
-        
-        return enhanced_cmd
+        try:
+            with open(self.cookie_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            lines = content.strip().split('\n')
+            data_lines = [line for line in lines if line.strip() and not line.startswith('#')]
+            
+            if not data_lines:
+                return {"valid": False, "reason": "Cookie file is empty or contains only comments"}
+            
+            # Check for YouTube cookies
+            youtube_cookies = [line for line in data_lines if 'youtube.com' in line]
+            
+            # Check for essential cookies
+            essential_cookies = ['VISITOR_INFO1_LIVE', 'YSC', 'CONSENT']
+            found_essential = []
+            
+            for line in data_lines:
+                for cookie in essential_cookies:
+                    if cookie in line:
+                        found_essential.append(cookie)
+            
+            return {
+                "valid": True,
+                "total_lines": len(data_lines),
+                "youtube_cookies": len(youtube_cookies),
+                "essential_cookies": found_essential,
+                "file_size": self.cookie_file.stat().st_size,
+                "last_modified": datetime.fromtimestamp(self.cookie_file.stat().st_mtime).isoformat()
+            }
+            
+        except Exception as e:
+            return {"valid": False, "reason": f"Error reading cookie file: {e}"}
+    
+    def get_cookie_path(self) -> Optional[str]:
+        """Get path to cookie file if it exists and is valid"""
+        validation = self.validate_cookies()
+        if validation["valid"]:
+            return str(self.cookie_file)
+        return None
 
 class EnhancedYouTubeDownloader:
-    """Enhanced YouTube downloader with anti-detection measures"""
+    """Enhanced YouTube downloader with cookie support and troubleshooting"""
     
     def __init__(self, download_dir: str = None):
         if download_dir is None:
@@ -174,7 +188,15 @@ class EnhancedYouTubeDownloader:
         
         self.download_dir = Path(download_dir)
         self.download_dir.mkdir(parents=True, exist_ok=True)
-        self.anti_detection = AntiDetectionManager()
+        self.cookie_manager = CookieManager()
+        
+        # User agents for rotation
+        self.user_agents = [
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
+        ]
         
         # Ensure yt-dlp is available
         self._ensure_ytdlp_available()
@@ -195,28 +217,58 @@ class EnhancedYouTubeDownloader:
                 logger.error(f"Failed to install yt-dlp: {e}")
                 raise RuntimeError("Could not install yt-dlp")
     
-    def get_video_info(self, url: str, retry_count: int = 0) -> Optional[Dict[str, Any]]:
-        """Get video information with anti-detection measures"""
-        max_retries = 3
+    def _build_command(self, base_cmd: List[str], use_cookies: bool = False) -> List[str]:
+        """Build yt-dlp command with proper options"""
+        cmd = base_cmd.copy()
+        
+        # Add user agent
+        cmd.extend(['--user-agent', random.choice(self.user_agents)])
+        
+        # Cookie handling
+        if use_cookies:
+            cookie_path = self.cookie_manager.get_cookie_path()
+            if cookie_path:
+                cmd.extend(['--cookies', cookie_path])
+                logger.info("Using cookie file for authentication")
+            else:
+                logger.warning("Cookies requested but no valid cookie file found")
+                cmd.extend(['--no-cookies'])
+        else:
+            cmd.extend(['--no-cookies'])
         
-        # Check rate limiting
-        if self.anti_detection.should_rate_limit():
-            logger.warning("Rate limiting applied - waiting before request")
-            time.sleep(30)  # Wait 30 seconds if rate limited
+        # Enhanced options for better success rate
+        cmd.extend([
+            '--sleep-interval', str(random.randint(1, 3)),
+            '--retries', '5',
+            '--fragment-retries', '5',
+            '--socket-timeout', '30',
+            '--no-check-certificates',
+            '--geo-bypass',
+            '--add-header', 'Accept:text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            '--add-header', 'Accept-Language:en-US,en;q=0.5',
+            '--add-header', 'Accept-Encoding:gzip, deflate',
+            '--add-header', 'DNT:1',
+            '--add-header', 'Connection:keep-alive',
+            '--add-header', 'Upgrade-Insecure-Requests:1',
+        ])
+        
+        return cmd
+    
+    def get_video_info(self, url: str, use_cookies: bool = False, retry_count: int = 0) -> Optional[Dict[str, Any]]:
+        """Get video information with cookie support"""
+        max_retries = 3
         
         try:
             base_cmd = [
                 'yt-dlp',
                 '--dump-json',
                 '--no-download',
-                '--no-cookies',
                 str(url)
             ]
             
-            # Enhance command with anti-detection measures
-            cmd = self.anti_detection.get_enhanced_command(base_cmd)
+            cmd = self._build_command(base_cmd, use_cookies)
             
-            logger.info(f"Executing command (attempt {retry_count + 1}): {' '.join(cmd[:5])}...")
+            logger.info(f"Getting video info (attempt {retry_count + 1}, cookies: {use_cookies})")
             
             result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=60)
             video_info = json.loads(result.stdout)
@@ -240,23 +292,27 @@ class EnhancedYouTubeDownloader:
             # Handle specific error cases
             if "429" in error_msg or "too many requests" in error_msg:
                 if retry_count < max_retries:
-                    wait_time = (retry_count + 1) * 30  # Exponential backoff
-                    logger.warning(f"Rate limited (429), waiting {wait_time}s before retry {retry_count + 1}")
+                    wait_time = (retry_count + 1) * 30
+                    logger.warning(f"Rate limited, waiting {wait_time}s before retry {retry_count + 1}")
                     time.sleep(wait_time)
-                    return self.get_video_info(url, retry_count + 1)
-                else:
-                    logger.error("Max retries exceeded for rate limiting")
-                    return None
+                    return self.get_video_info(url, use_cookies, retry_count + 1)
             
             elif "sign in" in error_msg or "bot" in error_msg:
-                if retry_count < max_retries:
-                    wait_time = (retry_count + 1) * 60  # Longer wait for bot detection
-                    logger.warning(f"Bot detection triggered, waiting {wait_time}s before retry {retry_count + 1}")
+                if not use_cookies and retry_count == 0:
+                    logger.warning("Bot detection triggered, retrying with cookies if available")
+                    return self.get_video_info(url, True, retry_count + 1)
+                elif retry_count < max_retries:
+                    wait_time = (retry_count + 1) * 60
+                    logger.warning(f"Bot detection, waiting {wait_time}s before retry {retry_count + 1}")
                     time.sleep(wait_time)
-                    return self.get_video_info(url, retry_count + 1)
-                else:
-                    logger.error("Max retries exceeded for bot detection")
-                    return None
+                    return self.get_video_info(url, use_cookies, retry_count + 1)
+            
+            elif "cookies" in error_msg and use_cookies:
+                logger.error("Cookie-related error - cookies may be expired or invalid")
+                # Try without cookies as fallback
+                if retry_count == 0:
+                    logger.info("Retrying without cookies as fallback")
+                    return self.get_video_info(url, False, retry_count + 1)
             
             logger.error(f"Failed to get video info: {e.stderr}")
             return None
@@ -265,19 +321,15 @@ class EnhancedYouTubeDownloader:
             logger.error(f"Error processing video info: {e}")
             if retry_count < max_retries:
                 time.sleep(10)
-                return self.get_video_info(url, retry_count + 1)
+                return self.get_video_info(url, use_cookies, retry_count + 1)
             return None
     
     def download_video(self, url: str, quality: str = "best", 
-                      audio_only: bool = False, retry_count: int = 0) -> Optional[str]:
-        """Download video with anti-detection measures"""
+                      audio_only: bool = False, use_cookies: bool = False, 
+                      retry_count: int = 0) -> Optional[str]:
+        """Download video with cookie support"""
         max_retries = 2
         
-        # Check rate limiting
-        if self.anti_detection.should_rate_limit():
-            logger.warning("Rate limiting applied - waiting before download")
-            time.sleep(30)
-        
         try:
             base_cmd = ['yt-dlp']
             
@@ -296,12 +348,11 @@ class EnhancedYouTubeDownloader:
                 else:
                     base_cmd.extend(['-f', quality])
             
-            base_cmd.extend(['--no-cookies', str(url)])
+            base_cmd.append(str(url))
             
-            # Enhance command with anti-detection measures
-            cmd = self.anti_detection.get_enhanced_command(base_cmd)
+            cmd = self._build_command(base_cmd, use_cookies)
             
-            logger.info(f"Downloading video (attempt {retry_count + 1}): {url}")
+            logger.info(f"Downloading video (attempt {retry_count + 1}, cookies: {use_cookies})")
             
             result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=300)
             
@@ -320,11 +371,15 @@ class EnhancedYouTubeDownloader:
             
             if ("429" in error_msg or "too many requests" in error_msg or 
                 "sign in" in error_msg or "bot" in error_msg):
-                if retry_count < max_retries:
+                
+                if not use_cookies and retry_count == 0:
+                    logger.warning("Download blocked, retrying with cookies if available")
+                    return self.download_video(url, quality, audio_only, True, retry_count + 1)
+                elif retry_count < max_retries:
                     wait_time = (retry_count + 1) * 60
                     logger.warning(f"Download blocked, waiting {wait_time}s before retry {retry_count + 1}")
                     time.sleep(wait_time)
-                    return self.download_video(url, quality, audio_only, retry_count + 1)
+                    return self.download_video(url, quality, audio_only, use_cookies, retry_count + 1)
             
             logger.error(f"Download failed: {e.stderr}")
             return None
@@ -332,7 +387,7 @@ class EnhancedYouTubeDownloader:
         except subprocess.TimeoutExpired:
             logger.error("Download timeout")
             if retry_count < max_retries:
-                return self.download_video(url, quality, audio_only, retry_count + 1)
+                return self.download_video(url, quality, audio_only, use_cookies, retry_count + 1)
             return None
 
 # Global downloader instance
@@ -340,14 +395,14 @@ downloader = EnhancedYouTubeDownloader()
 
 @app.get("/", response_class=HTMLResponse)
 async def read_root():
-    """Serve the main HTML interface"""
+    """Serve the main HTML interface with cookie upload"""
     html_content = """
     <!DOCTYPE html>
     <html lang="en">
     <head>
         <meta charset="UTF-8">
         <meta name="viewport" content="width=device-width, initial-scale=1.0">
-        <title>Enhanced YouTube Video Downloader</title>
+        <title>Cookie-Enhanced YouTube Downloader</title>
         <style>
             body {
                 font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
@@ -364,7 +419,7 @@ async def read_root():
                 border-radius: 15px;
                 box-shadow: 0 20px 40px rgba(0,0,0,0.1);
                 padding: 40px;
-                max-width: 800px;
+                max-width: 900px;
                 width: 100%;
             }
             .header {
@@ -376,22 +431,18 @@ async def read_root():
                 margin-bottom: 10px;
                 font-size: 2.5em;
             }
-            .header p {
-                color: #666;
-                font-size: 1.1em;
-            }
-            .features {
+            .section {
                 background: #f8f9fa;
                 border-radius: 8px;
                 padding: 20px;
                 margin: 20px 0;
             }
-            .feature {
-                background: white;
-                border: 1px solid #dee2e6;
-                border-radius: 5px;
-                padding: 15px;
-                margin: 10px 0;
+            .upload-area {
+                border: 2px dashed #dee2e6;
+                border-radius: 8px;
+                padding: 20px;
+                text-align: center;
+                margin: 15px 0;
             }
             .btn {
                 background: linear-gradient(135deg, #667eea, #764ba2);
@@ -403,6 +454,7 @@ async def read_root():
                 display: inline-block;
                 margin: 10px 5px;
                 transition: transform 0.2s ease;
+                cursor: pointer;
             }
             .btn:hover {
                 transform: translateY(-2px);
@@ -415,57 +467,144 @@ async def read_root():
                 margin: 20px 0;
                 color: #856404;
             }
+            .success {
+                background: #d4edda;
+                border: 1px solid #c3e6cb;
+                border-radius: 5px;
+                padding: 15px;
+                margin: 20px 0;
+                color: #155724;
+            }
+            input[type="file"] {
+                margin: 10px 0;
+            }
         </style>
     </head>
     <body>
         <div class="container">
             <div class="header">
-                <h1>🛡️ Enhanced YouTube Downloader</h1>
-                <p>Advanced anti-detection measures for reliable video downloading</p>
+                <h1>🍪 Cookie-Enhanced YouTube Downloader</h1>
+                <p>Upload your YouTube cookies for better success rates</p>
             </div>
             
             <div class="warning">
-                <strong>⚠️ Important:</strong> This enhanced version includes anti-bot measures to handle YouTube's restrictions. 
-                Downloads may take longer due to rate limiting and retry mechanisms.
+                <strong>⚠️ Cookie Issues?</strong> If your cookies aren't working, they might be:
+                <ul>
+                    <li>Expired (YouTube cookies expire frequently)</li>
+                    <li>Wrong format (must be Netscape format)</li>
+                    <li>Missing essential cookies</li>
+                    <li>From a different IP/location</li>
+                </ul>
             </div>
             
-            <div class="features">
-                <h3>🚀 Enhanced Features</h3>
-                
-                <div class="feature">
-                    <strong>🔄 Smart Retry Logic:</strong> Automatically retries failed requests with exponential backoff
-                </div>
-                
-                <div class="feature">
-                    <strong>🎭 User-Agent Rotation:</strong> Randomizes browser signatures to avoid detection
-                </div>
-                
-                <div class="feature">
-                    <strong>⏱️ Rate Limiting:</strong> Intelligent request spacing to prevent 429 errors
-                </div>
-                
-                <div class="feature">
-                    <strong>🌐 Enhanced Headers:</strong> Mimics real browser behavior with proper headers
-                </div>
-                
-                <div class="feature">
-                    <strong>🔧 Timeout Handling:</strong> Robust timeout and error recovery mechanisms
+            <div class="section">
+                <h3>📤 Upload Cookie File</h3>
+                <div class="upload-area">
+                    <form id="cookieForm" enctype="multipart/form-data">
+                        <p>Select your YouTube cookies.txt file (Netscape format):</p>
+                        <input type="file" id="cookieFile" name="cookie_file" accept=".txt" required>
+                        <br>
+                        <button type="submit" class="btn">Upload Cookies</button>
+                    </form>
                 </div>
+                <div id="uploadResult"></div>
+            </div>
+            
+            <div class="section">
+                <h3>🔍 How to Export Cookies</h3>
+                <ol>
+                    <li>Install a cookie export extension (like "Get cookies.txt LOCALLY")</li>
+                    <li>Go to YouTube and make sure you're logged in</li>
+                    <li>Use the extension to export cookies in Netscape format</li>
+                    <li>Save the file and upload it here</li>
+                </ol>
             </div>
             
             <div style="text-align: center;">
                 <a href="/docs" class="btn">📖 API Documentation</a>
                 <a href="/health" class="btn">🏥 Health Check</a>
+                <a href="/cookie-status" class="btn">🍪 Cookie Status</a>
             </div>
         </div>
+        
+        <script>
+            document.getElementById('cookieForm').addEventListener('submit', async function(e) {
+                e.preventDefault();
+                
+                const formData = new FormData();
+                const fileInput = document.getElementById('cookieFile');
+                formData.append('cookie_file', fileInput.files[0]);
+                
+                const resultDiv = document.getElementById('uploadResult');
+                resultDiv.innerHTML = '<p>Uploading...</p>';
+                
+                try {
+                    const response = await fetch('/upload-cookies', {
+                        method: 'POST',
+                        body: formData
+                    });
+                    
+                    const result = await response.json();
+                    
+                    if (result.success) {
+                        resultDiv.innerHTML = '<div class="success"><strong>✅ Success!</strong> ' + result.message + '</div>';
+                    } else {
+                        resultDiv.innerHTML = '<div class="warning"><strong>❌ Error:</strong> ' + result.message + '</div>';
+                    }
+                } catch (error) {
+                    resultDiv.innerHTML = '<div class="warning"><strong>❌ Error:</strong> Failed to upload cookies</div>';
+                }
+            });
+        </script>
     </body>
     </html>
     """
     return HTMLResponse(content=html_content)
 
+@app.post("/upload-cookies")
+async def upload_cookies(cookie_file: UploadFile = File(...)):
+    """Upload and validate cookie file"""
+    try:
+        if not cookie_file.filename.endswith('.txt'):
+            raise HTTPException(status_code=400, detail="Cookie file must be a .txt file")
+        
+        content = await cookie_file.read()
+        cookie_content = content.decode('utf-8')
+        
+        success = downloader.cookie_manager.save_cookies(cookie_content)
+        
+        if success:
+            validation = downloader.cookie_manager.validate_cookies()
+            return {
+                "success": True,
+                "message": f"Cookies uploaded successfully. Found {validation.get('youtube_cookies', 0)} YouTube cookies.",
+                "validation": validation
+            }
+        else:
+            return {
+                "success": False,
+                "message": "Failed to save cookie file. Please check the format."
+            }
+            
+    except Exception as e:
+        logger.error(f"Error uploading cookies: {e}")
+        return {
+            "success": False,
+            "message": f"Error processing cookie file: {str(e)}"
+        }
+
+@app.get("/cookie-status")
+async def cookie_status():
+    """Get current cookie status"""
+    validation = downloader.cookie_manager.validate_cookies()
+    return {
+        "cookie_file_exists": downloader.cookie_manager.cookie_file.exists(),
+        "validation": validation
+    }
+
 @app.get("/health", response_model=HealthResponse)
 async def health_check():
-    """Enhanced health check with strategy information"""
+    """Enhanced health check with cookie information"""
     try:
         subprocess.run(['yt-dlp', '--version'], capture_output=True, check=True)
         yt_dlp_available = True
@@ -473,39 +612,44 @@ async def health_check():
         yt_dlp_available = False
     
     strategies = [
+        "Cookie Support",
         "User-Agent Rotation",
-        "Rate Limiting",
         "Smart Retry Logic",
         "Enhanced Headers",
         "Timeout Handling",
-        "Exponential Backoff"
+        "Automatic Cookie Fallback"
     ]
     
     return HealthResponse(
         status="healthy" if yt_dlp_available else "unhealthy",
         yt_dlp_available=yt_dlp_available,
         timestamp=datetime.now().isoformat(),
+        cookie_file_exists=downloader.cookie_manager.cookie_file.exists(),
         strategies_enabled=strategies
     )
 
 @app.post("/video/info", response_model=Dict[str, Any])
 async def get_video_info(request: VideoInfoRequest):
-    """Get video information with enhanced anti-detection"""
+    """Get video information with cookie support"""
     try:
         url_str = str(request.url)
         if not any(domain in url_str for domain in ['youtube.com', 'youtu.be']):
             raise HTTPException(status_code=400, detail="Invalid YouTube URL")
         
-        # Get video info in thread pool with enhanced measures
         loop = asyncio.get_event_loop()
-        info = await loop.run_in_executor(executor, downloader.get_video_info, url_str)
+        info = await loop.run_in_executor(
+            executor, 
+            downloader.get_video_info, 
+            url_str, 
+            request.use_cookies
+        )
         
         if info:
             return {"success": True, "info": info}
         else:
             raise HTTPException(
                 status_code=503, 
-                detail="Failed to get video information. YouTube may be blocking requests. Please try again later."
+                detail="Failed to get video information. Try uploading fresh cookies or wait before retrying."
             )
             
     except HTTPException:
@@ -516,7 +660,7 @@ async def get_video_info(request: VideoInfoRequest):
 
 @app.post("/video/download", response_model=DownloadResponse)
 async def download_video(request: DownloadRequest, background_tasks: BackgroundTasks):
-    """Download video with enhanced anti-detection"""
+    """Download video with cookie support"""
     try:
         url_str = str(request.url)
         if not any(domain in url_str for domain in ['youtube.com', 'youtu.be']):
@@ -524,11 +668,16 @@ async def download_video(request: DownloadRequest, background_tasks: BackgroundT
         
         # Get video info first
         loop = asyncio.get_event_loop()
-        info = await loop.run_in_executor(executor, downloader.get_video_info, url_str)
+        info = await loop.run_in_executor(
+            executor, 
+            downloader.get_video_info, 
+            url_str, 
+            request.use_cookies
+        )
         if not info:
             raise HTTPException(
                 status_code=503, 
-                detail="Failed to get video information. YouTube may be blocking requests."
+                detail="Failed to get video information. Try uploading fresh cookies."
             )
         
         # Download the video
@@ -537,19 +686,20 @@ async def download_video(request: DownloadRequest, background_tasks: BackgroundT
             downloader.download_video, 
             url_str, 
             request.quality, 
-            request.audio_only
+            request.audio_only,
+            request.use_cookies
         )
         
         if downloaded_file:
             file_size = os.path.getsize(downloaded_file)
             filename = os.path.basename(downloaded_file)
             
-            # Schedule cleanup after 2 hours (longer due to potential delays)
+            # Schedule cleanup after 2 hours
             background_tasks.add_task(cleanup_file, downloaded_file, delay=7200)
             
             return DownloadResponse(
                 success=True,
-                message="Video downloaded successfully with anti-detection measures",
+                message="Video downloaded successfully with cookie support",
                 filename=filename,
                 file_size=file_size,
                 video_info=VideoInfo(**info),
@@ -558,7 +708,7 @@ async def download_video(request: DownloadRequest, background_tasks: BackgroundT
         else:
             raise HTTPException(
                 status_code=503, 
-                detail="Failed to download video. YouTube may be blocking requests. Please try again later."
+                detail="Failed to download video. Try uploading fresh cookies or wait before retrying."
             )
             
     except HTTPException: