Name: Text-to-Video API with Audio (LTX-2.3 Fast)
Brand: magicapi
SKU: api-magicapi-fast-video-generator-lightricks-ltx-2-3-fast
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Fast Text-to-Video API with Audio (LTX-2.3 Fast)

## Overview
LTX-2.3 Fast, from Lightricks, generates video from a text prompt, with optional generated audio. You can also give it a first frame image (image-to-video), and a last frame image to make the video move from one frame to the other. Lightricks describes it as fast video generation with portrait support, camera controls and synchronized audio: up to 20 seconds at 1080p, and up to 4K at 50 FPS.

## Features
- Text-to-video from a `prompt` (the only required field)
- Image-to-video with a first frame `image`, and an optional `last_frame_image` to interpolate between two frames
- Generated audio, on by default (`generate_audio`)
- Durations of 6, 8, 10, 12, 14, 16, 18 or 20 seconds (`duration`, default 6)
- Resolutions `1080p` (default), `2k` and `4k`
- Landscape `16:9` or portrait `9:16` (`aspect_ratio`)
- Frame rates of 24, 25, 48 or 50 FPS (`fps`, default 25)
- Camera motion presets: `dolly_in`, `dolly_out`, `dolly_left`, `dolly_right`, `jib_up`, `jib_down`, `static`, `focus_shift`, or `none`

Durations longer than 10 seconds are only available at 1080p with 24 or 25 FPS.

## Use Cases
### Social video
Generate short landscape or portrait clips with sound for feeds and stories from a single prompt.

### Bringing images to life
Animate a product shot, illustration or photo by passing it as the first frame, or set both a first and last frame to control where the shot starts and ends.

### Previsualization and b-roll
Try out shots with camera moves such as dolly or jib before filming, or create background footage for edits.

## Visual Examples
This is the request we ran through api.market (text-to-video, all other fields at their defaults: 1080p, 16:9, 25 FPS, audio on).

**Prompt:** "Ocean waves crash against black volcanic rocks at sunset, slow motion spray"

**Duration:** 6 seconds

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

## Pricing
- Pay As You Go (PAYG) pricing: you only pay for what you use.
- Price: $0.075 per API unit.
- 1 API unit = 1 second of output video at 1080p. Units are the requested `duration` times the resolution factor, rounded up to a whole unit per request.
- `resolution: "1080p"` (the default): 1 unit per second, so $0.075 per second of video.
- `resolution: "2k"`: 2 units per second, so $0.15 per second of video.
- `resolution: "4k"`: 4 units per second, so $0.30 per second of video.
- Worked example: the default 6 second video at 1080p is 6 units = $0.45. A 6 second video at 2k is 12 units = $0.90, and at 4k it is 24 units = $1.80. A 20 second video at 1080p is 20 units = $1.50.
- `fps`, `aspect_ratio`, `camera_motion` and `generate_audio` do not change the price.
- 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 should be made to: `https://prod.api.market/api/v1/magicapi/fast-video-generator-lightricks-ltx-2-3-fast`

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

### Asynchronous Processing
This API is asynchronous:
1. Send a POST request to `/predictions`. A successful request returns `201 Created` with a prediction `id` and a `status` of `starting` or `processing`. 201 means the job was accepted; it is not an error.
2. Poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
3. When `status` is `succeeded`, `output` holds the generated video as a URL.

Your code should:
- Wait about 1 second between status checks.
- Stop after a timeout you choose (the examples below use 600 seconds).
- Keep polling while `status` is `starting` or `processing`.
- Read `output` when `status` is `succeeded`.
- Handle `failed` and `canceled` (read the `error` field) and the timeout case.

### Endpoints
#### POST /predictions
Create a prediction. This is the request we ran for the example above.

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-video-generator-lightricks-ltx-2-3-fast/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
  "version": "6e44d7e6b51d045abf444dbac11bafd94a053a689b4529793ce997e0110e473e",
  "input": {
    "prompt": "Ocean waves crash against black volcanic rocks at sunset, slow motion spray",
    "duration": 6
  }
}'
```

Response (`201 Created`):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "6e44d7e6b51d045abf444dbac11bafd94a053a689b4529793ce997e0110e473e",
  "status": "starting",
  "created_at": "2026-10-13T11:11:59.334Z"
}
```

