REST API · Live

Free Topaz Gigapixel Alternative: AI Image Upscaler API

A production REST API for AI image upscaling — the developer-grade topaz gigapixel alternative free of a desktop license. One HTTP call upscales any photo or product image 2–16× with detail recovery, sharp edges, and clean output. $0.009 per image — significantly lower-priced than Topaz Gigapixel, Vance.ai, Let's Enhance, and Upscale.media. 5,000 free credits (24-hour trial), no credit card.

$0.009 / image 2–16× upscale 5,000 free credits (24-hour trial) No credit card Up to 20 MB input Custom output dimensions
Get an API key (free) Quick start See pricing API docs

Quick start — upscale an image in one API call

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": 9}

# Poll until completed
curl https://api.pixelapi.dev/v1/image/UUID \
  -H "Authorization: Bearer YOUR_API_KEY"
# Response: {"generation_id": "uuid", "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.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", 4)
if err != nil { panic(err) }
result.Save("photo_4x.png")

Upscale parameters at a glance

ParameterTypeDefaultDescription
imagefile upload—JPEG / PNG / WebP, max 20 MB. Use this or image_url.
image_urlstring—Publicly accessible URL to fetch the source image from.
scaleinteger 2–164Upscale factor. 2–4 = single AI pass. 5–16 = two-pass for large-format output.
target_widthinteger 64–16384—Optional exact output width in pixels. Must be paired with target_height.
target_heightinteger 64–16384—Optional exact output height in pixels. Must be paired with target_width.
fit_modestringstretchstretch (exact size), pad_white (preserve aspect, white border), pad_transparent (preserve aspect, transparent canvas).

Pricing — free Topaz Gigapixel alternative vs rivals

ProviderFree tierPer-image costAPI / RESTMax scale
PixelAPI 5,000 credits (24-hr trial), no card $0.009 ✓ REST API 16×
Topaz GigapixelNone$0.08–$0.12/image (native API)Native API + Replicate4×
Vance.aiLimited trial credits~$0.058/image (4×, Studio annual)API in paid plans8×
Let's EnhanceNone~$0.068/image (Max plan)Business API tier16×
Upscale.mediaLimited~$0.076/image (Pro plan)API in paid plans4×

Pricing verified from each rival's public pricing page, October 2026: developer.topazlabs.com, vanceai.com/pricing, letsenhance.io/pricing, upscale.media/pricing. PixelAPI price based on canonical billing (9 credits × $0.001/credit).

What you get back

Upscaled PNG — 2× to 16×

Default output is a full-quality PNG at the requested scale. A 1000×750px JPEG in becomes a 4000×3000px PNG at scale=4. Transparency in the source is preserved.

Custom output dimensions

Need exactly 3000×2000px for a print spec? Pass target_width=3000&target_height=2000. The API upscales then resizes to your exact dimensions.

Transparent canvas (pad_transparent)

Preserve aspect ratio and pad to exact dimensions with a transparent PNG canvas. Ideal for product images that must fit a standard slot without distortion.

White-padded output (pad_white)

Same as pad_transparent but with a white background — marketplace-ready for Amazon, Shopify, and studio-white catalogue specs.

Large-format print output

Two-pass upscaling at scale 5–16 produces 10,000px+ output from standard-res inputs — suitable for wide-format printing, signage, and fine art.

URL or file upload input

Submit via multipart file upload or pass an image_url. Both inputs accept JPEG, PNG, and WebP up to 20 MB.

Common use cases for AI image upscaling

The Image Upscaler API covers these production workflows. Each links to a related guide:

Image Upscaler API overview

Full API reference, parameters, and output format details for the upscale endpoint.

Best ESRGAN API

Comparison of ESRGAN-based upscaling APIs. PixelAPI vs alternatives for different use cases.

Community workflows (Reddit)

Real developer workflows and scripts for replacing Topaz Gigapixel in automated pipelines.

Open-source alternatives

How PixelAPI compares to running Real-ESRGAN locally vs a managed API.

Upscale API docs

Endpoint reference, authentication, and error code guide for the upscale endpoint.

vs Topaz Gigapixel

Side-by-side feature and pricing comparison against Topaz Gigapixel AI.

Integrations

The Image Upscaler API integrates with popular platforms via the PixelAPI SDK and webhook events:

Shopify

Auto-upscale product images on upload. Webhook-triggered, runs in the background.

Zapier

No-code upscale trigger. Connect to any Zap in two clicks.

Make.com

Drag-and-drop upscale step in Make scenarios. Works with Google Drive, Dropbox, and more.

Webflow

CMS image upscaling for editorial and product pages in Webflow collections.

BigCommerce

Catalog automation with the BC product API. Hi-res variants on demand.

Magento

Adobe Commerce / Magento 2 plugin pattern for batch product image upscaling.

Comparison vs alternatives — free Topaz Gigapixel alternative

vs Topaz Gigapixel

Topaz is a desktop app — no production REST API. PixelAPI gives Topaz-class AI quality over HTTP at $0.009/image with no desktop install or subscription.

vs Vance.ai

Vance.ai requires an annual subscription and costs ~$0.058/image at 4×. PixelAPI is pay-as-you-go at $0.009/image with a free trial, no commitment.

vs Let's Enhance

Let's Enhance costs ~$0.068/image. Business API tier requires contacting sales. PixelAPI has public pricing and a free trial you can start in 60 seconds.

