Convert Files for Google Merchant Center

Google Merchant Center has more nuanced image requirements than most platforms, because images feed two distinct surfaces: free product listings on Google Shopping and paid Shopping ads. The quality bar is higher for ads, and Google's automated policy enforcement will disapprove products with low-resolution, watermarked, or improperly cropped images — sometimes without clear error messaging. Getting image specs right upfront prevents feed disapprovals that can silently kill ad campaigns.

Google Merchant Center image and video specifications

Per Google's product image requirements:

Product Images

• Minimum size: 100×100 px for non-apparel products; 250×250 px for apparel. These are the absolute minimums — images at these sizes will be approved but will underperform in ads.
• Recommended size: 800×800 px or larger. Google recommends this for Shopping ads to enable zoom functionality. Higher-resolution images (1000×1000 px+) get better placement in some ad formats.
• Maximum size: 64 megapixels (e.g., 8000×8000 px). File size limit: 16 MB.
• Accepted formats: JPEG (.jpg), PNG (.png), WebP (.webp), GIF (non-animated for main image). HEIC, TIFF, BMP, and AVIF are not accepted.
• Aspect ratio: Square (1:1) strongly preferred for the main product image. Non-square images are accepted but may be padded or cropped in display.
• Background: White or light neutral background recommended for main product image. Lifestyle/contextual images work for additional images.
• Prohibited: Watermarks, borders, promotional text overlays, placeholder graphics, blurry or out-of-focus images, images showing only packaging (product must be visible).

Product Videos (additional_image_link attribute)

• Accepted formats: MP4, MOV, AVI, WMV, FLV, MKV, WebM, 3GPP
• Recommended codec: H.264 video, AAC audio
• Maximum file size: 5 GB
• Duration: 15 seconds to 10 minutes (Google recommends 15–60 seconds for Shopping)
• Resolution: 1280×720 px minimum for Shopping ads; 1920×1080 px recommended

Feed Files (for bulk uploads)

• Accepted formats: TSV (.txt), CSV, XML, Google Sheets, API
• Maximum feed file size: 4 GB uncompressed; can be gzipped for upload

Recommended source-to-target pairs

Conversion commands (curl + Python)

# curl — convert HEIC to JPEG for Google Merchant Center
curl -X POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer ctf_sk_your_key_here" \
  -F "file=@product.heic" \
  -F "target=jpg" \
  -o gmc-product.jpg

# Convert PNG to WebP (smaller files, faster feed crawl)
curl -X POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer ctf_sk_your_key_here" \
  -F "file=@product.png" \
  -F "target=webp" \
  -o gmc-product.webp

import requests
from pathlib import Path

API_KEY = "ctf_sk_your_key_here"

def convert_for_gmc(in_path: str, out_path: str, target: str = "jpg") -> None:
    """Convert image to Google Merchant Center-compatible format."""
    with open(in_path, "rb") as f:
        resp = requests.post(
            "https://changethisfile.com/v1/convert",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"file": f},
            data={"target": target},
            timeout=120,
        )
    resp.raise_for_status()
    out = Path(out_path)
    out.write_bytes(resp.content)
    kb = len(resp.content) / 1024
    print(f"{out.name}: {kb:.0f} KB ({target.upper()})")

# Convert all product images
for src in ["product-1.heic", "product-2.tiff", "product-3.bmp"]:
    out = src.rsplit(".", 1)[0] + ".jpg"
    convert_for_gmc(src, out)

For bulk feed preparation with dimension enforcement (ensures 800×800 px minimum):

# ImageMagick: resize to 1000x1000, white background, JPEG 90%
convert input.png \
  -background white -flatten \
  -resize 1000x1000 \
  -gravity center -extent 1000x1000 \
  -quality 90 \
  gmc-product.jpg

# FFmpeg: convert MOV product video to MP4 H.264 for GMC
ffmpeg -i product-video.mov \
  -c:v libx264 -crf 22 -preset fast \
  -c:a aac -b:a 128k \
  -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" \
  gmc-video.mp4

Batch script: convert a product catalog for Google Shopping

