Name: Lightricks LTX-2.3 LoRA Text-to-Video and Video Editing API
Brand: magicapi
SKU: api-magicapi-ai-video-enhancement-lora-replicate-ltxvideo-2-3-lora
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 Text-to-Video and Video Editing API (Lightricks LTX-2.3 LoRA)

## Overview
LTX-2.3 LoRA runs the LTX-2.3 video model from Lightricks together with a choice of community task LoRAs. Its developer describes it as LTX 2.3 with popular community LoRA tasks such as Ingredients or camera control.

With `task_lora` left at its default, `None \u2014 Text to video`, the model generates a video from a text `prompt`. The other 15 `task_lora` values load a task LoRA, for example inpainting and outpainting, 2x or 4x video upscaling, deblurring, colorizing, day to night or a new camera viewpoint. Tasks that change existing media take it in `input_media`, with `mask` and `crossview_warp_media` for the tasks that need them. Each request returns the URL of one MP4 video.

## Features
- **Text to video**: describe the scene, camera movement and sound in `prompt`; the default task generates the video from text alone.
- **15 task LoRAs** selected with `task_lora`: Ingredients (asset sheet identity or concept), Inpaint / Outpaint, Upscale video 2x, Upscale video 4x, Add water, Deblur, Remove compression artifacts, Cross-eyed effect, Remove facial hair, Colorize, Day to night, Cinemagraph, Foley sound effects, Clean plate (remove people or objects) and CrossView Warp (new camera viewpoint).
- **LoRA strength**: `lora_strength` from 0 to 3 (default 0) sets how strongly the selected task LoRA is applied.
- **Size**: `width` and `height` from 256 to 1536 pixels, divisible by 32 (default 768 x 512).
- **Length and frame rate**: `num_frames` from 9 to 257 in steps of 8k + 1 (default 121) and `frame_rate` from 1 to 60 (default 24). The clip length in seconds is `num_frames` divided by `frame_rate`.
- **Seed**: set `seed` to reproduce a result; 0 (default) picks a random seed.

## Use Cases
1. **Short clips from text**: scenes for social posts, ads, previsualization and storyboards.
2. **Cleaning up footage**: deblur a clip, remove compression artifacts or upscale it 2x or 4x.
3. **Restyling footage**: colorize a clip, turn day into night or make a cinemagraph.
4. **Removing objects**: create a clean plate without people or objects, or inpaint and outpaint a masked region.

## Visual Examples
### Example Input
Prompt: "A medium-wide tracking shot of a woman in a yellow raincoat running through a neon-lit market at night. Handheld camera, wet pavement reflecting signs, realistic motion and shallow depth of field. Footsteps splash through puddles beneath distant traffic and market chatter"

Settings: `task_lora` `None \u2014 Text to video`, `width` 768, `height` 512, `num_frames` 121 at `frame_rate` 24 (5.04 seconds), `lora_strength` 0, `seed` 0 (random), empty `reference_description`. No input media.

