LTX-2.3-Pro

LTX-2.3-Pro

LTX-2.3-Pro is the higher-fidelity 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 at 50 fps, 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 tuned for the cleanest LTX-2.3 result rather than the fastest: sharper fine detail, steadier motion and more faithful prompt following, for clips that go straight into an edit, an ad or a client delivery. Every option is available at every resolution: 4K, 50 fps, any camera motion, from your own frames.

Lightricks/LTX-2.3-Pro

At a glance

Why LTX-2.3-Pro

• Built for final renders. The Pro variant is tuned for fidelity: draft the prompt on LTX-2.3-Fast, then render the keeper here with the same prompt and the same options.
• No trade-offs between options. 4K at 50 fps for 10 seconds is a valid request. Resolution, frame rate, length and camera motion combine freely.
• 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.
• 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.
• Cinematic motion. The LTX-2.3 generation was trained to produce real movement and sharper fine detail (hair, edges, textures) than earlier LTX releases.

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.
• 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-Pro",
  "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": "4k",
  "aspect_ratio": "16:9",
  "duration": 10,
  "fps": 50,
  "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

On LTX-2.3-Pro, every length works at every resolution and every frame rate:

Need a longer single shot? LTX-2.3-Fast goes up to 20 seconds at 720p and 1080p.

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. On Pro, available at every resolution, including 4K.

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.

This is the most precise way to work on Pro: your key visual stays exactly as designed, and the model adds the motion, the camera move and the sound.

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.
• For 1440p and 4K output, start from a sharp, high-resolution image.

Quick start

Text-to-video in 4K (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-Pro",
    "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": "4k",
    "duration": 10,
    "camera_motion": "dolly_right"
  }'

A smooth vertical clip at 50 fps (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-Pro",
    "prompt": "A runner sprints along the Algiers seafront at sunrise, sweat catching the light. Fast footsteps on stone, waves breaking, heavy breathing.",
    "resolution": "1080p",
    "aspect_ratio": "9:16",
    "fps": 50,
    "duration": 8,
    "camera_motion": "dolly_left"
  }'

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-Pro",
        "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": "1440p",
        "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("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-Pro",
    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: 10,
    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-Pro" \
  -F prompt="The sneaker rotates slowly on a white studio floor. A soft whoosh as it turns." \
  -F image=@sneaker.png \
  -F resolution="1080p" \
  -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 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 the model does not offer:

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

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. Fill the length. 6 seconds holds one gesture; 10 seconds needs a short sequence of actions.
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 cheaply, finish here. Iterate at 720p, or on LTX-2.3-Fast, then render the final version on Pro with the same prompt and options.

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 cheaply. Find the shot on LTX-2.3-Fast or at 720p: try several prompts and camera motions at 6 seconds.
2. Lock the frames. When the shot depends on a product, a key visual or an approved storyboard, switch to image-to-video with your own first frame, and a last frame if the ending matters.
3. Set the length and the motion. Choose 6, 8 or 10 seconds, the frame rate the edit needs, and extend the prompt so the action fills the time.
4. Render the final on Pro. Keep the same prompt and options, change the model to Lightricks/LTX-2.3-Pro, and raise resolution to 1080p, 1440p or 4K.
5. Deliver. Download the MP4 from data[0].url right away: the link expires.

Pro or Fast?

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

Artifact benchmark

With the LTX-2.5 release, Lightricks published a preliminary, automatically graded benchmark that scores visual artifacts on 98 text-to-video prompts. Lower is better.

LTX-2.3 Pro remains the reference LTX-2.3 tier; for the lowest artifact rate, see LTX-2.5 Pro.

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

These are architecture figures from the report. On DEVUP AI, LTX-2.3-Pro generates up to 10 seconds per request; LTX-2.3-Fast goes up to 20.

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

• Advertising and brand films: 4K hero shots with a directed camera move and sound built in.
• E-commerce and product visuals: animate the exact product photo with image-to-video, at 1440p or 4K.
• Client deliveries: first and last frame locked to the storyboard, so the shot starts and ends where it was approved.
• Social and short-form content: vertical 9:16 Reels, Shorts and TikTok clips, at 50 fps for action.
• Sports and fast action: 48 or 50 fps at any resolution, for smooth motion and slow-motion editing.
• B-roll and atmosphere: landscapes, cityscapes, establishing shots and nature ambience in 4K.

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 are 6, 8 or 10 seconds long. For longer single shots, use LTX-2.3-Fast.
• 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