# LTX-2.3 22B Video Trainer API

> Addestra una LoRA LTX-2.3 22B per stili ed effetti video personalizzati, con audio facoltativo

Addestra una LoRA sul modello LTX-2.3 22B per stili ed effetti personalizzati a partire da uno zip di video o immagini, idealmente con 10 o più file. `number_of_steps` varia da 100 a 6000 (predefinito 2000), `frame_rate` è 25 per impostazione predefinita e `first_frame_conditioning_p` è 0.5 per impostazione predefinita. `with_audio` forza o disabilita l'addestramento audio e `generate_audio_in_validation` controlla l'audio nelle anteprime.

- Model id: `ltx23-video-trainer`
- Made by: Lightricks
- Category: Training
- Output: file
- Price: $0.0048 / step (cheapest run $9.60 (9600 API credits))
- Run: `POST https://api.doitong.com/v1/run/ltx23-video-trainer`
- Quote: `POST https://api.doitong.com/v1/quote/ltx23-video-trainer`
- Docs page: https://doitong.com/it/developers/models/ltx23-video-trainer

## Pricing

Price: **$0.0048 / step**. Billed per training step (`number_of_steps`).

The full example input below costs $9.60 = 9600 API credits (2000 steps × 4.8 API credits).

Prices are the upstream price in USD, paid from the API balance in API credits (1000 API credits = 1 USD). `POST https://api.doitong.com/v1/quote/ltx23-video-trainer` 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

