# Provider options

Send a control that only one video provider has, such as a negative prompt.

1. [Find the options a model takes](#1-find-the-options-a-model-takes).
2. [Put them under the provider's name](#2-put-them-under-the-providers-name).
3. [Send the job](#3-send-the-job).
4. [Keep a plain request beside it](#4-keep-a-plain-request-beside-it).

## 1. Find the options a model takes

The common controls, `duration`, `resolution`, `aspect_ratio`, `generate_audio` and `seed`, need no provider option: [Clips](/docs/reference/videos) lists them. Anything else is a provider's own option, under the provider's own name.

A model's `allowed_passthrough_parameters` on the video models list names the options it takes. Their values are in the provider's own documentation. Read on 2026-09-29:

| Models | Provider | Options it takes |
|---|---|---|
| `google/veo-3.1`, `-fast`, `-lite` | `google-vertex` | `negativePrompt`, `enhancePrompt`, `personGeneration`, `conditioningScale`, `aspectRatio` |
| `kwaivgi/kling-v3.0-pro`, `-std` | `atlas-cloud` | `negative_prompt`, `cfg_scale` |
| `kwaivgi/kling-video-o1` | `atlas-cloud` | `negative_prompt` |
| `alibaba/wan-2.6` | `atlas-cloud` | `negative_prompt`, `enable_prompt_expansion`, `shot_type`, `audio`, `size` |
| `alibaba/wan-2.7` | `atlas-cloud` | `negative_prompt`, `prompt_extend`, `audio`, `ratio`, `last_image`, `video`, `videos`, `images` |
| `bytedance/seedance-1-5-pro`, `-2.0`, `-2.0-fast` | `seed` | `watermark`, `req_key` |
| `openai/sora-2-pro` | `openai` | `quality`, `style` |
| `minimax/hailuo-2.3` | `minimax` | `prompt_optimizer`, `fast_pretreatment` |
| `alibaba/wan-3.0`, `-3.0-prime` | `alibaba` | none |

The sample in [Choose a video model](/docs/cookbook/choose-a-video-model) reads every model's list, options included.

## 2. Put them under the provider's name

`provider.options` holds one object per provider, under the provider's name from the table. Only the options of the provider that serves the job are sent to it. Google's options go one level deeper, under `parameters`, as Google's own API takes them.

```json
{
  "provider": {
    "options": {
      "google-vertex": {
        "parameters": {
          "negativePrompt": "blurry, low quality, text on screen"
        }
      }
    }
  }
}
```

## 3. Send the job

The sample asks `google/veo-3.1-lite` for 4 seconds at `720p` in `16:9`, with a negative prompt: what the clip must not show.

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

API_KEY = os.environ["OPENDUNES_API_KEY"]
ADDRESS = "https://opendunes.com/v1/videos"
MODEL = "google/veo-3.1-lite"
PROMPT = "A white jasmine flower opens on a tiled courtyard wall in Algiers"
NEGATIVE = "blurry, low quality, text on screen"

request = urllib.request.Request(
    ADDRESS,
    data=json.dumps(
        {
            "model": MODEL,
            "prompt": PROMPT,
            "duration": 4,
            "resolution": "720p",
            "aspect_ratio": "16:9",
            "provider": {
                "options": {
                    "google-vertex": {
                        "parameters": {"negativePrompt": NEGATIVE},
                    },
                },
            },
        }
    ).encode(),
    headers={
        "Authorization": "Bearer " + API_KEY,
        "Content-Type": "application/json",
    },
)
with urllib.request.urlopen(request) as response:
    job = json.load(response)

print(job["id"], job["status"])
```

```javascript
const API_KEY = process.env.OPENDUNES_API_KEY;
const ADDRESS = "https://opendunes.com/v1/videos";
const MODEL = "google/veo-3.1-lite";
const PROMPT =
  "A white jasmine flower opens on a tiled courtyard wall in Algiers";
const NEGATIVE = "blurry, low quality, text on screen";

const response = await fetch(ADDRESS, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: MODEL,
    prompt: PROMPT,
    duration: 4,
    resolution: "720p",
    aspect_ratio: "16:9",
    provider: {
      options: {
        "google-vertex": {
          parameters: { negativePrompt: NEGATIVE },
        },
      },
    },
  }),
});
const job = await response.json();

console.log(job.id, job.status);
```

```go
package main

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

const (
	address  = "https://opendunes.com/v1/videos"
	model    = "google/veo-3.1-lite"
	prompt   = "A white jasmine flower opens on a tiled courtyard wall " +
		"in Algiers"
	negative = "blurry, low quality, text on screen"
)

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

	body, err := json.Marshal(map[string]any{
		"model":        model,
		"prompt":       prompt,
		"duration":     4,
		"resolution":   "720p",
		"aspect_ratio": "16:9",
		"provider": map[string]any{
			"options": map[string]any{
				"google-vertex": map[string]any{
					"parameters": map[string]string{
						"negativePrompt": negative,
					},
				},
			},
		},
	})
	if err != nil {
		panic(err)
	}

	req, err := http.NewRequest("POST", address, bytes.NewReader(body))
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", "application/json")

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

	var job struct {
		ID     string `json:"id"`
		Status string `json:"status"`
	}
	if err := json.NewDecoder(res.Body).Decode(&job); err != nil {
		panic(err)
	}
	fmt.Println(job.ID, job.Status)
}
```

```bash cURL
ADDRESS="https://opendunes.com/v1/videos"
MODEL="google/veo-3.1-lite"
PROMPT="A white jasmine flower opens on a tiled courtyard wall in Algiers"
NEGATIVE="blurry, low quality, text on screen"

curl "$ADDRESS" \
  -H "Authorization: Bearer $OPENDUNES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "'"$MODEL"'",
    "prompt": "'"$PROMPT"'",
    "duration": 4,
    "resolution": "720p",
    "aspect_ratio": "16:9",
    "provider": {
      "options": {
        "google-vertex": {
          "parameters": {"negativePrompt": "'"$NEGATIVE"'"}
        }
      }
    }
  }'
```

The answer is `202`, with the job's `id` and `status` `pending`. Wait for it and fetch the clip as in [Text to video](/docs/cookbook/text-to-video).

<div class="watch-out">
<p>An option the provider does not know is dropped, with no error. A misspelt name costs you the control, not the job: check the clip, and the name against the table in step 1.</p>
</div>

## 4. Keep a plain request beside it

Options belong to one provider. If your app can move to another video model, keep the common request apart and add a provider's options only when that provider's model is picked. The same clip on `bytedance/seedance-2.0-fast`, with none:

```json
{
  "model": "bytedance/seedance-2.0-fast",
  "prompt": "A white jasmine flower opens on a tiled courtyard wall in Algiers",
  "duration": 4,
  "resolution": "720p",
  "aspect_ratio": "16:9"
}
```

The clip is charged in DA once, when the job reports `completed`, for what its model's page in *Models* lists. A job that ends `failed`, `cancelled` or `expired` charges nothing.