#!/usr/bin/env bash
# Usage: ./convert_gmc_batch.sh ./raw-catalog ./gmc-ready [jpg|webp]
# Converts HEIC, TIFF, BMP, PNG → GMC-ready images

API_KEY="ctf_sk_your_key_here"
INPUT_DIR="${1:-.}"
OUTPUT_DIR="${2:-./gmc-ready}"
TARGET="${3:-jpg}"

mkdir -p "$OUTPUT_DIR"
success=0; failed=0

for img in "$INPUT_DIR"/*.{heic,HEIC,tiff,tif,TIF,bmp,BMP,png,PNG,webp}; do
  [ -f "$img" ] || continue
  base=$(basename "$img" | sed 's/\.[^.]*$//')
  out="$OUTPUT_DIR/${base}.${TARGET}"

  printf "%-50s" "$(basename $img) → ${TARGET}..."
  code=$(curl -s -o "$out" -w "%{http_code}" \
    -X POST https://changethisfile.com/v1/convert \
    -H "Authorization: Bearer $API_KEY" \
    -F "file=@$img" \
    -F "target=$TARGET")

  if [ "$code" = "200" ]; then
    kb=$(du -k "$out" | cut -f1)
    echo "OK (${kb} KB)"
    ((success++))
  else
    echo "FAILED (HTTP $code)"
    rm -f "$out"
    ((failed++))
  fi
done

echo ""
echo "Results: $success OK, $failed failed → $OUTPUT_DIR"
echo "Next: update image_link column in your feed file to point to the new URLs."

Google Merchant Center gotchas

• Watermarks cause automatic disapprovals. Google's image policy scanner flags promotional text, watermarks, and borders. Even subtle branded watermarks in corners can trigger a disapproval. Use clean, product-only photos for the main image_link attribute.
• Google crawls your image URLs — redirects slow feed processing. If your image URLs redirect (HTTP 301/302) to the actual image, Google has to follow the redirect on every feed refresh. Use the final CDN URL directly in your feed. Avoid using URLs that require authentication or rate-limit Googlebot.
• WebP is smaller and accepted — but test with your CDN. WebP images are accepted by Google Merchant Center and are typically 25–35% smaller than equivalent JPEG. Smaller images mean faster feed crawls and lower CDN costs. However, ensure your CDN serves WebP with the correct MIME type (image/webp) — some legacy CDN configs serve it as application/octet-stream, which Google will reject.
• Apparel has stricter dimension requirements. Clothing, shoes, and accessories require at least 250×250 px (not 100×100 px like non-apparel). For apparel Shopping ads, 1000×1200 px portrait images outperform square crops in Google's own testing.
• Product disapprovals don't always cite the image. If products are disapproved for "missing required attribute" or "policy violation," check the image first. Google's disapproval messages are often generic. Use the Diagnostics tab in Merchant Center to see which products are affected.
• Feed files over 4GB must be gzipped. For large catalogs, compress your TSV/CSV feed with gzip before uploading. Google accepts .gz files and processes them without decompression on your end.

Feed file format tips for large catalogs

Beyond image format, the feed file itself has format requirements that cause silent failures:

• UTF-8 encoding with BOM causes parse errors. Save feed TSV/CSV files as UTF-8 without BOM. Excel and some Windows tools add a BOM character that confuses Google's feed parser, causing the first product row to fail silently.
• Gzip feed files for uploads over 100MB. Gzipped TSV uploads significantly faster and is more reliable for large catalogs. Google decompresses on their end.
• Image URLs must be publicly accessible. Google's crawler must reach image URLs without authentication. If you're testing with staging URLs behind HTTP auth, products will fail with a cryptic crawl error — not a clear auth error.

# Gzip a large feed file for upload
gzip -k product-feed.txt
# Produces product-feed.txt.gz — upload this to Merchant Center

Google Merchant Center's image requirements are enforced automatically, and disapprovals silently remove products from Shopping. A clean conversion workflow — correct format, minimum 800×800 px, no overlays — prevents the most common feed issues. Free tier covers 1,000 conversions/month.