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

> Referansevideogenerering som basisversjonen, men med opptil 3 tilpassede LoRA-er

Genererer video fra en obligatorisk `prompt` og en referanse-`video_url` for bevegelse og struktur, og krever i tillegg `loras`, opptil 3 LoRA-filer på maksimalt 3 GB hver. Valgfrie bilder av første, midterste og siste nøkkelbilde (`image_url`, `mid_image_url`, `end_image_url`) forankrer utseendet. `video_strength` og `strength` varierer fra 0 to 1, og `num_frames` fra 9 to 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/no/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 |  |  | Prompt som brukes til å styre genereringen. |
| `video_url` | `video` | string (video URL) | yes |  |  | URL som peker til en referansevideo brukt til å veilede bevegelse og struktur. |
| `control_video_url` |  | string (video URL) \| null | no |  |  | Valgfri forhåndsberegnet kontrollvideo, brukt i stedet for innebygd kontrollestimering når den leveres sammen med `skip_control_preprocess`. Den blir det direkte kontrollsignalet etter omprøving for å samsvare med utdataenes dimensjoner og antall bilder. Videoen kan for eksempel inneholde en allerede gjengitt dybde-, kant- eller positurkompositt. |
| `skip_control_preprocess` |  | boolean | no | `false` |  | Direkte kontrollmodus med `control_video_url` i stedet for intern estimering av dybde, kanter eller positur; uten denne URL-en ignoreres innstillingen. Størrelsen på utdata i denne modusen respekterer eksplisitte dimensjoner med 64-justering for å holde RGB- og kontrollvideoene samsvarende, mens `auto` bruker kildens dimensjoner og sideforhold innenfor LTX-begrensningene. |
| `preserve_original_video` |  | boolean | no | `false` |  | Modus for bevaring av originalvideo, kun tilgjengelig med `skip_control_preprocess`, `video_url` og `control_video_url`. Den er deaktivert som standard og lar standard kontrollbehandling være uendret; når den aktiveres, starter genereringen fra `video_url` samtidig som strukturell veiledning fra `control_video_url` beholdes. Denoising gjennom `strength` angir hvor mye som bevares, og lavere innstillinger beholder flere originale piksler. |
| `image_url` | `image` | string (image URL) \| null | no |  |  | Valgfri stil for bildeforankring eller karakteridentitet som nøkkelbilde i første bilde. |
| `mid_image_url` |  | string (image URL) \| null | no |  |  | Valgfritt utseende for bildeforankring nær klippets midtpunkt, som supplerer det innledende `image_url`-nøkkelbildet. Det hjelper utseendet med å følge kamerabevegelsen i stedet for å gli ut; krever `image_url`. |
| `end_image_url` | `end_image` | string (image URL) \| null | no |  |  | Valgfritt utseende for bildeforankring i klippets siste bilde. Nyttig når kamerabevegelsen ender et annet sted enn startbildet; krever `image_url`. |
| `video_strength` |  | number | no | `0.6` | 0 – 1 | Friheten til å endre bevegelse og struktur fra referansevideoen styres av denne betingelsesstyrken: lavere innstillinger tillater større endringer. |
| `strength` |  | number | no | `1` | 0 – 1 | Denoising-kontroll for sampling fra referansevideo til video, med effekt avhengig av `preserve_original_video`. Når modusen er av, forkorter den bare denoise-planen; når den er på, styrer den transformasjonen av kildepikslene, der 1.0 regenererer alt og lavere innstillinger bevarer mer (for eksempel bevarer 0.5 omtrent 50 %). |
| `num_frames` |  | integer | no | `121` | 9 – 481 | Antall bilder i utdata, underlagt et IC-LoRA-stabilitetsbudsjett basert på oppløsning multiplisert med antall bilder. Et 422-svar betyr at budsjettet ble overskredet: reduser oppløsningen eller `num_frames`. Budsjettet tillater omtrent 150 bilder ved dimensjoner i 720p-klassen og flere ved mindre størrelser. |
| `resolution` |  | object {width, height} \| enum (string) | no | `auto` | `auto`, `square_hd`, `square`, `portrait_4_3`, `portrait_16_9`, `landscape_4_3`, `landscape_16_9` | Dimensjoner for utdata-videoen, som også påvirker stabil varighet: mindre størrelser tillater flere bilder, mens større størrelser senker maksimumsverdien. Innebygd kontrollestimering holder størrelsen nær den offisielle kontrollarbeidsflyten; direkte kontroll gjennom `skip_control_preprocess` og `control_video_url` respekterer i stedet eksplisitte dimensjoner med 64-pikslers justering. I direkte kontrollmodus arver `auto` kildens dimensjoner og sideforhold innenfor LTX-begrensningene. |
| `frames_per_second` |  | number | no | `24` | 1 – 60 | Utdataens bildefrekvens for video, målt i bilder per sekund. |
| `num_inference_steps` |  | integer | no | `15` | 8 – 30 | Angi hvor mange inferenssteg som skal kjøres, opptil 30; hvis dette ikke endres, brukes 15. |
| `guidance_scale` |  | number | no | `1` | 1 – 20 | Juster classifier-free guidance med denne skalaen; standardinnstillingen er tilpasset både høy kvalitet og rask generering. |
| `generate_audio` |  | boolean | no | `true` |  | Bryter for lydspor i MP4-filen som returneres: av gir en videofil uten lyd, mens på inkluderer lyd. |
| `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` |  | Negativ prompt som angir hva genereringen skal unngå. |
| `seed` |  | integer \| null | no |  |  | Seed som gjør genereringen reproduserbar. Hvis den settes til None, velges en seed tilfeldig. |
| `enable_prompt_expansion` |  | boolean | no | `true` |  | Styrer om promptutvidelse er aktivert. |
| `enable_safety_checker` |  | boolean | no | `true` |  | Styrer om sikkerhetskontroll er aktivert. |
| `video_quality` |  | enum (string) | no | `high` | `low`, `medium`, `high`, `maximum` | Kvalitetsforvalg som brukes på utdata-videoen. |
| `video_write_mode` |  | enum (string) | no | `balanced` | `fast`, `balanced`, `small` | Skrivemodus for videoen som resultat. |
| `loras` |  | array of object {path, scale, transformer} | yes |  | ≤ 3 items | LoRA-tillegg for LTX-2.3, hvert begrenset til 3 GB, med maksimalt 3 tillatte oppføringer. Innlasting skjer først etter at registerets SSRF-sikre nedlaster har hentet hver bane. |
| `loras[].path` |  | string | yes |  | ≤ 2048 characters | Direkte HTTP(S)-URL til en LoRA .safetensors-fil på maksimalt 3 GB. Innlasting innledes med henting via en SSRF-sikker nedlaster. |
| `loras[].scale` |  | number | no | `1` | 0 – 2 | LoRA-påvirkningen på den genererte videoen øker når denne styrken økes innenfor området 0.0–2.0. |
| `loras[].transformer` |  | enum (string) | no | `both` | `high`, `low`, `both` | Flagg for valg av transformer: 'both' passer nesten alle som bruker LTX-2.3, fordi modellen bare har én transformer. Flagget finnes for å støtte fremtidige arkitekturer med flere transformere. |

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} | Video produsert av modellen. |
| `seed` | integer | Faktisk seed som brukes under genereringen. |
| `prompt` | string | Genereringsprompt, inkludert eventuell utvidelse som er brukt før den tas i bruk. |

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