LTX Video 0.9.8 13B Distilled — Multi-conditioning

Generate a video from a prompt and any number of images and video.

Input

Add your inputs and customize the generation settings.

Prompt *

Text prompt to guide generation

Additional Settings

Customize your input with more control.

Negative Prompt

Negative prompt for generation

Loras

LoRA weights to use for generation

Resolution

Resolution of the generated video.

Aspect Ratio

The aspect ratio of the video.

Seed

Random seed for generation

Number of Frames

The number of frames in the video.

Number of Inference Steps

Number of inference steps during the first pass.

Second Pass Number of Inference Steps

Number of inference steps during the second pass.

Second Pass Skip Initial Steps

The number of inference steps to skip in the initial steps of the second pass. By skipping some steps at the beginning, the second pass can focus on smaller details instead of larger changes.

Frame Rate

The frame rate of the video.

Expand Prompt

Whether to expand the prompt using a language model.

Reverse Video

Whether to reverse the video.

Enable Safety Checker

Whether to enable the safety checker. Disabling it requires account authorization; unauthorized requests are always checked.

Enable Detail Pass

Whether to use a detail pass. If True, the model will perform a second pass to refine the video and enhance details. This incurs a 2.0x cost multiplier on the base price.

Temporal AdaIN Factor

Input guidance

The factor for adaptive instance normalization (AdaIN) applied to generated video chunks after the first. This can help deal with a gradual increase in saturation/contrast in the generated video by normalizing the color distribution across the video. A high value will ensure the color distribution is more consistent across the video, while a low value will allow for more variation in color distribution.

Tone Map Compression Ratio

Input guidance

The compression ratio for tone mapping. This is used to compress the dynamic range of the video to improve visual quality. A value of 0.0 means no compression, while a value of 1.0 means maximum compression.

Constant Rate Factor

The constant rate factor (CRF) to compress input media with. Compressed input media more closely matches the model's training data, which can improve motion quality.

Images

URL of images to use as conditioning

Videos

Videos to use as conditioning

Calculate credits for your selected settings before generating.

Result & Pricing

Video output — your generated video will appear here.

Your video will appear here

Choose your inputs and customize your settings.

Model pricing (tax excluded) per video second at the documented billing FPS

Specification	Webot INR
Rate	₹2.40

Calculate credits in the input panel for your selected settings.

Prices, estimates and credit deductions exclude tax. Any applicable tax is charged only when you buy plans or credits.

Detail-pass cost factor: ×2. Billed video seconds = frames ÷ 24. Prices are converted to INR. Credits use your current plan rate.

Prices shown are estimates, not final charges. Final billing details will be available in Reports after generation is complete.

API

WEBOT API · Multi-conditioning

Generate from your server with your WEBOT account credits.

API Keys OpenAPI JSON

Use your 120-character WEBOT customer key (a–z, A–Z, 0–9). Send Authorization: Bearer YOUR_KEY. Keys are secrets: call from a server, never from public frontend code. Results come from verified webhooks and remain saved if your stream disconnects.

1. Configure your server

WEBOT_BASE_URL=https://webot.online
WEBOT_API_KEY=<your-server-side-WEBOT-key>

This base URL is resolved from verified domain mappings and your direct creator reseller. Forwarded Host headers are not trusted. New custom reseller domains need DNS, TLS and platform verification before activation.

2. Quote, then generate

Method	Endpoint	Purpose
POST	`https://webot.online/api/v1/models/ltxv_13b_098_distilled_multiconditioning/quote`	Validate input and calculate credits (no deduction).
POST	`https://webot.online/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests`	Reserve quoted credits and queue an asynchronous job.
GET	`https://webot.online/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests/{request_id}/result`	Read your saved result: 202 pending, 200 terminal.
GET	`https://webot.online/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests/{request_id}/events`	Authenticated SSE: generation / terminal events.

Send JSON {"input":{…}} to quote. Send the same input plus integer quoted_credits to generate, with Authorization: Bearer … and Idempotency-Key. Use a unique 16–128 character key per new job; persist it and reuse the same key and input on any uncertain response. Never retry with a new key: that creates a second chargeable job.

Credits are reserved only after validation and a durable request is saved. A changed quote or insufficient balance returns 409. Credits exclude purchase taxes. The quoted amount is an initial reservation. After generation, the final charge replaces it using confirmed usage. Any verified unused allocation becomes available automatically; additional usage may require more credits. Missing billing stays pending, including for failed jobs.

3. Input example

Save this as input.json. Replace sample prompts, files and media URLs with your own. Schemas do not guarantee provider acceptance of the content.

Supported generation options

Disable automatic and temporal downsampling for verified frame billing.

{
    "prompt": "Audit sample text",
    "constant_rate_factor": 29,
    "reverse_video": false,
    "num_frames": 121,
    "videos": [],
    "enable_safety_checker": true,
    "second_pass_skip_initial_steps": 5,
    "loras": [],
    "temporal_adain_factor": 0.5,
    "frame_rate": 24,
    "images": [],
    "first_pass_num_inference_steps": 8,
    "second_pass_num_inference_steps": 8,
    "negative_prompt": "worst quality, inconsistent motion, blurry, jittery, distorted",
    "aspect_ratio": "auto",
    "enable_detail_pass": false,
    "resolution": "720p",
    "expand_prompt": false,
    "tone_map_compression_ratio": 0
}

4. Language examples

Server-side language

# Save the model's example input as input.json, then replace prompts/media URLs.
# Requires curl and jq. Store NONCE once for this job; reuse it on any retry.
export NONCE="$(openssl rand -hex 16)"
BASE="${WEBOT_BASE_URL%/}"
jq -n --slurpfile input input.json '{input:$input[0]}' > quote-body.json
curl --fail-with-body -sS "$BASE/api/v1/models/ltxv_13b_098_distilled_multiconditioning/quote" \
  -H "Authorization: Bearer $WEBOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @quote-body.json > quote.json
