Name: LTX-2.5-Fast API: Fast Text and Image to Video
Brand: magicapi
SKU: api-magicapi-fast-text-to-video-api-lightricks-ltx-2-5-fast
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 Fast Text-to-Video and Image-to-Video API (LTX-2.5-Fast)

## Overview
This API runs LTX-2.5-Fast from Lightricks, a fast video generation model for text-to-video and image-to-video. It supports portrait (9:16) and landscape (16:9) output, generates synchronized audio by default, and can interpolate between a first frame and a last frame that you provide.

You choose the resolution (`720p`, `1080p`, `2k` or `4k`), the duration (2 to 20 seconds) and the frame rate (24, 25, 48 or 50 FPS). Videos longer than 10 seconds are available at 720p or 1080p with 24 or 25 FPS.

## Features
- **Text-to-video:** `prompt` is the only required field.
- **Image-to-video:** pass `image` as the first frame. Add `last_frame_image` and the video interpolates between the first frame and the last frame.
- **Synchronized audio:** `generate_audio` is `true` by default; set it to `false` for a silent video.
- **Four resolutions:** `720p`, `1080p` (default), `2k` and `4k`. Higher resolutions cap the maximum duration.
- **Durations:** 2, 3, 4, 5, 6 (default), 8, 10, 12, 14, 16, 18 or 20 seconds. Durations over 10 seconds need 720p or 1080p at 24 or 25 FPS.
- **Frame rate:** 24, 25 (default), 48 or 50 FPS. 48 and 50 FPS cap at 10 seconds.
- **Portrait or landscape:** `aspect_ratio` `16:9` (default) or `9:16`.

## Use Cases
1. **Social media clips:** vertical 9:16 videos with sound from a text prompt.
2. **Product and marketing videos:** animate a product photo from a first frame image.
3. **Transitions:** give a first and a last frame and let the model generate the motion between them.
4. **B-roll and backgrounds:** nature, city or abstract footage generated from a description.

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

**Prompt:** "Ocean waves crashing against black volcanic rocks at sunset, slow motion spray, the roar of the surf"

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

The linked file is a smaller re-encoded copy for this page, so its resolution is not the resolution the API returns.

## Pricing
- **Pay As You Go (PAYG) pricing:** you only pay for what you use.
- **Price:** $0.038 per API unit.
- **API unit:** billing is per second of output video, rounded up to whole seconds. The number of units per second depends on `resolution`, and the total for a request is rounded up to whole units.

| `resolution` | Units per second | Price per second | 6 second clip |
|--------------|------------------|------------------|---------------|
| 720p | 1 | $0.038 | 6 units ($0.228) |
| 1080p | 2 | $0.076 | 12 units ($0.456) |
| 2k | 4 | $0.152 | 24 units ($0.912) |
| 4k | 8 | $0.304 | 48 units ($1.824) |

- A request that leaves `resolution` unset uses the default (`1080p`): $0.076 per second, so the default 6 second clip bills 12 units ($0.456). The example above cost the same.
- Frame rate, aspect ratio and audio do not change the price.
- Failed or cancelled predictions are not billed.
- GET requests to check prediction status (GET /api/v1/magicapi/fast-text-to-video-api-lightricks-ltx-2-5-fast/predictions/{id}) 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-text-to-video-api-lightricks-ltx-2-5-fast`

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

### Asynchronous Processing
**IMPORTANT:** 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`.
2. Poll GET `/predictions/{id}` with that ID.
3. Stop when `status` is `succeeded` (the video URL is in `output`), `failed` (see `error`) or `canceled`.

### Endpoints

#### POST /api/v1/magicapi/fast-text-to-video-api-lightricks-ltx-2-5-fast/predictions
Create a new prediction.

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-text-to-video-api-lightricks-ltx-2-5-fast/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "52475fac89a8e8a3e524418ac6875a988057a668e54302399dd19f09fcffa8d4",
    "input": {
      "prompt": "Ocean waves crashing against black volcanic rocks at sunset, slow motion spray, the roar of the surf",
      "resolution": "1080p",
      "duration": 6
    }
  }'
```

Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "52475fac89a8e8a3e524418ac6875a988057a668e54302399dd19f09fcffa8d4",
  "status": "starting",
  "created_at": "2026-10-11T19:13:29.374Z"
}
```

