REST API · Live

Best Alternative to Topaz Gigapixel — 4x Image Upscaler API

The best alternative to Topaz Gigapixel for developers is PixelAPI's upscale-4x endpoint. Topaz Gigapixel is a powerful desktop application — but it has no public REST API, requires a per-seat license, and cannot be called from a pipeline. PixelAPI ships the same AI super-resolution quality as a simple HTTP call. Upload an image, get back a crisp 2x–16x enlarged version in seconds. $0.009 per image. 5,000 free credits (24-hour trial), no credit card.

$0.009 / image 2x – 16x scale 5,000 free credits (24-hr trial) No credit card PNG · JPG · WebP REST + 6 SDKs
Get an API key (free) Quick start See pricing API docs

Why developers switch from Topaz Gigapixel to PixelAPI

Topaz Gigapixel AI produces excellent results, but it is a desktop application — not a developer tool. There is no public REST endpoint, no per-call billing, and no way to automate it from a web backend or serverless function without undocumented workarounds. PixelAPI solves this directly:

REST API — no desktop required

One HTTP POST from any language, platform, or CI pipeline. No local install. No GUI. Works from a Lambda function, a Django view, a Next.js API route, or a shell script.

Pay-per-image, not per seat

At $0.009 per image you pay only for what you process. No monthly license, no seat negotiation, no annual commitment before you can try the results.

Scale from 2x to 16x in one call

The scale parameter accepts 2–16. Single-pass for 2–4x. Two-pass for 5–16x — turning a 1,254 px web image into a 10,000 px+ print master without a second API call.

Custom output dimensions with fit modes

Pass target_width and target_height for exact pixel output. Choose stretch, pad_white, or pad_transparent to control aspect-ratio handling.

Transparent PNG support

Alpha channels are preserved end-to-end. Upscaling a product cutout or logo on a transparent background returns a transparent PNG with the same quality enhancement.

Auto-refund for failed jobs

An output-quality layer checks every result. If the upscale would have been blank or corrupted, the job is rejected and credits are automatically refunded — you never pay for a broken result.

Quick start — one API call

Sign up, copy your key, and POST your image. The endpoint returns a generation_id; poll until status=completed, then download the upscaled image.

curl -X POST https://api.pixelapi.dev/v1/image/upscale \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "image=@photo.jpg" \
  -F "scale=4"
# 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.upscale(image="photo.jpg", scale=4)
result.save("photo_4x.jpg")  # matches input format
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.jpg");
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.jpg", $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.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.Upscale("photo.jpg", pixelapi.UpscaleOpts{Scale: 4})
if err != nil { panic(err) }
result.Save("photo_4x.jpg")

Custom dimensions example — exact output size

When you need to hit a precise canvas size (e.g. a Shopify banner at 2400×1600), pass target_width and target_height with a fit_mode:

curl -X POST https://api.pixelapi.dev/v1/image/upscale \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "image=@product.jpg" \
  -F "target_width=2400" \
  -F "target_height=1600" \
  -F "fit_mode=pad_white"
# Returns 2400×1600 JPG, original content aspect-preserved, padded with white

Pricing — cheaper than Let's Enhance and Upscale.media

ProviderFree tierPer-image costScale rangeAPI access
PixelAPI 5,000 credits (24-hr trial, no card) $0.009 2x – 16x REST · 6 SDKs
Topaz Gigapixel AI No free tier $149/yr desktop license (unlimited); enterprise API: contact sales 2x – 6x (desktop) Enterprise only (no public REST)
Let's Enhance 10 free credits ~$0.09/image (Starter: $9/mo, 100 credits) 2x+ Business plan (see letsenhance.io/business)
Upscale.media 3 credits/month ~$0.11/image (60-pack); ~$0.010/image (annual sub) 2x – 4x Included in all plans
VanceAI Some free credits Web app $15–75/mo subscription; API pricing via account dashboard 2x – 8x Separate API subscription

Pricing verified from each rival's public pricing page October 2026. Topaz Gigapixel AI pricing from topazlabs.com/pricing; Let's Enhance pricing from letsenhance.io/pricing; Upscale.media pricing from upscale.media/pricing; VanceAI pricing from vanceai.com/pricing.

What you get back

Format-preserving output

Upload JPEG → receive JPEG. Upload PNG → receive PNG. Upload WebP → receive WebP. Transparent PNGs keep their alpha channel at full upscaled resolution.

2x – 16x scale factor

Single-pass enhancement at 2x–4x. Two-pass for 5x–16x: a 1,254 px source becomes 10,000 px+ output in one API call — print-ready at 300 DPI for A0 posters.

Custom canvas dimensions

Optional target_width + target_height with stretch, pad_white, or pad_transparent fit modes. Hit any canvas spec without a second resize call.

Face + upscale combo

For portraits, chain upscale-4x with the face-restore endpoint in one call via the enhance route. Enlarges then sharpens facial detail — useful for old or low-resolution portrait photos.

Common workflows

The upscale-4x API is the foundation for these production workflows. Each links to a setup guide:

E-commerce catalogs

Upscale supplier low-res images to Shopify/Amazon listing spec before publish.

Print & large format

Take web-resolution originals to 300 DPI print quality — banners, canvas, posters.

Stock photo enhancement

Batch-enhance contributor uploads to meet agency minimum-resolution requirements.

Art print & fine art

Upscale digital artwork for gallery-quality print runs without visible artifacts.

Photography studios

