REST API · Live

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

The leading topaz gigapixel open source alternative for developers. PixelAPI wraps AI upscaling — 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.0015 per image, works server-side from any language, and ships 5,000 free credits (24-hour trial) with no credit card required.

$0.0015 / image 2× · 3× · 4× scale 5,000 free credits (24-hour trial) No credit card 20 MB max input AI upscaling 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 (AI upscaling) 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.0015 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

AI upscaling 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 "image=@photo.jpg" \
  -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 5,000 credits (24-hour trial), no card $0.0015 ✓ REST + SDKs AI upscaling (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 (image=@file.jpg) 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
imagefile—Multipart file upload (JPEG/PNG/WebP, max 20 MB). One of image or image_url required.
image_urlstring—Publicly accessible URL to fetch. Alternative to file upload.
scaleint4Upscale factor: 2, 3, or 4.
target_widthint—Exact output width in pixels (64–8192). Set with target_height for custom canvas.
target_heightint—Exact 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.0015/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 annual commitment.

Rate limits & error handling

Rate limits: 20 requests/minute on the free trial, 60 on Starter, 120 on Pro and 300 on Scale, with 3/10/20/50 jobs in parallel respectively. 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 AI upscaling, 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 AI upscaling in a production REST API at $0.0015 per image, with 5,000 free credits (24-hour trial) 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.0015 per image (10 credits; 1 credit = $0.001). New accounts get 5,000 free credits (24-hour trial) — enough for 50 upscales at no cost, no credit card required. After the free tier, credits carry forward only when recharged before validity expires 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. Rate limits: 20 requests/minute on the free trial, 60 on Starter, 120 on Pro and 300 on Scale, with 3/10/20/50 jobs in parallel respectively. For higher-throughput batch pipelines, email support@pixelapi.dev 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 AI upscaling 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.0015 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 — 5,000 credits, no card Read full API docs Compare all plans