Iteration Layer
Products
Use Cases
Resources
Pricing
Login Get Started

Image Processing for E-Commerce: Resize, Watermark, and Optimize in One API Call

18 min read Image Transformation

Every Marketplace Wants Something Different

If you sell products on more than one platform, you already know the pain. Amazon wants 1,000 x 1,000 pixels minimum on a pure white background. Shopify themes look best at 2,048 x 2,048. Etsy recommends 2,000 pixels on the shortest side. eBay wants at least 500 x 500 but renders thumbnails at 300 x 300. Your own website needs WebP for performance, JPEG for email campaigns, and a compressed version under 200 KB for mobile push notifications.

That is five different size requirements, three different formats, and a background removal step — for a single product photo. Multiply by a catalog of 500 SKUs and you have a pipeline problem, not an image problem.

Most teams cobble this together. A Sharp script in a Docker container. A cron job that watches an S3 bucket. A Lambda function that calls ImageMagick. Maybe Cloudinary for the CDN part, but now you are managing two systems. Every new marketplace means another resize preset, another format branch, another edge case where a CMYK TIFF or a transparent PNG breaks the pipeline at 3 AM.

The individual operations are not hard. Resizing an image is a solved problem. What is hard is chaining those operations together across formats, sizes, and quality targets — without maintaining the infrastructure yourself.

One Request, Multiple Operations

The Image Transformation API takes a different approach. Instead of running a series of tools in sequence, you describe the entire transformation chain in a single request. The API executes the operations in order, passes the result of each step to the next, and returns the final image.

Here is the simplest case: resize a product photo and convert it to WebP.

Request
curl -X POST \
  https://api.iterationlayer.com/image-transformation/v1/transform \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file": {
      "type": "url",
      "name": "product.jpg",
      "url": "https://example.com/images/product.jpg"
    },
    "operations": [
      {
        "type": "resize",
        "width_in_px": 1000,
        "height_in_px": 1000,
        "fit": "contain"
      },
      {
        "type": "convert",
        "format": "webp",
        "quality": 85
      }
    ]
  }'
Response
{
  "success": true,
  "data": {
    "buffer": "<base64-encoded image>",
    "mime_type": "image/webp"
  }
}
Request
import { IterationLayer } from "iterationlayer";

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

const result = await client.transform({
  file: {
    type: "url",
    name: "product.jpg",
    url: "https://example.com/images/product.jpg",
  },
  operations: [
    {
      type: "resize",
      width_in_px: 1000,
      height_in_px: 1000,
      fit: "contain",
    },
    {
      type: "convert",
      format: "webp",
      quality: 85,
    },
  ],
});
Response
{
  "success": true,
  "data": {
    "buffer": "<base64-encoded image>",
    "mime_type": "image/webp"
  }
}
Request
from iterationlayer import IterationLayer

client = IterationLayer(api_key="YOUR_API_KEY")

result = client.transform(
    file={
        "type": "url",
        "name": "product.jpg",
        "url": "https://example.com/images/product.jpg",
    },
    operations=[
        {
            "type": "resize",
            "width_in_px": 1000,
            "height_in_px": 1000,
            "fit": "contain",
        },
        {
            "type": "convert",
            "format": "webp",
            "quality": 85,
        },
    ],
)
Response
{
  "success": true,
  "data": {
    "buffer": "<base64-encoded image>",
    "mime_type": "image/webp"
  }
}
Request
package main

import il "github.com/iterationlayer/sdk-go"

client := il.NewClient("YOUR_API_KEY")

result, err := client.Transform(il.TransformRequest{
    File: il.NewFileFromURL(
        "product.jpg",
        "https://example.com/images/product.jpg",
    ),
    Operations: []il.TransformOperation{
        il.NewResizeOperation(1000, 1000, "contain"),
        il.NewConvertOperation("webp"),
    },
})
Response
{
  "success": true,
  "data": {
    "buffer": "<base64-encoded image>",
    "mime_type": "image/webp"
  }
}

Two operations, one request. The contain fit mode keeps the aspect ratio intact and fits the image within the target dimensions. The response is a base64-encoded buffer you can write directly to disk or upload to your CDN.

That is the foundation. The real value comes when you start chaining more operations together.

Background Removal for White-Background Requirements