CREDITS=$(jq -er '.quote.credits_consumed' quote.json)
jq --argjson credits "$CREDITS" '. + {quoted_credits:$credits}' quote-body.json > request-body.json
curl --fail-with-body -sS "$BASE/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests" \
  -H "Authorization: Bearer $WEBOT_API_KEY" -H "Idempotency-Key: $NONCE" \
  -H 'Content-Type: application/json' --data-binary @request-body.json > job.json
# Subscribe; after a nonterminal disconnect, reconnect this SAME URL.
curl --fail-with-body -N "$(jq -er '.events_url' job.json)" -H "Authorization: Bearer $WEBOT_API_KEY"
# Read saved output after terminal notification (never call provider status/results).
curl --fail-with-body -sS "$(jq -er '.result_url' job.json)" -H "Authorization: Bearer $WEBOT_API_KEY"

// Node.js 18+. Save your customized input in input.json.
import { readFileSync } from 'node:fs';
import { randomUUID } from 'node:crypto';
const base = process.env.WEBOT_BASE_URL.replace(/\/$/, '');
const key = process.env.WEBOT_API_KEY;
const input = JSON.parse(readFileSync('input.json', 'utf8'));
const nonce = process.env.WEBOT_JOB_NONCE || randomUUID(); // Persist before submission.
async function post(path, body, nonce) {
  const response = await fetch(base + path, {method:'POST', headers:{
    Authorization:`Bearer ${key}`, 'Content-Type':'application/json',
    ...(nonce ? {'Idempotency-Key':nonce} : {})}, body:JSON.stringify(body)});
  const json = await response.json();
  if (!response.ok) throw new Error(JSON.stringify(json));
  return json;
}
const {quote} = await post('/api/v1/models/ltxv_13b_098_distilled_multiconditioning/quote', {input});
const job = await post('/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests', {input, quoted_credits:quote.credits_consumed}, nonce);
console.log(job); // Stable WEBOT request_id, events_url, result_url.
// Stream saved webhook state. Reconnect ONLY the event stream, not the generation.
while (!job.terminal || job.financial_pending) {
  const stream = await fetch(job.events_url, {headers:{Authorization:`Bearer ${key}`}});
  if (!stream.ok) throw new Error(`Event stream HTTP ${stream.status}`);
  let buffer = '';
  for await (const chunk of stream.body.pipeThrough(new TextDecoderStream())) {
    buffer += chunk;
    let end;
    while ((end = buffer.indexOf('\n\n')) !== -1) {
      const event = buffer.slice(0, end); buffer = buffer.slice(end + 2);
      const data = event.split('\n').find(line => line.startsWith('data: '));
      if (!data) continue;
      const state = JSON.parse(data.slice(6));
      if (state.error && !state.status) throw new Error(JSON.stringify(state.error));
      if (state.terminal && !state.financial_pending) { console.log(state.output ?? state.error); process.exit(0); }
    }
  }
  await new Promise(resolve => setTimeout(resolve, 1500));
}
console.log(job.output ?? job.error);

// Node.js 18+. Save your customized input in input.json.
import { readFileSync } from 'node:fs';
import { randomUUID } from 'node:crypto';
const base = process.env.WEBOT_BASE_URL!.replace(/\/$/, '');
const key = process.env.WEBOT_API_KEY!;
const input = JSON.parse(readFileSync('input.json', 'utf8'));
const nonce = process.env.WEBOT_JOB_NONCE || randomUUID(); // Persist before submission.
async function post(path: string, body: unknown, nonce?: string) {
  const response = await fetch(base + path, {method:'POST', headers:{
    Authorization:`Bearer ${key}`, 'Content-Type':'application/json',
    ...(nonce ? {'Idempotency-Key':nonce} : {})}, body:JSON.stringify(body)});
  const json = await response.json();
  if (!response.ok) throw new Error(JSON.stringify(json));
  return json;
}
const {quote} = await post('/api/v1/models/ltxv_13b_098_distilled_multiconditioning/quote', {input});
const job = await post('/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests', {input, quoted_credits:quote.credits_consumed}, nonce);
console.log(job); // Stable WEBOT request_id, events_url, result_url.
// Stream saved webhook state. Reconnect ONLY the event stream, not the generation.
while (!job.terminal || job.financial_pending) {
  const stream = await fetch(job.events_url, {headers:{Authorization:`Bearer ${key}`}});
  if (!stream.ok) throw new Error(`Event stream HTTP ${stream.status}`);
  let buffer = '';
  for await (const chunk of stream.body.pipeThrough(new TextDecoderStream())) {
    buffer += chunk;
    let end;
    while ((end = buffer.indexOf('\n\n')) !== -1) {
      const event = buffer.slice(0, end); buffer = buffer.slice(end + 2);
      const data = event.split('\n').find(line => line.startsWith('data: '));
      if (!data) continue;
      const state = JSON.parse(data.slice(6));
      if (state.error && !state.status) throw new Error(JSON.stringify(state.error));
      if (state.terminal && !state.financial_pending) { console.log(state.output ?? state.error); process.exit(0); }
    }
  }
  await new Promise(resolve => setTimeout(resolve, 1500));
}
console.log(job.output ?? job.error);

# Python 3.9+, pip install requests
import json, os, time, uuid, requests
base = os.environ['WEBOT_BASE_URL'].rstrip('/')
headers = {'Authorization': 'Bearer ' + os.environ['WEBOT_API_KEY']}
with open('input.json', encoding='utf-8') as file:
    input_data = json.load(file)
nonce = os.environ.get('WEBOT_JOB_NONCE') or str(uuid.uuid4()) # Persist before submitting.
def post(path, body, extra=None):
    response = requests.post(base + path, headers={**headers, **(extra or {})}, json=body, timeout=180)
    response.raise_for_status()
    return response.json()
quote = post('/api/v1/models/ltxv_13b_098_distilled_multiconditioning/quote', {'input': input_data})['quote']
job = post('/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests', {'input': input_data, 'quoted_credits': quote['credits_consumed']}, {'Idempotency-Key': nonce})
state = job
while not state['terminal'] or state.get('financial_pending', False):
    # Reconnect while nonterminal; this reads WEBOT's database, never a provider status API.
    with requests.get(job['events_url'], headers=headers, stream=True, timeout=(10, 40)) as stream:
        stream.raise_for_status()
        for line in stream.iter_lines(decode_unicode=True):
            if line and line.startswith('data: '):
                state = json.loads(line[6:])
                if 'status' not in state: raise RuntimeError(state)
                if state['terminal'] and not state.get('financial_pending', False): break
    if not state['terminal'] or state.get('financial_pending', False): time.sleep(1.5)
