---
title: Upscaling and enhancing video with Proteus 4 — Topaz Labs Proteus 4 | Runware Docs
url: https://runware.ai/docs/models/topazlabs-proteus-4/guides/upscaling-video
description: "How to upscale and enhance video with Topaz Proteus 4: the request shape, width and height as an envelope, the frame rate floor, and what auto mode repairs on its own."
---
### [Introduction](https://runware.ai/docs/models/topazlabs-proteus-4/guides/upscaling-video#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.

**Source**:

[Watch video](https://runware.ai/docs/assets/source-vineyard.BspfgQRs.mp4)

**Enhanced**:

[Watch video](https://runware.ai/docs/assets/output-vineyard.BoiAVPCR.mp4)

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](https://runware.ai/docs/models/topazlabs-proteus-4/guides/upscaling-video#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`.

**TypeScript**:

```typescript
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'
  }
})
```

**Python**:

```python
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**:

```bash
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"
      }
    }
  ]'
```

**CLI**:

```bash
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
```

**JSON**:

```json
{
  "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"
  }
}
```

**Response**:

```json
[
  {
    "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](https://runware.ai/docs/models/topazlabs-proteus-4/guides/enhancement-weights), along with the grain and texture controls covered in [keeping grain and texture](https://runware.ai/docs/models/topazlabs-proteus-4/guides/grain-and-texture).
- `settings.focusFixLevel` rescues **out-of-focus subjects**, covered in [soft and blurred sources](https://runware.ai/docs/models/topazlabs-proteus-4/guides/soft-and-blurred-sources).
- `settings.videoType` and `settings.fieldOrder` describe how the source frames are laid out, covered in [interlaced sources](https://runware.ai/docs/models/topazlabs-proteus-4/guides/interlaced-sources).

> [!NOTE]
> Sending no `settings` at all runs the model in `auto`, where it estimates every weight itself. The moment you supply one weight you also have to set `settings.enhancement.mode` to `relative` or `manual`, because `auto` accepts no weights and the request is rejected with a validation error.

### [Sizing the output](https://runware.ai/docs/models/topazlabs-proteus-4/guides/upscaling-video#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.

**Source**:

[Watch video](https://runware.ai/docs/assets/source-apartment.DZJ4EPQ-.mp4)

**Enhanced**:

[Watch video](https://runware.ai/docs/assets/output-apartment.DWrjloif.mp4)

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](https://runware.ai/docs/models/topazlabs-proteus-4/guides/upscaling-video#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.

**Source**:

[Watch video](https://runware.ai/docs/assets/source-blender.CHeMIMl6.mp4)

**Enhanced**:

[Watch video](https://runware.ai/docs/assets/output-blender.WzJN69_p.mp4)

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](https://runware.ai/docs/models/topazlabs-proteus-4/guides/enhancement-weights).

### [What it can recover](https://runware.ai/docs/models/topazlabs-proteus-4/guides/upscaling-video#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.

**Source**:

[Watch video](https://runware.ai/docs/assets/source-founder.0zGLhVCD.mp4)

**Enhanced**:

[Watch video](https://runware.ai/docs/assets/output-founder.BMd4cra1.mp4)

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](https://runware.ai/docs/models/topazlabs-proteus-4/guides/upscaling-video#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](https://runware.ai/docs/models/topazlabs-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](https://runware.ai/docs/models/topazlabs-proteus-4/guides/upscaling-video#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](https://runware.ai/docs/models/topazlabs-proteus-4/guides/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](https://runware.ai/docs/models/topazlabs-proteus-4/guides/soft-and-blurred-sources)** 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](https://runware.ai/docs/models/topazlabs-proteus-4/guides/interlaced-sources)** 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](https://runware.ai/docs/models/topazlabs-proteus-4/guides/grain-and-texture)** 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](https://runware.ai/docs/models/topazlabs-proteus-4/guides/upscaling-video#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](https://runware.ai/docs/models/topazlabs-proteus-4/guides/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](https://runware.ai/docs/models/topazlabs-proteus-4/guides/enhancement-weights).