# Ltx 2.3 Quality · Reference Video to Video API

> Génération pilotée par une invite et guidée par une vidéo de référence, avec images-clés de début, du milieu et de fin facultatives

Crée une nouvelle vidéo à partir d'un `prompt` obligatoire et d'une `video_url` de référence qui fournit le mouvement et la structure. Les `image_url`, `mid_image_url` et `end_image_url` facultatifs définissent l'apparence au début, au milieu et à la fin. `video_strength` et `strength` (tous deux de 0 à 1) contrôlent le degré de fidélité ou de conservation de la source, et `control_video_url` peut fournir un signal de contrôle précalculé. `resolution` propose des préréglages automatiques ou fixes, notamment carré et portrait ou paysage 16:9.

- Model id: `ltx-2.3-quality/reference-video-to-video`
- Made by: Lightricks
- Category: Video to Video
- Output: video
- Price per megapixel of your output video: $0.00241 / megapixel of output video (cheapest run $0.003 (3 API credits))
- Run: `POST https://api.doitong.ru/v1/run/ltx-2.3-quality/reference-video-to-video`
- Quote: `POST https://api.doitong.ru/v1/quote/ltx-2.3-quality/reference-video-to-video`
- Docs page: https://doitong.com/fr-FR/developers/models/ltx-2.3-quality/reference-video-to-video

## Pricing

Price: **$0.00241 / megapixel of output video**. Price per megapixel of your output video: the input files are measured before the run (length, resolution, frame rate). The quote measures the same files and is exactly what the run charges.

The full example input below costs $0.27 = 270 API credits (112 MP output video × $0.002408).

Prices are the upstream price in USD, paid from the API balance in API credits (1000 API credits = 1 USD). `POST https://api.doitong.ru/v1/quote/ltx-2.3-quality/reference-video-to-video` with the same JSON body returns the exact price for that input; the quote is exactly what a run charges. Invalid input is never charged and failed or canceled requests are refunded automatically.

## Input parameters

Send either the canonical name or the native field name (not both). Canonical names are the same across models.