print(state['output'] if state['status'] == 'completed' else state['error'])

<?php // PHP 8.1+ with cURL
$base = rtrim(getenv('WEBOT_BASE_URL'), '/');
$input = json_decode(file_get_contents('input.json'), false, 64, JSON_THROW_ON_ERROR);
$nonce = getenv('WEBOT_JOB_NONCE') ?: bin2hex(random_bytes(16)); // Persist this before submission.
function post(string $path, array $body, ?string $nonce = null): array {
    global $base;
    $headers = ['Authorization: Bearer '.getenv('WEBOT_API_KEY'), 'Content-Type: application/json'];
    if ($nonce) $headers[] = 'Idempotency-Key: '.$nonce;
    $ch = curl_init($base.$path);
    curl_setopt_array($ch, [CURLOPT_RETURNTRANSFER=>true, CURLOPT_POST=>true,
        CURLOPT_TIMEOUT=>180, CURLOPT_HTTPHEADER=>$headers,
        CURLOPT_POSTFIELDS=>json_encode($body, JSON_THROW_ON_ERROR)]);
    $raw = curl_exec($ch); $status = curl_getinfo($ch, CURLINFO_HTTP_CODE); curl_close($ch);
    if ($raw === false || $status < 200 || $status >= 300) throw new RuntimeException('WEBOT HTTP '.$status);
    return json_decode($raw, true, 64, JSON_THROW_ON_ERROR);
}
$quote = post('/api/v1/models/ltxv_13b_098_distilled_multiconditioning/quote', ['input'=>$input])['quote'];
$job = post('/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests', ['input'=>$input, 'quoted_credits'=>$quote['credits_consumed']], $nonce);
echo json_encode($job, JSON_PRETTY_PRINT); // Connect to events_url with the same Bearer header.

// Go 1.20+; save as main.go.
package main
import ("bytes"; "encoding/json"; "fmt"; "io"; "net/http"; "os"; "strings"; "time"; "crypto/rand"; "encoding/hex")
func main() {
    base := strings.TrimRight(os.Getenv("WEBOT_BASE_URL"), "/")
    raw, err := os.ReadFile("input.json"); if err != nil { panic(err) }
    nonce := os.Getenv("WEBOT_JOB_NONCE")
    if nonce == "" { b := make([]byte,16); if _,err:=rand.Read(b);err!=nil {panic(err)}; nonce=hex.EncodeToString(b) }
    // Persist nonce before the submission; reuse on ambiguous responses.
    client := &http.Client{Timeout:180*time.Second}
    post := func(path string, body any, id string) map[string]any {
        data, err := json.Marshal(body); if err != nil {panic(err)}
        req, err := http.NewRequest("POST",base+path,bytes.NewReader(data)); if err!=nil {panic(err)}
        req.Header.Set("Authorization","Bearer "+os.Getenv("WEBOT_API_KEY")); req.Header.Set("Content-Type","application/json")
        if id!="" {req.Header.Set("Idempotency-Key",id)}
        res,err:=client.Do(req); if err!=nil {panic(err)}; defer res.Body.Close()
        data,err=io.ReadAll(res.Body); if err!=nil {panic(err)}
        if res.StatusCode<200||res.StatusCode>=300 {panic(string(data))}
        var result map[string]any; if err=json.Unmarshal(data,&result);err!=nil {panic(err)}; return result
    }
    input:=json.RawMessage(raw)
    quote:=post("/api/v1/models/ltxv_13b_098_distilled_multiconditioning/quote",map[string]any{"input":input},"")["quote"].(map[string]any)
    job:=post("/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests",map[string]any{"input":input,"quoted_credits":quote["credits_consumed"]},nonce)
    fmt.Println(job) // Stream events_url with the same Authorization header.
}

// Java 11+, Jackson databind dependency; class Main in Main.java.
import java.net.URI;
import java.net.http.*;
import java.nio.file.*;
import java.time.Duration;
import java.util.UUID;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.node.ObjectNode;
public class Main {
  static final ObjectMapper json = new ObjectMapper();
  static final HttpClient client = HttpClient.newHttpClient();
  static final String base = System.getenv("WEBOT_BASE_URL").replaceAll("/$", "");
  static JsonNode post(String path, JsonNode body, String nonce) throws Exception {
    var b = HttpRequest.newBuilder(URI.create(base+path)).timeout(Duration.ofSeconds(180))
      .header("Authorization","Bearer "+System.getenv("WEBOT_API_KEY")).header("Content-Type","application/json")
      .POST(HttpRequest.BodyPublishers.ofString(json.writeValueAsString(body)));
    if(nonce!=null)b.header("Idempotency-Key",nonce);
    var r=client.send(b.build(),HttpResponse.BodyHandlers.ofString());
    if(r.statusCode()<200||r.statusCode()>=300)throw new IllegalStateException(r.body());
    return json.readTree(r.body());
  }
  public static void main(String[] args) throws Exception {
    var input=json.readTree(Files.readString(Path.of("input.json")));
    ObjectNode body=json.createObjectNode();body.set("input",input);
    var quote=post("/api/v1/models/ltxv_13b_098_distilled_multiconditioning/quote",body,null).get("quote");
    body.put("quoted_credits",quote.get("credits_consumed").asInt());
    String nonce=System.getenv("WEBOT_JOB_NONCE");if(nonce==null)nonce=UUID.randomUUID().toString(); // Persist before POST.
    var job=post("/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests",body,nonce);System.out.println(job);
    // Subscribe to job.events_url with Authorization; use BodyHandlers.ofLines().
  }
}