| Parameter | Canonical name | Type | Required | Default | Allowed values / range | Description |
|---|---|---|---|---|---|---|
| `training_data_url` |  | string | yes |  |  | URL di un archivio ZIP per un dataset contenente esclusivamente immagini o esclusivamente video; i dataset con contenuti misti non sono supportati. Punta ad almeno 10 file, preferibilmente a una raccolta più ampia. Le estensioni accettate sono .png, .jpg, .jpeg per le immagini e .mp4, .mov, .avi, .mkv per i video. File di testo opzionali con didascalie possono accompagnare i contenuti multimediali; ogni file di didascalia deve avere lo stesso nome del relativo file multimediale. |
| `rank` |  | enum (integer) | no | `32` | `8`, `16`, `32`, `64`, `128` | Rango di adattamento LoRA, che scambia un maggiore consumo di memoria con una capacità superiore all'aumentare del valore. |
| `number_of_steps` |  | integer | no | `2000` | 100 – 6,000 | Numero totale di passaggi di addestramento. |
| `learning_rate` |  | number | no | `0.0002` | 0.000001 – 1 | Tasso di apprendimento dell'ottimizzazione, che bilancia un possibile aumento della velocità di training con il rischio di overfitting quando viene aumentato. |
| `number_of_frames` |  | integer | no | `89` | 9 – 121 | Numero di fotogrammi per ogni campione di addestramento. Dividendo il numero per 8 si deve ottenere resto 1; esempi: 1, 9, 17, 25, 33, 41, 49, 57, 65, 73, 81, 89, 97. |
| `frame_rate` |  | integer | no | `25` | 8 – 60 | Frequenza dei fotogrammi del video di destinazione, misurata in fotogrammi al secondo. |
| `resolution` |  | enum (string) | no | `medium` | `low`, `medium`, `high` | Risoluzione di addestramento. Aumentare la risoluzione incrementa i requisiti di memoria. |
| `aspect_ratio` |  | enum (string) | no | `1:1` | `16:9`, `1:1`, `9:16` | Rapporto d'aspetto di addestramento. |
| `trigger_phrase` |  | string | no | `` |  | Frase di attivazione dello stile LoRA, inserita all'inizio delle didascalie durante l'addestramento. |
| `auto_scale_input` |  | boolean | no | `false` |  | Regolazione automatica del video per adattarlo agli FPS e al numero di fotogrammi richiesti quando abilitata; i dataset di immagini restano invariati. |
| `split_input_into_scenes` |  | boolean | no | `true` |  | Suddivisione delle scene per i video che superano una soglia di durata, abilitata quando è true. |
| `split_input_duration_threshold` |  | number | no | `30` | 1 – 60 | Trigger di suddivisione delle scene espresso come durata in secondi: vengono suddivisi solo i video più lunghi della soglia. |
| `debug_dataset` |  | boolean | no | `false` |  | Modalità di ispezione del preprocessing per controllare video, immagini e didascalie prima di un'esecuzione completa dell'addestramento. Abilitandola, il trainer restituisce il dataset di addestramento elaborato in un archivio scaricabile per la revisione manuale. |
| `with_audio` |  | boolean \| null | no |  |  | Scegli True per forzare il training audio insieme al training video, oppure False per escludere l'audio. Lasciando l'impostazione al valore predefinito None, la scelta viene effettuata automaticamente in base alla presenza di audio nei video forniti. |
| `audio_normalize` |  | boolean | no | `true` |  | Normalizzazione dell'ampiezza di picco, consigliata per rendere uniformi i livelli audio nell'intero dataset portando i picchi a un livello comune. |
| `audio_preserve_pitch` |  | boolean | no | `true` |  | Conservazione dell'intonazione quando le durate di audio e video differiscono: l'abilitazione usa l'espansione o la compressione temporale; la disabilitazione usa invece il ritaglio o il riempimento con silenzio. |
| `first_frame_conditioning_p` |  | number | no | `0.5` | 0 – 1 | Migliora le prestazioni image-to-video aumentando la frequenza con cui il training usa il condizionamento sul primo fotogramma; questo valore imposta tale probabilità. |
| `validation` |  | array of object {prompt, image_url} | no | `[]` | ≤ 2 items | Elenco di prompt di convalida del training, i cui input devono includere tutti immagini oppure ometterle tutti. |
| `validation[].prompt` |  | string | yes |  |  | Prompt usato durante la convalida. |
| `validation[].image_url` |  | string (image URL) \| null | no |  |  | Immagine per la convalida image-to-video, consentita solo se anche ogni altro input di convalida include un'immagine. |
| `validation_negative_prompt` |  | string | no | `worst quality, inconsistent motion, blurry, jittery, distorted` |  | Prompt negativo applicato durante la convalida. |
| `validation_number_of_frames` |  | integer | no | `89` | 9 – 121 | Numero di fotogrammi per ogni video di convalida. |
| `validation_frame_rate` |  | integer | no | `25` | 8 – 60 | Frequenza dei fotogrammi del video di convalida di destinazione, misurata in fotogrammi al secondo. |
| `validation_resolution` |  | enum (string) | no | `high` | `low`, `medium`, `high` | Risoluzione usata durante la convalida. |
| `validation_aspect_ratio` |  | enum (string) | no | `1:1` | `16:9`, `1:1`, `9:16` | Rapporto d'aspetto usato durante la convalida. |
| `stg_scale` |  | number | no | `1` | 0 – 3 | Scala dello Spatio-Temporal Guidance (STG), con 1.0 consigliato e 0.0 che disattiva STG. |
| `generate_audio_in_validation` |  | boolean | no | `true` |  | Controlla se gli esempi di convalida includono audio generato. |

## Example input

Required parameters only:

```json
{
  "training_data_url": "https://example.com/your-file.zip"
}
```

A fuller example:

```json
{
  "training_data_url": "https://example.com/your-file.zip"
}
```

## 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.com/v1/run/ltx23-video-trainer?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "training_data_url": "https://example.com/your-file.zip"
  }'

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

### JavaScript

