Sell Amazon Main-Image Fixes: Audit Seller Photos and Fix Them Locally with rembg

Amazon is strict about the first photo on a product page. The main image has to sit on a pure white background (RGB 255, 255, 255), the product should fill 85% or more of the frame, and there can be no text, logos, watermarks or props that don’t come with the product. Images need to be at least 1,000 pixels on the longest side for zoom to work. When a main image breaks these rules, Amazon can suppress the listing from search until it’s fixed.

Many small sellers get this wrong. They shoot on a grey table, use a supplier photo with a watermark, or upload a tiny product floating in a huge white square. They’re losing sales and don’t know why, and fixing 80 photos in Photoshop is the last thing they want to do.

That’s a service you can sell starting today: a free audit that shows sellers which of their images break the rules, then a paid fix that delivers compliant 2000×2000 main images. The AI part (background removal) runs on your own computer, for free, with the open-source rembg library. What clients pay for is the result and your quality check.

In this guide you’ll build two Python scripts:

• audit.py checks a folder of images for non-white background, product too small, and resolution too low, and writes a CSV report you can send as a sales pitch
• fix.py removes the background, crops to the product, scales it to 88% of a 2000×2000 white canvas, and saves a JPEG ready to upload

AI cost: $0 per image (it all runs locally). Build time: about 30 minutes.

What you need

The rules you’re checking against

From Amazon Seller Central’s product image requirements (check the current page before you quote it to clients, because Amazon updates it):

• Main image background must be pure white, RGB 255, 255, 255
• The product should fill 85% or more of the image frame
• 1,000 px or larger on the longest side to enable zoom (500 px is the absolute minimum)
• JPEG preferred; TIFF, PNG and non-animated GIF are also accepted
• No text, logos, borders, color blocks, watermarks or other graphics on the main image
• Show only the product for sale, without accessories that aren’t included

Some categories have their own extra rules (clothing, for example, has rules about models and mannequins). Read the category style guide before taking an order from a category you don’t know.

eBay is looser but similar: at least 500 px on the longest side, 1,600 px recommended, and a plain white or neutral background is recommended. The same scripts work for eBay and for Shopify stores that want a consistent white-background catalog.

Step 1: Set up the project

mkdir mainimage && cd mainimage
python3.13 -m venv .venv && source .venv/bin/activate   # Windows: py -3.13 -m venv .venv, then .venv\Scripts\activate
pip install "rembg[cpu,cli]" pillow numpy

If you have an NVIDIA GPU with CUDA set up, install "rembg[gpu,cli]" instead. Everything below works the same.

Quick test with rembg’s own command line:

rembg i -m birefnet-general product.jpg product_cut.png

The first run downloads the BiRefNet model, close to 1 GB. That’s the slow part. After that, a single image takes a few seconds to around 20 seconds on a CPU, depending on the machine. Time it on yours before you promise anyone a turnaround.

Why BiRefNet: older models like u2net are fast but leave rough edges on things like cables, fabric and thin handles. birefnet-general is slower and noticeably cleaner. If your laptop struggles, try birefnet-general-lite or isnet-general-use.

Always pass -m (or REMBG_MODEL) explicitly. In current rembg versions the default model is bria-rmbg, and the rembg README notes that its weights need a paid agreement with BRIA for commercial use. Since you’re selling this work, stick to the BiRefNet or ISNet models, and check each model’s license yourself before you rely on it. The rembg code is MIT, but every model’s weights carry their own license.

Step 2: The audit script (your sales pitch)

Sellers don’t buy “background removal.” They buy “7 of your 12 listings break Amazon’s image rules, here’s the list.” This script produces that list.

Save as audit.py:

import csv, sys
from pathlib import Path

import numpy as np
from PIL import Image, ImageOps

EXTS = {".jpg", ".jpeg", ".png", ".webp"}
MIN_ZOOM, MIN_FILL, MIN_WHITE = 1000, 0.85, 0.99