// .NET 8 console app, top-level statements.
using System.Net.Http;
using System.Text;
using System.Text.Json.Nodes;
var client = new HttpClient { Timeout = TimeSpan.FromSeconds(180) };
var root = Environment.GetEnvironmentVariable("WEBOT_BASE_URL")!.TrimEnd('/');
var key = Environment.GetEnvironmentVariable("WEBOT_API_KEY");
async Task<JsonNode> Post(string path, JsonNode body, string? nonce = null) {
    using var req = new HttpRequestMessage(HttpMethod.Post, root + path);
    req.Headers.Add("Authorization", "Bearer " + key);
    if (nonce != null) req.Headers.Add("Idempotency-Key", nonce);
    req.Content = new StringContent(body.ToJsonString(), Encoding.UTF8, "application/json");
    using var res = await client.SendAsync(req);
    var raw = await res.Content.ReadAsStringAsync();res.EnsureSuccessStatusCode();
    return JsonNode.Parse(raw)!;
}
var input = JsonNode.Parse(await File.ReadAllTextAsync("input.json"));
var body = new JsonObject { ["input"] = input };
var quote = await Post("/api/v1/models/ltxv_13b_098_distilled_multiconditioning/quote", body);
body["quoted_credits"] = quote["quote"]!["credits_consumed"]!.GetValue<int>();
var nonce = Environment.GetEnvironmentVariable("WEBOT_JOB_NONCE") ?? Guid.NewGuid().ToString(); // Persist before submitting.
var job = await Post("/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests", body, nonce);
Console.WriteLine(job); // Subscribe to events_url with the same Bearer header and ResponseHeadersRead.

# Ruby 3+, standard library only.
require 'net/http'
require 'json'
require 'securerandom'
base = ENV.fetch('WEBOT_BASE_URL').sub(%r{/$}, '')
post = lambda do |path, body, nonce = nil|
  uri = URI(base + path)
  req = Net::HTTP::Post.new(uri)
  req['Authorization'] = 'Bearer ' + ENV.fetch('WEBOT_API_KEY')
  req['Content-Type'] = 'application/json'
  req['Idempotency-Key'] = nonce if nonce
  req.body = JSON.generate(body)
  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true, read_timeout: 180) { |http| http.request(req) }
  raise res.body unless res.is_a?(Net::HTTPSuccess)
  JSON.parse(res.body)
end
input = JSON.parse(File.read('input.json'))
quote = post.call('/api/v1/models/ltxv_13b_098_distilled_multiconditioning/quote', {'input' => input})['quote']
nonce = ENV['WEBOT_JOB_NONCE'] || SecureRandom.uuid # Persist this before submission.
job = post.call('/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests', {'input' => input, 'quoted_credits' => quote['credits_consumed']}, nonce)
puts JSON.pretty_generate(job) # Subscribe to events_url with the same Authorization header.

// Swift 5.9 server-side/CLI only. Do not embed customer keys in shipped apps.
import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
@main struct Main {
 static func main() async throws {
  let env=ProcessInfo.processInfo.environment
  let base=env["WEBOT_BASE_URL"]!.trimmingCharacters(in: CharacterSet(charactersIn:"/"))
  let input=try JSONSerialization.jsonObject(with: Data(contentsOf:URL(fileURLWithPath:"input.json")))
  func post(_ path:String,_ body:[String:Any],_ nonce:String?=nil) async throws -> [String:Any] {
   var req=URLRequest(url:URL(string:base+path)!);req.httpMethod="POST";req.timeoutInterval=180
   req.setValue("Bearer "+env["WEBOT_API_KEY"]!,forHTTPHeaderField:"Authorization")
   req.setValue("application/json",forHTTPHeaderField:"Content-Type")
   if let nonce {req.setValue(nonce,forHTTPHeaderField:"Idempotency-Key")}
   req.httpBody=try JSONSerialization.data(withJSONObject:body)
   let (data,res)=try await URLSession.shared.data(for:req)
   guard let http=res as? HTTPURLResponse,(200..<300).contains(http.statusCode) else {throw NSError(domain:"WEBOT",code:1)}
   return try JSONSerialization.jsonObject(with:data) as! [String:Any]
  }
  let quote=try await post("/api/v1/models/ltxv_13b_098_distilled_multiconditioning/quote",["input":input])["quote"] as! [String:Any]
  let nonce=env["WEBOT_JOB_NONCE"] ?? UUID().uuidString // Persist before submission.
  let job=try await post("/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests",["input":input,"quoted_credits":quote["credits_consumed"]!],nonce)
  print(job) // Subscribe to events_url with the same Authorization header.
 }
}

// Server-side Kotlin/JVM 17+, Gradle dependencies: OkHttp 4.12, org.json 20240303.
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import java.io.File
import java.util.UUID
import java.util.concurrent.TimeUnit
fun main() {
 val base=System.getenv("WEBOT_BASE_URL").trimEnd('/')
 val client=OkHttpClient.Builder().readTimeout(180,TimeUnit.SECONDS).build()
 fun post(path:String,body:JSONObject,nonce:String?=null):JSONObject {
  val b=Request.Builder().url(base+path).header("Authorization","Bearer "+System.getenv("WEBOT_API_KEY"))
   .post(body.toString().toRequestBody("application/json".toMediaType()))
  if(nonce!=null)b.header("Idempotency-Key",nonce)
  return client.newCall(b.build()).execute().use {res ->
   val raw=res.body!!.string();check(res.isSuccessful){raw};JSONObject(raw)
  }
 }
 val body=JSONObject().put("input",JSONObject(File("input.json").readText()))
 val quote=post("/api/v1/models/ltxv_13b_098_distilled_multiconditioning/quote",body).getJSONObject("quote")
 body.put("quoted_credits",quote.getInt("credits_consumed"))
 val nonce=System.getenv("WEBOT_JOB_NONCE") ?: UUID.randomUUID().toString() // Persist before submission.
 val job=post("/api/v1/models/ltxv_13b_098_distilled_multiconditioning/requests",body,nonce)
 println(job) // Subscribe to events_url with the same Authorization header.
}

5. Receive all results

