Name: LTX-2.3 Pro Video Generation API, up to 4K
Brand: magicapi
SKU: api-magicapi-high-fidelity-video-generation-lightricks-ltx-2-3-pro
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 High-Fidelity Video Generation API (LTX-2.3 Pro)

## Overview

LTX-2.3 Pro, from Lightricks, is a high-fidelity video model with portrait support. One endpoint covers five tasks, chosen with `task`:

- `text_to_video` (default): a video from a prompt.
- `image_to_video`: a video that starts from `image`, and optionally ends on `last_frame_image`.
- `audio_to_video`: a video driven by an input `audio` file.
- `retake`: regenerate a section of an existing `video` (its audio, its picture, or both).
- `extend`: add footage to the start or end of an existing `video`.

Output goes up to 4K (`resolution`) at up to 50 frames per second (`fps`), in landscape (`16:9`) or portrait (`9:16`).

## Features

- **Five tasks in one endpoint**: text to video, image to video, audio to video, retake and extend.
- **Resolution**: `1080p` (default), `2k` or `4k`. Only `1080p` is supported for `audio_to_video`, `retake` and `extend`.
- **Duration**: 6 (default), 8 or 10 seconds.
- **Frame rate**: 24, 25 (default), 48 or 50 FPS.
- **Landscape or portrait**: `aspect_ratio` `16:9` (default) or `9:16`.
- **Generated audio**: `generate_audio` (default true) for text to video and image to video.
- **Camera motion**: `none` (default), `dolly_in`, `dolly_out`, `dolly_left`, `dolly_right`, `jib_up`, `jib_down`, `static`, `focus_shift`.
- **First and last frame**: `last_frame_image` makes the video interpolate between `image` and that frame.
- **Retake controls**: `retake_start_time`, `retake_duration` (at least 2 seconds) and `retake_mode` (`replace_audio`, `replace_video`, `replace_audio_and_video`).
- **Extend controls**: `extend_mode` `start` or `end` (default).

## Use Cases

- **Ads and product videos**: High-resolution clips from a prompt or a product image.
- **Vertical content**: Native `9:16` videos for short-form platforms.
- **Music and voice visuals**: Generate video driven by an audio track.
- **Fixing a take**: Regenerate only the part of a clip that did not work with `retake`.
- **Longer shots**: Extend an existing clip at the start or end.

## Visual Examples

- **Prompt**: "A hummingbird hovers next to a red flower, slow motion"
- **Duration**: 6 seconds
- All other inputs left at their defaults (`text_to_video`, `1080p`, 25 FPS, `16:9`, audio on).

Output:

[Watch the example video](https://blog.api.market/wp-content/uploads/2026/10/ltx-2.3-pro-output-api-market.mp4)

## Pricing

- **Pay As You Go (PAYG) pricing**: You only pay for what you use.
- **Price**: $0.10 per API unit.
- **Billing is per second of output video.** Each second counts as a number of units that depends on `resolution`:
  - **`1080p`** (the default): 1 unit per second, **$0.10** per second.
  - **`2k`**: 2 units per second, **$0.20** per second.
  - **`4k`**: 4 units per second, **$0.40** per second.
- **Seconds are rounded up to the next whole second.**
- **Worked examples**: a 6 second video at 1080p (like the example above) is 6 units, **$0.60**. The same 6 seconds at 2k is 12 units, **$1.20**, and at 4k is 24 units, **$2.40**. A 10 second video at 4k is 40 units, **$4.00**.
- For `retake`, `extend` and `audio_to_video`, the bill is based on the length of the video returned (these tasks run at 1080p).
- **Failed or cancelled predictions**: Not billed.
- **GET requests to check prediction status**: Free and don't count toward API unit usage.
- **No monthly subscription fee**: Pay as you go.

## API Documentation

### Base URL

All API requests go to: `https://prod.api.market/api/v1/magicapi/high-fidelity-video-generation-lightricks-ltx-2-3-pro`

### Authentication

Include your api.market API key in the `x-api-market-key` header of every request:

```http
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing

This API is asynchronous:

1. Send a POST request to `/predictions`. The response is **201 Created** with a prediction `id` and a `status` of `starting` or `processing`. A 201 means the job was accepted; it is not an error.
2. Poll GET `/predictions/{id}` (for example once a second).
3. Stop when `status` is `succeeded` (the result is in `output`), `failed` or `canceled` (details in `error`).

Set a client-side timeout (for example 10 minutes) so a stuck job does not poll forever.

### Endpoints

#### POST /predictions

Creates a prediction. This is the request used for the example above:

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/high-fidelity-video-generation-lightricks-ltx-2-3-pro/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  --data @- <<'EOF'
{
  "version": "2560a82a0a6f2a7586087d51dc292c709248bcc10119160b9c54304f6ed64e85",
  "input": {
    "prompt": "A hummingbird hovers next to a red flower, slow motion",
    "duration": 6
  }
}
EOF
```

**Response (201 Created):**

```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "2560a82a0a6f2a7586087d51dc292c709248bcc10119160b9c54304f6ed64e85",
  "status": "starting",
  "created_at": "2026-10-13T10:45:20.695Z"
}
```

#### GET /predictions/{id}

Returns the prediction's status and, once it has succeeded, its output.

```bash
curl "https://prod.api.market/api/v1/magicapi/high-fidelity-video-generation-lightricks-ltx-2-3-pro/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Response (200 OK, succeeded):**

```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/ltx-2.3-pro-output-api-market.mp4",
  "created_at": "2026-10-13T10:45:20.695Z",
  "started_at": "2026-10-13T10:45:21.102Z",
  "completed_at": "2026-10-13T10:46:05.480Z"
}
```

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

### Input Parameters

| Parameter | Type | Default | Required | Description |
|---|---|---|---|---|
| `task` | string | text_to_video | No | The generation task to perform Allowed values: `text_to_video`, `image_to_video`, `audio_to_video`, `retake`, `extend`. |
| `prompt` | string | - | Yes | Text prompt describing the video to generate |
| `image` | string (URI) | - | No | First frame image for image-to-video generation |
| `last_frame_image` | string (URI) | - | No | Last frame image for image-to-video generation. When provided, the video interpolates between the first frame and this last frame. |
| `audio` | string (URI) | - | No | Input audio file for audio_to_video task |
| `video` | string (URI) | - | No | Input video for retake or extend tasks |
| `resolution` | string | 1080p | No | Resolution quality of the generated video. Only 1080p is supported for audio_to_video, retake, and extend tasks. Allowed values: `1080p`, `2k`, `4k`. |
| `duration` | integer | 6 | No | Duration of the video in seconds Allowed values: `6`, `8`, `10`. |
| `aspect_ratio` | string | 16:9 | No | Aspect ratio of the generated video Allowed values: `16:9`, `9:16`. |
| `fps` | integer | 25 | No | Frame rate in frames per second Allowed values: `24`, `25`, `48`, `50`. |
| `camera_motion` | string | none | No | Camera motion effect to apply to the generated video. Use 'none' for no camera motion. Allowed values: `none`, `dolly_in`, `dolly_out`, `dolly_left`, `dolly_right`, `jib_up`, `jib_down`, `static`, `focus_shift`. |
| `generate_audio` | boolean | true | No | Generate audio for the video. Used for text_to_video and image_to_video tasks. |
| `retake_start_time` | number | 0 | No | Start time in seconds of the section to edit. Used for retake task. Minimum: 0. |
| `retake_duration` | number | 2 | No | Duration in seconds of the section to edit. Must be at least 2 seconds. Used for retake task. Minimum: 2. |
| `retake_mode` | string | replace_audio_and_video | No | What to replace in the retake section. Used for retake task. Allowed values: `replace_audio`, `replace_video`, `replace_audio_and_video`. |
| `extend_mode` | string | end | No | Where to extend the video. Used for extend task. Allowed values: `start`, `end`. |

Which inputs each task uses:

- `text_to_video`: `prompt`, plus `duration`, `resolution`, `fps`, `aspect_ratio`, `camera_motion`, `generate_audio`.
- `image_to_video`: `image` (first frame), optional `last_frame_image`, plus the same options as text to video.
- `audio_to_video`: `audio`. 1080p only.
- `retake`: `video`, `retake_start_time`, `retake_duration`, `retake_mode`. 1080p only.
- `extend`: `video`, `extend_mode`. 1080p only.

### Status Codes

- **201 Created**: Prediction accepted (POST). Poll the GET endpoint for the result.
- **200 OK**: Prediction returned (GET).
- **400 Bad Request**: Invalid input, for example a value outside the allowed range or enum.
- **401 Unauthorized**: Missing or invalid `x-api-market-key`.
- **404 Not Found**: Unknown prediction ID.
- **429 Too Many Requests**: Too many requests in a short time. Wait and retry.
- **500 Internal Server Error**: Server-side error. Retry later.

### Error Handling

- Treat both 200 and 201 as success.
- A prediction can still end with `status: "failed"`; read the `error` field for the reason. Failed predictions are not billed.
- Retry 429 and 5xx responses with exponential backoff. Fix the request before retrying a 400.

## Rate Limits

All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Implementation Guide

### JavaScript

```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/high-fidelity-video-generation-lightricks-ltx-2-3-pro";

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: "2560a82a0a6f2a7586087d51dc292c709248bcc10119160b9c54304f6ed64e85", input })
  });

  // 201 Created is the normal success response here.
  if (!response.ok) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

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