#### GET /predictions/{id}
Get the status and result of a prediction.

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-video-generator-lightricks-ltx-2-3-fast/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (`200 OK`):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/ltx-2.3-fast-output-api-market.mp4",
  "created_at": "2026-10-13T11:11:59.334Z",
  "started_at": "2026-10-13T11:12:01.000Z",
  "completed_at": "2026-10-13T11:13:00.000Z"
}
```

### Status Codes
- 200 OK: Status request successful
- 201 Created: Prediction created (success)
- 400 Bad Request: Invalid input parameters or malformed request
- 401 Unauthorized: Missing or invalid API key
- 404 Not Found: Prediction not found
- 429 Too Many Requests: Rate limit exceeded
- 500 Internal Server Error: Server-side error
- 503 Service Unavailable: Service temporarily unavailable

### Input Parameters
Send these fields inside `input`. Only `prompt` is required.

| Parameter | Type | Default | Allowed values | Required | Description |
|---|---|---|---|---|---|
| `prompt` | string | none | any | Yes | Text prompt describing the video to generate. |
| `image` | string (URL) | none | any | No | First frame image for image-to-video generation. |
| `last_frame_image` | string (URL) | none | any | No | Last frame image for image-to-video generation. When provided, the video interpolates between the first frame and this last frame. |
| `resolution` | string | `"1080p"` | `1080p`, `2k`, `4k` | No | Resolution of the generated video. |
| `duration` | integer | `6` | `6`, `8`, `10`, `12`, `14`, `16`, `18`, `20` | No | Duration of the video in seconds. Durations longer than 10 seconds are only available with 1080p resolution at 24 or 25 FPS. |
| `aspect_ratio` | string | `"16:9"` | `16:9`, `9:16` | No | Aspect ratio of the generated video. |
| `fps` | integer | `25` | `24`, `25`, `48`, `50` | No | Frame rate in frames per second. |
| `camera_motion` | string | `"none"` | `none`, `dolly_in`, `dolly_out`, `dolly_left`, `dolly_right`, `jib_up`, `jib_down`, `static`, `focus_shift` | No | Camera motion effect to apply to the generated video. Use 'none' for no camera motion. |
| `generate_audio` | boolean | `true` | `true`, `false` | No | Generate audio for the video. |

### 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
### Example Code
#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/fast-video-generator-lightricks-ltx-2-3-fast";

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

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

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

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

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

  while (Date.now() - startTime < MAX_TIMEOUT) {
    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(POLL_INTERVAL);
  }

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

createAndWaitForPrediction({
  "prompt": "Ocean waves crash against black volcanic rocks at sunset, slow motion spray",
  "duration": 6
}).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/fast-video-generator-lightricks-ltx-2-3-fast"

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": "6e44d7e6b51d045abf444dbac11bafd94a053a689b4529793ce997e0110e473e", "input": input_data},
    )
    # 201 Created is the normal success response
    if response.status_code not in (200, 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({
    "prompt": "Ocean waves crash against black volcanic rocks at sunset, slow motion spray",
    "duration": 6
}))
```

#### cURL
```bash
# Step 1: create a prediction (returns 201 Created with an id)
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-video-generator-lightricks-ltx-2-3-fast/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
  "version": "6e44d7e6b51d045abf444dbac11bafd94a053a689b4529793ce997e0110e473e",
  "input": {
    "prompt": "Ocean waves crash against black volcanic rocks at sunset, slow motion spray",
    "duration": 6
  }
}'

# Step 2: check the prediction status (replace PREDICTION_ID with the id from step 1)
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-video-generator-lightricks-ltx-2-3-fast/predictions/PREDICTION_ID" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Repeat step 2 until status is "succeeded", "failed" or "canceled"
```

### Performance Optimization
- Stay at `1080p` unless you need a larger frame. 2k costs twice as much per second and 4k four times as much.
- Pick the shortest `duration` that fits. You pay per second of video.
- Remember that durations over 10 seconds need `1080p` with `fps` 24 or 25.
- Poll about once per second and stop polling as soon as the status is final.

## FAQ
**How long can a video be?**
6 to 20 seconds in 2 second steps. Durations longer than 10 seconds are only available at 1080p with 24 or 25 FPS.

**Can I start from an image?**
Yes. Pass a URL in `image` to use it as the first frame. Add `last_frame_image` and the video will interpolate between the first and last frame.

**Does the video have sound?**
By default, yes: `generate_audio` is `true`. Set it to `false` for a silent video.

**How is a request billed?**
Per second of video: $0.075 per second at 1080p, $0.15 at 2k and $0.30 at 4k. The default 6 second 1080p video costs $0.45. Failed or cancelled predictions are not billed.

## 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 a text prompt or first frame image using LTX-2.3 Fast from Lightricks. 1080p, 2K or 4K, camera motion presets, billed per second.