DEV Community: Oleg Tagobitsky

Batch Background Removal in Python, With a Quality Check

Oleg Tagobitsky — Tue, 13 Oct 2026 14:03:08 +0000

Removing the background from one photo is a solved problem. Removing it from a folder of 500 every day, and knowing which of the 500 came out wrong, is the part that takes engineering.

This tutorial builds a small batch tool around the API4AI Background Removal API. It cuts out a whole folder of product photos, writes transparent PNGs next to nothing it shouldn't touch, and produces a report that tells a person which handful of results to open. It's about 100 lines of Python with requests and Pillow.

One request

curl -X POST "https://api4ai.cloud/img-bg-removal/v1/results" \
     -H "X-API-KEY: $API4AI_KEY" \
     -F "image=@shoes.jpg"

The photo goes in as multipart form data: a file in image, or a public link in url. JPEG or PNG, under 16 MB, at most 4096×4096. For photos of people there's a separate People Background Removal API, tuned for them.

Two options worth knowing:

?mode=fg-mask returns a black-and-white mask instead of the cut-out, if you'd rather apply the cut yourself.
An image-bg (or url-bg) field puts your own background behind the object in the same request.

What comes back

The result is JSON, and the cut-out is inside it as base64:

{
  "results": [
    {
      "status": { "code": "ok", "message": "Success" },
      "name": "shoes.jpg",
      "width": 1500,
      "height": 1000,
      "entities": [
        { "kind": "image", "name": "general-fg-image",
          "format": "PNG", "image": "iVBORw0KGgo..." },
        { "kind": "objects", "name": "objects", "objects": [] }
      ]
    }
  ]
}

The image entity is a 4-channel PNG: the object keeps its original pixels, the background is transparent, and pixels along the edge can be partly transparent.

The lesson from the HTTP 200

The single most useful line in this script is the one that checks status.code.

When the service can't process a photo, because it's corrupted, isn't really a JPEG, or is bigger than 4096×4096, it still answers HTTP 200. The JSON says "failure" and gives the reason:

{ "status": { "code": "failure",
              "message": "Resolution is too big: 6000x4000. Max allowed resolution: 4096x4096." } }

Code that only checks raise_for_status() treats that as a success, writes nothing, and moves on. Run that over 500 photos and you lose a few without a trace. In a batch tool, every failure has to end up in the report with its reason, and the counts at the end have to add up.

Flagging the results a person should see

The API returns a cut-out, not a verdict on it. But the alpha channel of that cut-out tells you a lot, and it costs nothing to read. The script checks four things:

Almost nothing kept (under 3% of the frame): the model probably didn't find the subject you expected.
Almost nothing removed (over 90%): the background may have been kept.
The subject touches the edge of the frame: the product was cropped in the photo, or part of the background survived.
Lots of soft edges (semi-transparent pixels over 15% of the object): normal around hair, a warning sign for glass, lace, smoke or blur.

None of these say a result is wrong. They say it's worth a look. The thresholds are a starting point: run a day's photos, look at what gets flagged and what doesn't, and move them.

The script

"""Cut out a folder of photos and flag the ones a person should check.

    pip install requests pillow
    export API4AI_KEY=...            # from portal.api4.ai
    python3 bulk_cutout.py photos/ cutouts/

Originals are never touched. Each result is a transparent PNG at the same relative
path under cutouts/, and cutouts/report.csv says which ones to look at and why.
"""
import base64
import csv
import io
import os
import pathlib
import sys
import time
from concurrent.futures import ThreadPoolExecutor

import requests
from PIL import Image

URL = "https://api4ai.cloud/img-bg-removal/v1/results"
KEY = os.environ["API4AI_KEY"]
PHOTOS = {".jpg", ".jpeg", ".png"}
src, dst = pathlib.Path(sys.argv[1]), pathlib.Path(sys.argv[2])