### Example Output
[Watch the example output](https://blog.api.market/wp-content/uploads/2026/10/ltxvideo-2-3-lora-output-dzq3shv7-api-market.mp4)

A 768 x 512 clip of 5.04 seconds (121 frames at 24 fps) generated from the prompt above.

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Text prompt for video generation |
| `task_lora` | string | No | `None \u2014 Text to video` | `None \u2014 Text to video`, `Ingredients \u2014 Asset sheet identity/concept`, `Inpaint / Outpaint`, `Upscale video 2×`, `Upscale video 4×`, `Add water`, `Deblur`, `Remove compression artifacts`, `Cross-eyed effect`, `Remove facial hair`, `Colorize`, `Day to night`, `Cinemagraph`, `Foley sound effects`, `Clean plate \u2014 Remove people/objects`, `CrossView Warp \u2014 New camera viewpoint` | Task LoRA to apply. The default, `None \u2014 Text to video`, generates video from the prompt only |
| `input_media` | string (URL) | No | none |  | Input media URL for tasks that change existing media |
| `crossview_warp_media` | string (URL) | No | none |  | Media URL for the `CrossView Warp \u2014 New camera viewpoint` task |
| `reference_description` | string | No | `""` |  | Optional text that describes the reference media |
| `mask` | string (URL) | No | none |  | Mask URL for tasks that use a mask, such as `Inpaint / Outpaint` |
| `lora_strength` | number | No | `0` | 0 to 3 | Strength of the selected task LoRA |
| `width` | integer | No | `768` | 256 to 1536 | Output width, divisible by 32 |
| `height` | integer | No | `512` | 256 to 1536 | Output height, divisible by 32 |
| `num_frames` | integer | No | `121` | 9 to 257 | Frame count; must be 8k + 1 (for example 97, 121 or 257) |
| `frame_rate` | number | No | `24` | 1 to 60 | Output video frame rate |
| `seed` | integer | No | `0` | 0 or more | Random seed. Use 0 for a random seed. |

Several `task_lora` values contain the em dash character (Unicode U+2014). Send them exactly as listed; in JSON, JavaScript and Python strings you can write that character as `\u2014`, as the examples on this page do.

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.20 per API unit.
- **1 API unit = 1 request with up to 118 seconds of processing.** A request that runs longer is billed one more unit for each started 118-second block (for example, more than 118 and up to 236 seconds of processing is 2 units, $0.40).
- The price per unit is the same for every `task_lora`. Longer, larger or higher-frame-count videos take longer to process and can cross into a second unit.
- **Example cost**: the example request (121 frames of 768 x 512 video at 24 fps) took 61.6 seconds of processing, which fits in one 118-second block: 1 API unit, $0.20.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/ai-video-enhancement-lora-replicate-ltxvideo-2-3-lora`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-video-enhancement-lora-replicate-ltxvideo-2-3-lora/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "40c83084b6dea970e3c26deea0ccb5b3048915837021281c13edcaf178972c56",
    "input": {
      "seed": 0,
      "width": 768,
      "height": 512,
      "prompt": "A medium-wide tracking shot of a woman in a yellow raincoat running through a neon-lit market at night. Handheld camera, wet pavement reflecting signs, realistic motion and shallow depth of field. Footsteps splash through puddles beneath distant traffic and market chatter",
      "task_lora": "None \u2014 Text to video",
      "frame_rate": 24,
      "num_frames": 121,
      "lora_strength": 0,
      "reference_description": ""
    }
  }'
```

Response (201 Created):
```json
{
  "id": "dzq3shv759rp40d1f1ra4sw9b4",
  "version": "40c83084b6dea970e3c26deea0ccb5b3048915837021281c13edcaf178972c56",
  "status": "starting",
  "created_at": "2026-10-26T13:39:54.953Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-video-enhancement-lora-replicate-ltxvideo-2-3-lora/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "dzq3shv759rp40d1f1ra4sw9b4",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/ltxvideo-2-3-lora-output-dzq3shv7-api-market.mp4",
  "error": null,
  "created_at": "2026-10-26T13:39:54.953Z",
  "started_at": "2026-10-26T13:42:52.992Z",
  "completed_at": "2026-10-26T13:43:54.551Z"
}
```

`output` is a single URL string pointing to the generated MP4 video.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `prompt` or a `width` outside 256 to 1536.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
Requests are rate limited to keep usage fair. If you receive a 429 response, wait and retry with exponential backoff.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/ai-video-enhancement-lora-replicate-ltxvideo-2-3-lora";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "40c83084b6dea970e3c26deea0ccb5b3048915837021281c13edcaf178972c56", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
  "seed": 0,
  "width": 768,
  "height": 512,
  "prompt": "A medium-wide tracking shot of a woman in a yellow raincoat running through a neon-lit market at night. Handheld camera, wet pavement reflecting signs, realistic motion and shallow depth of field. Footsteps splash through puddles beneath distant traffic and market chatter",
  "task_lora": "None \u2014 Text to video",
  "frame_rate": 24,
  "num_frames": 121,
  "lora_strength": 0,
  "reference_description": ""
}).then((output) => console.log(output));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/ai-video-enhancement-lora-replicate-ltxvideo-2-3-lora"


def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "40c83084b6dea970e3c26deea0ccb5b3048915837021281c13edcaf178972c56", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])


def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 10 minutes")


print(create_and_wait_for_prediction({
    "seed": 0,
    "width": 768,
    "height": 512,
    "prompt": "A medium-wide tracking shot of a woman in a yellow raincoat running through a neon-lit market at night. Handheld camera, wet pavement reflecting signs, realistic motion and shallow depth of field. Footsteps splash through puddles beneath distant traffic and market chatter",
    "task_lora": "None \u2014 Text to video",
    "frame_rate": 24,
    "num_frames": 121,
    "lora_strength": 0,
    "reference_description": ""
}))
```

## FAQ
- **How do I generate a video from text only?**
  - Send a `prompt` and either leave out `task_lora` or send its default, `None \u2014 Text to video`.
- **How long can a video be?**
  - Up to 257 frames. The length in seconds is `num_frames` divided by `frame_rate`, so 257 frames at the default 24 fps is about 10.7 seconds.
- **Which `num_frames` values are valid?**
  - Values of the form 8k + 1 between 9 and 257, such as 9, 17, 97, 121 (default) or 257.
- **Where do I send the video or image for an editing task?**
  - Pass it as `input_media`. Use `mask` for tasks that need a mask, such as `Inpaint / Outpaint`, and `crossview_warp_media` for the CrossView Warp task.
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## Contact Us
If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


Generate video from text with Lightricks LTX-2.3, or apply task LoRAs for inpainting, deblurring, colorizing or upscaling. $0.20 per request, pay as you go.