> For the complete documentation index, see [llms.txt](https://developer.topazlabs.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developer.topazlabs.com/getting-started/model-pricing/video-models.md).

# Video Models

Learn how video models are priced

Video models are priced in one of two major ways, depending on the model.

## Per Output Frame

Many of our models are priced by the **number of output frames**, with one rate for 1080p output and one for 4K:

```
credit rate per frame = 1 ÷ frames per credit for the output resolution
credits = ceil(output frames × credit rate per frame)
```

**Example:** a 10-second clip at 30 fps is 300 frames at the Generative rate

```
credits for 1080p output = ceil(300 × 1/26.0417) = 12
credits for 4K output    = ceil(300 × 1/11.9179) = 26
```

Models under this pricing schema include [Generative Upscaling](/video-models/upscaling-and-enhancement/generative.md), [Creative Upscaling](/video-models/upscaling-and-enhancement/creative.md), and many other models.

## Per Generated Gigapixel and Frame Count

### Frame interpolation

Frame interpolation models are priced by **output frame count, output/input fps ratio, and slow motion factor**. For the [Chronos](/video-models/frame-interpolation/chronos.md) models and for requests where there is no slow motion factor (`slowmo = 1`) and the fps ratio (`output fps / input fps`) is 2 or less, the credit cost is per generated gigapixel. For requests where slow motion factor is greater than 1 or the fps ratio is greater than 2, credit cost is based on the model's multiplier.

| Model       | Multiplier |
| ----------- | ---------- |
| Apollo Fast | 2          |
| Apollo      | 4          |
| Aion        | 8          |

#### Chronos or Per Generated Gigapixel

```
output frame count = fps ratio * slowmo * input frame count
generated frames = abs(output frame count - input frame count)
GP = generated frames * input width * input height / 1024³
credits = ceil(GP)
```

**Example:** converting a 10-second 1080p 24fps video to 30fps

```
output frame count = 30/24 * 1 * 240
generated frames = abs(300 - 240)
GP = 60 * 1920 * 1080 / 1024³
credits = ceil(0.116) = 1
```

#### With slow motion or fps ratio greater than 2

```
GP = input frame count * input width * input height / 1024³
credits = ceil(model multiplier * GP)
```

**Example:** converting a 10-second 1080p 24fps video to 60fps with 2x slow motion using [Apollo](/video-models/frame-interpolation/apollo.md)

```
GP = 240 * 1920 * 1080 / 1024³
credits = 4
```

### Upscaling

Precision upscaling, denoise, and HDR video models are priced at 2 credits per gigapixel and varies by **frame count and output/input resolution ratio**. The input dimensions are multiplied by a fixed scale step (1×, 2× or 4×) that's rounded up from the ratio between the input video's resolution and the desired output resolution. For [denoise](/video-models/denoising.md) and [HDR](broken://pages/pynlBq3VnAH5Jtzxa90F) models that do not perform upscaling, 1x scale step is used.

**1. Find the Scale Step**

```
scale = max(output width / input width, output height / input height)
```

| Actual scale       | Billed scale step |
| ------------------ | ----------------- |
| 1.2 or less        | 1×                |
| Over 1.2 up to 2.4 | 2×                |
| Over 2.4           | 4×                |

**2. Calculate Gigapixels and Credits**

```
GP      = (input width * step) * (input height * step) * frame count / 1024³
credits = ceil(2 * GP)
```

**Example:** a 10-second, 30 fps clip upscaled from 720p to 1080p

```
scale   = max(1920/1280, 1080/720) = 1.5  →  step 2
GP      = (1280 * 2) * (720 * 2) * 300 / 1024³ ≈ 1.03
credits = ceil(2 * 1.03) = 3
```

**Estimated Credits at 30 fps**

| Input → Output | Step | 10 s | 1 min | 5 min | 10 min |
| -------------- | ---- | ---- | ----- | ----- | ------ |
| 480p → 1080p   | 4×   | 4    | 20    | 97    | 194    |
| 720p → 1080p   | 2×   | 3    | 13    | 65    | 129    |
| 720p → 4K      | 4×   | 9    | 52    | 258   | 515    |
| 1080p → 4K     | 2×   | 5    | 29    | 145   | 290    |

### Data cost

For these models, there is also a data cost of 1 credit per GiB of output file size, which is dependent on the bitrate and frame count. The raw fractional cost is added to the processing cost calculations above, before the ceiling function, and is usually a small portion of the overall cost.

Example data costs for a 30fps video using H265:

| Output resolution | Output setting           | 10 s  | 1 min | 5 min | 10 min |
| ----------------- | ------------------------ | ----- | ----- | ----- | ------ |
| 1080p             | Constant 16m             | 0.019 | 0.112 | 0.56  | 1.12   |
| 1080p             | Low dynamic compression  | 0.032 | 0.191 | 0.96  | 1.91   |
| 1080p             | High dynamic compression | 0.048 | 0.287 | 1.43  | 2.87   |
| 4K                | Constant 80m             | 0.093 | 0.559 | 2.79  | 5.59   |
| 4K                | Low dynamic compression  | 0.128 | 0.765 | 3.82  | 7.65   |
| 4K                | High dynamic compression | 0.191 | 1.147 | 5.74  | 11.47  |

## Combining Video Models

When a request has more than one model in `filters`, each model is priced on its own output, and its output properties (frame count, resolution, etc) are used as inputs in the calculations for subsequent models.

**Example:** upscaling a 10-second 720p 24fps video to 1080p with [Proteus](/video-models/upscaling-and-enhancement/precision/proteus.md) (`prob-4`), then converting to 30fps with [Apollo](/video-models/frame-interpolation/apollo.md) (`apo-8`)

```
# 1. Proteus (prob-4): 720p → 1080p (240 frames)
scale           = max(1920/1280, 1080/720) = 1.5  →  step 2
GP_proteus      = (1280 * 2) * (720 * 2) * 240 / 1024³ ≈ 0.82
credits_proteus = ceil(2 * 0.82) = 2

# 2. Apollo (apo-8): 24fps → 30fps at 1080p (240 frames from Proteus)
output frame count = 30/24 * 1 * 240 = 300
generated frames   = abs(300 - 240) = 60
GP_apollo          = 60 * 1920 * 1080 / 1024³ ≈ 0.116
credits_apollo     = ceil(0.116) = 1

# Total
credits = 2 + 1 = 3
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://developer.topazlabs.com/getting-started/model-pricing/video-models.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.