Topaz Labs Proteus 4

Introduction

Proteus 4 is Topaz Labs' general-purpose video enhancement model. You hand it a clip and a target size, and it rebuilds the picture on the way up, clearing compression artefacts, reducing noise, sharpening edges, and reconstructing detail frame by frame. Every repair it makes is measured from the footage itself, so the detail it produces is built out of the signal your clip already carries.

Each of those repairs is a weight, and left alone the model sets all of them from the clip itself. That is the request in its simplest form: a video and a size, with no settings at all.

The vineyard flyover above went in as a compressed 480p export. Foliage is the first thing a low bitrate destroys, since every leaf is fine detail the encoder cannot afford, so drag the handle and the vine rows come back as individual leaves where the source held a green smear, with the gravel tracks and the winery roof resolving alongside them.

This guide covers the request shape, how width and height behave as an envelope, the frame rate floor, and what the model repairs before you touch a single weight. It is the entry point to the set, and the four guides that follow each take one part of settings.

The request

An enhancement pass is one clip in and one clip out, and it runs as an asynchronous video task. Put the source in inputs.video, name the model, and give the output size in width and height.

import { createClient } from '@runware/sdk'

const client = await createClient({ apiKey: process.env.RUNWARE_API_KEY })
await client.connect()

const [result] = await client.run({
  model: 'topazlabs:proteus@4',
  deliveryMethod: 'async',
  width: 1920,
  height: 1080,
  inputs: {
    video: 'https://vm.runware.ai/video/os/a14d18/ws/2/vi/2b3c4d5e-6f70-4819-a2b3-c4d5e6f70819.mp4'
  }
})

import asyncio
import os

from runware import Runware


async def main():
    async with Runware(api_key=os.environ["RUNWARE_API_KEY"]) as client:
        results = await client.run({
            "model": "topazlabs:proteus@4",
            "deliveryMethod": "async",
            "width": 1920,
            "height": 1080,
            "inputs": {
                "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/2b3c4d5e-6f70-4819-a2b3-c4d5e6f70819.mp4"
            }
        })


asyncio.run(main())

curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "upscale",
      "taskUUID": "c4d5e6f7-8a9b-4c0d-9e1f-2a3b4c5d6e7f",
      "model": "topazlabs:proteus@4",
      "deliveryMethod": "async",
      "width": 1920,
      "height": 1080,
      "inputs": {
        "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/2b3c4d5e-6f70-4819-a2b3-c4d5e6f70819.mp4"
      }
    }
  ]'

runware run topazlabs:proteus@4 \
  deliveryMethod=async \
  width=1920 \
  height=1080 \
  inputs.video=https://vm.runware.ai/video/os/a14d18/ws/2/vi/2b3c4d5e-6f70-4819-a2b3-c4d5e6f70819.mp4

{
  "taskType": "upscale",
  "taskUUID": "c4d5e6f7-8a9b-4c0d-9e1f-2a3b4c5d6e7f",
  "model": "topazlabs:proteus@4",
  "deliveryMethod": "async",
  "width": 1920,
  "height": 1080,
  "inputs": {
    "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/2b3c4d5e-6f70-4819-a2b3-c4d5e6f70819.mp4"
  }
}

[
  {
    "taskType": "upscale",
    "taskUUID": "c4d5e6f7-8a9b-4c0d-9e1f-2a3b4c5d6e7f",
    "videoUUID": "9f0a1b2c-3d4e-4f50-8a6b-7c8d9e0f1a2b",
    "videoURL": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/9f0a1b2c-3d4e-4f50-8a6b-7c8d9e0f1a2b.mp4"
  }
]

• inputs.video is the only input. It takes a public URL or the UUID of an earlier Runware task.
• width and height are required on every request and describe an envelope, covered below.
• fps defaults to the source frame rate, which is also its lower bound.
• settings.enhancement holds the mode and the repair weights, covered in tuning the enhancement weights, along with the grain and texture controls covered in keeping grain and texture.
• settings.focusFixLevel rescues out-of-focus subjects, covered in soft and blurred sources.
• settings.videoType and settings.fieldOrder describe how the source frames are laid out, covered in interlaced sources.

Sizing the output

width and height are not a scale factor. They describe an envelope the result fits inside: the source aspect ratio is preserved, so each value is a bound rather than a promise, and the output can come back narrower or shorter than the box you asked for.

