DEV Community: Om Prakash

AI Background Removal API (Replace BG) - Snappy & Localized for E-Commerce

Om Prakash — Thu, 11 Jun 2026 07:14:03 +0000

Introduction

We are excited to share the release of the updated PixelAPI Background Removal (Replace BG) tool!

This tool is optimized for high-fidelity e-commerce product catalogs, social avatar creation, and automated bulk workflows.

Features

Blazing Fast Processing: Snappy UI transition times, with processing animations optimized to never exceed 1.0 second.
Perfect Color-Grading Preservation: Built with a localized soft-light blending model that keeps pure blacks and pure whites intact during variant autogeneration. No dirty clipping!
Bulk REST API: Process thousands of images in parallel with clean JSON schema responses.
Cross-Platform Access: Available on Lensora Mobile App, the PixelAPI Web UI, and the Bulk Developer API.

Video Walkthrough & Showreel

Watch the full walkthrough in high resolution (16:9, H.264/AAC, 1080p) showing the live Lensora application store search, Web UI upload, and Bulk API requests:

👉 Watch the Showreel Video

API Code Example

import requests

url = "https://api.pixelapi.dev/v1/background/replace"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
payload = {
    "images": ["https://pixelapi.dev/landing/product_shoe.png"],
    "background_prompt": "Minimalist white studio light background",
    "color_grading": "soft_light_blend"
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

HomeVision Studio — AI Interior Redesign for Any Room

Om Prakash — Thu, 11 Jun 2026 02:48:34 +0000

HomeVision Studio is live on PixelAPI — re-imagine any room in 10 seconds.

Snap a photo of your living room, bedroom, kitchen or bathroom, pick a style — modern Indian, Vastu-compliant, minimalist, Scandinavian, Bohemian, Kerala, Rajasthani luxury and more — and HomeVision Studio renders a photoreal redesign in about 10 seconds.

What's new

Free-form prompt: tell it exactly what you want changed or kept ("add a tall plant in the corner, keep the existing rug, warmer wall colors"). Moderated by gemma4 before reaching the model.
10 design styles · 6 room types
Photoreal output that preserves your room's geometry (walls, windows, ceiling)
2× cheaper than Decor8 AI / InteriorAI — pay per generation, no subscription wall
Built for homeowners, brokers, real-estate marketplaces and interior designers in India and worldwide

Three ways to use it

Web — drop a photo at pixelapi.dev/app/#homevision
Lensora Android app — install on Google Play
REST API for bulk — docs

Free credits on signup at pixelapi.dev.

remove.bg charges $0.105/image — here's a $0.009 alternative (2026 API comparison)

Om Prakash — Tue, 09 Jun 2026 12:17:13 +0000

If you're processing product images at scale, you've probably noticed that remove.bg charges $0.105 per image on their API. That's $105 for 1,000 images, $1,050 for 10,000 images.

For a small side project, that's fine. For an e-commerce team running thousands of product photos monthly, that cost compounds fast.

Here's a practical comparison of background removal APIs in 2026, including pricing and code examples.

Pricing comparison

Provider	Price per image	Notes
remove.bg	$0.105	Market leader, great quality
PhotoRoom	$0.020	Good for basic removal
Clipdrop	$0.070–0.090	Now owned by Jasper
PixelAPI	$0.009	23× cheaper than remove.bg

At 10,000 images/month:

remove.bg: $1,050
PixelAPI: $90

What is a Background Removal API?

A background removal API takes an image as input and returns the foreground subject as a transparent PNG. You POST an image, get back a cutout. That's it — no model training, no infrastructure, one HTTP call.

Most providers handle products, people, animals, and vehicles automatically using AI segmentation models.

Quick start with PixelAPI

cURL:

curl -X POST https://api.pixelapi.dev/v1/image/remove-background \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "image=@product.jpg"
# Returns: {"generation_id": "uuid", "status": "queued"}

# Poll until complete:
curl https://api.pixelapi.dev/v1/image/GENERATION_ID \
  -H "Authorization: Bearer YOUR_API_KEY"
# Returns: {"status": "completed", "output_url": "https://..."}

Python:

import requests

def remove_background(image_path, api_key):
    # Submit job
    with open(image_path, 'rb') as f:
        resp = requests.post(
            'https://api.pixelapi.dev/v1/image/remove-background',
            headers={'Authorization': f'Bearer {api_key}'},
            files={'image': f}
        )
    job_id = resp.json()['generation_id']

    # Poll for result
    import time
    while True:
        result = requests.get(
            f'https://api.pixelapi.dev/v1/image/{job_id}',
            headers={'Authorization': f'Bearer {api_key}'}
        ).json()
        if result['status'] == 'completed':
            return result['output_url']
        time.sleep(1)

url = remove_background('product.jpg', 'YOUR_KEY')
print(f'Transparent PNG: {url}')

When to use which API

Use remove.bg if:

You need the absolute best edge detection for complex hair/fur
Brand recognition matters for your use case
Processing under 100 images/month (cost difference is negligible)

Use PixelAPI if:

You're processing 1,000+ images/month (cost savings become significant)
You need multiple tools beyond background removal (they also do upscaling, face restore, object removal, virtual try-on)
You want to avoid dependency on a single-purpose tool

Output quality

PixelAPI uses BiRefNet for background removal — the same class of models used by premium providers. For standard product photography (objects on clean backgrounds), results are comparable. For complex hair and fine detail, test with your actual use case.

Get started

500 free credits at pixelapi.dev — enough to test with your real product images before committing to a plan. No credit card required.

Pricing figures sourced from each provider's published API pricing pages as of June 2026.

remove.bg charges $0.105/image — here's a $0.009 alternative (2026 comparison)

Om Prakash — Tue, 09 Jun 2026 12:12:34 +0000

The problem: background removal gets expensive fast

If you're building anything that touches product photos — an e-commerce catalog, a marketplace, a print-on-demand tool — you'll eventually need to strip backgrounds programmatically. One image is trivial. The bill arrives when you're doing 10,000 or 100,000 a month.

I call a lot of these APIs, so here's an honest 2026 comparison of the background-removal services I've actually integrated, with current public pricing.

Pricing (public list / volume pricing, June 2026)

API	Price per image	Free tier
remove.bg	~$0.105 (high volume) – $0.23 (standard)	50 preview-res calls/mo
Clipdrop	$0.07–0.09	limited
PhotoRoom	~$0.02	trial
PixelAPI	$0.009	500 credits, no card

Prices move around and vary by tier and commitment — check each vendor's page before you commit. But the spread is the point: at scale, the gap between $0.105 and $0.009 is real money.

Quick math for 50,000 images/month:

remove.bg @ $0.105 = $5,250
PhotoRoom @ $0.02 = $1,000
PixelAPI @ $0.009 = $450

Same transparent PNG out the other end.

The actual API call

Every one of these is a multipart POST. Here's PixelAPI with curl:

curl -X POST https://api.pixelapi.dev/v1/image/remove-background \
  -H "Authorization: Bearer YOUR_KEY" \
  -F "image=@product.jpg" \
  -o product-nobg.png

You get a transparent PNG back. No async polling, no job queue to babysit for a single image.

Python

In a real pipeline you're looping over a folder or a queue. Here's the requests version:

import requests

API_KEY = "YOUR_KEY"
URL = "https://api.pixelapi.dev/v1/image/remove-background"

def remove_bg(in_path, out_path):
    with open(in_path, "rb") as f:
        resp = requests.post(
            URL,
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"image": f},
            timeout=60,
        )
    resp.raise_for_status()
    with open(out_path, "wb") as out:
        out.write(resp.content)
    print(f"saved {out_path} ({len(resp.content)} bytes)")

remove_bg("product.jpg", "product-nobg.png")

Drop that into a ThreadPoolExecutor and you can churn through a catalog in parallel. Output is a transparent PNG, hair-level edges, typically under 3 seconds, up to 50MP source.

When to use which

I'm not going to pretend one API wins everything. Honest take:

remove.bg — the incumbent, very strong on hair, fur, and tricky edges. If quality on hard subjects is the only thing that matters and volume is low, it's a safe default. You pay for it.
Clipdrop — convenient if you're already in the Stability ecosystem and want cleanup/relight in the same place.
PhotoRoom — good middle ground, reasonable price, batch-friendly, strong on e-commerce product shots.
PixelAPI — cheapest by a wide margin, transparent PNG, up to 50MP, simple bearer-token REST. This is the one I reach for when the workload is high-volume product imagery and per-image cost dominates the decision.

The real decision usually isn't "best edges in the world" — it's "good enough edges at a price that survives 100k images a month." For most catalog and e-commerce work, the cheap option clears the quality bar fine.

Things that bite you in production (any provider)

A few hard-won notes that apply no matter which API you pick:

Resolution limits. Several APIs silently downscale above a cap, or charge more for full-res output (remove.bg's free tier only returns preview resolution). If you need print-quality output, confirm the max megapixels up front — PixelAPI handles up to 50MP.
Rate limits and concurrency. Batch jobs hammer the endpoint. Back off on HTTP 429s and cap your thread pool; don't fire 500 concurrent requests and assume it's fine.
PNG size. Transparent PNGs are big. If you're storing thousands, convert to WebP-with-alpha afterward — your object-storage bill will thank you.
Edge cases over averages. Test on your worst images, not your prettiest. Flyaway hair, transparent glass, white-on-white, motion blur. The average image looks fine on every provider; the price difference and the quality difference both show up in the tail.

Try it

PixelAPI gives you 500 free credits, no credit card, so you can run your own hardest images through it before believing any of my numbers:

Docs: https://pixelapi.dev/remove-background-api.html
Endpoint: POST https://api.pixelapi.dev/v1/image/remove-background

Grab a key, point the Python snippet above at your ugliest product photo — the one with flyaway hair on a busy background — and compare the PNG against whatever you're paying for now. That's the only benchmark that matters.

remove.bg charges $0.105/image — here's a $0.009 alternative (2026 comparison)

Om Prakash — Tue, 09 Jun 2026 12:03:06 +0000

If you remove image backgrounds at any real volume — product catalogs, user uploads, marketplace listings — the per-image price stops being a rounding error and starts being a line item. At 50,000 images a month the difference between $0.10 and $0.01 per image is the difference between a $5,000 bill and a $500 bill.

I've been benchmarking the background-removal APIs developers actually reach for. Here's where pricing lands in 2026.

Pricing (pay-as-you-go, per image)

API	Price / image	Free tier
remove.bg	~$0.105 (varies by volume; higher at low volume)	1 preview credit
Clipdrop	~$0.07–0.09	limited trial
PhotoRoom	~$0.02	trial
PixelAPI	$0.009	500 credits, no card

remove.bg is the quality benchmark most people know, but it's also the most expensive — roughly 12× the price of PixelAPI per image at comparable tiers. PhotoRoom is the closest on price and still a bit over 2× more. (Prices shift, so check each provider's current page before you commit — these are the numbers I saw while writing this.)

For the rest of this post I'll use PixelAPI for the examples because it's the cheapest and the API is dead simple, but the patterns map cleanly to the others — they're all "POST an image, get a transparent PNG back."

The 30-second curl test

curl -X POST https://api.pixelapi.dev/v1/image/remove-background \
  -H "Authorization: Bearer YOUR_KEY" \
  -F "image=@product.jpg" \
  --output cutout.png

You get back a transparent PNG. No async job to poll, no webhook to wire up for single images — the response is the file.

Doing it in Python

The realistic case isn't one image, it's a folder of them. Here's a batch loop with requests:

import requests
from pathlib import Path

API_KEY = "YOUR_KEY"
URL = "https://api.pixelapi.dev/v1/image/remove-background"

def remove_bg(src: Path, dst: Path):
    with src.open("rb") as f:
        r = requests.post(
            URL,
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"image": f},
            timeout=60,
        )
    r.raise_for_status()
    dst.write_bytes(r.content)
    print(f"{src.name} -> {dst.name} ({len(r.content)//1024} KB)")

src_dir = Path("products")
out_dir = Path("cutouts"); out_dir.mkdir(exist_ok=True)

for img in src_dir.glob("*.jpg"):
    remove_bg(img, out_dir / f"{img.stem}.png")

That's the whole integration. For thousands of images, wrap the call in a ThreadPoolExecutor (4–8 workers is plenty) and add a retry on 5xx. The endpoint handles images up to ~50MP, so you usually don't need to downscale first.

Which one should you actually use?

There's no single winner — it depends on what you're optimizing for:

Lowest cost at scale → PixelAPI ($0.009). If you're processing tens of thousands of images and the cutouts are "good enough out of the box," the math is hard to argue with.
Closest price-to-quality balance → PhotoRoom (~$0.02). Strong results, reasonable price, good if you also want their templating/scene features.
Maximum brand trust / established tooling → remove.bg. You pay a premium, but it's the name most stakeholders already recognize, and the edge quality on hair/fur is excellent.
Already in the Stability/Clipdrop ecosystem → Clipdrop, so you keep one vendor.

My honest take: pick based on a real test set, not a pricing table. Run 50 of your actual images through two or three of these and eyeball the hair edges, semi-transparent objects (glass, mesh), and busy backgrounds. Quality differences are smaller than they used to be; price differences are not.

What to check before you ship

Edge quality on your hardest cases (flyaway hair, fur, glass). This is where cheap APIs historically fell down — verify it on your images.
Latency — PixelAPI returns in under ~3 seconds for typical product shots; fine for batch, check it if you need it in a user-facing request path.
Output format — transparent PNG is standard; confirm it preserves the resolution you need.
Rate limits and concurrency on the plan you're buying.

Try it

PixelAPI gives you 500 credits free, no credit card — enough to run a real batch and judge the quality yourself before paying anyone.

Free key & docs: https://pixelapi.dev/remove-background-api.html
Endpoint: POST https://api.pixelapi.dev/v1/image/remove-background

Run your own images through it and compare. That's the only benchmark that matters.

I built an AI ad-creative API that keeps your exact product and uses real text — $0.01/ad

Om Prakash — Sun, 07 Jun 2026 05:45:20 +0000

Every store has the same gap. You have a clean product photo. What you need to run is an ad — that product in a scene that feels premium, with a headline, a CTA button, a brand name, maybe a "20% OFF" badge, sized for Instagram or a Google banner. Getting from one to the other normally means a designer, a Canva afternoon, or a $1–4-per-creative SaaS subscription.

I shipped an API that does it in one call for one cent.

The trade-off everyone else makes

There are two camps, and both are bad in different ways:

Pure text-to-image ("describe your ad"). Fast, but it redraws your product into something that's like your product — wrong logo, wrong shape — and the ad text comes out as melted nonsense, because diffusion models can't spell.
Traditional ad-creative SaaS. Gets the text right, but charges $1–4 per creative and still makes you art-direct every variation by hand.

The approach: compositing with a generative scene in the middle

Instead of asking one model to draw the whole ad, I treat it as a compositing problem:

Matte the product off its background (BiRefNet, commercial-safe).
Generate a scene around the product with SDXL inpainting — so the model adds contextual lighting and a real contact shadow. This is the anti-"floating product" lever.
Paste the exact product back on top, pixel-for-pixel. Your watch face, your logo, your stitching — untouched.
Render real typography — headline, sub-headline, CTA pill and badge as actual HTML/CSS text. Crisp, legible, editable. Never AI-garbled.

Two things are true at once: the product is pixel-exact, and the text is real. That combination is what makes the output something you can actually run.

Using it

curl -X POST https://api.pixelapi.dev/v1/image/ad-creative \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "product_image=@backpack.jpg" \
  -F "headline=CARRY MORE, EASIER" \
  -F "subheadline=Everyday backpack, built to last" \
  -F "cta=Get yours" -F "brand=NOMAD" -F "badge=20% OFF" \
  -F "ad_format=meta_1080x1080" -F "style=luxury"

You get a generation_id; poll GET /v1/image/{id} and the output_url appears ~20 seconds later. Formats: square, story (1080×1920), Google (1200×628), Flipkart and Meesho. No product image? Omit it and you get a typographic sale ad on a generated background.

Pricing

Tool	Price / ad	Real editable text
PixelAPI AI Ad Creative	$0.01	Yes
Google "Nano Banana" image	$0.039	No
Pebblely / Mokker	$0.02–0.30	No ad text
AdCreative.ai	$1–4	Yes

At one cent a call, generating a hundred ad variations for an A/B test costs a dollar — which is the only price at which this gets used in production instead of reserved for one hero asset.

Docs and a live demo: pixelapi.dev/ai-ad-creative-api.html

Edit a Whole Real-Estate Listing in One API Call

Om Prakash — Sat, 30 May 2026 13:55:11 +0000

Real-estate photos are a volume problem. A single listing is 20–40 photos. A busy agent or property photographer shoots several listings a week. Every one of those photos needs the same boring treatment: fix the white balance, lift the dark interiors, straighten the wide-angle tilt, and — for the exterior shots — turn that flat grey sky into something a buyer actually wants to click on.

Doing that one photo at a time in Lightroom or Photoshop is hours of work per listing. So we built an endpoint that takes the whole listing at once.

The idea: send a folder, get a folder back

PixelAPI's real-estate batch endpoint is deliberately simple. You zip up a folder of property photos, POST it in a single request, and the response is the processed zip. No job IDs, no polling loop, no webhooks to wire up. It's synchronous: you send 10–50 photos and the listing-ready versions come straight back.

Under the hood each photo gets a non-destructive pass:

Every photo: white balance, contrast, and a gentle colour boost — the whole scene is kept, nothing is cut out.
Exteriors only: the real sky is detected and replaced with a clean blue gradient, feathered at the rooflines so clouds and edges are preserved.
Safety: if no genuine sky is found, the photo is just enhanced — so an interior shot can never get accidentally painted blue.

The result: brighter, consistent, listing-ready photos for the entire property in seconds.

Call it from code

Here's the whole integration. Zip the folder, send it, unzip the response.

import io
import os
import zipfile
from pathlib import Path

import requests

API_KEY = os.environ["PIXELAPI_KEY"]
ENDPOINT = "https://api.pixelapi.dev/v1/real-estate/batch-process"

PRODUCTS = Path("products")
OUTPUT = Path("output")
OUTPUT.mkdir(exist_ok=True)

# 1. Bundle every property photo into one zip (in memory).
photos = sorted(
    p for p in PRODUCTS.iterdir()
    if p.suffix.lower() in {".jpg", ".jpeg", ".png"}
)
buf = io.BytesIO()
with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
    for photo in photos:
        zf.write(photo, arcname=photo.name)
buf.seek(0)

# 2. Send the whole batch in a single request.
resp = requests.post(
    ENDPOINT,
    headers={"Authorization": f"Bearer {API_KEY}"},
    files={"file": ("listing.zip", buf, "application/zip")},
    timeout=600,
)
resp.raise_for_status()

# 3. The response IS the processed zip — unzip it straight into output/.
with zipfile.ZipFile(io.BytesIO(resp.content)) as zf:
    for name in zf.namelist():
        (OUTPUT / Path(name).name).write_bytes(zf.read(name))

print(f"Done. {len(photos)} listing-ready photos in output/")

Prefer curl?

curl -X POST https://api.pixelapi.dev/v1/real-estate/batch-process \
  -H "Authorization: Bearer $PIXELAPI_KEY" \
  -F "file=@listing_raw.zip" \
  --output listing_ready.zip

That's the entire contract. One multipart POST with a zip of photos, one zip of processed photos back.

Don't want to write code?

There's a web tool too. Sign in, drag in a zip of property photos, and run a real batch against the same live API — the before/after results come straight back in the browser, and you can download the finished listing as a zip. Same engine, no integration required.

Who this is for

Real estate agents & brokerages — prep an entire MLS / Zillow / Rightmove listing in one upload.
Property photographers — post-process a full 30–40 frame shoot automatically and deliver the same day.
Short-term rental hosts — batch-clean every room into consistent, bright listing images.
Proptech & listing portals — auto-enhance every agent-uploaded photo at ingest, so listings look uniform across thousands of properties.

See it run end to end

We recorded a full walkthrough — real sign-in, a real zip upload, the live API call, the before/after results for every photo, and the same job driven from a Python script. No slides, no faked output.

▶️ Watch the tutorial: https://youtu.be/4lgKyCByMs8

Try it free

You get 100 free credits, no credit card to run your first listings.

Start here: https://pixelapi.dev
API reference: https://api.pixelapi.dev

If you batch-process property photos for a living, this is the boring-but-essential step you can stop doing by hand.

How to Remove Unwanted Objects from Photos with AI (Without the Photoshop Bill)

Om Prakash — Thu, 28 May 2026 22:50:34 +0000

How to Remove Unwanted Objects from Photos with AI (Without the Photoshop Bill)

Every photo has something in it that shouldn't be there.

A power cable across an otherwise clean product shot. A watermark from a stock photo you licensed but can't reshoot. Tourists in a venue photo. A logo on a garment that creates licensing complications. Price tags, stickers, sensor dust.

Photoshop's content-aware fill solves this brilliantly — but it costs $55/month, requires manual work per image, and doesn't batch. Here's the API equivalent.

LaMa: The Model Behind Serious Object Removal

LaMa (Large Mask) was developed at Samsung AI for exactly this problem — removing objects from photos while reconstructing the background convincingly. Unlike older inpainting approaches that tile neighboring pixels, LaMa uses Fourier convolutions to understand and regenerate large missing regions coherently.

It's particularly strong at:

Regular textures (wood grain, fabric, brick, grass)
Objects against simple or repetitive backgrounds
Watermark removal
Product cleanup

Basic Usage

import requests, base64

def remove_object(image_url: str, mask_url: str, api_key: str) -> str:
    """
    image_url: URL of the original image
    mask_url:  URL of a black/white mask (white = area to remove)
    Returns: URL of cleaned image
    """
    response = requests.post(
        "https://api.pixelapi.dev/v1/edit",
        headers={"Authorization": f"Bearer {api_key}"},
        json={
            "operation": "remove-object",
            "image_url": image_url,
            "mask_url": mask_url
        }
    )
    return response.json()["output_url"]

The mask is a simple black/white image the same dimensions as the original. White pixels = "remove this". Black pixels = "leave this alone".

Creating Masks Programmatically

For automated pipelines, generate masks with OpenCV:

import cv2, numpy as np

def create_simple_mask(image_path: str, x: int, y: int, w: int, h: int) -> str:
    """Create a rectangular mask over specified region."""
    img = cv2.imread(image_path)
    mask = np.zeros(img.shape[:2], dtype=np.uint8)  # Black canvas
    mask[y:y+h, x:x+w] = 255  # White rectangle = remove this
    mask_path = "/tmp/mask.png"
    cv2.imwrite(mask_path, mask)
    return mask_path

# Example: remove a 200x50px watermark from bottom-right corner
mask = create_simple_mask("product.jpg", x=800, y=950, w=200, h=50)

Real Pipeline: Watermark Removal at Scale

import requests
import boto3
from concurrent.futures import ThreadPoolExecutor

def process_image(s3_key: str, api_key: str, mask_url: str) -> dict:
    # Generate presigned URL for the image
    image_url = generate_presigned_url(s3_key)

    # Remove object
    clean_url = remove_object(image_url, mask_url, api_key)

    # Download and re-upload to permanent storage
    clean_bytes = requests.get(clean_url).content
    clean_key = s3_key.replace("raw/", "processed/")
    upload_to_s3(clean_bytes, clean_key)

    return {"original": s3_key, "processed": clean_key}