Amazon, Google Shopping, and most comparison shopping engines require a white or neutral background. If your product photos come from a studio with a gray backdrop, or from a supplier who shoots on a wooden table, you need to remove the background before uploading.

The remove_background operation detects the foreground subject and strips away everything else. You can optionally replace the removed background with a solid color — white for Amazon, transparent for your own website where you composite on custom backgrounds.

curl -X POST \
  https://api.iterationlayer.com/image-transformation/v1/transform \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file": {
      "type": "url",
      "name": "product-raw.jpg",
      "url": "https://example.com/images/product-raw.jpg"
    },
    "operations": [
      {
        "type": "remove_background",
        "background_hex_color": "#FFFFFF"
      },
      {
        "type": "resize",
        "width_in_px": 1000,
        "height_in_px": 1000,
        "fit": "contain"
      },
      {
        "type": "convert",
        "format": "jpeg",
        "quality": 90
      }
    ]
  }'
const result = await client.transform({
  file: {
    type: "url",
    name: "product-raw.jpg",
    url: "https://example.com/images/product-raw.jpg",
  },
  operations: [
    {
      type: "remove_background",
      background_hex_color: "#FFFFFF",
    },
    {
      type: "resize",
      width_in_px: 1000,
      height_in_px: 1000,
      fit: "contain",
    },
    {
      type: "convert",
      format: "jpeg",
      quality: 90,
    },
  ],
});
result = client.transform(
    file={
        "type": "url",
        "name": "product-raw.jpg",
        "url": "https://example.com/images/product-raw.jpg",
    },
    operations=[
        {
            "type": "remove_background",
            "background_hex_color": "#FFFFFF",
        },
        {
            "type": "resize",
            "width_in_px": 1000,
            "height_in_px": 1000,
            "fit": "contain",
        },
        {
            "type": "convert",
            "format": "jpeg",
            "quality": 90,
        },
    ],
)
bgOp := il.NewRemoveBackgroundOperation()
bgOp.BackgroundHexColor = "#FFFFFF"

result, err := client.Transform(il.TransformRequest{
    File: il.NewFileFromURL(
        "product-raw.jpg",
        "https://example.com/images/product-raw.jpg",
    ),
    Operations: []il.TransformOperation{
        bgOp,
        il.NewResizeOperation(1000, 1000, "contain"),
        il.NewConvertOperation("jpeg"),
    },
})

Three operations in sequence: remove the background and replace with white, resize to 1,000 x 1,000, convert to JPEG. The output is ready for Amazon without any intermediate files.

If you skip the background_hex_color parameter, the background is removed entirely — you get a transparent PNG. Useful when you want to composite the product onto seasonal promotional backgrounds or custom brand templates.

Smart Crop for Thumbnails and Listing Images

Standard cropping cuts from a fixed point — top-left, center, whatever you specify. That works until your product is off-center in the original photo, and a center crop chops off half the item.

The smart_crop operation analyzes the image to detect the primary subject, then crops around it. The product stays centered in the output regardless of where it sits in the original frame.

This is critical for thumbnail grids. When a shopper scrolls through a search results page, every listing image needs to show the product clearly at small sizes. A generic center crop risks cutting off a shoe’s toe, a lamp’s shade, or a bag’s handle.

curl -X POST \
  https://api.iterationlayer.com/image-transformation/v1/transform \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file": {
      "type": "url",
      "name": "product.jpg",
      "url": "https://example.com/images/product.jpg"
    },
    "operations": [
      {
        "type": "remove_background",
        "background_hex_color": "#FFFFFF"
      },
      {
        "type": "smart_crop",
        "width_in_px": 300,
        "height_in_px": 300
      },
      {
        "type": "convert",
        "format": "webp",
        "quality": 80
      }
    ]
  }'
