Image Upscale API: Integration Guide, Pricing & Code

An image upscale API takes an image and returns a larger, sharper version of it through a programmatic endpoint. “Upscale” means resolution: the model reconstructs a higher-pixel version of your source, removes compression artifacts, and sharpens detail. It is a post-processing effect, not a generator — the content and composition of the source image stay the same.

Every vendor page for this category sells the same sentence (“bigger, sharper images”), but the APIs underneath bill in incompatible units, cap their inputs differently, and mean different things by “4x”. This guide compares the image upscale APIs that actually rank for this query — Picsart, Topaz, Claid, Clipdrop, and the aggregator route — with pricing normalized to a per-image figure, the input/output limits each one enforces, and integration code you can run today. Provider facts were read from the live official pages on August 23, 2026.

What an image upscale API does — and what it can’t fix

An upscale API increases the pixel dimensions of an image and reconstructs detail that a plain resize would blur. The mechanics differ by provider, but the practical contract is the same: send an image, specify a target scale or size, get a larger image back.

That contract has boundaries worth knowing before you build on it:

• Low-resolution but clean source images (small product photos, old scans, downscaled renders) — upscaling genuinely helps; this is the ideal case.
• Heavily compressed images (social-media re-encodes, low-bitrate JPEGs) — a good model removes artifacts and recovers some detail, but it cannot invent what compression destroyed.
• Blurry or noisy source images — resolution scaling alone will not fix focus. Some providers sell sharpen/unblur as separate capabilities; do not assume the upscale endpoint includes them. Kie’s Topaz reseller page, for example, markets upscale, unblur, and sharpen as three distinct products.

The second boundary is the scale factor. When a vendor says “4x upscale”, it means each dimension is multiplied by 4 — a 1024×1024 image becomes 4096×4096, which is 16× the pixel count, not 4×. That distinction matters when you check a “4K output” claim against your actual source size, and it is the first thing to verify in any pricing calculation. If the asset you are processing is a video rather than a still image, the same comparison logic applies to the AI video upscale API category — different providers, same three architectures, same unit-normalization problem.

How to compare image upscale APIs: pricing, limits, output

Vendor pages quote prices in incompatible units, when they quote them at all. Here is what the live pages for the providers ranking on this query actually publish (accessed August 23, 2026):

Provider	Billing unit	Published rate	Output ceiling
Modellix (seedream-5.0-lite-edit)	per image	$0.0362/image (flat)	model-defined imageSize
Modellix (nano-banana-2-edit)	per image, by output size	$0.0419 (512) – $0.1265 (4K)	up to 4K
Topaz Labs API (Enhance)	credit per request	from $0.12/credit (entry tier)	24 MP per request
Clipdrop	credit per request	not published on docs page; x-credits-consumed returned per call	16k×16k async, 4096px sync
Picsart	usage-based	not published on product page	up to 8x
Claid	usage-based	not published on product page	16x claim

The comparison you need is dollars per output image for your specific source. Worked example, stated assumptions: a 1024×1024 source image (1 MP), upscaled 4× to 4096×4096 (16.7 MP output), one image per request:

• Modellix seedream-5.0-lite-edit: $0.0362 per image, flat — the output size does not change the rate.
• Modellix nano-banana-2-edit: $0.0419 at 512 output up to $0.1265 at 4K; a 4096×4096 request lands at the 4K tier.
• Topaz Enhance: the entry tier is $0.12/credit and Enhance consumes 1 credit per request up to 24 MP output — 16.7 MP fits, so ≈$0.12.
• Clipdrop: credit-based; the exact cost is only visible per request via the x-credits-consumed response header, so budget a test call.
• Picsart and Claid: no per-image rate published on their product pages — you cannot price them without contacting sales or running a test account.

This is a worked example with stated assumptions, not a quote — prices move, and Modellix is an aggregator whose per-image rates include the platform’s margin. But the exercise is the point: no two vendors quote the same unit, and any comparison that does not convert everything to cost per output image for your source size is marketing, not math.

