LTX-2.5-Fast

LTX-2.5-Fast

LTX-2.5-Fast is the speed-optimized variant of LTX-2.5, the newest generation of Lightricks' audio-video foundation model. From a text prompt, and optionally a first and a last frame, it produces cinematic video up to 4K, in five aspect ratios from vertical to square to widescreen, and up to 20 seconds in one generation, with a fully synchronized audio track. It can also tell a small story in one clip: native multi-shot generation cuts between connected shots while keeping characters, setting, lighting and voice consistent.

It brings LTX-2.5's sharper picture, finer detail and stronger prompt adherence to a fast, iteration-friendly tier: ideal for ads, social content, storyboards and product films where you want several angles of the same scene, for every placement, without stitching separate generations together.

Lightricks/LTX-2.5-Fast

At a glance

What's new in LTX-2.5

LTX-2.5 rebuilds several stages of the pipeline that LTX-2.3 introduced:

• Native multi-shot scenes. One generation can contain several connected shots. Characters, environment, lighting, visual style and voice stay consistent across the cuts, with no separate generations stitched together afterward.
• A diffusion video decoder. The final reconstruction stage is now a diffusion decoder instead of a VAE, for higher pixel quality and finer detail in textures, faces and typography.
• Diffusion Fidelity Rendering. Compute is allocated according to how complex each scene is.
• A new text encoder. A custom 12B Gemma 4 encoder reads long, multi-part prompts more faithfully, which matters when one prompt describes several shots.
• Stronger prompt adherence across action, camera and sound.

Why LTX-2.5-Fast

• Several shots, one request. Describe an establishing shot, a close-up and a reaction, and get them as one continuous, consistent clip.
• Up to 20 seconds. Enough room for a full shot list: a short ad, a product story or a complete social clip in one generation.
• Every placement, one model. 16:9 for YouTube and TV, 9:16 for Reels and TikTok, 1:1 for the feed, 3:2 and 2:3 for web heroes and Pinterest.
• Start from your own image. Give a first frame to animate a product photo or a key visual, and a last frame to decide exactly where the clip lands.
• Directed camera. Choose a dolly, a jib, a focus shift or a locked-off shot, so the movement is part of the brief.
• Picture and sound together. Ambience, effects, motion sounds and voices are generated with the frames, so they land on the right moment. Turn the audio off when you will add your own.
• From draft to 4K. Iterate at 720p, deliver at 1080p, 1440p or 4K with the same prompt.
• Built for iteration. The Fast tier is tuned for speed, so you can explore more ideas, angles and edits of the same scene.

Resolutions and aspect ratios

Each request selects one output resolution with resolution and one shape with aspect_ratio. Without them, the video is generated in 1080p, 16:9.

The resolution names the short side of the frame: 1080p is 1080 pixels on the short side, whatever the shape. Values are case-insensitive: 4K and 4k are the same. The price depends on the resolution you choose, not on the aspect ratio; the current rates are shown at the top of this page.

Which resolution to pick

• 720p: drafts, prompt and shot-list exploration, social previews.
• 1080p: the default; the best balance for most finished clips, and the highest resolution for clips over 10 seconds.
• 1440p: sharper faces, text and textures for large screens.
• 4K: final masters, hero shots and footage that will be cropped or reframed.

Which aspect ratio to pick

Video options

Every option is optional. An option you leave out takes its default.

A request with every option

{
  "model": "Lightricks/LTX-2.5-Fast",
  "prompt": "Close-up of a ceramic coffee cup on a wooden table as steam curls up in the morning light, a spoon clinking against the saucer. Cut to a medium shot of a woman lifting the cup and smiling at the window. Cut to a wide shot of the sunlit café, soft chatter and the hiss of the espresso machine.",
  "resolution": "1080p",
  "aspect_ratio": "1:1",
  "duration": 14,
  "fps": 24,
  "generate_audio": true,
  "camera_motion": "dolly_out",
  "image": "https://example.com/coffee-first-frame.jpg",
  "last_frame_image": "https://example.com/cafe-last-frame.jpg"
}

Length, resolution and frame rate together

The longest clips are available at the standard resolutions and frame rates. At 1440p, 4K, 48 fps or 50 fps, a clip is 6, 8 or 10 seconds:

This applies to every aspect ratio. A combination outside this table is refused before anything is generated, the error message lists the lengths that are available, and nothing is charged (see Errors).

Choosing the length

A longer clip needs a longer prompt. Give each shot its own action and sound, so the model has enough to fill the time.

Camera motion

The camera motion sets the movement; describe the subject's action, the look and the sound in the prompt, and keep the prompt consistent with the move you chose.

Matching the move to the intent

• Reveal a product or a place: dolly_out or jib_up.
• Build tension or intimacy: dolly_in.
• Follow action across the frame: dolly_left or dolly_right.
• Descend into a scene: jib_down.
• Hand attention from one subject to another: focus_shift.
• Let the subject carry the shot (talking heads, product hero shots): static.

Frame rate

• 24 fps: the cinematic standard, and the default.
• 25 fps: the PAL broadcast standard, for TV in Europe, Africa and the Middle East.
• 48 or 50 fps: smoother motion for fast action, sports and slow-motion editing, for clips of 6, 8 or 10 seconds.

Audio

The audio track is generated from your prompt, shot by shot, so describe the sound you want: the ambience, the effects, the voices, the rhythm of the scene. Send "generate_audio": false when you will add music or a voice-over yourself; the video then has no audio stream.

Image-to-video

Send image to use your own picture as the first frame: the model animates from it. Add last_frame_image to also fix the last frame, and the model generates the motion, and any cuts you describe, between the two. last_frame_image is only accepted together with image.

Each image can be sent as:

• an https:// URL;
• a data URI: data:image/png;base64,..., data:image/jpeg;base64,... or data:image/webp;base64,...;
• a file, in a multipart/form-data field named image or last_frame_image.

Requirements

• PNG, JPEG or WebP, at most 10 MB and at most 4096 pixels on a side. The type is read from the image itself, not from its name.
• The whole request body can be at most 10 MiB. A data URI is about a third larger than the image, so send large images as a URL.
• Images are kept only for the request and deleted afterwards.

Getting the best result

• The video keeps the aspect_ratio you ask for (16:9 by default). Give a first frame of the same shape: a square image for 1:1, a portrait image for 9:16 or 2:3, a landscape image for 16:9 or 3:2.
• For a first and a last frame, use two images of the same world: the same product, character or place, so the model can connect them.
• Describe the motion, not the picture. The model already sees the frame; tell it what moves, how the camera moves, where it cuts and what we hear.

Quick start

Multi-shot text-to-video (cURL)

curl -X POST 'https://api.devupai.com/v1/video/generations' \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Lightricks/LTX-2.5-Fast",
    "prompt": "Wide shot of a quiet desert road at dawn, a vintage motorcycle approaching from the horizon, engine growing louder. Cut to a close-up of the rider lifting her goggles, wind and distant birds. Cut to a low angle as the motorcycle roars past the camera and fades into the dust.",
    "resolution": "1080p",
    "duration": 10
  }'

A 20-second vertical ad for Reels and Shorts (cURL)

curl -X POST 'https://api.devupai.com/v1/video/generations' \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Lightricks/LTX-2.5-Fast",
    "prompt": "Close-up of hands opening a small kraft box on a marble counter, paper rustling. Cut to a medium shot of a young woman lifting a glass serum bottle to the light, a soft chime. Cut to a close-up of a single drop falling onto her fingertips. Cut to a wide shot of her smiling at the mirror in a bright bathroom, gentle music and morning birds.",
    "resolution": "1080p",
    "aspect_ratio": "9:16",
    "duration": 20
  }'

A square product clip from a photo (Python)

import os
import requests

response = requests.post(
    "https://api.devupai.com/v1/video/generations",
    headers={
        "Authorization": f"Bearer {os.environ['DEVUP_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "Lightricks/LTX-2.5-Fast",
        "prompt": (
            "The sneaker slowly turns on a white studio floor as soft light "
            "sweeps across the leather. Cut to a close-up of the sole flexing "
            "as a foot steps down. A soft whoosh and a confident footstep."
        ),
        "image": "https://example.com/sneaker-square.png",
        "resolution": "1080p",
        "aspect_ratio": "1:1",
        "duration": 8,
        "camera_motion": "dolly_in",
    },
    timeout=600,
)