const result = await client.transform({
  file: {
    type: "url",
    name: "product.jpg",
    url: "https://example.com/images/product.jpg",
  },
  operations: [
    {
      type: "remove_background",
      background_hex_color: "#FFFFFF",
    },
    {
      type: "smart_crop",
      width_in_px: 300,
      height_in_px: 300,
    },
    {
      type: "convert",
      format: "webp",
      quality: 80,
    },
  ],
});
result = client.transform(
    file={
        "type": "url",
        "name": "product.jpg",
        "url": "https://example.com/images/product.jpg",
    },
    operations=[
        {
            "type": "remove_background",
            "background_hex_color": "#FFFFFF",
        },
        {
            "type": "smart_crop",
            "width_in_px": 300,
            "height_in_px": 300,
        },
        {
            "type": "convert",
            "format": "webp",
            "quality": 80,
        },
    ],
)
bgOp := il.NewRemoveBackgroundOperation()
bgOp.BackgroundHexColor = "#FFFFFF"

result, err := client.Transform(il.TransformRequest{
    File: il.NewFileFromURL(
        "product.jpg",
        "https://example.com/images/product.jpg",
    ),
    Operations: []il.TransformOperation{
        bgOp,
        il.NewSmartCropOperation(300, 300),
        il.NewConvertOperation("webp"),
    },
})

Background removal first, then smart crop, then format conversion. The output is a 300 x 300 WebP thumbnail with the product centered and the background clean.

Compress to a Target File Size

Email service providers and push notification platforms enforce strict file size limits. Mailchimp caps inline images at 1 MB. Push notifications on iOS work best under 100 KB. Some ad networks reject creatives over 150 KB.

The compress_to_size operation takes a target in bytes and automatically adjusts quality and dimensions to hit that target. You do not need to guess the quality setting or run a trial-and-error loop.

curl -X POST \
  https://api.iterationlayer.com/image-transformation/v1/transform \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file": {
      "type": "url",
      "name": "hero-image.jpg",
      "url": "https://example.com/images/hero-image.jpg"
    },
    "operations": [
      {
        "type": "resize",
        "width_in_px": 600,
        "height_in_px": 400,
        "fit": "cover"
      },
      {
        "type": "compress_to_size",
        "max_file_size_in_bytes": 102400
      }
    ]
  }'
const result = await client.transform({
  file: {
    type: "url",
    name: "hero-image.jpg",
    url: "https://example.com/images/hero-image.jpg",
  },
  operations: [
    {
      type: "resize",
      width_in_px: 600,
      height_in_px: 400,
      fit: "cover",
    },
    {
      type: "compress_to_size",
      max_file_size_in_bytes: 102_400,
    },
  ],
});
result = client.transform(
    file={
        "type": "url",
        "name": "hero-image.jpg",
        "url": "https://example.com/images/hero-image.jpg",
    },
    operations=[
        {
            "type": "resize",
            "width_in_px": 600,
            "height_in_px": 400,
            "fit": "cover",
        },
        {
            "type": "compress_to_size",
            "max_file_size_in_bytes": 102400,
        },
    ],
)
result, err := client.Transform(il.TransformRequest{
    File: il.NewFileFromURL(
        "hero-image.jpg",
        "https://example.com/images/hero-image.jpg",
    ),
    Operations: []il.TransformOperation{
        il.NewResizeOperation(600, 400, "cover"),
        il.NewCompressToSizeOperation(102400),
    },
})

The API figures out the optimal quality and compression settings to land at or below 100 KB. No more iterating through quality levels in a loop until the output is small enough.

Upscaling Low-Resolution Supplier Images

Supplier catalogs are notorious for low-resolution images. You get a 400 x 400 pixel photo from a wholesale catalog, and your storefront needs 2,000 x 2,000 for the zoom viewer. Naive upscaling produces blurry results. The upscale operation uses AI-based super-resolution to increase image dimensions by 2x, 3x, or 4x while preserving detail.

Chain it with the rest of your pipeline:

curl -X POST \
  https://api.iterationlayer.com/image-transformation/v1/transform \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file": {
      "type": "url",
      "name": "supplier-photo.jpg",
      "url": "https://example.com/supplier/photo.jpg"
    },
    "operations": [
      {
        "type": "upscale",
        "factor": 4
      },
      {
        "type": "remove_background",
        "background_hex_color": "#FFFFFF"
      },
      {
        "type": "resize",
        "width_in_px": 2000,
        "height_in_px": 2000,
        "fit": "contain"
      },
      {
        "type": "sharpen",
        "sigma": 1.5
      },
      {
        "type": "convert",
        "format": "webp",
        "quality": 90
      }
    ]
  }'