| Parameter | Canonical name | Type | Required | Default | Allowed values / range | Description |
|---|---|---|---|---|---|---|
| `prompt` |  | string | yes |  |  | Invite utilisée pour orienter la génération. |
| `video_url` | `video` | string (video URL) | yes |  |  | URL pointant vers une vidéo de référence utilisée pour guider le mouvement et la structure. |
| `control_video_url` |  | string (video URL) \| null | no |  |  | Vidéo de contrôle précalculée facultative, utilisée à la place de l’estimation de contrôle intégrée lorsqu’elle est fournie avec `skip_control_preprocess`. Elle devient le signal de contrôle direct après rééchantillonnage pour correspondre aux dimensions de sortie et au nombre d’images. La vidéo peut par exemple contenir une composition de profondeur, de contours ou de pose déjà rendue. |
| `skip_control_preprocess` |  | boolean | no | `false` |  | Mode de contrôle direct utilisant `control_video_url` au lieu d’estimer la profondeur, les contours ou la pose en interne ; sans cette URL, ce paramètre est ignoré. Dans ce mode, les dimensions explicites sont respectées avec un alignement sur 64 pour maintenir la correspondance entre les vidéos RGB et de contrôle, tandis que `auto` reprend les dimensions et le rapport d’aspect de la source dans les limites de LTX. |
| `preserve_original_video` |  | boolean | no | `false` |  | Mode de conservation de la vidéo d’origine, disponible uniquement avec `skip_control_preprocess`, `video_url` et `control_video_url`. Désactivé par défaut, il conserve le traitement de contrôle standard ; lorsqu’il est activé, la génération commence à partir de `video_url` tout en conservant le guidage structurel de `control_video_url`. Le débruitage via `strength` définit la quantité conservée ; les valeurs faibles préservent davantage de pixels d’origine. |
| `image_url` | `image` | string (image URL) \| null | no |  |  | Style d’ancrage d’image ou identité de personnage facultatif utilisé comme image clé de la première image. |
| `mid_image_url` |  | string (image URL) \| null | no |  |  | Apparence d’ancrage d’image facultative vers le milieu du clip, en complément de l’image clé initiale `image_url`. Elle aide l’apparence à suivre le mouvement de la caméra plutôt qu’à dériver ; nécessite `image_url`. |
| `end_image_url` | `end_image` | string (image URL) \| null | no |  |  | Apparence d’ancrage d’image facultative à la dernière image du clip. Utile lorsque le mouvement de la caméra se termine à un emplacement différent de celui de l’image de départ ; nécessite `image_url`. |
| `video_strength` |  | number | no | `0.6` | 0 – 1 | La liberté de modifier le mouvement et la structure de la vidéo de référence est contrôlée par cette intensité de conditionnement : les valeurs faibles autorisent davantage de changements. |
| `strength` |  | number | no | `1` | 0 – 1 | Contrôle du débruitage pour l’échantillonnage vidéo-à-vidéo de référence, dont l’effet dépend de `preserve_original_video`. Lorsque ce mode est désactivé, il raccourcit simplement le calendrier de débruitage ; lorsqu’il est activé, il contrôle la transformation des pixels sources : 1.0 régénère tout et les valeurs plus faibles en préservent davantage, par exemple 0.5 en conserve environ 50 %. |
| `num_frames` |  | integer | no | `121` | 9 – 481 | Nombre d’images de sortie, soumis à un budget de stabilité IC-LoRA basé sur la résolution multipliée par le nombre d’images. Une réponse 422 signifie que ce budget a été dépassé : réduisez la résolution ou `num_frames`. Le budget autorise environ 150 images pour des dimensions de classe 720p, et davantage pour des tailles inférieures. |
| `resolution` |  | object {width, height} \| enum (string) | no | `auto` | `auto`, `square_hd`, `square`, `portrait_4_3`, `portrait_16_9`, `landscape_4_3`, `landscape_16_9` | Dimensions de la vidéo de sortie, qui influencent également la durée stable : les petites tailles autorisent davantage d’images, tandis que les grandes réduisent le maximum. L’estimation de contrôle intégrée conserve une taille proche du flux de contrôle officiel ; le contrôle direct via `skip_control_preprocess` et `control_video_url` respecte plutôt les dimensions explicites avec un alignement sur 64px. En mode de contrôle direct, `auto` reprend les dimensions et le rapport d’aspect de la source dans les limites de LTX. |
| `frames_per_second` |  | number | no | `24` | 1 – 60 | Fréquence d’images de la vidéo de sortie, mesurée en images par seconde. |
| `num_inference_steps` |  | integer | no | `15` | 8 – 30 | Définissez le nombre de pas d’inférence à exécuter, jusqu’à 30 ; laisser ce réglage inchangé utilise 15. |
| `guidance_scale` |  | number | no | `1` | 1 – 20 | Ajustez le classifier-free guidance avec cette échelle ; son réglage par défaut vise à la fois une qualité élevée et une génération rapide. |
| `generate_audio` |  | boolean | no | `true` |  | Option de piste audio pour le MP4 renvoyé : désactivée, elle produit un fichier vidéo sans audio ; activée, elle inclut l’audio. |
| `negative_prompt` |  | string | no | `color distortion, overexposure, static, blurry details, subtitles, style, artwork, painting, frame, still, dim overall tone, worst quality, low quality, JPEG compression artifacts, ugly, mutilated, extra fingers, poorly drawn hands, poorly drawn face, deformed, disfigured, malformed limbs, fused fingers, motionless frame, cluttered background, three legs, crowded background, walking backwards` |  | Invite négative indiquant ce que la génération doit éviter. |
| `seed` |  | integer \| null | no |  |  | Graine qui rend la génération reproductible. La définir sur None sélectionne une graine aléatoirement. |
| `enable_prompt_expansion` |  | boolean | no | `true` |  | Contrôle l’activation de l’expansion de l’invite. |
| `enable_safety_checker` |  | boolean | no | `true` |  | Contrôle l'activation de la vérification de sécurité. |
| `video_quality` |  | enum (string) | no | `high` | `low`, `medium`, `high`, `maximum` | Préréglage de qualité appliqué à la vidéo de sortie. |
| `video_write_mode` |  | enum (string) | no | `balanced` | `fast`, `balanced`, `small` | Mode d’écriture de la vidéo résultante. |