def call_api(photo, tries=4):
    for attempt in range(tries):
        with photo.open("rb") as f:
            r = requests.post(URL, headers={"X-API-KEY": KEY},
                              files={"image": f}, timeout=120)
        if r.status_code in (429, 500, 502, 503, 504) and attempt < tries - 1:
            time.sleep(2 ** attempt)                          # 1, 2, 4 s
            continue
        r.raise_for_status()
        return r.json()["results"][0]


def checks(png):
    """Cheap signals from the alpha channel. Thresholds are a starting point."""
    alpha = png.getchannel("A")
    w, h = alpha.size
    hist = alpha.histogram()
    total, solid = w * h, sum(hist[128:])
    soft = sum(hist[1:255])
    border = [alpha.getpixel((x, y)) for x in range(w) for y in (0, h - 1)]
    border += [alpha.getpixel((x, y)) for y in range(h) for x in (0, w - 1)]
    flags = []
    if solid < 0.03 * total:
        flags.append("almost nothing kept")
    if solid > 0.90 * total:
        flags.append("almost nothing removed")
    if max(border) > 128:
        flags.append("touches the edge")
    if soft > 0.15 * max(solid, 1):
        flags.append("lots of soft edges")
    return solid / total, flags


def cutout(photo):
    rel = photo.relative_to(src)
    out = dst / rel.with_suffix(".png")
    if out.exists():
        return rel, "skipped", None, []
    result = call_api(photo)
    # A photo the service can't read comes back as HTTP 200 with "failure".
    if result["status"]["code"] != "ok":
        return rel, "failed: " + result["status"]["message"], None, []
    image = next(e for e in result["entities"] if e["kind"] == "image")
    png = Image.open(io.BytesIO(base64.b64decode(image["image"])))
    out.parent.mkdir(parents=True, exist_ok=True)
    png.save(out)
    share, flags = checks(png)
    return rel, "ok", share, flags


photos = sorted(p for p in src.rglob("*") if p.suffix.lower() in PHOTOS)
dst.mkdir(parents=True, exist_ok=True)
counts = {"ok": 0, "skipped": 0, "failed": 0, "to check": 0}

with ThreadPoolExecutor(max_workers=8) as pool, \
        open(dst / "report.csv", "a", newline="") as f:
    writer = csv.writer(f)
    if f.tell() == 0:
        writer.writerow(["file", "status", "foreground", "flags"])
    for rel, status, share, flags in pool.map(cutout, photos):
        counts[status.split(":")[0]] += 1
        if status == "skipped":
            continue
        counts["to check"] += bool(flags)
        writer.writerow([rel, status, f"{share:.2f}" if share is not None else "",
                         "; ".join(flags)])
        print(f"{status:>7}  {'CHECK ' if flags else '      '}{rel}")

print(f"\n{len(photos)} photos in: {counts['ok']} cut out, "
      f"{counts['skipped']} already done, {counts['failed']} failed; "
      f"{counts['to check']} flagged for a person")

Run it:

pip install requests pillow
export API4AI_KEY=...
python3 bulk_cutout.py photos/ cutouts/

The report, cutouts/report.csv:

file,status,foreground,flags
shoes-01.jpg,ok,0.31,
shoes-02.jpg,ok,0.62,touches the edge
model-07.jpg,ok,0.44,lots of soft edges
broken.jpg,failed: Can not load image.,,

What it takes care of:

Originals are never touched. Results go to a separate folder with the same structure: photos/2026-10/shoes.jpg becomes cutouts/2026-10/shoes.png.
Resume. A photo with a result already in place is skipped, so after a crash or Ctrl-C you run the same command again. Failed photos have no result, so they're retried.
Rate limits. A 429 or a 5xx waits 1, 2, then 4 seconds before giving up.
Count in vs out. The last line adds up cut out, already done and failed. If that doesn't match the number of photos, you know before anyone else does.

Eight workers is a starting point, not a tuned number. If you see a lot of 429s, lower it.

What it costs

