AI Video Upscale API: Multi-Provider Integration Guide

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

An AI video upscale API takes an existing video and returns a higher-resolution, sharper version of it through a programmatic endpoint. “Upscale” here means resolution and clarity: the model reconstructs a larger frame from the pixels it has, removes compression artifacts, and sharpens edges. It is a post-processing effect, not a generator — the content, style, and motion of the source clip stay the same.

That boundary matters, because it sets expectations for what an upscale API can deliver for your footage:

• Low native resolution with clean detail (a 720p render, an old scan) — upscaling genuinely helps; this is the ideal case.
• Heavily compressed or noisy footage (social-media re-encodes, low-bitrate streams) — a good model removes artifacts and recovers some detail, but it cannot invent what was destroyed by compression.
• Motion blur or out-of-focus footage — resolution scaling alone will not fix this. Some providers sell restoration add-ons (deblur, face repair) as separate capabilities; do not assume the upscale endpoint includes them.

When you search for an “ai video upscale api”, you are not choosing between “4K yes or no”. You are choosing between three different model architectures that produce different trade-offs — and the providers on page one of Google all use different ones. That is the part every vendor page skips, and it is the part that determines whether your integration works on day one.

The three architectures behind every video upscale API

Every provider that ranks for “ai video upscale api” uses one of three approaches. Knowing which one you are buying explains the price, the output quality, and the failure modes before you write any code.

1. Frame-by-frame super-resolution (RealESRGAN and relatives)

The most common approach: the video is split into frames, each frame is run through a super-resolution model, and the frames are re-encoded. fal’s video upscaler states this directly — RealESRGAN applied per frame — and the same family powers Segmind’s ESRGAN video upscaler and lucataco/real-esrgan-video on Replicate.

Strengths: predictable output, low hallucination risk (the model adds texture but rarely fabricates content), cheap per frame at scale, and the underlying models are open weight so many providers host them. Weaknesses: each frame is processed independently, so temporal consistency is only as good as the model — flicker and shimmering are possible on fast motion; and the per-frame billing adds up on long clips.

2. Proprietary enhancement models (Topaz-style)

Topaz Labs’ API exposes the same models behind its desktop Video AI product — trained on large corpora of real footage, tuned for detail recovery and artifact reduction. Replicate hosts a topazlabs/video-upscale model with the same family name, and resellers such as Pixazo bundle “Topaz” as a named model tier.

Strengths: the best detail recovery for real-world footage, strong motion handling from temporal processing, and a track record of studio use. Weaknesses: closed weights, premium pricing (credit-based, typically contact-sales for volume), and less control — you take the model’s notion of “better”.

3. Generative / diffusion upscalers (Magnific, SeedVR2)

A newer approach that uses diffusion or GAN-based generation to add detail that was not in the source. Magnific’s video upscaler is the clearest example: its request body exposes creativity, sharpen, smart_grain, and fps_boost parameters, and it supports output resolutions from 720p up to 4K. Note that fps_boost is a frame-interpolation feature rather than a resolution one: the docs describe it as increasing the frame rate of the upscaled video — i.e., synthesizing intermediate frames between the originals, a separate axis from upscaling. SeedVR2 (resold by Pixazo and others) is in the same family.

Strengths: can produce genuinely sharper, more “filmic” output than frame-by-frame models on soft footage, and the artistic controls let you tune the look. Weaknesses: generative models can invent detail (grain, texture, even structure) that changes the footage; output is less predictable; and per-request pricing is higher.

The architecture determines the trade-off you are buying: predictably cheap (frame-by-frame), best detail on real footage (proprietary), or creative enhancement with generative risk (diffusion).

How to compare upscale APIs: pricing, inputs, outputs

Vendor pages quote prices in incompatible units. Here is what you will actually see on the live docs of the providers ranking for this query:

Provider	Billing unit	Published rate (accessed Aug 12, 2026)
PiAPI (Qubico/video-toolkit)	per frame	$0.0003/frame
fal (fal-ai/video-upscaler)	per megapixel	$0.0008/megapixel
Topaz API	credit per request	from $0.12/credit; volume tiers lower
Modellix (pixverse/upscale-video)	per second of output	$0.0403/second
Magnific	per request	pricing page, not per-minute

To compare them, convert everything to dollars per minute of source video. The math is simple but you must state your assumptions. For a 30-second clip at 30 fps (900 frames), source 720p (0.92 megapixels per frame), upscaled 2x:

• PiAPI: 900 frames × $0.0003 = $0.27 per 30-second clip. PiAPI’s own docs give the same arithmetic: 60 frames × $0.0003 = $0.018.
• fal: 900 frames × 0.92 MP ≈ 829 megapixels × $0.0008 = $0.66 per clip.
• Modellix: 30 seconds × $0.0403 = $1.21 per clip.

