Topaz Video AI Video Enhancer: Setup and API Options

The Topaz Video AI video enhancer is desktop software from Topaz Labs that cleans up footage you already have: it removes noise, reduces compression damage, recovers detail and upscales toward 1080p or 4K. It is not a video generator and it does not invent new shots. It takes a file that looks bad and makes it look better, which is a narrower and much more useful job than most AI video marketing suggests.

This post covers what the tool actually repairs, how its pricing is structured, when the free browser tools are enough, and how to do related work from code when you need enhancement inside a pipeline rather than inside an app. There is a complete working example at the end using an API key you can create in a minute.

What the Topaz Video AI video enhancer does

Enhancement software sits between two very different families of model. Generative models like the ones described in the Wikipedia entry on diffusion models start from noise and produce an image from a text prompt. Restoration models start from your pixels and try to predict what the original scene looked like before a cheap sensor, a low bitrate or a bad re-encode got to it. The Topaz Video AI video enhancer belongs firmly in the second family.

Internally it is a set of specialised models rather than a single button. One reviewer summarises the lineup as AI models that sharpen details, remove noise and upscale resolution with precision, and that split matters in practice: the model that fixes a grainy night shot is not the model that fixes a soft 480p DVD rip. Picking the wrong one produces an output that is technically larger and still looks wrong.

Typical capabilities across the product line:

• Upscaling. 2x or 4x resolution increase, with detail reconstructed rather than interpolated. Hosted versions of the model advertise up to 4x upscaling with H.264 and H.265 output.
• Denoising. Sensor grain from low-light shooting, which standard sharpening would otherwise amplify.
• Deblocking. The square artefacts left by aggressive compression, common in anything downloaded from a social platform.
• Frame interpolation. Generating intermediate frames to raise frame rate or produce smooth slow motion.
• Stabilisation and motion handling. Keeping the enhanced result consistent while the camera or subject moves.

That last point is the one people underestimate, and it is the main reason a video enhancer costs more than an image upscaler. Enhancing one frame is a solved problem. Enhancing 1,440 consecutive frames so that the reconstructed texture on someone’s jacket does not shimmer from frame to frame is the hard part. Picsart’s hosted version names this explicitly as keeping motion and colour natural while recovering detail.

Which problems a video enhancer fixes, and which it does not

Before you spend anything, be honest about the source material. Enhancement amplifies whatever signal is present. If the signal is gone, nothing recovers it.

Work well:

• Old camcorder or DV footage at 480p or 576p that is soft but correctly exposed.
• Interview footage shot at a high ISO with visible grain.
• Clips that were uploaded, re-compressed and downloaded again, so the detail is intact but buried under blocking.
• Screen recordings and archival material that need to sit alongside modern 4K footage in the same timeline.

Work badly:

• Motion blur from a slow shutter. The detail was never captured; you only have smear.
• Blown highlights or crushed blacks. Clipped data is not recoverable.
• Severe out-of-focus shots. The model will guess, and the guess will look like a different face.
• Heavily cropped 240p video stretched to 4K. You can make it bigger. You cannot make it detailed.

A good rule: if a human looking at a still frame at 100% zoom can tell what something is, the model can probably sharpen it. If a human cannot, the model is inventing, and inventing is where enhancement starts looking uncanny.

Is the Topaz Video AI video enhancer free?

Partly. Topaz Labs offers browser-based tools that let you run footage through their enhancement models without installing anything, which is how most people first try the Topaz Video AI video enhancer. Free runs come with limits, usually some combination of clip length, output resolution, watermarking or export format. The full desktop application is a paid licence.

I am not going to quote a price here, because licence pricing and promotions change and a stale number in a blog post is worse than no number. Check the vendor directly. What is worth understanding is the shape of the cost, because it determines which option suits you:

Option	Cost shape	Best for
Free web tools	No cost, capped output	Evaluating quality on your own footage before committing
Desktop licence	One payment or subscription, unlimited local runs	Regular restoration work, long files, offline or confidential material
Hosted video model via API	Per job or per second of video	Occasional enhancement inside an automated workflow
Image upscaling via API	Per output image	Stills, thumbnails, poster frames, very short clips

The desktop route has one advantage that pricing tables miss: your footage never leaves your machine, and after the licence is paid, a 90-minute restoration costs nothing but electricity and time. Per-job hosted pricing is the opposite: zero up-front, and an expense that scales linearly with every second of video you push through it. If you are restoring a family archive, buy the licence. If you need enhancement to happen automatically when a file lands in a bucket, you need an API.

Desktop app, web tool or API: how to choose

