Meet Amazon, Shopify, and Etsy Image Requirements — Automatically

Every Marketplace Has Different Rules

You have a product photo. One photo. You need it on Amazon, Shopify, and Etsy. Each marketplace wants something different.

Amazon requires JPEG or PNG, minimum 1000x1000 pixels for zoom functionality, white background (RGB 255,255,255), and recommends images be 2000px on the longest side. Shopify accepts up to 4472x4472 but recommends 2048x2048, supports JPEG, PNG, and WebP, and has a 20MB file size limit. Etsy wants at least 2000px on the shortest side for their zoom feature, supports JPEG, PNG, and GIF, and recommends a 5:4 aspect ratio for listing thumbnails.

That’s three different sets of dimensions, three different format preferences, and three different rules about backgrounds and aspect ratios. For one product. Multiply by your catalog size and you’re looking at hours of manual image editing — or a fragile script that breaks every time a marketplace updates its guidelines.

The Image Transformation API lets you define a pipeline for each marketplace and process every product image automatically.

The Amazon Pipeline

Amazon’s requirements are strict about backgrounds. The main listing image must have a pure white background. If your product photos are shot on a slightly off-white backdrop, or have transparency from being cut out in Photoshop, they’ll get flagged.

import { IterationLayer } from "iterationlayer";

const client = new IterationLayer({ apiKey: "YOUR_API_KEY" });

const result = await client.transform({
  file: { type: "url", name: "product.png", url: sourceUrl },
  operations: [
    // Remove transparency — composites onto white background
    { type: "remove_transparency", hex_color: "#FFFFFF" },
    // Resize to Amazon's recommended 2000px, maintaining aspect ratio
    { type: "resize", width_in_px: 2000, height_in_px: 2000, fit: "inside" },
    // Sharpen after resize to keep product detail crisp
    { type: "sharpen", sigma: 0.5 },
    // Amazon prefers JPEG for photos
    { type: "convert", format: "jpeg", quality: 90 },
  ],
});

remove_transparency handles PNG images with alpha channels by compositing them onto white. fit: "inside" ensures neither dimension exceeds 2000px while preserving the aspect ratio — a 3000x2000 image becomes 2000x1333, and a 2000x3000 image becomes 1333x2000.

Quality 90 keeps product detail sharp without bloating file size. Amazon doesn’t have a strict file size limit per image, but keeping images under 5MB improves upload speed and page load time.

The Shopify Pipeline

Shopify is more flexible on backgrounds but has its own dimension sweet spot. Their CDN automatically serves different sizes based on the customer’s screen, so uploading at 2048x2048 gives the CDN enough resolution to work with.

const shopifyOperations = [
  // Constrain to Shopify's recommended max
  { type: "resize", width_in_px: 2048, height_in_px: 2048, fit: "inside" },
  { type: "sharpen", sigma: 0.5 },
  // WebP for smaller files — Shopify's CDN handles format negotiation,
  // but uploading WebP gives a head start
  { type: "convert", format: "webp", quality: 85 },
];

If you want to keep file sizes lean for faster uploads — especially when syncing a large catalog — add compress_to_size:

const shopifyOperations = [
  { type: "resize", width_in_px: 2048, height_in_px: 2048, fit: "inside" },
  { type: "sharpen", sigma: 0.5 },
  { type: "convert", format: "webp" },
  { type: "compress_to_size", max_file_size_in_bytes: 2_000_000 },
];

The Etsy Pipeline

Etsy emphasizes aspect ratio. Listing thumbnails display at 5:4, and images that don’t match get cropped unpredictably by Etsy’s own system. Better to control the crop yourself.

const etsyOperations = [
  // Smart crop to 5:4 aspect ratio — AI detects the product and crops around it
  { type: "smart_crop", width_in_px: 2500, height_in_px: 2000 },
  // Sharpen after crop
  { type: "sharpen", sigma: 0.5 },
  // JPEG for broad compatibility
  { type: "convert", format: "jpeg", quality: 90 },
];

smart_crop is the key here. Instead of center-cropping — which might cut off the top of a vase or the handle of a bag — it uses AI object detection to find the product in the image and crops around it. The result is a 5:4 image with the product centered and visible.

One Source, All Variants

The real value is generating all marketplace variants from a single source image. Upload once, transform three (or more) times.

const MARKETPLACE_PIPELINES = {
  amazon: [
    { type: "remove_transparency", hex_color: "#FFFFFF" },
    { type: "resize", width_in_px: 2000, height_in_px: 2000, fit: "inside" },
    { type: "sharpen", sigma: 0.5 },
    { type: "convert", format: "jpeg", quality: 90 },
  ],
  shopify: [
    { type: "resize", width_in_px: 2048, height_in_px: 2048, fit: "inside" },
    { type: "sharpen", sigma: 0.5 },
    { type: "convert", format: "webp", quality: 85 },
  ],
  etsy: [
    { type: "smart_crop", width_in_px: 2500, height_in_px: 2000 },
    { type: "sharpen", sigma: 0.5 },
    { type: "convert", format: "jpeg", quality: 90 },
  ],
} as const;