This is a worked example with stated assumptions, not a quote — the numbers move with frame rate, source resolution, and current prices. But the exercise is the point: no two vendors quote the same unit, and anyone who promises “cheap 4K upscaling” without telling you the unit is hiding the comparison.

Input constraints 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	PiAPI	fal	Modellix (PixVerse)
Max input resolution	720p (1280×720)	not capped in docs; URL input	not specified on model page
Max file size	10 MB (MP4 only)	URL-based, no stated cap	URL-based (via File API where needed)
Scale factor	2x only	scale parameter (e.g. 2, 4)	provider-defined
Output resolution	resized to 720p/1080p standard	up to model capability	“increases resolution and clarity”

PiAPI’s 720p input cap and 2x-only scale factor are the classic hidden limits: a “4K upscale” search that lands on PiAPI will not get 4K — its output tops out at 1080p. Meanwhile Topaz advertises 4K-class output and Magnific lists 720p/1k/2k/4k output options. “4K” is a per-provider claim, not a category feature — verify the output contract before you promise resolution in your product.

Provider snapshot: what each upscale API actually offers

• Topaz API — proprietary models from Topaz Video AI and Gigapixel. Credit-based: entry tier at $0.12/credit, 1 credit covers a request at up to 24 MP output on the Enhance endpoint, larger outputs cost 2-16 credits. Try-without-credit-card onboarding; volume pricing via sales. Docs at developer.topazlabs.com.
• fal.ai video-upscaler — RealESRGAN per frame, billed $0.0008/megapixel, accepts a video URL (mp4, mov, webm, m4v, gif), scale parameter, async queue with status polling. Commercial use, schema and playground on the model page.
• PiAPI — hosts a Qubico/video-toolkit model, task_type: "upscale", $0.0003/frame, 720p-max input, MP4, 2x scale, webhook support. Good for short clips; the frame cap (10-240 frames per the formal spec) means roughly 0.3-8 seconds of 30 fps footage per task.
• Replicate — not one model but a collection: runwayml/upscale-v1 (up to 4x, 4K-class output for clips under 40 seconds), lucataco/real-esrgan-video (MP4, cost/quality balance), topazlabs/video-upscale (premium), plus specialty models — pbarker/gfpgan-video and zsxkib/stable-video-face-restoration for faces, tencentarc/animesr for anime. Per-second billing at the model level; check each model page.
• Segmind — ESRGAN-based video upscaler model page with GAN-style artifact reduction; positioned for content creation, film restoration, and gaming footage.
• Magnific — diffusion-based upscaler with creativity, sharpen, smart_grain, fps_boost controls, output resolutions 720p to 4K, plus a Turbo variant. Task list/get endpoints and webhooks.

Two of these families — frame-by-frame super-resolution and generative upscalers — overlap with other video-to-video processing you may already be running, such as video extension APIs. If you are building a pipeline that already generates clips, the upscale step is usually the last one, and its output contract (resolution, codec, aspect ratio) has to match your delivery target.

Integration code: the same upscale job on three routes

All of these APIs share one pattern: submit an async task, poll (or get a webhook), download the result. The differences are the endpoint, the auth header, and the input field.

Every provider in this guide follows the same async contract — only the endpoint, auth header, and status field names differ.

Here is the same job — upscale a 30-second 720p clip 2x — on three routes.

fal.ai (submit to the queue, poll the request):

curl -X POST https://queue.fal.run/fal-ai/video-upscaler \
  -H "Authorization: Key $FAL_KEY" \
  -H "Content-Type: application/json" \
  -d '{"video": {"url": "https://your-bucket/clip.mp4"}, "scale": 2}'
# → {"request_id": "..."} — poll status until COMPLETED, then read video.url

PiAPI (submit a task, poll by task_id):

curl --location 'https://api.piapi.ai/api/v1/task' \
  --header 'x-api-key: YOUR_PIAPI_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "Qubico/video-toolkit",
    "task_type": "upscale",
    "input": {"video": "https://your-bucket/clip.mp4", "resolution": "1080p"}
  }'
# → {"task_id": "..."} — poll GET /api/v1/task/{task_id} until done

Modellix (aggregator route — the same async contract for every provider behind one key):

curl -X POST https://api.modellix.ai/api/v1/pixverse/upscale-video/async \
  -H "Authorization: Bearer $MODELLIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"video": "https://your-bucket/clip.mp4"}'
# → {"task_id": "..."} — poll GET /api/v1/tasks/{task_id}, or set X-Webhook-URL

The polling loop is identical across providers; only the status shape differs:

import requests, time

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("status") or r.json().get("state")
        if state in ("succeeded", "completed", "SUCCEEDED"):
            return r.json()
        if state in ("failed", "FAILED"):
            raise RuntimeError(f"task failed: {r.text}")
        time.sleep(5)
    raise TimeoutError("task did not finish in time")