const result = await client.transform({
  file: {
    type: "url",
    name: "supplier-photo.jpg",
    url: "https://example.com/supplier/photo.jpg",
  },
  operations: [
    {
      type: "upscale",
      factor: 4,
    },
    {
      type: "remove_background",
      background_hex_color: "#FFFFFF",
    },
    {
      type: "resize",
      width_in_px: 2000,
      height_in_px: 2000,
      fit: "contain",
    },
    {
      type: "sharpen",
      sigma: 1.5,
    },
    {
      type: "convert",
      format: "webp",
      quality: 90,
    },
  ],
});
result = client.transform(
    file={
        "type": "url",
        "name": "supplier-photo.jpg",
        "url": "https://example.com/supplier/photo.jpg",
    },
    operations=[
        {
            "type": "upscale",
            "factor": 4,
        },
        {
            "type": "remove_background",
            "background_hex_color": "#FFFFFF",
        },
        {
            "type": "resize",
            "width_in_px": 2000,
            "height_in_px": 2000,
            "fit": "contain",
        },
        {
            "type": "sharpen",
            "sigma": 1.5,
        },
        {
            "type": "convert",
            "format": "webp",
            "quality": 90,
        },
    ],
)
bgOp := il.NewRemoveBackgroundOperation()
bgOp.BackgroundHexColor = "#FFFFFF"

result, err := client.Transform(il.TransformRequest{
    File: il.NewFileFromURL(
        "supplier-photo.jpg",
        "https://example.com/supplier/photo.jpg",
    ),
    Operations: []il.TransformOperation{
        il.NewUpscaleOperation(4),
        bgOp,
        il.NewResizeOperation(2000, 2000, "contain"),
        il.NewSharpenOperation(1.5),
        il.NewConvertOperation("webp"),
    },
})

Five operations in one request: upscale the 400 x 400 image to 1,600 x 1,600, remove the background, resize to the target 2,000 x 2,000, sharpen to recover crispness, and convert to WebP. A supplier thumbnail becomes a marketplace-ready hero image.

The Full E-Commerce Pipeline

The real workflow is not a single transformation — it is generating multiple variants from one source image. Your product listing needs a main image, a thumbnail, an email-safe version, and a social media card. Each has different dimensions, formats, and quality targets.

With a composable API, you make one request per variant. Here is a complete pipeline for preparing a product image for multi-channel distribution. Each call starts from the same source image.

Main listing image — 2,000 x 2,000, white background, WebP:

curl -X POST \
  https://api.iterationlayer.com/image-transformation/v1/transform \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file": {
      "type": "url",
      "name": "product.jpg",
      "url": "https://example.com/images/product.jpg"
    },
    "operations": [
      {
        "type": "remove_background",
        "background_hex_color": "#FFFFFF"
      },
      {
        "type": "resize",
        "width_in_px": 2000,
        "height_in_px": 2000,
        "fit": "contain"
      },
      {
        "type": "convert",
        "format": "webp",
        "quality": 90
      }
    ]
  }'
// Main listing image
const mainImage = await client.transform({
  file: {
    type: "url",
    name: "product.jpg",
    url: "https://example.com/images/product.jpg",
  },
  operations: [
    {
      type: "remove_background",
      background_hex_color: "#FFFFFF",
    },
    {
      type: "resize",
      width_in_px: 2000,
      height_in_px: 2000,
      fit: "contain",
    },
    {
      type: "convert",
      format: "webp",
      quality: 90,
    },
  ],
});
# Main listing image
main_image = client.transform(
    file={
        "type": "url",
        "name": "product.jpg",
        "url": "https://example.com/images/product.jpg",
    },
    operations=[
        {
            "type": "remove_background",
            "background_hex_color": "#FFFFFF",
        },
        {
            "type": "resize",
            "width_in_px": 2000,
            "height_in_px": 2000,
            "fit": "contain",
        },
        {
            "type": "convert",
            "format": "webp",
            "quality": 90,
        },
    ],
)
bgOp := il.NewRemoveBackgroundOperation()
bgOp.BackgroundHexColor = "#FFFFFF"

mainImage, err := client.Transform(il.TransformRequest{
    File: il.NewFileFromURL(
        "product.jpg",
        "https://example.com/images/product.jpg",
    ),
    Operations: []il.TransformOperation{
        bgOp,
        il.NewResizeOperation(2000, 2000, "contain"),
        il.NewConvertOperation("webp"),
    },
})

