# Ltx 2.3 Quality · Reference Video to Video · LoRA API

> Etaloninio vaizdo įrašo generavimas kaip bazinėje versijoje, papildomai pritaikant iki 3 pasirinktinių LoRA

Generuoja vaizdo įrašą pagal privalomą `prompt` ir etaloninį `video_url`, skirtą judesiui bei struktūrai, taip pat reikalauja `loras` – iki 3 LoRA failų, kurių kiekvienas gali būti ne didesnis nei 3 GB. Pasirinktiniai pirmojo, vidurinio ir paskutinio pagrindinio kadro vaizdai (`image_url`, `mid_image_url`, `end_image_url`) nustato išvaizdą. `video_strength` ir `strength` reikšmės yra nuo 0 iki 1, o `num_frames` – nuo 9 iki 481.

- Model id: `ltx-2.3-quality/reference-video-to-video/lora`
- Made by: Lightricks
- Category: Video to Video
- Output: video
- Price per megapixel of your output video: $0.00271 / 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/lora`
- Quote: `POST https://api.doitong.ru/v1/quote/ltx-2.3-quality/reference-video-to-video/lora`
- Docs page: https://doitong.com/lt/developers/models/ltx-2.3-quality/reference-video-to-video/lora

## Pricing

Price: **$0.00271 / 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.304 = 304 API credits (112 MP output video × $0.002708).

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/lora` 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 |  |  | Generavimui nukreipti naudojamas raginys. |
| `video_url` | `video` | string (video URL) | yes |  |  | URL, nurodantis orientacinį vaizdo įrašą, naudojamą judesiui ir struktūrai valdyti. |
| `control_video_url` |  | string (video URL) \| null | no |  |  | Pasirinktinis iš anksto apskaičiuotas valdymo vaizdo įrašas, naudojamas vietoj integruoto valdymo įvertinimo, kai pateikiamas kartu su `skip_control_preprocess`. Po keitimo, kad sutaptų išvesties matmenys ir kadrų skaičius, jis tampa tiesioginiu valdymo signalu. Vaizdo įraše, pavyzdžiui, gali būti jau pateiktas gylio, kraštų arba pozos kompozitas. |
| `skip_control_preprocess` |  | boolean | no | `false` |  | Tiesioginis valdymo režimas, naudojantis `control_video_url` vietoj vidinio gylio, kraštų ar pozos įvertinimo; be šio URL nustatymas ignoruojamas. Šiame režime išvesties dydis laikosi aiškiai nurodytų matmenų, sulygiuotų iki 64, kad RGB ir valdymo vaizdo įrašai sutaptų, o `auto` perima šaltinio matmenis ir kraštinių santykį pagal LTX ribas. |
| `preserve_original_video` |  | boolean | no | `false` |  | Originalaus vaizdo įrašo išsaugojimo režimas, pasiekiamas tik su `skip_control_preprocess`, `video_url` ir `control_video_url`. Pagal numatytuosius nustatymus išjungtas, jis palieka standartinį valdymo apdorojimą; įjungus generavimas pradedamas nuo `video_url`, išsaugant struktūrinį valdymą iš `control_video_url`. Triukšmo šalinimas naudojant `strength` nustato išsaugomą dalį: mažesnės reikšmės išsaugo daugiau originalių pikselių. |
| `image_url` | `image` | string (image URL) \| null | no |  |  | Pasirinktinis vaizdo įtvirtinimo stilius arba veikėjo tapatybė kaip pirmojo kadro pagrindinis kadras. |
| `mid_image_url` |  | string (image URL) \| null | no |  |  | Pasirinktinė vaizdo įtvirtinimo išvaizda netoli klipo vidurio, papildanti pradinį `image_url` pagrindinį kadrą. Ji padeda išvaizdai sekti kameros judesį, o ne nukrypti; reikia `image_url`. |
| `end_image_url` | `end_image` | string (image URL) \| null | no |  |  | Pasirinktinė vaizdo įtvirtinimo išvaizda paskutiniame klipo kadre. Naudinga, kai kameros judesys baigiasi kitoje vietoje nei pradinis vaizdas; reikia `image_url`. |
| `video_strength` |  | number | no | `0.6` | 0 – 1 | Laisvę keisti orientacinio vaizdo įrašo judesį ir struktūrą valdo ši sąlygojimo stiprumo reikšmė: mažesnės reikšmės leidžia didesnius pakeitimus. |
| `strength` |  | number | no | `1` | 0 – 1 | Triukšmo šalinimo valdymas orientacinio vaizdo įrašo į vaizdo įrašą atrankai, kurio poveikis priklauso nuo `preserve_original_video`. Kai režimas išjungtas, jis tik sutrumpina triukšmo šalinimo tvarkaraštį; kai įjungtas, valdo šaltinio pikselių transformaciją: 1.0 viską sugeneruoja iš naujo, o mažesnės reikšmės išsaugo daugiau, pvz., 0.5 išsaugo apie 50 %. |
| `num_frames` |  | integer | no | `121` | 9 – 481 | Išvesties kadrų skaičius, ribojamas IC-LoRA stabilumo biudžeto, apskaičiuojamo raišką dauginant iš kadrų skaičiaus. 422 atsakas reiškia, kad biudžetas viršytas: sumažinkite raišką arba `num_frames`. Biudžetas leidžia maždaug 150 kadrų 720p klasės matmenims ir daugiau mažesniems dydžiams. |
| `resolution` |  | object {width, height} \| enum (string) | no | `auto` | `auto`, `square_hd`, `square`, `portrait_4_3`, `portrait_16_9`, `landscape_4_3`, `landscape_16_9` | Išvesties vaizdo įrašo matmenys, taip pat veikiantys stabilią trukmę: mažesni dydžiai leidžia daugiau kadrų, o didesni sumažina maksimumą. Integruotas valdymo įvertinimas išlaiko dydį artimą oficialiai valdymo eigai; tiesioginis valdymas per `skip_control_preprocess` ir `control_video_url` laikosi aiškių matmenų, sulygiuotų iki 64 pikselių. Tiesioginio valdymo režime `auto` perima šaltinio matmenis ir kraštinių santykį pagal LTX ribas. |
| `frames_per_second` |  | number | no | `24` | 1 – 60 | Išvesties vaizdo įrašo kadrų dažnis, matuojamas kadrais per sekundę. |
| `num_inference_steps` |  | integer | no | `15` | 8 – 30 | Nustatykite, kiek vykdyti išvedimo žingsnių (iki 30); nepakeitus naudojama 15. |
| `guidance_scale` |  | number | no | `1` | 1 – 20 | Šia skale koreguokite classifier-free guidance; numatytasis derinimas skirtas aukštai kokybei ir sparčiam generavimui. |
| `generate_audio` |  | boolean | no | `true` |  | Grąžinamo MP4 garso takelio perjungiklis: išjungus sukuriamas tik vaizdo failas, o įjungus įtraukiamas garsas. |
| `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` |  | Neigiamas raginys, nurodantis, ko generuojant reikia vengti. |
| `seed` |  | integer \| null | no |  |  | Generavimą atkurianti pradinė reikšmė. Nustačius None, ji parenkama atsitiktinai. |
| `enable_prompt_expansion` |  | boolean | no | `true` |  | Valdo, ar įjungtas raginio išplėtimas. |
| `enable_safety_checker` |  | boolean | no | `true` |  | Valdo, ar įjungtas saugos tikrinimas. |
| `video_quality` |  | enum (string) | no | `high` | `low`, `medium`, `high`, `maximum` | Išvesties vaizdo įrašui taikomas kokybės išankstinis nustatymas. |
| `video_write_mode` |  | enum (string) | no | `balanced` | `fast`, `balanced`, `small` | Gauto vaizdo įrašo įrašymo režimas. |
| `loras` |  | array of object {path, scale, transformer} | yes |  | ≤ 3 items | LTX-2.3 skirtos LoRA papildomos reikšmės, kiekviena ne didesnė nei 3 GB; leidžiami ne daugiau kaip 3 įrašai. Įkeliama tik registrui SSRF saugiu atsisiuntikliu gavus kiekvieną kelią. |
| `loras[].path` |  | string | yes |  | ≤ 2048 characters | Tiesioginis HTTP(S) URL į ne didesnį nei 3 GB LoRA .safetensors failą. Prieš įkėlimą jis gaunamas naudojant SSRF saugų atsisiuntiklį. |
| `loras[].scale` |  | number | no | `1` | 0 – 2 | LoRA įtaka generuojamam vaizdo įrašui didėja stiprumui kylant 0.0–2.0 intervale. |
| `loras[].transformer` |  | enum (string) | no | `both` | `high`, `low`, `both` | Transformerio pasirinkimo vėliavėlė: 'both' tinka beveik visiems LTX-2.3 naudotojams, nes modelis turi tik vieną transformerį. Vėliavėlė skirta būsimoms architektūroms su keliais transformeriais palaikyti. |

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
{
  "loras": [
    {
      "path": "https://example.com/your-file.safetensors"
    }
  ],
  "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
{
  "loras": [
    {
      "path": "https://example.com/your-file.safetensors"
    }
  ],
  "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/lora?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "loras": [
      {
        "path": "https://example.com/your-file.safetensors"
      }
    ],
    "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/lora?wait=20", {
  method: "POST",
  headers,
  body: JSON.stringify({
    "loras": [
      {
        "path": "https://example.com/your-file.safetensors"
      }
    ],
    "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 = {
    "loras": [
        {
            "path": "https://example.com/your-file.safetensors",
        },
    ],
    "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/lora", 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/lora",
      "input": {
        "loras": [
          {
            "path": "https://example.com/your-file.safetensors"
          }
        ],
        "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/lora",
  "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": 304,
    "usd": "0.304",
    "charged": 304,
    "refunded": 0
  },
  "input": {
    "loras": [
      {
        "path": "https://example.com/your-file.safetensors"
      }
    ],
    "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} | Modelio sukurtas vaizdo įrašas. |
| `seed` | integer | Generuojant pritaikyta tikroji pradinė reikšmė. |
| `prompt` | string | Generavimo raginys, įskaitant prieš naudojimą pritaikytą išplėtimą. |

## 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/lora
- 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/lora
- 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/lora