LTX-2.3-Fast

LTX-2.3-Fast

LTX-2.3-Fast is the speed- and cost-optimized variant of LTX-2.3, Lightricks' production-ready audio-video foundation model. It turns a text prompt, and optionally a first and a last frame, into a cinematic video in landscape or portrait, up to 4K, and up to 20 seconds in a single shot, with an AI-generated audio track synchronized to the scene: ambience, effects and motion sounds produced together with the picture, in a single generation.

It is the most affordable way to reach LTX-2.3 quality and the longest clip in the LTX-2.3 line, which makes it the natural choice for prototyping, content at volume, social clips, storyboards and product visuals, while still scaling up to 1440p and 4K when a shot needs the detail.

Lightricks/LTX-2.3-Fast

At a glance

Why LTX-2.3-Fast

• Up to 20 seconds in one shot. Long enough for a full product reveal, a complete social clip or a continuous establishing shot, with no stitching between generations.
• Picture and sound in one pass. LTX-2.3 generates the video and its audio jointly, so footsteps, waves, engines and ambience land on the frame they belong to. Turn the audio off when you will add your own.
• Landscape or portrait. Render 16:9 for YouTube, the web and TV, or 9:16 for Reels, Shorts and TikTok, from the same model and the same prompt.
• Start from your own image. Give a first frame to animate a product photo, a character or a key visual, and a last frame to decide exactly where the shot lands.
• Directed camera. Choose a dolly, a jib, a focus shift or a locked-off shot, so the movement is part of the brief and not left to chance.
• Up to 4K. Choose the output resolution per request, from 720p for fast iteration up to 4K for final delivery.
• Built for iteration. The Fast variant trades a little headroom for speed and cost, so you can try more prompts, more angles and more variations of the same idea, then render the keeper in the resolution you need.

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.

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 exploration, social previews.
• 1080p: the default; the best balance for most finished clips, and the highest resolution for clips over 10 seconds.
• 1440p: sharper detail for large screens and cropping room in editing.
• 4K: final masters, hero shots and content that will be reframed or downscaled.

Which aspect ratio to pick

• 16:9: YouTube, websites, presentations, TV and most ad placements.
• 9:16: Instagram Reels, YouTube Shorts, TikTok and Stories, full-screen on a phone.

Video options

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

A request with every option

{
  "model": "Lightricks/LTX-2.3-Fast",
  "prompt": "A slow push toward a ceramic coffee cup on a wooden table as steam curls up in the morning light. A spoon clinks softly against the saucer.",
  "resolution": "1080p",
  "aspect_ratio": "9:16",
  "duration": 12,
  "fps": 24,
  "generate_audio": true,
  "camera_motion": "dolly_in",
  "image": "https://example.com/coffee-first-frame.jpg",
  "last_frame_image": "https://example.com/coffee-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:

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: describe what happens first, next and last, so the model has enough action 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, so describe the sound you want: the ambience, the effects, 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 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 landscape image for 16:9, a portrait image for 9:16.
• For a first and a last frame, use two images of the same scene, framing and lighting; the model generates the change between them.
• Describe the motion, not the picture. The model already sees the frame; tell it what moves, how the camera moves and what we hear.

Quick start

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.3-Fast",
    "prompt": "A slow tracking shot along a rocky Mediterranean shore at golden hour. Waves crash against the rocks and spray catches the warm light. Gulls call in the distance and the surf rumbles steadily.",
    "resolution": "1080p",
    "duration": 10,
    "camera_motion": "dolly_right"
  }'

A 20-second vertical clip 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.3-Fast",
    "prompt": "A street food vendor in Algiers flips a sizzling msemen on a hot griddle. He folds it, lifts it onto a plate and hands it to a smiling customer. Steam rises in the evening light. Oil crackles and the street hums behind him.",
    "resolution": "1080p",
    "aspect_ratio": "9:16",
    "duration": 20,
    "camera_motion": "dolly_in"
  }'

Image-to-video (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.3-Fast",
        "prompt": (
            "The perfume bottle slowly turns on a marble pedestal. "
            "Soft light sweeps across the glass and catches the gold cap. "
            "A quiet, elegant ambient tone."
        ),
        "image": "https://example.com/perfume-bottle.png",
        "resolution": "1080p",
        "duration": 6,
        "camera_motion": "static",
    },
    timeout=600,
)

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