# Batch process with thread pool
with ThreadPoolExecutor(max_workers=5) as executor:
    results = list(executor.map(
        lambda key: process_image(key, API_KEY, WATERMARK_MASK_URL),
        s3_image_keys
    ))

When It Works Brilliantly vs When It Struggles

Works well:

Watermarks on textured backgrounds
Price tags, stickers, labels
Power cables and wires over complex backgrounds
Unwanted people in background of venue photos
Skin blemishes and temporary marks

More challenging:

Objects that occlude structural elements (a person standing in front of an architectural feature — the model must reconstruct what's behind them)
Very large masks (>30% of image area)
Objects at the intersection of multiple different materials

For difficult cases: use a slightly smaller mask than you think you need, and run multiple passes if needed.

Cost vs Alternatives

Cloud photo editing APIs with object removal:

Adobe Firefly API: enterprise pricing, waitlist
Cleanup.pictures: ~20 credits/image on their plan
Manual Fiverr edits: high per-image cost at any volume

PixelAPI: 20 credits/image. At Starter plan, that's 500 object removals from a single purchase.

Getting Started

pixelapi.dev — 100 free credits. That's 5 test removals to verify it handles your use case before committing.

API reference: api.pixelapi.dev/docs

LaMa inpainting runs on PixelAPI's dedicated RTX GPUs. Results available within 3-5 seconds for typical image sizes.

Color Grading at Scale: How I Stopped Wrestling with ImageMagick and Just Used an API

Om Prakash — Thu, 28 May 2026 05:41:41 +0000

I've been building a tool for a small e-commerce brand that sells handmade ceramics. Their problem: product photos come in from three different photographers with three completely different color treatments. One shoots warm and golden, one shoots cool and clinical, the other shoots whatever mood they're in that day. The brand's Instagram looks like a ransom note.

My first instinct was the classic developer move: shell out to ImageMagick, write a bunch of bash, tune some curves, hope for the best. Two weekends later I had something that worked fine for JPEGs shot in good light and completely fell apart on anything shot indoors or with shadows. Color correction is genuinely hard, and doing it consistently at scale is harder.

That's when I started looking at PixelAPI's Color Grade endpoint. Sub-3 second turnaround, REST interface, free tier to actually test with before committing. Let me walk through how it fits into the workflow I ended up with.

The Basic Flow

The Color Grade API takes an image URL and applies a grade to it. Here's the minimal version:

import httpx
import os

PIXELAPI_KEY = os.environ["PIXELAPI_KEY"]

def color_grade(image_url: str, style: str) -> str:
    response = httpx.post(
        "https://pixelapi.dev/api/color-grade",
        headers={"Authorization": f"Bearer {PIXELAPI_KEY}"},
        json={
            "image_url": image_url,
            "style": style,
        },
        timeout=30,
    )
    response.raise_for_status()
    return response.json()["output_url"]

graded = color_grade(
    "https://mybucket.s3.amazonaws.com/ceramics/bowl-001.jpg",
    "warm-natural"
)
print(graded)

That's it. No ImageMagick, no ffmpeg, no configuring LUT files, no fighting with color profiles. You get back a URL to the processed image.

Where It Gets Useful: Batch Processing

The ceramics client uploads photos via a simple Django admin. When a photo hits storage, I kick off processing in Celery. Here's a stripped-down version of that task:

from celery import shared_task
from .models import ProductPhoto
from .grading import color_grade

@shared_task(bind=True, max_retries=3)
def process_product_photo(self, photo_id: int):
    photo = ProductPhoto.objects.get(pk=photo_id)

    try:
        graded_url = color_grade(
            photo.original_url,
            style="warm-natural",
        )
        photo.graded_url = graded_url
        photo.graded = True
        photo.save(update_fields=["graded_url", "graded"])
    except Exception as exc:
        raise self.retry(exc=exc, countdown=10)

The latency being under 3 seconds is what makes this work in practice. It's fast enough that the task completes before any human would notice the photo isn't ready yet. If it were 15–20 seconds per image, I'd need a completely different UX pattern — show a spinner, poll for status, handle failures gracefully. At sub-3s it's just... done.

Beyond E-Commerce: A Few Other Scenarios

Content creator tools. I know a developer who built a small SaaS for newsletter writers — they upload photos, the tool applies a consistent warm treatment that matches their brand, and everything goes out looking cohesive. The API does the heavy lifting; the developer focused on the product.

Real estate listings. Photos from agents come in with wildly different white balance and exposure. Consistent color grading makes a portfolio of listings look like it was shot by the same team.

App with a photo editor. You don't have to build color grading into your frontend at all. User selects a style → you send the image URL to the API → you get back the result. No WebGL shaders, no client-side processing, no worrying about whether it works on the device in the user's pocket.

What Predictable Pricing Actually Means for a Project

I've been bitten before by APIs where costs scale weirdly — image processing in particular has historically been all over the place depending on resolution, output format, whether you're storing results. "Predictable pricing" on PixelAPI means I can actually scope the cost of a project before I sign a client. When someone asks "what's it going to cost to process our 8,000 product catalog?" I can give an honest answer.

The free tier (no card required) also means I can build a real proof of concept and show it to a client before asking them to commit to anything. That's a meaningful difference when you're a solo developer trying to close a project.

Gotchas Worth Knowing

The API expects a publicly accessible image URL. If your images are behind auth or in a private S3 bucket, you'll need to generate a presigned URL first. That adds a couple of lines but it's not a big deal:

import boto3

s3 = boto3.client("s3")

def presign(bucket: str, key: str, expires: int = 300) -> str:
    return s3.generate_presigned_url(
        "get_object",
        Params={"Bucket": bucket, "Key": key},
        ExpiresIn=expires,
    )

Also worth noting: the output URL you get back is hosted by PixelAPI. For production use you probably want to download that result and store it in your own bucket rather than serving the PixelAPI URL directly to end users.

The Honest Takeaway

Color grading sounds like a solved problem until you try to do it consistently at scale. Writing your own pipeline is a rabbit hole I've fallen into more than once. The REST API approach trades a small per-image cost for a huge amount of engineering time you don't have to spend. For most projects, that's the right trade.

The free tier at pixelapi.dev is a real free tier — you can do meaningful testing without a credit card. That's how I'd start: grab a key, run a few hundred test images through it, see if the output quality matches what your project needs. For the ceramics client it was immediately obvious it was going to work.

I'll write this blog post now.

Om Prakash — Wed, 27 May 2026 05:49:21 +0000

Cleaning Up Dirty Audio with a REST API: A Developer's Workflow

I record screencasts for documentation. My desk is next to a window, and anyone who has tried to record audio in a home office knows what that means: HVAC hum, keyboard clatter, occasional traffic rumble bleeding through the glass. For the longest time, my post-processing workflow was a mess — I'd export from my recording software, open a separate audio editor, apply a noise profile manually, re-export, and then bring the clean file back into my video editor.

It worked. It also took 15 minutes per video and required me to not forget any of the steps.

A few weeks ago I finally got fed up and looked for a way to automate it. I landed on PixelAPI's Audio Denoise endpoint and wired it into my processing script. It took about an hour from zero to working pipeline, and now the whole thing runs automatically when I drop a file into a folder.

Here's how I did it and what the code looks like.

The Setup

My recording pipeline is a Python script that already handled file organization and thumbnail generation. Adding audio denoising was a matter of adding one more step before the video got assembled.

PixelAPI exposes audio denoising as a plain REST endpoint — you POST a file, you get back a cleaned file. No SDK to install, no configuration wizard, no account dashboard you have to click through to find an API key. You sign up, grab a key, and you're making requests in minutes. They give you free credits to start without requiring a card, which meant I could test it against real recordings before committing to anything.

The Code

Here's the relevant chunk of my pipeline script:

import httpx
import os

PIXELAPI_KEY = os.environ["PIXELAPI_KEY"]

def denoise_audio(input_path: str, output_path: str) -> None:
    url = "https://pixelapi.dev/api/v1/audio/denoise"

    with open(input_path, "rb") as f:
        response = httpx.post(
            url,
            headers={"Authorization": f"Bearer {PIXELAPI_KEY}"},
            files={"audio": (os.path.basename(input_path), f, "audio/wav")},
            timeout=30.0,
        )

    response.raise_for_status()

    with open(output_path, "wb") as out:
        out.write(response.content)

    print(f"Denoised: {input_path} -> {output_path}")

That's the whole thing. I call this function in my pipeline right after the raw recording lands on disk, before anything else touches the file.

I'm using httpx here because I was already using it elsewhere in the project, but requests works fine too — it's a standard multipart POST.

Latency in Practice

The thing that surprised me most was the round-trip time. The docs say sub-3 second latency, and in my experience with typical screencast audio (5–15 minute WAV files) I've been seeing responses in the 1.5–2.5 second range. For an automated pipeline that's running in the background while I go do something else, that's completely fine.

If you're building something user-facing — say, a voice memo app or a podcast recording tool where the user is waiting on the result — that latency is fast enough to feel responsive without needing to architect around async polling. I briefly considered making the denoising step async anyway, but honestly for files under a few minutes the synchronous approach is fine and keeps the code simpler.

Where I Actually Use This

A few scenarios where this has saved me real time:

Screencasts and tutorials. My original use case. The HVAC hum is completely gone. I still try to record in reasonably quiet conditions, but I no longer lose takes because a truck rumbled by outside.

Interview recordings. I do occasional developer interviews for a side project. Remote audio quality varies wildly — some guests are on good setups, some are on laptop mics in live-in kitchens. Running the audio through denoising before editing means I spend less time in the editor compensating for bad source quality.

Podcast episode drafts. Before sending a rough cut to a guest for approval, running it through denoising removes distracting background noise without me having to do it manually per-clip.

Integrating It Into a Watch Script

Here's the folder-watcher version I actually run day-to-day. When a new WAV lands in my raw/ directory, it gets processed automatically:

import time
from pathlib import Path
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

class RecordingHandler(FileSystemEventHandler):
    def on_created(self, event):
        if event.is_directory:
            return
        path = Path(event.src_path)
        if path.suffix.lower() not in (".wav", ".mp3", ".m4a"):
            return

        output = path.parent.parent / "clean" / path.name
        print(f"Processing {path.name}...")
        denoise_audio(str(path), str(output))

if __name__ == "__main__":
    observer = Observer()
    observer.schedule(RecordingHandler(), path="./raw", recursive=False)
    observer.start()
    print("Watching ./raw for new recordings...")
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()

This runs as a background process. I record, save, and by the time I've opened my video editor the clean version is already sitting in ./clean/ waiting for me.

A Few Practical Notes

File formats. WAV, MP3, and M4A all work. I've mostly used WAV because my recording software exports that by default, but I tested M4A and it works fine.

Error handling. Add proper error handling before putting this anywhere near production. I keep the raw file around until I've verified the denoised version looks right — response.raise_for_status() catches HTTP errors, but you should also handle timeouts and log failures somewhere meaningful.

Batch processing. If you're processing a backlog, just loop over your files. The API handles it without issue; just be sensible about concurrency if you're parallelizing.

The predictable pricing was the other thing that sold me on this for a pipeline context. With usage-based APIs you occasionally get surprised by a bill because something ran more than expected. Having predictable costs per request makes it easy to reason about what the automation will actually cost as volume grows.

If you're dealing with any kind of audio in your app or workflow — recording tools, podcast platforms, transcription pipelines, voice interfaces — denoising at the API level rather than shipping DSP code yourself is a significant complexity reduction. The REST interface means you can add it in any language, any stack, in an afternoon.

How I Added AI-Generated Headshots to Our Onboarding Flow in an Afternoon

Om Prakash — Tue, 26 May 2026 05:56:52 +0000

Last month I was building out the user profile section of a SaaS app and ran into the most predictable problem: nobody uploads a decent profile photo. Half our users had the default avatar, a quarter had something blurry shot in bad lighting, and the rest had cropped group photos where you could still see a stranger's shoulder.

I'd seen AI headshot generators as standalone web apps before, but I needed something I could wire into our existing backend — not another product my users had to visit separately. I wanted it to feel like a native feature. That's when I started poking around PixelAPI's AI Headshot endpoint.

Here's what happened when I actually built it.

The actual use case

Our app is a professional directory — think a niche LinkedIn for a specific industry. Profile photos matter. A good headshot signals credibility. We already had an upload flow, but I wanted to add an optional "enhance my photo" step: user uploads a casual selfie, we return a polished headshot-style image.

The requirements I had in mind:

Accept a standard image upload from the frontend
Return a result fast enough to show inline (no long polling or async job status)
Be simple enough that one developer (me) could ship it without a dedicated ML infrastructure project

The sub-3 second latency claim caught my eye. That's synchronous-friendly. If the response comes back in under 3s, I can just await it in the same request handler without building a job queue.

What the integration looks like

The API is a straightforward REST call. You POST an image URL and get back a transformed image URL. Here's the Node.js version of what I ended up shipping:

async function generateHeadshot(sourceImageUrl) {
  const response = await fetch('https://pixelapi.dev/api/v1/ai-headshot', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.PIXELAPI_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      image_url: sourceImageUrl,
    }),
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Headshot generation failed: ${error.message}`);
  }

  const data = await response.json();
  return data.output_url;
}

// In your upload handler
app.post('/api/profile/enhance-photo', async (req, res) => {
  const { uploadedImageUrl } = req.body;

  try {
    const headshotUrl = await generateHeadshot(uploadedImageUrl);
    res.json({ headshotUrl });
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: 'Could not generate headshot' });
  }
});

That's genuinely the core of the integration. No SDK to install, no special client library, just fetch. The output URL comes back pointing to a hosted image, so I stored it in our user record the same way we store any uploaded photo URL.

What I got wrong the first time

I initially tried to pass a base64-encoded image directly in the request body instead of a URL. That didn't work — the API expects a publicly accessible URL. My fix was to upload the user's photo to our S3 bucket first, then pass the S3 URL to the headshot endpoint. Two-step, but not complicated.

One thing I'd do differently: I'd add a timeout wrapper around the fetch call. The API is fast, but network conditions vary and you don't want a slow response to hang your entire profile update endpoint.

async function generateHeadshotWithTimeout(sourceImageUrl, timeoutMs = 8000) {
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);

  try {
    const response = await fetch('https://pixelapi.dev/api/v1/ai-headshot', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.PIXELAPI_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ image_url: sourceImageUrl }),
      signal: controller.signal,
    });

    clearTimeout(timeoutId);

    if (!response.ok) throw new Error('API error');
    const data = await response.json();
    return data.output_url;
  } catch (err) {
    if (err.name === 'AbortError') throw new Error('Headshot generation timed out');
    throw err;
  }
}

Where else this makes sense

Since shipping this I've thought about a few other places this same endpoint would be useful:

E-commerce seller profiles. Marketplaces where individual sellers have storefronts could offer this as a premium feature — give your store a more professional look without requiring sellers to hire a photographer.

Internal HR tools. Employee directories with consistent, professional-looking headshots. If you're an HR platform and your users are uploading selfies from their phones, you could run those through the API on ingest and standardize the look.

Agency client portals. I talked to a friend who runs a small agency. They build websites for local businesses, and getting usable photos from clients is a constant headache. An automated headshot step in their content intake form would save them a lot of back-and-forth.

Ghost-writing or creator platforms. If you're building something where people have public author profiles, a headshot step in your onboarding reduces friction significantly. Users don't need to have a professional photo ready — they just need any photo.

The thing that actually surprised me

I expected to spend time fiddling with model parameters, aspect ratios, background styles — the usual knobs. There weren't many to fiddle with, which turned out to be a feature. The defaults produce consistent results without me having to tune anything. For a product integration (as opposed to a standalone creative tool), that consistency matters more than flexibility. Every headshot that comes out looks like it belongs in the same visual language.

No card required to get started, so I prototyped the whole thing before committing to anything. That's the right order of operations for evaluating any API you're considering dropping into a production flow.

If you're building anything where user photos matter, it's worth the afternoon to wire this up. The integration surface is minimal and the payoff — users who look like they're taking the product seriously — is real.

Turning Product Photos Into 3D Models With a REST API Call

Om Prakash — Mon, 25 May 2026 06:00:16 +0000

I've been building a small e-commerce side project for the last few months. Nothing fancy — a store that sells handmade ceramics. The owner kept asking me about 3D previews so customers could rotate items before buying. I knew what she wanted, but I also knew what it usually takes to get there: a 3D artist, a weeks-long asset pipeline, Blender exports, mesh cleanup. For a small shop selling mugs, that's a non-starter.

Then I started poking at PixelAPI's Image to 3D endpoint and built the whole thing in an afternoon.

What I Actually Needed

The requirement was simple in concept: take the product photos the shop owner already has (shot on a table with decent lighting), and let customers spin a 3D version of the item in the browser. The photos exist. The 3D model does not. The gap between those two things is where this API lives.

The Image to 3D endpoint takes a single image URL and returns a 3D model asset. No special camera rig, no multi-angle capture session, no photogrammetry pipeline. One image in, one model out, in under three seconds.

The Actual Integration

Here's a minimal Node.js example of how the call looks:

const fetch = require("node-fetch");

async function generateModel(imageUrl) {
  const response = await fetch("https://api.pixelapi.dev/v1/3d/image-to-3d", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.PIXELAPI_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      image_url: imageUrl,
      output_format: "glb",
    }),
  });

  if (!response.ok) {
    throw new Error(`API error: ${response.status}`);
  }

  const data = await response.json();
  return data.model_url;
}

// usage
generateModel("https://yourstore.com/products/mug-001.jpg")
  .then((url) => console.log("Model ready:", url))
  .catch(console.error);

That's the whole thing. The model_url in the response is a .glb file you can drop straight into a Three.js scene, a model-viewer web component, or whatever renderer you're already using on the frontend.

For the ceramics shop I used <model-viewer> from Google because it's zero-config and works on mobile:

<model-viewer
  src="https://cdn.yourstore.com/models/mug-001.glb"
  alt="Handmade ceramic mug"
  auto-rotate
  camera-controls
  style="width: 100%; height: 400px;"
></model-viewer>

The owner uploads a JPEG, my backend hits the API, stores the .glb in S3, and the product page shows a spinner for a couple of seconds before the model loads. That's the entire pipeline.

Where This Actually Works Well

I've been testing it across a few different use cases since the ceramics project.

Product thumbnails that become 3D previews. If you have existing product photography — and most e-commerce clients do — you can retroactively add 3D previews without a reshoot. The model quality depends heavily on the source photo: clean background, good lighting, and a clear silhouette produce noticeably better results than cluttered or dark shots. Worth mentioning to whoever is doing the photography.

Rapid prototyping for game assets. A friend who makes small browser games has been using it to sketch out prop assets. He drops in a sketch or a reference photo, gets a rough mesh back, then refines it in Blender. It's not replacing the modeling step — it's compressing the "what does this thing roughly look like in 3D" discovery phase from days to minutes.

Content creation pipelines. If you're building content tools for creators — say, a platform that lets influencers merchandise their own stuff — having 3D previews without a manual asset creation step is a real differentiator. A creator uploads a design, your platform generates a mock-up, and a 3D preview appears automatically.

A Few Things Worth Knowing Before You Build

The sub-3s latency is real but not uniform across all inputs. Simple, well-lit objects on clean backgrounds consistently come back fast. Complex scenes or images with lots of background noise take longer, and the model quality is lower. For a production workflow, I'd recommend a preprocessing step that crops and normalizes the image before sending it — it genuinely improves output.

You also want to think about how you handle the model lifecycle. If you're generating 3D models on demand, cache them. There's no reason to regenerate a model for the same product image twice, and it keeps your costs predictable as traffic grows.

The free tier includes 100 credits with no credit card required, which is enough to build out a full prototype and stress-test your integration before you commit to anything.

Why REST Matters Here

The thing that made this fit my workflow is that it's just an HTTP endpoint. I didn't install a new SDK, I didn't set up a Python environment for some ML-adjacent toolchain, I didn't learn a proprietary CLI. My existing infrastructure — Node backend, standard fetch calls, existing auth patterns — worked without modification.

For teams that are already building on REST APIs, this is the integration style that lets you ship in an afternoon rather than a sprint.

Where I'd Use This Again

Honestly, any project that involves physical objects and a web interface is worth evaluating. AR try-on for a fashion client, 3D visualization for a furniture catalog, asset previews in a design tool — any of these would benefit from automated 3D generation from existing photography.

The ceramics shop has had the feature live for about six weeks. The owner told me customers spend more time on product pages now. I have no idea if it's converting better — she doesn't track that closely — but she's happy, and the integration was genuinely low-effort.

If you want to try it yourself, grab your free credits at pixelapi.dev and run the snippet above against one of your own product images. The feedback loop is fast enough that you'll know within a few minutes whether it fits your use case.

DEV Community: Om Prakash

AI Background Removal API (Replace BG) - Snappy & Localized for E-Commerce

Introduction

Features

Video Walkthrough & Showreel

API Code Example

Links

HomeVision Studio — AI Interior Redesign for Any Room

What's new

Three ways to use it

remove.bg charges $0.105/image — here's a $0.009 alternative (2026 API comparison)

Pricing comparison

What is a Background Removal API?

Quick start with PixelAPI

When to use which API

Output quality

Get started

remove.bg charges $0.105/image — here's a $0.009 alternative (2026 comparison)

The problem: background removal gets expensive fast

Pricing (public list / volume pricing, June 2026)

The actual API call

Python

When to use which

Things that bite you in production (any provider)

Try it

remove.bg charges $0.105/image — here's a $0.009 alternative (2026 comparison)

Pricing (pay-as-you-go, per image)

The 30-second curl test

Doing it in Python

Which one should you actually use?

What to check before you ship

Try it

I built an AI ad-creative API that keeps your exact product and uses real text — $0.01/ad

The trade-off everyone else makes

The approach: compositing with a generative scene in the middle

Using it

Pricing

Edit a Whole Real-Estate Listing in One API Call

The idea: send a folder, get a folder back

Call it from code

Don't want to write code?

Who this is for

See it run end to end

Try it free

How to Remove Unwanted Objects from Photos with AI (Without the Photoshop Bill)

How to Remove Unwanted Objects from Photos with AI (Without the Photoshop Bill)

LaMa: The Model Behind Serious Object Removal

Basic Usage

Creating Masks Programmatically

Real Pipeline: Watermark Removal at Scale

When It Works Brilliantly vs When It Struggles

Cost vs Alternatives

Getting Started

Color Grading at Scale: How I Stopped Wrestling with ImageMagick and Just Used an API

The Basic Flow

Where It Gets Useful: Batch Processing

Beyond E-Commerce: A Few Other Scenarios

What Predictable Pricing Actually Means for a Project

Gotchas Worth Knowing

The Honest Takeaway

I'll write this blog post now.

The Setup

The Code

Latency in Practice

Where I Actually Use This

Integrating It Into a Watch Script

A Few Practical Notes

How I Added AI-Generated Headshots to Our Onboarding Flow in an Afternoon

The actual use case

What the integration looks like

What I got wrong the first time

Where else this makes sense

The thing that actually surprised me

Turning Product Photos Into 3D Models With a REST API Call

What I Actually Needed

The Actual Integration

Where This Actually Works Well

A Few Things Worth Knowing Before You Build

Why REST Matters Here

Where I'd Use This Again