result = response.json()
if response.status_code != 200:
    raise RuntimeError(result["error"]["message"])

video_url = result["data"][0]["url"]
with open("sneaker.mp4", "wb") as f:
    f.write(requests.get(video_url, timeout=600).content)

print(result["_devup"])

First and last frame (JavaScript, Node.js)

import { writeFile } from "node:fs/promises";

const response = await fetch("https://api.devupai.com/v1/video/generations", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.DEVUP_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "Lightricks/LTX-2.5-Fast",
    prompt:
      "The empty room fills with furniture piece by piece as morning light " +
      "moves across the floor. Soft footsteps and the rustle of fabric.",
    image: "https://example.com/room-empty.jpg",
    last_frame_image: "https://example.com/room-furnished.jpg",
    resolution: "1080p",
    duration: 8,
    camera_motion: "static",
  }),
});

const result = await response.json();
if (!response.ok) throw new Error(result.error.message);

const video = await fetch(result.data[0].url);
await writeFile("room.mp4", Buffer.from(await video.arrayBuffer()));

console.log(result._devup);

Uploading the image as a file (cURL, multipart)

curl -X POST 'https://api.devupai.com/v1/video/generations' \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -F model="Lightricks/LTX-2.5-Fast" \
  -F prompt="The handbag slowly rotates on a velvet stand. Soft light glides across the leather. A quiet, elegant tone." \
  -F image=@handbag.png \
  -F resolution="720p" \
  -F aspect_ratio="2:3" \
  -F duration="6" \
  -F generate_audio="false"

In a multipart request, every option is sent as a text field and read the same way as in JSON.

Response

{
  "data": [
    {
      "url": "<video-url>"
    }
  ],
  "_devup": {
    "cost_dzd": "<cost_dzd>",
    "balance_dzd": "<balance_dzd>",
    "request_id": "req_<id>"
  }
}

• data[0].url is a signed link to the MP4. It expires, so download the file rather than storing the link.
• Send "response_format": "b64_json" to receive the video Base64-encoded in data[0].b64_json instead of a link.
• _devup.cost_dzd is what the request cost, _devup.balance_dzd your remaining balance, and _devup.request_id the id to quote to support.

Billing

• You are billed per second of video actually generated, at the rate of the resolution you chose.
• Your balance must cover the length you request before the generation starts.
• Aspect ratio, frame rate, audio, camera motion, images and the number of shots do not change the price.

Errors

Every option is checked before anything is generated. A value or a combination the model does not accept returns HTTP 400 with the code invalid_value, the message lists what is available, and nothing is charged.

A resolution the model does not offer:

{
  "error": {
    "message": "`8k` is not available for this model. Available: `720p`, `1080p`, `1440p`, `4k`.",
    "type": "devup_error",
    "code": "invalid_value"
  }
}

A clip length that is too long for the resolution:

{
  "error": {
    "message": "`duration` 12 is not available with `resolution` `4k` on this model. Available: 6, 8, 10.",
    "type": "devup_error",
    "code": "invalid_value"
  }
}

The same check applies to 48 and 50 fps: above 10 seconds, the message lists the lengths available at that frame rate.

An image that cannot be used (wrong type, too large, unreachable) also returns HTTP 400 invalid_value, and the message names the field and what to send.

A request your balance cannot cover returns HTTP 402 before anything is generated, and before any image is downloaded.

Full reference: Text-to-video → Video options, Image to video, Output resolution and Errors.

Writing multi-shot prompts

LTX-2.5 decides the cuts from your words, so the prompt works like a short shot list.

1. One scene, several shots. Keep the same place and the same characters, and change the framing between shots.
2. Mark the cuts. Start each new shot with Cut to…, and name the framing: wide shot, close-up, over-the-shoulder, low angle.
3. Describe characters the same way every time. Reuse the same words for a person or object (the rider, the red motorcycle) so the model keeps them consistent.
4. Give each shot its sound. Engine growing louder, wind and distant birds, a door slams. The audio follows your description shot by shot.
5. Match the number of shots to the length. Two or three shots read best in 6 to 10 seconds; a 20-second clip has room for a full shot list.
6. Want one continuous take? Don't mark any cut, and set the move with camera_motion.
7. With an image, start from it. Your first frame is the opening shot; describe what happens next and where the cuts go.
8. Draft in 720p, finish in 1080p and above. Lock the shot list at the lowest resolution, then render the keeper at the resolution you need.