Three practical rules when integrating async video pipelines:

1. Host your input as a public URL. Every provider in this list accepts a video URL; only some accept direct uploads. A signed S3/GCS URL that expires after the task completes is the standard pattern.
2. Set the webhook if the provider supports it. PiAPI, Modellix, Magnific, and fal’s queue all support webhook callbacks — one header (X-Webhook-URL on Modellix, a webhook_config block on PiAPI) removes the polling loop entirely.
3. Test with a 5-second clip first. Input caps (PiAPI’s 10 MB / 10-240 frames), codec assumptions (MP4-only), and scale-factor limits surface in the first test run, not in the docs.

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

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

• One integration contract. The POST /api/v1/<provider>/<model>/async + task-poll pattern above is identical for PixVerse upscale, a video generator, an image model, or a lip-sync model. If your pipeline already calls Modellix for generation, adding the PixVerse Upscale Video route is one more endpoint, not one more vendor.
• One bill, per-call logs. Pay-as-you-go with per-call cost/status logs beats juggling per-frame credit balances 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-call price includes the platform’s margin. For a single high-volume upscale workload, going direct to the cheapest per-minute provider (PiAPI at ~$0.27 per 30-second clip in the worked example above) can beat any aggregator on raw unit cost.

Modellix is an aggregator and has a commercial interest in this comparison. The honest version of the argument: 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 route too — the math above is exactly how.

Decision framework: which upscale API should you integrate?

Your use case	Best fit	Why
Archival footage / film restoration	Topaz API (or a premium reseller route)	Best real-footage detail recovery; face models (GFPGAN-family) if people appear
Upscaling AI-generated clips before delivery	RealESRGAN route (fal, Segmind, Replicate)	Predictable output, no invented detail, cheap per frame
Batch UGC at high volume, cost-sensitive	PiAPI or the cheapest per-minute route after normalization	The per-frame/per-second math dominates at scale
Anime / stylized content	tencentarc/animesr on Replicate	Tuned for clean lines and flat colors
Artistic enhancement with control	Magnific	Creativity/sharpen/grain parameters give you the look
Mixed pipeline (generate + upscale + edit)	Aggregator route (Modellix PixVerse upscale)	One key, one async contract, one bill

Whichever route you pick, the discipline is the same: normalize the price to a per-minute figure with stated assumptions, verify the input caps against your source footage, and test before you promise a resolution — a “4K” claim on the vendor’s marketing page is not the same as a verified output contract for your input.

For a deeper walkthrough of one specific route — endpoints, parameters, and the credit math — see our PixVerse video upscale API guide. For current prices across all models, the Modellix pricing page is updated continuously and searchable per model.

FAQ

Is there a free AI video upscale API?

No major provider offers a free API tier. Topaz’s API onboarding is try-without-credit-card, and some platforms offer trial credits, but every upscale request consumes paid capacity — free trials live on consumer apps, not on the API endpoints. Budget a test clip instead.

Which video upscale API guarantees 4K output?

None of them guarantee it for arbitrary input. Topaz and Magnific support 4K-class output; PiAPI caps output at 1080p; PixVerse’s upscale improves resolution without publishing a fixed output resolution. The guarantee depends on the model, the source, and the parameters — verify per request.

How much does it cost to upscale one minute of video?

It depends on the billing unit and frame rate. Using the worked example above (30 fps, 720p source, 2x): PiAPI ≈ $0.54/minute, fal ≈ $1.32/minute, Modellix PixVerse ≈ $2.42/minute. Re-run the arithmetic with your own frame rate and resolution before budgeting.

What input does a video upscale API accept?

A publicly accessible video URL in MP4 (most providers), with provider-specific caps on resolution, file size, and duration — PiAPI is the strictest at 720p input, 10 MB, 10-240 frames, MP4 only.

Topaz API vs RealESRGAN — which is better?

Topaz is better on real-world footage with compression artifacts and motion; RealESRGAN routes are cheaper, more predictable, and fine for clean AI-generated clips. Choose by footage type, not by brand.

Can I upscale video without quality loss?

No — upscaling always adds inferred pixels. The goal is acceptable loss: better models add less visible artifact. There is no lossless 4K upscale; if a vendor implies otherwise, that is marketing.

---

Provider facts in this guide were read from the live official pages on August 12, 2026: Topaz API, fal video-upscaler, PiAPI video upscale docs, Replicate AI-enhance-videos collection, Segmind ESRGAN video upscaler, Magnific video upscaler docs, and Modellix’s API documentation. Pricing, input limits, and model availability change without notice; this article is a dated guide, not a quote. Modellix is an AI model API aggregator and has a commercial interest in the aggregator discussion above.

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