The response includes a stable WEBOT request_id, events_url and result_url. Subscribe with a Bearer-authenticated HTTP stream. Nonterminal streams end after 25 seconds; reconnect to the same URL after at least 1.5 seconds. Current saved state is replayed immediately, including completion that happened while disconnected. A terminal event contains the result envelope. The JSON terminal flag describes generation completion. Keep reconnecting while financial_pending is true; stop after the terminal event confirms financial settlement. Never poll provider status/results. Native browser EventSource cannot send a Bearer header; keep the key on your server.

Completed output contains the full model result, including every generated media/document item, not just the first URL. Failed output is null with error and refund_state. Results are strictly limited to the key owner, including on reseller domains. Model-independent aliases: /api/v1/requests/{request_id}/result and /events. Revoking a key blocks subsequent reads and streams; saved results remain accessible with another valid key of the same account.

6. Schemas and parameter defaults

Required fields are marked with *. Required text must contain non-whitespace content. Defaults apply when an optional parameter is omitted; null, false, 0 and an empty array are distinct values. “No documented default” means WEBOT does not invent one. Examples are sample inputs, not defaults. WEBOT generation constraints can require an explicit value even when the provider publishes an automatic default.

Input schema · fields, constraints and defaults

Parameter	Type	Required	Default when omitted	Description / constraints
`prompt`	string	Yes *	`No documented default`	Text prompt to guide generation
`constant_rate_factor`	integer	No	`29`	The constant rate factor (CRF) to compress input media with. Compressed input media more closely matches the model's training data, which can improve motion quality. minimum: 0 · maximum: 51
`seed`	integer \| null	No	`No documented default`	Random seed for generation
`reverse_video`	boolean	No	`false`	Whether to reverse the video.
`num_frames`	integer	No	`121`	The number of frames in the video. minimum: 9 · maximum: 1441
`videos`	array	No	`[]`	Videos to use as conditioning
`videos[].strength`	number	No	`1`	Strength of the conditioning. 0.0 means no conditioning, 1.0 means full conditioning. minimum: 0 · maximum: 1
`videos[].limit_num_frames`	boolean	No	`false`	Whether to limit the number of frames used from the video. If True, the `max_num_frames` parameter will be used to limit the number of frames.
`videos[].target_fps`	integer	No	`24`	Target FPS to resample the video to. Only relevant if `resample_fps` is True. minimum: 1 · maximum: 60
`videos[].video_url`	string	Yes *	`No documented default`	URL of video to use as conditioning
`videos[].max_num_frames`	integer	No	`1441`	Maximum number of frames to use from the video. If None, all frames will be used. minimum: 1 · maximum: 1441
`videos[].start_frame_num`	integer	No	`0`	Frame number of the video from which the conditioning starts. Must be a multiple of 8. minimum: 0 · maximum: 1440
`videos[].preprocess`	boolean	No	`false`	Whether to preprocess the video. If True, the video will be preprocessed to match the conditioning type. This is a no-op for RGB conditioning.
`videos[].conditioning_type`	string \| null	No	`"rgb"`	Type of conditioning this video provides. This is relevant to ensure in-context LoRA weights are applied correctly, as well as selecting the correct preprocessing pipeline, when enabled.
`videos[].reverse_video`	boolean	No	`false`	Whether to reverse the video. This is useful for tasks where the video conditioning should be applied in reverse order.
`videos[].resample_fps`	boolean	No	`false`	Whether to resample the video to a specific FPS. If True, the `target_fps` parameter will be used to resample the video.
`enable_safety_checker`	boolean	No	`true`	Whether to enable the safety checker. Disabling it requires account authorization; unauthorized requests are always checked.
`second_pass_skip_initial_steps`	integer	No	`5`	The number of inference steps to skip in the initial steps of the second pass. By skipping some steps at the beginning, the second pass can focus on smaller details instead of larger changes. minimum: 1 · maximum: 11
`loras`	array	No	`[]`	LoRA weights to use for generation
`loras[].weight_name`	string \| null	No	`No documented default`	Name of the LoRA weight. Only used if `path` is a HuggingFace repository, and is only required when the repository contains multiple LoRA weights.
`loras[].path`	string	Yes *	`No documented default`	URL or path to the LoRA weights.
`loras[].scale`	number	No	`1`	Scale of the LoRA weight. This is a multiplier applied to the LoRA weight when loading it. minimum: 0 · maximum: 4
`temporal_adain_factor`	number	No	`0.5`	The factor for adaptive instance normalization (AdaIN) applied to generated video chunks after the first. This can help deal with a gradual increase in saturation/contrast in the generated video by normalizing the color distribution across the video. A high value will ensure the color distribution is more consistent across the video, while a low value will allow for more variation in color distribution. minimum: 0 · maximum: 1
`frame_rate`	integer	No	`24`	The frame rate of the video. minimum: 1 · maximum: 60
`images`	array	No	`[]`	URL of images to use as conditioning
`images[].strength`	number	No	`1`	Strength of the conditioning. 0.0 means no conditioning, 1.0 means full conditioning. minimum: 0 · maximum: 1
`images[].image_url`	string	Yes *	`No documented default`	URL of image to use as conditioning
`images[].start_frame_num`	integer	No	`0`	Frame number of the image from which the conditioning starts. Must be a multiple of 8. minimum: 0 · maximum: 1440
`first_pass_num_inference_steps`	integer	No	`8`	Number of inference steps during the first pass. minimum: 2 · maximum: 12
`second_pass_num_inference_steps`	integer	No	`8`	Number of inference steps during the second pass. minimum: 2 · maximum: 12
`negative_prompt`	string	No	`"worst quality, inconsistent motion, blurry, jittery, distorted"`	Negative prompt for generation
`aspect_ratio`	string	No	`"auto"`	The aspect ratio of the video. enum: ["9:16","1:1","16:9","auto"]
`enable_detail_pass`	boolean	No	`false`	Whether to use a detail pass. If True, the model will perform a second pass to refine the video and enhance details. This incurs a 2.0x cost multiplier on the base price.
`resolution`	string	No	`"720p"`	Resolution of the generated video. enum: ["480p","720p"]
`expand_prompt`	boolean	No	`false`	Whether to expand the prompt using a language model.
`tone_map_compression_ratio`	number	No	`0`	The compression ratio for tone mapping. This is used to compress the dynamic range of the video to improve visual quality. A value of 0.0 means no compression, while a value of 1.0 means maximum compression. minimum: 0 · maximum: 1

