File Conversion for E-Commerce

Format problems compound in e-commerce. A new supplier sends product images in TIFF. Their data feed is in XML when your PIM expects CSV. The merchandising team wants a printable PDF catalog but the data lives in a spreadsheet. Your product pages load slowly because the images are 2MB JPEGs instead of WebP. Each of these is a solved problem — the issue is having a reliable way to solve them at scale without manual intervention.

Where file conversion matters in e-commerce

The conversion needs in a typical e-commerce operation:

• Product image optimization — convert supplier-provided JPG/PNG to WebP for faster page loads and better Core Web Vitals
• Supplier feed normalization — suppliers send product data as XLSX, CSV, XML, or JSON; your import pipeline needs a consistent format
• High-res image handling — photographers deliver large TIFF or RAW files; you need web-ready JPEG and WebP derivatives
• Catalog PDF generation — sales team needs printable catalogs from spreadsheet data
• Marketplace-specific formats — Amazon requires JPEG, Google Shopping requires specific dimensions, social commerce has its own specs
• Import/export data — export order data as XLSX for accounting, import inventory updates from supplier CSV
• Archive management — receive product image sets in ZIP or RAR from suppliers, need to extract and process

Format pairs e-commerce teams convert most often

The specific routes that come up in e-commerce workflows:

• JPG / PNG → WebP — product images for Core Web Vitals improvement (client-side, files stay local)
• TIFF → JPG / WebP — normalize photography studio deliveries
• XLSX / XLS → CSV — supplier product feeds for PIM import
• CSV → XLSX — formatted reports for buying team review
• XML → JSON — parse supplier catalog data feeds for processing
• JSON → CSV — export order data for accounting or fulfillment
• ZIP / RAR → ZIP — repackage supplier image archives
• DOCX → PDF — finalize purchase orders and supplier agreements
• PNG → JPG — reduce file size for marketplace image uploads that have size limits

The browser tool for one-off product image conversions

For quick conversions, drop files at changethisfile.com. Product image conversions (JPG, PNG, TIFF, WebP) run in the browser — files stay on your device. No upload, no account.

Useful for:

• Converting a batch of images from a new supplier before setting up automation
• Spot-checking that a specific TIFF converts cleanly to WebP before processing all 500
• One-off feed conversions (a supplier sends an XLS file this one time)

For recurring workflows — processing every new supplier shipment, converting images on upload, normalizing weekly feed files — the API is more practical.

API automation for product pipelines

The API handles the repetitive work: every new product image gets converted to WebP, every supplier feed gets normalized to CSV before import. Free key covers 1,000 conversions/month — enough for small catalogs or development.

import requests
from pathlib import Path

CTF_API_KEY = "ctf_sk_your_key_here"

def convert_image(in_path: str, target_format: str, out_dir: str) -> str:
    """Convert a single image to target format."""
    source_ext = Path(in_path).suffix.lstrip(".").lower()
    with open(in_path, "rb") as f:
        resp = requests.post(
            "https://changethisfile.com/v1/convert",
            headers={"Authorization": f"Bearer {CTF_API_KEY}"},
            files={"file": f},
            data={"source": source_ext, "target": target_format},
            timeout=30,
        )
    resp.raise_for_status()
    out_path = Path(out_dir) / Path(in_path).with_suffix(f".{target_format}").name
    out_path.write_bytes(resp.content)
    return str(out_path)

def normalize_feed(xlsx_path: str, output_csv: str) -> str:
    """Convert supplier XLSX feed to CSV for PIM import."""
    with open(xlsx_path, "rb") as f:
        resp = requests.post(
            "https://changethisfile.com/v1/convert",
            headers={"Authorization": f"Bearer {CTF_API_KEY}"},
            files={"file": f},
            data={"source": "xlsx", "target": "csv"},
            timeout=30,
        )
    resp.raise_for_status()
    Path(output_csv).write_bytes(resp.content)
    return output_csv

Code example: bulk product image conversion to WebP

Processing a new supplier's image delivery: all JPEGs and TIFFs converted to WebP for CDN upload. Runs concurrently for speed.