The honest answer depends on three things: volume, automation and whether your material is actually video.

You want the desktop app when

You are working on long files, you need to compare model outputs frame by frame before committing, you care about keeping footage local, or you are doing this often enough that a licence amortises quickly. Interactive preview is genuinely valuable; choosing the wrong enhancement model is the most common cause of bad results, and an app makes that choice visible.

You want an API when

Enhancement is a step in a larger system. A user uploads a product video, your backend normalises it, and nobody should have to open a GUI. The Topaz Video AI video enhancer as a desktop product does not fit that pattern, which is why hosted versions of Topaz video upscaling exist on several platforms. If you need motion-aware video upscaling specifically, use one of those.

You want an image model when

Your real deliverable is stills. This is more common than people admit: thumbnails pulled from video, a poster frame for a landing page, a product photo extracted from a clip, a title card that needs to be 4K. For all of these, running a full video enhancer is overkill. On Unicorn API, Topaz Upscale Image handles single frames at 10 credits for 2x and 20 credits for 4x per output. Credits on a monthly plan cost $0.01 each, so that is $0.10 and $0.20 per frame, and you can see the exact figure before you run anything.

How to upscale frames with the Topaz model on Unicorn API

Here is the practical pattern. Unicorn API gives you one key and one bill across image, video, audio and chat models, and media models all share the same shape: POST a job, poll it, read the output URL. Create a key at /keys, then check the price before you spend anything:

curl -X POST https://api.unicornapi.net/v1/models/price \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "topaz-image-upscale",
    "input": {
      "image_url": "https://example.com/frame_0001.png",
      "upscale_factor": "4"
    }
  }'

Every request you can make has a price endpoint, so cost is never a surprise. Now the job itself. A single frame upscale looks like this:

curl -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "topaz-image-upscale",
    "input": {
      "image_url": "https://example.com/frame_0001.png",
      "upscale_factor": "2"
    }
  }'

That returns a job with an id and a status. Poll GET /v1/jobs/{id} until status is succeeded, then read outputs[0].url. Wrapped into a frame pipeline in Python:

import os
import subprocess
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {
    "Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}",
    "Content-Type": "application/json",
}


def extract_frames(src, out_dir, fps=24):
    os.makedirs(out_dir, exist_ok=True)
    subprocess.run([
        "ffmpeg", "-i", src,
        "-vf", f"fps={fps}",
        f"{out_dir}/frame_%05d.png",
    ], check=True)
    return sorted(os.listdir(out_dir))


def upscale(image_url, factor="2"):
    """Submit one frame, wait for it, return the output URL."""
    created = requests.post(
        f"{API}/v1/jobs",
        headers=HEADERS,
        json={
            "model": "topaz-image-upscale",
            "input": {"image_url": image_url, "upscale_factor": factor},
        },
        timeout=30,
    )
    created.raise_for_status()
    job_id = created.json()["id"]

    while True:
        job = requests.get(
            f"{API}/v1/jobs/{job_id}", headers=HEADERS, timeout=30
        ).json()
        if job["status"] == "succeeded":
            return job["outputs"][0]["url"]
        if job["status"] == "failed":
            raise RuntimeError(f"job {job_id} failed: {job.get('error')}")
        time.sleep(2)


def download(url, path):
    with requests.get(url, stream=True, timeout=120) as r:
        r.raise_for_status()
        with open(path, "wb") as f:
            for chunk in r.iter_content(1 << 16):
                f.write(chunk)


def enhance_clip(src, out, fps=24, factor="2"):
    frames = extract_frames(src, "frames_in", fps=fps)
    os.makedirs("frames_out", exist_ok=True)

    for i, name in enumerate(frames, start=1):
        # upload_public() is yours: S3, R2, GCS, anything that
        # returns a URL the API can fetch.
        frame_url = upload_public(f"frames_in/{name}")
        result_url = upscale(frame_url, factor=factor)
        download(result_url, f"frames_out/frame_{i:05d}.png")

    subprocess.run([
        "ffmpeg", "-framerate", str(fps),
        "-i", "frames_out/frame_%05d.png",
        "-c:v", "libx264", "-pix_fmt", "yuv420p",
        "-crf", "18", out,
    ], check=True)


if __name__ == "__main__":
    enhance_clip("source.mp4", "enhanced.mp4", fps=24, factor="2")

Two practical notes. The model takes an image_url, so frames must be reachable over HTTP; any object storage bucket with public or signed URLs works. And run the upscale calls concurrently rather than in the serial loop above once you have confirmed quality on a handful of frames, because wall-clock time is dominated by waiting, not computing. A thread pool of eight is a reasonable starting point.