Example

Close-up of a chef's hands slicing fresh herbs on a wooden board, the knife tapping steadily. Cut to a medium shot of the chef tossing vegetables in a flaming pan, oil sizzling loudly. Cut to a wide shot of the busy open kitchen, warm light, plates clinking and orders being called.

A production workflow

1. Write the shot list. One line per shot: framing, action, sound. Mark each cut with Cut to….
2. Explore at 720p. Try the shot list at 6 to 10 seconds and adjust the cuts, the camera motion and the wording.
3. Lock the frames. When the clip depends on a product or a key visual, switch to image-to-video with your own first frame, and a last frame if the ending matters.
4. Set the length and the placement. Choose the aspect_ratio for where the clip will run, and raise duration to fit the shot list.
5. Render the final. Keep the same prompt and options, and raise resolution to 1080p for long clips, or to 1440p or 4K for clips up to 10 seconds.
6. Need maximum fidelity? Send the same request to LTX-2.5-Pro: only the model changes.

Fast or Pro?

The request is the same on both: switch the model and keep the rest.

LTX-2.5 or LTX-2.3?

• LTX-2.5 adds native multi-shot scenes, a diffusion decoder for finer detail, and three more aspect ratios (1:1, 3:2, 2:3).
• LTX-2.3 offers 16:9 and 9:16, with the same lengths, frame rates, camera motions and image-to-video, and remains a strong choice for single continuous shots.

Under the hood

LTX-2.5 extends the LTX-2 architecture, which Lightricks describes in its technical report: a video stream and an audio stream run side by side and exchange information through bidirectional cross-attention, which keeps sound and picture aligned in time.

The LTX-2 architecture that LTX-2.5 builds on. Source: LTX-2: Efficient Joint Audio-Visual Foundation Model, Lightricks.

On top of that foundation, LTX-2.5 replaces the VAE reconstruction stage with a diffusion video decoder, adds Diffusion Fidelity Rendering, and swaps in a custom Gemma 4 12B text encoder built for long, multi-part prompts.

Benchmarks

Artifact benchmark

Lightricks published a preliminary, automatically graded artifact benchmark with the LTX-2.5 release. It runs 98 text-to-video prompts and scores visual artifacts; lower is better.

The scores are for the Pro tier of each generation. Lightricks has not published a separate score for the Fast variant; the figures show the generational jump from LTX-2.3 to LTX-2.5.

The LTX-2 foundation

From the LTX-2 technical report, the architecture LTX-2.5 builds on:

On DEVUP AI, LTX-2.5-Fast generates up to 20 seconds in one request, at 720p and 1080p.

Best use cases

• Ads and product films: establishing shot, product close-up and lifestyle shot in one clip, up to 20 seconds.
• One campaign, every placement: the same prompt rendered in 16:9, 9:16, 1:1 and 2:3 for YouTube, Reels, the feed and Pinterest.
• E-commerce: animate a product photo with image-to-video, in square for listings or vertical for social.
• Social and short-form content: Reels, Shorts and TikTok stories with several shots and sound built in.
• Storyboards and pre-visualization: test a sequence of camera angles and cuts before a shoot or a Pro render.
• Narrative moments: short scenes with a consistent character across cuts.

Limitations

• Multi-shot results depend on how clearly the prompt marks each shot; vague prompts may produce a single take or unexpected cuts.
• Like LTX-2.3, the model may not follow every detail of a prompt, and scenes without clear sound sources can have weaker audio.
• Generative video models can reflect societal biases and produce inappropriate content. Review outputs before publishing.

On DEVUP AI:

• Clips longer than 10 seconds are available at 720p and 1080p, at 24 or 25 fps.
• Only use images you have the right to use.

Resources

• LTX-2.5 model card on Hugging Face
• LTX-2 technical report (arXiv)
• LTX-2 on GitHub
• LTX-2.x Community License
• DEVUP AI text-to-video documentation