Input limits matter more than price for most integrations, and they are the least documented part of every vendor page. The ones that break integrations on day one:

Constraint	Clipdrop	Topaz	Picsart	Modellix
Max input resolution	16 MP	model-dependent	not stated	not stated (URL or file input)
Max file size	30 MB	not stated	not stated	via File API (documented limits)
Input format	PNG, JPEG, WebP	images/video	images	images, URL or upload
Scale control	target width/height (1–4096 px)	up to 24 MP output	up to 8x	model parameter (imageSize)
Sync or async	both	async	async	async

Clipdrop’s sync endpoint caps target dimensions at 4096 px per side, while its async route allows up to 16k×16k output — the same vendor, two very different output contracts depending on which endpoint you call. Picsart markets “up to 8x”, which sounds generous until you do the pixel math above: 8x on a 512×512 source is only 4096×4096. Always compute the output pixel count for your source, then check it against the provider’s ceiling.

Two integration patterns: synchronous and asynchronous

Every upscale API falls into one of two shapes, and your pipeline’s latency budget decides which you need:

• Synchronous — you send the image, the response body is the upscaled image. Simple, but the request blocks for the model’s runtime, and providers cap input size to keep responses fast. Clipdrop’s /upscale endpoint is the clearest example.
• Asynchronous — you submit a task, receive a task_id, and either poll a status endpoint or register a webhook; the finished image is downloaded from a result URL. This is the pattern for large images, batches, and production pipelines. Topaz, Picsart, and Modellix all use it.

The sync path returns image bytes in the response; the async path returns a task id first, then a result URL after polling or a webhook.

The async pattern dominates the category because upscaling is compute-heavy. If you are building a batch pipeline — thousands of product images per day — synchronous calls serialize your throughput; the async path lets you submit N tasks and drain them in parallel.

Image upscale API code: the same job on two routes

Here is the same job — upscale a 1024×1024 image 4× — on a synchronous route and an asynchronous route.

Clipdrop (synchronous, multipart upload):

curl -X POST https://clipdrop-api.co/image-upscaling/v1/upscale \
  -H "x-api-key: $CLIPDROP_API_KEY" \
  -F "image_file=@input.png" \
  -F "target_width=4096" \
  -F "target_height=4096" \
  -o output.jpg

The response body is the upscaled image (WebP if the source has transparency, JPEG otherwise), and the response headers include x-credits-consumed so you can meter real cost per request.

Modellix (asynchronous, URL input, poll for the result):

curl -X POST https://api.modellix.ai/api/v1/bytedance/seedream-5.0-lite-edit/async \
  -H "Authorization: Bearer $MODELLIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Upscale this image 4x, keep it identical", "image_url": "https://your-bucket/input.png"}'
# → {"code":0,"data":{"status":"pending","task_id":"task-abc123","get_result":{...}}}

Then poll the returned task endpoint:

curl -X GET https://api.modellix.ai/api/v1/tasks/task-abc123 \
  -H "Authorization: Bearer $MODELLIX_API_KEY"
# → {"code":0,"data":{"status":"success","output":{...}}}

The polling loop is the same regardless of provider — here it is in Python, which is the pattern you will ship:

import time
import requests