const transformForMarketplace = async (
  imageUrl: string,
  fileName: string,
  marketplace: keyof typeof MARKETPLACE_PIPELINES,
) => {
  const result = await client.transform({
    file: { type: "url", name: fileName, url: imageUrl },
    operations: MARKETPLACE_PIPELINES[marketplace],
  });

  return Buffer.from(result.data.buffer, "base64");
};

// Generate all variants for one product image
const sourceUrl = "https://cdn.example.com/products/raw/widget-001.png";

const [amazonImage, shopifyImage, etsyImage] = await Promise.all([
  transformForMarketplace(sourceUrl, "widget-001.png", "amazon"),
  transformForMarketplace(sourceUrl, "widget-001.png", "shopify"),
  transformForMarketplace(sourceUrl, "widget-001.png", "etsy"),
]);

Three API calls in parallel, three marketplace-ready images. The source image stays untouched in your storage. Each marketplace gets exactly what it needs.

Processing an Entire Catalog

When you have hundreds or thousands of products, the pattern scales linearly. Each product image gets the same pipeline treatment.

const productImages = [
  { url: "https://cdn.example.com/products/raw/widget-001.png", name: "widget-001.png" },
  { url: "https://cdn.example.com/products/raw/widget-002.png", name: "widget-002.png" },
  { url: "https://cdn.example.com/products/raw/gadget-001.jpg", name: "gadget-001.jpg" },
  // ... hundreds more
];

// Process all products for Amazon
const amazonImages = await Promise.all(
  productImages.map(({ url, name }) => transformForMarketplace(url, name, "amazon"))
);

For large catalogs, you’ll want to batch with concurrency limits rather than firing all requests at once. But the API handles each request independently — there’s no state to manage, no queue to monitor, no server to scale.

Handling Edge Cases

Product photography isn’t always clean. Here are pipelines for common issues.

DSLR photos with EXIF rotation. Some cameras store orientation in EXIF metadata instead of rotating the actual pixels. The rotate operation with angle_in_degrees: 0 normalizes EXIF orientation — the image pixels are rotated to match the metadata, and the metadata is stripped.

const operations = [
  { type: "rotate", angle_in_degrees: 0 },
  { type: "resize", width_in_px: 2000, height_in_px: 2000, fit: "inside" },
  { type: "convert", format: "jpeg", quality: 90 },
];

Underexposed product photos. Phone cameras in poor lighting produce dark, flat images. auto_contrast normalizes the histogram — stretching the brightness range so whites are white and darks are dark. modulate can bump brightness further if needed.

const operations = [
  { type: "auto_contrast" },
  { type: "modulate", brightness: 1.1 },
  { type: "resize", width_in_px: 2000, height_in_px: 2000, fit: "inside" },
  { type: "sharpen", sigma: 0.5 },
  { type: "convert", format: "jpeg", quality: 90 },
];

Low-resolution source images. If your source image is too small for a marketplace’s minimum dimension, upscale can increase resolution by 2x, 3x, or 4x using AI upscaling. A 500x500 image upscaled 4x becomes 2000x2000 — meeting Amazon’s requirement.

const operations = [
  { type: "upscale", factor: 4 },
  { type: "sharpen", sigma: 0.3 },
  { type: "convert", format: "jpeg", quality: 90 },
];

Why Not Just Resize

Resizing alone doesn’t solve the problem. Marketplace image requirements go beyond dimensions.

Format matters — Amazon wants JPEG, Shopify benefits from WebP, and sending a PNG photo with 24-bit color wastes file size. Background matters — Amazon’s white background requirement catches a lot of sellers off guard. Aspect ratio matters — Etsy’s thumbnail crop can hide your product if you don’t control it.

A resize-only approach also misses quality optimization. A DSLR photo resized to 2000x2000 at default quality might be 3MB. The same image at quality 90 might be 800KB with no visible difference. Multiply that by a catalog of 500 products and you’re saving gigabytes of storage and bandwidth.

The pipeline approach handles all of these concerns in one pass: resize, fix the background, crop to the right aspect ratio, convert to the right format, and optimize quality. One API call per variant.

Get Started

The Image Transformation API is part of Iteration Layer. Sign up for a free account — no credit card required — and get an API key in the dashboard.

The Image Transformation docs cover all 24 operations with parameters and examples. Define your marketplace pipelines once, and every new product image gets processed automatically.