LTX-2.3 Pricing: API Cost, Local Inference & Cloud Trade-offs (2026)

Hey, guys. I’m Dora. You know that I hate vague pricing. I want to know: if I generate a 12-second 1080p clip twice because the first take missed the brief, how much does that eat from my budget today? I tested LTX-2.3 in March 2026, API where available, and the open weights locally via Hugging Face.

Below is the math I use to estimate LTX-2.3 API cost for real projects, plus where I’ve been surprised (both good and bad). My March test notes are my own observations; the published prices below were checked on October 28, 2026. If I say it “saves time,” I’ll show you how many minutes.

LTX-2.3 API Pricing Structure

I’m not a tech geek, but I’ve identified a pattern in how video APIs price runs. The first thing I check now is which endpoint I’m buying from. LTX’s own API lists separate ltx-2-3-fast and ltx-2-3-pro models.

Variant speed/quality: “Fast” and “Pro” are model choices on LTX’s first-party API. Don’t assume a third-party route offers the same choice.
Resolution: 720p costs less than 1080p on the published tables checked here. Both portrait and landscape are supported, but use the exact resolution allowed by your endpoint.
Duration: Video generation is priced by clip length on these routes. A new generation after a missed brief is another run.
Other operations: Retake, extend, and audio-to-video may use different endpoints and billing rules. Native audio in a text-to-video result does not automatically mean a separate audio charge.

If you see LTX-2.3 pricing presented as credits, convert it to a rate you can compare. My conversion sheet looks like this:

Effective rate ($/sec) = price per 100 credits ÷ seconds generated per 100 credits
Or, if priced per frame: $/sec = price per 1,000 frames × (fps ÷ 1,000)

Pro tip: lock your settings before calculating. Model, endpoint, resolution, fps, and duration all belong next to the price in your notes.

Cost-Per-Second in Practice: What a Typical Generation Costs

Here’s how I estimate LTX-2.3 price per clip in real workflows. I used placeholder rates in my original worksheet. For a budget I would approve today, I replace them with the selected provider’s published rate.

On the WaveSpeedAI text-to-video route, the October 28, 2026 price table works out to $0.02/sec at 480p, $0.03/sec at 720p, and $0.04/sec at 1080p. Its request schema allows 5–20 seconds, either 16:9 or 9:16, and lists prompt, resolution, aspect_ratio, duration, and seed. It does not list a Fast/Pro selector.

LTX’s first-party pricing is a different quote: for text-to-video, Fast is $0.03/sec at 720p or $0.06/sec at 1080p; Pro is $0.04/sec at 720p or $0.08/sec at 1080p. Check its model support matrix before multiplying: Fast supports 6–20 seconds at 720p/1080p and 24 or 25 fps; Pro supports 6, 8, or 10 seconds, including at 1080p. Five-second first-party requests and 20-second Pro requests are not valid examples.

5s clip / 10s clip / 20s clip where the endpoint permits them

Endpoint and setting	Short clip	10s	20s
WaveSpeedAI 720p	5s: $0.15	$0.30	$0.60
WaveSpeedAI 1080p	5s: $0.20	$0.40	$0.80
LTX API Fast 720p	6s: $0.18	$0.30	$0.60
LTX API Fast 1080p	6s: $0.36	$0.60	$1.20
LTX API Pro 720p	6s: $0.24	$0.40	Not supported
LTX API Pro 1080p	6s: $0.48	$0.80	Not supported

These are published-rate calculations, not charges from my March billing export. They assume one successful generation at the stated duration and exclude separate operations. Prices and available settings can change; recheck the endpoint before a production batch.

The 12-Second Budget Check

Back to the question that sent me down this rabbit hole. On the WaveSpeedAI route, two 12-second 1080p generations cost 2 × 12 × $0.04 = $0.96 at the checked rate. On LTX’s first-party Fast route at 1080p and 24/25 fps, the same duration is allowed and the listed generation cost is 2 × 12 × $0.06 = $1.44.

A single 12-second Pro request is not in LTX’s current support matrix. I would need a different plan—such as separate supported clips or an applicable edit/extend operation—and price that plan by its own rules. That’s why my worksheet starts with “Is this exact request valid?” before “What’s the rate?”

