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.
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:
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.
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.
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.
Pass target_width and target_height for exact pixel output. Choose stretch, pad_white, or pad_transparent to control aspect-ratio handling.
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.
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.
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")
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
| Provider | Free tier | Per-image cost | Scale range | API 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.
Upload JPEG → receive JPEG. Upload PNG → receive PNG. Upload WebP → receive WebP. Transparent PNGs keep their alpha channel at full upscaled resolution.
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.
Optional target_width + target_height with stretch, pad_white, or pad_transparent fit modes. Hit any canvas spec without a second resize call.
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.
The upscale-4x API is the foundation for these production workflows. Each links to a setup guide:
Upscale supplier low-res images to Shopify/Amazon listing spec before publish.
Take web-resolution originals to 300 DPI print quality — banners, canvas, posters.
Batch-enhance contributor uploads to meet agency minimum-resolution requirements.
Upscale digital artwork for gallery-quality print runs without visible artifacts.
Rescue client photos shot at insufficient resolution for the ordered print size.
Upscale swatch and lookbook images for hi-res editorial or print use.
Enhance product macro shots to meet luxury retailer high-resolution requirements.
Scale client assets to digital-out-of-home and billboard spec automatically.
Batch-upscale showroom and dealer inventory photos for hi-res display ads.
Auto-upscale product images on upload via webhook. Keeps your catalog at listing-spec resolution automatically.
No-code upscale trigger: new image in Google Drive → upscaled in Dropbox.
Drag-and-drop upscale module in Make scenarios, no code required.
Upscale product gallery images on WooCommerce upload via WordPress hook.
Catalog automation with the BigCommerce product and image API.
CMS asset upscale for hi-res Webflow product and editorial pages.
Same visual quality. REST API vs desktop-only. Pay-per-image vs annual seat license. Works from any language.
$0.009 vs ~$0.09/image. No monthly subscription required. 16x scale vs 2x+. JPEG/PNG/WebP output.
Comparable per-image price. 2–16x scale vs 2–4x. REST + 6 SDKs. Auto-refund on failures.
Public pay-as-you-go pricing vs separate API plan. 6 official SDKs. Custom output dimensions.
Full JSON REST API vs upload-form flow. 2–16x scale. Transparent PNG alpha preserved.
Simpler pricing model. Free trial with no credit card. Drop-in replacement for upscale workflows.
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.
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.
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.
$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.
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.
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.
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.
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.
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.
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.
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.
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.
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.