{
    "title": "DistilledMultiConditioningVideoInput",
    "type": "object",
    "properties": {
        "prompt": {
            "title": "Prompt",
            "type": "string",
            "examples": [
                "A vibrant, abstract composition featuring a person with outstretched arms, rendered in a kaleidoscope of colors against a deep, dark background. The figure is composed of intricate, swirling patterns reminiscent of a mosaic, with hues of orange, yellow, blue, and green that evoke the style of artists such as Wassily Kandinsky or Bridget Riley. The camera zooms into the face striking portrait of a man, reimagined through the lens of old-school video-game graphics. The subject's face is rendered in a kaleidoscope of colors, with bold blues and reds set against a vibrant yellow backdrop. His dark hair is pulled back, framing his profile in a dramatic pose."
            ],
            "description": "Text prompt to guide generation"
        },
        "constant_rate_factor": {
            "title": "Constant Rate Factor",
            "minimum": 0,
            "type": "integer",
            "examples": [
                29
            ],
            "description": "The constant rate factor (CRF) to compress input media with. Compressed input media more closely matches the model's training data, which can improve motion quality.",
            "maximum": 51,
            "default": 29
        },
        "seed": {
            "title": "Seed",
            "description": "Random seed for generation",
            "anyOf": [
                {
                    "type": "integer"
                },
                {
                    "type": "null"
                }
            ]
        },
        "reverse_video": {
            "title": "Reverse Video",
            "type": "boolean",
            "examples": [
                false
            ],
            "description": "Whether to reverse the video.",
            "default": false
        },
        "num_frames": {
            "title": "Number of Frames",
            "minimum": 9,
            "type": "integer",
            "examples": [
                121
            ],
            "description": "The number of frames in the video.",
            "maximum": 1441,
            "default": 121
        },
        "videos": {
            "title": "Videos",
            "type": "array",
            "items": {
                "title": "VideoConditioningInput",
                "type": "object",
                "properties": {
                    "strength": {
                        "title": "Strength",
                        "minimum": 0,
                        "type": "number",
                        "description": "Strength of the conditioning. 0.0 means no conditioning, 1.0 means full conditioning.",
                        "maximum": 1,
                        "default": 1
                    },
                    "limit_num_frames": {
                        "title": "Limit Number of Frames",
                        "type": "boolean",
                        "description": "Whether to limit the number of frames used from the video. If True, the `max_num_frames` parameter will be used to limit the number of frames.",
                        "default": false
                    },
                    "target_fps": {
                        "title": "Target FPS",
                        "minimum": 1,
                        "type": "integer",
                        "examples": [
                            24
                        ],
                        "description": "Target FPS to resample the video to. Only relevant if `resample_fps` is True.",
                        "maximum": 60,
                        "default": 24
                    },
                    "video_url": {
                        "title": "Video URL",
                        "type": "string",
                        "description": "URL of video to use as conditioning"
                    },
                    "max_num_frames": {
                        "title": "Maximum Number of Frames",
                        "minimum": 1,
                        "type": "integer",
                        "examples": [
                            1441
                        ],
                        "description": "Maximum number of frames to use from the video. If None, all frames will be used.",
                        "maximum": 1441,
                        "default": 1441
                    },
                    "start_frame_num": {
                        "title": "Start Frame Number",
                        "minimum": 0,
                        "type": "integer",
                        "multipleOf": 8,
                        "description": "Frame number of the video from which the conditioning starts. Must be a multiple of 8.",
                        "maximum": 1440,
                        "default": 0
                    },
                    "preprocess": {
                        "title": "Preprocess",
                        "type": "boolean",
                        "description": "Whether to preprocess the video. If True, the video will be preprocessed to match the conditioning type. This is a no-op for RGB conditioning.",
                        "default": false
                    },
                    "conditioning_type": {
                        "title": "Conditioning Type",
                        "default": "rgb",
                        "examples": [
                            "rgb"
                        ],
                        "description": "Type of conditioning this video provides. This is relevant to ensure in-context LoRA weights are applied correctly, as well as selecting the correct preprocessing pipeline, when enabled.",
                        "anyOf": [
                            {
                                "enum": [
                                    "rgb",
                                    "depth",
                                    "pose",
                                    "canny"
                                ],
                                "type": "string"
                            },
                            {
                                "type": "null"
                            }
                        ]
                    },
                    "reverse_video": {
                        "title": "Reverse Video",
                        "type": "boolean",
                        "description": "Whether to reverse the video. This is useful for tasks where the video conditioning should be applied in reverse order.",
                        "default": false
                    },
                    "resample_fps": {
                        "title": "Resample FPS",
                        "type": "boolean",
                        "description": "Whether to resample the video to a specific FPS. If True, the `target_fps` parameter will be used to resample the video.",
                        "default": false
                    }
                },
                "x-webot-order-properties": [
                    "video_url",
                    "conditioning_type",
                    "preprocess",
                    "start_frame_num",
                    "strength",
                    "limit_num_frames",
                    "max_num_frames",
                    "resample_fps",
                    "target_fps",
                    "reverse_video"
                ],
                "required": [
                    "video_url"
                ]
            },
            "description": "Videos to use as conditioning",
            "default": []
        },
        "enable_safety_checker": {
            "title": "Enable Safety Checker",
            "type": "boolean",
            "examples": [
                true
            ],
            "description": "Whether to enable the safety checker. Disabling it requires account authorization; unauthorized requests are always checked.",
            "default": true
        },
        "second_pass_skip_initial_steps": {
            "title": "Second Pass Skip Initial Steps",
            "minimum": 1,
            "type": "integer",
            "examples": [
                5
            ],
            "description": "The number of inference steps to skip in the initial steps of the second pass. By skipping some steps at the beginning, the second pass can focus on smaller details instead of larger changes.",
            "maximum": 11,
            "default": 5
        },
        "loras": {
            "title": "Loras",
            "type": "array",
            "items": {
                "title": "LoRAWeight",
                "type": "object",
                "properties": {
                    "weight_name": {
                        "title": "Weight Name",
                        "description": "Name of the LoRA weight. Only used if `path` is a HuggingFace repository, and is only required when the repository contains multiple LoRA weights.",
                        "anyOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "null"
                            }
                        ]
                    },
                    "path": {
                        "title": "Path",
                        "type": "string",
                        "description": "URL or path to the LoRA weights."
                    },
                    "scale": {
                        "title": "Scale",
                        "minimum": 0,
                        "type": "number",
                        "description": "Scale of the LoRA weight. This is a multiplier applied to the LoRA weight when loading it.",
                        "maximum": 4,
                        "default": 1
                    }
                },
                "x-webot-order-properties": [
                    "path",
                    "weight_name",
                    "scale"
                ],
                "required": [
                    "path"
                ]
            },
            "description": "LoRA weights to use for generation",
            "default": []
        },
        "temporal_adain_factor": {
            "title": "Temporal AdaIN Factor",
            "minimum": 0,
            "type": "number",
            "description": "The factor for adaptive instance normalization (AdaIN) applied to generated video chunks after the first. This can help deal with a gradual increase in saturation/contrast in the generated video by normalizing the color distribution across the video. A high value will ensure the color distribution is more consistent across the video, while a low value will allow for more variation in color distribution.",
            "multipleOf": 0.05,
            "examples": [
                0.5
            ],
            "maximum": 1,
            "default": 0.5
        },
        "frame_rate": {
            "title": "Frame Rate",
            "minimum": 1,
            "type": "integer",
            "examples": [
                24
            ],
            "description": "The frame rate of the video.",
            "maximum": 60,
            "default": 24
        },
        "images": {
            "title": "Images",
            "type": "array",
            "examples": [
                [
                    {
                        "strength": 1,
                        "image_url": "https://storage.googleapis.com/falserverless/model_tests/ltx/NswO1P8sCLzrh1WefqQFK_9a6bdbfa54b944c9a770338159a113fd.jpg",
                        "start_frame_num": 0
                    },
                    {
                        "strength": 1,
                        "image_url": "https://storage.googleapis.com/falserverless/model_tests/ltx/YAPOGvmS2tM_Krdp7q6-d_267c97e017c34f679844a4477dfcec38.jpg",
                        "start_frame_num": 120
                    }
                ]
            ],
            "items": {
                "title": "ImageConditioningInput",
                "type": "object",
                "properties": {
                    "strength": {
                        "title": "Strength",
                        "minimum": 0,
                        "type": "number",
                        "description": "Strength of the conditioning. 0.0 means no conditioning, 1.0 means full conditioning.",
                        "maximum": 1,
                        "default": 1
                    },
                    "image_url": {
                        "title": "Image URL",
                        "type": "string",
                        "description": "URL of image to use as conditioning"
                    },
                    "start_frame_num": {
                        "title": "Start Frame Number",
                        "minimum": 0,
                        "type": "integer",
                        "multipleOf": 8,
                        "description": "Frame number of the image from which the conditioning starts. Must be a multiple of 8.",
                        "maximum": 1440,
                        "default": 0
                    }
                },
                "x-webot-order-properties": [
                    "image_url",
                    "start_frame_num",
                    "strength"
                ],
                "required": [
                    "image_url"
                ]
            },
            "description": "URL of images to use as conditioning",
            "default": []
        },
        "first_pass_num_inference_steps": {
            "title": "Number of Inference Steps",
            "minimum": 2,
            "type": "integer",
            "examples": [
                8
            ],
            "description": "Number of inference steps during the first pass.",
            "maximum": 12,
            "default": 8
        },
        "second_pass_num_inference_steps": {
            "title": "Second Pass Number of Inference Steps",
            "minimum": 2,
            "type": "integer",
            "examples": [
                8
            ],
            "description": "Number of inference steps during the second pass.",
            "maximum": 12,
            "default": 8
        },
        "negative_prompt": {
            "title": "Negative Prompt",
            "type": "string",
            "description": "Negative prompt for generation",
            "default": "worst quality, inconsistent motion, blurry, jittery, distorted"
        },
        "aspect_ratio": {
            "title": "Aspect Ratio",
            "enum": [
                "9:16",
                "1:1",
                "16:9",
                "auto"
            ],
            "type": "string",
            "examples": [
                "auto"
            ],
            "description": "The aspect ratio of the video.",
            "default": "auto"
        },
        "enable_detail_pass": {
            "title": "Enable Detail Pass",
            "type": "boolean",
            "examples": [
                false
            ],
            "description": "Whether to use a detail pass. If True, the model will perform a second pass to refine the video and enhance details. This incurs a 2.0x cost multiplier on the base price.",
            "default": false
        },
        "resolution": {
            "title": "Resolution",
            "enum": [
                "480p",
                "720p"
            ],
            "type": "string",
            "examples": [
                "720p"
            ],
            "description": "Resolution of the generated video.",
            "default": "720p"
        },
        "expand_prompt": {
            "title": "Expand Prompt",
            "type": "boolean",
            "examples": [
                false
            ],
            "description": "Whether to expand the prompt using a language model.",
            "default": false
        },
        "tone_map_compression_ratio": {
            "title": "Tone Map Compression Ratio",
            "minimum": 0,
            "type": "number",
            "description": "The compression ratio for tone mapping. This is used to compress the dynamic range of the video to improve visual quality. A value of 0.0 means no compression, while a value of 1.0 means maximum compression.",
            "multipleOf": 0.05,
            "examples": [
                0
            ],
            "maximum": 1,
            "default": 0
        }
    },
    "x-webot-order-properties": [
        "prompt",
        "negative_prompt",
        "loras",
        "resolution",
        "aspect_ratio",
        "seed",
        "num_frames",
        "first_pass_num_inference_steps",
        "second_pass_num_inference_steps",
        "second_pass_skip_initial_steps",
        "frame_rate",
        "expand_prompt",
        "reverse_video",
        "enable_safety_checker",
        "enable_detail_pass",
        "temporal_adain_factor",
        "tone_map_compression_ratio",
        "constant_rate_factor",
        "images",
        "videos"
    ],
    "required": [
        "prompt"
    ]
}