def wait_for_task(get_url: str, headers: dict, timeout: int = 600):
    for _ in range(timeout // 5):
        r = requests.get(get_url, headers=headers)
        state = r.json().get("data", {}).get("status")
        if state == "success":
            return r.json()
        if state in ("failed", "canceled"):
            raise RuntimeError(f"task failed: {r.text}")
        time.sleep(5)
    raise TimeoutError("task did not finish in time")

To skip the polling entirely, Modellix accepts an X-Webhook-URL header on the submit call; the webhook fires once the task reaches a terminal state (success, failed, canceled) and carries the task result, delivered as a POST with an X-Modellix-Event header naming the event (prediction.task.succeeded, prediction.task.failed, or prediction.task.canceled).

Image Upscale API Reference

See the full submit, poll, and webhook contract for Modellix media generation APIs.

View Docs

Provider snapshot: what each image upscale API actually offers

• Picsart Upscale API — the top-ranking product page (picsart.io/upscale): up to 8x upscaling, API key from the Picsart console, positioned for e-commerce, advertising, social, and print. No published per-image price; “easy integration” claims without a public limits table. Usage-based billing.
• Topaz Labs API — official API docs for the models behind Topaz’s desktop products. Credit-based: entry tier from $0.12/credit; the Enhance endpoint covers requests up to 24 MP output. This is the provider most resellers (Kie, and others) bundle, so check whether a “Topaz API” reseller is actually calling Topaz’s own endpoint or a proxy.
• Claid — product page claims 16x upscaling, combines upscale with “decompress” (JPEG artifact cleanup) and “polish” (sharpening), and publishes a real integration case: Mixam, a print platform, reports 78% fewer image-quality complaints after automating quality improvement on ~22 MB average images. Batch support; URL-based input; no published per-image rate.
• Clipdrop — official API docs are the most concrete in the category: sync endpoint (16 MP / 30 MB input caps, 1–4096 px target dimensions) and async endpoint (16k×16k output ceiling). Credit-based with per-request cost returned in the response headers.
• LetsEnhance / Claid family — LetsEnhance’s 2026 roundup is the freshest listicle in the SERP (January 2026) and benchmarks seven tools: LetsEnhance, Topaz, Clipdrop, Magnific, Pixelbin/Upscale.media, Picsart, and Cloudinary. Useful as a landscape map; the pricing table is in “subscription + credits” units, not per-image.
• Stability AI — the ranking result is a 2023 press release announcing the Image Upscaling API. It is three years old; Stability’s image models have since moved to its platform API. Useful as a reminder that this SERP is stale — “image upscale api” results have not been meaningfully refreshed since 2023-2026, which is exactly why a dated integration guide can win.
• Replicate (Real-ESRGAN and friends) — Replicate’s super-resolution collection hosts the open-weight Real-ESRGAN family and similar models, billed per second of compute at the model level. If you want predictable, open-source-style upscaling without a vendor lock-in and are comfortable with per-second metering, this is the route to evaluate. The underlying models are the same ones many commercial APIs wrap.

The three families behind every upscale API: open-weight super-resolution models (Real-ESRGAN and relatives), proprietary restoration models (Topaz-style), and generative upscalers that invent detail.

When an aggregator route makes sense (and when it doesn’t)

The same job can run through an aggregator like Modellix, which proxies model providers behind one API key and one billing relationship. For upscaling specifically, the aggregator argument is a routing decision, not a quality decision:

• One integration contract. The async submit→poll→retrieve pattern above is identical for an upscaler, an image generator, or a video model. If your pipeline already calls Modellix for generation — the same pattern our AI media generation API guide walks through — adding the image upscale collection — six image-to-image models including Seedream 5.0 Lite Edit and Nano Banana 2 Edit — is one more endpoint, not one more vendor.
• One bill, per-call logs. Pay-as-you-go with per-call cost and status logs beats juggling credit packs and per-megapixel meters across three accounts.
• The trade-off is real. Provider-specific parameters sometimes get flattened in aggregation; brand-new models often land on the vendor’s own API first; and the per-image price includes the platform’s margin. For a single high-volume upscale workload, going direct to the cheapest per-image provider (Clipdrop’s credits, or Topaz at volume) can beat any aggregator on raw unit cost.

Modellix is an aggregator and has a commercial interest in this comparison. The honest version: if you already use an aggregator for the rest of your media pipeline, routing upscale through it costs you nothing extra in integration work; if upscale is your entire workload, price the direct routes too — the math above is exactly how.

Decision framework: which image upscale API should you integrate?

Your use case	Best fit	Why
Product photos at high volume, print-quality output	Claid (or LetsEnhance)	Batch-first positioning and a published print case; no per-image price, so test first
Clean open-source-style upscaling, no vendor lock-in	Replicate (Real-ESRGAN collection)	Open weights, per-second metering, predictable output
Large-format output (posters, 8K-class)	Clipdrop async	16k×16k output ceiling is the highest published in the category
Pro-grade enhancement + restoration	Topaz API (or a Topaz reseller)	Credit-based, 24 MP per request, established quality reputation
Mixed pipeline (generate + upscale + edit)	Aggregator route (Modellix image upscale collection)	One key, one async contract, one bill; flat per-image rates on Seedream edit
Consumer-style quick fixes, budget ≈ zero	None of the APIs — use a free consumer tool	The free tiers live on consumer apps, not on API endpoints

Whichever route you pick, the discipline is the same: convert the published billing unit to cost per output image for your source size, verify the output pixel count against the provider’s ceiling, and run one paid test image before you promise a resolution in your product.

Start Upscaling Images via API

Log in to Modellix to try the image upscale collection and 210+ other models on one API key.

Login

FAQ

Is there a free image upscale API?

No major provider maintains a sustained free API tier. Topaz’s API landing page advertises “try for free — no credit card required”, a trial-based allowance rather than an unlimited free API; Clipdrop has a free allowance in its consumer tools, and Kie offers free credits to test its Topaz reseller. Every long-term integration above consumes paid capacity. Free upscaling lives on consumer apps (Picsart’s free web tool, Pixelcut), which are not the same as an API you can integrate. Budget a test image instead.

Which image upscale API gives 4K or 8K output?

None of them guarantee it for arbitrary input — “4K” is a per-provider claim. Clipdrop’s async endpoint supports up to 16k×16k output; Topaz covers up to 24 MP per Enhance request; Picsart advertises up to 8x (which is 8× per dimension). The actual output depends on your source resolution and the endpoint you call, so compute the pixel math for your input before promising resolution.

How much does it cost to upscale one image?

Using the worked example above (1024×1024 → 4x → 4096×4096): Modellix seedream-5.0-lite-edit ≈ $0.0362, Modellix nano-banana-2-edit at the 4K tier ≈ $0.1265, Topaz Enhance ≈ $0.12 at entry-tier credits. Clipdrop, Picsart, and Claid do not publish per-image rates, so the honest answer for them is “run a test call and read the meter.”

What is the difference between an image upscale API and an image enhance API?

Upscaling increases resolution and reconstructs detail; enhancement is a broader category that includes sharpening, denoising, color correction, and artifact removal. Some providers (Claid, Kie/Topaz) sell them together, but the endpoints are distinct capabilities. If your images are already high-resolution but noisy, enhancement is the relevant tool, not upscaling.

What is the best image upscaler API?

There is no single best — it depends on volume, output size, and whether you need batch processing. For published per-image pricing and flat rates, the aggregator route (Seedream 5.0 Lite Edit at $0.0362/image) is the cheapest verifiable figure in this comparison as of August 2026. For the highest published output ceiling, Clipdrop’s async endpoint (16k×16k) wins. For pro-grade restoration, Topaz has the reputation. Match the provider to the workload, not the brand.

Can I upscale images via API with Python?

Yes — every provider in this guide has an HTTP API you can call from Python with requests. The async pattern with a polling loop (the wait_for_task function above) is the standard approach; sync routes like Clipdrop’s /upscale return the image bytes directly in the response.

What input formats do image upscale APIs accept?

Clipdrop documents PNG, JPEG, and WebP with a 16 MP / 30 MB input cap. Most providers accept standard image formats and a publicly accessible URL; Modellix also supports direct file upload through its File API, which returns a URL you can pass into the model call.

---

Provider details and pricing reflect public information as of August 23, 2026, and change frequently. Validate against each provider’s live pricing before committing — several vendors in this category do not publish per-image rates at all. Access image and video models, including the leading Chinese models, through a single API key at www.modellix.ai.

Cover image: illustrative Modellix artwork; it is not a vendor product screenshot or source evidence.