Neither calculation predicts whether I’ll like either take. If I expect two attempts per usable clip, I budget for two generations. I also keep a separate line for post-production and for any failed-job charges shown by my provider’s billing records; I don’t assume every failed request is free or billable without checking.

The Free Tier and Open-Weight Access

Yes, LTX-2.3 has open weights you can download on Hugging Face. Here’s what “free” actually meant for me in practice:

Download: No per-download model fee in my setup. Good internet and roughly tens of GB of free disk were required.
Local run: You’ll pay with hardware, electricity, and time. If your GPU is older or VRAM-limited, you’ll pay with waiting and crashes.
Opportunity cost: When local inference stalls in the middle of a batch, that’s your posting window slipping.

I love open weights because I can prototype without API rate limits and I’m not bleeding credits during prompt tinkering. But when I need dependable throughput for client deadlines, I still lean on API. “LTX-2.3 free” makes sense for access to the weights. For production, running them still costs you somewhere else.

Local Inference Real Cost: Hardware, Electricity & Ops

I didn’t know how to quantify local costs either, until I discovered a simple estimate that keeps me honest. I ran LTX-2.3 locally on a single RTX 4090 (24GB) and a 3080 (10GB) machine. The throughput calculation below is from my 4090 setup; it should not be read as a 3080 result or a general LTX benchmark. My exact local settings and logs aren’t attached here.

GPU Depreciation and Energy Cost Estimates

Use this template. Swap your own numbers.

Hardware depreciation per productive hour = GPU price ÷ estimated productive hours over its useful life
My example assumption: $1,700 GPU, 2-year life, 1,500 productive hours/year → 3,000 hours total
$1,700 ÷ 3,000 ≈ $0.57/hour
Power cost per active hour = (average watts ÷ 1,000) × electricity $/kWh
My reported Kill-A-Watt reading: 4090 rig at ~420W while generating; my electricity assumption: $0.22/kWh
0.42 × $0.22 ≈ $0.092/hour
Ops overhead: I add a 20% planning buffer for cooling, storage, maintenance, and “oops” time

So my baseline local cost/hour ≈ ($0.57 + $0.092) × 1.2 ≈ **$0.80/hour**. That is a planning estimate, not a metered all-in invoice. It depends heavily on getting those 1,500 productive hours each year; using the GPU less would raise depreciation per productive hour.

Now translate to cost per generated second. You need throughput:

On my 4090: ~5–7 sec of 1080p video per minute at “pro-like” settings; ~10–12 sec/min at “fast-ish.” I averaged 8 sec/min over 40 test prompts.
That’s 8 sec/min × 60 = 480 generated sec/hour.
Local cost per generated second ≈ $0.80 ÷ 480 ≈ $0.0017/sec (about 0.17 cents/sec) under those assumptions.

When Local Is Genuinely Cheaper (Break-Even Analysis)

This is the formula I use to decide API vs local.

Estimated local unit cost = local cost per productive hour ÷ generated seconds per productive hour
Compare that with the API rate for a valid request at the same output setting, then account for how many usable clips each route produces

Using my 4090 numbers above, the estimated local unit cost is about $0.0017/sec. That looks far below the listed API rates, but it leaves out my labor, any hardware beyond the GPU covered by the buffer, and differences in output quality or reliability. If the box sits idle, the hardware assumption gets worse. If a deadline values speed-to-first-result, an API may still be the practical choice.

Time saved note: For batch ideation (ten 8–10s clips), my local box produced ~80–100s in ~10–12 minutes unattended. API did it in ~2–5 minutes total, but I sometimes hit queue delays midday. Measured over three sessions, according to my notes; those times aren’t a service-level promise.

LTX-2.3 vs Comparable API Options: Price Comparison

I care about “effective $/second at my target quality,” not marketing tiers. Here’s how I compare LTX-2.3 with WAN 2.2, Kling, and Runway without getting lost in credits.

What I did in my March comparison:

Generated the same 10-second 1080p prompt on each service at their closest “fast” and “pro” equivalents.
Logged total spend per clip, retries, and time-to-first-frame.