File parameters (`video`, `control_video_url`, `image`, `mid_image_url`, `end_image`) take a public `https://` URL, a `data:` URI up to 10 MB, or the `file_url` of an upload from `POST /files`.

## Example input

Required parameters only:

```json
{
  "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
  "video": "https://content.doitong.com/video/showcase/v3/gen_fox_cartoon.mp4"
}
```

A fuller example:

```json
{
  "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
  "video_url": "https://content.doitong.com/video/showcase/v3/gen_fox_cartoon.mp4"
}
```

## Run it

Set `DOITONG_API_KEY` to a key from https://doitong.com/developers/dashboard#keys. `?wait=20` returns the finished request in the same call when it is ready within 20 seconds; otherwise poll `GET /requests/{id}` (it also accepts `?wait=`), or pass `webhook_url`.

### curl

```bash
# Run the model; wait up to 20 s for the finished result in the same call
curl -X POST "https://api.doitong.ru/v1/run/ltx-2.3-quality/reference-video-to-video?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
    "video_url": "https://content.doitong.com/video/showcase/v3/gen_fox_cartoon.mp4"
  }'

# Still "queued" or "running"? Poll with the id from the response:
curl "https://api.doitong.ru/v1/requests/REQUEST_ID?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY"
```

### JavaScript

```javascript
const API = "https://api.doitong.ru/v1";
const headers = {
  "Authorization": "Bearer " + process.env.DOITONG_API_KEY,
  "Content-Type": "application/json",
};

// Run the model; wait up to 20 s for the finished result in the same call
let res = await fetch(API + "/run/ltx-2.3-quality/reference-video-to-video?wait=20", {
  method: "POST",
  headers,
  body: JSON.stringify({
    "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
    "video_url": "https://content.doitong.com/video/showcase/v3/gen_fox_cartoon.mp4"
  }),
});
let request = await res.json();
if (!res.ok) throw new Error(request.error.code + ": " + request.error.message);

// Not finished yet: long-poll until it is
while (request.status === "queued" || request.status === "running") {
  res = await fetch(API + "/requests/" + request.id + "?wait=20", { headers });
  request = await res.json();
}
if (request.status !== "succeeded") throw new Error(JSON.stringify(request.error));
console.log(request.outputs.map((o) => o.url), request.cost.credits + " API credits ($" + request.cost.usd + ")");
```

### Python

```python
import os
import requests

API = "https://api.doitong.ru/v1"
headers = {"Authorization": "Bearer " + os.environ["DOITONG_API_KEY"]}

payload = {
    "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
    "video_url": "https://content.doitong.com/video/showcase/v3/gen_fox_cartoon.mp4",
}

# Run the model; wait up to 20 s for the finished result in the same call
r = requests.post(API + "/run/ltx-2.3-quality/reference-video-to-video", params={"wait": 20}, json=payload, headers=headers)
request = r.json()
if not r.ok:
    raise RuntimeError(request["error"]["code"] + ": " + request["error"]["message"])

# Not finished yet: long-poll until it is
while request["status"] in ("queued", "running"):
    request = requests.get(API + "/requests/" + request["id"], params={"wait": 20}, headers=headers).json()
if request["status"] != "succeeded":
    raise RuntimeError(request["error"])
print([o["url"] for o in request["outputs"]], request["cost"]["credits"], "API credits", "$" + request["cost"]["usd"])
```

### MCP

