E-commerce Product Image Automation: Save 100+ Hours/Month

A client once showed me their product image workflow. For every new SKU, someone opened Photoshop, duplicated a template, typed in the price, added a badge if it was on sale, exported at three sizes, and uploaded to their store.

Per SKU. Every time. For 2,000 products.

They were spending 40+ hours a week on product images alone. Now they spend zero. Their catalog connects to an image API, and every product image generates automatically.

Here's how to set up the same system for your store.

Why product image automation mattersWhy Product Image Automation Matters

E-commerce runs on images. Every product needs them, often multiple versions:

• Main listing image
• Sale/promo overlays
• Size comparison graphics
• Social media crops
• Email newsletter versions

Multiply this by your SKU count. A store with 500 products and 4 image types per product needs 2,000 images. Update prices quarterly? That's 2,000 images recreated four times a year.

The manual approach doesn't scale. Automation does.

What stores automate:

• Price tags on product photos
• "Sale," "New," and "Bestseller" badges
• Size and color variant labels
• Shipping info banners
• Bundle and kit graphics

The basic architectureThe Basic Architecture

Product image automation follows a simple pattern:

Product Data → Template → Image API → Generated Image → Store/CDN

Your product catalog already has the data you need: prices, names, categories, sale status. The API pulls this data and inserts it into templates.

Data sourcesData Sources

Most e-commerce platforms expose product data through:

If your store has an API (most do), you can automate images.

Setting up automation step by stepSetting Up Automation: Step by Step

Let's build a working system. I'll use Shopify as the example, but the pattern works anywhere.

Step 1 design your templateStep 1: Design Your Template

Create a product image template with editable fields for:

• Product name (text)
• Price (text)
• Original price (text, for strikethrough on sales)
• Badge (conditional: "Sale," "New," etc.)
• Product image (image URL)

In Imejis.io, design this template and mark each field as editable. Note your template ID—you'll need it for API calls.

Step 2 connect to your product dataStep 2: Connect to Your Product Data

For Shopify, you have two options:

Option A: Shopify Flow (No Code)

Shopify Flow triggers on product events and can call external APIs:

1. Trigger: Product created or updated
2. Action: Send HTTP request to your image generation endpoint
3. Action: Save returned image URL to product metafield

Option B: Custom App

Build a small app that listens for product webhooks:

// Shopify webhook handler
app.post('/webhooks/products/update', async (req, res) => {
  const product = req.body;
 
  // Generate image for each variant
  for (const variant of product.variants) {
    const imageUrl = await generateProductImage({
      name: product.title,
      price: `$${variant.price}`,
      originalPrice: variant.compare_at_price
        ? `$${variant.compare_at_price}`
        : null,
      badge: product.tags.includes('sale') ? 'SALE' : null,
      productImage: product.images[0]?.src,
    });
 
    // Save to product or CDN
    await saveProductImage(product.id, variant.id, imageUrl);
  }
 
  res.sendStatus(200);
});

Step 3 generate the imageStep 3: Generate the Image

Call the Imejis.io API with your product data:

async function generateProductImage(data) {
  const response = await fetch(
    'https://render.imejis.io/v1/your-product-template-id',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.IMEJIS_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        name: data.name,
        price: data.price,
        original_price: data.originalPrice || '',
        badge: data.badge || '',
        product_image: data.productImage,
      }),
    }
  );
 
  const result = await response.json();
  return result.url;
}

Step 4 handle updatesStep 4: Handle Updates

Product data changes. Prices update, sales start and end, new items launch. Your automation should handle:

• New products: Generate images on product creation
• Price changes: Regenerate on price update
• Sale toggles: Regenerate when sale status changes
• Bulk updates: Process in batches to avoid rate limits

Use webhooks to trigger regeneration only when relevant fields change.

Template variationsTemplate Variations

One template rarely covers every need. Build a library:

Main listing templateMain Listing Template

Clean product shot with:

• Product name
• Current price
• Compare-at price (if on sale)
• Simple badge

Promotional templatePromotional Template

Bold sale-focused design with:

• Large discount percentage
• Original and sale price
• Urgency text ("Ends Sunday!")
• Bright colors and badges

Social media templateSocial Media Template

Square format (1080x1080) with:

• Product image
• Short headline
• Price
• Your logo

Email templateEmail Template

Horizontal format for newsletters:

• Multiple products per row
• Compact price display
• CTA button styling

Check our template library for ready-to-use product image designs.

Handling edge casesHandling Edge Cases

Real catalogs have messy data. Plan for:

Long product namesLong Product Names

A 50-character name looks different than a 15-character one. Build templates that:

• Auto-size text to fit
• Truncate with ellipsis at a maximum
• Use multiple lines when needed

Missing imagesMissing Images

Some products don't have photos yet. Your template should:

• Show a placeholder graphic
• Use a category-based default
• Display "Image Coming Soon"

Price formattingPrice Formatting

Prices come in many formats:

• $19.99 vs $20 vs $19
• €15,99 vs €15.99
• ¥1,500 vs ¥1500

Normalize pricing format before sending to the API, or build template logic to handle variations.

Variable badgesVariable Badges

Not every product needs a badge. Make badges conditional:

const badge = product.tags.includes('new') ? 'NEW'
  : product.on_sale ? 'SALE'
  : product.inventory < 10 ? 'LOW STOCK'
  : null;

Performance and scalingPerformance and Scaling

At 1,000+ products, performance matters.

Batch processingBatch Processing

Don't generate images one at a time. Queue them:

const queue = [];
 
for (const product of products) {
  queue.push(generateProductImage(product));
 
  // Process in batches of 10
  if (queue.length >= 10) {
    await Promise.all(queue);
    queue.length = 0;
  }
}
 
// Process remaining
await Promise.all(queue);

CachingCaching

Same product, same price, same badge = same image. Cache by content hash:

function getImageCacheKey(data) {
  return crypto
    .createHash('md5')
    .update(JSON.stringify(data))
    .digest('hex');
}

Check cache before generating. Saves API calls and time.

Cdn storageCDN Storage

Don't hotlink API URLs in your store. Download generated images to your CDN:

1. Generate image, get URL
2. Download image bytes
3. Upload to your CDN (S3, Cloudinary, Shopify)
4. Use CDN URL in your store

This ensures images stay available even if you switch providers later.

Measuring roiMeasuring ROI

Track these to justify (or improve) your automation:

Time saved:

• Hours per week on manual image creation
• Designer salary equivalent

Error reduction:

• Incorrect prices displayed
• Missing sale badges
• Outdated images

Speed improvements:

• Time from product creation to listing live
• Sale setup time

One mid-size store we know went from 4-hour sale setup (manually adding badges) to 15-minute setup (updating a tag and letting automation run).

FaqFAQ

How much does this cost at scaleHow much does this cost at scale?

With Imejis.io pricing, generating 10,000 product images costs about $25/month on the Pro plan. Compare that to designer hours or subscription design tools.

Can i automate images for product variantsCan I automate images for product variants?

Yes. Generate unique images for each variant by passing variant-specific data (size, color, price) to the API.

What if my product images have different dimensionsWhat if my product images have different dimensions?

Design templates for your most common product image ratio. The API can crop or fit images into designated areas.

How do i handle seasonal promotionsHow do I handle seasonal promotions?

Create promotion-specific templates. Swap template IDs when promotions start: regular template most days, holiday template during sales.

Can this work with print on demandCan this work with print-on-demand?

Absolutely. POD businesses often generate mockup images showing customer designs on products. Same automation principles apply. Check our guide on 10 ways businesses use image APIs for more examples.

Start automatingStart Automating

You don't need to automate everything at once. Start small:

1. Pick one product image type (sale badges are a good first choice)
2. Create a single template
3. Connect your highest-volume products
4. Measure time saved

Once the first automation works, expand. Add templates, connect more products, automate more image types.

The stores that win aren't the ones with the most designers. They're the ones that stopped doing repetitive work manually.

Get started with Imejis.io →