video_url = result["data"][0]["url"]
with open("perfume.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.3-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.3-Fast" \
  -F prompt="The sneaker rotates slowly on a white studio floor. A soft whoosh as it turns." \
  -F image=@sneaker.png \
  -F resolution="720p" \
  -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 and images 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 prompts that work

LTX models respond best to a prompt that reads like a short shot description. Lightricks notes that prompt-following depends heavily on prompt style, so structure matters.

1. Start with the shot. Name the framing: close-up, wide shot, over-the-shoulder. Set the movement with camera_motion, and keep the prompt consistent with it.
2. Describe the action in order. Say what happens first, then next, in plain present-tense sentences.
3. Set the look. Lighting, time of day, color palette, lens feel: golden hour, neon reflections on wet asphalt, soft overcast light.
4. Write the sound. The audio is generated from your words, so describe it: rain on a tin roof, a crowd murmuring, a low engine hum.
5. Keep it to one scene. One location and one continuous moment per clip gives the cleanest result.
6. Match the length to the action. A 6-second clip holds one gesture; a 20-second clip needs a sequence of actions to fill it.
7. With an image, describe the motion, not the picture. The model already sees the frame; tell it what moves, how, and what we hear.
8. Draft in 720p, finish in 1080p and above. Iterate on the prompt at the lowest resolution, then render the keeper at the resolution you need.

Example

A close-up of a barista's hands pouring steamed milk into a cup, forming a leaf pattern. The camera slowly pulls back to reveal a small, sunlit café. Warm morning light, shallow depth of field. The espresso machine hisses softly and cups clink in the background.

More guidance: Lightricks prompting guide for LTX-2.

A production workflow

1. Explore at 720p. Try several prompts and camera motions at 6 seconds; it is the fastest and cheapest way to find the shot.
2. Lock the frames. When the shot depends on a product or a layout, switch to image-to-video with your own first frame, and a last frame if the ending matters.
3. Set the length. Raise duration to the length the edit needs, and extend the prompt so the action fills it.
4. 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.
5. Need maximum fidelity? Send the same request to LTX-2.3-Pro: only the model changes.

Fast or Pro?

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

Under the hood: the LTX architecture

LTX-2.3 builds on LTX-2, which Lightricks describes in its technical report as an open audiovisual diffusion model that generates synchronized video and audio from one architecture.

LTX-2 overview. Source: LTX-2: Efficient Joint Audio-Visual Foundation Model, Lightricks.

• Two coupled streams. A video stream and an audio stream run side by side and exchange information through bidirectional cross-attention, which is what keeps sound and picture aligned in time.
• Rich text understanding. Prompts are encoded with a large multilingual language model and passed through a dedicated text connector, so timing, motion and expression in the prompt carry into the result.
• Modality-aware guidance. Guidance is applied separately to the picture and to the sound, so each follows the prompt without overpowering the other.

The dual-stream design with audio-video cross-attention. Source: LTX-2 technical report.

What LTX-2.3 adds

Lightricks presents LTX-2.3 as its most production-ready release, with:

• A redesigned VAE, trained on higher-quality data, for sharper fine detail in hair, edges and textures;
• An upgraded text connector that follows timing, motion and expression in the prompt more faithfully;
• A new audio vocoder with fewer silence gaps and artifacts, and tighter alignment between sound and picture;
• Stronger motion, with less of the slow-pan "Ken Burns" look;
• 22 billion parameters, up from 19 billion in LTX-2.

Benchmarks

Lightricks has not published benchmark scores for LTX-2.3-Fast itself. The figures below come from the LTX-2 technical report, the architecture LTX-2.3 builds on.

Speed

Time per diffusion step on an NVIDIA H100, 121 frames at 720p:

LTX-2 is about 18× faster per step than Wan 2.2-14B, while also generating audio.

Clip length in one generation

On DEVUP AI, LTX-2.3-Fast generates the full 20 seconds in one request, at 720p and 1080p.

Quality

• Human preference: the report states that LTX-2 significantly outperforms Ovi, the open audio-video model it was compared with, and reaches preference scores comparable to leading proprietary models, including Veo 3 and Sora 2. No numeric scores were published.
• Independent leaderboard: at the time of the report, LTX-2 ranked 3rd in image-to-video and 4th in text-to-video on the Artificial Analysis video arena.

Best use cases

• Social and short-form content: vertical 9:16 Reels, Shorts and TikTok clips with sound built in, up to 20 seconds.
• E-commerce and product visuals: animate a product photo with image-to-video, then add a slow dolly or a static hero shot.
• Content at volume: many variations of the same idea, angle or product, at a cost that scales.
• Advertising and storyboards: test concepts, camera moves and pacing before a shoot or before a Pro render.
• Transitions and reveals: fix the first and last frame to control a before-and-after, a makeover or a reveal.
• B-roll and atmosphere: landscapes, cityscapes, establishing shots and nature ambience in one long take.

Limitations

From Lightricks' model card:

• The model is not intended to provide factual information.
• It may not match every prompt exactly; results depend strongly on how the prompt is written.
• Audio without speech may be of lower quality than scenes with clear sound sources.
• Like other generative models, it may reflect or amplify societal biases, and it may 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 technical report (arXiv)
• LTX-2 on GitHub
• LTX-2.3 model card on Hugging Face
• LTX-2 Community License
• DEVUP AI text-to-video documentation