async function pollForResult(id) {
  const timeoutMs = 10 * 60 * 1000;
  const start = Date.now();

  while (Date.now() - start < timeoutMs) {
    const response = await fetch(`${baseUrl}/predictions/${id}`, {
      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 new Promise((resolve) => setTimeout(resolve, 1000));
  }

  throw new Error("Prediction timed out");
}

createAndWaitForPrediction({
  "prompt": "A hummingbird hovers next to a red flower, slow motion",
  "duration": 6
}).then(console.log);
```

### Python

```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/high-fidelity-video-generation-lightricks-ltx-2-3-pro"

def create_and_wait_for_prediction(input_data):
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers={"Content-Type": "application/json", "x-api-market-key": API_KEY},
        json={"version": "2560a82a0a6f2a7586087d51dc292c709248bcc10119160b9c54304f6ed64e85", "input": input_data},
    )
    # 201 Created is the normal success response here.
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")
    return poll_for_result(response.json()["id"])

def poll_for_result(prediction_id, timeout=600):
    start = time.time()
    while time.time() - start < timeout:
        response = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers={"x-api-market-key": API_KEY},
        )
        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(1)
    raise Exception("Prediction timed out")

print(create_and_wait_for_prediction({
  "prompt": "A hummingbird hovers next to a red flower, slow motion",
  "duration": 6
}))
```

### cURL

```bash
# Step 1: create the prediction (returns 201 Created with an id)
curl -X POST "https://prod.api.market/api/v1/magicapi/high-fidelity-video-generation-lightricks-ltx-2-3-pro/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  --data @- <<'EOF'
{
  "version": "2560a82a0a6f2a7586087d51dc292c709248bcc10119160b9c54304f6ed64e85",
  "input": {
    "prompt": "A hummingbird hovers next to a red flower, slow motion",
    "duration": 6
  }
}
EOF

# Step 2: poll with the id from step 1 until status is succeeded, failed or canceled
curl "https://prod.api.market/api/v1/magicapi/high-fidelity-video-generation-lightricks-ltx-2-3-pro/predictions/PREDICTION_ID" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## FAQ

**Why do I get a 201 response instead of the result?**
The API is asynchronous. 201 Created means the prediction was accepted. Poll GET `/predictions/{id}` until `status` is `succeeded` and read `output`.

**How do I pick a task?**
Set `task` to `text_to_video` (default), `image_to_video`, `audio_to_video`, `retake` or `extend`, and send the inputs that task uses (see the list under Input Parameters).

**Which resolutions are available?**
`1080p`, `2k` and `4k`. `audio_to_video`, `retake` and `extend` support only `1080p`.

**Does 4K cost more?**
Yes. 1080p is $0.10 per second, 2k $0.20 per second and 4k $0.40 per second of output video.

**Can I make portrait videos?**
Yes. Set `aspect_ratio` to `9:16`.

## 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 with audio from text, images or audio with LTX-2.3 Pro from Lightricks. Retake and extend clips, 1080p to 4K, pay per second.