Thumbnail — 300 x 300, smart-cropped, WebP:

curl -X POST \
  https://api.iterationlayer.com/image-transformation/v1/transform \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file": {
      "type": "url",
      "name": "product.jpg",
      "url": "https://example.com/images/product.jpg"
    },
    "operations": [
      {
        "type": "remove_background",
        "background_hex_color": "#FFFFFF"
      },
      {
        "type": "smart_crop",
        "width_in_px": 300,
        "height_in_px": 300
      },
      {
        "type": "convert",
        "format": "webp",
        "quality": 80
      }
    ]
  }'
// Thumbnail
const thumbnail = await client.transform({
  file: {
    type: "url",
    name: "product.jpg",
    url: "https://example.com/images/product.jpg",
  },
  operations: [
    {
      type: "remove_background",
      background_hex_color: "#FFFFFF",
    },
    {
      type: "smart_crop",
      width_in_px: 300,
      height_in_px: 300,
    },
    {
      type: "convert",
      format: "webp",
      quality: 80,
    },
  ],
});
# Thumbnail
thumbnail = client.transform(
    file={
        "type": "url",
        "name": "product.jpg",
        "url": "https://example.com/images/product.jpg",
    },
    operations=[
        {
            "type": "remove_background",
            "background_hex_color": "#FFFFFF",
        },
        {
            "type": "smart_crop",
            "width_in_px": 300,
            "height_in_px": 300,
        },
        {
            "type": "convert",
            "format": "webp",
            "quality": 80,
        },
    ],
)
bgOp := il.NewRemoveBackgroundOperation()
bgOp.BackgroundHexColor = "#FFFFFF"

thumbnail, err := client.Transform(il.TransformRequest{
    File: il.NewFileFromURL(
        "product.jpg",
        "https://example.com/images/product.jpg",
    ),
    Operations: []il.TransformOperation{
        bgOp,
        il.NewSmartCropOperation(300, 300),
        il.NewConvertOperation("webp"),
    },
})

Email-safe version — 600 x 400, JPEG, under 100 KB:

curl -X POST \
  https://api.iterationlayer.com/image-transformation/v1/transform \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file": {
      "type": "url",
      "name": "product.jpg",
      "url": "https://example.com/images/product.jpg"
    },
    "operations": [
      {
        "type": "remove_background",
        "background_hex_color": "#FFFFFF"
      },
      {
        "type": "resize",
        "width_in_px": 600,
        "height_in_px": 400,
        "fit": "cover"
      },
      {
        "type": "convert",
        "format": "jpeg"
      },
      {
        "type": "compress_to_size",
        "max_file_size_in_bytes": 102400
      }
    ]
  }'
// Email-safe version
const emailImage = await client.transform({
  file: {
    type: "url",
    name: "product.jpg",
    url: "https://example.com/images/product.jpg",
  },
  operations: [
    {
      type: "remove_background",
      background_hex_color: "#FFFFFF",
    },
    {
      type: "resize",
      width_in_px: 600,
      height_in_px: 400,
      fit: "cover",
    },
    {
      type: "convert",
      format: "jpeg",
    },
    {
      type: "compress_to_size",
      max_file_size_in_bytes: 102_400,
    },
  ],
});
# Email-safe version
email_image = client.transform(
    file={
        "type": "url",
        "name": "product.jpg",
        "url": "https://example.com/images/product.jpg",
    },
    operations=[
        {
            "type": "remove_background",
            "background_hex_color": "#FFFFFF",
        },
        {
            "type": "resize",
            "width_in_px": 600,
            "height_in_px": 400,
            "fit": "cover",
        },
        {
            "type": "convert",
            "format": "jpeg",
        },
        {
            "type": "compress_to_size",
            "max_file_size_in_bytes": 102400,
        },
    ],
)
bgOp := il.NewRemoveBackgroundOperation()
bgOp.BackgroundHexColor = "#FFFFFF"

emailImage, err := client.Transform(il.TransformRequest{
    File: il.NewFileFromURL(
        "product.jpg",
        "https://example.com/images/product.jpg",
    ),
    Operations: []il.TransformOperation{
        bgOp,
        il.NewResizeOperation(600, 400, "cover"),
        il.NewConvertOperation("jpeg"),
        il.NewCompressToSizeOperation(102400),
    },
})

