A production REST API for AI image upscaling — the developer-grade topaz gigapixel alternative free of a desktop license. One HTTP call upscales any photo or product image 2–16× with detail recovery, sharp edges, and clean output. $0.009 per image — significantly lower-priced than Topaz Gigapixel, Vance.ai, Let's Enhance, and Upscale.media. 5,000 free credits (24-hour trial), no credit card.
Sign up, copy your key from the dashboard, and POST your image. The endpoint returns a generation id; poll until status=completed, then download the upscaled PNG from output_url.
curl -X POST https://api.pixelapi.dev/v1/image/upscale \
-H "Authorization: Bearer YOUR_API_KEY" \
-F "image=@photo.jpg" \
-F "scale=4"
# Response: {"id": "uuid", "status": "queued", "credits_used": 9}
# Poll until completed
curl https://api.pixelapi.dev/v1/image/UUID \
-H "Authorization: Bearer YOUR_API_KEY"
# Response: {"generation_id": "uuid", "status": "completed", "output_url": "https://..."}
pip install pixelapi
---
from pixelapi import PixelAPI
client = PixelAPI(api_key="YOUR_API_KEY")
result = client.upscale(image="photo.jpg", scale=4)
result.save("photo_4x.png") # upscaled PNG
npm install pixelapi
---
import { PixelAPI } from "pixelapi";
const client = new PixelAPI({ apiKey: process.env.PIXELAPI_KEY });
const result = await client.upscale({ image: "./photo.jpg", scale: 4 });
await result.save("photo_4x.png"); // upscaled PNG
composer require pixelapi/pixelapi
---
<?php
use PixelAPI\Client;
$client = new Client(getenv("PIXELAPI_KEY"));
$result = $client->upscale(["image" => "photo.jpg", "scale" => 4]);
file_put_contents("photo_4x.png", $result->getBody());
gem install pixelapi
---
require "pixelapi"
client = PixelAPI::Client.new(api_key: ENV["PIXELAPI_KEY"])
result = client.upscale(image: "photo.jpg", scale: 4)
File.binwrite("photo_4x.png", result.body)
go get github.com/pixelapi/pixelapi-go
---
import "github.com/pixelapi/pixelapi-go"
client := pixelapi.New("YOUR_API_KEY")
result, err := client.Upscale("photo.jpg", 4)
if err != nil { panic(err) }
result.Save("photo_4x.png")
| Parameter | Type | Default | Description |
|---|---|---|---|
image | file upload | — | JPEG / PNG / WebP, max 20 MB. Use this or image_url. |
image_url | string | — | Publicly accessible URL to fetch the source image from. |
scale | integer 2–16 | 4 | Upscale factor. 2–4 = single AI pass. 5–16 = two-pass for large-format output. |
target_width | integer 64–16384 | — | Optional exact output width in pixels. Must be paired with target_height. |
target_height | integer 64–16384 | — | Optional exact output height in pixels. Must be paired with target_width. |
fit_mode | string | stretch | stretch (exact size), pad_white (preserve aspect, white border), pad_transparent (preserve aspect, transparent canvas). |
| Provider | Free tier | Per-image cost | API / REST | Max scale |
|---|---|---|---|---|
| PixelAPI | 5,000 credits (24-hr trial), no card | $0.009 | ✓ REST API | 16× |
| Topaz Gigapixel | None | $0.08–$0.12/image (native API) | Native API + Replicate | 4× |
| Vance.ai | Limited trial credits | ~$0.058/image (4×, Studio annual) | API in paid plans | 8× |
| Let's Enhance | None | ~$0.068/image (Max plan) | Business API tier | 16× |
| Upscale.media | Limited | ~$0.076/image (Pro plan) | API in paid plans | 4× |
Pricing verified from each rival's public pricing page, October 2026: developer.topazlabs.com, vanceai.com/pricing, letsenhance.io/pricing, upscale.media/pricing. PixelAPI price based on canonical billing (9 credits × $0.001/credit).
Default output is a full-quality PNG at the requested scale. A 1000×750px JPEG in becomes a 4000×3000px PNG at scale=4. Transparency in the source is preserved.
Need exactly 3000×2000px for a print spec? Pass target_width=3000&target_height=2000. The API upscales then resizes to your exact dimensions.
Preserve aspect ratio and pad to exact dimensions with a transparent PNG canvas. Ideal for product images that must fit a standard slot without distortion.
Same as pad_transparent but with a white background — marketplace-ready for Amazon, Shopify, and studio-white catalogue specs.
Two-pass upscaling at scale 5–16 produces 10,000px+ output from standard-res inputs — suitable for wide-format printing, signage, and fine art.
Submit via multipart file upload or pass an image_url. Both inputs accept JPEG, PNG, and WebP up to 20 MB.
The Image Upscaler API covers these production workflows. Each links to a related guide:
Full API reference, parameters, and output format details for the upscale endpoint.
Comparison of ESRGAN-based upscaling APIs. PixelAPI vs alternatives for different use cases.
Real developer workflows and scripts for replacing Topaz Gigapixel in automated pipelines.
How PixelAPI compares to running Real-ESRGAN locally vs a managed API.
Endpoint reference, authentication, and error code guide for the upscale endpoint.
Side-by-side feature and pricing comparison against Topaz Gigapixel AI.
The Image Upscaler API integrates with popular platforms via the PixelAPI SDK and webhook events:
Auto-upscale product images on upload. Webhook-triggered, runs in the background.
No-code upscale trigger. Connect to any Zap in two clicks.
Drag-and-drop upscale step in Make scenarios. Works with Google Drive, Dropbox, and more.
CMS image upscaling for editorial and product pages in Webflow collections.
Catalog automation with the BC product API. Hi-res variants on demand.
Adobe Commerce / Magento 2 plugin pattern for batch product image upscaling.
Topaz is a desktop app — no production REST API. PixelAPI gives Topaz-class AI quality over HTTP at $0.009/image with no desktop install or subscription.
Vance.ai requires an annual subscription and costs ~$0.058/image at 4×. PixelAPI is pay-as-you-go at $0.009/image with a free trial, no commitment.
Let's Enhance costs ~$0.068/image. Business API tier requires contacting sales. PixelAPI has public pricing and a free trial you can start in 60 seconds.
Upscale.media costs ~$0.076/image on the Pro plan. PixelAPI is 8× cheaper at $0.009 with more scale options (up to 16×) and custom dimension support.
BigJPG is a consumer web tool without a developer-grade REST API. PixelAPI provides production SLA, API key auth, async job queue, and volume pricing.
Claid.ai bundles upscaling with image editing. If you only need upscaling, PixelAPI is a focused, lower-cost option with transparent per-image pricing.
20 requests/minute on the free trial, 60 on Starter, 120 on Pro, and 300 on Scale — with 3/10/20/50 concurrent jobs respectively. Exceeding the limit returns HTTP 429 with a Retry-After header. For large batch workloads, use the concurrent jobs cap to parallelize throughput rather than hammering rate limits.
# Python SDK auto-retries 429 with exponential backoff
from pixelapi import PixelAPI
client = PixelAPI(api_key="...", max_retries=4)
result = client.upscale(image="photo.jpg", scale=4) # auto-retries on 429
# Batch: submit N jobs, collect results
import asyncio
from pixelapi.async_client import AsyncPixelAPI
async def batch_upscale(paths):
client = AsyncPixelAPI(api_key="...")
jobs = await asyncio.gather(*[client.upscale(image=p, scale=4) for p in paths])
return jobs
Common error codes: 400 invalid parameters or unsupported file, 402 insufficient credits, 413 image exceeds 20 MB, 429 rate limit hit. All errors return JSON with a detail field. Credits are never charged for jobs that fail input validation or produce blank output — failures trigger an automatic refund.
PixelAPI's Image Upscaler API. It upscales images 2–16× at $0.009 per image, with 5,000 free credits (24-hour trial) and no credit card required. Topaz Gigapixel is a desktop application and does not offer a production REST API — making PixelAPI the direct API-first alternative for developers and production pipelines.
POST your image to https://api.pixelapi.dev/v1/image/upscale with your API key and scale=4 (or any integer 2–16). The endpoint returns a generation id. Poll GET /v1/image/{id} until status=completed, then download the full-resolution PNG from output_url. See the Quick Start section above for code in 6 languages.
$0.009 per image (9 credits × $0.001/credit). New accounts receive 5,000 free credits (24-hour trial) with no credit card required — roughly 555 upscales to test on real data. There is no subscription required for pay-as-you-go usage.
The scale parameter accepts any integer from 2 to 16. Scales 2–4 run a single AI upscaling pass; scales 5–16 run two AI passes for extreme output sizes. A 1254px source image at scale 8 becomes approximately 10,000px — suitable for large-format print and high-resolution stock photo submissions.
Yes. New accounts get 5,000 free credits (24-hour trial) with no credit card required. At 9 credits per upscale, that covers approximately 555 image upscales — plenty to test on real catalogue data, bulk workflows, or any mix of PixelAPI's other tools in the same trial window.
PixelAPI uses Real-ESRGAN AI upscaling — the same class of model behind Topaz Gigapixel and similar professional tools. Detail recovery, edge sharpening, and noise reduction happen in one AI pass. Fine text, hair, fabric texture, and product edge sharpness are handled cleanly at all scale factors from 2× through 16×.
JPEG, PNG, and WebP, up to 20 MB per file. Submit via multipart file upload (image field) or by passing an image_url pointing to a publicly accessible URL. Both paths support all three formats.
Yes. Pass target_width and target_height (both required together, 64–16384px each) to request an exact output size. Combine with fit_mode: stretch for exact dimensions, pad_white to preserve aspect ratio with a white border, or pad_transparent for a transparent PNG canvas at exact dimensions.
PNG. Opaque RGB inputs return RGB PNG. Transparent RGBA inputs preserve the alpha channel. Use fit_mode=pad_transparent to explicitly request a transparent-padded canvas when using custom dimensions.
Yes — pip install pixelapi. Official SDKs are also available for Node.js (npm install pixelapi), PHP (Composer), Ruby (Gem), and Go (go get github.com/pixelapi/pixelapi-go). All SDKs handle authentication, async job polling, retry-on-429 with backoff, and binary file saving automatically.
20 requests/minute on the free trial, 60 on Starter, 120 on Pro, and 300 on Scale — with 3/10/20/50 concurrent jobs respectively. Exceeding the limit returns HTTP 429 with a Retry-After header. The Python and Node SDKs handle retry-with-backoff automatically. Higher limits for large batch workloads: email support@pixelapi.dev.
Yes. Scale 8–16 produces print-ready output from web-resolution sources. A 1500×1000px source becomes ~12,000×8,000px at 8× — suitable for wide-format signage, fine art prints, and stock library submissions requiring 50+ MP files. Credits are charged per image regardless of scale factor.