If you would rather see output before writing any code, the same model is in the browser playground at /studio/image, and the full request reference lives in the docs.

Worked example: a 10-second clip, with real numbers

Suppose you have a 10-second 480p clip at 24fps and you want it at 960p. That is 240 frames. At 10 credits per 2x output, the job costs 2,400 credits, which is $24 on a monthly plan where credits are $0.01 each. At 4x it is 4,800 credits, or $48. Top-up credits are $0.015 each and never expire, so the same job on top-ups is $36 or $72. Current plan tiers and credit prices are on the pricing page.

Look at that honestly: $24 for ten seconds is not a video workflow. It is a reminder that per-image pricing and video frame counts multiply badly. The frame-by-frame route is the right tool for:

• Single frames. One poster frame at 4x costs 20 credits, or $0.20. That is the whole job.
• Very short clips. A two-second logo sting at 24fps is 48 frames, around 480 credits at 2x.
• Stills sequences. Stop motion, timelapse at low frame rates, animated title cards.

For anything longer, use the desktop Topaz Video AI video enhancer or a hosted video-native model that prices per second of footage instead of per frame. Picking the cheaper tool is not a compromise here; a video model will also give you better results, because it can smooth across frames in a way that 240 independent image calls cannot.

Mistakes people make with AI video enhancement

Upscaling before denoising

If you enlarge grain, you get bigger grain and the sharpener treats it as detail. Clean first, enlarge second. The desktop Topaz Video AI video enhancer lets you order its models explicitly; respect that order.

Going straight to 4x

4x costs twice as much and is more likely to look synthetic. Try 2x first and compare at the resolution your audience will actually watch. Most footage that looks bad at 480p looks fine at 960p and starts looking artificial at 1920p.

Ignoring temporal consistency

This is the single biggest failure mode of the frame-by-frame approach. An image model reconstructs each frame independently, so skin texture, hair and fabric can be rendered slightly differently every frame. In motion that reads as shimmer. Mitigations: lower the upscale factor, denoise before upscaling, and add a light temporal filter when re-encoding. Or use a video model and skip the problem.

Mismatched frame rate on the way out

If you extract at 24fps and re-encode at 30, your clip plays slow and your audio drifts. Read the source frame rate with ffprobe and use the same value in both commands.

Expecting restoration to replace reshooting

Enhancement buys perhaps one generation of quality: 480p to a decent 1080p, grainy to acceptable. It does not turn phone footage into a cinema camera. If the shot is salvageable, a video enhancer saves it. If it is broken, enhancement makes a sharper version of a broken shot.

Where enhancement fits alongside generated media

Most teams reaching for the Topaz Video AI video enhancer are also generating assets, and it helps to think of both as steps in one pipeline behind a single key. Generation produces the asset, restoration raises its resolution, and both get billed the same way.

On the generation side, Nano Banana 2 Lite handles fast 1K images and edits with up to ten reference images at 4 credits per image, which makes it cheap for iterating on a concept before you commit. GPT Image 1.5 is the choice when you need legible text or an optional transparent background, at 3 credits on low quality, 4 on medium and 15 on high. For editing existing frames rather than creating new ones, Seedream 5.0 Flash Image to Image takes source images plus a prompt at 4 credits per output, and Seedream 5.0 Flash Layer Decomposition splits an image into layers, which is useful when you need to re-composite a frame rather than repaint it.

A realistic composite workflow: generate a 1K title card with Nano Banana 2 Lite for 4 credits, push it through Topaz Upscale Image at 4x for 20 credits, and you have a 4K asset for 24 credits total, about $0.24 on a plan. That is a different economic shape from enhancing minutes of footage, and it is where API pricing wins outright. The rest of the catalogue, including video, audio and chat models, is at /models, and if you work from Cursor or Claude Code you can drive the same endpoints over MCP from /agents.

Bottom line on the Topaz Video AI video enhancer

For actual video restoration, the Topaz Video AI video enhancer is the right class of tool: purpose-built models for denoise, deblock, sharpen, upscale and interpolate, with temporal handling that image upscalers do not have. Try the free web tools on your own worst clip first, because that tells you more than any review will. If the result is good, the licence pays for itself on the first archive project.

For everything adjacent, stills, thumbnails, poster frames, generated assets that need to be 4K, calling an image model from code is cheaper, faster to automate and priced per output so you always know what a job will cost. Check the price endpoint, start at 2x, and only reach for a full video enhancer when you genuinely have motion to preserve.