vs Upscale.media

Upscale.media costs ~$0.076/image on the Pro plan. PixelAPI is 8× cheaper at $0.009 with more scale options (up to 16×) and custom dimension support.

vs BigJPG

BigJPG is a consumer web tool without a developer-grade REST API. PixelAPI provides production SLA, API key auth, async job queue, and volume pricing.

vs Claid.ai

Claid.ai bundles upscaling with image editing. If you only need upscaling, PixelAPI is a focused, lower-cost option with transparent per-image pricing.

Rate limits & error handling

20 requests/minute on the free trial, 60 on Starter, 120 on Pro, and 300 on Scale — with 3/10/20/50 concurrent jobs respectively. Exceeding the limit returns HTTP 429 with a Retry-After header. For large batch workloads, use the concurrent jobs cap to parallelize throughput rather than hammering rate limits.

# Python SDK auto-retries 429 with exponential backoff
from pixelapi import PixelAPI
client = PixelAPI(api_key="...", max_retries=4)
result = client.upscale(image="photo.jpg", scale=4)  # auto-retries on 429

# Batch: submit N jobs, collect results
import asyncio
from pixelapi.async_client import AsyncPixelAPI

async def batch_upscale(paths):
    client = AsyncPixelAPI(api_key="...")
    jobs = await asyncio.gather(*[client.upscale(image=p, scale=4) for p in paths])
    return jobs

Common error codes: 400 invalid parameters or unsupported file, 402 insufficient credits, 413 image exceeds 20 MB, 429 rate limit hit. All errors return JSON with a detail field. Credits are never charged for jobs that fail input validation or produce blank output — failures trigger an automatic refund.

Frequently asked questions

What is the best free Topaz Gigapixel alternative with a REST API?

PixelAPI's Image Upscaler API. It upscales images 2–16× at $0.009 per image, with 5,000 free credits (24-hour trial) and no credit card required. Topaz Gigapixel is a desktop application and does not offer a production REST API — making PixelAPI the direct API-first alternative for developers and production pipelines.

How do I upscale an image via the API?

POST your image to https://api.pixelapi.dev/v1/image/upscale with your API key and scale=4 (or any integer 2–16). The endpoint returns a generation id. Poll GET /v1/image/{id} until status=completed, then download the full-resolution PNG from output_url. See the Quick Start section above for code in 6 languages.

What does the PixelAPI image upscaler cost?

$0.009 per image (9 credits × $0.001/credit). New accounts receive 5,000 free credits (24-hour trial) with no credit card required — roughly 555 upscales to test on real data. There is no subscription required for pay-as-you-go usage.

What upscale factors are supported?

The scale parameter accepts any integer from 2 to 16. Scales 2–4 run a single AI upscaling pass; scales 5–16 run two AI passes for extreme output sizes. A 1254px source image at scale 8 becomes approximately 10,000px — suitable for large-format print and high-resolution stock photo submissions.

Does PixelAPI have a free trial?

Yes. New accounts get 5,000 free credits (24-hour trial) with no credit card required. At 9 credits per upscale, that covers approximately 555 image upscales — plenty to test on real catalogue data, bulk workflows, or any mix of PixelAPI's other tools in the same trial window.

How does the output quality compare to Topaz Gigapixel?

PixelAPI uses Real-ESRGAN AI upscaling — the same class of model behind Topaz Gigapixel and similar professional tools. Detail recovery, edge sharpening, and noise reduction happen in one AI pass. Fine text, hair, fabric texture, and product edge sharpness are handled cleanly at all scale factors from 2× through 16×.

What image input formats are accepted?

JPEG, PNG, and WebP, up to 20 MB per file. Submit via multipart file upload (image field) or by passing an image_url pointing to a publicly accessible URL. Both paths support all three formats.

Can I upscale to a specific pixel dimension?

Yes. Pass target_width and target_height (both required together, 64–16384px each) to request an exact output size. Combine with fit_mode: stretch for exact dimensions, pad_white to preserve aspect ratio with a white border, or pad_transparent for a transparent PNG canvas at exact dimensions.

What output format does the upscaler return?

PNG. Opaque RGB inputs return RGB PNG. Transparent RGBA inputs preserve the alpha channel. Use fit_mode=pad_transparent to explicitly request a transparent-padded canvas when using custom dimensions.

Is there a Python SDK for image upscaling?

Yes — pip install pixelapi. Official SDKs are also available for Node.js (npm install pixelapi), PHP (Composer), Ruby (Gem), and Go (go get github.com/pixelapi/pixelapi-go). All SDKs handle authentication, async job polling, retry-on-429 with backoff, and binary file saving automatically.

What are the rate limits?

20 requests/minute on the free trial, 60 on Starter, 120 on Pro, and 300 on Scale — with 3/10/20/50 concurrent jobs respectively. Exceeding the limit returns HTTP 429 with a Retry-After header. The Python and Node SDKs handle retry-with-backoff automatically. Higher limits for large batch workloads: email support@pixelapi.dev.

Can I use this for large-format print or commercial stock photos?

Yes. Scale 8–16 produces print-ready output from web-resolution sources. A 1500×1000px source becomes ~12,000×8,000px at 8× — suitable for wide-format signage, fine art prints, and stock library submissions requiring 50+ MP files. Credits are charged per image regardless of scale factor.

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