Output (inside result.output) schema · fields, constraints and defaults

Parameter	Type	Required	Default when omitted	Description / constraints
`seed`	integer	Yes *	`No documented default`	The seed used for generation.
`video`	object	Yes *	`No documented default`	The generated video file.
`video.url`	string	Yes *	`No documented default`	The URL where the file can be downloaded from.
`video.content_type`	string \| null	No	`No documented default`	The mime type of the file.
`video.file_size`	integer \| null	No	`No documented default`	The size of the file in bytes.
`video.file_name`	string \| null	No	`No documented default`	The name of the file. It will be auto-generated if not provided.
`prompt`	string	Yes *	`No documented default`	The prompt used for generation.

{
    "title": "MultiConditioningVideoOutput",
    "type": "object",
    "properties": {
        "seed": {
            "title": "Seed",
            "type": "integer",
            "description": "The seed used for generation."
        },
        "video": {
            "title": "File",
            "type": "object",
            "properties": {
                "url": {
                    "title": "Url",
                    "type": "string",
                    "description": "The URL where the file can be downloaded from."
                },
                "content_type": {
                    "title": "Content Type",
                    "examples": [
                        "image/png"
                    ],
                    "description": "The mime type of the file.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "null"
                        }
                    ]
                },
                "file_size": {
                    "title": "File Size",
                    "examples": [
                        4404019
                    ],
                    "description": "The size of the file in bytes.",
                    "anyOf": [
                        {
                            "type": "integer"
                        },
                        {
                            "type": "null"
                        }
                    ]
                },
                "file_name": {
                    "title": "File Name",
                    "examples": [
                        "z9RV14K95DvU.png"
                    ],
                    "description": "The name of the file. It will be auto-generated if not provided.",
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "null"
                        }
                    ]
                }
            },
            "x-webot-order-properties": [
                "url",
                "content_type",
                "file_name",
                "file_size"
            ],
            "required": [
                "url"
            ],
            "examples": [
                {
                    "url": "https://storage.googleapis.com/falserverless/example_outputs/ltxv-multiconditioning-output.mp4"
                }
            ],
            "description": "The generated video file."
        },
        "prompt": {
            "title": "Prompt",
            "type": "string",
            "examples": [
                "A vibrant, abstract composition featuring a person with outstretched arms, rendered in a kaleidoscope of colors against a deep, dark background. The figure is composed of intricate, swirling patterns reminiscent of a mosaic, with hues of orange, yellow, blue, and green that evoke the style of artists such as Wassily Kandinsky or Bridget Riley. The camera zooms into the face striking portrait of a man, reimagined through the lens of old-school video-game graphics. The subject's face is rendered in a kaleidoscope of colors, with bold blues and reds set against a vibrant yellow backdrop. His dark hair is pulled back, framing his profile in a dramatic pose."
            ],
            "description": "The prompt used for generation."
        }
    },
    "x-webot-order-properties": [
        "video",
        "prompt",
        "seed"
    ],
    "required": [
        "video",
        "prompt",
        "seed"
    ]
}

