Mass Image Converter: Convert Multiple Images at Once (2025)

1. Our Online Mass Image Converter

The fastest and most comprehensive way to convert multiple images online:

1. Upload unlimited images at once (no 50-100 image limits like competitors)
2. Select from 500+ target formats (JPG, PNG, WebP, HEIC, AVIF, JPEG-XL, TIFF, BMP, GIF)
3. Adjust quality, compression, and resize settings simultaneously
4. Enable AI-powered optimization for best quality-to-size ratio
5. Download all converted images as a ZIP file or individually

Need help choosing the right format? Our image format guide explains when to use each format type.

#!/usr/bin/env python3
import os
from PIL import Image
import concurrent.futures
from pathlib import Path

def convert_image(input_path, output_dir, target_format, quality=85):
    """Convert single image with error handling"""
    try:
        with Image.open(input_path) as img:
            # Convert RGBA to RGB for JPG compatibility
            if target_format.upper() == 'JPEG' and img.mode == 'RGBA':
                background = Image.new('RGB', img.size, (255, 255, 255))
                background.paste(img, mask=img.split()[-1])
                img = background
            
            output_path = output_dir / f"{input_path.stem}.{target_format.lower()}"
            
            img.save(output_path, format=target_format, quality=quality, optimize=True)
            return f"✓ Converted: {input_path.name}"
    except Exception as e:
        return f"✗ Error: {input_path.name} - {str(e)}"

def mass_convert_images(input_dir, output_dir, target_format='WEBP', quality=85, max_workers=4):
    """Mass convert images using multithreading"""
    input_path = Path(input_dir)
    output_path = Path(output_dir)
    output_path.mkdir(exist_ok=True)
    
    # Supported input formats
    supported_formats = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.gif'}
    image_files = [f for f in input_path.iterdir() 
                   if f.suffix.lower() in supported_formats]
    
    print(f"Found {len(image_files)} images to convert...")
    
    # Process images in parallel
    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = [executor.submit(convert_image, img_file, output_path, target_format, quality) 
                   for img_file in image_files]
        
        for future in concurrent.futures.as_completed(futures):
            print(future.result())
    
    print(f"Conversion complete! Check {output_dir} for results.")

# Usage example
if __name__ == "__main__":
    mass_convert_images(
        input_dir="./input_images",
        output_dir="./converted_images", 
        target_format="WEBP",
        quality=85,
        max_workers=8  # Adjust based on your CPU cores
    )

#!/usr/bin/env python3
import time
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
from PIL import Image
import os

class ImageConverter(FileSystemEventHandler):
    def __init__(self, output_dir, target_format='WEBP', quality=85):
        self.output_dir = output_dir
        self.target_format = target_format
        self.quality = quality
        os.makedirs(output_dir, exist_ok=True)
    
    def on_created(self, event):
        if not event.is_directory and self.is_image_file(event.src_path):
            time.sleep(1)  # Wait for file to be fully written
            self.convert_image(event.src_path)
    
    def is_image_file(self, filepath):
        return filepath.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.tiff'))
    
    def convert_image(self, input_path):
        try:
            filename = os.path.basename(input_path)
            name, ext = os.path.splitext(filename)
            output_path = os.path.join(self.output_dir, f"{name}.{self.target_format.lower()}")
            
            with Image.open(input_path) as img:
                img.save(output_path, format=self.target_format, quality=self.quality, optimize=True)
            print(f"✓ Auto-converted: {filename} → {name}.{self.target_format.lower()}")
        except Exception as e:
            print(f"✗ Error converting {filename}: {str(e)}")

# Set up watch folder
if __name__ == "__main__":
    watch_folder = "./watch_folder"
    output_folder = "./auto_converted"
    
    event_handler = ImageConverter(output_folder, 'WEBP', 85)
    observer = Observer()
    observer.schedule(event_handler, watch_folder, recursive=False)
    
    observer.start()
    print(f"Watching {watch_folder} for new images...")
    
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()