def audit(path):
    im = ImageOps.exif_transpose(Image.open(path))
    if im.mode in ("RGBA", "LA", "P"):
        # Transparent pixels are not white, which is exactly the problem we want to catch
        im = im.convert("RGBA")
        bg = Image.new("RGBA", im.size, (0, 0, 0, 255))
        im = Image.alpha_composite(bg, im)
    a = np.asarray(im.convert("RGB"))
    h, w = a.shape[:2]

    border = np.concatenate([a[0], a[-1], a[:, 0], a[:, -1]])
    pure_white = (border == 255).all(axis=1).mean()

    ys, xs = np.nonzero((a < 245).any(axis=2))   # anything that isn't near-white
    if len(xs) == 0:
        fill = 0.0
    else:
        fill = max((xs.max() - xs.min() + 1) / w, (ys.max() - ys.min() + 1) / h)

    problems = []
    if pure_white < MIN_WHITE:
        problems.append(f"background not pure white ({pure_white:.0%} of edge pixels are 255)")
    if fill < MIN_FILL:
        problems.append(f"product fills {fill:.0%} of frame (needs 85%+)")
    if max(w, h) < MIN_ZOOM:
        problems.append(f"{w}x{h}px, too small for zoom (needs 1000px+)")
    return w, h, pure_white, fill, problems

def main(folder, report="audit.csv"):
    files = sorted(p for p in Path(folder).iterdir() if p.suffix.lower() in EXTS)
    bad = 0
    with open(report, "w", newline="", encoding="utf-8") as f:
        out = csv.writer(f)
        out.writerow(["file", "width", "height", "white_edge", "fill", "status", "problems"])
        for p in files:
            w, h, white, fill, problems = audit(p)
            status = "FAIL" if problems else "OK"
            bad += bool(problems)
            out.writerow([p.name, w, h, f"{white:.2f}", f"{fill:.2f}", status, "; ".join(problems)])
            print(f"{status:4}  {p.name}  {'; '.join(problems)}")
    print(f"\n{bad} of {len(files)} images need fixing. Report: {report}")

if __name__ == "__main__":
    main(*sys.argv[1:3])   # optional 2nd argument: report filename

Run it on a folder of the seller’s images:

python audit.py client_photos/

FAIL  blender-front.jpg  background not pure white (12% of edge pixels are 255)
FAIL  mug-white.png      product fills 61% of frame (needs 85%+)
OK    lamp-main.jpg
FAIL  supplier-01.jpg    800x800px, too small for zoom (needs 1000px+)

3 of 4 images need fixing. Report: audit.csv

Two things to know about these checks:

• The white check looks only at the outermost row of pixels. Many photos look white but are actually RGB 250–253 from camera noise or JPEG compression. That still breaks the pure-white rule, and you’ll find it a lot.
• The fill check measures the product’s longest side against the frame. It can be fooled by a shadow, a reflection or a stray dust speck, so look at every FAIL before you put it in a report.

The script can’t detect text, watermarks or props. Check those by eye. It takes seconds per image.

Step 3: The fix script

Save as fix.py:

import os, sys
from pathlib import Path

from PIL import Image, ImageOps
from rembg import new_session, remove

SIZE = int(os.environ.get("SIZE", 2000))      # output canvas, px
FILL = float(os.environ.get("FILL", 0.88))    # product's longest side / canvas
MODEL = os.environ.get("REMBG_MODEL", "birefnet-general")
EXTS = {".jpg", ".jpeg", ".png", ".webp"}

session = new_session(MODEL)

