DEV Community: AI Engine

Best Age Verification APIs in 2026, Compared for Developers

AI Engine — Fri, 16 Oct 2026 22:17:47 +0000

If you run an online shop for alcohol or vapes, a dating app, a gaming platform or any service with adult content, you now need a real age verification API, not an "Are you over 18?" checkbox. Regulators in the UK and Germany have moved to enforcement, and the vendors split into two camps: certified identity platforms that run liveness and ID checks, and fast facial age estimation APIs that cost a fraction of a cent.

Below: what you can sign up for in 2026, what it costs at 10,000 checks a month, and a Python age gate that does not let borderline faces through.

Curious what an estimate looks like on your own users? Try the Face Analyzer API on a few selfies.

Quick Comparison

Prices from each provider's official pages, checked in October 2026:

AI Engine Face Analyzer: selfie age range for every face. About $0.0023 per call
Didit: age estimation with passive liveness. $0.10 per check
Yoti: predicted age with uncertainty, optional anti-spoofing. Price not published
Persona: age estimation with liveness and deepfake detection. Price not published
Veriff: age estimation sold separately, liveness certified to ISO/IEC 30107-3. ID checks from $0.80, age estimation price not published
Sumsub: age estimation enabled on request, with liveness. Verifications from $1.35

Estimation vs Verification vs Liveness

Facial age estimation: a selfie in, an estimated age or range out. No document, about a second. Add a safety buffer and it screens every user cheaply.
Document-based verification: date of birth read from an ID, document checked, selfie matched to the ID photo. Slower, but proves an exact age.
Liveness: checks the camera sees a real person, not a printed photo, a replay or a deepfake.

Most production flows estimate first and only ask for an ID when the estimate is too close to the legal age.

When You Need a Certified Provider

Ofcom lists facial age estimation among the methods capable of being "highly effective" age assurance under the UK Online Safety Act, but the whole process must also be accurate, robust against circumvention, reliable and fair, with evidence. In Germany, the KJM assesses and approves age verification systems for adult content.

If you fall under those adult content rules, buy liveness, published accuracy and audit evidence. For lower-risk cases (a first filter before checkout, age-appropriate content, flagging likely minors), a fast estimation API with a safety buffer is enough and far cheaper.

The Providers in Short

AI Engine Face Analyzer: AgeRange with Low/High for every face, one REST call, works on photos you already store. Best for age gates and minor flagging at volume; pair with a certified provider for regulated adult content.
Didit: age estimation $0.10 per check with passive liveness, ID verification $0.15, 500 free verifications a month for its ID bundle.
Yoti: predicted age with standard deviation, optional anti-spoofing. July 2025 white paper reports a mean absolute error of 1.1 years for ages 13 to 17 (self-reported); evaluated in NIST's face analysis program. Quote only.
Persona: selfie estimation with liveness and deepfake detection, configurable buffers, ID fallback. Used by Vimeo. No public per-check price.
Veriff: Age Estimation as a separate product with real-time liveness. ID plans from $0.80 per verification ($49 minimum).
Sumsub: facial estimation on its liveness tech, 1 to 2 year typical error claimed, recommends 3, 7 or 10 year buffers, KJM approved. Plans from $1.35 ($149 minimum).

Cost at 10,000 Checks a Month

AI Engine Face Analyzer (age range estimate): $22.99
Didit (estimate with passive liveness): about $1,000
Veriff Essential (full ID verification): about $8,000
Sumsub Basic (full verification): about $13,500
Yoti, Persona: quote only

These do not buy the same thing. The point is the structure: an estimate for everyone plus an ID check for the borderline few costs far less than an ID check for everyone.

The full comparison with the decision guide has the detailed tables and sources.

A Python Age Gate with a Safety Buffer

Passing everyone estimated above 18 lets a 17-year-old estimated at 16 to 21 through. Use a challenge age (legal age plus a buffer) on the lowest estimate, block clear minors, and send the rest to an ID check:

import requests

API_URL = "https://faceanalyzer-ai.p.rapidapi.com/faceanalysis"
HEADERS = {
    "x-rapidapi-host": "faceanalyzer-ai.p.rapidapi.com",
    "x-rapidapi-key": "YOUR_API_KEY",
}

def age_gate(selfie_path, legal_age=18, buffer=5):
    """Return 'pass', 'id_check', 'deny' or 'retry' for one selfie."""
    with open(selfie_path, "rb") as f:
        resp = requests.post(API_URL, headers=HEADERS, files={"image": f}, timeout=30)
    faces = resp.json()["body"]["faces"]
    if len(faces) != 1:
        return "retry", None  # no face or several faces: ask for a new selfie
    age = faces[0]["facialFeatures"]["AgeRange"]
    if age["Low"] >= legal_age + buffer:
        return "pass", age  # clearly above the challenge age
    if age["High"] < legal_age:
        return "deny", age  # clearly under age
    return "id_check", age  # too close to call: fall back to an ID document

for photo in ["selfie_1.jpg", "selfie_2.jpg", "selfie_3.jpg"]:
    decision, age = age_gate(photo)
    print(photo, age, decision)

On six stock photos with an 18+ rule and a 5-year buffer (challenge age 23):

A larger buffer sends more adults to the ID step but lets fewer minors through. Sumsub's 3, 7 or 10 years is a sensible starting range, the same idea as "Challenge 25" in UK shops. For a complete endpoint with edge cases and data retention, see the face-based age verification tutorial.

Which One?

AI Engine Face Analyzer: lower-risk age gates and minor-flagging at the lowest cost per check
Didit: published prices with liveness included
Yoti, Persona, Veriff, Sumsub: regulated adult content, or when you need liveness, deepfake detection, audit evidence and an ID fallback from one vendor

Sources

Run it on your own selfies: grab a key on the Face Analyzer API page and paste it into the script above.

NSFW Video and GIF Moderation with Python and an API

AI Engine — Fri, 16 Oct 2026 16:31:11 +0000

If your app accepts video or GIF uploads (short clips in a social feed, reaction GIFs in chat, product videos on a marketplace), checking only the thumbnail is not moderation. The problem frame can sit at second 12 of a 30 second clip. NSFW video moderation with an image API works by sampling frames, scoring each one, and deciding on the whole clip.

Every number below comes from a real run on a public domain 25 second clip of a beer being poured: it starts with an empty glass and ends with a full one, a good test for how detections change over time.

Want to see the labels on your own clips? Try the NSFW Detect API on a frame from one of your uploads.

How it works

A moderation API looks at images, so a video becomes a list of frames:

Sample frames with ffmpeg, at a fixed interval or on scene changes.
Score each frame with the API, in parallel.
Aggregate per top-level category: highest confidence, number of flagged frames, timestamps.
Decide allow, review, or block for the clip, and stop early when a frame already settles it.

Step 1: Sample frames with ffmpeg

import os
import subprocess

def extract_frames(video_path, out_dir, every_seconds=1.0):
    """Grab one frame every N seconds. Returns [(timestamp, path), ...]."""
    subprocess.run(
        ["ffmpeg", "-v", "error", "-i", video_path,
         "-vf", f"fps=1/{every_seconds},scale='min(1280,iw)':-2",
         "-q:v", "3", f"{out_dir}/frame_%05d.jpg"],
        check=True,
    )
    files = sorted(os.listdir(out_dir))
    return [(i * every_seconds, os.path.join(out_dir, f)) for i, f in enumerate(files)]

On the 25 second test clip, one frame per second gives 26 frames; one every 2 seconds gives 13.

Step 2: Score frames in parallel

Keep only the top-level categories (empty ParentName) so every sub-label maps to one policy rule:

import tempfile
from concurrent.futures import ThreadPoolExecutor

import requests

API_URL = "https://nsfw-detect3.p.rapidapi.com/nsfw-detect"
HEADERS = {
    "x-rapidapi-key": "YOUR_API_KEY",
    "x-rapidapi-host": "nsfw-detect3.p.rapidapi.com",
}

def moderate_frame(path):
    """Return the top-level categories found in one frame: {name: confidence}."""
    with open(path, "rb") as f:
        r = requests.post(API_URL, headers=HEADERS, files={"image": f}, timeout=30)
    r.raise_for_status()
    labels = r.json()["body"]["ModerationLabels"]
    return {l["Name"]: l["Confidence"] for l in labels if l["ParentName"] == ""}

def moderate_video(video_path, every_seconds=1.0, workers=4):
    """Moderate sampled frames in parallel. Returns [(timestamp, categories), ...]."""
    with tempfile.TemporaryDirectory() as tmp:
        frames = extract_frames(video_path, tmp, every_seconds)
        with ThreadPoolExecutor(max_workers=workers) as pool:
            results = list(pool.map(lambda fr: moderate_frame(fr[1]), frames))
    return [(t, cats) for (t, _), cats in zip(frames, results)]

for t, cats in moderate_video("beer_pour.mp4"):
    print(f"{t:>3.0f}s", {k: round(v, 1) for k, v in cats.items()})
#   0s {}                    empty glass
#   8s {'Alcohol': 94.9}
#  11s {'Alcohol': 95.9}
#  21s {'Alcohol': 99.3}
#  25s {'Alcohol': 99.8}
#  (26 frames in total)

The empty glass at second 0 comes back clean, and Alcohol is flagged from second 3, as soon as beer is in the glass, up to 99.8% on the full glass. That timeline is what turns frame scores into a decision: when the category first appears, how often, and how confident the API is at its peak.

Step 3: Aggregate per category and decide

Each policy rule gets one extra field compared with a single image policy: min_frames, the number of frames that must cross the threshold before the rule fires.

POLICY = {
    "Explicit":                                          {"action": "block",  "threshold": 60, "min_frames": 1},
    "Non-Explicit Nudity of Intimate parts and Kissing": {"action": "review", "threshold": 70, "min_frames": 2},
    "Violence":                                          {"action": "block",  "threshold": 70, "min_frames": 2},
    "Hate Symbols":                                      {"action": "block",  "threshold": 50, "min_frames": 1},
    "Drugs & Tobacco":                                   {"action": "review", "threshold": 80, "min_frames": 2},
    "Alcohol":                                           {"action": "review", "threshold": 90, "min_frames": 2},
}

def summarize(results):
    """Per category: max confidence, number of flagged frames, timestamps."""
    summary = {}
    for t, cats in results:
        for name, conf in cats.items():
            s = summary.setdefault(name, {"max": 0.0, "frames": 0, "times": []})
            s["max"] = max(s["max"], conf)
            s["frames"] += 1
            s["times"].append(t)
    return summary

def decide(summary):
    """Turn the per-category summary into allow / review / block."""
    verdict, reasons = "allow", []
    for name, s in summary.items():
        rule = POLICY.get(name)
        if not rule or s["max"] < rule["threshold"] or s["frames"] < rule["min_frames"]:
            continue
        reasons.append(f"{name}: {s['frames']} frames, max {s['max']:.1f}%, first at {s['times'][0]:.0f}s")
        if rule["action"] == "block":
            verdict = "block"
        elif verdict != "block":
            verdict = "review"
    return verdict, reasons

print(decide(summarize(moderate_video("beer_pour.mp4"))))
# ('review', ['Alcohol: 9 frames, max 99.8%, first at 3s'])

The reasons string tells a reviewer where to jump in the clip instead of watching all of it.

The full guide adds a scene-change sampler with a frame gap cap and the exact numbers behind each sampling choice.

Step 4: Stop early on a clear block

Once a block rule fires, the remaining frames cannot change the verdict:

def moderate_with_early_stop(frames, workers=4):
    """Moderate frames in time order, batch by batch; stop at the first block."""
    results, calls = [], 0
    with ThreadPoolExecutor(max_workers=workers) as pool:
        for i in range(0, len(frames), workers):
            batch = frames[i:i + workers]
            cats = list(pool.map(lambda fr: moderate_frame(fr[1]), batch))
            results += [(t, c) for (t, _), c in zip(batch, cats)]
            calls += len(batch)
            verdict, reasons = decide(summarize(results))
            if verdict == "block":
                break
    return verdict, reasons, calls

POLICY["Alcohol"] = {"action": "block", "threshold": 90, "min_frames": 2}  # kids platform
with tempfile.TemporaryDirectory() as tmp:
    frames = extract_frames("beer_pour.mp4", tmp, every_seconds=1.0)
    print(moderate_with_early_stop(frames))
# ('block', ['Alcohol: 3 frames, max 95.9%, first at 3s'], 12)

Blocked after 12 calls instead of 26. Clean videos still need every sampled frame.

Choosing a sampling rate

Real results on the same clip, with the review policy:

Every 1 second: 26 calls, peak 99.8%, verdict review
Every 2 seconds: 13 calls, peak 99.8%, verdict review

Both rates flag the clip. For short user uploads, one frame every one to two seconds is a solid default; for long edited videos, scene-change sampling with a gap cap cuts calls further.

GIF uploads

ffmpeg reads GIFs directly, so extract_frames("reaction.gif", tmp, 2.0) works unchanged. Without ffmpeg, Pillow can sample by frame duration:

from PIL import Image, ImageSequence

def extract_gif_frames(gif_path, out_dir, every_seconds=1.0):
    """Sample a GIF every N seconds using each frame's own duration."""
    gif = Image.open(gif_path)
    frames, t, next_t = [], 0.0, 0.0
    for i, frame in enumerate(ImageSequence.Iterator(gif)):
        if t >= next_t:
            path = os.path.join(out_dir, f"gif_{i:05d}.jpg")
            frame.convert("RGB").save(path, quality=90)
            frames.append((t, path))
            next_t += every_seconds
        t += frame.info.get("duration", 100) / 1000
    return frames

On a GIF made from the same clip, sampling every 2 seconds gave 13 frames, Alcohol on 7 (max 99.9%) and a review verdict. The convert("RGB") is required: GIF frames are palette images and JPEG cannot store them.

How many API calls?

One call per sampled frame. A 30 second clip sampled every 2 seconds costs 15 calls, and 1,000 such clips come to about 15,000 calls over the month before early stops. Upload duration limits bound the worst case, and hashing uploads avoids re-moderating reposted GIFs.

Production tips

Publish after the verdict. Keep new videos pending and moderate in a background worker; 26 frames with 4 workers took about 6 seconds in this test.
Fail safe to review when a frame call errors out.
Moderate the poster frame shown in the feed too.

Sources

One example of how to pour beer (Wikimedia Commons): the public domain test clip
ffmpeg select filter documentation: scene and prev_selected_t variables

Run it on the clips your users actually upload: grab a key on the NSFW Detect API page and tune the thresholds on real data.

Clipdrop API Pricing in 2026 and a Cheaper Alternative

AI Engine — Wed, 14 Oct 2026 10:42:14 +0000

If you are looking at Clipdrop API pricing, you are probably deciding whether to keep its remove background endpoint or switch. This post covers what the Clipdrop API looks like today, what it costs at 10,000 images a month, and a drop-in Python function that moves your integration to a cheaper API without touching the rest of your code. Every snippet was run against the live API before publishing.

Want to compare cutout quality first? Try the Background Removal API on one of your own product photos.

The Clipdrop remove background API today

Clipdrop started at Stability AI and has been part of Jasper since 2024. The API docs describe it like this:

Endpoint: POST https://clipdrop-api.co/remove-background/v1, multipart body
Auth: an x-api-key header
Input: image_file (PNG, JPG or WebP, up to 25 megapixels and 30 MB), plus an optional transparency_handling flag
Output: the image bytes, PNG by default, WebP or JPG through the accept header
Credit headers: x-remaining-credits and x-credits-consumed on every response
Rate limit: 60 requests per minute per key by default

Clipdrop API pricing: credit packs

One successful call costs 1 credit. Credits are prepaid and stay valid for 2 years. Prices on the Clipdrop API pricing page, checked in October 2026:

100 free credits: one time, for development
100 credits: $50 ($0.50 per image)
1,000 credits: $320 ($0.32 per image)
5,000 credits: $800 ($0.16 per image)
25,000 credits: $3,600 ($0.144 per image)

Above that, the page sends you to Jasper to discuss bigger plans. There is no published monthly plan.

At 10,000 images a month that is $1,440 to $1,600 a month. Background removal is now sold well under a cent per image elsewhere, which is why teams start looking.

Why teams look for an alternative

Cost at volume: even the largest pack is $0.144 per image.
Prepaid budgeting: a 402 in production means someone forgot to top up the credits.
Growth goes through sales: past 25,000 credits, pricing is a conversation with Jasper.
Cutout only: putting the product on a white or branded background is extra code on your side.

Request mapping

clipdrop-api.co/remove-background/v1 becomes background-removal-ai.p.rapidapi.com/remove-background
x-api-key becomes x-rapidapi-key plus x-rapidapi-host
image_file becomes image (or send image_url)
accept: image/webp or image/jpg: the new API always returns PNG, convert with Pillow
Response bytes become JSON with an image_url to download
x-remaining-credits becomes x-ratelimit-requests-remaining

The output keeps the input resolution: a 24 megapixel photo came back as a 6000x4005 PNG in about 8 seconds.

Before: a typical Clipdrop call

import requests
with open("bag.jpg", "rb") as image_file:
    r = requests.post(
        "https://clipdrop-api.co/remove-background/v1",
        files={"image_file": ("bag.jpg", image_file, "image/jpeg")},
        headers={"x-api-key": "YOUR_CLIPDROP_KEY"},
    )
if r.ok:
    with open("bag-cutout.png", "wb") as out:
        out.write(r.content)  # raw PNG bytes
else:
    r.raise_for_status()

After: a drop-in remove_background() function

It takes the same image and returns image bytes like Clipdrop did, including the accept option for WebP and JPG output.

import io
import os
import requests
from PIL import Image
API = "https://background-removal-ai.p.rapidapi.com"
HEADERS = {
    "x-rapidapi-host": "background-removal-ai.p.rapidapi.com",
    "x-rapidapi-key": os.environ["RAPIDAPI_KEY"],
}
def remove_background(image_file, accept="image/png"):
    """Same input as Clipdrop's remove-background call, returns image bytes like Clipdrop."""
    with open(image_file, "rb") as f:
        resp = requests.post(API + "/remove-background", headers=HEADERS,
                             files={"image": f}, timeout=60)
    resp.raise_for_status()
    result = resp.json()  # {"image_url": ..., "width": ..., "height": ..., "size_bytes": ...}
    png = requests.get(result["image_url"], timeout=60).content
    if accept == "image/png":
        return png
    # Clipdrop could also return WebP or JPG through the accept header
    img = Image.open(io.BytesIO(png))
    out = io.BytesIO()
    if accept == "image/webp":
        img.save(out, "WEBP")
    else:  # image/jpg: no alpha channel, flatten on white
        flat = Image.new("RGB", img.size, (255, 255, 255))
        flat.paste(img, mask=img.getchannel("A"))
        flat.save(out, "JPEG", quality=92)
    return out.getvalue()

The call site becomes:

png = remove_background("bag.jpg")
with open("bag-cutout.png", "wb") as out:
    out.write(png)

The full guide on ai-engine.net has the JavaScript version, the cost table and the error code mapping.

Beyond transparency: new backgrounds in one call

With Clipdrop, a white or branded background meant compositing the cutout yourself. Here the background is an endpoint choice. Colors use the R,G,B,A format (a hex value returns a 422).

def replace_background(image_file, endpoint, data=None, bg_image=None):
    files = {"image": open(image_file, "rb")}
    if bg_image:
        files["bg_image"] = open(bg_image, "rb")
    resp = requests.post(API + endpoint, headers=HEADERS, data=data or {},
                         files=files, timeout=60)
    resp.raise_for_status()
    return resp.json()["image_url"]
# White catalog background
print(replace_background("bag.jpg", "/color-background",
                         {"bg_color": "255,255,255,255"}))
# Your own background photo, composited server-side
print(replace_background("bag.jpg", "/image-background", bg_image="marble.jpg"))

Migration checklist

Search your codebase for clipdrop-api.co and x-api-key to find every call site.
Note which accept formats you request and whether you use transparency_handling.
Swap the call for remove_background() and run it on 20 to 50 of your real images, including hard ones: hair, glass, a white product on a white table.
Replace client-side compositing with /color-background or /image-background.
Swap credit monitoring for the rate limit headers.
Keep your remaining Clipdrop credits as a fallback: they stay valid for 2 years.

Sources

Clipdrop remove background API documentation: endpoint, limits, headers, errors, rate limit and free credits
Clipdrop API pricing: credit packs and validity (checked October 2026)

Run it on your own catalog: test the Background Removal API with a few of your hardest product photos.

Originally published at ai-engine.net

Best Face Recognition & Comparison APIs in 2026

AI Engine — Wed, 07 Oct 2026 21:15:07 +0000

If you are adding identity checks to an app, such as selfie-to-ID verification at signup, face login, employee check-in or duplicate account detection, a face recognition API saves you from training, hosting and tuning your own models.

The market changed in 2025 and 2026: Google Vision still does not recognize faces, a well-known open-source server stopped shipping releases, and two long-standing APIs pivoted or went offline. Here is what developers can actually sign up for today, and the catches you only find in the docs.

Want to see how it handles your own photos? Try the Face Analyzer API on a pair of images.

Detection, comparison, search: which one you need

Vendors use "face recognition" loosely. Pin down the operation first, because not every API offers all three:

Face detection: finds faces and returns boxes, landmarks and sometimes attributes (age range, emotion, glasses). It does not tell you who the person is.
Face comparison or verification (1:1): "are these two photos the same person?". The core of selfie-to-ID checks and face login.
Face search or identification (1:N): enroll known faces in a gallery, then ask "who is this?" for a new photo. Attendance systems and duplicate account detection need this.

The options at a glance

AI Engine Face Analyzer: detection with attributes, 1:1 comparison, 1:N search in repositories. Plain REST with one key. No liveness check.
Face++ (Megvii): detect, compare, search in FaceSets. The free key shares a 3 queries-per-second capacity with other users, and failed requests are billed.
Luxand.cloud: recognition, verification, liveness, emotion and age in every plan. Each plan caps how many faces you can store.
Google Cloud Vision: detection only. Its docs state that recognizing specific individuals is not supported.
CompreFace: open source (Apache 2.0), self-hosted with Docker. Last release August 2023, so updates are on you.
Kairos: now documented as an identity verification product (documents, selfie-to-ID, liveness); the classic gallery API is gone.
Betaface: public API listed as temporarily down.

Compare two faces (1:1)

import requests

HEADERS = {
    "x-rapidapi-host": "faceanalyzer-ai.p.rapidapi.com",
    "x-rapidapi-key": "YOUR_API_KEY",
}

resp = requests.post(
    "https://faceanalyzer-ai.p.rapidapi.com/compare-faces",
    headers=HEADERS,
    data={
        "source_image_url": "https://example.com/id-photo.jpg",
        "target_image_url": "https://example.com/selfie.jpg",
    },
)
body = resp.json()["body"]
print("Same person" if body["matchedFaces"] else "Different person")

The response lists matchedFaces and unmatchedFaces with bounding boxes and landmarks. You can upload files instead with the source_image and target_image multipart fields.

Search a face among enrolled users (1:N)

API = "https://faceanalyzer-ai.p.rapidapi.com"
REPO = "employees"

# 1. Create a repository once
requests.post(f"{API}/create-facial-repository", headers=HEADERS,
              data={"repository_id": REPO})

# 2. Enroll each person with your own ID
requests.post(f"{API}/save-face-in-repository", headers=HEADERS,
              files={"image": open("alice.jpg", "rb")},
              data={"repository_id": REPO, "external_id": "alice", "max_faces": "1"})

# 3. Identify a new photo
resp = requests.post(f"{API}/search-face-in-repository", headers=HEADERS,
                     files={"image": open("door-camera.jpg", "rb")},
                     data={"repository_id": REPO})
for match in resp.json()["body"]["FaceMatches"]:
    print(match["ExternalImageId"], round(match["Similarity"], 2))

We enrolled two people and searched with a third photo of one of them in a different pose. Only the right person came back, with a similarity of 99.99:

The full comparison has the cost of each API at 10,000 calls a month side by side.

Which one should you choose?

AI Engine if you want comparison and 1:N search with one key and a few lines of REST, plus face attributes from the same API
Luxand.cloud if you need liveness bundled with recognition from one vendor
Face++ if you are fine with shared throughput on the free key and want per-call billing
CompreFace if images must never leave your infrastructure and you can maintain the stack
Google Cloud Vision only if detection is all you need

For complete builds, see the guides to selfie-to-ID verification (eKYC) and a face recognition attendance system.

Sources

Google Cloud Vision face detection docs: detection only, no recognition
Face++ pricing: per-call prices and free key limits
Luxand.cloud pricing: plans and included features
CompreFace on GitHub: licence, features and release history

Read the full guide with the pricing table and the Kairos and Betaface details on ai-engine.net.

remove.bg API Shutting Down: Migrate Your Code in 10 Minutes

AI Engine — Wed, 07 Oct 2026 14:33:03 +0000

If your app calls the remove.bg API, you have a hard deadline: the self-service API stops accepting requests on 1 December 2026 at 9:00 CET, and unused pay-as-you-go credits expire the same day. Anything still pointing at api.remove.bg after that will fail.

This post covers what is shutting down, how each remove.bg parameter maps to a replacement API, and a drop-in Python function you can swap in so the rest of your code keeps working. Every snippet was run against the live API before publishing.

Want to check the cutout quality before you migrate? Try the Background Removal API on one of your own images.

What exactly is shutting down

Self-service API: stops on 1 December 2026, 9:00 CET.
Website and accounts: become inaccessible. Export your invoices and usage reports before the deadline.
Credits: unused pay-as-you-go credits expire. Annual subscriptions end with a pro-rata refund, monthly ones end automatically.
Plugins: the Photoshop plugin and other integrations are discontinued.
Enterprise contracts: not affected.

remove.bg points self-service API users to Leonardo.ai (both belong to Canva). You can migrate there or to another background removal API, but your integration code has to change either way.

Leonardo.ai or another API?

Leonardo's migration guide recommends its synchronous endpoint and keeps most remove.bg option names (size, type, bg_color, crop, channels). It is the closest match if you depend on those options. What you still have to code around:

Requests are JSON only. No multipart upload: send files as base64 or upload them first to a presigned URL.
The response is a URL or base64 string, not raw image bytes.
Errors can come back with HTTP 200 and an errors array, so status checks alone are not enough.
bg_image_file is not supported, and bg_image_url is renamed.
The migration guide lists about $0.10 per image.

If you mostly send an image and get a transparent PNG back, sometimes with a background color or image, a plain REST API that accepts the same multipart upload does the job for a fraction of that. The rest of this post migrates to the AI Engine Background Removal API.

Parameter mapping

Auth: X-Api-Key header becomes x-rapidapi-key + x-rapidapi-host.
image_file becomes image (same multipart upload, new field name).
image_url stays image_url.
image_file_b64: not supported, decode it and send a file.
No bg_* parameter maps to POST /remove-background (transparent PNG).
bg_color maps to POST /color-background with bg_color as R,G,B,A (for example 255,255,255,255). A hex value returns a 422.
bg_image_url maps to POST /image-background, same parameter name. bg_image_file becomes the bg_image file field.
format: output is always PNG. Convert with Pillow if you need JPG or WebP.
size, scale, crop, roi, position, type, channels, shadows: no equivalent. The output keeps the input resolution, so resize or crop afterwards.
Extras remove.bg did not have: /blur-background and /gradient-background.

The response changes too. Instead of image bytes, you get JSON with a CDN link:

{
  "image_url": "https://images.ai-engine.net/background-removal-ai/2b6c7a0b-....png",
  "width": 1200,
  "height": 1500,
  "size_bytes": 692010
}

Before: a typical remove.bg call

import requests

response = requests.post(
    "https://api.remove.bg/v1.0/removebg",
    files={"image_file": open("product.jpg", "rb")},
    data={"size": "auto", "bg_color": "ffffff"},
    headers={"X-Api-Key": "YOUR_REMOVE_BG_KEY"},
)
if response.status_code == requests.codes.ok:
    with open("product-white.png", "wb") as out:
        out.write(response.content)

After: a drop-in remove_bg() function

Wrap the new API in a function that takes the same inputs and returns PNG bytes, like remove.bg did:

import os
import requests

API = "https://background-removal-ai.p.rapidapi.com"
HEADERS = {
    "x-rapidapi-host": "background-removal-ai.p.rapidapi.com",
    "x-rapidapi-key": os.environ["RAPIDAPI_KEY"],
}


def hex_to_rgba(value):
    """remove.bg takes 'ffffff' or '#81d4fa'; AI Engine takes 'R,G,B,A'."""
    value = value.lstrip("#")
    r, g, b = (int(value[i:i + 2], 16) for i in (0, 2, 4))
    return f"{r},{g},{b},255"


def remove_bg(image_file=None, image_url=None, bg_color=None, bg_image_url=None):
    """Same inputs as the remove.bg call, returns PNG bytes like remove.bg did."""
    data, files = {}, {}
    if image_file:
        files["image"] = open(image_file, "rb")
    else:
        data["image_url"] = image_url

    if bg_image_url:
        endpoint = "/image-background"
        data["bg_image_url"] = bg_image_url
    elif bg_color:
        endpoint = "/color-background"
        data["bg_color"] = hex_to_rgba(bg_color)
    else:
        endpoint = "/remove-background"

    resp = requests.post(API + endpoint, headers=HEADERS, data=data,
                         files=files or None, timeout=60)
    resp.raise_for_status()
    result = resp.json()  # {"image_url": ..., "width": ..., "height": ..., "size_bytes": ...}
    return requests.get(result["image_url"], timeout=60).content

The call site from the "before" example becomes:

png = remove_bg(image_file="product.jpg", bg_color="ffffff")
with open("product-white.png", "wb") as out:
    out.write(png)

We ran it on four inputs (local file, public URL, hex color, background image URL). All four returned a 1200x1500 PNG, the same size as the input.

The full migration guide also has the same function in JavaScript (Node 18+, no extra package) and the complete parameter table.

Update your error handling

remove.bg returned {"errors": [...]} with 400, 402, 403 and 429. On the new API we observed:

422 with {"detail": "..."}: bad input, like an unreachable image_url or a hex bg_color. Replaces most 400s.
403: invalid key, or a key not subscribed to the API.
429: too many requests. Retry with backoff.
415: missing or unsupported content type. Send multipart, form or JSON.

Migration checklist

Grep your codebase for api.remove.bg and X-Api-Key to find every call site.
List the remove.bg parameters you actually send. If you rely on size, crop, channels or shadows, plan a Pillow step or pick an API that supports them.
Swap in remove_bg() and run it on 20 to 50 real images, including the hard ones (hair, glass, low contrast).
Update error handling for the new status codes.
Export your remove.bg invoices before 1 December.
Switch production before the deadline, not on it.

Sources

remove.bg FAQ: shutdown date, credits, subscriptions and plugins
remove.bg API documentation: parameters, responses and error codes
Leonardo.ai: migrate from the remove.bg API: request format, supported options and price per image

Comparing more options before you switch? Read our 2026 background removal API comparison with cost per image at 10,000 images a month.

Marketplace Product Image Pipeline: Moderate, Clean, Tag (Python)

AI Engine — Sun, 21 Jun 2026 13:38:29 +0000

A marketplace lives or dies on its catalog, and the catalog is built from images other people upload. Every seller photo needs three things before it belongs on your storefront: a safety check so prohibited products never go live, a consistent look so the catalog does not resemble a flea market, and tags so the item is findable. Doing that by hand does not scale. Three APIs, chained into one Python pipeline, do it automatically for every upload.

This guide builds that pipeline: screen the image for prohibited content, remove the background and place the product on white, and auto-tag it for search. Each step is one API call, and all code runs against live endpoints.

Building this for your store? Each API used below has a free tier, starting with the Background Removal API.

The Three Stages

Each stage is a focused job handled by its own API, so you can tune or swap any one without disturbing the others:

Moderate: the content moderation API screens for nudity, violence, drugs, weapons, and hate symbols. It runs first, so a prohibited image never gets cleaned, tagged, or stored.
Clean: the Background Removal API puts every approved product on a uniform white background.
Tag: the Image Labeling API returns product labels for search, filtering, and auto-categorization.

A small shared helper keeps the credentials in one place:

import requests

API_KEY = "YOUR_API_KEY"

def api(host):
    return {"x-rapidapi-key": API_KEY, "x-rapidapi-host": host}

Stage 1: Moderate the Image

Screen the upload before spending any other work on it. The endpoint returns labels across risk categories, each with a confidence score and a parent category; the top-level categories are the ones with an empty ParentName:

def moderate(image_path):
    """Return the moderation labels for an image (empty list means clean)."""
    with open(image_path, "rb") as f:
        r = requests.post(
            "https://nsfw-detect3.p.rapidapi.com/nsfw-detect",
            headers=api("nsfw-detect3.p.rapidapi.com"),
            files={"image": f},
        )
    return r.json()["body"]["ModerationLabels"]

# Categories that should keep a listing off the marketplace
PROHIBITED = {
    "Explicit",
    "Non-Explicit Nudity of Intimate parts and Kissing",
    "Violence",
    "Hate Symbols",
    "Drugs & Tobacco",
}

Tune PROHIBITED to your marketplace. An apparel store keeps Swimwear or Underwear off this list because it is a legitimate product. For the full policy engine with per-category thresholds and a review queue, see content moderation for marketplace listings. You can grab a key on the content moderation API page.

Stage 2: Clean the Image

Once an image passes moderation, standardize it. Marketplaces like Amazon expect a pure white background on the main image, and a consistent backdrop makes any catalog look professional. The /color-background endpoint removes the original background and composites the product onto solid white in one call:

def clean_image(image_path):
    """Remove the background and place the product on solid white."""
    with open(image_path, "rb") as f:
        r = requests.post(
            "https://background-removal-ai.p.rapidapi.com/color-background",
            headers=api("background-removal-ai.p.rapidapi.com"),
            files={"image": f},
            data={"bg_color": "255,255,255,255"},
        )
    return r.json()["image_url"]   # URL to the white-background image

The bg_color is R,G,B,A, so 255,255,255,255 is opaque white. The response also carries width, height, and size_bytes. For the full batch and concurrency patterns of this step on its own, see background removal at scale.

Stage 3: Tag the Image

Tags power search, filters, and auto-categorization, so sellers do not have to label everything by hand and buyers can actually find the item. The /detect-label endpoint returns labels with a confidence score from 0 to 1:

def tag(image_path, min_score=0.7):
    """Return product tags above a confidence threshold."""
    with open(image_path, "rb") as f:
        r = requests.post(
            "https://label-image.p.rapidapi.com/detect-label",
            headers=api("label-image.p.rapidapi.com"),
            files={"image": f},
        )
    labels = r.json()["body"]["labels"]
    return [l["description"] for l in labels if l["score"] >= min_score]

print(tag("leather_shoe.jpg"))
# ['Walking Shoe', 'Cross Training Shoe', 'Running Shoe']

The min_score filter drops low-confidence guesses so you store tags you can trust. Map the returned labels to your own category taxonomy with the Image Labeling API, or keep them as free-text search tags.

The Pipeline: One Function per Listing

Now chain the three stages. Moderate first, because there is no point cleaning and tagging an image you are going to reject, and a prohibited image should never land in your processed bucket:

def process_listing(image_path):
    """Screen, then clean and tag one seller image. Returns a result dict."""
    # 1. Screen the original upload first
    flagged = [
        label["Name"]
        for label in moderate(image_path)
        if label["ParentName"] == "" and label["Name"] in PROHIBITED
    ]
    if flagged:
        return {"status": "rejected", "reasons": flagged}

    # 2. Clean for the catalog, 3. tag for search
    return {
        "status": "approved",
        "image_url": clean_image(image_path),
        "tags": tag(image_path),
    }

print(process_listing("leather_shoe.jpg"))
# {'status': 'approved',
#  'image_url': 'https://images.ai-engine.net/background-removal-ai/....png',
#  'tags': ['Walking Shoe', 'Cross Training Shoe', 'Running Shoe']}

# An image that trips a prohibited category comes back rejected,
# with no wasted background-removal or tagging calls:
# {'status': 'rejected', 'reasons': ['Drugs & Tobacco']}

One call into process_listing and a seller upload comes back either rejected with a reason or approved with a clean catalog image and a set of tags, ready to write to your database.

Run It Across the Whole Catalog

The same function runs event-driven on new listings and as a batch over an existing catalog. Process concurrently so a backfill of thousands of images finishes in minutes, not hours:

from concurrent.futures import ThreadPoolExecutor, as_completed

def process_catalog(listings, max_workers=8):
    """listings: list of dicts with id and image path."""
    approved, rejected = [], []
    with ThreadPoolExecutor(max_workers=max_workers) as pool:
        futures = {pool.submit(process_listing, l["image"]): l for l in listings}
        for fut in as_completed(futures):
            listing = futures[fut]
            try:
                result = fut.result()
            except Exception as e:
                result = {"status": "rejected", "reasons": [f"pipeline error: {e}"]}
            (approved if result["status"] == "approved" else rejected).append(
                {"id": listing["id"], **result}
            )
    return approved, rejected

approved, rejected = process_catalog(all_listings)
print(f"{len(approved)} approved, {len(rejected)} held")

Write the approved images and tags back to your catalog and route the rejected list to your seller-support flow. New uploads call process_listing from your listing-creation webhook, so every product gets the same treatment automatically.

Honest Limits

Tags need a taxonomy. The labeling API returns generic descriptions; mapping them to your category tree is your work. Treat low-confidence tags as suggestions, not truth.
Moderation is visual, not legal. It catches offensive imagery, not counterfeits, brand misuse, or whether a product is restricted in a given country. Those need seller verification and category rules.
Cleaning has a tail of hard cases. Reflective or transparent products cut out imperfectly, so keep a quality check on the background-removal output for the few percent that need it.

Getting Started

Grab keys from the Background Removal, content moderation, and Image Labeling APIs, drop them into the helper, and run process_listing on a sample of your real listings. Tune PROHIBITED and the tag threshold to your catalog, wire the function into listing creation, backfill once, and your marketplace images clean, screen, and tag themselves. A free tier is available on each API to test the full pipeline first.

Read the full tutorial on ai-engine.net.

Content Moderation for Marketplace Seller Listings (Python)

AI Engine — Thu, 18 Jun 2026 17:52:16 +0000

On a marketplace, your catalog is built from images other people upload, whether from third-party sellers on a structured e-commerce site or from individuals posting ads on a classifieds platform. At any real volume you cannot review them by hand, and you cannot afford not to. Prohibited or offensive images do show up: weapons, drugs, explicit material, a hate symbol printed on a t-shirt. One of them reaching the storefront is a brand problem, a payment-processor problem, and sometimes a legal one. The risk runs higher on classifieds, where uploads come from individuals rather than vetted sellers.

A content moderation API screens every upload automatically and sends only the ambiguous ones to a human. This guide builds that for an e-commerce catalog in Python: scoring a listing image, a policy that passes legitimate product categories while blocking prohibited ones, a gate at listing creation, and a bulk backfill. All code runs against a live API.

Want to try it first? Screen an image with the content moderation API on your own listings.

Why a Generic Nudity Filter Hurts a Marketplace

The instinct is to bolt on a nudity detector and block anything it flags. On a marketplace that backfires. An apparel seller listing a bikini, a lingerie brand, a swimwear store: a blanket nudity filter rejects all of them and you lose real sellers and real sales. The same photo that is a violation on a social feed is a legitimate product on a fashion marketplace.

So marketplace moderation is not "block flagged images." It is "apply a policy that knows your catalog": reject genuinely prohibited content, let category-relevant product imagery through, and send the in-between to a fast human review. That needs a moderation API that returns which category fired and how confidently, not a single score.

Step 1: Score a Listing Image

Send the seller's image and get back the labels the API is confident about. A clean product photo returns an empty list:

import requests

HEADERS = {
    "x-rapidapi-key": "YOUR_API_KEY",
    "x-rapidapi-host": "nsfw-detect3.p.rapidapi.com",
}

def moderate(image_path):
    """Return the moderation labels for an image (empty list means clean)."""
    with open(image_path, "rb") as f:
        r = requests.post(
            "https://nsfw-detect3.p.rapidapi.com/nsfw-detect",
            headers=HEADERS,
            files={"image": f},
        )
    return r.json()["body"]["ModerationLabels"]

Each label has a Name, a Confidence (0 to 100), and a ParentName. Labels are hierarchical, so the top-level categories are the ones with an empty ParentName. Print them on a sample of your real listings to see the exact names you need:

labels = moderate("seller_photo.jpg")
categories = [l["Name"] for l in labels if l["ParentName"] == ""]
print(categories)
# ['Swimwear or Underwear']   on a bikini listing (legit for apparel)
# ['Drugs & Tobacco']         on a prohibited listing
# []                          on a clean product photo

Step 2: A Policy That Knows Your Catalog

Map each category to a listing action, and make the category-relevant ones review or approve instead of a hard reject. An apparel marketplace reviews swimwear rather than blocking it; a wine marketplace allows alcohol:

# Tune per marketplace. A category absent from the table is approved.
LISTING_POLICY = {
    "Explicit":                                          {"action": "reject", "threshold": 50},
    "Non-Explicit Nudity of Intimate parts and Kissing": {"action": "reject", "threshold": 60},
    "Violence":                                          {"action": "reject", "threshold": 60},
    "Hate Symbols":                                      {"action": "reject", "threshold": 40},
    "Drugs & Tobacco":                                   {"action": "reject", "threshold": 60},
    # Category-relevant for apparel -> review, do not auto-reject
    "Swimwear or Underwear":                             {"action": "review", "threshold": 60},
    "Gambling":                                          {"action": "review", "threshold": 70},
    # Alcohol absent -> approved (wine and spirits sellers)
}

def screen_listing(labels):
    """Map moderation labels to a verdict: approve, review, or reject."""
    verdict, reasons = "approve", []
    for label in labels:
        if label["ParentName"]:          # top-level categories only
            continue
        rule = LISTING_POLICY.get(label["Name"])
        if not rule or label["Confidence"] < rule["threshold"]:
            continue
        reasons.append(f"{label['Name']} ({label['Confidence']:.0f}%)")
        if rule["action"] == "reject":
            verdict = "reject"
        elif verdict != "reject":
            verdict = "review"
    return verdict, reasons

print(screen_listing(moderate("leather_shoe.jpg")))   # ('approve', [])
print(screen_listing(moderate("bikini.jpg")))         # ('review', ['Swimwear or Underwear (97%)'])
print(screen_listing(moderate("prohibited.jpg")))     # ('reject', ['Drugs & Tobacco (100%)'])

The bikini listing lands in review, not the bin, so a human confirms a legitimate apparel product in seconds instead of the system silently killing the sale. One table, edited per marketplace, serves a fashion store, a wine merchant, or a general bazaar.

Building a trust-and-safety layer? The content moderation API has a free tier to test on your catalog.

Step 3: Gate at Listing Creation

A listing usually has several images, and it should be gated by its worst one. Screen them all on submit, strictest verdict wins:

RANK = {"approve": 0, "review": 1, "reject": 2}

def on_new_listing(listing_id, image_paths):
    """Screen every image on a new listing; the strictest verdict wins."""
    verdict, reasons = "approve", []
    for path in image_paths:
        v, r = screen_listing(moderate(path))
        reasons += r
        if RANK[v] > RANK[verdict]:
            verdict = v

    if verdict == "approve":
        publish_listing(listing_id)            # goes live
    elif verdict == "review":
        queue_for_review(listing_id, reasons)  # human checks
    else:
        reject_listing(listing_id, reasons)    # seller is notified why
    return verdict

Returning a clear reason on a reject matters: the seller sees why and can fix the photo instead of opening a support ticket.

Step 4: Backfill the Existing Catalog

Listings created before you added the check still need screening. Run a one-time batch concurrently, and act on each result as it lands:

from concurrent.futures import ThreadPoolExecutor, as_completed

def screen_one(listing):
    try:
        verdict, reasons = screen_listing(moderate(listing["image"]))
    except Exception as e:
        verdict, reasons = "review", [f"moderation error: {e}"]
    return {"id": listing["id"], "verdict": verdict, "reasons": reasons}

def backfill(catalog, max_workers=10):
    flagged = []
    with ThreadPoolExecutor(max_workers=max_workers) as pool:
        futures = [pool.submit(screen_one, l) for l in catalog]
        for fut in as_completed(futures):
            res = fut.result()
            if res["verdict"] != "approve":
                flagged.append(res)        # pull or review these
    return flagged

flagged = backfill(all_listings)
print(f"{len(flagged)} listings need attention")

Failing safe to review on error keeps a failed call from quietly approving a listing.

Honest Limits

It does not catch counterfeits or IP misuse. A fake handbag looks like a real one. Brand rights and authenticity need seller verification and brand registries, not a pixel score.
Restricted does not equal unsafe. Whether a legal product can be sold in a given country is a category-and-jurisdiction rule, separate from whether the image is offensive.
Thresholds are yours to tune. Too strict and you bury reviewers in legitimate apparel; too loose and prohibited items slip through. Tune against your own catalog.

For moderating non-commerce user uploads (profile photos, chat images, review photos), see the content moderation guide for user uploads, and for a provider comparison, the best content moderation APIs comparison.

Getting Started

Grab a key from the content moderation API page, run moderate over a sample of your real listings to see which categories fire, and set LISTING_POLICY so legitimate product categories review or pass while prohibited ones reject. Wire it into listing creation, backfill once, and prohibited products stop reaching your storefront. A free tier is available to test first.

Read the full tutorial on ai-engine.net.

Face Recognition Attendance System with REST API (Python)

AI Engine — Wed, 17 Jun 2026 06:24:13 +0000

Punch cards get shared. Fingerprint scanners spread germs and fail on worn fingertips. A face recognition attendance system fixes both: an employee looks at a camera, the system matches the face against a registered repository, and the check-in is logged. No hardware beyond a webcam or phone.

This builds one in Python with a face analysis REST API, no OpenCV, dlib, or local model required.

Want to see the matching in action? Try the Face Analyzer API with two photos.

Why a REST API instead of OpenCV

Rolling your own means dlib or a deep model, a GPU for reasonable latency, and ongoing maintenance of the recognition pipeline. A REST API handles detection, embedding, and matching server-side. You manage a face repository and call two endpoints.

Setting up the face repository

import requests

BASE = "https://faceanalyzer-ai.p.rapidapi.com"
HEADERS = {
    "x-rapidapi-host": "faceanalyzer-ai.p.rapidapi.com",
    "x-rapidapi-key": "YOUR_API_KEY",
}

requests.post(
    f"{BASE}/create-facial-repository",
    headers={**HEADERS, "Content-Type": "application/x-www-form-urlencoded"},
    data={"repository_id": "office-hq"},
)

Registering employees

def register_employee(photo_path, employee_id):
    with open(photo_path, "rb") as f:
        r = requests.post(
            f"{BASE}/save-face-in-repository",
            headers=HEADERS,
            files={"image": (photo_path, f, "image/jpeg")},
            data={"repository_id": "office-hq", "external_id": employee_id, "max_faces": "1"},
        )
    return r.json()

register_employee("alice.jpg", "EMP-001")
register_employee("bob.jpg", "EMP-002")

See the repository-management details in the complete tutorial.

The check-in endpoint

At check-in, search the repository for the captured face:

def check_in(photo_path):
    with open(photo_path, "rb") as f:
        r = requests.post(
            f"{BASE}/search-face-in-repository",
            headers=HEADERS,
            files={"image": (photo_path, f, "image/jpeg")},
            data={"repository_id": "office-hq"},
        )
    matches = r.json()["body"].get("FaceMatches", [])
    return matches[0]["ExternalImageId"] if matches else None

employee = check_in("checkin_capture.jpg")
print(f"Checked in: {employee}" if employee else "No match, try again")

Wrapping it in Flask

from flask import Flask, request, jsonify
from datetime import datetime

app = Flask(__name__)

@app.route("/checkin", methods=["POST"])
def checkin():
    file = request.files["image"]
    file.save("/tmp/capture.jpg")
    emp = check_in("/tmp/capture.jpg")
    if emp:
        return jsonify({"employee_id": emp, "time": str(datetime.now())})
    return jsonify({"error": "no match"}), 404

Anti-spoofing and privacy

Pair the check-in with a liveness step (ask for a blink or head turn) to block photo-of-a-photo buddy punching. For GDPR compliance, store only the repository's face identifiers, get explicit employee consent, and provide a delete path with the delete-face-from-repository endpoint.

Face recognition vs fingerprint

Face recognition is contactless, works on any phone or webcam, and is hard to share. Fingerprint hardware is cheap but fails on worn fingertips and raises hygiene concerns. For distributed or remote teams, the camera-based approach wins on reach.

Read the full tutorial with the complete Flask app, cURL tests, and JavaScript examples on ai-engine.net.

Content Moderation API: Screen User Uploads Beyond Nudity

AI Engine — Fri, 12 Jun 2026 06:25:10 +0000

The moment your product lets users upload images, profile photos, listing pictures, chat attachments, review photos, you inherit a Trust and Safety problem. Someone will upload something that breaks your policy, and if it reaches other users before you catch it, that is a brand and sometimes a legal incident. Manual review does not scale past a trickle of uploads. A content moderation API screens every image automatically and lets a human handle only the genuinely ambiguous ones.

This builds that flow: one call to score an image across the risk categories, a per-category policy engine that turns scores into an allow / review / block decision, and a concurrent batch pattern for real platform volume. All code is Python and runs against a live API.

Want to test it on your own uploads? Try the content moderation API on a sample image.

Moderation is more than a nudity filter

A lot of "NSFW detection" content treats moderation as one yes/no question about nudity. Real platform policy is broader. Weapons and gore, drug paraphernalia, hate symbols, and gambling promotions all break the rules on most platforms, and none of them are nudity. The API returns labels across a broad set of categories (nudity, suggestive content, violence, visually disturbing imagery, drugs and tobacco, alcohol, gambling, hate symbols, rude gestures), each with a confidence score.

That breadth lets your policy distinguish a weapon from a wine bottle instead of lumping everything into "bad."

Step 1: Score an image

Send an image (file or public URL) and get back the labels the model is confident about. A clean image returns an empty list:

import requests

HEADERS = {
    "x-rapidapi-key": "YOUR_API_KEY",
    "x-rapidapi-host": "nsfw-detect3.p.rapidapi.com",
}

def moderate(image_path):
    """Return the moderation labels for an image (empty list means clean)."""
    with open(image_path, "rb") as f:
        r = requests.post(
            "https://nsfw-detect3.p.rapidapi.com/nsfw-detect",
            headers=HEADERS,
            files={"image": f},
        )
    return r.json()["body"]["ModerationLabels"]

Each label has a Name, a Confidence (0 to 100), and a ParentName. Labels are hierarchical and can be a few levels deep (a specific drug label sits under a broader Drugs & Tobacco category). Top-level categories are the ones with an empty ParentName. The reliable way to build a policy is to first see which top-level categories the API actually returns on your content:

labels = moderate("sample_upload.jpg")
categories = [l["Name"] for l in labels if l["ParentName"] == ""]
print(categories)
# ['Gambling']          on a poker photo
# ['Drugs & Tobacco']   on a pills photo
# []                    on a clean photo

Step 2: Turn scores into a policy decision

The labels are not a decision. A wine marketplace allows alcohol; a kids' app blocks it. Your policy lives in a small table that maps each top-level category to an action and a threshold:

# Use the exact Names the API returns for your content (see Step 1).
# A category absent from the table is allowed.
POLICY = {
    "Explicit":                                          {"action": "block",  "threshold": 60},
    "Non-Explicit Nudity of Intimate parts and Kissing": {"action": "block",  "threshold": 60},
    "Violence":                                          {"action": "block",  "threshold": 70},
    "Hate Symbols":                                      {"action": "block",  "threshold": 50},
    "Drugs & Tobacco":                                   {"action": "block",  "threshold": 70},
    "Swimwear or Underwear":                             {"action": "review", "threshold": 60},
    "Gambling":                                          {"action": "review", "threshold": 80},
    # Alcohol is not listed, so it is allowed (e.g. a wine marketplace)
}

def decide(labels):
    """Map moderation labels to a verdict: allow, review, or block."""
    verdict, reasons = "allow", []
    for label in labels:
        if label["ParentName"]:          # match on top-level categories only
            continue
        rule = POLICY.get(label["Name"])
        if not rule or label["Confidence"] < rule["threshold"]:
            continue
        reasons.append(f"{label['Name']} ({label['Confidence']:.0f}%)")
        if rule["action"] == "block":
            verdict = "block"
        elif verdict != "block":
            verdict = "review"
    return verdict, reasons


print(decide(moderate("clean_photo.jpg")))    # ('allow', [])
print(decide(moderate("wine_listing.jpg")))   # ('allow', [])  Alcohol is not in the policy
print(decide(moderate("poker_table.jpg")))    # ('review', ['Gambling (99%)'])

Three ideas make this work at scale. Match on the top-level category (empty ParentName) so a deeply nested label still maps to the right rule. Set thresholds per category. And use three outcomes, not two: block clear violations, allow clean images, and route the uncertain middle to a human.

Curious which categories fire on your content? Run the API on a sample and print the top-level labels.

Step 3: Screen uploads at scale

A live platform does not moderate one image at a time. Screen a batch concurrently and act on each verdict as it lands:

from concurrent.futures import ThreadPoolExecutor, as_completed

def screen(upload):
    """upload: dict with id and local path. Returns the moderation verdict."""
    try:
        verdict, reasons = decide(moderate(upload["path"]))
    except Exception as e:
        # On error, fail safe to review rather than letting content through
        verdict, reasons = "review", [f"moderation error: {e}"]
    return {"id": upload["id"], "verdict": verdict, "reasons": reasons}

def screen_batch(uploads, max_workers=10):
    blocked, review, allowed = [], [], []
    with ThreadPoolExecutor(max_workers=max_workers) as pool:
        futures = [pool.submit(screen, u) for u in uploads]
        for fut in as_completed(futures):
            r = fut.result()
            {"block": blocked, "review": review, "allow": allowed}[r["verdict"]].append(r)
    return blocked, review, allowed

Publish the allowed bucket, hold the blocked bucket, and push the review bucket to your moderation queue. The fail-safe to review on error matters: when the API call fails, you want the image held for a human, not published unchecked.

Honest limits

A moderation API is a strong first line, not the whole system. It scores pixels, not intent, so the same image can be a violation or legitimate news depending on context the model cannot see (that is what the review queue is for). Thresholds are a product decision: strict catches more but annoys real users with false positives. Policy is regional, and images are one surface (text, video, and audio need their own moderation).

Read the full guide with the review-queue pattern and the honest limits on ai-engine.net.

Background Removal at Scale: A High-Volume Pipeline for Ecommerce

AI Engine — Sun, 07 Jun 2026 05:49:56 +0000

You run an online store, a marketplace integration, or a product-data pipeline, and you have thousands of product photos shot against inconsistent backgrounds: vendor warehouses, kitchen tables, studio sweeps, phone snaps. Marketplaces want clean, uniform images. Doing this by hand in Photoshop does not scale past a few dozen SKUs. A background removal API turns it into a batch job you run once and forget.

This walkthrough covers the scaling patterns that matter when you are processing a whole catalog: single calls, concurrent batches, white-background output for marketplace listings, and a retry-safe pipeline. All code is Python and runs against a live API.

Want to see the cutout quality on your own products? Try the Background Removal API on a sample image.

Why backgrounds matter for conversion

Product image quality is not cosmetic. Amazon requires a pure white background (RGB 255, 255, 255) for main listing images. Shopify themes look broken when one product floats on white and the next sits on a gray kitchen counter. Consistent backgrounds make a catalog look professional, and that consistency is part of how shoppers judge whether a store is trustworthy. The problem is that source images almost never arrive consistent, especially when vendors or drop-shippers supply them.

So the real job is not "remove one background." It is "normalize thousands of inconsistent images into one clean look, repeatably, as new products arrive."

The single call

Start with one image to confirm the shape. Install the two packages first (pip install requests tqdm), then:

import requests

HEADERS = {
    "x-rapidapi-key": "YOUR_API_KEY",
    "x-rapidapi-host": "background-removal-ai.p.rapidapi.com",
}

resp = requests.post(
    "https://background-removal-ai.p.rapidapi.com/remove-background",
    headers={**HEADERS, "Content-Type": "application/json"},
    json={"image_url": "https://example.com/product.jpg"},
)
result = resp.json()
print(result["image_url"])  # URL to the transparent PNG

The response includes the output image_url plus width, height, and size_bytes, which you can store alongside your product records.

White background for marketplace listings

Transparency is great for your own site, but marketplaces usually want a solid white backdrop. Instead of removing the background and then compositing onto white in a second step, use the color-background endpoint to do both at once:

def on_white(image_url):
    """Remove background and composite the product onto solid white."""
    resp = requests.post(
        "https://background-removal-ai.p.rapidapi.com/color-background",
        headers={**HEADERS, "Content-Type": "application/json"},
        json={"image_url": image_url, "bg_color": "255,255,255,255"},
    )
    return resp.json()["image_url"]

The bg_color value is R,G,B,A (each 0 to 255), so 255,255,255,255 is opaque white. Swap it if a channel needs a brand color behind the product.

Run the white-background call on a product photo and check the result before wiring up a batch.

Batch a whole catalog concurrently

A catalog migration is the moment scaling matters. Processing sequentially, 10,000 images at 1.5 seconds each is over 4 hours of wall-clock time. With a concurrency pool, the same job finishes in a fraction of that. Here is a retry-safe batch processor:

import csv
import requests
from concurrent.futures import ThreadPoolExecutor, as_completed
from tqdm import tqdm

HEADERS = {
    "x-rapidapi-key": "YOUR_API_KEY",
    "x-rapidapi-host": "background-removal-ai.p.rapidapi.com",
}
URL = "https://background-removal-ai.p.rapidapi.com/color-background"

def process(sku, image_url, retries=3):
    """Process one product image, retrying on transient errors."""
    for attempt in range(retries):
        try:
            r = requests.post(
                URL,
                headers={**HEADERS, "Content-Type": "application/json"},
                json={"image_url": image_url, "bg_color": "255,255,255,255"},
                timeout=30,
            )
            r.raise_for_status()
            return sku, r.json()["image_url"], None
        except Exception as e:
            if attempt == retries - 1:
                return sku, None, str(e)

# products.csv has columns: sku, image_url
with open("products.csv") as f:
    products = list(csv.DictReader(f))

results, failures = [], []
with ThreadPoolExecutor(max_workers=10) as pool:
    futures = [pool.submit(process, p["sku"], p["image_url"]) for p in products]
    for fut in tqdm(as_completed(futures), total=len(futures), desc="Removing backgrounds"):
        sku, out_url, err = fut.result()
        (failures if err else results).append((sku, err or out_url))

print(f"Processed {len(results)} images, {len(failures)} failed")

The max_workers=10 setting controls concurrency. Tune it to your plan's rate limit: higher means faster but risks throttling. The retry loop absorbs transient network blips so a single failure does not abort a 10,000-image run, and failed SKUs land in a list you can re-run.

Quality control at scale

Most product photos cut out cleanly, but a catalog always has a tail of hard cases: reflective bottles, transparent or glossy packaging, white products on near-white surfaces. Publishing a bad cutout looks worse than the original photo, so a high-volume pipeline needs a QA step. You cannot eyeball 10,000 images, so flag the suspicious ones automatically and send only those to a human:

import statistics

def flag_for_review(results_with_meta):
    """results_with_meta: list of (sku, width, height, size_bytes, category)"""
    sizes = [m[3] for m in results_with_meta]
    median = statistics.median(sizes)
    tricky = {"glassware", "jewelry", "transparent-packaging"}

    review = []
    for sku, w, h, size_bytes, category in results_with_meta:
        too_small = size_bytes < median * 0.3  # over-cropped subject
        if too_small or category in tricky:
            review.append(sku)
    return review

Two cheap signals catch most failures: an output whose file size is far from the batch norm, and products in categories you already know are tricky. Route the flagged SKUs to a review queue and auto-publish the rest, keeping human effort on the few percent that need it.

When a cloud API beats self-hosting

Open-source models like rembg are free and fine for low volume. At catalog scale the calculus changes: a managed API holds quality across hair, fur, and transparent packaging where lighter models struggle, there is no GPU fleet to operate, and you monitor one pipeline with retries and a single output format instead of a model deployment you maintain. The trade-off is a per-call cost and a network dependency, usually worth it when image quality directly affects conversion.

Read the full guide with the new-product ingest worker and the gradient and blur options on ai-engine.net.

Build eKYC for Your SaaS: Match a Selfie to an ID with an API

AI Engine — Sun, 07 Jun 2026 05:49:50 +0000

Your SaaS needs to confirm new users are who they claim to be: a fintech opening accounts, a marketplace onboarding sellers, a gig app vetting workers. The standard step is eKYC. The user uploads a government ID and takes a selfie, and your backend checks that the selfie matches the photo on the ID. Building that from scratch means face-recognition models and document parsing. Two APIs handle both halves, and you can wire the onboarding step together in an afternoon.

This walkthrough builds the two layers you can ship quickly: extracting the ID data with an OCR API, and matching the selfie to the ID photo with a face comparison API, then combining them into an approve / review / reject decision. Every snippet runs against live endpoints.

Want to test the match step now? Try the Face Analyzer API on a selfie and an ID photo.

What eKYC actually requires

It helps to be precise about the layers, because no single API does all of them and overclaiming here is how teams ship insecure onboarding:

Document data extraction - read the name, date of birth, document number, and expiry off the ID. This uses an OCR API.
Face match - confirm the selfie is the same person as the ID photo. This uses a face comparison API.
Liveness - confirm the selfie is a live person, not a photo of a photo or a screen replay. A separate concern.
Document authenticity - confirm the ID itself is genuine and unaltered. Also separate, and the hardest to automate.

The first two are the layers you can build today with a couple of API calls, and they catch the most common case: a user submitting someone else's ID.

Step 1: Extract the ID data with OCR

Send the ID image to the OCR endpoint and get the text back. For a national ID, license, or passport, it returns every printed field:

import requests

OCR_HEADERS = {
    "x-rapidapi-key": "YOUR_API_KEY",
    "x-rapidapi-host": "ocr-wizard.p.rapidapi.com",
}

def read_id_document(id_image_path):
    """OCR an ID document, return the raw extracted text."""
    with open(id_image_path, "rb") as f:
        r = requests.post(
            "https://ocr-wizard.p.rapidapi.com/ocr",
            headers=OCR_HEADERS,
            files={"image": f},
        )
    return r.json()["body"]["fullText"]

Labels and values come back on separate lines, exact order varying by document. To turn that into structured fields, pipe it through an LLM, the same pattern as an invoice or receipt parser.

Reading IDs, invoices, or receipts? Try the OCR Wizard API on your own document.

Step 2: Match the selfie to the ID photo

Now the core of identity verification: does the selfie belong to the same person as the photo on the ID. The compare-faces endpoint takes two images and returns the faces that matched. A useful detail: you can pass the full ID image as the target without cropping the photo first, and the API locates the face on the document for you.

FACE_HEADERS = {
    "x-rapidapi-key": "YOUR_API_KEY",
    "x-rapidapi-host": "faceanalyzer-ai.p.rapidapi.com",
}

def faces_match(selfie_path, id_image_path):
    """Return True if the selfie matches the face on the ID document."""
    with open(selfie_path, "rb") as selfie, open(id_image_path, "rb") as id_img:
        r = requests.post(
            "https://faceanalyzer-ai.p.rapidapi.com/compare-faces",
            headers=FACE_HEADERS,
            files={
                "source_image": ("selfie.jpg", selfie, "image/jpeg"),
                "target_image": ("id.jpg", id_img, "image/jpeg"),
            },
        )
    body = r.json()["body"]
    return len(body.get("matchedFaces", [])) > 0

A non-empty matchedFaces means the selfie and the ID photo are the same person. An empty match with a populated unmatchedFaces means a mismatch.

Curious how it scores your own pair of images? Run it on a selfie and an ID and read the matched faces back.

Step 3: Quality-gate the inputs with face detection

The compare call finds the face on the ID for you, so you do not need detection to make the match. Where detection earns its place is as a quality gate before the comparison: confirm the selfie shows exactly one clear face, and confirm the ID actually has a detectable photo. That turns a useless empty match into a clear reason like "no face found on the document":

def count_faces(image_path):
    """Return how many faces the detector finds in an image."""
    with open(image_path, "rb") as f:
        r = requests.post(
            "https://faceanalyzer-ai.p.rapidapi.com/faceanalysis",
            headers=FACE_HEADERS,
            files={"image": f},
        )
    return len(r.json()["body"]["faces"])

Zero faces on the selfie means a bad capture, two or more means someone else is in frame, and zero on the ID means the photo region was not readable. Each is a reason to route to review rather than guess.

Step 4: Turn it into a decision

No single call is a decision. Combine the detection gate, the document data, the expiry check, and the face match into one verdict your flow can act on:

import re
from datetime import date

def verify_identity(selfie_path, id_image_path):
    if count_faces(selfie_path) != 1:
        return "review", "selfie must show exactly one clear face"
    if count_faces(id_image_path) != 1:
        return "review", "could not find a single face on the ID document"

    text = read_id_document(id_image_path)
    m = re.search(r"EXPIRES\s+(\d{4}-\d{2}-\d{2})", text)
    expiry = date.fromisoformat(m.group(1)) if m else None
    if expiry is not None and expiry < date.today():
        return "reject", "ID is expired"

    if not faces_match(selfie_path, id_image_path):
        return "review", "selfie did not match the ID photo"
    if expiry is None:
        return "review", "could not read the expiry date"
    return "approve", "identity verified"

Auto-approve when everything lines up, auto-reject on a clear failure, and send the ambiguous middle to a human queue rather than guessing.

Honest limits

These two layers catch the common failure modes, but they are not a complete eKYC stack on their own. There is no liveness here, so a face match alone cannot tell a live selfie from a held-up photo of the ID owner; add a liveness step for anything high-risk. And OCR reads what is printed, it does not verify the ID is genuine; forged documents need a separate authenticity layer. Treat this as the face-match and data-extraction core of your eKYC, not the whole thing.

Read the full guide with the Flask endpoint, the response shapes, and the decision logic on ai-engine.net.

PDF OCR in Python: Extract Text from Scanned PDFs in 5 Lines

AI Engine — Sat, 06 Jun 2026 05:55:14 +0000

You have a folder of scanned PDFs. Invoices, contracts, old reports, bank statements your accountant emailed you. None of them are searchable. PyPDF2 returns empty strings because the text is locked inside pixel data, not actual characters.

The classic Python answer is Tesseract: install the binary, install pytesseract, install pdf2image and Poppler, convert each page to an image, run OCR per page, stitch the text back together. Forty lines of code, three system dependencies, and accuracy that varies with scan quality.

A cloud OCR API skips all of that. Here are the five lines of Python that replace the entire pipeline.

Want to run it now? Grab a key from the OCR Wizard API and paste it in.

The 5-line solution

import requests

with open("scanned.pdf", "rb") as f:
    r = requests.post(
        "https://ocr-wizard.p.rapidapi.com/ocr-pdf",
        headers={"x-rapidapi-key": "YOUR_API_KEY", "x-rapidapi-host": "ocr-wizard.p.rapidapi.com"},
        files={"pdf_file": f},
        data={"first_page": 1, "last_page": 10},
    )

print("\n\n".join(p["fullText"] for p in r.json()["body"]["pages"]))

No Tesseract install, no pdf2image, no Poppler, no per-page image conversion. Open the PDF, post it, join the pages.

One detail worth knowing: the API caps each request at a 10-page range (the difference between first_page and last_page cannot exceed 10). The snippet covers any PDF from 1 to 10 pages in a single call.

Process PDFs longer than 10 pages

Slide a 10-page window across the document:

import requests

HEADERS = {"x-rapidapi-key": "YOUR_API_KEY", "x-rapidapi-host": "ocr-wizard.p.rapidapi.com"}
URL = "https://ocr-wizard.p.rapidapi.com/ocr-pdf"
BATCH = 10

def ocr_pdf(pdf_path, total_pages):
    all_pages = []
    for start in range(1, total_pages + 1, BATCH):
        end = min(start + BATCH - 1, total_pages)
        with open(pdf_path, "rb") as f:
            r = requests.post(URL, headers=HEADERS, files={"pdf_file": f},
                              data={"first_page": start, "last_page": end})
        all_pages.extend(r.json()["body"]["pages"])
    return all_pages

pages = ocr_pdf("annual-report.pdf", total_pages=120)
print(f"{len(pages)} pages, {sum(len(p['fullText']) for p in pages)} characters")

See the folder-batch and citation variations in the complete guide.

Track page numbers for citations

The API does not return a pageNumber field, so use the list index plus your first_page offset when you need to cite specific pages:

pages = r.json()["body"]["pages"]
first_page = 1
for offset, p in enumerate(pages):
    print(f"[Page {first_page + offset}] ({p['detectedLanguage']})")
    print(p["fullText"][:200], "...\n")

Why skip Tesseract locally

Tesseract is a fine engine and still the go-to for offline, privacy-sensitive workloads. For most other use cases, the cloud approach wins on three concrete points: no system dependencies (no binary, no Poppler), no per-page image conversion (the API accepts the PDF directly), and better accuracy on noisy scans like faxes and skewed pages.

Read the full PDF OCR developer guide on ai-engine.net, or see how to pipe OCR into GPT-4 in the ID Card to JSON tutorial.