```javascript
const API = "https://api.doitong.com/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/ltx23-video-trainer?wait=20", {
  method: "POST",
  headers,
  body: JSON.stringify({
    "training_data_url": "https://example.com/your-file.zip"
  }),
});
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.com/v1"
headers = {"Authorization": "Bearer " + os.environ["DOITONG_API_KEY"]}

payload = {
    "training_data_url": "https://example.com/your-file.zip",
}

# Run the model; wait up to 20 s for the finished result in the same call
r = requests.post(API + "/run/ltx23-video-trainer", 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.com/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": "ltx23-video-trainer",
      "input": {
        "training_data_url": "https://example.com/your-file.zip"
      },
      "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": "ltx23-video-trainer",
  "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": 9600,
    "usd": "9.60",
    "charged": 9600,
    "refunded": 0
  },
  "input": {
    "training_data_url": "https://example.com/your-file.zip"
  },
  "output": {
    "video": {
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
      "content_type": "image/jpeg",
      "file_name": "0-output.jpeg",
      "file_size": 1843200
    },
    "lora_file": {
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
      "content_type": "image/jpeg",
      "file_name": "0-output.jpeg",
      "file_size": 1843200
    },
    "config_file": {
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
      "content_type": "image/jpeg",
      "file_name": "0-output.jpeg",
      "file_size": 1843200
    },
    "debug_dataset": {
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
      "content_type": "image/jpeg",
      "file_name": "0-output.jpeg",
      "file_size": 1843200
    }
  },
  "outputs": [
    {
      "type": "file",
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
      "content_type": "image/jpeg",
      "file_size": 1843200,
      "stored": true
    }
  ],
  "error": null,
  "metrics": {
    "inference_seconds": 6.8
  },
  "urls": {
    "self": "https://api.doitong.com/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t",
    "cancel": "https://api.doitong.com/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t/cancel"
  }
}
```

### Output fields (`output`)

| Field | Type | Description |
|---|---|---|
| `video` | object {url, content_type, file_name, file_size} \| null | URL di eventuali video di convalida disponibili. |
| `lora_file` | object {url, content_type, file_name, file_size} | URL dei pesi LoRA addestrati in formato .safetensors. |
| `config_file` | object {url, content_type, file_name, file_size} | Configurazione per l'impostazione dell'endpoint di inferenza. |
| `debug_dataset` | object {url, content_type, file_name, file_size} \| null | Archivio di debug scaricabile restituito solo per gli input con `debug_dataset` abilitato; contiene il dataset di training preelaborato, inclusi audio e video decodificati. |

## Related models

- [LTX 2.3 Trainer (V2) - Audio Inpainting](https://doitong.com/developers/models/ltx23-trainer-v2/audio-inpaint.md) (`ltx23-trainer-v2/audio-inpaint`): $0.0023 / step
- [LTX 2.3 Trainer (V2) - Audio+Video Reference IC-LoRA](https://doitong.com/developers/models/ltx23-trainer-v2/ic-lora/av2av.md) (`ltx23-trainer-v2/ic-lora/av2av`): $0.0068 / step
- [LTX 2.3 Trainer (V2) - Audio+Video Reference Transformation](https://doitong.com/developers/models/ltx23-trainer-v2/av2av.md) (`ltx23-trainer-v2/av2av`): $0.0068 / step
- [LTX 2.3 Trainer (V2) - Audio-to-Audio](https://doitong.com/developers/models/ltx23-trainer-v2/a2a.md) (`ltx23-trainer-v2/a2a`): $0.0023 / step
- [LTX 2.3 Trainer (V2) - Audio-to-Audio IC-LoRA](https://doitong.com/developers/models/ltx23-trainer-v2/ic-lora/a2a.md) (`ltx23-trainer-v2/ic-lora/a2a`): $0.0023 / step
- [LTX 2.3 Trainer (V2) - Audio-to-Video](https://doitong.com/developers/models/ltx23-trainer-v2/a2v.md) (`ltx23-trainer-v2/a2v`): $0.006 / step
- [LTX 2.3 Trainer (V2) - Backward Audio Extension](https://doitong.com/developers/models/ltx23-trainer-v2/audio-extend-suffix.md) (`ltx23-trainer-v2/audio-extend-suffix`): $0.0023 / step
- [LTX 2.3 Trainer (V2) - Backward Video Extension](https://doitong.com/developers/models/ltx23-trainer-v2/extend-suffix.md) (`ltx23-trainer-v2/extend-suffix`): $0.0061 / step

## Links

- HTML page: https://doitong.com/developers/models/ltx23-video-trainer
- 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=ltx23-video-trainer
- Errors: https://doitong.com/developers/docs/errors
- Model details as JSON: https://api.doitong.com/v1/models/ltx23-video-trainer