#### GET /api/v1/magicapi/fast-text-to-video-api-lightricks-ltx-2-5-fast/predictions/{id}
Check the status of a prediction and get the result.

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-text-to-video-api-lightricks-ltx-2-5-fast/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when finished (200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/ltx-2.5-fast-output-api-market.mp4",
  "error": null
}
```

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

### Status Codes
- **200 OK:** status check succeeded.
- **201 Created:** prediction created. This is the normal response to a POST, not an error.
- **400 Bad Request:** invalid input (for example a missing `prompt` or a value that is not in the allowed list).
- **401 Unauthorized:** missing or invalid API key.
- **404 Not Found:** unknown prediction ID.
- **429 Too Many Requests:** rate limit exceeded. Wait and retry with backoff.
- **500 Internal Server Error:** server-side error. Retry later.

### Error Handling
- A prediction can be created (201) and still fail later. When polling, check `status`: if it is `failed`, the `error` field explains why. Failed predictions are not billed.
- Check the duration rules before sending: more than 10 seconds needs `720p` or `1080p` with 24 or 25 FPS, and 48 or 50 FPS caps at 10 seconds.
- `duration` and `fps` accept only the listed values (for example 7 seconds is not allowed).
- Retry 429 and 5xx responses with exponential backoff.

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

## Input Parameters

| Parameter | Type | Default | Allowed Values | Required | Description |
|-----------|------|---------|----------------|----------|-------------|
| `prompt` | string | none | Text | Yes | Text prompt describing the video to generate. |
| `image` | string (URI) | null | Image URL | No | First frame image for image-to-video generation. |
| `last_frame_image` | string (URI) | null | Image URL | 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` | `720p`, `1080p`, `2k`, `4k` | No | Resolution of the generated video. Higher resolutions cap the maximum duration. Affects price. |
| `duration` | integer | 6 | 2, 3, 4, 5, 6, 8, 10, 12, 14, 16, 18, 20 | No | Duration in seconds. Durations longer than 10 seconds are only available at 720p or 1080p with 24 or 25 FPS. 48/50 FPS caps at 10 seconds. |
| `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. |
| `generate_audio` | boolean | true | `true`, `false` | No | Generate audio for the video, for text-to-video and image-to-video. |

## Implementation Guide

#### JavaScript Example
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/fast-text-to-video-api-lightricks-ltx-2-5-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: "52475fac89a8e8a3e524418ac6875a988057a668e54302399dd19f09fcffa8d4",
      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; // 10 minutes
  const POLL_INTERVAL = 2000; // 2 seconds between checks
  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 crashing against black volcanic rocks at sunset, slow motion spray, the roar of the surf",
  resolution: "1080p",
  duration: 6
}).then(videoUrl => console.log("Video:", videoUrl));
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/fast-text-to-video-api-lightricks-ltx-2-5-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": "52475fac89a8e8a3e524418ac6875a988057a668e54302399dd19f09fcffa8d4",
            "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  # 10 minutes
    POLL_INTERVAL = 2  # seconds between checks
    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")

video_url = create_and_wait_for_prediction({
    "prompt": "Ocean waves crashing against black volcanic rocks at sunset, slow motion spray, the roar of the surf",
    "resolution": "1080p",
    "duration": 6,
})
print("Video:", video_url)
```

## Tips
- Draft at `720p` (the cheapest resolution) and render the final version at a higher resolution.
- Each step up in resolution doubles the price per second: 1080p costs 2x, 2k 4x and 4k 8x the 720p rate.
- Describe sounds in the prompt (as in the example, "the roar of the surf") when `generate_audio` is on.
- For clips longer than 10 seconds, use `720p` or `1080p` with `fps` 24 or 25.

## FAQ
**Q: Do I need an input image?**
A: No. `prompt` is the only required field. Add `image` (and optionally `last_frame_image`) for image-to-video.

**Q: Does audio cost extra?**
A: No. The price depends only on resolution and the length of the video.

**Q: What does the API return?**
A: When the prediction succeeds, `output` is a URL to the generated video file.

**Q: What happens if my prediction fails?**
A: Failed or cancelled predictions are not billed. Check the `error` field, fix the input and retry.

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


Lightricks LTX-2.5-Fast API on api.market: text or image to video with synchronized audio, 16:9 or 9:16, 720p to 4K. Pay per second of video.