Three API calls, three variants, zero infrastructure. The same product image goes to your storefront, your search results grid, and your email campaign — each in the right format and size.

Format Conversion: WebP, AVIF, JPEG, and When to Use What

Not every format works everywhere. WebP has near-universal browser support and delivers excellent quality-to-size ratios. AVIF is smaller still but has spotty support in older browsers and email clients. JPEG remains the safest choice for email and legacy platforms. PNG is necessary when you need transparency.

The convert operation handles the translation. Pair it with quality settings to control the tradeoff between file size and visual fidelity.

A practical strategy for e-commerce:

  • Storefront hero images: WebP at quality 90. Best balance of quality and file size for modern browsers.
  • Category page thumbnails: WebP at quality 75-80. Smaller file sizes improve page load speed on grid layouts.
  • Email campaigns: JPEG at quality 85. Universal compatibility across email clients.
  • Product zoom viewer: AVIF at quality 90 with a JPEG fallback. AVIF gives the smallest file size at high quality, critical for large zoomable images.
  • Images with transparency: PNG. The only format in this list that supports full alpha channels across all clients.

Each of these is a single convert operation at the end of your transformation chain. The format conversion applies after all other operations — resize first, crop second, convert last.

Chaining with Other APIs

Image transformation is one step in a larger workflow. Consider the full product onboarding pipeline for a marketplace seller.

A supplier sends a PDF catalog with product descriptions and embedded images. You need to extract the product data, process the images, and generate listing-ready assets. With composable APIs, that becomes three chained steps:

  1. Extract the product data from the PDF catalog using the Document Extraction API — names, descriptions, prices, and SKU numbers come back as structured JSON with confidence scores.
  2. Transform each product image using the Image Transformation API — remove backgrounds, resize for marketplace requirements, convert to WebP.
  3. Generate social media cards or promotional banners using the Image Generation API — composite the product onto branded templates with pricing overlays.

Each step uses the same API key, the same credit pool, and the same error format. No glue code between vendors. No format conversion between services. The structured JSON from step one contains the product names and prices that go into the templates in step three.

Where the DIY Approach Still Wins

If you process fewer than a dozen images a month and your requirements never change, a Sharp script or an ImageMagick command works fine. The cost is zero and the control is total.

The calculus shifts when your catalog grows, your marketplace requirements multiply, or your operations team spends hours manually processing images. At that point, maintaining the Docker container, debugging the CMYK edge case, and adding the new AVIF conversion path costs more in engineering time than the API calls.

The API also runs on EU infrastructure with zero data retention — files are processed in memory and discarded immediately. If your product images include customer-facing content or if your business operates under EU data regulations, that matters.

Available Operations

The transformation API supports chaining up to 30 operations per request. Beyond what we have covered here, you can:

  • Sharpen or blur with configurable sigma values
  • Rotate by any angle, with optional background fill color
  • Flip (vertical) or flop (horizontal) for mirror variations
  • Extend canvas with padding in any direction and color
  • Trim whitespace or near-uniform borders automatically
  • Modulate brightness, saturation, and hue
  • Grayscale conversion for stylized product shots
  • Auto-contrast for normalizing inconsistent lighting across supplier photos
  • Denoise for cleaning up low-quality source images

Every operation composes with every other operation. The order matters — resize before sharpen produces a different result than sharpen before resize — and you control the sequence.

Get Started

The full operation reference and SDK guides are in the Image Transformation docs. Install the TypeScript SDK (iterationlayer on npm), the Python SDK (iterationlayer on PyPI), or the Go SDK and start transforming images.

Sign up for a free account — no credit card required. Send a product image, chain a few operations, and check the result. The same request you test with one image works identically when you process your full catalog.

If your product images also need structured data — dimensions, weight, material extracted from a supplier spec sheet — the Document Extraction API chains naturally with image transformation. Same auth, same credits, same API conventions. Extract the data, transform the images, generate the listings.

Try with your own data

Get a free API key and run this in minutes. No credit card required.

Image Transformation

Transform images at scale. 150 free image transformations included.
Get Your Free API Key