From iPhone Photo to Hero Shot: Build an AI Product Image Pipeline for Magento 2 in Python

Bad product photos are the cheapest conversion problem you’re not solving

Most Magento store owners I work with have spent more on Google Ads in the last 30 days than they’ve spent on product photography in the last three years. And it shows on the PDP. The hero image is an iPhone snapshot taken against a beige wall, half a coffee mug visible in the bottom-left, and the bottle is rotated 7° off-vertical because that’s how the supplier sent it. Then the store wonders why the $3 / click traffic isn’t converting at the same rate as the competitor whose hero shot is on a clean white background with three angles in the gallery.

The kicker: it’s the cheapest problem to fix on a Magento store right now. Not cheap as in “buy a Photoroom subscription.” Cheap as in “write a ~400-line Python service, point it at your pub/media folder, fire it on every product save, and watch every SKU clean itself up.” That’s the pipeline I’ve been shipping on production Magento + Hyvä stores for the last 14 months, and what the rest of this article walks you through end-to-end.

4 steps from upload to PDP-ready hero

Every product save fires the same flow: catch the new images, remove the backgrounds, standardise the sizes, optionally fill in missing angles. The whole sequence runs out-of-band — the admin save action never waits.

<?php
// app/code/Vendor/ImagePipeline/Observer/QueueOnProductSave.php
public function execute(Observer $observer): void
{
    $product = $observer->getProduct();
    foreach ($this->newImages($product) as $entry) {
        $this->publisher->publish('image_pipeline.process', [
            'sku'   => $product->getSku(),
            'image' => $entry->getFile(),
            'hash'  => $entry->getMediaHash(),
        ]);
    }
}

from rembg import remove
from PIL import Image
import io

with open('input.jpg', 'rb') as f:
    raw = f.read()

# remove() takes bytes or PIL.Image and returns the same type
output_bytes = remove(raw)
cutout = Image.open(io.BytesIO(output_bytes))  # RGBA, transparent bg
cutout.save('stage/cutout.png')

from PIL import Image, ImageOps, ImageDraw

cutout = Image.open('stage/cutout.png')
cutout = ImageOps.exif_transpose(cutout)  # CRITICAL — fixes sideways

canvas = Image.new('RGB', (1500, 1500), (255, 255, 255))
# fit cutout with 12% margin
max_dim = int(1500 * 0.76)
cutout.thumbnail((max_dim, max_dim), Image.LANCZOS)
x = (1500 - cutout.width) // 2
y = (1500 - cutout.height) // 2
canvas.paste(cutout, (x, y), cutout)  # use alpha mask

# faint corner watermark
draw = ImageDraw.Draw(canvas)
draw.text((24, 1460), '© panth.dev', fill=(180, 180, 180))

canvas.save('out.webp', 'WebP', quality=80, method=6)
canvas.save('out.jpg',  'JPEG', quality=88, optimize=True, progressive=True)

from openai import OpenAI
client = OpenAI()

with open('out.jpg', 'rb') as hero:
    response = client.images.edit(
        model='gpt-image-1',
        image=hero,
        prompt=(
            'Same product, three-quarter angle view, '
            'white background, soft studio lighting, '
            'centered, no shadows or props.'
        ),
        size='1024x1024',
        n=3,
    )
for i, item in enumerate(response.data):
    Path(f'angle_{i}.png').write_bytes(b64decode(item.b64_json))

Why rembg + Pillow + OpenAI — and what we ruled out

There’s no shortage of options for each stage. Here’s the honest comparison we ran before settling on the stack. Pick means “default choice”, Maybe means “has a niche, not the default.”

Worked example — tabbed source for every layer

These are the actual files from the production pipeline (anonymised). The Magento side is one observer; the Python side is a FastAPI worker plus a CLI for backfills. Total: ~400 lines of code across both languages.

# Python 3.11+
pip install rembg[gpu] pillow openai fastapi uvicorn aio-pika

# rembg downloads the U-2-Net weights (~170 MB) on first use
python -c 'from rembg import remove; remove(b"")'

<?php
declare(strict_types=1);

namespace Vendor\ImagePipeline\Observer;

use Magento\Framework\Event\Observer;
use Magento\Framework\Event\ObserverInterface;
use Magento\Framework\MessageQueue\PublisherInterface;

class QueueOnProductSave implements ObserverInterface
{
    public function __construct(
        private readonly PublisherInterface $publisher
    ) {}

    public function execute(Observer $observer): void
    {
        $product = $observer->getEvent()->getProduct();
        $gallery = $product->getMediaGalleryImages();
        if (!$gallery || !$gallery->count()) {
            return;
        }
        foreach ($gallery as $entry) {
            // Only fire for images added in this save
            if (!$entry->getData('_is_new')) {
                continue;
            }
            $this->publisher->publish('image_pipeline.process', json_encode([
                'sku'   => $product->getSku(),
                'image' => ltrim($entry->getFile(), '/'),
            ]));
        }
    }
}

# worker.py
from fastapi import FastAPI
from rembg import remove
from PIL import Image, ImageOps
from pathlib import Path
import io

app = FastAPI()
MEDIA = Path('/var/www/magento/pub/media')

