7 Proven Ways to Image Scraping With Python in 2026: Complete guide

import requests
from bs4 import BeautifulSoup
import os
import urllib.parse
import mimetypes

def scrape_static_images(url, save_folder="images"):
    """
    Batch image download Python function.
    Handles relative URLs robustly and streams downloads.
    """
    os.makedirs(save_folder, exist_ok=True)
    
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
    except requests.RequestException as e:
        print(f"✗ Failed to retrieve the main URL: {e}")
        return

    soup = BeautifulSoup(response.content, "html.parser")
    img_tags = soup.find_all("img")
    
    base_url = response.url

    for index, img in enumerate(img_tags, 1):
        src_url = img.get("src") or img.get("data-src")

        if not src_url:
            continue
        
        img_url = urllib.parse.urljoin(base_url, src_url)

        try:
            if not img_url.startswith('http'):
                continue

            img_response = requests.get(img_url, timeout=5, stream=True)
            img_response.raise_for_status()

            content_type = img_response.headers.get('content-type', '')
            ext = mimetypes.guess_extension(content_type)
            if not ext:
                ext = os.path.splitext(urllib.parse.urlparse(img_url).path)[1] or '.jpg'

            filename = f"{save_folder}/image_{index}{ext}"
            
            with open(filename, "wb") as f:
                for chunk in img_response.iter_content(1024):
                    f.write(chunk)
            print(f"✓ Downloaded image {index} as {os.path.basename(filename)}")
            
        except requests.RequestException as e:
            print(f"✗ Failed to download {img_url}: {e}")

if __name__ == "__main__":
    target_url = "https://example.com"
    scrape_static_images(target_url)

import asyncio
from playwright.async_api import async_playwright
import os
import urllib.parse
import mimetypes

async def scrape_dynamic_images(url, save_folder="images", max_concurrent=10):
    """
    Extract images from website using Playwright Python.
    Uses async download for efficiency.
    """
    os.makedirs(save_folder, exist_ok=True)
    
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()
        
        try:
            await page.goto(url, wait_until="networkidle", timeout=30000)
            
            image_urls = await page.evaluate("""
                () => {
                    const images = document.querySelectorAll('img, [style*="background-image"]');
                    const urls = [];
                    
                    images.forEach(img => {
                        if (img.src && !img.src.startsWith('data:')) {
                            urls.push(img.src);
                        }
                        if (img.dataset.src && !img.dataset.src.startsWith('data:')) {
                            urls.push(img.dataset.src);
                        }
                        if (img.srcset) {
                            const srcset = img.srcset.split(',').pop().trim().split(' ')[0];
                            if (srcset && !srcset.startsWith('data:')) {
                                urls.push(srcset);
                            }
                        }
                    });
                    
                    return [...new Set(urls)];
                }
            """)
            
            print(f"Found {len(image_urls)} unique image URLs")
            
            semaphore = asyncio.Semaphore(max_concurrent)
            
            async def download_with_semaphore(index, img_url):
                async with semaphore:
                    await download_image(page, index, img_url, save_folder)
            
            tasks = [download_with_semaphore(i, url) for i, url in enumerate(image_urls, 1)]
            await asyncio.gather(*tasks, return_exceptions=True)
            
        finally:
            await browser.close()

async def download_image(page, index, img_url, save_folder):
    """Async download helper using Playwright Python."""
    try:
        if not img_url.startswith('http'):
            return
        
        response = await page.goto(img_url, wait_until="load", timeout=10000)
        
        if response and response.status == 200:
            body = await response.body()
            content_type = response.headers.get('content-type', 'image/jpeg')
            ext = mimetypes.guess_extension(content_type) or '.jpg'
            
            filename = f"{save_folder}/image_{index}{ext}"
            
            with open(filename, 'wb') as f:
                f.write(body)
            
            print(f"✓ Downloaded dynamic image {index} ({len(body)/1024:.1f}KB)")
            
    except Exception as e:
        print(f"✗ Failed to download image {index}: {e}")

if __name__ == "__main__":
    target_url = "https://example.com"
    asyncio.run(scrape_dynamic_images(target_url))

import aiohttp
import asyncio
import os
import mimetypes

async def download_image_async(session, url, filename, index, semaphore):
    """Concurrent image downloads with semaphore control."""
    async with semaphore:
        try:
            async with session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as response:
                if response.status == 200:
                    body = await response.read()
                    content_type = response.headers.get('content-type', 'image/jpeg')
                    ext = mimetypes.guess_extension(content_type) or '.jpg'
                    
                    final_filename = f"{filename.replace('.jpg', '')}{ext}"
                    
                    with open(final_filename, 'wb') as f:
                        f.write(body)
                    
                    print(f"✓ Downloaded {index}: {len(body)/1024:.1f}KB")
                    return True
                    
        except asyncio.TimeoutError:
            print(f"✗ Timeout downloading image {index}")
        except Exception as e:
            print(f"✗ Error downloading image {index}: {e}")
        
        return False

async def scrape_images_concurrent(image_urls, save_folder="images", concurrent=50):
    """
    Concurrent image downloads using aiohttp.
    Implements batch image download Python strategies.
    """
    os.makedirs(save_folder, exist_ok=True)
    
    connector = aiohttp.TCPConnector(limit=concurrent)
    
    async with aiohttp.ClientSession(connector=connector) as session:
        semaphore = asyncio.Semaphore(concurrent)
        
        tasks = []
        for index, url in enumerate(image_urls, 1):
            filename = f"{save_folder}/image_{index}.jpg"
            task = download_image_async(session, url, filename, index, semaphore)
            tasks.append(task)
        
        results = await asyncio.gather(*tasks, return_exceptions=True)
        success_count = sum(1 for r in results if r is True)
        
        print(f"\n✓ Downloaded {success_count}/{len(image_urls)} images")
        return success_count