What I learned (without turning that small, non-identical-model comparison into a benchmark):

Runway used credits. I converted them to $/sec from its official pricing before comparing. It’s convenient and polished: I paid a premium for speed and UI in my runs.
Kling and WAN 2.2 availability and endpoint prices varied with the route I could access. I check the exact model version and current provider page before planning a batch.
LTX-2.3 gave me the most transparent knob-turning locally (open weights) and a straightforward per-second mental model through the APIs I used.

For bulk ideation, that clarity helps me predict spend. My March notes don’t include a published cross-platform results table, so I wouldn’t claim a general price or speed winner from them.

Hidden Costs to Watch

These are the places I accidentally overspent during my first week.

Audio Generation Adds Cost

Some APIs treat audio as a separate model call. Don’t add an audio multiplier to this LTX-2.3 estimate by default: the WaveSpeedAI text-to-video route describes synchronized audio in its generated video, while LTX’s pricing page lists text-to-video and audio-to-video as different operations. I now check the operation I actually selected before budgeting voice, music, or sound effects. Sometimes I still generate visuals first and layer audio elsewhere so I can control the cut.

Retake and Extend Pricing

A new full generation is another generation charge. An extend is not necessarily just “extra seconds × the text-to-video rate.” On LTX’s first-party API, extend billing includes the extended portion plus context frames, subject to its stated cap; retake has its own rate and is available on Pro. I price those operations separately before deciding whether to extend, retake, or generate a fresh clip.

Managed API Rate Limits and Overage

Free tiers may throttle, and paid accounts may have rate or concurrency limits. If I burst ten prompts at once, I might queue or hit a limit; that is a scheduling problem first, not proof of an “overage” charge. My workaround: stagger requests in 3–5 job waves or run local for drafts while the API handles finals. I check the provider’s own rate-limit and billing terms rather than borrowing a rule from an unrelated cloud service.

Which Tier Is Right for Your Workflow

Editing TikTok isn’t hard, the challenge is efficiency. Here’s how I split work to keep throughput high without wrecking quality. Fast and Pro below refer to LTX’s first-party variants; on the WaveSpeedAI route above, choose from its documented resolution settings instead.

Storyboard / Concept Pass
- Use Fast 720p where that variant is offered. I generate 3–4 versions per idea. Cost stays manageable, iteration is fast, and I can judge motion/blocks.
- Target supported short clips for rhythm tests. My “batch 10 ideas in 15 minutes” target is a workflow goal, not a guaranteed API completion time.
Draft / Timing Lock
- Switch to Fast 1080p for the winner. I only do one retake here if needed. The goal is to validate text legibility/framing at full res.
- If you need portrait, lock 9:16 now so you don’t crop away important action later.
Production / Final Look
- Go Pro 1080p for pieces that matter (sponsored posts, product pages, paid ads), within Pro’s supported 6-, 8-, or 10-second durations. I keep prompts identical to the locked draft to avoid surprise motion changes.
- For social skits or UGC where texture isn’t critical, I sometimes stay on Fast 1080p and push detail in post.

Micro-template I use when briefing myself:

Intent: Hook in first 1.2s: subject enters from frame right.
Variant: Fast 720p for ideation (×3 takes) → Fast 1080p (×1) → Pro 1080p (final, supported duration).
Budget cap: $6 per concept (all takes combined). If I cross it, I stop and re-prompt.

FAQ

Is LTX-2.3 free to use?

Kind of. The weights are available to download, but running them locally costs hardware, power, and time. A hosted API charges under its own endpoint rules. So “LTX-2.3 free” describes access to open weights better than the total cost of producing clips.

Does audio generation cost extra via API?

It depends on the operation and provider. Don’t add a separate charge just because a supported text-to-video output includes native audio. If you call audio-to-video or another audio service, check that endpoint’s price and billing unit.

How does LTX-2.3 pricing compare to WAN 2.2 API?

It depends on the specific provider, model version, and settings. Convert each valid request to an effective cost per usable clip at your target resolution and duration, then compare. I recheck prices the day I start a batch because they change.

Previous posts: