REST API · Live

Topaz Gigapixel Open Source Alternative: 4× AI Image Upscaler API

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.

$0.01 / image 2× · 3× · 4× scale 500 free credits No credit card 20 MB max input Real-ESRGAN model
Get an API key (free) Quick start See pricing API docs

Why developers switch from Topaz Gigapixel to PixelAPI

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.

No desktop, no license

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.

Pay per image, not per seat

$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.

Open-source model quality

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.

Quick start — one API call to upscale 4×

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")

Pricing — vs Topaz Gigapixel and other upscalers

ProviderFree tierPer-image costAPI availableModel
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.

What you get back

PNG at 2× / 3× / 4× resolution

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.

Custom exact dimensions

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.

URL input or file upload

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.

JPEG, PNG, WebP input

The API accepts JPEG, PNG, and WebP, up to 20 MB per image. Output is always PNG for maximum fidelity at the enlarged resolution.

Request parameters

ParameterTypeDefaultNotes
imagefileMultipart file upload (JPEG/PNG/WebP, max 20 MB). One of image or image_url required.
image_urlstringPublicly accessible URL to fetch. Alternative to file upload.
scaleint4Upscale factor: 2, 3, or 4.
target_widthintExact output width in pixels (64–8192). Set with target_height for custom canvas.
target_heightintExact output height in pixels (64–8192). Set with target_width for custom canvas.
fit_modestringstretchstretch · pad_white · pad_transparent. Controls how aspect ratio is handled when custom dims differ from input.

Common workflows

The Image Upscaler API is the foundation for these production workflows. Each links to a setup guide:

Art prints & posters

Upscale stock art or customer photos to 300 DPI print-ready dimensions without visible artifacts.

E-commerce catalogs

Bulk-upscale supplier product images to marketplace hi-res requirements in one automated pipeline.

Photography studios

Recover detail in compressed or low-res client shoots before delivery.

Real estate listings

Upscale phone-camera listing photos to high-res before publishing.

Fashion & apparel

Enlarge product shots for zoom-on-hover features and lookbook pages.

Furniture catalogs

Upscale manufacturer product photos for hi-res detail pages.

Marketplace sellers

Meet Amazon, Etsy, and eBay hi-res image requirements automatically.

Watches & luxury goods

Museum-quality macro upscaling for engravings, dials, and surface textures.

Social media

Rescale legacy square posts to landscape or portrait without visible pixel stretching.

More use-case guides: all industries →

Integrations & SDKs

Shopify

Upscale product images on upload via webhook — no manual step for your team.

Zapier

No-code upscaling trigger — connects to Google Drive, Dropbox, Airtable.

Make.com

Drag-and-drop upscale node in Make scenarios for any image workflow.

Webflow

CMS asset auto-upscale for hi-res product detail pages.

BigCommerce

Catalog automation — upscale all new product images on import.

Magento

Adobe Commerce / Magento 2 plugin pattern for automated upscaling.

Comparison vs alternatives

vs Topaz Gigapixel AI

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.

vs Let's Enhance

Both offer API access. PixelAPI's pricing is transparent and per-image; Let's Enhance charges by subscription credit bundle.

vs Vance.ai

Vance.ai has rebranded to Unifab.ai and shifted focus to video desktop software. PixelAPI remains focused on image API.

vs Upscale.media

Upscale.media uses INR-based credit bundles. PixelAPI offers USD-transparent per-image pricing with no subscription lock-in.

Rate limits & error handling

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 codeMeaningAction
400Invalid params or image too large (>20 MB)Fix params and retry
401Missing or invalid API keyCheck Authorization header
402Insufficient creditsTop up at /pricing
429Rate limit hitRetry after Retry-After seconds
503Queue full (transient)Retry in a few seconds — credits not charged

Frequently asked questions

Is PixelAPI a true open source alternative to Topaz Gigapixel?

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.

How do I upscale an image via the API?

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.

What upscale factors are supported?

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.

What does the image upscaling API cost?

$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.

What image formats does the API accept?

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.

What does the API return?

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).

How large can the output image be?

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.

Does PixelAPI support batch upscaling?

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.

Is there a Python SDK?

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.

What makes this better than running Real-ESRGAN myself?

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.

What if the upscale job fails?

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.

Start free — 500 credits, no card Read full API docs Compare all plans