How to Batch Merge Images: The Complete Automation Guide for 2025

1. Prepare image pairs in organized folders:
   /products/product-001-main.jpg
   /products/product-001-detail.jpg
   /products/product-002-main.jpg
   /products/product-002-detail.jpg

2. Upload all images to batch tool
3. Set merge settings: horizontal layout, 10px spacing, 100% quality
4. Process batch
5. Download merged results

# Merge all pairs horizontally
for i in {1..100}; do
  convert main-$i.jpg detail-$i.jpg +append -quality 100 merged-$i.jpg
done

from PIL import Image
import os

def merge_images_horizontal(image1_path, image2_path, output_path, spacing=10):
    """Merge two images horizontally with spacing."""
    img1 = Image.open(image1_path)
    img2 = Image.open(image2_path)

    # Calculate dimensions
    total_width = img1.width + img2.width + spacing
    max_height = max(img1.height, img2.height)

    # Create new image with white background
    merged = Image.new('RGB', (total_width, max_height), (255, 255, 255))

    # Paste images
    merged.paste(img1, (0, 0))
    merged.paste(img2, (img1.width + spacing, 0))

    # Save with high quality
    merged.save(output_path, 'JPEG', quality=95)

# Process all image pairs
for i in range(1, 101):
    main = f'products/product-{i:03d}-main.jpg'
    detail = f'products/product-{i:03d}-detail.jpg'
    output = f'output/merged-{i:03d}.jpg'

    if os.path.exists(main) and os.path.exists(detail):
        merge_images_horizontal(main, detail, output)
        print(f'Processed: {output}')

Trigger: New files in Dropbox folder
Action 1: Download images
Action 2: Call image merging API
Action 3: Upload merged results to Google Drive
Action 4: Send Slack notification

brew install imagemagick

sudo apt-get install imagemagick

convert -version

convert image1.jpg image2.jpg +append output.jpg

convert image1.jpg image2.jpg -splice 10x0 +append output.jpg

convert img1.jpg img2.jpg img3.jpg img4.jpg +append output.jpg

#!/bin/bash
# Merge all *-main.jpg with corresponding *-detail.jpg

for main in *-main.jpg; do
    # Extract base name (e.g., "product-001")
    base="${main%-main.jpg}"
    detail="${base}-detail.jpg"
    output="merged/${base}-merged.jpg"

    if [ -f "$detail" ]; then
        echo "Merging: $main + $detail → $output"
        convert "$main" "$detail" +append -quality 100 "$output"
    else
        echo "Warning: No matching detail image for $main"
    fi
done

echo "Batch processing complete!"

chmod +x batch-merge.sh
./batch-merge.sh

#!/bin/bash
# Create 2×2 grids from sets of 4 images

for i in {1..50}; do
    img1="photos/img-${i}-1.jpg"
    img2="photos/img-${i}-2.jpg"
    img3="photos/img-${i}-3.jpg"
    img4="photos/img-${i}-4.jpg"
    output="grids/grid-${i}.jpg"

    if [ -f "$img1" ] && [ -f "$img2" ] && [ -f "$img3" ] && [ -f "$img4" ]; then
        # Create top row
        convert "$img1" "$img2" +append /tmp/top-${i}.jpg
        # Create bottom row
        convert "$img3" "$img4" +append /tmp/bottom-${i}.jpg
        # Stack rows
        convert /tmp/top-${i}.jpg /tmp/bottom-${i}.jpg -append "$output"
        # Cleanup temp files
        rm /tmp/top-${i}.jpg /tmp/bottom-${i}.jpg
        echo "Created: $output"
    fi
done

#!/bin/bash
# Resize images to same height before horizontal merge

for main in *-main.jpg; do
    base="${main%-main.jpg}"
    detail="${base}-detail.jpg"
    output="merged/${base}-merged.jpg"

    if [ -f "$detail" ]; then
        # Resize both to 800px height, maintain aspect ratio
        convert "$main" -resize x800 /tmp/main-resized.jpg
        convert "$detail" -resize x800 /tmp/detail-resized.jpg
        # Merge resized images
        convert /tmp/main-resized.jpg /tmp/detail-resized.jpg +append -quality 100 "$output"
        echo "Processed: $output"
    fi