On the API4AI developer portal the Background Removal API is pay-as-you-go at $5 per 1,000 images, with no subscription; people photos are $15 per 1,000 and cars $30. At 500 product photos a day, about 15,000 a month, that's around $75. Above a few thousand a day, ask for a volume quote at hello@api4.ai.

Before you write code

Put your hardest photos through the demo on the Background Removal page first: the white shirt on white, the glass bottle, the curly hair. It takes any JPEG or PNG. The full reference is in the docs, and the less technical version of this post, about where automation fits in an editing workflow, is on our blog.

What does your batch flag most often: edges, glass, or files that never come back?

Tag a Clothing Catalog in Python: From a Folder of Photos to a CSV

Oleg Tagobitsky — Tue, 06 Oct 2026 09:47:08 +0000

A clothing catalog is mostly photos, and the photos rarely come with good labels. A seller writes "nice outfit". A supplier sends a folder called new_final_2. Somebody then has to look at each picture and type "scarf".

This walkthrough turns that folder into a CSV: one row for every garment and accessory found, with the item type, a confidence score and a bounding box. It uses the API4AI Fashion API, about 80 lines of Python, and no ML setup.

At the end there's a short second script that does the part people skip: deciding which tags to trust and which photos a person should still look at.

One request

curl -X POST "https://api4ai.cloud/fashion/v2/results" \
     -H "X-API-KEY: $API4AI_KEY" \
     -F "image=@outfit.jpg"

The photo goes in as multipart form data: a file in image, or a public link in url. JPEG or PNG, under 16 MB.

What comes back

This is the example from the docs:

{
  "results": [
    {
      "status": { "code": "ok", "message": "Success" },
      "name": "scarf.jpg",
      "md5": "a447c0aa2b2b89aa6ffb488317c0ab1e",
      "width": 1024,
      "height": 768,
      "entities": [
        {
          "kind": "objects",
          "name": "fashion",
          "objects": [
            {
              "box": [0.2627, 0.0462, 0.6867, 0.6496],
              "entities": [
                {
                  "kind": "classes",
                  "name": "classes",
                  "classes": { "scarf": 0.6910 }
                }
              ]
            }
          ]
        }
      ]
    }
  ]
}

Every detected item is one entry in objects:

box is [x, y, width, height] in normalized coordinates, 0 to 1 from the top-left corner. Multiply by the image width and height to get pixels.
classes maps a class name to a confidence between 0 and 1.

Look at the confidence in the docs' own example: 0.69. The scarf was found, but not with certainty. That number is what the second half of this post is about.

One more thing to be clear on: you get the item type and its position. Not color, not material, not size, not brand.

Three things that catch people

A photo the service can't read still returns HTTP 200. status.code is "failure" and status.message says why (wrong file type, corrupted image, a URL that can't be downloaded). If you only call raise_for_status(), those photos vanish from your catalog without a trace.
An outfit photo returns everything in it. A model wearing a shirt, a sweater and a belt gives you three items, and maybe only one is for sale. The boxes help: the item that fills most of the frame is usually the product.
Zero items is a valid answer. A photo with no detections comes back as "ok" with an empty list. Log it, or you can't tell "nothing found" from "never processed".

The script

It walks the folder (subfolders included), sends each photo, and appends rows to a CSV as it goes.

"""Tag a folder of clothing photos with the API4AI Fashion API and write a CSV.

    export API4AI_KEY=...            # from portal.api4.ai
    python3 tag_catalog.py photos/ tags.csv

One row per detected item (or one row per photo with nothing found, or failed).
Run it again after a crash: photos already tagged are skipped, failed ones retried.
"""
import csv
import os
import pathlib
import sys
import time

import requests

URL = "https://api4ai.cloud/fashion/v2/results"
KEY = os.environ["API4AI_KEY"]
PHOTOS = {".jpg", ".jpeg", ".png"}
src, out = pathlib.Path(sys.argv[1]), pathlib.Path(sys.argv[2])


def call_api(photo, tries=4):
    for attempt in range(tries):
        with photo.open("rb") as f:
            r = requests.post(URL, headers={"X-API-KEY": KEY},
                              files={"image": f}, timeout=120)
        if r.status_code in (429, 500, 502, 503, 504) and attempt < tries - 1:
            time.sleep(2 ** attempt)                    # 1, 2, 4 s
            continue
        r.raise_for_status()
        return r.json()["results"][0]


def items(result):
    """Yield (class name, confidence, box) for every detected item."""
    for entity in result["entities"]:
        if entity["kind"] != "objects":
            continue
        for obj in entity["objects"]:
            classes = obj["entities"][0]["classes"]
            name = max(classes, key=classes.get)
            yield name, classes[name], obj["box"]


done = set()
if out.exists():
    with out.open(newline="") as f:
        done = {row["file"] for row in csv.DictReader(f) if row["status"] == "ok"}

photos = sorted(p for p in src.rglob("*") if p.suffix.lower() in PHOTOS)
counts = {"ok": 0, "skipped": 0, "failed": 0}

with out.open("a", newline="") as f:
    writer = csv.writer(f)
    if out.stat().st_size == 0:
        writer.writerow(["file", "status", "item", "confidence", "x", "y", "w", "h"])
    for photo in photos:
        rel = str(photo.relative_to(src))
        if rel in done:
            counts["skipped"] += 1
            continue
        result = call_api(photo)
        # A photo the service can't read comes back as HTTP 200 with "failure".
        if result["status"]["code"] != "ok":
            counts["failed"] += 1
            writer.writerow([rel, "failed: " + result["status"]["message"]])
            continue
        counts["ok"] += 1
        found = list(items(result))
        if not found:
            writer.writerow([rel, "ok", "", "", "", "", "", ""])
        for name, confidence, box in found:
            writer.writerow([rel, "ok", name, f"{confidence:.2f}",
                             *(f"{v:.3f}" for v in box)])
        f.flush()
        print(f"{len(found)} item(s)  {rel}")

print(f"\n{len(photos)} photos: {counts['ok']} tagged, "
      f"{counts['skipped']} already done, {counts['failed']} failed")

Run it:

pip install requests
export API4AI_KEY=...
python3 tag_catalog.py photos/ tags.csv

And the CSV looks like this:

file,status,item,confidence,x,y,w,h
look-01.jpg,ok,scarf,0.99,0.262,0.253,0.115,0.401
look-01.jpg,ok,belt,0.72,0.268,0.577,0.118,0.150
broken.jpg,failed: Can not load image.
flatlay-07.jpg,ok,,,,,,

What it takes care of:

Resume. Photos that are already tagged are skipped, so after a crash or Ctrl-C you run the same command again. Failed photos are tried again; the old "failed" row stays in the file as a log.
Rate limits and hiccups. A 429 or a 5xx waits 1, 2, then 4 seconds before giving up.
Failures you can see. Anything that comes back as "failure" gets a row with the reason.
Empty photos. A photo with nothing found gets a row with an empty item.
The count at the end. Tagged plus already-done plus failed should equal the number of photos.

It sends one photo at a time, which keeps the code short. For a large folder, wrap call_api in a ThreadPoolExecutor and lower the worker count if you start seeing 429s.

The part that matters: which tags to trust

A CSV of detections isn't a catalog yet. Between them sits one decision about confidence:

import csv
from collections import Counter

AUTO, REVIEW = 0.90, 0.60          # your thresholds, not ours

rows = list(csv.DictReader(open("tags.csv")))
items = [r for r in rows if r["status"] == "ok" and r["item"]]

auto   = [r for r in items if float(r["confidence"]) >= AUTO]
review = [r for r in items if REVIEW <= float(r["confidence"]) < AUTO]

print(f"{len(auto)} tags to write automatically, {len(review)} for a person")
print("Catalog by item type:", Counter(r["item"] for r in auto).most_common())

empty  = sorted({r["file"] for r in rows if r["status"] == "ok" and not r["item"]})
tagged = {r["file"] for r in rows if r["status"] == "ok"}
failed = sorted({r["file"] for r in rows if r["status"].startswith("failed")} - tagged)
print(f"{len(empty)} photos with nothing found, {len(failed)} failed")

Above the first threshold, write the tag. Between the two, show the photo to a person with the tag already suggested. Below, ignore it.

The 0.90 and 0.60 here are placeholders. Flat-lay shots on white behave differently from crowded street photos, so run a few hundred of your own images, look at what lands in each band, and move the numbers. Because the raw scores are in the CSV, changing a threshold later costs nothing: you don't call the API again.

Two more uses of the same file:

Map names once. The API says "trousers"; your shop may say "pants". Keep a small dictionary in your code, not in the data.
Crop for visual search. x * width, y * height and so on give you a pixel box for each item, ready to cut out and index.

What it costs

On the API4AI developer portal the Fashion API is pay-as-you-go, with a list price of $300 per 1,000 requests and no subscription. One photo is one request.

That price is for small and occasional use. For a real catalog, ask for a quote: it depends on how many images you process, their resolution and how many items a typical photo contains, and at volume the discount is significant. Write to hello@api4.ai with a rough monthly number and a few sample photos.

Try it before you write any code

The Fashion API page has a demo that takes your own JPEG or PNG and draws the boxes with their scores. If the results look right on your kind of photo, a key on the portal takes a minute and needs no credit card. The full reference is in the docs, and the less technical version of this post, with the use cases, is on our blog.

How are you tagging product photos today: by hand, from the supplier feed, or with a model of your own?

Blurring license plates in 10,000 photos with Python — and knowing which ones to check

Oleg Tagobitsky — Tue, 29 Sep 2026 10:02:09 +0000

Blurring a license plate is one line of OpenCV. Knowing where the plate is — in 10,000 photos, at every angle, on every kind of car — is the actual job. And once it's done, the question nobody plans for arrives: which of those 10,000 should a person actually look at before they go public?

This walkthrough covers both. It uses the API4AI Image Anonymization API, which finds and blurs plates (and faces, if you want) and leaves the rest of the photo untouched. The script at the end runs a whole folder, keeps the folder structure, survives rate limits and failures, and writes a CSV of every plate it hid — which turns out to be the most useful part.

It's for archives, rental fleets, marketplace uploads, street photography, datasets: anywhere the scene has to stay and only the plate has to go. If you're a car dealer who wants the background replaced as well, skip to the end — there's a no-code route for that.

One request

curl -X POST "https://api4ai.cloud/img-anonymization/v1/results?mode=hide-clp" \
     -H "X-API-KEY: $API4AI_KEY" \
     -F "image=@car.jpg"

mode=hide-clp means "hide car license plates". The other mode is hide-face. Leave mode out entirely and the API hides everything it supports — plates and faces, which is worth knowing before you run a folder of photos where faces should stay. Repeat the parameter to be explicit about both: ?mode=hide-clp&mode=hide-face.

The photo goes in as multipart form data: a file in image, or a public link in url.

What comes back

This is the example from the docs, trimmed:

{
  "results": [
    {
      "status": { "code": "ok", "message": "Success" },
      "name": "car.jpg",
      "width": 1024,
      "height": 768,
      "entities": [
        {
          "kind": "image",
          "name": "anonymized-image",
          "format": "PNG",
          "image": "iVBORw0KGgoAAAA...YII="
        },
        {
          "kind": "objects",
          "name": "hidden-objects",
          "objects": [
            {
              "box": [0.7458, 0.6651, 0.1189, 0.0745],
              "entities": [
                {
                  "kind": "classes",
                  "name": "classes",
                  "classes": { "License plate": 0.5641 }
                }
              ]
            }
          ]
        }
      ]
    }
  ]
}

Two entities:

image — the anonymized photo, base64-encoded, in format (the docs say it's usually the same as the input format, so a JPEG in usually comes back as a JPEG).
objects — every object that was hidden, with a bounding box in normalized [x, y, width, height] coordinates and a confidence between 0 and 1.

Look at that confidence in the docs' own example: 0.56. The plate was found and blurred, but the model wasn't sure about it. Hold on to that — it's what makes the review step at the end work.

Four things that catch people

A photo the service can't read still returns HTTP 200. status.code is "failure" and status.message says why. If you only call raise_for_status(), those files silently vanish from your output folder.
Pick entities by kind, not by position. Code that reads entities[0] works until it doesn't.
Limits: JPEG, PNG or PDF, under 16 MB, at most 4096×4096. A PDF is split into pages and each page is processed separately, so results can hold more than one entry.
Faces are included by default. Say mode=hide-clp when you mean plates only.

The script

Eighty-odd lines, standard library plus requests. It walks the source folder recursively, sends eight photos at a time, writes each result to the same relative path under the output folder, and logs every hidden plate to plates.csv.

"""Blur license plates in a folder of photos, keep the scene, log what was hidden.

    export API4AI_KEY=...            # from portal.api4.ai
    python3 blur_plates.py photos/ blurred/

Writes each result under blurred/ with the same relative path, and a
blurred/plates.csv with one row per hidden plate (or per photo with none).
"""
import base64
import csv
import os
import pathlib
import sys
import time
from concurrent.futures import ThreadPoolExecutor

import requests

URL = "https://api4ai.cloud/img-anonymization/v1/results"
KEY = os.environ["API4AI_KEY"]
PHOTOS = {".jpg", ".jpeg", ".png"}
EXT = {"JPEG": ".jpg", "PNG": ".png"}
src, dst = pathlib.Path(sys.argv[1]), pathlib.Path(sys.argv[2])


def call_api(photo, tries=4):
    for attempt in range(tries):
        with photo.open("rb") as f:
            r = requests.post(URL, params={"mode": "hide-clp"},   # plates only
                              headers={"X-API-KEY": KEY},
                              files={"image": f}, timeout=120)
        if r.status_code in (429, 500, 502, 503, 504) and attempt < tries - 1:
            time.sleep(2 ** attempt)                              # 1, 2, 4 s
            continue
        r.raise_for_status()
        return r.json()["results"][0]


def blur(photo):
    rel = photo.relative_to(src)
    done = [p for p in (dst / rel).parent.glob(rel.stem + ".*") if p.suffix != ".csv"]
    if done:
        return rel, "skipped", []

    result = call_api(photo)
    # A photo the service can't read comes back as HTTP 200 with "failure".
    if result["status"]["code"] != "ok":
        return rel, "failed: " + result["status"]["message"], []

    by_kind = {e["kind"]: e for e in result["entities"]}
    image = by_kind["image"]
    out = dst / rel.with_suffix(EXT.get(image["format"], ".png"))
    out.parent.mkdir(parents=True, exist_ok=True)
    out.write_bytes(base64.b64decode(image["image"]))

    plates = [(o["box"], max(o["entities"][0]["classes"].values()))
              for o in by_kind.get("objects", {}).get("objects", [])]
    return rel, "ok", plates


photos = sorted(p for p in src.rglob("*") if p.suffix.lower() in PHOTOS)
dst.mkdir(parents=True, exist_ok=True)
counts = {"ok": 0, "skipped": 0, "failed": 0}

log_path = dst / "plates.csv"
new_log = not log_path.exists()
with ThreadPoolExecutor(max_workers=8) as pool, open(log_path, "a", newline="") as log:
    writer = csv.writer(log)
    if new_log:
        writer.writerow(["file", "status", "plates", "box_xywh", "confidence"])
    for rel, status, plates in pool.map(blur, photos):
        counts[status.split(":")[0]] += 1
        if status == "skipped":
            continue
        if not plates:
            writer.writerow([rel, status, 0, "", ""])
        for box, confidence in plates:
            writer.writerow([rel, status, len(plates),
                             " ".join(f"{v:.3f}" for v in box), f"{confidence:.2f}"])
        print(f"{status:>7}  {len(plates)} plate(s)  {rel}")

print(f"\n{len(photos)} photos: {counts['ok']} blurred, "
      f"{counts['skipped']} already done, {counts['failed']} failed")

Run it:

export API4AI_KEY=...
python3 blur_plates.py photos/ blurred/

What it takes care of:

Resume. A photo that already has an output file is skipped, so after a crash, a failure or a Ctrl-C you just run it again. Failed photos have no output, so they get retried automatically.
Rate limits and hiccups. A 429 or a 5xx waits 1, 2, then 4 seconds and tries again before giving up.
Failures you can see. Anything that comes back as "failure" is counted, printed and logged with its message, not dropped.
Structure. photos/2024/lot-3/car.jpg ends up at blurred/2024/lot-3/car.jpg.
The count at the end. Blurred plus already-done plus failed should equal what went in. If it doesn't, something's wrong, and you know before anyone else does.

Eight workers is a starting point, not a tuned number. If you start seeing a lot of 429s, lower it.

The part that matters: which photos to check

Here's the problem with 10,000 blurred photos: nobody is going to look at 10,000 photos. But you also can't publish them without looking at any.

The CSV gives you a way to pick. Two kinds of rows deserve a human:

Low confidence. The docs' own example came back at 0.56. Nothing is necessarily wrong with a low score — it means the model was less sure, which is exactly where you want a second pair of eyes.
Zero plates in a photo that should have one. A front or rear shot of a car where nothing was hidden is either a car without a visible plate, or a plate that wasn't found. Only a person can tell which.

import csv

rows = list(csv.DictReader(open("blurred/plates.csv")))
check = [r for r in rows
         if r["status"] == "ok"
         and (r["plates"] == "0" or float(r["confidence"] or 1) < 0.6)]

for r in sorted(check, key=lambda r: float(r["confidence"] or 0)):
    print(r["plates"], r["confidence"] or "-", r["file"])
print(f"{len(check)} of {len(rows)} rows to look at")

The 0.6 threshold is arbitrary — pick one, look at what it gives you, and move it. The point is that the review list is now a few hundred files ranked by how unsure the model was, not ten thousand in alphabetical order.

The boxes help too. They're normalized, so x * width and y * height give you pixels, and you can crop a thumbnail of each hidden region into a contact sheet and flick through it in a minute.

What it costs

The API is pay-as-you-go at $25 per 1,000 requests. One photo is one request, so 10,000 photos is $250. Keys and billing are on the API4AI developer portal, and the full reference is in the Image Anonymization docs.

If you don't want to write code

One or two photos: the Image Anonymization API page has a free demo. Upload a photo and see the result.
A dealer's listing photos: if you want the background replaced as well — every car on the same white or brand-color backdrop — CarBG does the cut-out and the plate in one pass, 60 photos at a time or a .zip. The background is removed either way there, so it's the wrong tool if you need to keep the scene.

There's a longer comparison of the three routes in How to Blur License Plates in Car Photos.

What are you anonymizing, and how are you checking the results today — spot checks, a second model, or not at all?

Standardizing 250 car photos a week without Photoshop (a 20-line Python job)

Oleg Tagobitsky — Mon, 21 Sep 2026 11:30:35 +0000

A dealership photographs twelve cars on the lot. Twelve different backgrounds come back: the service bay, a competitor's banner, half a customer's minivan. Individually fine. On a listing page, it looks like twelve different dealerships.

The fix is boring and mechanical, which makes it a good thing to automate: cut the car out, put it on the same backdrop every time. Here's the whole integration.

The endpoint

POST https://api4ai.cloud/img-bg-removal/v1/cars/results?mode=<mode>

Multipart form data. The photo goes in the image field as a file, or in url as a public link. Your key goes in the X-API-KEY header (api_key or key as a query parameter also works).

mode decides what you get back:

Mode	Output
`fg-image`	Car on a transparent background
`fg-image-shadow`	Car with a drop shadow
`fg-image-hideclp`	Car with the license plate hidden
`fg-image-shadow-hideclp`	Both
`fg-mask`	A mask, for compositing yourself

GET /img-bg-removal/v1/modes returns the list at runtime, so you don't have to hardcode it.

There's also an optional backdrop: pass your own image in image-bg (or url-bg) and it's blended under the car, centered. The output keeps the dimensions of the main input image, not the backdrop — worth knowing before you send a 4K backdrop and wonder why the result is 1500 px wide.

The response, and the failure case that isn't a 4xx

{
  "results": [
    {
      "status": { "code": "ok", "message": "Success" },
      "name": "img.jpg",
      "width": 1024,
      "height": 768,
      "entities": [
        {
          "kind": "image",
          "name": "cars-fg-image",
          "image": "iVBORw0KGgoAAAA...YII=",
          "format": "PNG",
          "representation": "base64"
        }
      ]
    }
  ]
}

The finished PNG is base64 in results[].entities[], alongside an objects entity with bounding boxes — so pick the entity by kind == "image" rather than by index.

The gotcha: an image the service can't read still comes back as HTTP 200. status.code is failure and status.message says why. If you only check raise_for_status(), those files quietly vanish from your output folder. Limits that trigger it: anything that isn't JPEG or PNG, over 16 MB, or larger than 4096 × 4096.

The batch script

import base64
import pathlib
import requests

API_KEY = "a4a-..."                # from portal.api4.ai
URL = "https://api4ai.cloud/img-bg-removal/v1/cars/results"
MODE = "fg-image-shadow"           # or fg-image, fg-mask, fg-image-hideclp, ...

src = pathlib.Path("inbox")        # today's lot photos
dst = pathlib.Path("ready")
dst.mkdir(exist_ok=True)

for photo in sorted(src.glob("*.jpg")):
    with photo.open("rb") as f:
        response = requests.post(
            URL,
            params={"mode": MODE},
            headers={"X-API-KEY": API_KEY},
            files={"image": f},
            timeout=60,
        )
    response.raise_for_status()

    result = response.json()["results"][0]
    if result["status"]["code"] != "ok":
        print(f"skipped {photo.name}: {result['status']['message']}")
        continue

    picture = next(e for e in result["entities"] if e["kind"] == "image")
    out = dst / f"{photo.stem}.png"
    out.write_bytes(base64.b64decode(picture["image"]))
    print(f"{photo.name} -> {out.name}")

Requests are independent, so for a few hundred cars wrap the loop body in a ThreadPoolExecutor and run 8–16 at a time.

One domain detail worth knowing

If the output feeds Google's vehicle ads, their image guidelines ask for at least 500 × 500 (1500 × 1500 recommended) at a 4:3 ratio, with no superimposed logos or text, and the whole vehicle in frame. Cluttered backgrounds and modified license plates are both on the "allowed but hurts performance" list.

So the plate-hiding modes are right for your own site and for marketplaces where you'd rather not publish a plate — and the plain modes are right for that feed. Run the batch twice with different modes; at $0.03 a photo it's not a real decision.

If you don't want to write the loop at all

The same engine runs as a browser tool at carbg.api4.ai: drop up to 60 photos or a .zip, pick transparent / white / brand color, optional shadow and plate blur, get one zip back. Prepaid at 3 cents a photo, $5 of credit on a new account (about 166 photos), no card. Useful for the pilot before you decide the automation is worth building.

Full API docs: api4.ai/docs/car-bg-removal. What do you use for image preprocessing in your listing pipeline?