# Choose a video model

Pick the video model that makes the clip you need.

1. [Name the clip](#1-name-the-clip): its length, size, shape, sound and what it starts from.
2. [Read the video models](#2-read-the-video-models) and keep those that make it.
3. [Compare the ones left](#3-compare-the-ones-left).
4. [Check what it charges for](#4-check-what-it-charges-for) on the model's page.

## 1. Name the clip

A model makes a clip only in the lengths, sizes and shapes it lists. Settle these five before you look at a single model.

| The clip's | Sent as | Example |
|---|---|---|
| length, in seconds | `duration` | `10` |
| size | `resolution` | `1080p` |
| shape | `aspect_ratio` | `9:16`, for a phone story |
| sound | `generate_audio` | `true` |
| starting picture | `frame_images` | a first frame, a last frame, or both |

Every field of the request: [Clips](/docs/reference/videos).

## 2. Read the video models

`GET /v1/videos/models` lists every video model on sale, with what each can make. Reading it is free. The sample keeps the models that make a 10-second clip at `1080p` in `9:16` from a first frame, and prints each one's ID with the provider options it takes.

```python
import json
import os
import urllib.request

API_KEY = os.environ["OPENDUNES_API_KEY"]
ADDRESS = "https://opendunes.com/v1/videos/models"
RESOLUTION = "1080p"
ASPECT_RATIO = "9:16"
FRAME = "first_frame"
DURATION = 10

request = urllib.request.Request(
    ADDRESS,
    headers={"Authorization": "Bearer " + API_KEY},
)
with urllib.request.urlopen(request) as response:
    models = json.load(response)["data"]


def makes(model, field, value):
    return value in (model.get(field) or [])


for model in models:
    if (
        makes(model, "supported_durations", DURATION)
        and makes(model, "supported_resolutions", RESOLUTION)
        and makes(model, "supported_aspect_ratios", ASPECT_RATIO)
        and makes(model, "supported_frame_images", FRAME)
    ):
        print(model["id"], model.get("allowed_passthrough_parameters"))
```

```javascript
const API_KEY = process.env.OPENDUNES_API_KEY;
const ADDRESS = "https://opendunes.com/v1/videos/models";
const RESOLUTION = "1080p";
const ASPECT_RATIO = "9:16";
const FRAME = "first_frame";
const DURATION = 10;

const response = await fetch(ADDRESS, {
  headers: { Authorization: `Bearer ${API_KEY}` },
});
const { data } = await response.json();

const makes = (model, field, value) => (model[field] ?? []).includes(value);

for (const model of data) {
  if (
    makes(model, "supported_durations", DURATION) &&
    makes(model, "supported_resolutions", RESOLUTION) &&
    makes(model, "supported_aspect_ratios", ASPECT_RATIO) &&
    makes(model, "supported_frame_images", FRAME)
  ) {
    console.log(model.id, model.allowed_passthrough_parameters);
  }
}
```

```go
package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"slices"
)

const (
	address     = "https://opendunes.com/v1/videos/models"
	resolution  = "1080p"
	aspectRatio = "9:16"
	frame       = "first_frame"
	duration    = 10
)

type videoModel struct {
	ID          string   `json:"id"`
	Durations   []int    `json:"supported_durations"`
	Resolutions []string `json:"supported_resolutions"`
	Ratios      []string `json:"supported_aspect_ratios"`
	Frames      []string `json:"supported_frame_images"`
	Options     []string `json:"allowed_passthrough_parameters"`
}

func main() {
	apiKey := os.Getenv("OPENDUNES_API_KEY")

	req, err := http.NewRequest("GET", address, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+apiKey)

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	var list struct {
		Data []videoModel `json:"data"`
	}
	if err := json.NewDecoder(res.Body).Decode(&list); err != nil {
		panic(err)
	}

	for _, m := range list.Data {
		if slices.Contains(m.Durations, duration) &&
			slices.Contains(m.Resolutions, resolution) &&
			slices.Contains(m.Ratios, aspectRatio) &&
			slices.Contains(m.Frames, frame) {
			fmt.Println(m.ID, m.Options)
		}
	}
}
```

```bash cURL
ADDRESS="https://opendunes.com/v1/videos/models"
RESOLUTION="1080p"
ASPECT_RATIO="9:16"
FRAME="first_frame"
DURATION=10

curl -s "$ADDRESS" \
  -H "Authorization: Bearer $OPENDUNES_API_KEY" \
  | jq -r --argjson d "$DURATION" --arg r "$RESOLUTION" \
      --arg a "$ASPECT_RATIO" --arg f "$FRAME" '
    .data[]
    | select((.supported_durations // []) | index($d))
    | select((.supported_resolutions // []) | index($r))
    | select((.supported_aspect_ratios // []) | index($a))
    | select((.supported_frame_images // []) | index($f))
    | .id'
```

The cURL tab filters with `jq`.

| Field | Holds |
|---|---|
| `supported_durations` | the clip lengths it makes, in seconds |
| `supported_resolutions` | the sizes it makes |
| `supported_aspect_ratios` | the shapes it makes |
| `supported_frame_images` | the frames it starts or ends on: `first_frame`, `last_frame` |
| `generate_audio` | whether it makes the clip's sound |
| `seed` | whether a `seed` makes a repeat likelier to match |
| `allowed_passthrough_parameters` | the provider's own options it takes: [Provider options](/docs/cookbook/provider-options) |

A field is `null` where the model does not say.

<div class="good-to-know">
<p>No field says whether a model takes reference pictures. Its description does: <a href="/docs/cookbook/reference-pictures">Reference pictures</a> lists the models that name them.</p>
</div>

## 3. Compare the ones left

The two tables below were read from the video models list on 2026-09-29. Models come and go, so run step 2 before you rely on a row.

**The clip's shape**

| The clip needs | Models that make it |
|---|---|
| more than 15 seconds | `alibaba/wan-3.0` and `alibaba/wan-3.0-prime` (up to 30) · `bytedance/seedance-2.5` (up to 30) · `black-forest-labs/flux-3-video` (up to 20) · `openai/sora-2-pro` (up to 20) |
| 4K | `google/veo-3.1` · `google/veo-3.1-fast` · `bytedance/seedance-2.0` |
| 21:9, wide | `bytedance/seedance-2.0`, `-2.0-fast`, `-2.0-mini`, `-2.5`, `-1-5-pro` · `alibaba/happyhorse-1.0`, `-1.1` · `black-forest-labs/flux-3-video` · `minimax/hailuo-3`, `-3-max` |
| 9:16, a phone story | every model that makes a clip from words, but `minimax/hailuo-2.3`, which makes 16:9 only |
| no sound of its own | `minimax/hailuo-2.3` · `minimax/hailuo-3-max` · `runway/gen-4.5`; `alibaba/happyhorse-1.0`, `-1.1` and both `x-ai/grok-imagine-video` models do not say |

**What the clip starts from**

| The clip starts from | Models that take it |
|---|---|
| words only | `openai/sora-2-pro` takes no frame |
| a first frame only | `alibaba/wan-3.0`, `-3.0-prime`, `-2.6` · `alibaba/happyhorse-1.0`, `-1.1` · `minimax/hailuo-2.3` · `runway/gen-4.5` · `x-ai/grok-imagine-video`, `-1.5` |
| a first and a last frame | `google/veo-3.1`, `-fast`, `-lite` · `kwaivgi/kling-v3.0-pro`, `-std`, `kwaivgi/kling-video-o1` · `bytedance/seedance-1-5-pro`, `-2.0`, `-2.0-fast`, `-2.0-mini`, `-2.5` · `alibaba/wan-2.7` · `black-forest-labs/flux-3-video` · `minimax/hailuo-3`, `-3-max` |
| an existing clip, or one photo to animate | `black-forest-labs/flux-video-edit`, `black-forest-labs/flux-video-upscale`, `runway/aleph-2`, `heygen/avatar-iv`: they edit, enlarge or animate, and list no clip length |

A model's own page in *Models* shows its description. Try two or three on the same prompt before you settle on one.

<div class="buttons">
<a href="/models?modality=video" class="button primary">Browse video models</a>
</div>

## 4. Check what it charges for

A clip is charged once, when its job reports `completed`. What counts differs by model, so read it on the model's page in *Models*, or in its `pricing_skus` on the list in step 2, before you settle.

| On these models, read 2026-09-29 | The charge counts |
|---|---|
| most | the seconds of video, at the rate of the size picked and, on some, of `generate_audio` |
| `kwaivgi/kling-v3.0-pro`, `-std` · `alibaba/wan-2.6` | the seconds, at one rate from words and another from a picture |
| `bytedance/seedance-1-5-pro`, `-2.0`, `-2.0-fast`, `-2.0-mini`, `-2.5` | the video tokens made |
| `x-ai/grok-imagine-video`, `-1.5` | the seconds, and each picture sent in |
| `minimax/hailuo-3` | the seconds, and each reference picture |

Sending a job and asking where it stands are free. A job that ends `failed`, `cancelled` or `expired` charges nothing. Where to read the charge: [Video](/docs/video).

<div class="watch-out">
<p>On a model charged by the second, the length drives the price. Make short drafts at a small size, then the final length and size.</p>
</div>

Next: [Text to video](/docs/cookbook/text-to-video).