@app.post('/process')
async def process(payload: dict):
    src = MEDIA / 'catalog' / 'product' / payload['image']
    raw = src.read_bytes()

    cutout = Image.open(io.BytesIO(remove(raw)))
    cutout = ImageOps.exif_transpose(cutout)

    canvas = Image.new('RGB', (1500, 1500), (255, 255, 255))
    max_dim = int(1500 * 0.76)
    cutout.thumbnail((max_dim, max_dim), Image.LANCZOS)
    x = (1500 - cutout.width)  // 2
    y = (1500 - cutout.height) // 2
    canvas.paste(cutout, (x, y), cutout)

    out = src.with_suffix('.webp')
    canvas.save(out, 'WebP', quality=80, method=6)
    return {'ok': True, 'out': out.name}

# php bin/magento panth:image:process <sku>
# php bin/magento panth:image:process --all   # entire catalogue
# php bin/magento panth:image:process --since=2026-04-01

# Internally just iterates SKUs and pushes them onto the same queue
# the live observer uses. Idempotent — re-running on a clean image
# is a no-op thanks to the SHA-256 dedup key in the worker.

# docker-compose.yml — sidecar to Magento
services:
  image-pipeline:
    build: ./pipeline
    container_name: panth_image_pipeline
    restart: unless-stopped
    environment:
      OPENAI_API_KEY: ${OPENAI_API_KEY}
      RABBITMQ_HOST: rabbitmq
    volumes:
      - ./src/pub/media:/var/www/magento/pub/media:rw
      - rembg_cache:/root/.u2net
    depends_on:
      - rabbitmq

  rabbitmq:
    image: rabbitmq:3-management-alpine
    container_name: panth_rabbitmq
    ports: ["15672:15672"]

volumes:
  rembg_cache:

What the output actually looks like

Four real SKUs from a Hyvä client’s catalogue. Each card shows the iPhone-snapshot input on the left and the pipeline output on the right. No Photoshop, no human in the loop — just the 4 steps above.

Cost per product image, line by line

The boring number every CFO asks for. Three scenarios: self-host only, with one OpenAI angle, with three OpenAI angles. Plus a reference cost for a Photoroom-only approach and a human photo shoot.

Drag the slider — see the JPEG quality trade-off

Pillow lets you write JPEG / WebP at any quality between 1–95. There’s a real sweet spot most stores miss — not high enough and you ship visible artifacts; too high and you waste bandwidth. Drag below to see the trade.

Three ways to wire the pipeline into Magento

Same Python service, three different ways to invoke it from Magento. Pick based on your traffic volume and the infrastructure you already have.

Docker layout — one sidecar, two services

The Python pipeline runs as a sidecar to your existing Magento stack. It shares the pub/media directory via a read/write volume mount, talks to Magento via RabbitMQ, and caches the U-2-Net model weights in a named volume so container restarts don’t re-download 170 MB.

# docker-compose.yml — sidecar to Magento
services:
  image-pipeline:
    build: ./pipeline
    container_name: panth_image_pipeline
    restart: unless-stopped
    environment:
      OPENAI_API_KEY: ${OPENAI_API_KEY}
      RABBITMQ_HOST: rabbitmq
    volumes:
      - ./src/pub/media:/var/www/magento/pub/media:rw
      - rembg_cache:/root/.u2net
    depends_on:
      - rabbitmq

  rabbitmq:
    image: rabbitmq:3-management-alpine
    container_name: panth_rabbitmq
    ports: ["15672:15672"]

volumes:
  rembg_cache:

3-tool scorecard — rembg vs Photoroom vs OpenAI

The visual companion to the comparison table above. Six dimensions, scored 1–10, higher is better.

Dimension	rembg (self-host)	Photoroom API	OpenAI gpt-image-1
Cost Per-image cost at 5,000 images / month. Higher score = cheaper.	10	4	3
Quality Edge accuracy on real product photos (subjective, sample of 60).	7	9	10
Speed Median latency per image including network for SaaS.	8	9	5
Privacy Does the image leave your network? Higher = more private.	10	5	4
Customization Can you fine-tune behaviour / swap models / extend?	9	4	7
Production-ready Maturity for high-volume e-commerce production use.	7	9	7

• rembg + OpenAI is the combo we recommend for most Magento stores — the cheap workhorse + the high-quality angle filler.
• Photoroom wins on pure quality + speed but loses on cost and privacy. Use as a fallback, not a default.
• Scores are from production builds 2024–2026, not vendor marketing.

Patterns you’ll want before this hits real traffic

The MVP works at the scale of one developer’s test catalogue. Going to production needs a handful of patterns the tutorial-grade code skips.

What having this pipeline actually unlocks

Three real flows we’ve enabled for clients in the last 12 months. Each delivered measurable PDP / conversion wins inside 30 days.

Six ways this can bite you in production

Every gotcha below is something we tripped over at least once. Calling them out so your first deploy doesn’t.

Build vs buy — the honest call for your store size

Not every store should build this. The lines below are where we’d actually advise each segment, with no skin in the “you should hire us” game.

Other things on this site that pair well with this build

Where the numbers and claims came from

1. rembg — U-2-Net background removal library — github.com/danielgatis/rembg
2. Pillow imaging documentation — pillow.readthedocs.io
3. OpenAI Images API — gpt-image-1 reference — platform.openai.com/docs/api-reference/images
4. Webkul Image Background Removal extension (commercial) — webkul.com Magento 2 marketplace
5. Mirasvit AI Image Editor for Magento 2 — mirasvit.com
6. Eden AI — background removal API comparison — edenai.co blog, 2025