Errors and limits

401 invalid/expired/revoked key · 403 key scope or domain mismatch · 404 unavailable model or unowned request · 409 quote changed, balance, concurrency or idempotency conflict · 413 JSON exceeds 2 MB · 415 wrong content type · 422 invalid fields/media · 429 rate limit · 503 temporary/ambiguous submission. Respect Retry-After. Current limits per account: 12 quotes/submissions, 120 result reads and 8 stream connections per minute. One submission preparation at a time per account. Do not automatically regenerate failed jobs.

Your requests

LTX Video 0.9.8 13B Distilled - Multi-conditioning · Your account only

Select Requests to load your history.

Request ID	Created at (IST)	Status	Credits used	Refunded	Processing time	Report

Show rows

Your model analytics

LTX Video 0.9.8 13B Distilled - Multi-conditioning · Request dates in IST

Select Analytics to load your metrics.

Request counts

Daily requests by their current status

Request outcomes

Completed, failed and pending requests

Credits used

Daily recorded charges before refunds

Processing time

Daily average for completed requests with recorded timing

Processing percentiles

Completed requests only · Time from submission to recorded completion

How to use LTX Video 0.9.8 13B Distilled — Multi-conditioning

Start with an existing video and use this model’s editing or transformation tools to change it. The exact kind of change depends on this particular endpoint.

Required inputs

Prompt: Your instructions to the model. Say what you want, include the important details and avoid contradictory directions. For a video, describe the action as well as the scene.

Workflow

Prepare your source material and fill the required inputs above. Review the supported settings for this model.
Sign in to calculate the credit estimate. Review the estimate before choosing Generate.
Keep this model page open while the request runs. Completed results arrive in the result area; use the available player or download controls to review the output.

When to use this workflow

Apply the transformation described for this model.
Use an existing clip as the starting material.

Key settings

Prompt: Your instructions to the model. Say what you want, include the important details and avoid contradictory directions. For a video, describe the action as well as the scene.
Negative Prompt: Describe things you would prefer the model to avoid, such as unwanted blur or objects. This guides the result but is not a guarantee that those things will never appear.
Loras: A compatible learned adapter that changes a model’s style, subject or behaviour. It is an add-on to a base model, not a normal reference photo. Use adapters made for the supported base model.
Weight Name: The specific saved file or subfolder to load from a compatible model repository. It identifies an existing component; it is not a description of the picture you want.
Path: A compatible saved model or learned adapter file. This is not an ordinary picture. Use the exact format and base-model compatibility required by this tool.
Scale: A scale or enlargement amount. For an image enlargement factor, 2× doubles both width and height, producing four times as many pixels. Other uses of “scale” can differ; check this model’s description. Minimum: 0. Maximum: 4

Related model workspaces

Alibaba Happy Horse — Edit Video

Alibaba Wan 2.2 — Depth

Alibaba Wan 2.2 — Inpainting

Alibaba Wan 2.2 — Move

Alibaba Wan 2.2 — Outpainting

Alibaba Wan 2.2 — Reframe

Product-video workflow · Video route comparison

Compare more AI models · Explore plans and credits