Upload 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,6 +13,7 @@ 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
@@ -33,12 +34,23 @@ class VideoInfoRequest(BaseModel):
     url: HttpUrl
     use_cookies: bool = False
     
+class BatchVideoInfoRequest(BaseModel):
+    urls: List[HttpUrl]
+    use_cookies: bool = False
+    
 class DownloadRequest(BaseModel):
     url: HttpUrl
     quality: str = "best"
     audio_only: bool = False
     use_cookies: bool = False
 
+class BatchDownloadRequest(BaseModel):
+    urls: List[HttpUrl]
+    quality: str = "best"
+    audio_only: bool = False
+    use_cookies: bool = False
+    max_concurrent: int = 2  # Limit concurrent downloads
+
 class VideoInfo(BaseModel):
     title: str
     duration: int
@@ -51,6 +63,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 +77,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.0.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 +123,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 +145,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 +181,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 = []
             
@@ -176,8 +209,8 @@ class CookieManager:
             return str(self.cookie_file)
         return 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:
@@ -190,7 +223,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',
@@ -198,14 +230,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,10 +251,8 @@ class EnhancedYouTubeDownloader:
         """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:
@@ -236,7 +264,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',
@@ -259,13 +286,7 @@ class EnhancedYouTubeDownloader:
         max_retries = 3
         
         try:
-            base_cmd = [
-                'yt-dlp',
-                '--dump-json',
-                '--no-download',
-                str(url)
-            ]
-            
+            base_cmd = ['yt-dlp', '--dump-json', '--no-download', str(url)]
             cmd = self._build_command(base_cmd, use_cookies)
             
             logger.info(f"Getting video info (attempt {retry_count + 1}, cookies: {use_cookies})")
@@ -289,7 +310,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
@@ -307,13 +327,6 @@ class EnhancedYouTubeDownloader:
                     time.sleep(wait_time)
                     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
             
@@ -333,11 +346,9 @@ class EnhancedYouTubeDownloader:
         try:
             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])
             
-            # Set format/quality
             if audio_only:
                 base_cmd.extend(['-f', 'bestaudio/best'])
             else:
@@ -349,7 +360,6 @@ class EnhancedYouTubeDownloader:
                     base_cmd.extend(['-f', quality])
             
             base_cmd.append(str(url))
-            
             cmd = self._build_command(base_cmd, use_cookies)
             
             logger.info(f"Downloading video (attempt {retry_count + 1}, cookies: {use_cookies})")
@@ -358,7 +368,6 @@ class EnhancedYouTubeDownloader:
             
             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)
@@ -389,20 +398,161 @@ 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()
 
 @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"""
     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;
@@ -419,7 +569,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 {
@@ -437,13 +587,6 @@ async def read_root():
                 padding: 20px;
                 margin: 20px 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);
                 color: white;
@@ -459,103 +602,79 @@ async def read_root():
             .btn:hover {
                 transform: translateY(-2px);
             }
-            .warning {
-                background: #fff3cd;
-                border: 1px solid #ffeaa7;
-                border-radius: 5px;
-                padding: 15px;
-                margin: 20px 0;
-                color: #856404;
-            }
-            .success {
-                background: #d4edda;
-                border: 1px solid #c3e6cb;
+            .feature {
+                background: white;
+                border: 1px solid #dee2e6;
                 border-radius: 5px;
                 padding: 15px;
-                margin: 20px 0;
-                color: #155724;
-            }
-            input[type="file"] {
                 margin: 10px 0;
             }
+            .new-feature {
+                background: #e8f5e8;
+                border: 1px solid #4caf50;
+            }
         </style>
     </head>
     <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="warning">
-                <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>
+                <h1>📦 Batch YouTube Video Downloader</h1>
+                <p>Download single videos or process multiple URLs in batches</p>
             </div>
             
             <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>
+                <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">
+                    <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 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>
+                <h3>📋 API Endpoints</h3>
+                
+                <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>
+                </ul>
+                
+                <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>
             </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>
         </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>
     """
@@ -604,7 +723,7 @@ async def cookie_status():
 
 @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
@@ -612,12 +731,13 @@ async def health_check():
         yt_dlp_available = False
     
     strategies = [
+        "Batch Processing",
         "Cookie Support",
         "User-Agent Rotation",
         "Smart Retry Logic",
         "Enhanced Headers",
-        "Timeout Handling",
-        "Automatic Cookie Fallback"
+        "Concurrent Downloads",
+        "Progress Tracking"
     ]
     
     return HealthResponse(
@@ -625,9 +745,11 @@ 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 cookie support"""
@@ -666,7 +788,6 @@ async def download_video(request: DownloadRequest, background_tasks: BackgroundT
         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, 
@@ -680,7 +801,6 @@ 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, 
@@ -694,12 +814,11 @@ async def download_video(request: DownloadRequest, background_tasks: BackgroundT
             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)
             
             return DownloadResponse(
                 success=True,
-                message="Video downloaded successfully with cookie support",
+                message="Video downloaded successfully",
                 filename=filename,
                 file_size=file_size,
                 video_info=VideoInfo(**info),
@@ -717,6 +836,94 @@ 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("/video/file/{filename}")
 async def download_file(filename: str):
     """Serve downloaded files"""