# LTX-2.3 22B Video Trainer API

> Trains an LTX-2.3 22B LoRA for custom video styles and effects, with optional audio

Trains a LoRA on the LTX-2.3 22B model for custom styles and effects from a zip of videos or images, ideally 10 or more files. `number_of_steps` ranges 100 to 6000 (default 2000), `frame_rate` defaults to 25, and `first_frame_conditioning_p` defaults to 0.5. `with_audio` forces or disables audio training, and `generate_audio_in_validation` controls audio in previews.

- 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/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 |  |  | ZIP archive URL for a dataset containing exclusively images or exclusively videos; mixed media datasets are unsupported. Aim for 10 files or more, preferably a larger collection. Accepted extensions are .png, .jpg, .jpeg for images and .mp4, .mov, .avi, .mkv for videos. Optional caption text files may accompany the media, with each caption file named to match its associated media file. |
| `rank` |  | enum (integer) | no | `32` | `8`, `16`, `32`, `64`, `128` | LoRA adaptation rank, trading increased memory consumption for greater capacity as the setting rises. |
| `number_of_steps` |  | integer | no | `2000` | 100 – 6,000 | Total count of training steps. |
| `learning_rate` |  | number | no | `0.0002` | 0.000001 – 1 | Optimization learning rate, balancing a possible speedup in training against the risk of overfitting when increased. |
| `number_of_frames` |  | integer | no | `89` | 9 – 121 | Frame count for each training sample. Dividing the count by 8 must leave a remainder of 1; examples include 1, 9, 17, 25, 33, 41, 49, 57, 65, 73, 81, 89, 97. |
| `frame_rate` |  | integer | no | `25` | 8 – 60 | Target video frame rate, measured in frames per second. |
| `resolution` |  | enum (string) | no | `medium` | `low`, `medium`, `high` | Training resolution. Increasing the resolution raises memory requirements. |
| `aspect_ratio` |  | enum (string) | no | `1:1` | `16:9`, `1:1`, `9:16` | Training aspect ratio. |
| `trigger_phrase` |  | string | no | `` |  | LoRA style activation phrase, inserted at the start of captions during training. |
| `auto_scale_input` |  | boolean | no | `false` |  | Automatic video adjustment to match the requested FPS and frame count when enabled; image datasets remain unchanged. |
| `split_input_into_scenes` |  | boolean | no | `true` |  | Scene splitting for videos exceeding a duration threshold, enabled when true. |
| `split_input_duration_threshold` |  | number | no | `30` | 1 – 60 | Scene-splitting trigger expressed as a duration in seconds: only videos longer than the threshold are split. |
| `debug_dataset` |  | boolean | no | `false` |  | Preprocessing inspection mode for checking videos, images, and captions before a full training run. Enabling it makes the trainer return the processed training dataset in a downloadable archive for manual review. |
| `with_audio` |  | boolean \| null | no |  |  | Choose True to force audio training alongside video training, or False to exclude audio. Leaving the setting at its default, None, makes the choice automatic based on whether the supplied videos contain audio. |
| `audio_normalize` |  | boolean | no | `true` |  | Peak-amplitude normalization, recommended to make audio levels consistent throughout the dataset by bringing peaks to a common level. |
| `audio_preserve_pitch` |  | boolean | no | `true` |  | Pitch preservation when audio and video lengths differ: enabled uses time stretching or compression; disabled uses trimming or silence padding instead. |
| `first_frame_conditioning_p` |  | number | no | `0.5` | 0 – 1 | Improve image-to-video performance by increasing how often training uses first-frame conditioning; this value sets that probability. |
| `validation` |  | array of object {prompt, image_url} | no | `[]` | ≤ 2 items | Training validation prompt list, whose inputs must either all include images or all omit them. |
| `validation[].prompt` |  | string | yes |  |  | Prompt used during validation. |
| `validation[].image_url` |  | string (image URL) \| null | no |  |  | Image for image-to-video validation, permitted only if every other validation input also includes an image. |
| `validation_negative_prompt` |  | string | no | `worst quality, inconsistent motion, blurry, jittery, distorted` |  | Negative prompt applied during validation. |
| `validation_number_of_frames` |  | integer | no | `89` | 9 – 121 | Frame count for each validation video. |
| `validation_frame_rate` |  | integer | no | `25` | 8 – 60 | Target validation video frame rate, measured in frames per second. |
| `validation_resolution` |  | enum (string) | no | `high` | `low`, `medium`, `high` | Resolution used during validation. |
| `validation_aspect_ratio` |  | enum (string) | no | `1:1` | `16:9`, `1:1`, `9:16` | Aspect ratio used during validation. |
| `stg_scale` |  | number | no | `1` | 0 – 3 | Spatio-Temporal Guidance (STG) scale, with 1.0 recommended and 0.0 turning STG off. |
| `generate_audio_in_validation` |  | boolean | no | `true` |  | Controls whether validation samples include generated audio. |

## 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 for any available validation videos. |
| `lora_file` | object {url, content_type, file_name, file_size} | URL for trained LoRA weights in .safetensors format. |
| `config_file` | object {url, content_type, file_name, file_size} | Configuration for inference endpoint setup. |
| `debug_dataset` | object {url, content_type, file_name, file_size} \| null | Downloadable debug archive returned only for inputs with `debug_dataset` enabled; it holds the preprocessed training dataset, including decoded audio and video. |

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