The MCP server at `https://api.doitong.ru/v1/mcp` exposes the tools `search_models`, `get_model`, `quote`, `run`, `get_request`, `cancel_request`, `list_requests`, `create_upload` and `get_account`. A `run` call for this model:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "run",
    "arguments": {
      "model_id": "ltx-2.3-quality/reference-video-to-video",
      "input": {
        "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
        "video_url": "https://content.doitong.com/video/showcase/v3/gen_fox_cartoon.mp4"
      },
      "wait_seconds": 20
    }
  }
}
```

## Response

Every call returns a request object. `status` is one of `queued`, `running`, `succeeded`, `failed`, `canceled`. `outputs` lists the generated files with URLs on our storage (kept forever, or 7 days with `?storage=temporary`; `storage` says which); `output` is the model's own result object with the same URLs.

```json
{
  "id": "req_8k2m4q7x1z9c3v5b6n0p2r4t",
  "object": "request",
  "model": "ltx-2.3-quality/reference-video-to-video",
  "status": "succeeded",
  "created_at": "2026-10-20T12:00:00Z",
  "started_at": "2026-10-20T12:00:02Z",
  "completed_at": "2026-10-20T12:00:09Z",
  "queue_position": null,
  "cost": {
    "credits": 270,
    "usd": "0.27",
    "charged": 270,
    "refunded": 0
  },
  "input": {
    "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
    "video_url": "https://content.doitong.com/video/showcase/v3/gen_fox_cartoon.mp4"
  },
  "output": {
    "video": {
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.mp4",
      "content_type": "video/mp4",
      "file_name": "0-output.mp4",
      "file_size": 1843200
    },
    "seed": 42,
    "prompt": "string"
  },
  "outputs": [
    {
      "type": "video",
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.mp4",
      "content_type": "video/mp4",
      "file_size": 1843200,
      "width": 1280,
      "height": 720,
      "duration": 5,
      "stored": true
    }
  ],
  "error": null,
  "metrics": {
    "inference_seconds": 6.8
  },
  "urls": {
    "self": "https://api.doitong.ru/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t",
    "cancel": "https://api.doitong.ru/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t/cancel"
  }
}
```

### Output fields (`output`)

| Field | Type | Description |
|---|---|---|
| `video` | object {url, content_type, file_name, file_size} | Vidéo produite par le modèle. |
| `seed` | integer | Seed effectivement appliquée pendant la génération. |
| `prompt` | string | Invite de génération, y compris toute expansion appliquée avant son utilisation. |

## Related models

- [Ltx 2.3 Quality · Text to Video](https://doitong.com/developers/models/ltx-2.3-quality/text-to-video.md) (`ltx-2.3-quality/text-to-video`): $0.00241 / megapixel of output video
- [Ltx 2.3 Quality · Text to Video · LoRA](https://doitong.com/developers/models/ltx-2.3-quality/text-to-video/lora.md) (`ltx-2.3-quality/text-to-video/lora`): $0.00271 / megapixel of output video
- [Ltx 2.3 Quality · Image to Video](https://doitong.com/developers/models/ltx-2.3-quality/image-to-video.md) (`ltx-2.3-quality/image-to-video`): $0.00241 / megapixel of output video
- [Ltx 2.3 Quality · Image to Video · LoRA](https://doitong.com/developers/models/ltx-2.3-quality/image-to-video/lora.md) (`ltx-2.3-quality/image-to-video/lora`): $0.00271 / megapixel of output video
- [Ltx 2.3 Quality · Ingredient](https://doitong.com/developers/models/ltx-2.3-quality/ingredient.md) (`ltx-2.3-quality/ingredient`): $0.00241 / megapixel of output video
- [Ltx 2.3 Quality · Clean Plate](https://doitong.com/developers/models/ltx-2.3-quality/clean-plate.md) (`ltx-2.3-quality/clean-plate`): $0.00241 / megapixel of output video
- [Ltx 2.3 Quality · Colorization](https://doitong.com/developers/models/ltx-2.3-quality/colorization.md) (`ltx-2.3-quality/colorization`): $0.00241 / megapixel of output video
- [Ltx 2.3 Quality · Cross Eyed](https://doitong.com/developers/models/ltx-2.3-quality/cross-eyed.md) (`ltx-2.3-quality/cross-eyed`): $0.00241 / megapixel of output video

## Links

- HTML page: https://doitong.com/developers/models/ltx-2.3-quality/reference-video-to-video
- All models and guides for AI agents: https://doitong.com/developers/llms.txt
- OpenAPI 3.1 with this model's typed request body: https://doitong.com/developers/openapi.json?model=ltx-2.3-quality/reference-video-to-video
- Errors: https://doitong.com/developers/docs/errors
- Model details as JSON: https://api.doitong.ru/v1/models/ltx-2.3-quality/reference-video-to-video