The apartment walkthrough below went in at 854 × 480 under a 2048 × 2048 envelope. Width binds first on a 16:9 clip, so the result came back 2048 × 1152 rather than square.

The rug weave and the window frames hold up under the lift because the source still carried them. Ask for the size you actually ship, since an envelope larger than the detail the clip can support spends processing on pixels that arrive soft.

There is a floor as well as a ceiling. Each value must exceed a fifth of the matching source dimension, so a 1920 × 1080 source cannot be sent through at less than 384 × 216 and the model refuses to work as a downscaler. Either edge tops out at 8192.

fps follows the same one-way logic. It defaults to the source frame rate, and that rate is also its lower bound, so a value below it is rejected. Leave it out and the timing of the source comes through untouched.

What auto mode does

With no settings in the payload the model runs in auto and estimates each repair weight from the clip in front of it. The blender packshot below is that request and nothing more, a source and a size with no tuning.

Auto suits footage whose problems are ordinary. It reads the source and sets its own compression recovery, noise reduction, sharpening, and detail level, which is usually the right call for a compressed export or a soft camera original.

Two situations argue for taking the weights over yourself. One is a source with an unusual mix of problems, such as heavy grain that auto reads as detail worth keeping. The other is batch consistency, where a house look repeated across fifty clips matters more than the best possible treatment of any one of them. Both are covered in tuning the enhancement weights.

What it can recover

Proteus rebuilds from the signal that survived, so the state of the source sets the ceiling on the result. The hardware store clip below is deliberately rough, a 360p re-encode carrying sensor noise, closer to a phone upload than a camera original.

The apron weave and the shelf edges firm up and the noise clears out. Look at the face, which is where an aggressive clean-up shows itself first: skin that lost its texture in the source comes back smooth rather than detailed, because there is nothing left to rebuild from.

So enhance before the quality is crushed, not after. A clip that still carries usable detail lifts convincingly, and one that has been through several rounds of re-compression gets cleaner without getting more detailed.

Proteus or Starlight Precise

Runware hosts two Topaz video enhancers, and they work on opposite principles. Proteus 4 is parametric: it measures the footage and applies weighted repairs, and every weight is yours to override. Starlight Precise 2.5 is diffusion-based: it regenerates detail and takes no tuning beyond the output size.

Reach for Proteus when the source has nameable, fixable problems (compression, noise, haloing, interlacing) or when the same treatment has to land identically across a batch. Reach for Starlight when the footage is simply short on detail and you want a model to invent a convincing amount of it.

Where to go next

Everything above runs on the model's own estimates. The rest of the set is settings, one cluster per guide:

• Tuning the enhancement weights covers settings.enhancement: the auto, relative, and manual modes, and the compression, noise, details, and halo weights that repair a damaged source.
• Rescuing soft and out-of-focus footage covers settings.focusFixLevel for a subject that missed focus, with preblur for aliasing and blur for sharpening. Read it before you send focus fix, because it changes what size comes back.
• Enhancing interlaced and tape-sourced footage covers settings.videoType and settings.fieldOrder, which is the first thing to set on anything digitised from tape.
• Keeping grain and texture in an enhanced clip covers prenoise, recoverOriginalDetail, grain, and grainSize, the controls that stop a hard clean-up from looking plastic.

Start with auto on a representative clip, then pick the guide that matches whatever it left behind.

Tips

1. Send a size, not a factor. width and height are required and act as a bounding box, so the result matches the source aspect ratio and may come back smaller than the values you sent.

2. Start with auto. The estimated weights handle ordinary compression and noise well. Move to relative or manual when a clip has a problem auto misreads, or when a batch has to match.

3. Feed it recoverable input. Detail that was destroyed by re-compression does not come back. Run the enhancement on the best version of the footage you hold, not on the copy that has already been through a delivery encode.

4. Watch the faces. Skin is where over-smoothing appears first, and it is the reason to check a result at full size rather than in a preview window.

5. Leave fps out unless you need it. It defaults to the source rate and cannot go below it, so sending it does nothing for a clip you want to keep at its original timing.

6. Tell it what the source is. Interlaced and legacy footage needs settings.videoType set to match, or the model treats fields as frames and the result combs. See interlaced sources.

7. Enhance last. Cut and grade first, then run the enhancement on the finished piece so the rebuilt detail is not thrown away by a later re-encode.

8. Reach for the weights when auto misreads a clip. The estimates handle ordinary damage well, so change them when the footage has an unusual mix of problems or when a batch has to match. See tuning the enhancement weights.