done

# Cleanup
rm /tmp/main-resized.jpg /tmp/detail-resized.jpg 2>/dev/null

convert img1.jpg img2.jpg +append -quality 100 output.jpg

convert img.jpg -thumbnail 800x800 resized.jpg

convert img1.jpg img2.jpg +append -strip -quality 95 output.jpg

ls *-main.jpg | parallel -j 4 './process-single.sh {}'

# Python 3 should already be installed on macOS/Linux
# Windows: download from python.org

# Install Pillow (PIL fork)
pip install Pillow

from PIL import Image
import os
from pathlib import Path

def merge_horizontal(img1_path, img2_path, output_path, spacing=20, quality=95):
    """
    Merge two images horizontally with spacing.

    Args:
        img1_path: Path to first image
        img2_path: Path to second image
        output_path: Path to save merged image
        spacing: Pixels between images (default: 20)
        quality: JPEG quality 1-100 (default: 95)
    """
    try:
        # Open images
        img1 = Image.open(img1_path)
        img2 = Image.open(img2_path)

        # Calculate dimensions
        total_width = img1.width + img2.width + spacing
        max_height = max(img1.height, img2.height)

        # Create new image (white background)
        merged = Image.new('RGB', (total_width, max_height), (255, 255, 255))

        # Paste images
        merged.paste(img1, (0, (max_height - img1.height) // 2))
        merged.paste(img2, (img1.width + spacing, (max_height - img2.height) // 2))

        # Ensure output directory exists
        os.makedirs(os.path.dirname(output_path), exist_ok=True)

        # Save
        merged.save(output_path, 'JPEG', quality=quality, optimize=True)
        return True
    except Exception as e:
        print(f"Error processing {img1_path} + {img2_path}: {e}")
        return False

# Example usage
if __name__ == "__main__":
    merge_horizontal(
        'photos/main-001.jpg',
        'photos/detail-001.jpg',
        'output/merged-001.jpg'
    )

from PIL import Image
import os
from pathlib import Path
from tqdm import tqdm

def find_image_pairs(folder, main_suffix='-main', detail_suffix='-detail'):
    """
    Find matching image pairs in a folder.
    Returns list of (main_path, detail_path, output_name) tuples.
    """
    pairs = []
    main_files = list(Path(folder).glob(f'*{main_suffix}.jpg'))

    for main_path in main_files:
        base_name = main_path.stem.replace(main_suffix, '')
        detail_path = main_path.parent / f'{base_name}{detail_suffix}.jpg'

        if detail_path.exists():
            output_name = f'{base_name}-merged.jpg'
            pairs.append((str(main_path), str(detail_path), output_name))
        else:
            print(f'Warning: No matching detail for {main_path.name}')

    return pairs

def batch_merge(input_folder, output_folder, spacing=20, quality=95):
    """
    Batch merge all matching image pairs in a folder.
    """
    # Find all pairs
    pairs = find_image_pairs(input_folder)

    if not pairs:
        print('No image pairs found!')
        return

    print(f'Found {len(pairs)} image pairs to process')

    # Create output folder
    os.makedirs(output_folder, exist_ok=True)

    # Process with progress bar
    success_count = 0
    for main_path, detail_path, output_name in tqdm(pairs, desc='Merging images'):
        output_path = os.path.join(output_folder, output_name)
        if merge_horizontal(main_path, detail_path, output_path, spacing, quality):
            success_count += 1

    print(f'\nProcessing complete: {success_count}/{len(pairs)} successful')

# Run batch merge
if __name__ == "__main__":
    batch_merge(
        input_folder='photos',
        output_folder='output/merged',
        spacing=20,
        quality=95
    )

pip install tqdm

def create_grid(image_paths, output_path, cols=2, spacing=10, quality=95):
    """
    Create a grid layout from multiple images.

    Args:
        image_paths: List of image file paths
        output_path: Where to save the grid
        cols: Number of columns (default: 2 for 2×2, 2×3, etc.)
        spacing: Pixels between images
        quality: JPEG quality
    """
    images = [Image.open(path) for path in image_paths]

    # Calculate grid dimensions
    rows = (len(images) + cols - 1) // cols

    # Find max dimensions in each row/column
    max_widths = []
    max_heights = []

    for i in range(rows):
        row_images = images[i * cols:(i + 1) * cols]
        max_heights.append(max(img.height for img in row_images))

    for i in range(cols):
        col_images = [images[j] for j in range(i, len(images), cols) if j < len(images)]
        max_widths.append(max(img.width for img in col_images))

    # Calculate total dimensions
    total_width = sum(max_widths) + spacing * (cols - 1)
    total_height = sum(max_heights) + spacing * (rows - 1)

    # Create grid
    grid = Image.new('RGB', (total_width, total_height), (255, 255, 255))

    # Paste images
    y_offset = 0
    for row in range(rows):
        x_offset = 0
        for col in range(cols):
            idx = row * cols + col
            if idx < len(images):
                img = images[idx]
                # Center image in cell
                x_pos = x_offset + (max_widths[col] - img.width) // 2
                y_pos = y_offset + (max_heights[row] - img.height) // 2
                grid.paste(img, (x_pos, y_pos))
                x_offset += max_widths[col] + spacing
        y_offset += max_heights[row] + spacing

    # Save
    grid.save(output_path, 'JPEG', quality=quality, optimize=True)
    print(f'Grid created: {output_path}')

# Example: Create 3×3 grid
if __name__ == "__main__":
    photos = [f'photos/img-{i}.jpg' for i in range(1, 10)]
    create_grid(photos, 'output/grid-3x3.jpg', cols=3, spacing=15)

from playwright.sync_api import sync_playwright
import time

def batch_merge_online(image_pairs, download_folder):
    """
    Automate batch merging using MergeJPG online tool.
    """
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()

        for main_img, detail_img in image_pairs:
            # Navigate to merge tool
            page.goto('https://merge-jpg.app/merge-jpg-horizontally')

            # Upload images
            page.set_input_files('input[type="file"]', [main_img, detail_img])

            # Wait for processing
            time.sleep(2)

            # Click merge button
            page.click('button:has-text("Merge")')

            # Wait for download
            with page.expect_download() as download_info:
                page.click('button:has-text("Download")')
            download = download_info.value

            # Save to folder
            download.save_as(f'{download_folder}/{os.path.basename(main_img)}-merged.jpg')

            print(f'Processed: {main_img}')

        browser.close()

# Install with: pip install playwright && playwright install

project/
├── input/
│   ├── main/
│   │   ├── product-001.jpg
│   │   ├── product-002.jpg
│   │   └── product-003.jpg
│   └── detail/
│       ├── product-001.jpg
│       ├── product-002.jpg
│       └── product-003.jpg
├── output/
│   └── merged/
│       ├── product-001-merged.jpg
│       ├── product-002-merged.jpg
│       └── product-003-merged.jpg
└── scripts/
    └── batch-merge.sh

✅ Good:
product-001-main.jpg + product-001-detail.jpg
product-002-main.jpg + product-002-detail.jpg

❌ Bad:
IMG_0001.jpg + detail1.jpg
photo.jpg + detail photo.jpg

✅ Good:
item-001.jpg, item-002.jpg, item-003.jpg

❌ Bad:
item-1.jpg, item-2.jpg, ..., item-10.jpg (sorting issues)

001, 002, ..., 099, 100  (✅ sorts correctly)
1, 2, ..., 10, 11, 100   (❌ sorts as 1, 10, 100, 11, 2)

# Count matching pairs
main_count=$(ls input/main/*.jpg | wc -l)
detail_count=$(ls input/detail/*.jpg | wc -l)
echo "Main images: $main_count"
echo "Detail images: $detail_count"

# Find missing pairs
for main in input/main/*.jpg; do
    base=$(basename "$main")
    detail="input/detail/$base"
    if [ ! -f "$detail" ]; then
        echo "Missing detail for: $base"
    fi
done

# Generate size charts programmatically
def generate_size_chart(product_id, sizes):
    # Create image with size table
    chart = Image.new('RGB', (400, 300), 'white')
    draw = ImageDraw.Draw(chart)
    # ... draw table with sizes
    chart.save(f'charts/chart-{product_id}.jpg')

# Batch merge products + charts
for product_id in range(1, 1001):
    main = f'products/product-{product_id}.jpg'
    chart = f'charts/chart-{product_id}.jpg'
    output = f'listings/listing-{product_id}.jpg'
    merge_horizontal(main, chart, output)

for prop in property-*-1.jpg; do
    id="${prop%-1.jpg}"
    convert \
        "${id}-1.jpg" "${id}-2.jpg" +append \
        "${id}-3.jpg" "${id}-4.jpg" +append \
        -append -quality 100 "grids/${id}-grid.jpg"
done

for post_id in range(1, 51):
    frames = [f'frames/post-{post_id}-frame-{i}.jpg' for i in range(1, 6)]
    create_grid(frames, f'previews/preview-{post_id}.jpg', cols=5, spacing=5)

convert img1.jpg -resize x800 img2.jpg -resize x800 +append output.jpg

# Resize to same height
max_height = 800
img1 = img1.resize((int(img1.width * max_height / img1.height), max_height))
img2 = img2.resize((int(img2.width * max_height / img2.height), max_height))

convert img1.jpg img2.jpg +append -quality 100 output.jpg

image.save('output.jpg', 'JPEG', quality=95, optimize=True, subsampling=0)

def batch_merge_chunked(pairs, chunk_size=50):
    for i in range(0, len(pairs), chunk_size):
        chunk = pairs[i:i + chunk_size]
        for main, detail, output in chunk:
            merge_horizontal(main, detail, output)
        print(f'Processed chunk {i // chunk_size + 1}')

from datetime import datetime

timestamp = datetime.now().strftime('%Y%m%d-%H%M%S')
output = f'merged-{timestamp}-{base_name}.jpg'

# Create backup before processing
cp -r original/ backup/original-$(date +%Y%m%d)/

# Process first 5 pairs to verify settings
for i in {1..5}; do
    ./batch-merge.sh $i
done

git init
git add batch-merge.sh
git commit -m "Initial batch merge script"

import logging

logging.basicConfig(
    filename='batch-merge.log',
    level=logging.INFO,
    format='%(asctime)s - %(message)s'
)

logging.info(f'Processed: {output_path}')

def validate_output(output_path, min_size_kb=50):
    """Check if output file is valid."""
    if not os.path.exists(output_path):
        return False
    size_kb = os.path.getsize(output_path) / 1024
    if size_kb < min_size_kb:
        print(f'Warning: {output_path} is suspiciously small ({size_kb:.1f}KB)')
        return False
    return True

ls *-main.jpg | parallel -j 8 './merge-single.sh {}'

# Rename files to consistent pattern
i=1
for file in *.jpg; do
    mv "$file" "image-$(printf '%03d' $i).jpg"
    ((i++))
done

[
  {"output": "set1.jpg", "inputs": ["a.jpg", "b.jpg"]},
  {"output": "set2.jpg", "inputs": ["c.jpg", "d.jpg", "e.jpg"]}
]

convert img1.jpg img2.jpg +append -strip output.jpg

from PIL import Image
import piexif

exif_dict = piexif.load(img1_path)
image.save(output_path, 'JPEG', quality=95, exif=piexif.dump(exif_dict))

convert img1.jpg img2.jpg +append \
  -gravity southeast -pointsize 20 -fill white \
  -annotate +10+10 'Copyright 2025' output.jpg

main_folder = 'photos/main/'
detail_folder = 'photos/detail/'

for filename in os.listdir(main_folder):
    main = os.path.join(main_folder, filename)
    detail = os.path.join(detail_folder, filename)
    output = f'output/{filename}'
    merge_horizontal(main, detail, output)