if __name__ == "__main__":
    image_urls = [
        "https://example.com/image1.jpg",
        "https://example.com/image2.jpg",
    ]
    
    asyncio.run(scrape_images_concurrent(image_urls, concurrent=50))

from PIL import Image
from PIL.ExifTags import TAGS
import os

def compress_and_resize_images(input_folder, output_folder, max_size=(1200, 1200), quality=85):
    """
    Python image automation: batch resize and compress.
    """
    os.makedirs(output_folder, exist_ok=True)
    
    total_original = 0
    total_compressed = 0
    
    for filename in os.listdir(input_folder):
        if not filename.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
            continue
        
        filepath = os.path.join(input_folder, filename)
        
        try:
            img = Image.open(filepath)
            img.thumbnail(max_size, Image.Resampling.LANCZOS)
            
            if img.mode in ('RGBA', 'LA', 'P'):
                rgb_img = Image.new('RGB', img.size, (255, 255, 255))
                rgb_img.paste(img, mask=img.split()[-1] if img.mode == 'RGBA' else None)
                img = rgb_img
            
            output_path = os.path.join(output_folder, filename)
            img.save(output_path, quality=quality, optimize=True)
            
            original_size = os.path.getsize(filepath)
            compressed_size = os.path.getsize(output_path)
            savings = (1 - compressed_size / original_size) * 100
            
            total_original += original_size
            total_compressed += compressed_size
            
            print(f"✓ {filename}: {savings:.1f}% reduction")
            
        except Exception as e:
            print(f"✗ Error processing {filename}: {e}")
    
    if total_original > 0:
        total_savings = (1 - total_compressed / total_original) * 100
        print(f"\n✓ Total: {total_savings:.1f}% reduction")

if __name__ == "__main__":
    compress_and_resize_images("images", "images_compressed")

import re

def scrape_css_background_images(url, save_folder="images"):
    """Extract images from website using CSS parsing."""
    response = requests.get(url)
    soup = BeautifulSoup(response.content, "html.parser")
    
    image_urls = []
    
    for element in soup.find_all(style=True):
        style = element.get("style", "")
        urls = re.findall(r'url\([\'"]?([^\)\'\"]+)[\'"]?\)', style)
        image_urls.extend(urls)
    
    for style_tag in soup.find_all("style"):
        style_content = style_tag.string or ""
        urls = re.findall(r'url\([\'"]?([^\)\'\"]+)[\'"]?\)', style_content)
        image_urls.extend(urls)
    
    print(f"Found {len(set(image_urls))} unique background images")
    
    for index, img_url in enumerate(set(image_urls), 1):
        try:
            img_url = urllib.parse.urljoin(url, img_url)
            img_response = requests.get(img_url, timeout=5)
            with open(f"{save_folder}/bg_{index}.jpg", "wb") as f:
                f.write(img_response.content)
        except:
            pass

async def scrape_lazy_loaded_images(url, save_folder="images"):
    """Extract images from website using JavaScript rendering."""
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()
        await page.goto(url)
        
        await page.evaluate("""
            async () => {
                let scrolled = 0;
                while (scrolled < document.body.scrollHeight) {
                    window.scrollBy(0, window.innerHeight);
                    await new Promise(resolve => setTimeout(resolve, 500));
                    scrolled += window.innerHeight;
                }
            }
        """)
        
        image_urls = await page.evaluate("""
            () => {
                return Array.from(document.querySelectorAll('img'))
                    .map(img => img.dataset.src || img.src)
                    .filter(src => src && !src.includes('placeholder'));
            }
        """)
        
        print(f"Found {len(image_urls)} real images")

import random
import time
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def create_session_with_evasion():
    """Anti-bot detection evasion using realistic headers."""
    session = requests.Session()
    
    retry = Retry(
        total=5,
        backoff_factor=1,
        status_forcelist=[429, 500, 502, 503, 504]
    )
    adapter = HTTPAdapter(max_retries=retry)
    session.mount('http://', adapter)
    session.mount('https://', adapter)
    
    session.headers.update({
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        'Accept': 'image/webp,image/apng,image/*,*/*;q=0.8',
        'Accept-Language': 'en-US,en;q=0.9',
        'Accept-Encoding': 'gzip, deflate',
        'DNT': '1',
        'Connection': 'keep-alive'
    })
    
    return session

def scrape_with_evasion(image_urls, save_folder="images"):
    """Web scraping with Python featuring anti-bot detection evasion."""
    session = create_session_with_evasion()
    os.makedirs(save_folder, exist_ok=True)
    
    for index, url in enumerate(image_urls, 1):
        try:
            time.sleep(random.uniform(2, 8))
            response = session.get(url, timeout=15)
            response.raise_for_status()
            
            with open(f"{save_folder}/image_{index}.jpg", "wb") as f:
                f.write(response.content)
            print(f"✓ Downloaded {index}")
        except Exception as e:
            print(f"✗ Failed: {e}")

import hashlib

def deduplicate_images(folder):
    """Remove duplicate images."""
    seen_hashes = {}
    duplicates = []
    
    for filename in os.listdir(folder):
        filepath = os.path.join(folder, filename)
        
        sha256_hash = hashlib.sha256()
        with open(filepath, "rb") as f:
            for byte_block in iter(lambda: f.read(4096), b""):
                sha256_hash.update(byte_block)
        
        file_hash = sha256_hash.hexdigest()
        
        if file_hash in seen_hashes:
            duplicates.append((filename, seen_hashes[file_hash]))
            os.remove(filepath)
        else:
            seen_hashes[file_hash] = filename
    
    print(f"✓ Removed {len(duplicates)} duplicate images")
    print(f"✓ Kept {len(seen_hashes)} unique images")