import requests
import concurrent.futures
from pathlib import Path
from typing import Optional

CTF_API_KEY = "ctf_sk_your_key_here"
IMAGE_EXTENSIONS = {"jpg", "jpeg", "tiff", "tif", "png", "bmp"}

def convert_to_webp(in_path: Path, out_dir: Path) -> Optional[str]:
    """Convert a single image file to WebP."""
    ext = in_path.suffix.lstrip(".").lower()
    if ext not in IMAGE_EXTENSIONS:
        return None
    # Normalize jpeg → jpg
    source = "jpg" if ext in ("jpeg",) else ("tiff" if ext == "tif" else ext)
    try:
        with open(in_path, "rb") as f:
            resp = requests.post(
                "https://changethisfile.com/v1/convert",
                headers={"Authorization": f"Bearer {CTF_API_KEY}"},
                files={"file": f},
                data={"source": source, "target": "webp"},
                timeout=30,
            )
        resp.raise_for_status()
        out_path = out_dir / in_path.with_suffix(".webp").name
        out_path.write_bytes(resp.content)
        return str(out_path)
    except Exception as e:
        print(f"Failed {in_path.name}: {e}")
        return None

def bulk_convert_supplier_images(
    input_dir: str,
    output_dir: str,
    max_workers: int = 5,
) -> dict:
    """Bulk convert all images in a directory to WebP."""
    in_dir = Path(input_dir)
    out_dir = Path(output_dir)
    out_dir.mkdir(parents=True, exist_ok=True)

    images = [p for p in in_dir.iterdir() if p.suffix.lstrip(".").lower() in IMAGE_EXTENSIONS]
    print(f"Converting {len(images)} images to WebP...")

    success, failed = [], []
    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as pool:
        futures = {pool.submit(convert_to_webp, img, out_dir): img for img in images}
        for future in concurrent.futures.as_completed(futures):
            img = futures[future]
            result = future.result()
            if result:
                success.append(result)
            else:
                failed.append(str(img))

    print(f"Done: {len(success)} converted, {len(failed)} failed")
    return {"success": success, "failed": failed}

# Usage:
# bulk_convert_supplier_images("./supplier-delivery/images", "./cdn-ready/webp")

Pricing at e-commerce scale

For context: a 10,000 SKU catalog where each product has 5 images converts at 50,000 conversions — that's the Startup plan. If you're only converting on new product uploads (not re-converting the entire catalog), the Hobby plan often suffices.

FAQ

How much smaller are WebP images than JPEG?

WebP is typically 25-35% smaller than JPEG at equivalent visual quality. For e-commerce product images (usually detail shots on white backgrounds), the savings are often at the high end. Switching an image-heavy product page from JPEG to WebP can reduce total page weight by 30% or more.

What happens to a multi-sheet XLSX when converted to CSV?

Only the first sheet is converted. If your supplier feed spans multiple sheets, you'll need to split them first (save each sheet as a separate XLSX) before converting. Most product feeds use a single sheet — check before automating.

Can I convert RAW product photography (CR2, NEF, ARW)?

RAW formats are supported for conversion to JPEG and PNG. The server uses dcraw for RAW processing. Results depend on the file's embedded color profile and white balance settings. For professional photography workflows, test with your photographer's typical output before relying on it for production.

How do I handle supplier feeds in XML format?

XML → JSON conversion is client-side (files stay in browser). Once you have JSON, process it with your preferred language's JSON parser or use JSON → CSV if your PIM needs flat format. For complex XML schemas (nested products with variants), you may need post-processing after conversion.

Is there a limit on how many files I can drop at once in the browser tool?

The browser tool supports batch drops. Practical limit depends on browser memory — batches of 50-100 images work reliably. For 500+ files, the API with a concurrent worker pool is more appropriate.

Can I automate this as part of my Shopify or WooCommerce setup?

The API works with any HTTP client. For Shopify, you'd typically run the conversion pipeline on your own server (triggered by product webhooks) and then upload the converted images back via the Shopify Admin API. For WooCommerce, a plugin or background job using the API works similarly.

Related guides

Specific conversion guides for e-commerce tasks: