DEV Community: AI Engine

Kairos and Betaface API Alternative: Drop-in Python Code

AI Engine — Thu, 29 Oct 2026 16:16:07 +0000

Kairos and Betaface were two of the go-to face recognition APIs of the 2010s: enroll a face under a name, then recognize it in any photo. In 2026, Kairos sells identity verification and the public Betaface API is offline, which leaves attendance apps, visitor kiosks and photo tools built on them looking for a replacement.

Below: a small Python module that keeps the Kairos function names (enroll, recognize, verify, galleries) and the Kairos response shape on top of a hosted face recognition API. Every output comes from a live run on real photos of an office team.

Want to run it on your own photos? Get a key for the Face Analyzer API.

Where Kairos and Betaface stand in 2026

Checked on 28 October 2026:

Kairos: kairos.com now presents identity verification (documents, selfies, liveness). The classic face recognition docs still live on face.kairos.com, but sign-up asks for a business email and how you plan to use Kairos, and pricing is a contact-sales form
Betaface: the betaface.com products page reads "Public betafaceapi.com is temporarily down", the latest news post (17 March 2026) says the website is being restored, and the betafaceapi.com domain no longer resolves. On-premise licences are still offered

Kairos endpoints mapped

Kairos	Face Analyzer API
`/enroll`	/save-face-in-repository (subject_id becomes external_id)
`/recognize`	/faceanalysis, then /search-face-in-repository per face
`/verify`	/search-face-in-repository filtered on the subject
`/detect`	/faceanalysis (box, landmarks, age range, gender, emotions)
`/gallery/list_all`	/list-facial-repositories
`/gallery/view`	/list-repository-faces
`/gallery/remove_subject`	/delete-face-from-repository
`/gallery/remove`	/delete-facial-repository
confidence 0 to 1, default 0.60	Similarity 0 to 100, we use 90

For Betaface, a namespace becomes a face repository, a person such as john@mynamespace becomes the external_id, face tags (age, gender, glasses, smile) come from /faceanalysis, verification is /compare-faces and identification is /search-face-in-repository. The module below works as the base for both migrations.

Step 1: a Kairos-compatible module

Kairos /recognize matches every face in a photo, while the repository search looks at the main face of the image it receives, so recognize detects the faces first and searches a crop of each one. Save as kairos_compat.py:

import io
import requests
from PIL import Image, ImageOps

BASE = "https://faceanalyzer-ai.p.rapidapi.com"
HEADERS = {
    "x-rapidapi-host": "faceanalyzer-ai.p.rapidapi.com",
    "x-rapidapi-key": "YOUR_API_KEY",
}
MIN_SIMILARITY = 90  # 0 to 100 scale


def _post(endpoint, files=None, data=None):
    r = requests.post(f"{BASE}{endpoint}", headers=HEADERS, files=files, data=data)
    return r.json()["body"]


def _get(endpoint, params=None):
    r = requests.get(f"{BASE}{endpoint}", headers=HEADERS, params=params)
    return r.json()["body"]


def _search(face_jpg, gallery_name):
    """Return the matches of one face in a gallery, best first."""
    body = _post(
        "/search-face-in-repository",
        files={"image": ("face.jpg", face_jpg, "image/jpeg")},
        data={"repository_id": gallery_name},
    )
    matches = [m for m in body.get("FaceMatches", []) if m["Similarity"] >= MIN_SIMILARITY]
    return sorted(matches, key=lambda m: m["Similarity"], reverse=True)


def enroll(image_path, subject_id, gallery_name):
    """Kairos /enroll: store the face under subject_id, creating the gallery if needed."""
    if gallery_name not in _get("/list-facial-repositories")["FacialRepositoriesId"]:
        _post("/create-facial-repository", data={"repository_id": gallery_name})
    with open(image_path, "rb") as f:
        body = _post(
            "/save-face-in-repository",
            files={"image": f},
            data={"repository_id": gallery_name, "external_id": subject_id, "max_faces": "1"},
        )
    return {"face_id": body["FacesId"][0], "subject_id": subject_id}


def recognize(image_path, gallery_name):
    """Kairos /recognize: match every face in the photo against the gallery."""
    with open(image_path, "rb") as f:
        faces = _post("/faceanalysis", files={"image": f})["faces"]
    im = ImageOps.exif_transpose(Image.open(image_path)).convert("RGB")
    w, h = im.size
    images = []
    for face in faces:
        b = face["boundingBox"]
        x1, y1 = int(b["topLeft"]["x"] * w), int(b["topLeft"]["y"] * h)
        x2, y2 = int(b["bottomRight"]["x"] * w), int(b["bottomRight"]["y"] * h)
        m = int((x2 - x1) * 0.4)
        buf = io.BytesIO()
        im.crop((max(0, x1 - m), max(0, y1 - m), min(w, x2 + m), min(h, y2 + m))).save(buf, "JPEG")
        matches = _search(buf.getvalue(), gallery_name)
        transaction = {"topLeftX": x1, "topLeftY": y1, "width": x2 - x1, "height": y2 - y1}
        if matches:
            transaction.update(
                status="success",
                subject_id=matches[0]["ExternalImageId"],
                confidence=round(matches[0]["Similarity"] / 100, 5),
            )
        else:
            transaction.update(status="failure", message="no match found")
        candidates = [
            {"subject_id": m["ExternalImageId"], "confidence": round(m["Similarity"] / 100, 5)}
            for m in matches
        ]
        images.append({"transaction": transaction, "candidates": candidates})
    return {"images": images}


def verify(image_path, subject_id, gallery_name):
    """Kairos /verify: is the main face in the photo this subject?"""
    with open(image_path, "rb") as f:
        matches = _search(f.read(), gallery_name)
    scores = [m["Similarity"] for m in matches if m["ExternalImageId"] == subject_id]
    confidence = round(max(scores, default=0) / 100, 5)
    return {"status": "success" if scores else "failure", "subject_id": subject_id, "confidence": confidence}


def gallery_view(gallery_name):
    """Kairos /gallery/view: the subject_ids enrolled in a gallery."""
    faces = _get("/list-repository-faces", {"repository_id": gallery_name})["Faces"]
    return {"subject_ids": sorted({f["ExternalImageId"] for f in faces})}


def gallery_remove_subject(gallery_name, subject_id):
    """Kairos /gallery/remove_subject: delete every face enrolled for subject_id."""
    faces = _get("/list-repository-faces", {"repository_id": gallery_name})["Faces"]
    face_ids = [f["FaceId"] for f in faces if f["ExternalImageId"] == subject_id]
    _post("/delete-face-from-repository", data={"repository_id": gallery_name, "face_ids": face_ids})
    return {"status": "Complete", "removed": len(face_ids)}


def gallery_remove(gallery_name):
    """Kairos /gallery/remove: delete the gallery and all its faces."""
    return _post("/delete-facial-repository", data={"repository_id": gallery_name})

Step 2: enroll your people

Four staff badges, one photo each, with the same call as Kairos. The gallery is created on first use:

from kairos_compat import enroll, recognize, verify, gallery_view, gallery_remove_subject

GALLERY = "office-staff"
for name in ["marcus", "andre", "nia", "daniel"]:
    print(enroll(f"badges/{name}.jpg", name, GALLERY))
# {'face_id': 'b2ab7035-...', 'subject_id': 'marcus'}
# ... one line per person

Step 3: recognize every face in a group photo

result = recognize("team.jpg", GALLERY)
for image in result["images"]:
    t = image["transaction"]
    print(t["status"], t.get("subject_id", "-"), t.get("confidence", ""))
# success daniel 0.9998
# success nia 0.99934
# failure -
# success andre 0.99999
# success marcus 0.99999

Five faces, five correct answers in under 3 seconds: the four enrolled people are named above 0.999, and the fifth man, never enrolled, comes back as failure with no candidate and the same "no match found" message Kairos uses.

Step 4: verify one person

Tested on a photo from another day of the shoot, in a suit and tie instead of the white t-shirt of his badge:

print(verify("daniel_suit.jpg", "daniel", GALLERY))
print(verify("daniel_suit.jpg", "marcus", GALLERY))
# {'status': 'success', 'subject_id': 'daniel', 'confidence': 0.99975}
# {'status': 'failure', 'subject_id': 'marcus', 'confidence': 0.0}

Step 5: manage the gallery

print(gallery_view(GALLERY))
print(gallery_remove_subject(GALLERY, "andre"))
print(gallery_view(GALLERY))
# {'subject_ids': ['andre', 'daniel', 'marcus', 'nia']}
# {'status': 'Complete', 'removed': 1}
# {'subject_ids': ['daniel', 'marcus', 'nia']}

Migration tips

Re-enroll from the original photos: face templates are specific to each engine, so run your source images through enroll once with the same subject_ids
Set the threshold on the new scale: 90 on the 0 to 100 Similarity scale is a strict start for access control
Enroll more than one photo per person: a profile shot or a photo with glasses helps in real conditions
Switch behind a flag: the module returns Kairos-shaped JSON, so you can compare answers on a share of traffic first
One gallery per customer: never mix the faces of two customers in a SaaS

Full guide with the Betaface mapping and sources: Kairos and Betaface API alternative on ai-engine.net.

Sources: Kairos API reference, Betaface products page, test photos by Kindel Media on Pexels.

👉 Grab a key from the Face Analyzer API page and point your app at kairos_compat.py.

Group Photos by Face in Python: One Album per Person

AI Engine — Tue, 27 Oct 2026 09:23:49 +0000

Phone galleries, family archives, a photographer's backlog: where are all the photos of this person? Here is how to group photos by face in Python: detect every face, match it in a face repository, and sort the library into one album per person. No model to download, no dlib to compile.

Every number below comes from a live run on 24 photos from two outings, a camping trip and a beach picnic.

Want to sort your own library? Get a key for the Face Analyzer API.

Step 1: create a face repository

import io
import os
import shutil
import requests
from concurrent.futures import ThreadPoolExecutor
from PIL import Image, ImageOps

BASE = "https://faceanalyzer-ai.p.rapidapi.com"
HEADERS = {
    "x-rapidapi-host": "faceanalyzer-ai.p.rapidapi.com",
    "x-rapidapi-key": "YOUR_API_KEY",
}
LIBRARY = "my-photo-library"
MIN_SIMILARITY = 90

r = requests.post(
    f"{BASE}/create-facial-repository",
    headers=HEADERS,
    data={"repository_id": LIBRARY},
)
print(r.json())

Step 2: detect and crop every face

def detect_faces(path):
    """Return the photo path and the bounding box of every face in it."""
    with open(path, "rb") as f:
        r = requests.post(f"{BASE}/faceanalysis", headers=HEADERS, files={"image": f})
    return path, [face["boundingBox"] for face in r.json()["body"]["faces"]]

def crop_face(path, box, margin=0.4):
    """Cut one face out of the photo, with a margin, as JPEG bytes."""
    im = ImageOps.exif_transpose(Image.open(path)).convert("RGB")
    w, h = im.size
    x1, y1 = box["topLeft"]["x"] * w, box["topLeft"]["y"] * h
    x2, y2 = box["bottomRight"]["x"] * w, box["bottomRight"]["y"] * h
    mx, my = (x2 - x1) * margin, (y2 - y1) * margin
    face = im.crop((
        int(max(0, x1 - mx)), int(max(0, y1 - my)),
        int(min(w, x2 + mx)), int(min(h, y2 + my)),
    ))
    buf = io.BytesIO()
    face.save(buf, "JPEG", quality=92)
    return buf.getvalue()

The repository search looks at the main face of the image it receives, so each face is sent as its own crop.

Step 3: match each face or start a new person

def who_is(face_jpg):
    """Return the label of the closest known person, or None for a new face."""
    r = requests.post(
        f"{BASE}/search-face-in-repository",
        headers=HEADERS,
        files={"image": ("face.jpg", face_jpg)},
        data={"repository_id": LIBRARY},
    )
    matches = [
        m for m in r.json()["body"].get("FaceMatches", [])
        if m["Similarity"] >= MIN_SIMILARITY
    ]
    if not matches:
        return None
    return max(matches, key=lambda m: m["Similarity"])["ExternalImageId"]

def remember(face_jpg, person):
    """Save the face under the person's label, so later photos match it too."""
    requests.post(
        f"{BASE}/save-face-in-repository",
        headers=HEADERS,
        files={"image": ("face.jpg", face_jpg)},
        data={"repository_id": LIBRARY, "external_id": person, "max_faces": "1"},
    )

people = {}  # person label -> names of the photos they appear in

def sort_photos(folder):
    """Detect faces in parallel, then match each face to a person in order."""
    paths = sorted(os.path.join(folder, n) for n in os.listdir(folder))
    with ThreadPoolExecutor(max_workers=4) as pool:
        detected = list(pool.map(detect_faces, paths))
    for path, boxes in detected:
        for box in boxes:
            face_jpg = crop_face(path, box)
            person = who_is(face_jpg)
            if person is None:
                person = f"person_{len(people) + 1}"
                people[person] = set()
            remember(face_jpg, person)
            people[person].add(path)
    return sum(len(boxes) for _, boxes in detected)

faces = sort_photos("photos")
print(faces, "faces,", len(people), "face groups")
# 54 faces, 16 face groups

Step 4: one album per person

MIN_PHOTOS = 3

def build_albums(out_dir="albums"):
    """Copy each photo into the album of every person in it."""
    shutil.rmtree(out_dir, ignore_errors=True)
    for person, paths in people.items():
        album = person if len(paths) >= MIN_PHOTOS else "unsorted"
        os.makedirs(os.path.join(out_dir, album), exist_ok=True)
        for path in paths:
            shutil.copy(path, os.path.join(out_dir, album, os.path.basename(path)))
    for album in sorted(os.listdir(out_dir)):
        print(album, len(os.listdir(os.path.join(out_dir, album))), "photos")

build_albums()

person_10 6 photos
person_12 4 photos
person_13 4 photos
person_14 5 photos
person_2 6 photos
person_3 6 photos
person_5 7 photos
person_6 5 photos
person_9 3 photos
unsorted 7 photos

Nine albums for the nine people: the two campers and the seven picnic friends. Every album contains a single person, checked by eye. Faces seen once or twice (a head turned away, a passer-by out of focus) go to unsorted.

Step 5: new photos join the right album

before = {person: set(paths) for person, paths in people.items()}
sort_photos("new_photos")
for person, paths in people.items():
    for path in sorted(paths - before.get(person, set())):
        print(os.path.basename(path), "->", person)
build_albums()

IMG_5064932.jpg -> person_3
IMG_8021122.jpg -> person_9

Under 3 seconds, no re-clustering.

Why not face_recognition + DBSCAN?

	face_recognition + DBSCAN	Face Analyzer API
Install	dlib source build (CMake, C++)	requests and Pillow
Last release	1.3.0, February 2020	hosted
New photos	re-cluster, labels can change	one search per face, stable labels
Tuning	eps and min_samples	one similarity threshold
Children	README warns it mixes them up at 0.6	same code for every face

Production tips

One repository per user, deleted when they turn the feature off
Face grouping is biometric processing under GDPR Article 9: make it opt-in
Let users merge and rename albums
Run the first pass as a background job

Full guide: group photos by face on ai-engine.net.

Sources: face_recognition, dlib on PyPI, GDPR Article 9, test photos from Pexels (Kamaji Ogino, Thirdman).

👉 Grab a key from the Face Analyzer API page and sort your own photos.

Blur Faces in Photos Automatically with Python (GDPR)

AI Engine — Mon, 26 Oct 2026 07:21:49 +0000

Street shots for a city guide, user uploads, a training dataset, a CCTV clip someone asked for under GDPR: all of them are full of faces of people who never agreed to be published. Here is how to blur them automatically in Python: one API call finds every face, Pillow pixelates them, and the saved file drops the GPS metadata too.

All numbers below come from live calls on six crowded street photos and one party photo.

Want to run it on your own photos? Get a key for the Face Analyzer API.

Step 1: detect every face

import os
import requests
from concurrent.futures import ThreadPoolExecutor
from PIL import Image, ImageFilter, ImageOps

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

def detect_faces(path):
    """Return the bounding box of every face in the image (0 to 1 coordinates)."""
    with open(path, "rb") as f:
        r = requests.post(f"{BASE}/faceanalysis", headers=HEADERS, files={"image": f})
    return [face["boundingBox"] for face in r.json()["body"]["faces"]]

boxes = detect_faces("photos/covered_market.jpg")
print(len(boxes), "faces")  # 21 faces

A photo without anyone in it returns {"faces": []}, so no special case is needed.

Step 2: pixelate and blur each face

A light Gaussian blur can leave a face recognizable. Shrinking each face to an 8x8 grid first removes the detail for good:

def blur_boxes(path, boxes, out_path, pad=0.25):
    """Pixelate and blur each face box, then save without the original metadata."""
    im = ImageOps.exif_transpose(Image.open(path)).convert("RGB")
    w, h = im.size
    for b in boxes:
        x1, y1 = b["topLeft"]["x"] * w, b["topLeft"]["y"] * h
        x2, y2 = b["bottomRight"]["x"] * w, b["bottomRight"]["y"] * h
        px, py = max((x2 - x1) * pad, 4), max((y2 - y1) * pad, 4)
        box = (
            int(max(0, x1 - px)), int(max(0, y1 - py)),
            int(min(w, x2 + px)), int(min(h, y2 + py)),
        )
        face = im.crop(box)
        tiny = face.resize((8, 8))  # 8x8 blocks: the facial detail is gone
        im.paste(tiny.resize(face.size, Image.NEAREST).filter(ImageFilter.GaussianBlur(4)), box)
    im.save(out_path, quality=90)  # no exif= argument: GPS and camera data are dropped

Metadata is dropped: a test photo with GPS coordinates came out with an empty EXIF block.
Phone photos stay upright: the API reads the orientation tag, and exif_transpose rotates the pixels the same way.
Tiny faces stay covered: the 4-pixel minimum margin handles faces a few pixels wide.

Step 3: a whole folder in parallel

def anonymize(path, out_dir="blurred"):
    """Detect and blur every face in one photo."""
    boxes = detect_faces(path)
    blur_boxes(path, boxes, os.path.join(out_dir, os.path.basename(path)))
    return os.path.basename(path), len(boxes)

os.makedirs("blurred", exist_ok=True)
photos = sorted(os.path.join("photos", n) for n in os.listdir("photos"))
with ThreadPoolExecutor(max_workers=4) as pool:
    for name, count in pool.map(anonymize, photos):
        print(name, count, "faces blurred")

city_market.jpg 17 faces blurred
covered_market.jpg 21 faces blurred
crowded_street.jpg 22 faces blurred
london_street.jpg 19 faces blurred
road_crossing.jpg 24 faces blurred
zurich_crossing.jpg 20 faces blurred

123 faces in about 3.5 seconds.

Why not OpenCV Haar cascades?

Same photos, the usual haarcascade_frontalface_default.xml with scaleFactor=1.1, minNeighbors=5:

Photo	Haar cascade (boxes)	Face Analyzer API (faces)
city_market.jpg	0	17
covered_market.jpg	8, 3 not faces	21
crowded_street.jpg	4	22
london_street.jpg	1	19
road_crossing.jpg	3	24
zurich_crossing.jpg	3	20
party.jpg (5 people)	7, 2 not faces	5

The cascade boxed a shop sign, a pair of shorts, a snack packet, a coat and a shoe. For anonymization, a missed face is the failure that matters: it gets published as is.

Blur everyone except one person

For GDPR access requests, the requester gets a copy where everyone else is blurred. /compare-faces splits the faces of the scene into matchedFaces and unmatchedFaces:

def blur_all_except(reference_path, photo_path, out_path):
    """Blur every face in the photo except the person in the reference photo."""
    with open(reference_path, "rb") as ref, open(photo_path, "rb") as photo:
        r = requests.post(
            f"{BASE}/compare-faces",
            headers=HEADERS,
            files={"source_image": ref, "target_image": photo},
        )
    body = r.json()["body"]
    others = [face["boundingBox"] for face in body["unmatchedFaces"]]
    blur_boxes(photo_path, others, out_path)
    return len(body["matchedFaces"]), len(others)

print(blur_all_except("requester.jpg", "party.jpg", "party_for_requester.jpg"))
# (1, 4)

Blur matchedFaces instead to hide one person who withdrew consent.

Production tips

Blur before storage, not with CSS at display time
Check other clues too: name badges, plates, screens
Raise the margin for close-up portraits
Video: run the same function frame by frame

Full guide with the GDPR background (Recital 26, EDPB video guidelines): blur faces in photos on ai-engine.net.

Sources: GDPR Recital 26, EDPB Guidelines 3/2019, test photos from Pexels.

👉 Grab a key from the Face Analyzer API page and blur your own photos.

face-api.js Alternative: Face Recognition in Node.js with an API

AI Engine — Fri, 23 Oct 2026 09:28:38 +0000

face-api.js made face recognition in JavaScript easy, but its last release (0.22.2) shipped in March 2020 and still pins TensorFlow.js core 1.7.0. The best-known fork, @vladmandic/face-api, is now archived too, yet the two packages still pull about 465,000 and 518,000 npm downloads a month.

Here is how to replace it with a face recognition API from Node.js 20: built-in fetch and FormData, no SDK, no model weights, no canvas or tfjs-node build. All code below ran against the live API.

Want to run it on your own photos? Get a key for the Face Analyzer API.

face-api.js calls mapped to endpoints

face-api.js	Face Analyzer API
`nets.*.loadFromDisk("./models")`	nothing to load
`detectAllFaces().withFaceLandmarks()`	`/faceanalysis` (`boundingBox`, `landmarks`)
`.withAgeAndGender()`, `.withFaceExpressions()`	`/faceanalysis` (`AgeRange`, `Gender`, `Emotions`)
`euclideanDistance(d1, d2) < 0.6`	`/compare-faces` (`matchedFaces`, `unmatchedFaces`)
`new FaceMatcher(labeledDescriptors)`	`/save-face-in-repository` with `external_id`
`faceMatcher.findBestMatch()`	`/search-face-in-repository` (label + `Similarity`)

One helper for every endpoint

// face.mjs
import { openAsBlob } from "node:fs";

const BASE = "https://faceanalyzer-ai.p.rapidapi.com";
const HEADERS = {
  "x-rapidapi-host": "faceanalyzer-ai.p.rapidapi.com",
  "x-rapidapi-key": process.env.RAPIDAPI_KEY,
};

export async function callApi(endpoint, files = {}, fields = {}) {
  const form = new FormData();
  for (const [name, path] of Object.entries(files)) {
    form.append(name, await openAsBlob(path), path);
  }
  for (const [name, value] of Object.entries(fields)) {
    form.append(name, value);
  }
  const res = await fetch(`${BASE}${endpoint}`, {
    method: "POST",
    headers: HEADERS,
    body: form,
  });
  return (await res.json()).body;
}

Detection and attributes

import { callApi } from "./face.mjs";

const { faces } = await callApi("/faceanalysis", { image: "team.jpg" });
console.log(faces.length, "faces");
for (const face of faces) {
  const { Gender, Eyeglasses, Emotions } = face.facialFeatures;
  console.log(Gender, Eyeglasses ? "glasses" : "no glasses", Emotions.join(", "));
}

5 faces
Female glasses HAPPY
Male no glasses HAPPY
Male glasses HAPPY
Male glasses CALM
Female no glasses HAPPY

Compare two faces

async function samePerson(sourcePath, targetPath) {
  const body = await callApi("/compare-faces", {
    source_image: sourcePath,
    target_image: targetPath,
  });
  return body.matchedFaces.length > 0;
}

console.log(await samePerson("alex_badge.jpg", "alex_today.jpg")); // true
console.log(await samePerson("alex_badge.jpg", "maya.jpg"));       // false

No threshold to tune. On a photo of a colleague, the API even found Alex out of focus in the background, half hidden behind an arm.

Replace FaceMatcher

const REPO = "team-faces";
await callApi("/create-facial-repository", {}, { repository_id: REPO });

const team = { alex: "alex_badge.jpg", maya: "maya.jpg", sam: "sam.jpg" };
for (const [label, path] of Object.entries(team)) {
  await callApi("/save-face-in-repository", { image: path }, {
    repository_id: REPO,
    external_id: label,
    max_faces: "1",
  });
}

async function whoIs(path) {
  const { FaceMatches = [] } = await callApi(
    "/search-face-in-repository",
    { image: path },
    { repository_id: REPO },
  );
  const best = FaceMatches.reduce(
    (a, b) => (!a || b.Similarity > a.Similarity ? b : a),
    null,
  );
  return best && best.Similarity >= 90
    ? `${best.ExternalImageId} (${best.Similarity.toFixed(2)})`
    : "unknown";
}

console.log(await whoIs("alex_office.jpg")); // alex (100.00)
console.log(await whoIs("visitor.jpg"));     // unknown

Browser uploads: proxy through your server

Keep the API key out of the browser with a small Express route (npm i express multer):

import express from "express";
import multer from "multer";

const app = express();
const upload = multer({ limits: { fileSize: 5 * 1024 * 1024 } });

app.post("/api/faces", upload.single("image"), async (req, res) => {
  if (!req.file) return res.status(400).json({ error: "image is required" });
  const form = new FormData();
  form.append("image", new Blob([req.file.buffer], { type: req.file.mimetype }), req.file.originalname);
  const r = await fetch("https://faceanalyzer-ai.p.rapidapi.com/faceanalysis", {
    method: "POST",
    headers: {
      "x-rapidapi-host": "faceanalyzer-ai.p.rapidapi.com",
      "x-rapidapi-key": process.env.RAPIDAPI_KEY,
    },
    body: form,
  });
  res.status(r.status).json((await r.json()).body);
});

app.listen(3000);

Migration tips

Drop face-api.js, canvas, @tensorflow/tfjs-node and the models folder
Re-enroll reference photos with your existing labels as external_id (descriptors cannot be imported)
Scale boxes by image size: coordinates come back from 0 to 1
No face means empty lists, not an error

Full guide with the mapping details: face-api.js alternative on ai-engine.net.

Sources: face-api.js, @vladmandic/face-api, Node.js fs.openAsBlob.

👉 Grab a key from the Face Analyzer API page and run the scripts on your own photos.

Find Event Photos by Selfie with a Face Search API (Python)

AI Engine — Thu, 22 Oct 2026 20:39:47 +0000

After a wedding, a conference or a race, the photographer delivers 2,000 photos and every guest asks: which ones am I in? A face search fixes it. The guest takes one selfie, and the gallery shows only the photos that contain them.

Below is the full flow in Python, with real results from a live 18-photo birthday gallery.

Want to try it on your own gallery? Get a key for the Face Analyzer API and point the script at a folder of event photos.

How it works

Index the gallery once. Each event photo goes to a face repository. Every face in it is stored, labeled with the photo's file name.
Search with a selfie. Each match carries the label of the photo it came from, a similarity score and the face's position.

A group photo with five people produces five stored faces with the same label. The label turns a face match into a photo match.

Step 1: one repository per event

import os
import requests
from concurrent.futures import ThreadPoolExecutor

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

requests.post(
    f"{BASE}/create-facial-repository",
    headers=HEADERS,
    data={"repository_id": EVENT},
)

Step 2: index every event photo

def index_photo(path):
    """Save every face in one event photo, labeled with the photo's file name."""
    with open(path, "rb") as f:
        r = requests.post(
            f"{BASE}/save-face-in-repository",
            headers=HEADERS,
            files={"image": f},
            data={
                "repository_id": EVENT,
                "external_id": os.path.basename(path),
                "max_faces": "20",
            },
        )
    return os.path.basename(path), len(r.json()["body"].get("FacesId", []))

photos = sorted(os.path.join("event_photos", n) for n in os.listdir("event_photos"))
with ThreadPoolExecutor(max_workers=4) as pool:
    for name, faces in pool.map(index_photo, photos):
        print(name, faces, "faces indexed")

18 photos, 76 faces, one call per photo.

Step 3: find a guest's photos

MIN_SIMILARITY = 95

def find_my_photos(selfie_path):
    """Return the event photos that contain the person in the selfie."""
    with open(selfie_path, "rb") as f:
        r = requests.post(
            f"{BASE}/search-face-in-repository",
            headers=HEADERS,
            files={"image": f},
            data={"repository_id": EVENT},
        )
    body = r.json()["body"]
    if "error" in body:
        return None  # no face found in the selfie: ask for a new one
    best = {}
    for m in body["FaceMatches"]:
        photo = m["ExternalImageId"]
        if m["Similarity"] >= MIN_SIMILARITY and (
            photo not in best or m["Similarity"] > best[photo]["Similarity"]
        ):
            best[photo] = m
    return sorted(best.values(), key=lambda m: m["Similarity"], reverse=True)

matches = find_my_photos("selfie.jpg")
print(len(matches), "photos found")

14 photos found
IMG_7336946.jpg 100.0
IMG_7337110.jpg 99.99
...
IMG_7336992.jpg 98.89

She appears in exactly those 14 photos, and the 4 left out are the ones she is not in. Five-person group shots, a side view and a face cut by the frame edge all matched. The search took about half a second.

Edge cases: a selfie with no face returns an error in the body (handled above), and a person who was not at the event gets an empty FaceMatches list.

Step 4: highlight the guest

from PIL import Image, ImageDraw

def highlight(photo_path, match, out_path):
    """Draw a box around the guest's face in one matched photo."""
    im = Image.open(photo_path).convert("RGB")
    w, h = im.size
    box = match["BoundingBox"]
    rect = [
        box["topLeft"]["x"] * w, box["topLeft"]["y"] * h,
        box["bottomRight"]["x"] * w, box["bottomRight"]["y"] * h,
    ]
    ImageDraw.Draw(im).rectangle(rect, outline=(52, 211, 153), width=6)
    im.save(out_path)

The whole script (create, index 18 photos, search, highlight 14) ran in under 8 seconds.

Production tips

Ask for a clear, front-facing selfie
Show guests only their own matches
Get consent before the selfie, do not store it, and call /delete-facial-repository when the gallery closes
Index new uploads as the photographer delivers them
Genuine matches scored 98.89 and above, so a 95 cutoff keeps a wide margin

More on the full guide at ai-engine.net, including where selfie search fits (photographers, races, weddings, conferences, schools).

Sources: GDPR Article 9 (biometric data), test photos by Polina Tankilevitch on Pexels.

👉 Grab a key from the Face Analyzer API page and run a search with your own selfie.

Detect Duplicate Accounts at Signup with a Face Search API (Python)

AI Engine — Wed, 21 Oct 2026 06:22:25 +0000

Your referral bonus is being farmed. One person opens ten accounts with ten email addresses, ten prepaid SIMs and a VPN, and your fraud rules see ten different users. Email, phone and device checks fail because those signals are cheap to rotate. A face is not.

The fix: index every verified user's selfie once, then search each new selfie against that index before the account is created. Below is the full check in Python, with real similarity scores from live calls.

Want to see the scores on your own photos? Try the Face Analyzer API with two photos of the same person.

Where multi-accounting costs you money

Referral and signup bonuses (fintech, wallets, delivery apps)
Free-trial abuse (SaaS and AI tools where a new account resets the quota)
Banned users coming back (marketplaces, dating, gig platforms)
Betting and gaming (bonus hunting, self-excluded players)
Fake reviews (one person running several buyer accounts)

1:N search, not 1:1 comparison

A face comparison answers "are these two photos the same person?". Duplicate detection asks "is this person anywhere among my existing users?". A face repository answers that in one call: save each verified face once with your user ID as external_id, then search returns matching labels with a Similarity score (0 to 100).

Flow:

Create one face repository (once)
On signup, search the new selfie
Match above threshold: hold for review
No match: create the account, save the face, store the returned face ID
No face in the photo: ask for a retake

Duplicates are never indexed, so a repeat offender cannot add a second entry.

The cURL calls

# one-time setup
curl -X POST "https://faceanalyzer-ai.p.rapidapi.com/create-facial-repository" \
  -H "x-rapidapi-key: YOUR_API_KEY" \
  -H "x-rapidapi-host: faceanalyzer-ai.p.rapidapi.com" \
  -d "repository_id=signup-faces"

# search a new selfie
curl -X POST "https://faceanalyzer-ai.p.rapidapi.com/search-face-in-repository" \
  -H "x-rapidapi-key: YOUR_API_KEY" \
  -H "x-rapidapi-host: faceanalyzer-ai.p.rapidapi.com" \
  -F "image=@selfie.jpg" \
  -F "repository_id=signup-faces"

A duplicate comes back like this (real response, trimmed):

{
  "statusCode": 200,
  "body": {
    "FaceMatches": [
      {"FaceId": "61dbcaca-...", "ExternalImageId": "user_1001", "Similarity": 99.9853744506836}
    ]
  }
}

The signup check in Python

import requests

API = "https://faceanalyzer-ai.p.rapidapi.com"
HEADERS = {
    "x-rapidapi-host": "faceanalyzer-ai.p.rapidapi.com",
    "x-rapidapi-key": "YOUR_API_KEY",
}
REPO = "signup-faces"
DUPLICATE_THRESHOLD = 95.0


def search_face(selfie_path):
    with open(selfie_path, "rb") as f:
        r = requests.post(
            f"{API}/search-face-in-repository",
            headers=HEADERS,
            files={"image": f},
            data={"repository_id": REPO},
        )
    body = r.json()["body"]
    if "error" in body:
        raise ValueError(body["error"])  # e.g. no face in the photo
    return body["FaceMatches"]


def index_face(user_id, selfie_path):
    with open(selfie_path, "rb") as f:
        r = requests.post(
            f"{API}/save-face-in-repository",
            headers=HEADERS,
            files={"image": f},
            data={"repository_id": REPO, "external_id": user_id, "max_faces": 1},
        )
    return r.json()["body"]["FacesId"][0]


def check_signup(user_id, selfie_path):
    try:
        matches = search_face(selfie_path)
    except ValueError:
        return {"decision": "retake_selfie"}

    duplicates = [m for m in matches if m["Similarity"] >= DUPLICATE_THRESHOLD]
    if duplicates:
        return {
            "decision": "review",
            "matched_accounts": [
                (m["ExternalImageId"], round(m["Similarity"], 2)) for m in duplicates
            ],
        }

    face_id = index_face(user_id, selfie_path)
    return {"decision": "approve", "face_id": face_id}


print(check_signup("user_7731", "selfie.jpg"))

Two details the code handles: pass max_faces on the save call, and read errors from the error key inside body.

Real results

Five users indexed (anonymous stock models), then three signups:

Second photo of user_1001 (other outfit and background): matched at 99.99, held for review
Second photo of user_1003: matched at 100.0, held for review
Never indexed person: no match, account created
Photo with no face: retake requested

The full guide has the result images, the degraded-photo tests and the deletion flow.

Picking the threshold

Degraded copies of indexed people still scored 99.49 (downscaled 14x), 99.98 (heavy blur), 99.98 (grayscale) and 99.99 (rotated 90 degrees). Eleven people who were not indexed returned no match at all: the search only returns candidates above an internal floor. A threshold of 95 leaves a wide margin.

Review, do not auto-ban: some returning users have a legitimate reason (forgotten login, new email)
Show the reviewer the matched account and whether it is banned
Combine with device and payment signals

Privacy and deletion

Faces used for identification are biometric data (GDPR Article 9; Illinois BIPA in the US). Ask for explicit consent, keep the face index rather than photos, label with opaque user IDs, and delete with the stored face ID:

def erase_user(face_id):
    r = requests.post(
        f"{API}/delete-face-from-repository",
        headers=HEADERS,
        data={"repository_id": REPO, "face_ids": [face_id]},
    )
    return r.json()["body"]  # {"message": "OK"}

After deletion, a new search with the same person's photo returned an empty list.

Scaling notes

Two calls per genuine new user (search + save), one per flagged duplicate. Logins never touch the API.
One repository per product or region if data must stay separated.
Keep a liveness check in front for high-risk flows.

Sources

GDPR Article 9: special categories, including biometric data
GDPR Article 17: right to erasure
Illinois Biometric Information Privacy Act

👉 Grab a key from the Face Analyzer API page and run the check on a few photos of the same person tonight.

NSFW Filter for AI-Generated Images: Check Before You Show

AI Engine — Tue, 20 Oct 2026 06:17:29 +0000

If your product generates images (an avatar app, an AI art tool, an ad creative generator, a chatbot that draws), every output is content you publish. An NSFW filter for AI-generated images checks each output before a user sees it, so a bad generation becomes a retry instead of a screenshot on social media.

Every number below is a real response from a live moderation API, on images produced by a text-to-image model.

👉 Try the NSFW Detect API on your own generations

Why prompt filters and built-in checkers are not enough

Harmless prompts can produce unsafe images. Models fill in details nobody asked for.
Users route around word lists with misspellings, other languages and image-to-image uploads.
Built-in checkers are coarse. The Stable Diffusion safety checker in diffusers returns one boolean per image (or None when it is not loaded), and the pipeline accepts safety_checker=None. A yes/no flag cannot tell alcohol from nudity.
Hosted providers moderate on their terms, and that changes when you switch provider.

Where the check goes

Prompt filter, then generate, then moderate the bytes, and only then storage, CDN or client. Never upload to a public bucket and moderate from the URL: if the check fails, the image is already public.

Step 1: moderate the generated bytes

import requests

