Optimize images for AI APIs with Python, reduce token consumption, and maintain accuracy
Join developers getting comprehensive guides, code examples, optimization tips, and time-saving prompts to accelerate their development workflow.
No spam. Unsubscribe anytime.
I was integrating Gemini AI for automated filename generation when I discovered my client's 4K product photos were consuming massive amounts of tokens. A single 3840x2160 image was costing $0.15 per API call, and with thousands of images to process, costs quickly spiraled to over $600 per batch.
After implementing intelligent image optimization, I reduced processing costs by 92% while maintaining perfect AI recognition accuracy. This guide shows you exactly how to optimize images for AI processing using Python, reducing both costs and processing time without sacrificing quality.
AI endpoints like OpenAI's Vision API, Google's Gemini, and Anthropic's Claude charge based on token consumption, and image size directly impacts cost. Here's what I discovered about pricing structures:
Most AI vision models perform equally well on images resized to 512px or smaller on the longest dimension. The key insight is that AI doesn't need the same resolution humans do for accurate object detection, text recognition, or content analysis.
Based on processing over 50,000 images through various AI endpoints, I developed a three-tier optimization approach that balances quality, cost, and processing speed:
The goal is reducing file size by 80-95% while maintaining all the visual information AI models need for accurate analysis.
Here's the production-tested image optimization system I use for AI processing:
# File: ai_image_optimizer.py
import io
import logging
from pathlib import Path
from typing import Tuple, Optional
from PIL import Image
logger = logging.getLogger(__name__)
class AIImageOptimizer:
"""Optimizes images specifically for AI processing to reduce costs and improve speed."""
def __init__(self, max_dimension: int = 512, jpeg_quality: int = 85):
"""
Initialize optimizer with settings optimized for AI processing.
Args:
max_dimension: Maximum pixels on longest side (512px recommended for most AI APIs)
jpeg_quality: JPEG compression quality (85 provides best size/quality balance)
"""
self.max_dimension = max_dimension
self.jpeg_quality = jpeg_quality
def optimize_for_ai(self, image_path: str) -> Tuple[bytes, dict]:
"""
Optimize image for AI processing with comprehensive metrics.
Returns:
Tuple of (optimized_image_bytes, optimization_metrics)
"""
original_path = Path(image_path)
# Read original image
with open(original_path, 'rb') as f:
original_bytes = f.read()
original_size = len(original_bytes)
try:
# Open with PIL
img = Image.open(io.BytesIO(original_bytes))
original_dimensions = img.size
original_format = img.format
# Calculate optimal dimensions
new_width, new_height = self._calculate_optimal_size(img.size)
# Resize if necessary
if max(img.size) > self.max_dimension:
img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
was_resized = True
else:
was_resized = False
# Convert to RGB if necessary (handles RGBA, P, etc.)
if img.mode in ('RGBA', 'LA', 'P'):
# Create white background for transparency
background = Image.new('RGB', img.size, (255, 255, 255))
if img.mode == 'P':
img = img.convert('RGBA')
background.paste(img, mask=img.split()[-1] if img.mode in ('RGBA', 'LA') else None)
img = background
elif img.mode != 'RGB':
img = img.convert('RGB')
# Save optimized image to bytes buffer
output_buffer = io.BytesIO()
img.save(output_buffer, format='JPEG', quality=self.jpeg_quality, optimize=True)
optimized_bytes = output_buffer.getvalue()
optimized_size = len(optimized_bytes)
# Calculate metrics
size_reduction_percent = ((original_size - optimized_size) / original_size) * 100
metrics = {
'original_size_bytes': original_size,
'optimized_size_bytes': optimized_size,
'size_reduction_percent': round(size_reduction_percent, 2),
'original_dimensions': original_dimensions,
'optimized_dimensions': (new_width, new_height) if was_resized else original_dimensions,
'was_resized': was_resized,
'original_format': original_format,
'optimized_format': 'JPEG'
}
logger.info(
f"Optimized {original_path.name}: {original_size} → {optimized_size} bytes "
f"({size_reduction_percent:.1f}% reduction)"
)
return optimized_bytes, metrics
except Exception as e:
logger.error(f"Failed to optimize {original_path.name}: {e}")
# Return original bytes with error metrics
return original_bytes, {
'original_size_bytes': original_size,
'optimized_size_bytes': original_size,
'size_reduction_percent': 0,
'original_dimensions': None,
'optimized_dimensions': None,
'was_resized': False,
'original_format': None,
'optimized_format': None,
'error': str(e)
}
def _calculate_optimal_size(self, original_size: Tuple[int, int]) -> Tuple[int, int]:
"""Calculate optimal dimensions maintaining aspect ratio."""
width, height = original_size
if max(width, height) <= self.max_dimension:
return width, height
if width > height:
new_width = self.max_dimension
new_height = int(height * (self.max_dimension / width))
else:
new_height = self.max_dimension
new_width = int(width * (self.max_dimension / height))
return new_width, new_height
def estimate_cost_savings(self, original_size_bytes: int, optimized_size_bytes: int,
cost_per_1k_tokens: float = 0.03) -> dict:
"""
Estimate cost savings based on typical AI endpoint pricing.
Args:
cost_per_1k_tokens: Cost per 1000 tokens (default based on Gemini pricing)
"""
# Rough estimation: 1000 bytes ≈ 100 tokens for images
original_tokens = original_size_bytes / 10
optimized_tokens = optimized_size_bytes / 10
original_cost = (original_tokens / 1000) * cost_per_1k_tokens
optimized_cost = (optimized_tokens / 1000) * cost_per_1k_tokens
savings = original_cost - optimized_cost
savings_percent = (savings / original_cost) * 100 if original_cost > 0 else 0
return {
'original_estimated_cost': round(original_cost, 4),
'optimized_estimated_cost': round(optimized_cost, 4),
'estimated_savings': round(savings, 4),
'savings_percent': round(savings_percent, 2)
}
Now let's create a batch processing system that handles multiple images efficiently:
# File: batch_ai_optimizer.py
import asyncio
import time
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from typing import List, Dict, Any
from ai_image_optimizer import AIImageOptimizer
class BatchAIOptimizer:
"""Batch process images for AI optimization with progress tracking."""
def __init__(self, max_dimension: int = 512, jpeg_quality: int = 85, max_workers: int = 4):
self.optimizer = AIImageOptimizer(max_dimension, jpeg_quality)
self.max_workers = max_workers
def process_directory(self, input_dir: str, output_dir: str = None,
supported_extensions: set = None) -> Dict[str, Any]:
"""
Process all images in a directory with optimization metrics.
"""
if supported_extensions is None:
supported_extensions = {'.jpg', '.jpeg', '.png', '.webp', '.bmp', '.tiff'}
input_path = Path(input_dir)
output_path = Path(output_dir) if output_dir else input_path / 'optimized'
output_path.mkdir(exist_ok=True)
# Find all supported images
image_files = [
f for f in input_path.rglob('*')
if f.is_file() and f.suffix.lower() in supported_extensions
]
if not image_files:
return {'error': 'No supported images found', 'processed': 0}
print(f"Found {len(image_files)} images to optimize...")
# Process with thread pool for I/O-bound operations
start_time = time.time()
results = []
total_original_size = 0
total_optimized_size = 0
with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
# Submit all optimization tasks
future_to_path = {
executor.submit(self._optimize_single_image, img_path, output_path): img_path
for img_path in image_files
}
# Collect results with progress tracking
for i, future in enumerate(future_to_path, 1):
try:
result = future.result()
results.append(result)
if 'error' not in result:
total_original_size += result['metrics']['original_size_bytes']
total_optimized_size += result['metrics']['optimized_size_bytes']
# Progress update every 10 files or at completion
if i % 10 == 0 or i == len(image_files):
print(f"Processed {i}/{len(image_files)} images...")
except Exception as e:
file_path = future_to_path[future]
results.append({
'file_path': str(file_path),
'error': str(e),
'metrics': {}
})
processing_time = time.time() - start_time
# Calculate overall metrics
successful_results = [r for r in results if 'error' not in r]
failed_count = len(results) - len(successful_results)
overall_reduction = 0
if total_original_size > 0:
overall_reduction = ((total_original_size - total_optimized_size) / total_original_size) * 100
# Estimate cost savings
cost_analysis = self.optimizer.estimate_cost_savings(
total_original_size, total_optimized_size
)
summary = {
'total_files': len(image_files),
'successful': len(successful_results),
'failed': failed_count,
'processing_time_seconds': round(processing_time, 2),
'total_original_size_mb': round(total_original_size / (1024 * 1024), 2),
'total_optimized_size_mb': round(total_optimized_size / (1024 * 1024), 2),
'overall_size_reduction_percent': round(overall_reduction, 2),
'cost_analysis': cost_analysis,
'results': results
}
self._print_summary(summary)
return summary
def _optimize_single_image(self, image_path: Path, output_dir: Path) -> Dict[str, Any]:
"""Optimize single image and save to output directory."""
try:
optimized_bytes, metrics = self.optimizer.optimize_for_ai(str(image_path))
# Save optimized image
output_path = output_dir / f"{image_path.stem}_optimized.jpg"
with open(output_path, 'wb') as f:
f.write(optimized_bytes)
return {
'original_path': str(image_path),
'optimized_path': str(output_path),
'metrics': metrics
}
except Exception as e:
return {
'original_path': str(image_path),
'error': str(e),
'metrics': {}
}
def _print_summary(self, summary: Dict[str, Any]):
"""Print formatted summary of batch processing results."""
print("\n" + "="*60)
print("AI IMAGE OPTIMIZATION SUMMARY")
print("="*60)
print(f"Files processed: {summary['successful']}/{summary['total_files']}")
print(f"Processing time: {summary['processing_time_seconds']}s")
print(f"Original total size: {summary['total_original_size_mb']} MB")
print(f"Optimized total size: {summary['total_optimized_size_mb']} MB")
print(f"Size reduction: {summary['overall_size_reduction_percent']}%")
print("\nCOST ANALYSIS:")
cost = summary['cost_analysis']
print(f"Estimated original cost: ${cost['original_estimated_cost']}")
print(f"Estimated optimized cost: ${cost['optimized_estimated_cost']}")
print(f"Estimated savings: ${cost['estimated_savings']} ({cost['savings_percent']}%)")
print("="*60)
Here's how to use the optimization system for different AI processing scenarios:
# File: ai_processing_examples.py
from batch_ai_optimizer import BatchAIOptimizer
from ai_image_optimizer import AIImageOptimizer
def optimize_for_content_analysis():
"""Optimize images for content analysis (object detection, scene understanding)."""
# For content analysis, 512px is optimal
optimizer = AIImageOptimizer(max_dimension=512, jpeg_quality=85)
optimized_bytes, metrics = optimizer.optimize_for_ai('product_photo_4k.jpg')
print(f"Optimization complete:")
print(f"Size reduction: {metrics['size_reduction_percent']}%")
print(f"Dimensions: {metrics['original_dimensions']} → {metrics['optimized_dimensions']}")
return optimized_bytes
def optimize_for_text_recognition():
"""Optimize images for OCR/text recognition - slightly higher resolution needed."""
# For text recognition, use 768px to preserve text clarity
optimizer = AIImageOptimizer(max_dimension=768, jpeg_quality=90)
optimized_bytes, metrics = optimizer.optimize_for_ai('document_scan.png')
return optimized_bytes
def batch_optimize_ecommerce_photos():
"""Optimize large batch of e-commerce product photos."""
# Standard optimization for product catalogs
batch_processor = BatchAIOptimizer(max_dimension=512, jpeg_quality=85, max_workers=8)
results = batch_processor.process_directory(
input_dir='/path/to/product/photos',
output_dir='/path/to/optimized/photos'
)
return results
def optimize_with_custom_settings():
"""Demonstrate custom optimization for specific AI use cases."""
# Ultra-aggressive optimization for large-scale processing
ultra_optimizer = AIImageOptimizer(max_dimension=256, jpeg_quality=75)
# Conservative optimization for high-quality analysis
conservative_optimizer = AIImageOptimizer(max_dimension=1024, jpeg_quality=95)
# Process same image with both approaches
test_image = 'sample_image.jpg'
ultra_bytes, ultra_metrics = ultra_optimizer.optimize_for_ai(test_image)
conservative_bytes, conservative_metrics = conservative_optimizer.optimize_for_ai(test_image)
print("COMPARISON:")
print(f"Ultra: {ultra_metrics['size_reduction_percent']}% reduction")
print(f"Conservative: {conservative_metrics['size_reduction_percent']}% reduction")
Here's how this optimization integrates into a production AI processing pipeline, based on the actual implementation from my image processing service:
# File: production_ai_integration.py
async def process_image_with_ai_optimization(image_path: str, ai_model, language_code: str):
"""Production implementation showing AI optimization in real pipeline."""
original_filename = os.path.basename(image_path)
try:
# Read original image
with open(image_path, 'rb') as f:
original_bytes = f.read()
# Optimize for AI processing
optimizer = AIImageOptimizer(max_dimension=250, jpeg_quality=85) # Conservative for production
optimized_bytes, metrics = optimizer.optimize_for_ai(image_path)
logger.info(
f"Optimized {original_filename}: {len(original_bytes)} → {len(optimized_bytes)} bytes "
f"({metrics['size_reduction_percent']}% reduction)"
)
# Use optimized bytes for AI processing
suggested_filename = await generate_filename_from_image(
model=ai_model,
image_bytes=optimized_bytes, # Use optimized bytes instead of original
filename=original_filename,
language_code=language_code,
mime_type='image/jpeg' # Always JPEG after optimization
)
return {
'success': True,
'suggested_filename': suggested_filename,
'optimization_metrics': metrics
}
except Exception as e:
logger.error(f"Error processing {original_filename}: {e}")
return {'success': False, 'error': str(e)}
Based on processing over 50,000 images through various AI endpoints, here are the real-world cost savings achieved:
| Image Type | Original Size | Optimized Size | Cost Reduction | AI Accuracy Impact |
|---|---|---|---|---|
| Product photos (4K) | 12-15 MB | 150-300 KB | 92-95% | No degradation |
| Screenshots (1080p) | 2-4 MB | 80-150 KB | 85-90% | No degradation |
| Document scans | 8-12 MB | 200-400 KB | 88-93% | Minimal impact |
| Social media images | 500KB-2MB | 50-120 KB | 75-85% | No degradation |
Key findings:
Choose appropriate dimensions based on AI task:
Use JPEG compression intelligently:
Handle edge cases gracefully:
Batch processing optimization:
Monitor and measure:
The image optimization system I've shown reduces AI processing costs by 85-95% while maintaining accuracy. For a typical e-commerce catalog with 10,000 product images, this represents savings of $500-2000 per processing batch, making AI-powered image analysis economically viable at scale.
Start with the conservative settings (512px, 85% quality) and adjust based on your specific AI accuracy requirements and cost constraints. The upfront implementation investment pays for itself within the first batch of processed images.
Thanks, Matija