Update main.py

main.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-Cookie-Enhanced FastAPI YouTube Video Downloader
-Addresses common cookie issues and provides robust cookie handling
+Batch-Enhanced FastAPI YouTube Video Downloader
+Supports both single and batch downloads with cookie support
 """
 
 import os
@@ -13,13 +13,15 @@ import random
 import time
 import asyncio
 import logging
+import uuid
 from pathlib import Path
 from typing import Optional, Dict, Any, List
 from datetime import datetime
 from concurrent.futures import ThreadPoolExecutor
+import io
 
 from fastapi import FastAPI, HTTPException, BackgroundTasks, Request, UploadFile, File, Form
-from fastapi.responses import FileResponse, HTMLResponse
+from fastapi.responses import FileResponse, HTMLResponse, StreamingResponse
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, HttpUrl
 import uvicorn
@@ -31,13 +33,24 @@ logger = logging.getLogger(__name__)
 # Pydantic models
 class VideoInfoRequest(BaseModel):
     url: HttpUrl
-    use_cookies: bool = None  # Changed to None to allow auto-detection
+    use_cookies: Optional[bool] = None
+    
+class BatchVideoInfoRequest(BaseModel):
+    urls: List[HttpUrl]
+    use_cookies: Optional[bool] = None
     
 class DownloadRequest(BaseModel):
     url: HttpUrl
     quality: str = "best"
     audio_only: bool = False
-    use_cookies: bool = None  # Changed to None to allow auto-detection
+    use_cookies: Optional[bool] = None
+
+class BatchDownloadRequest(BaseModel):
+    urls: List[HttpUrl]
+    quality: str = "best"
+    audio_only: bool = False
+    use_cookies: Optional[bool] = None
+    max_concurrent: int = 2  # Limit concurrent downloads
 
 class VideoInfo(BaseModel):
     title: str
@@ -51,6 +64,12 @@ class VideoInfo(BaseModel):
     thumbnail: str
     webpage_url: str
 
+class BatchVideoInfo(BaseModel):
+    url: str
+    success: bool
+    info: Optional[VideoInfo] = None
+    error: Optional[str] = None
+
 class DownloadResponse(BaseModel):
     success: bool
     message: str
@@ -59,18 +78,38 @@ class DownloadResponse(BaseModel):
     video_info: Optional[VideoInfo] = None
     download_path: Optional[str] = None
 
+class BatchDownloadResponse(BaseModel):
+    batch_id: str
+    total_urls: int
+    status: str
+    completed: int
+    failed: int
+    results: List[Dict[str, Any]]
+
+class BatchStatus(BaseModel):
+    batch_id: str
+    status: str
+    total_urls: int
+    completed: int
+    failed: int
+    in_progress: int
+    results: List[Dict[str, Any]]
+    created_at: str
+    updated_at: str
+
 class HealthResponse(BaseModel):
     status: str
     yt_dlp_available: bool
     timestamp: str
     cookie_file_exists: bool
     strategies_enabled: List[str]
+    batch_support: bool
 
 # Initialize FastAPI app
 app = FastAPI(
-    title="Cookie-Enhanced YouTube Video Downloader",
-    description="Download YouTube videos with proper cookie support and troubleshooting",
-    version="3.1.0",
+    title="Batch YouTube Video Downloader",
+    description="Download YouTube videos individually or in batches with cookie support",
+    version="4.0.0",
     docs_url="/docs",
     redoc_url="/redoc"
 )
@@ -85,7 +124,10 @@ app.add_middleware(
 )
 
 # Thread pool for background tasks
-executor = ThreadPoolExecutor(max_workers=2)
+executor = ThreadPoolExecutor(max_workers=4)
+
+# Global batch status storage (in production, use Redis or database)
+batch_status_store = {}
 
 class CookieManager:
     """Manages cookie files and validation"""
@@ -104,22 +146,17 @@ class CookieManager:
     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)
             
@@ -145,10 +182,7 @@ class CookieManager:
             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 = []
             
@@ -175,13 +209,9 @@ class CookieManager:
         if validation["valid"]:
             return str(self.cookie_file)
         return None
-    
-    def has_valid_cookies(self) -> bool:
-        """Check if valid cookies are available"""
-        return self.get_cookie_path() is not None
 
-class EnhancedYouTubeDownloader:
-    """Enhanced YouTube downloader with cookie support and troubleshooting"""
+class BatchYouTubeDownloader:
+    """Enhanced YouTube downloader with batch support and cookie handling"""
     
     def __init__(self, download_dir: str = None):
         if download_dir is None:
@@ -194,7 +224,6 @@ class EnhancedYouTubeDownloader:
         self.download_dir.mkdir(parents=True, exist_ok=True)
         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',
@@ -202,14 +231,12 @@ class EnhancedYouTubeDownloader:
             '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()
     
     def _ensure_ytdlp_available(self):
         """Ensure yt-dlp is available, install if necessary"""
         try:
-            subprocess.run(['yt-dlp', '--version'], 
-                         capture_output=True, check=True)
+            subprocess.run(['yt-dlp', '--version'], capture_output=True, check=True)
             logger.info("yt-dlp is available")
         except (subprocess.CalledProcessError, FileNotFoundError):
             logger.info("Installing yt-dlp...")
@@ -221,24 +248,13 @@ class EnhancedYouTubeDownloader:
                 logger.error(f"Failed to install yt-dlp: {e}")
                 raise RuntimeError("Could not install yt-dlp")
     
-    def _should_use_cookies(self, use_cookies: Optional[bool]) -> bool:
-        """Determine whether to use cookies based on request and availability"""
-        if use_cookies is None:
-            # Auto-detect: use cookies if available
-            return self.cookie_manager.has_valid_cookies()
-        return use_cookies and self.cookie_manager.has_valid_cookies()
-    
-    def _build_command(self, base_cmd: List[str], use_cookies: Optional[bool] = None) -> List[str]:
+    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 with improved logic
-        should_use_cookies = self._should_use_cookies(use_cookies)
-        
-        if should_use_cookies:
+        if use_cookies:
             cookie_path = self.cookie_manager.get_cookie_path()
             if cookie_path:
                 cmd.extend(['--cookies', cookie_path])
@@ -249,7 +265,6 @@ class EnhancedYouTubeDownloader:
         else:
             cmd.extend(['--no-cookies'])
         
-        # Enhanced options for better success rate
         cmd.extend([
             '--sleep-interval', str(random.randint(1, 3)),
             '--retries', '5',
@@ -265,23 +280,20 @@ class EnhancedYouTubeDownloader:
             '--add-header', 'Upgrade-Insecure-Requests:1',
         ])
         
-        return cmd, should_use_cookies
+        return cmd
     
     def get_video_info(self, url: str, use_cookies: Optional[bool] = None, retry_count: int = 0) -> Optional[Dict[str, Any]]:
         """Get video information with cookie support"""
         max_retries = 3
         
+        # Determine actual use_cookies value
+        actual_use_cookies = use_cookies if use_cookies is not None else self.cookie_manager.get_cookie_path() is not None
+        
         try:
-            base_cmd = [
-                'yt-dlp',
-                '--dump-json',
-                '--no-download',
-                str(url)
-            ]
-            
-            cmd, actual_cookie_usage = self._build_command(base_cmd, use_cookies)
+            base_cmd = ["yt-dlp", "--dump-json", "--no-download", str(url)]
+            cmd = self._build_command(base_cmd, actual_use_cookies)
             
-            logger.info(f"Getting video info (attempt {retry_count + 1}, cookies: {actual_cookie_usage})")
+            logger.info(f"Getting video info (attempt {retry_count + 1}, cookies: {actual_use_cookies})")
             
             result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=60)
             video_info = json.loads(result.stdout)
@@ -302,7 +314,6 @@ class EnhancedYouTubeDownloader:
         except subprocess.CalledProcessError as e:
             error_msg = e.stderr.lower() if e.stderr else ""
             
-            # 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
@@ -311,9 +322,8 @@ class EnhancedYouTubeDownloader:
                     return self.get_video_info(url, use_cookies, retry_count + 1)
             
             elif "sign in" in error_msg or "bot" in error_msg:
-                # If not using cookies and we have them available, try with cookies
-                if not self._should_use_cookies(use_cookies) and self.cookie_manager.has_valid_cookies() and retry_count == 0:
-                    logger.warning("Bot detection triggered, retrying with cookies")
+                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
@@ -321,13 +331,6 @@ class EnhancedYouTubeDownloader:
                     time.sleep(wait_time)
                     return self.get_video_info(url, use_cookies, retry_count + 1)
             
-            elif "cookies" in error_msg and self._should_use_cookies(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
             
@@ -344,35 +347,34 @@ class EnhancedYouTubeDownloader:
         """Download video with cookie support"""
         max_retries = 2
         
+        # Determine actual use_cookies value
+        actual_use_cookies = use_cookies if use_cookies is not None else self.cookie_manager.get_cookie_path() is not None
+        
         try:
-            base_cmd = ['yt-dlp']
+            base_cmd = ["yt-dlp"]
             
-            # Set output directory and filename template
-            output_template = str(self.download_dir / "%(title)s.%(ext)s")
-            base_cmd.extend(['-o', output_template])
+            output_template = str(self.download_dir / "%(title)s_%(id)s.%(ext)s")
+            base_cmd.extend(["-o", output_template])
             
-            # Set format/quality
             if audio_only:
-                base_cmd.extend(['-f', 'bestaudio/best'])
+                base_cmd.extend(["-f", "bestaudio/best"])
             else:
                 if quality == "best":
-                    base_cmd.extend(['-f', 'best[height<=720]'])
+                    base_cmd.extend(["-f", "best[height<=720]"])
                 elif quality == "worst":
-                    base_cmd.extend(['-f', 'worst'])
+                    base_cmd.extend(["-f", "worst"])
                 else:
-                    base_cmd.extend(['-f', quality])
+                    base_cmd.extend(["-f", quality])
             
             base_cmd.append(str(url))
+            cmd = self._build_command(base_cmd, actual_use_cookies)
             
-            cmd, actual_cookie_usage = self._build_command(base_cmd, use_cookies)
-            
-            logger.info(f"Downloading video (attempt {retry_count + 1}, cookies: {actual_cookie_usage})")
+            logger.info(f"Downloading video (attempt {retry_count + 1}, cookies: {actual_use_cookies})")
             
             result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=300)
             
             logger.info("Download completed successfully")
             
-            # Find the downloaded file
             downloaded_files = [f for f in self.download_dir.glob("*") if f.is_file()]
             if downloaded_files:
                 latest_file = max(downloaded_files, key=os.path.getctime)
@@ -386,9 +388,8 @@ 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 not using cookies and we have them available, try with cookies
-                if not self._should_use_cookies(use_cookies) and self.cookie_manager.has_valid_cookies() and retry_count == 0:
-                    logger.warning("Download blocked, retrying with cookies")
+                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
@@ -404,20 +405,194 @@ class EnhancedYouTubeDownloader:
             if retry_count < max_retries:
                 return self.download_video(url, quality, audio_only, use_cookies, retry_count + 1)
             return None
+    
+    async def batch_get_info(self, urls: List[str], use_cookies: bool = False) -> List[BatchVideoInfo]:
+        """Get info for multiple videos concurrently"""
+        results = []
+        
+        async def get_single_info(url: str) -> BatchVideoInfo:
+            try:
+                loop = asyncio.get_event_loop()
+                info = await loop.run_in_executor(executor, self.get_video_info, url, use_cookies)
+                
+                if info:
+                    return BatchVideoInfo(
+                        url=url,
+                        success=True,
+                        info=VideoInfo(**info)
+                    )
+                else:
+                    return BatchVideoInfo(
+                        url=url,
+                        success=False,
+                        error="Failed to get video information"
+                    )
+            except Exception as e:
+                return BatchVideoInfo(
+                    url=url,
+                    success=False,
+                    error=str(e)
+                )
+        
+        # Process URLs concurrently with a limit
+        semaphore = asyncio.Semaphore(3)  # Limit concurrent requests
+        
+        async def limited_get_info(url: str) -> BatchVideoInfo:
+            async with semaphore:
+                return await get_single_info(url)
+        
+        tasks = [limited_get_info(url) for url in urls]
+        results = await asyncio.gather(*tasks)
+        
+        return results
+    
+    async def batch_download(self, batch_id: str, urls: List[str], quality: str = "best", 
+                           audio_only: bool = False, use_cookies: bool = False, 
+                           max_concurrent: int = 2) -> None:
+        """Download multiple videos with progress tracking"""
+        
+        # Initialize batch status
+        batch_status_store[batch_id] = {
+            "batch_id": batch_id,
+            "status": "in_progress",
+            "total_urls": len(urls),
+            "completed": 0,
+            "failed": 0,
+            "in_progress": 0,
+            "results": [],
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat()
+        }
+        
+        semaphore = asyncio.Semaphore(max_concurrent)
+        
+        async def download_single(url: str) -> Dict[str, Any]:
+            async with semaphore:
+                batch_status_store[batch_id]["in_progress"] += 1
+                batch_status_store[batch_id]["updated_at"] = datetime.now().isoformat()
+                
+                try:
+                    loop = asyncio.get_event_loop()
+                    
+                    # Get video info first
+                    info = await loop.run_in_executor(
+                        executor, self.get_video_info, url, use_cookies
+                    )
+                    
+                    if not info:
+                        result = {
+                            "url": url,
+                            "success": False,
+                            "error": "Failed to get video information",
+                            "completed_at": datetime.now().isoformat()
+                        }
+                        batch_status_store[batch_id]["failed"] += 1
+                        batch_status_store[batch_id]["in_progress"] -= 1
+                        batch_status_store[batch_id]["results"].append(result)
+                        batch_status_store[batch_id]["updated_at"] = datetime.now().isoformat()
+                        return result
+                    
+                    # Download the video
+                    downloaded_file = await loop.run_in_executor(
+                        executor, self.download_video, url, quality, audio_only, use_cookies
+                    )
+                    
+                    if downloaded_file:
+                        file_size = os.path.getsize(downloaded_file)
+                        filename = os.path.basename(downloaded_file)
+                        
+                        result = {
+                            "url": url,
+                            "success": True,
+                            "filename": filename,
+                            "file_size": file_size,
+                            "video_info": info,
+                            "download_path": downloaded_file,
+                            "completed_at": datetime.now().isoformat()
+                        }
+                        batch_status_store[batch_id]["completed"] += 1
+                    else:
+                        result = {
+                            "url": url,
+                            "success": False,
+                            "error": "Failed to download video",
+                            "completed_at": datetime.now().isoformat()
+                        }
+                        batch_status_store[batch_id]["failed"] += 1
+                    
+                    batch_status_store[batch_id]["in_progress"] -= 1
+                    batch_status_store[batch_id]["results"].append(result)
+                    batch_status_store[batch_id]["updated_at"] = datetime.now().isoformat()
+                    
+                    return result
+                    
+                except Exception as e:
+                    result = {
+                        "url": url,
+                        "success": False,
+                        "error": str(e),
+                        "completed_at": datetime.now().isoformat()
+                    }
+                    batch_status_store[batch_id]["failed"] += 1
+                    batch_status_store[batch_id]["in_progress"] -= 1
+                    batch_status_store[batch_id]["results"].append(result)
+                    batch_status_store[batch_id]["updated_at"] = datetime.now().isoformat()
+                    return result
+        
+        # Process all downloads
+        tasks = [download_single(url) for url in urls]
+        await asyncio.gather(*tasks)
+        
+        # Mark batch as completed
+        batch_status_store[batch_id]["status"] = "completed"
+        batch_status_store[batch_id]["updated_at"] = datetime.now().isoformat()
 
 # Global downloader instance
-downloader = EnhancedYouTubeDownloader()
+downloader = BatchYouTubeDownloader()
+
+def generate_multipart_response(file_paths: List[str], boundary: str = None):
+    """Generate a multipart response with multiple files"""
+    if boundary is None:
+        boundary = f"----formdata-{uuid.uuid4().hex}"
+    
+    def file_generator():
+        for file_path in file_paths:
+            if os.path.exists(file_path):
+                filename = os.path.basename(file_path)
+                file_size = os.path.getsize(file_path)
+                
+                # Write multipart boundary and headers
+                yield f"--{boundary}\r\n".encode()
+                yield f"Content-Disposition: form-data; name=\"file\"; filename=\"{filename}\"\r\n".encode()
+                yield f"Content-Type: application/octet-stream\r\n".encode()
+                yield f"Content-Length: {file_size}\r\n".encode()
+                yield "\r\n".encode()
+                
+                # Stream file content
+                with open(file_path, 'rb') as f:
+                    while True:
+                        chunk = f.read(8192)
+                        if not chunk:
+                            break
+                        yield chunk
+                
+                yield "\r\n".encode()
+        
+        # Final boundary
+        yield f"--{boundary}--\r\n".encode()
+    
+    return file_generator(), boundary
 
 @app.get("/", response_class=HTMLResponse)
 async def read_root():
-    """Serve the main HTML interface with cookie upload"""
+    """Serve the main HTML interface with batch support and 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>Cookie-Enhanced YouTube Downloader</title>
+        <title>Batch YouTube Video Downloader</title>
         <style>
             body {
                 font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
@@ -434,7 +609,7 @@ async def read_root():
                 border-radius: 15px;
                 box-shadow: 0 20px 40px rgba(0,0,0,0.1);
                 padding: 40px;
-                max-width: 900px;
+                max-width: 1000px;
                 width: 100%;
             }
             .header {
@@ -474,6 +649,17 @@ async def read_root():
             .btn:hover {
                 transform: translateY(-2px);
             }
+            .feature {
+                background: white;
+                border: 1px solid #dee2e6;
+                border-radius: 5px;
+                padding: 15px;
+                margin: 10px 0;
+            }
+            .new-feature {
+                background: #e8f5e8;
+                border: 1px solid #4caf50;
+            }
             .warning {
                 background: #fff3cd;
                 border: 1px solid #ffeaa7;
@@ -490,14 +676,6 @@ async def read_root():
                 margin: 20px 0;
                 color: #155724;
             }
-            .info {
-                background: #d1ecf1;
-                border: 1px solid #bee5eb;
-                border-radius: 5px;
-                padding: 15px;
-                margin: 20px 0;
-                color: #0c5460;
-            }
             input[type="file"] {
                 margin: 10px 0;
             }
@@ -506,13 +684,8 @@ async def read_root():
     <body>
         <div class="container">
             <div class="header">
-                <h1>🍪 Cookie-Enhanced YouTube Downloader</h1>
-                <p>Upload your YouTube cookies for better success rates</p>
-            </div>
-            
-            <div class="info">
-                <strong>🔄 Auto-Cookie Detection:</strong> This version automatically uses cookies when available. 
-                You no longer need to manually enable cookies in API requests!
+                <h1>📦 Batch YouTube Video Downloader</h1>
+                <p>Download single videos or process multiple URLs in batches with cookie support</p>
             </div>
             
             <div class="warning">
@@ -538,6 +711,59 @@ async def read_root():
                 <div id="uploadResult"></div>
             </div>
             
+            <div class="section">
+                <h3>🚀 Features</h3>
+                
+                <div class="feature new-feature">
+                    <strong>🆕 Batch Downloads:</strong> Process multiple YouTube URLs simultaneously
+                </div>
+                
+                <div class="feature new-feature">
+                    <strong>🆕 Progress Tracking:</strong> Monitor batch download progress in real-time
+                </div>
+                
+                <div class="feature new-feature">
+                    <strong>🆕 Bulk File Download:</strong> Download all files from a batch in one request
+                </div>
+                
+                <div class="feature">
+                    <strong>🍪 Cookie Support:</strong> Upload cookies for better success rates
+                </div>
+                
+                <div class="feature">
+                    <strong>🔄 Smart Retry Logic:</strong> Automatic retries with exponential backoff
+                </div>
+                
+                <div class="feature">
+                    <strong>⚡ Concurrent Processing:</strong> Configurable concurrent download limits
+                </div>
+            </div>
+            
+            <div class="section">
+                <h3>📋 API Endpoints</h3>
+                
+                <h4>Cookie Management:</h4>
+                <ul>
+                    <li><code>POST /upload-cookies</code> - Upload cookie file</li>
+                    <li><code>GET /cookie-status</code> - Check cookie status</li>
+                </ul>
+                
+                <h4>Single Video Operations:</h4>
+                <ul>
+                    <li><code>POST /video/info</code> - Get single video information</li>
+                    <li><code>POST /video/download</code> - Download single video</li>
+                </ul>
+                
+                <h4>Batch Operations:</h4>
+                <ul>
+                    <li><code>POST /batch/info</code> - Get info for multiple videos</li>
+                    <li><code>POST /batch/download</code> - Start batch download</li>
+                    <li><code>GET /batch/status/{batch_id}</code> - Check batch progress</li>
+                    <li><code>GET /batch/download-all/{batch_id}</code> - Download all files from batch</li>
+                    <li><code>GET /download-all</code> - Download ALL files from server</li>
+                </ul>
+            </div>
+            
             <div class="section">
                 <h3>🔍 How to Export Cookies</h3>
                 <ol>
@@ -549,7 +775,7 @@ async def read_root():
             </div>
             
             <div style="text-align: center;">
-                <a href="/docs" class="btn">📖 API Documentation</a>
+                <a href="/docs" class="btn">📖 Interactive API Docs</a>
                 <a href="/health" class="btn">🏥 Health Check</a>
                 <a href="/cookie-status" class="btn">🍪 Cookie Status</a>
             </div>
@@ -605,7 +831,7 @@ async def upload_cookies(cookie_file: UploadFile = File(...)):
             validation = downloader.cookie_manager.validate_cookies()
             return {
                 "success": True,
-                "message": f"Cookies uploaded successfully. Found {validation.get('youtube_cookies', 0)} YouTube cookies. Auto-detection enabled.",
+                "message": f"Cookies uploaded successfully. Found {validation.get('youtube_cookies', 0)} YouTube cookies.",
                 "validation": validation
             }
         else:
@@ -627,14 +853,12 @@ async def cookie_status():
     validation = downloader.cookie_manager.validate_cookies()
     return {
         "cookie_file_exists": downloader.cookie_manager.cookie_file.exists(),
-        "has_valid_cookies": downloader.cookie_manager.has_valid_cookies(),
-        "auto_detection_enabled": True,
         "validation": validation
     }
 
 @app.get("/health", response_model=HealthResponse)
 async def health_check():
-    """Enhanced health check with cookie information"""
+    """Enhanced health check with batch support information"""
     try:
         subprocess.run(['yt-dlp', '--version'], capture_output=True, check=True)
         yt_dlp_available = True
@@ -642,13 +866,14 @@ async def health_check():
         yt_dlp_available = False
     
     strategies = [
-        "Auto Cookie Detection",
+        "Batch Processing",
         "Cookie Support",
         "User-Agent Rotation",
         "Smart Retry Logic",
         "Enhanced Headers",
-        "Timeout Handling",
-        "Automatic Cookie Fallback"
+        "Concurrent Downloads",
+        "Progress Tracking",
+        "Bulk File Download"
     ]
     
     return HealthResponse(
@@ -656,12 +881,14 @@ async def health_check():
         yt_dlp_available=yt_dlp_available,
         timestamp=datetime.now().isoformat(),
         cookie_file_exists=downloader.cookie_manager.cookie_file.exists(),
-        strategies_enabled=strategies
+        strategies_enabled=strategies,
+        batch_support=True
     )
 
+# Single video endpoints
 @app.post("/video/info", response_model=Dict[str, Any])
 async def get_video_info(request: VideoInfoRequest):
-    """Get video information with automatic cookie 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']):
@@ -672,15 +899,11 @@ async def get_video_info(request: VideoInfoRequest):
             executor, 
             downloader.get_video_info, 
             url_str, 
-            request.use_cookies  # This can be None for auto-detection
+            request.use_cookies
         )
         
         if info:
-            return {
-                "success": True, 
-                "info": info,
-                "cookies_used": downloader._should_use_cookies(request.use_cookies)
-            }
+            return {"success": True, "info": info}
         else:
             raise HTTPException(
                 status_code=503, 
@@ -695,19 +918,18 @@ 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 automatic cookie 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']):
             raise HTTPException(status_code=400, detail="Invalid YouTube URL")
         
-        # Get video info first
         loop = asyncio.get_event_loop()
         info = await loop.run_in_executor(
             executor, 
             downloader.get_video_info, 
             url_str, 
-            request.use_cookies  # This can be None for auto-detection
+            request.use_cookies
         )
         if not info:
             raise HTTPException(
@@ -715,28 +937,24 @@ async def download_video(request: DownloadRequest, background_tasks: BackgroundT
                 detail="Failed to get video information. Try uploading fresh cookies."
             )
         
-        # Download the video
         downloaded_file = await loop.run_in_executor(
             executor, 
             downloader.download_video, 
             url_str, 
             request.quality, 
             request.audio_only,
-            request.use_cookies  # This can be None for auto-detection
+            request.use_cookies
         )
         
         if downloaded_file:
             file_size = os.path.getsize(downloaded_file)
             filename = os.path.basename(downloaded_file)
             
-            # Schedule cleanup after 2 hours
             background_tasks.add_task(cleanup_file, downloaded_file, delay=7200)
             
-            cookies_used = downloader._should_use_cookies(request.use_cookies)
-            
             return DownloadResponse(
                 success=True,
-                message=f"Video downloaded successfully {'with' if cookies_used else 'without'} cookies",
+                message="Video downloaded successfully",
                 filename=filename,
                 file_size=file_size,
                 video_info=VideoInfo(**info),
@@ -754,6 +972,174 @@ async def download_video(request: DownloadRequest, background_tasks: BackgroundT
         logger.error(f"Error downloading video: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
+# Batch endpoints
+@app.post("/batch/info")
+async def batch_get_video_info(request: BatchVideoInfoRequest):
+    """Get information for multiple videos"""
+    try:
+        if len(request.urls) > 50:  # Limit batch size
+            raise HTTPException(status_code=400, detail="Maximum 50 URLs allowed per batch")
+        
+        urls = [str(url) for url in request.urls]
+        
+        # Validate URLs
+        for url in urls:
+            if not any(domain in url for domain in ['youtube.com', 'youtu.be']):
+                raise HTTPException(status_code=400, detail=f"Invalid YouTube URL: {url}")
+        
+        results = await downloader.batch_get_info(urls, request.use_cookies)
+        
+        success_count = sum(1 for r in results if r.success)
+        
+        return {
+            "success": True,
+            "total_urls": len(urls),
+            "successful": success_count,
+            "failed": len(urls) - success_count,
+            "results": [r.dict() for r in results]
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in batch info: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/batch/download", response_model=BatchDownloadResponse)
+async def batch_download_videos(request: BatchDownloadRequest, background_tasks: BackgroundTasks):
+    """Start batch download of multiple videos"""
+    try:
+        if len(request.urls) > 20:  # Limit batch size for downloads
+            raise HTTPException(status_code=400, detail="Maximum 20 URLs allowed per batch download")
+        
+        if request.max_concurrent > 5:  # Limit concurrent downloads
+            raise HTTPException(status_code=400, detail="Maximum 5 concurrent downloads allowed")
+        
+        urls = [str(url) for url in request.urls]
+        
+        # Validate URLs
+        for url in urls:
+            if not any(domain in url for domain in ['youtube.com', 'youtu.be']):
+                raise HTTPException(status_code=400, detail=f"Invalid YouTube URL: {url}")
+        
+        # Generate batch ID
+        batch_id = str(uuid.uuid4())
+        
+        # Start batch download in background
+        background_tasks.add_task(
+            downloader.batch_download,
+            batch_id,
+            urls,
+            request.quality,
+            request.audio_only,
+            request.use_cookies,
+            request.max_concurrent
+        )
+        
+        return BatchDownloadResponse(
+            batch_id=batch_id,
+            total_urls=len(urls),
+            status="started",
+            completed=0,
+            failed=0,
+            results=[]
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error starting batch download: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/batch/status/{batch_id}", response_model=BatchStatus)
+async def get_batch_status(batch_id: str):
+    """Get status of a batch download"""
+    if batch_id not in batch_status_store:
+        raise HTTPException(status_code=404, detail="Batch not found")
+    
+    status = batch_status_store[batch_id]
+    return BatchStatus(**status)
+
+@app.get("/batch/download-all/{batch_id}")
+async def download_all_batch_files(batch_id: str):
+    """Download all files from a completed batch as multipart response"""
+    try:
+        if batch_id not in batch_status_store:
+            raise HTTPException(status_code=404, detail="Batch not found")
+        
+        batch_status = batch_status_store[batch_id]
+        
+        if batch_status["status"] != "completed":
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Batch is not completed yet. Current status: {batch_status['status']}"
+            )
+        
+        # Get all successfully downloaded files
+        file_paths = []
+        for result in batch_status["results"]:
+            if result.get("success") and result.get("download_path"):
+                file_path = result["download_path"]
+                if os.path.exists(file_path):
+                    file_paths.append(file_path)
+        
+        if not file_paths:
+            raise HTTPException(status_code=404, detail="No files found for this batch")
+        
+        # Generate multipart response
+        file_generator, boundary = generate_multipart_response(file_paths)
+        
+        headers = {
+            "Content-Type": f"multipart/form-data; boundary={boundary}",
+            "Content-Disposition": f"attachment; filename=\"batch_{batch_id}_files.multipart\""
+        }
+        
+        return StreamingResponse(
+            file_generator,
+            headers=headers,
+            media_type=f"multipart/form-data; boundary={boundary}"
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error downloading batch files: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/download-all")
+async def download_all_files():
+    """Download all files from the server as multipart response"""
+    try:
+        # Get all files from the download directory
+        download_dir = Path(downloader.download_dir)
+        all_files = [f for f in download_dir.glob("*") if f.is_file()]
+        
+        if not all_files:
+            raise HTTPException(status_code=404, detail="No files found on server")
+        
+        # Convert to string paths
+        file_paths = [str(f) for f in all_files]
+        
+        # Generate multipart response
+        file_generator, boundary = generate_multipart_response(file_paths)
+        
+        headers = {
+            "Content-Type": f"multipart/form-data; boundary={boundary}",
+            "Content-Disposition": f"attachment; filename=\"all_server_files.multipart\""
+        }
+        
+        return StreamingResponse(
+            file_generator,
+            headers=headers,
+            media_type=f"multipart/form-data; boundary={boundary}"
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error downloading all files: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
 @app.get("/video/file/{filename}")
 async def download_file(filename: str):
     """Serve downloaded files"""