def fix(src, dst):
    im = ImageOps.exif_transpose(Image.open(src)).convert("RGB")
    cut = remove(im, session=session)          # returns RGBA with background removed

    # Crop to the product, ignoring faint alpha noise around the edges
    mask = cut.getchannel("A").point(lambda v: 255 if v > 10 else 0)
    bbox = mask.getbbox()
    if not bbox:
        return "nothing detected, skipped"
    cut = cut.crop(bbox)

    scale = SIZE * FILL / max(cut.size)
    new_size = (max(1, round(cut.width * scale)), max(1, round(cut.height * scale)))
    cut = cut.resize(new_size, Image.LANCZOS)

    canvas = Image.new("RGB", (SIZE, SIZE), (255, 255, 255))
    canvas.paste(cut, ((SIZE - cut.width) // 2, (SIZE - cut.height) // 2), cut)
    canvas.save(dst, "JPEG", quality=92, optimize=True)

    return f"upscaled {scale:.1f}x, check sharpness" if scale > 1.5 else "ok"

def main(src_dir, out_dir):
    out = Path(out_dir)
    out.mkdir(exist_ok=True)
    for p in sorted(Path(src_dir).iterdir()):
        if p.suffix.lower() not in EXTS:
            continue
        note = fix(p, out / f"{p.stem}_main.jpg")
        print(f"{p.name}: {note}")

if __name__ == "__main__":
    main(sys.argv[1], sys.argv[2])

Run it, then re-audit the output to prove it passes:

python fix.py client_photos/ fixed/
python audit.py fixed/ after.csv

The second command should print 0 of N images need fixing (white or very pale products can still show a low fill, because the audit can’t see near-white edges; check those by eye) and save after.csv (a separate file, so your original audit.csv isn’t overwritten). Send that report to the client with the delivery. It’s a before/after they can understand without opening a single image.

Why these settings:

• 2000×2000 gives zoom plenty of room and keeps file sizes reasonable. Square works for almost every category.
• 88% fill leaves a small margin above the 85% minimum so nothing gets cropped by Amazon’s thumbnails, while staying clearly compliant.
• The upscale warning catches small supplier photos that get blown up and turn soft. For those, run an AI upscaler first. Our Real-ESRGAN upscaling guide covers that, also free and local.

Step 4: Review every image before it ships

Background removal is good, not perfect. Open every output and check:

1. Edges. Zoom to 100% on handles, cables, straps and corners. Look for a white halo or bitten-off pieces.
2. Holes. The inside of a mug handle or the gap in a chair back should be white, not the old background.
3. White products. A white mug on a white canvas can lose its outline. Amazon allows a natural shadow, so you can add a soft shadow in GIMP, or ask the client for a photo shot on a darker background, which cuts out much more cleanly.
4. Glass and clear plastic. These are the hardest cases for any model. Expect manual work or tell the client up front these cost more.

Budget about 20–40 seconds of review per image, and a few minutes for the ones that need touch-ups in Photopea or GIMP. That review is what separates you from a seller just using a free website themselves.

What the market pays

Search Fiverr for “amazon white background” or “amazon main image” and you’ll find many gigs offering background removal and Amazon-compliant edits. Basic packages are often priced per batch of images, and simple cut-outs often come out to well under $1 per image once you divide the package price by the image count. This is a crowded, low-price category. Gigs that sell “Amazon compliant” retouching, shadows and resizing charge more. Check current listings yourself before setting your price, because the range is wide and changes often.

For comparison, commercial background-removal APIs such as remove.bg and Photoroom charge per image (check their current pricing pages). Those costs are what you’re avoiding by running rembg locally.

A simple price sheet to start with:

Charge per image, with a minimum order (for example $15), so tiny jobs are still worth your time. You won’t win on price against the cheapest bulk gigs. The audit report, the re-audit proof and your manual review are what justify charging more, so lead with those.

Where to find clients

• Fiverr / Upwork. Easiest start, but expect fees: Fiverr takes 20% of every order from sellers, and Upwork charges freelancers a variable fee (0–15% per contract since 2025, shown before you send a proposal). Put a before/after and a sample audit CSV in your gig gallery.
• Amazon seller communities. Facebook groups and Reddit’s r/FulfillmentByAmazon and r/AmazonSeller are full of sellers asking about suppressed listings. Answer the question helpfully first. Many groups ban direct self-promotion, so read the rules.
• Shopify and Etsy stores moving to Amazon. Their contact details are public on their stores. Run the audit on the images on their site and send a short message with the result attached.
• Local exporters and small brands. In Indonesia, many UMKM selling on Amazon or other global marketplaces shoot product photos with a phone. A free audit is an easy foot in the door.

Don’t contact sellers through Amazon’s Buyer-Seller Messaging to pitch them. That channel is meant for order questions, and using it for solicitation goes against Amazon’s communication guidelines.

Costs

Your real cost is time: finding clients and reviewing images.

Realistic earnings

There’s no public data on what people earn doing this, so here is plain arithmetic instead of a promise. Fiverr’s 20% fee is already taken off:

Expect your first weeks to bring zero orders. New gigs in a crowded category often get no orders until they have reviews, and many people give up before that. Selling directly (no 20% fee) pays better per image but takes more time hunting for clients. The money is in repeat clients: a seller who launches 10 new products a month comes back every month, and catalog work (hundreds of SKUs at once) is where per-image pricing adds up.

Risks

This topic is fully legal and inside platform rules, but it still has risks:

• Copyright. Only edit photos the client owns or has the right to use. Many “supplier photos” from Alibaba listings are reused without permission. If a client hands you a competitor’s photo, decline. Removing someone else’s watermark to reuse their photo can also break copyright law (in the US, removing copyright management information is covered by DMCA §1202).
• Misrepresentation. Amazon requires the image to accurately show the product. Don’t remove real defects, change colors, or “improve” the product beyond what the buyer will receive. If the buyer gets something that looks different, the seller gets returns and negative reviews, and you lose the client.
• Disputes and refunds. On Fiverr, buyers can request cancellations, and a few bad reviews early on hurt a new gig a lot. Agree in writing what “fixed” means (the audit criteria are perfect for this), and deliver a sample of 2–3 images before the full batch.
• Rules change. Amazon updates its image requirements and category style guides. Re-read them every few months and update MIN_FILL and the checks if they change.
• Not a guarantee of un-suppression. A listing can be suppressed for other reasons (missing attributes, policy issues). Never promise “your listing will come back.” Promise “your main images will meet the image requirements.”

Reality check

“Just use rembg” is not a business. Anyone can remove a background with a free website. Sellers pay for three things: knowing what’s wrong (the audit), not having to think about it (batch delivery in the right size and format), and someone checking the result. If you skip the review step, you’re competing with free tools and you’ll lose.

Bad source photos stay bad. A blurry, badly lit phone photo on a cluttered table becomes a blurry, badly lit product on a white background. For those, the honest answer is “reshoot it”: product near a window, plain sheet behind it, phone on a stack of books. You can sell a short shooting guide as an add-on.

Transparent, reflective and white-on-white products are where AI cut-outs fail most. Price them higher or exclude them in your gig description.

Common mistakes:

• Checking “white” by eye instead of by pixel value. RGB 252 looks white and still fails.
• Leaving the product tiny in the middle of the canvas. Fill failures are very common.
• Upscaling a 400px supplier image to 2000px with plain resizing and calling it done
• Removing a background prop that actually comes in the box (it’s allowed and expected)
• Running the full 300-image batch before the client approves a sample

Model names change. If birefnet-general is renamed in a newer rembg version, run rembg --help or check the rembg README for the current model list and set REMBG_MODEL.

Final checklist

• rembg, Pillow and numpy installed; BiRefNet downloaded and timed on your machine
• audit.py tested on 10 real product photos, every FAIL checked by eye
• fix.py output re-audited: 0 failures
• Gig or price sheet live with a before/after and sample audit report
• Copyright question asked for every new client’s photos
• Sample of 2–3 images approved before the full batch