The leading topaz gigapixel open source alternative for developers. PixelAPI wraps Real-ESRGAN — the same open-source model that powers the best upscalers — in a production REST API with one HTTP call. Topaz Gigapixel is a proprietary desktop app at $149/year with no public API. PixelAPI is $0.01 per image, works server-side from any language, and ships 500 free credits with no credit card required.
Topaz Gigapixel AI is a high-quality desktop application — but it has no public API. You cannot call it from a server, embed it in a pipeline, or process images programmatically without screen-automation hacks. PixelAPI solves that by exposing the same open-source upscaling model (Real-ESRGAN) as a clean REST endpoint you can call from any language or CI pipeline.
Topaz Gigapixel requires a $149/year subscription and a Windows or Mac machine. PixelAPI is an HTTPS endpoint — call it from a Lambda, a GitHub Action, a Docker container, or a Raspberry Pi.
$0.01 per upscale. Process 10 images this month, pay $0.10. Process 100,000, pay $1,000. No annual commitment, no seat count, no overage surprises. Free trial: 500 images, no card.
Real-ESRGAN is the state-of-the-art open-source super-resolution model. It handles photos, illustrations, and compressed images equally well — the same model powering many open-source upscaling tools, now available as a managed API.
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 "[email protected]" \ -F "scale=4" # Response: {"id": "uuid", "status": "queued", "credits_used": 10} # Poll until completed curl https://api.pixelapi.dev/v1/image/upscale/UUID \ -H "Authorization: Bearer YOUR_API_KEY" # Response: {"generation_id": "uuid", "status": "completed", "output_url": "https://..."}
pip install pixelapi
---
import time
from pixelapi import PixelAPI
client = PixelAPI(api_key="YOUR_API_KEY")
result = client.upscale(image="photo.jpg", scale=4)
while result.status != "completed":
time.sleep(2)
result = result.refresh()
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", pixelapi.UpscaleOpts{Scale: 4})
if err != nil { panic(err) }
result.Save("photo_4x.png")
| Provider | Free tier | Per-image cost | API available | Model |
|---|---|---|---|---|
| PixelAPI | 500 credits, no card | $0.010 | ✓ REST + SDKs | Real-ESRGAN (open source) |
| Topaz Gigapixel AI | No free tier | $149/year subscription | ✗ Desktop app only | Proprietary |
| Let's Enhance | Limited credits | See letsenhance.io/pricing | ✓ (via Claid.ai API) | Proprietary |
| Vance.ai | — | See unifab.ai (rebranded) | — (rebranded to video tool) | Proprietary |
| Upscale.media | Limited credits | See upscale.media/pricing (INR-based) | ✓ Web app + API | Proprietary |
Topaz Gigapixel pricing verified from topazlabs.com/pricing May 2026. Other rival pricing is subscription or credit-based with opaque per-image costs — see each provider's pricing page for current rates. PixelAPI's per-image price is set at exactly half the cheapest comparable REST API rate per our pricing principle.
The default output is a PNG at the requested scale. Pass scale=2, scale=3, or scale=4. Most use cases want 4× — it's the default.
Pass target_width and target_height (64–8192 px) to get output at a precise canvas size. Use with fit_mode=stretch for exact resize, pad_white for aspect-preserving white pad, or pad_transparent for transparent PNG pad.
POST a file via multipart ([email protected]) or pass a public URL via image_url=https://… for server-to-server pipelines where you already have an image URL.
The API accepts JPEG, PNG, and WebP, up to 20 MB per image. Output is always PNG for maximum fidelity at the enlarged resolution.
| Parameter | Type | Default | Notes |
|---|---|---|---|
image | file | — | Multipart file upload (JPEG/PNG/WebP, max 20 MB). One of image or image_url required. |
image_url | string | — | Publicly accessible URL to fetch. Alternative to file upload. |
scale | int | 4 | Upscale factor: 2, 3, or 4. |
target_width | int | — | Exact output width in pixels (64–8192). Set with target_height for custom canvas. |
target_height | int | — | Exact output height in pixels (64–8192). Set with target_width for custom canvas. |
fit_mode | string | stretch | stretch · pad_white · pad_transparent. Controls how aspect ratio is handled when custom dims differ from input. |
The Image Upscaler API is the foundation for these production workflows. Each links to a setup guide:
Upscale stock art or customer photos to 300 DPI print-ready dimensions without visible artifacts.
Bulk-upscale supplier product images to marketplace hi-res requirements in one automated pipeline.
Recover detail in compressed or low-res client shoots before delivery.
Upscale phone-camera listing photos to high-res before publishing.
Enlarge product shots for zoom-on-hover features and lookbook pages.
Upscale manufacturer product photos for hi-res detail pages.
Meet Amazon, Etsy, and eBay hi-res image requirements automatically.
Museum-quality macro upscaling for engravings, dials, and surface textures.
Rescale legacy square posts to landscape or portrait without visible pixel stretching.
More use-case guides: all industries →
Upscale product images on upload via webhook — no manual step for your team.
No-code upscaling trigger — connects to Google Drive, Dropbox, Airtable.
Drag-and-drop upscale node in Make scenarios for any image workflow.
CMS asset auto-upscale for hi-res product detail pages.
Catalog automation — upscale all new product images on import.
Adobe Commerce / Magento 2 plugin pattern for automated upscaling.
Topaz is a desktop app at $149/year — no API, no automation. PixelAPI is a REST endpoint at $0.01/image with no desktop software required.
Both offer API access. PixelAPI's pricing is transparent and per-image; Let's Enhance charges by subscription credit bundle.
Vance.ai has rebranded to Unifab.ai and shifted focus to video desktop software. PixelAPI remains focused on image API.
Upscale.media uses INR-based credit bundles. PixelAPI offers USD-transparent per-image pricing with no subscription lock-in.
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. Recommended: exponential backoff starting at 2 s, doubling on each retry up to 30 s. The Python and Node SDKs handle retries automatically.
# Python SDK auto-retries 429 with backoff from pixelapi import PixelAPI client = PixelAPI(api_key="...", max_retries=4) result = client.upscale(image="bulk_photo.jpg", scale=4) # auto-retries on 429
Credits are deducted on job submission. If the job fails for any reason, credits are auto-refunded — you never pay for a broken result. Failed jobs return status=failed with an error_message. Common errors:
| HTTP code | Meaning | Action |
|---|---|---|
400 | Invalid params or image too large (>20 MB) | Fix params and retry |
401 | Missing or invalid API key | Check Authorization header |
402 | Insufficient credits | Top up at /pricing |
429 | Rate limit hit | Retry after Retry-After seconds |
503 | Queue full (transient) | Retry in a few seconds — credits not charged |
Yes. PixelAPI's upscaling is powered by Real-ESRGAN, the leading open-source super-resolution model. Topaz Gigapixel uses a proprietary model and charges $149/year for a desktop-only application with no public API. PixelAPI wraps Real-ESRGAN in a production REST API at $0.01 per image, with 500 free credits and no credit card required to start.
POST your image to https://api.pixelapi.dev/v1/image/upscale with your API key. The endpoint returns a generation id; poll GET /v1/image/upscale/{id} until status=completed and download the upscaled PNG from output_url. See the Quick Start section above for code in 6 languages.
2×, 3×, and 4× (default). Pass scale=2, scale=3, or scale=4 in the form body. You can also specify exact target_width and target_height (64–8192 px) — the API pre-shrinks oversized inputs if needed and post-resizes the model output to match your exact canvas dimensions.
$0.01 per image (10 credits; 1 credit = $0.001). New accounts get 500 free credits — enough for 50 upscales at no cost, no credit card required. After the free tier, credits never expire and can be used across all PixelAPI tools.
JPEG, PNG, and WebP, up to 20 MB. You can POST either a file upload via multipart/form-data or an image_url pointing to a publicly accessible image URL. Output is always PNG for lossless fidelity at the enlarged resolution.
A PNG at the requested resolution. For custom canvas dimensions, control aspect ratio handling with fit_mode=stretch (exact target, may distort), fit_mode=pad_white (preserve aspect, white padding), or fit_mode=pad_transparent (preserve aspect, transparent padding for compositing).
The model output is capped at 4096 px on the longest side to ensure stable quality. For larger targets, pass target_width and target_height — the API upscales first, then PIL-resizes the output to your exact pixel dimensions.
Yes. Send concurrent POST requests — each is queued and processed independently. Free tier allows 60 requests/minute; paid tiers allow 600 requests/minute. For higher-throughput batch pipelines, email [email protected] with your expected volume.
Yes — pip install pixelapi. Official SDKs are also available for Node.js (npm install pixelapi), PHP (Composer), Ruby (Gem), and Go (go get). All SDKs handle authentication, polling, retry-on-429, and binary file return automatically.
Self-hosting requires provisioning hardware, managing Python dependencies, building a job queue, and keeping the model weights up to date. PixelAPI gives you a single HTTPS endpoint, SDKs in 6 languages, a production SLA, and auto-refunds on failed jobs — for $0.01 per image with zero infrastructure to operate.
Failures are detected automatically by an output-quality layer. Credits are auto-refunded if the job fails — you never pay for a broken result. The status field returns failed and error_message explains what went wrong. Transient queue-full errors (503) also trigger an automatic credit refund before they reach the client.