Rescue client photos shot at insufficient resolution for the ordered print size.

Fashion & apparel

Upscale swatch and lookbook images for hi-res editorial or print use.

Jewelry & accessories

Enhance product macro shots to meet luxury retailer high-resolution requirements.

Marketing agencies

Scale client assets to digital-out-of-home and billboard spec automatically.

Automotive

Batch-upscale showroom and dealer inventory photos for hi-res display ads.

Integrations & SDKs

Shopify

Auto-upscale product images on upload via webhook. Keeps your catalog at listing-spec resolution automatically.

Zapier

No-code upscale trigger: new image in Google Drive → upscaled in Dropbox.

Make.com

Drag-and-drop upscale module in Make scenarios, no code required.

WooCommerce

Upscale product gallery images on WooCommerce upload via WordPress hook.

BigCommerce

Catalog automation with the BigCommerce product and image API.

Webflow

CMS asset upscale for hi-res Webflow product and editorial pages.

Comparison vs alternatives

vs Topaz Gigapixel AI

Same visual quality. REST API vs desktop-only. Pay-per-image vs annual seat license. Works from any language.

vs Let's Enhance

$0.009 vs ~$0.09/image. No monthly subscription required. 16x scale vs 2x+. JPEG/PNG/WebP output.

vs Upscale.media

Comparable per-image price. 2–16x scale vs 2–4x. REST + 6 SDKs. Auto-refund on failures.

vs VanceAI

Public pay-as-you-go pricing vs separate API plan. 6 official SDKs. Custom output dimensions.

vs Bigjpg

Full JSON REST API vs upload-form flow. 2–16x scale. Transparent PNG alpha preserved.

vs Claid.ai

Simpler pricing model. Free trial with no credit card. Drop-in replacement for upscale workflows.

Rate limits & error handling

20 requests/minute on the free trial, 60 on Starter, 120 on Pro, and 300 on Scale — plus 3/10/20/50 parallel job slots respectively (see pixelapi.dev/docs/parallel-processing.html). 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 exponential backoff
from pixelapi import PixelAPI
client = PixelAPI(api_key="...", max_retries=4)
result = client.upscale(image="batch_item.jpg", scale=4)  # auto-retries on 429

Common error codes: 400 — missing image or invalid parameter (check detail field). 402 — insufficient credits or trial ended. 413 — input file exceeds 20 MB. 429 — rate limit; respect Retry-After. 500 — transient worker error; credits auto-refunded.

Frequently asked questions

What is the best alternative to Topaz Gigapixel for developers?

PixelAPI's upscale-4x endpoint is the leading developer alternative to Topaz Gigapixel AI. Unlike Topaz — a desktop application with no public REST API — PixelAPI is API-first: POST an image, get back a sharpened upscaled version in seconds at $0.009 per image.

How does the image upscaler API work?

POST your image (file upload or image_url form field) to https://api.pixelapi.dev/v1/image/upscale. The endpoint returns a generation_id; poll GET /v1/image/{id} until status=completed, then download from output_url. See Quick Start above for code in 6 languages.

What does the upscaler API cost?

$0.009 per image (9 credits at $0.001/credit). New accounts get 5,000 free credits in a 24-hour trial window — no credit card required. That covers 555+ upscales before spending anything.

What upscale factors are supported?

The scale parameter accepts any integer from 2 to 16. Values 2–4 run a single enhancement pass. Values 5–16 run two sequential passes for print-level output — a 1,254 px source at scale=8 yields 10,000 px+, suitable for large-format printing at 300 DPI.

What output formats does the upscaler API return?

The output format matches your input: JPEG in → JPEG out, PNG in → PNG out, WebP in → WebP out. Transparent PNGs preserve their alpha channel throughout the upscaling process.

Can I set a custom output size instead of a fixed scale factor?

Yes. Pass target_width and target_height together. Control aspect-ratio handling with fit_mode: stretch fills the canvas exactly, pad_white preserves aspect ratio and pads with white, pad_transparent pads with transparent pixels.

What is the maximum input file size?

The API accepts images up to 20 MB per call. Very large inputs are pre-scaled to a safe dimension before the upscale model runs. Use scale=8 or scale=16 for multi-pass high-resolution output from standard web-sized source images.

Is there a free trial?

Yes. New accounts receive 5,000 free credits in a 24-hour window — no credit card required. At $0.009 per upscale that covers 555+ images. Credits you purchase stay in your account and unlock the moment you subscribe.

How fast is the upscaler API?

Most 4x upscales complete in under 5 seconds end-to-end. There are no cold-start delays — capacity is kept warm 24/7 so your first request is as fast as your thousandth batch job.

Does the upscaler work for print and stock photo workflows?

Yes. The API powers print-on-demand pipelines (art prints, canvas, large-format banners), stock photo enhancement workflows, and e-commerce catalog preparation. The multi-pass 5–16x mode is designed for taking a web-resolution source to 300 DPI print quality in a single call.

Is there a Python SDK?

Yes — pip install pixelapi. Official SDKs for Node.js (npm install pixelapi), PHP (Composer), Ruby (Gem), Go (go get), and Java/Kotlin. All SDKs handle authentication, polling, retry-on-429, and binary file return automatically.

Can I get an invoice or GST receipt?

Yes. PixelAPI is a registered Indian business. GST invoices are issued automatically — 18% IGST for international clients, CGST/SGST for domestic. Invoice download is built into the dashboard.

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