A production REST API for AI-powered image inpainting and object removal. One HTTP call removes any unwanted element — watermarks, logos, people, power lines, shadows, or price tags — and fills the gap with coherent background content. This is the open source inpaint API approach made available as a managed endpoint: all the quality, zero infrastructure. $0.005 per call — half the price of alternatives. 500 free credits, no credit card.
Sign up, copy your key from the dashboard, and POST your image. Optionally pass a mask (bounding box or binary mask image) or a text prompt describing what to erase. Poll until status=completed, then download the clean image.
curl -X POST https://api.pixelapi.dev/v1/image/remove-object \ -H "Authorization: Bearer YOUR_API_KEY" \ -F "[email protected]" \ -F "prompt=watermark in bottom-right corner" # Response: {"generation_id": "uuid", "status": "queued"} # Poll until completed curl https://api.pixelapi.dev/v1/image/UUID \ -H "Authorization: Bearer YOUR_API_KEY" # Response: {"status": "completed", "output_url": "https://..."}
pip install pixelapi
---
from pixelapi import PixelAPI
client = PixelAPI(api_key="YOUR_API_KEY")
result = client.remove_object(
image="product.jpg",
prompt="remove the watermark in the bottom-right corner"
)
result.save("product_clean.jpg")
npm install pixelapi
---
import { PixelAPI } from "pixelapi";
const client = new PixelAPI({ apiKey: process.env.PIXELAPI_KEY });
const result = await client.removeObject({
image: "./product.jpg",
prompt: "remove the watermark in the bottom-right corner",
});
await result.save("product_clean.jpg");
composer require pixelapi/pixelapi
---
<?php
use PixelAPI\Client;
$client = new Client(getenv("PIXELAPI_KEY"));
$result = $client->removeObject([
"image" => "product.jpg",
"prompt" => "remove the watermark in the bottom-right corner",
]);
file_put_contents("product_clean.jpg", $result->getBody());
gem install pixelapi
---
require "pixelapi"
client = PixelAPI::Client.new(api_key: ENV["PIXELAPI_KEY"])
result = client.remove_object(
image: "product.jpg",
prompt: "remove the watermark in the bottom-right corner"
)
File.binwrite("product_clean.jpg", result.body)
go get github.com/pixelapi/pixelapi-go
---
import "github.com/pixelapi/pixelapi-go"
client := pixelapi.New("YOUR_API_KEY")
result, err := client.RemoveObject(pixelapi.RemoveObjectParams{
Image: "product.jpg",
Prompt: "remove the watermark in the bottom-right corner",
})
if err != nil { panic(err) }
result.Save("product_clean.jpg")
PixelAPI's per-call price is set at exactly half the cheapest publicly-verified rival per-image rate, per our standing pricing principle.
| Provider | Free tier | Per-image cost | API access |
|---|---|---|---|
| PixelAPI | 500 credits, no card | $0.005 | REST + 6 SDKs |
| watermarkremover.io | limited | $0.01 (best tier) | REST |
| cleanup.pictures | yes | see cleanup.pictures/pricing | REST (custom quote) |
| snapedit | 10 credits/mo | see snapedit.app/api-pricing | REST |
| Picsart Inpaint API | limited trial | enterprise quote | REST (enterprise) |
Pricing verified from each rival's public pricing page, May 2026. PixelAPI's per-call price is set at exactly half the cheapest verifiable rival per-unit cost.
The erased region is filled with coherent background — textures, lighting, and perspective matched to the surrounding content. No visible seams or halos.
Input JPEG → output JPEG. Input PNG → output PNG. Override with output_format=webp for smaller file sizes on web delivery.
Images are processed at native resolution up to 50 megapixels. Hi-res real estate and e-commerce photos are handled without quality loss.
Pass a text prompt, a bounding-box (x, y, w, h), or a binary mask image. Mix and match for precise control over what gets removed.
The Inpaint / Object Removal API is the backbone of these production workflows. Each links to a setup guide:
Strip watermarks and logos from supplier images before uploading to your storefront. Runs in bulk via webhook.
Remove power lines, parked cars, and temporary signage from property listings at scale.
Automate blemish, sticker, and timestamp removal from batch RAW exports.
Clean up UGC images before publishing. Remove competing brand logos from influencer content.
Erase reflections, cords, and staging props from product photography.
Remove price tags, shelf labels, and competing products from packshot images.
Repurpose licensed stock photos by removing watermarks and unwanted elements.
Clean dealer-lot backgrounds: remove cones, banners, and other vehicles from car photos.
Erase hangers, pins, and garment tags from flat-lay and on-model images.
More use-case guides: all industries →
Auto-clean product images on upload via Shopify webhook + PixelAPI.
No-code object removal triggered from any Zapier-connected app.
Drag-and-drop inpaint step inside Make scenarios.
CMS-driven watermark removal for Webflow product pages.
Bulk-clean supplier catalog images before WooCommerce import.
Automate object removal in the BigCommerce product API pipeline.
PixelAPI publishes transparent pay-as-you-go pricing at $0.005/call. cleanup.pictures requires a custom API quote.
REST API with 6 SDKs vs a browser-only tool. No manual brush strokes — automate at scale.
No Creative Cloud subscription required. Per-call billing with no monthly minimum.
Simple REST endpoint vs SDK-only integration. Lower per-image cost with transparent pricing.
Default 60 requests/minute on the free tier, 600 on paid tiers. Exceeding the limit returns HTTP 429 with a Retry-After header. Recommended: exponential backoff starting at 2s, doubling on each retry up to 30s. The Python and Node SDKs handle this automatically.
# Python SDK auto-retries 429 with backoff
from pixelapi import PixelAPI
client = PixelAPI(api_key="...", max_retries=4)
result = client.remove_object(
image="bulk.jpg",
prompt="remove the watermark"
) # auto-retries on 429
Common error codes:
| HTTP code | Meaning | Action |
|---|---|---|
| 400 | Bad request (unsupported format, missing image) | Check request parameters |
| 401 | Invalid or missing API key | Verify Authorization: Bearer header |
| 402 | Insufficient credits | Top up at /pricing |
| 429 | Rate limit exceeded | Backoff and retry per Retry-After header |
| 500 | Processing error | Credits auto-refunded; retry |
An inpaint API lets you remove or replace arbitrary regions of an image via an HTTP call — no desktop app, no manual brush strokes. You mark what to erase (by sending a mask or a text prompt), and the API fills the gap with coherent background content. PixelAPI's inpaint endpoint is POST /v1/image/remove-object at $0.005 per call.
$0.005 per call — exactly half the price of watermarkremover.io's best published per-image rate ($0.01). New accounts get 500 free credits with no credit card required, enough to erase objects from 100 images before paying a cent.
POST your image (and an optional mask or prompt) to https://api.pixelapi.dev/v1/image/remove-object with your API key in the Authorization: Bearer header. The endpoint returns a generation_id; poll GET /v1/image/{id} until status=completed, then download from output_url. See the Quick Start section above for code in 6 languages.
Anything: watermarks, logos, price tags, people, power lines, furniture, shadows, timestamps, skin blemishes, stickers, and any other unwanted object. You can target by bounding-box mask or by passing a text description of what to erase — no image-editing software required.
JPEG by default (original format preserved). You can also request PNG or WebP via the output_format parameter. The inpainted region is blended seamlessly into the original — no alpha-channel cutout, just a clean image with the object gone.
Most removals complete in 3–8 seconds depending on image resolution and object complexity. Capacity is kept warm so there are no cold-start penalties — the first request is as fast as the thousandth. Bulk concurrent requests are processed in parallel.
Yes — pip install pixelapi. SDKs are also available for Node.js (npm install pixelapi), PHP (Composer), Ruby (Gem), Go (go get github.com/pixelapi/pixelapi-go), and a Java/Kotlin client. All SDKs handle authentication, polling, retry-on-429, and binary file return automatically.
Default 60 requests/minute on the free tier, 600 requests/minute on paid tiers. Exceeding the limit returns HTTP 429 with a Retry-After header. The Python and Node SDKs retry automatically with exponential backoff. Higher limits for batch pipelines — email [email protected].
Yes. Pass the watermark region as a bounding-box mask (x, y, width, height) or describe it in the prompt field ("remove watermark in bottom-right corner"). The API fills the region with coherent background content. Works on text watermarks, logo overlays, and semi-transparent stamps.
cleanup.pictures does not publish API pricing publicly — contact their sales team for a quote. PixelAPI charges $0.005/call with transparent pay-as-you-go billing, 500 free credits, no minimum commitment, and 6 official SDKs.
Yes — projects like AI object removal and IOPaint can be production-ready. The trade-off is provisioning inference servers, managing queues, and ongoing maintenance. PixelAPI delivers the same image-quality results via a single HTTP call at $0.005 with no infrastructure to operate.
Failed or corrupted jobs are caught by an output-quality QC layer. Credits are auto-refunded — you never pay for a broken result. Retrying the same request is always safe, and the Python/Node SDKs will retry automatically on 500 errors.