Compress All the Images in a Folder by Single Click

Easily Compress all the images in any folder without lossing too much quality.

November 14, 2025

1 min read

automationimages

How to use this Trick

You can copy the code below, or download the Full Project for the best experience.

1. ConfigureUse the inputs below to customize the code variables.

2. DownloadGet the zip file containing the source code.

3. Run (Windows)Unzip and double-click run_windows.bat.

3. Run (Mac/Linux)Unzip and double-click run_mac.command.

Configuration

Input Folder

Output Folder

Quality (1-100)

Code Editor (python)

import os
import time
import shutil
from PIL import Image

# Configuration mapped from inputs
INPUT_DIR = r"{{input_dir}}"
OUTPUT_DIR = r"{{output_dir}}"
QUALITY = {{quality}}

SUPPORTED_EXTENSIONS = ('.jpg', '.jpeg', '.png', '.webp')

def get_size_format(b, factor=1024, suffix="B"):
    """Scale bytes to its proper byte format (e.g: 12.5 MB)"""
    for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
        if b < factor:
            return f"{b:.2f}{unit}{suffix}"
        b /= factor
    return f"{b:.2f}Y{suffix}"

def compress_image(file_path, save_path):
    """
    Compresses image without resizing.
    Checks if result is smaller; if not, keeps original.
    """
    try:
        img = Image.open(file_path)
        original_size = os.path.getsize(file_path)
        
        # Determine format to handle transparency correctly
        file_ext = os.path.splitext(save_path)[1].lower()
        
        # JPEG specific handling (Remove alpha channel)
        if file_ext in ['.jpg', '.jpeg']:
            if img.mode in ('RGBA', 'P'):
                img = img.convert('RGB')
            img.save(save_path, optimize=True, quality=int(QUALITY))

# PNG/WebP specific handling
        else:
            # For PNG, standard 'quality' param is ignored by Pillow.
            # We use optimize=True. If you want lossy PNG (smaller size),
            # we need to quantize (reduce colors) if quality setting is low.
            if file_ext == '.png' and int(QUALITY) < 85:
                 # Optional: Quantize to 256 colors to force size reduction for PNGs
                 # If you want strictly lossless, remove the next 2 lines.
                 if img.mode != 'P':
                    img = img.quantize(colors=256, method=2)
            
            img.save(save_path, optimize=True, quality=int(QUALITY))
        
        # --- SAFETY CHECK ---
        # Check if the "compressed" file is actually bigger than original
        compressed_size = os.path.getsize(save_path)
        
        if compressed_size >= original_size:
            # If new file is bigger or same, just copy the original over
            shutil.copy2(file_path, save_path)
            print(f"[SKIP] {os.path.basename(file_path)} (Optimized file was larger, kept original)")
        else:
            reduction = ((original_size - compressed_size) / original_size) * 100
            print(f"[OK]   {os.path.basename(file_path)}")
            print(f"       {get_size_format(original_size)} -> {get_size_format(compressed_size)} (-{reduction:.1f}%)")
        
    except Exception as e:
        print(f"[ERROR] Could not process {os.path.basename(file_path)}: {e}")

def main():
    print(f"--- Denaro Studio Smart Compressor ---")
    print(f"Input: {INPUT_DIR}")
    print(f"Output: {OUTPUT_DIR}")
    print(f"Quality Setting: {QUALITY}")
    print("-" * 40)

start_time = time.time()
    processed_count = 0

# Ensure output directory exists
    if not os.path.exists(OUTPUT_DIR):
        os.makedirs(OUTPUT_DIR)

# Walk through directory
    for root, dirs, files in os.walk(INPUT_DIR):
        rel_path = os.path.relpath(root, INPUT_DIR)
        target_dir = os.path.join(OUTPUT_DIR, rel_path)
        
        if not os.path.exists(target_dir):
            os.makedirs(target_dir)

for file in files:
            if file.lower().endswith(SUPPORTED_EXTENSIONS):
                input_path = os.path.join(root, file)
                output_path = os.path.join(target_dir, file)
                
                compress_image(input_path, output_path)
                processed_count += 1

elapsed = time.time() - start_time
    print("-" * 40)
    print(f"Completed! Processed {processed_count} images in {elapsed:.2f} seconds.")

if __name__ == "__main__":
    main()

Download Full Project

Get the complete source code with your configuration applied. Includes one-click runner scripts for Windows and macOS.

run_windows.batrun_mac.command100% Open Source

Overview

Related Tricks

File Management🐍

Organize Files in any Folder by File Type

Automatically sort files into folders by file type using Python.

Easyautomationfile-system

Nov 5, 2025

Data Processing🐍

JSON to CSV Converter

Easily convert JSON files into clean, structured CSV files for analysis or automation.

Easyautomationdata

Nov 1, 2025