NSFW_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(image_bytes, filename="output.png"):
    """Send generated image bytes to the moderation API, return its labels."""
    r = requests.post(
        NSFW_URL,
        headers=HEADERS,
        files={"image": (filename, image_bytes, "image/png")},
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["body"]["ModerationLabels"]

On a generated photo of a man smoking, the API returned Smoking under Drugs & Tobacco Paraphernalia & Use under Drugs & Tobacco, all at 97.1%. Key your policy on the label with an empty ParentName (the top-level category): a generated joint came back under the sub-label Pills, but its top-level category was still Drugs & Tobacco at 99.7%.

Step 2: a policy for generated content

# Top-level category -> (action, minimum confidence). Absent = allowed.
POLICY = {
    "Explicit": ("block", 50),
    "Non-Explicit Nudity of Intimate parts and Kissing": ("block", 50),
    "Violence": ("block", 60),
    "Visually Disturbing": ("block", 60),
    "Hate Symbols": ("block", 40),
    "Drugs & Tobacco": ("block", 60),
    "Swimwear or Underwear": ("review", 60),
    "Gambling": ("review", 50),
    "Rude Gestures": ("review", 60),
}

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

The thresholds are set per category, so one table covers every style your generator produces: the illustrated casino was caught as Gambling and sent to review. An adult (18+) art platform would flip several rows (nudity and swimwear allowed), but keep violence and hate symbols blocked.

👉 Full guide with the policy table and latency measurements

Step 3: generate_safely() with retries and an audit log

import hashlib
import json
import random
import time

def audit(record):
    with open("moderation_audit.jsonl", "a") as f:
        f.write(json.dumps(record) + "\n")

def generate_safely(prompt, generate, user_id, max_attempts=3):
    """generate(prompt, seed) is your image model or provider, returning PNG bytes."""
    for attempt in range(1, max_attempts + 1):
        seed = random.randint(0, 2**31 - 1)
        image = generate(prompt, seed)
        started = time.time()
        try:
            verdict, reasons = decide(moderate(image))
        except requests.RequestException as e:
            verdict, reasons = "review", [f"moderation unavailable: {e}"]  # fail closed
        audit({
            "ts": time.time(), "user": user_id, "prompt": prompt, "seed": seed,
            "attempt": attempt, "verdict": verdict, "reasons": reasons,
            "sha256": hashlib.sha256(image).hexdigest(),
            "check_ms": round((time.time() - started) * 1000),
        })
        if verdict == "allow":
            return {"status": "ok", "image": image, "seed": seed}
        if verdict == "review":
            return {"status": "held_for_review", "seed": seed, "reasons": reasons}
        # blocked: discard this image and try a new seed
    return {"status": "refused", "reasons": reasons}

Block means regenerate with a new seed (capped), review means hold, errors fail closed.
Log the decision and a hash, not the image.
Repeated refused results for one user are a probing pattern: rate-limit or review that account.

Latency

About 0.8 s for a 140 KB JPEG and 1.3 s for a 1.2 MB PNG, end to end. Moderate the exact bytes you publish.

The rules are tightening

Google Play's AI-Generated Content policy: prevent restricted content, offer in-app reporting or flagging.
EU AI Act, Article 50: machine-readable marking of synthetic images from 2 August 2026.

Production tips

Calibrate on your own presets: run a few hundred outputs per style through the API and tune the per-category thresholds.
Start strict, then relax: send borderline categories to review first.
Extend to video: generated clips use the same policy on sampled frames (NSFW video and GIF moderation in Python).

Sources

👉 Get a key on the NSFW Detect API page and point the wrapper at your generator.

Can AI Make Transparent PNGs? Gemini, ChatGPT, Grok

AI Engine — Sun, 18 Oct 2026 11:11:01 +0000

You asked an image generator for a logo, a sticker or a product mockup "on a transparent background", downloaded the PNG, dropped it on your site, and got a white box or a grey checkerboard around it. Most AI image tools cannot output a real alpha channel, and the ones that try often paint the checkerboard into the pixels.

Here is the answer tool by tool, a way to check whether a file is really transparent, and a Python fix that turns any AI-generated image into a true transparent PNG.

Want to test it on your own generated images? Try the Background Removal API on one of them.

Which AI Image Generators Support Transparency?

Based on each tool's official documentation, checked in October 2026:

Gemini / nano banana: no documented transparency option. You get a solid background, or a checkerboard drawn into the image.
OpenAI GPT Image API: yes, on supported models. Set background to transparent with PNG or WebP output.
Grok (xAI): no documented option. Treat every image as opaque.
Midjourney: no parameter for it in the full parameter list. Prompt a plain background and remove it afterwards.

On the Google AI developer forum, users asking how to get a transparent background with Nano Banana Pro describe the same result: the background is "only graphically represented as tiles", not see-through. Typing "transparent background" in the prompt makes it worse, because the model draws the checkerboard it has seen in thousands of screenshots.

The Fake Checkerboard Problem

A painted checkerboard looks right in the preview. The grey and white squares are regular pixels with full opacity, so they show up around your logo on a dark website header. Check a file before it reaches production:

from PIL import Image


def has_real_transparency(path: str) -> bool:
    im = Image.open(path)
    if im.mode not in ("RGBA", "LA", "PA") and "transparency" not in im.info:
        return False  # no alpha channel at all
    # at least one pixel must be less than fully opaque
    return im.convert("RGBA").getchannel("A").getextrema()[0] < 255


print(has_real_transparency("generated.png"))  # False for a painted checkerboard

On the cover image, the left half returns False (plain RGB). The right half returns True: the robot sits on a background that is half checkerboard, half blue, which only works when the pixels around it are truly empty.

The Fix: Plain Background, Then One API Call

Step 1: generate on a plain, contrasting background. Ask for "a plain solid orange background, no shadow, no floor". Avoid the word "transparent" in the prompt, it is what triggers the painted checkerboard.

Step 2: remove the background. Send the file to /remove-background. The response is JSON with a link to an RGBA PNG:

import requests

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

with open("robot.png", "rb") as f:
    r = requests.post(API_URL, headers=HEADERS, files={"image": f}, timeout=60)
r.raise_for_status()
data = r.json()
print(data["image_url"], data["width"], data["height"])

png = requests.get(data["image_url"], timeout=60).content
with open("robot-transparent.png", "wb") as f:
    f.write(png)

If your generator returns a URL, pass it directly with json={"image_url": "https://example.com/generated.png"} instead of uploading the file.

The test image is a 3D character render on a flat orange backdrop, the same kind of output an image generator returns. The cutout keeps the hands, the thin arm joints and the reflective visor. We also sent a recreated checkerboard version: the API removed the painted squares and returned a clean RGBA file.

See the full guide with the tool-by-tool table, cURL example and sources on ai-engine.net.

Batch Script for Stickers and Icons

AI-generated assets come in sets. This script converts a whole folder in parallel (PNG, JPEG and WebP in, transparent PNG out):

import requests
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor

API_URL = "https://background-removal-ai.p.rapidapi.com/remove-background"
HEADERS = {
    "x-rapidapi-host": "background-removal-ai.p.rapidapi.com",
    "x-rapidapi-key": "YOUR_API_KEY",
}
SRC = Path("generated")  # images exported from your AI generator
OUT = Path("transparent")
OUT.mkdir(exist_ok=True)


def make_transparent(path: Path) -> str:
    with open(path, "rb") as f:
        r = requests.post(API_URL, headers=HEADERS, files={"image": f}, timeout=60)
    r.raise_for_status()
    png = requests.get(r.json()["image_url"], timeout=60).content
    out = OUT / f"{path.stem}.png"
    out.write_bytes(png)
    return out.name


files = sorted(p for p in SRC.iterdir() if p.suffix.lower() in {".png", ".jpg", ".jpeg", ".webp"})
with ThreadPoolExecutor(max_workers=4) as pool:
    for name in pool.map(make_transparent, files):
        print("saved", name)

Chroma Key or an API?

If you control the prompt, you can generate on pure green and delete green pixels with a color mask. It is free, and it breaks on:

Green or yellow-green subjects (plants, mascots, neon logos)
Soft edges like hair, fur and smoke, which keep a green fringe
Reflections and glass that pick up the green cast
Images you did not generate: user uploads, painted checkerboards, old asset libraries

A segmentation-based API looks at the subject, not at a color, so one call handles all of these.

Tips for Clean Cutouts

Ask for contrast, not transparency. Dark subject on a light flat color, or the reverse.
Ban shadows and floors in the prompt. A soft drop shadow is part of the image.
Generate at full size. Upscale before the cutout, not after.
Need a brand color instead? The /color-background endpoint takes bg_color as "R,G,B,A" (for example "37,99,235,255") and returns the subject on your exact color.

Sources

OpenAI image generation guide: background option and PNG/WebP output
Google AI developer forum: "How can I make the background transparent?": Nano Banana Pro output shows tiles
xAI image generation guide: no transparency setting
Midjourney parameter list: no transparency parameter
Transparent PNG stickers with Nano Banana Pro: the chroma key approach

Ready to fix your generated assets? Get a key for the Background Removal API, point the batch script at your folder and run it. Read the full guide on ai-engine.net.

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 and a free tier to test.
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 markets identity verification (documents, selfie-to-ID, liveness); the classic gallery API docs remain on face.kairos.com, but sign-up asks for a business email and pricing goes through sales.
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.