Methodology · 9 min · 6 citations
Cheapest AI Video API 2026: Per-Second Costs Ranked
Cheapest AI video API 2026: Luma Ray 3.2 from $0.012/s, Grok Imagine Lite $0.02/s, Pika 2.2 $0.04/s, Runway $0.05/s, and what resolution does to cost.
By the cheapest published rate on October 19, 2026: Luma Ray 3.2 from $0.012 a second (360p drafts, pre-release rates)[5], Grok Imagine 1.5 Lite $0.02/s at 480p through Runway's API[1], Pika 2.2 $0.04/s at 720p on fal.ai[3], then Runway Gen-4 Turbo, WAN 3 and MiniMax H3 Max at $0.05/s[1].
The cheapest sticker is rarely the cheapest API. Resolution multiplies the rate, retries multiply the count, and a model that needs neither can win on cost per accepted clip.
If you are adding AI video to a product, the per-second price is the first number you check and the last one you should trust. This guide ranks the published rates, checked against Runway's API price list, fal.ai, Luma and Replicate on October 19, 2026, then shows the three factors that decide your actual bill: resolution, retries, and quality per dollar.
1. Per-second prices, ranked
| Model (route) | Cheapest published rate | Higher resolutions |
|---|---|---|
| Luma Ray 3.2 (Luma API, pre-release rates) | $0.012/s, 360p draft[5] | 540p $0.03, 720p $0.06, 1080p $0.24 |
| Grok Imagine 1.5 Lite (Runway API) | $0.02/s, 480p[1] | 720p $0.03, 1080p $0.14 |
| Gemini Omni Flash 1.1 (Runway API) | $0.034/s, 360p[1] | 720p $0.10, 1080p $0.15, 4K $0.30 |
| Pika 2.2 (fal.ai) | $0.04/s, 720p[3] | 1080p $0.09 |
| Runway Gen-4 Turbo (Runway API) | $0.05/s[1] | One rate |
| WAN 3 (Runway API) | $0.05/s, 480p[1] | 720p $0.10, 1080p $0.20 |
| MiniMax H3 Max (Runway API) | $0.05/s, 480p[1] | 768p $0.08 |
| Kling 2.5 Turbo Pro (fal.ai) | $0.07/s, $0.35 minimum for 5 s[2] | One rate |
| Kling 3.0 Standard (Runway API) | $0.09/s without audio[1] | $0.13 with audio |
| Wan 2.1 image-to-video (Replicate) | $0.09/s, 480p[6] | 720p $0.25 |
| Veo 3.1 Fast (Runway API) | $0.10/s without audio[1] | $0.15 with audio |
| Runway Gen-4.5 (Runway API) | $0.12/s[1] | One rate |
Runway's API now resells about twenty model families at $0.01 a credit, so one key reaches most of the cheap end of the market[1]. Some routes add small per-input charges: Grok Imagine adds a credit for each reference image, including an image-to-video start frame, and Gemini Omni Flash charges for reference images and input video[1]. Two prices are provisional: Luma says Ray 3.2's API rates may change before general availability[5], and fal.ai retires Luma Ray 2 ($0.50 per 5-second 540p clip) on October 25, 2026 in favour of Ray 3.2[4].
2. Why the cheapest sticker is not the cheapest API
The lowest per-second rate often costs the most in practice. A cheap model that needs three attempts to produce a usable clip, or that only looks acceptable at a higher resolution tier, ends up pricier per finished clip than a slightly more expensive model that delivers on the first try at lower resolution. The right metric is cost per accepted clip, which folds in quality, retries, and the resolution you actually ship.
3. Resolution multiplies the bill
Resolution is the most common hidden multiplier, and the cheapest rates are almost always the lowest resolutions. Grok Imagine 1.5 Lite costs $0.02 a second at 480p and $0.14 at 1080p, seven times as much[1]. Luma Ray 3.2 goes from $0.03 at 540p to $0.24 at 1080p, eight times[5], and Wan 2.1 on Replicate from $0.09 at 480p to $0.25 at 720p[6]. Always price the resolution you will publish, not the base tier in the headline.
4. Budget for retries, not single takes
Video generation is probabilistic, so you rarely accept the first output. If you keep one clip in three, your effective cost is three times the per-clip rate. A 5-second Runway Gen-4 Turbo clip is about $0.25 per generation, so at a one-in-three acceptance rate the cost per shipped clip is closer to $0.75[1]. Track your acceptance rate per model and use it to compute the real number; a model with a higher acceptance rate can beat a cheaper one that you reroll constantly.
5. A method to find your cheapest option
- List your hard requirements: resolution, length, and minimum quality bar.
- Run the same prompts through two or three models on a multi-model API such as fal.ai, Replicate or Runway's.
- Record acceptance rate per model, not just the per-second price.
- Compute cost per accepted clip = per-clip cost ÷ acceptance rate, at the resolution you ship.
- Pick the lowest cost per accepted clip that clears your quality bar, then revisit direct API access if monthly volume is high.
To turn that per-clip number into a monthly budget for your expected volume, use the AI stack cost calculator, and the ROI payback calculator to check the video feature earns back its generation cost. For the subscription plans and commercial rights, see Runway vs Kling vs Pika vs Luma.
All pricing figures verified against official pricing and host pages on 2026-10-19.
Frequently asked questions
What is the cheapest AI video API in 2026?
By the cheapest published rate on October 19, 2026: Luma Ray 3.2 at $0.012 a second for 360p drafts and $0.03 at 540p (rates Luma says may change before general availability), Grok Imagine 1.5 Lite at $0.02 a second at 480p through Runway's API, and Pika 2.2 at $0.04 a second at 720p on fal.ai. Runway Gen-4 Turbo, WAN 3 and MiniMax H3 Max follow at $0.05 a second. Compare them at the resolution you ship: Grok Imagine Lite costs seven times as much at 1080p as at 480p.
Is a cheaper per-second rate always cheaper overall?
No. Three things change the real bill. First, resolution: Luma Ray 3.2 at $0.03 a second at 540p becomes $0.24 at 1080p. Second, retries: video generation often needs several attempts to get a usable take, so divide the per-clip cost by your real acceptance rate. Third, quality: a cheaper model that needs more retries or a higher resolution to look right can cost more per finished clip than a pricier model that delivers on the first try. Compare cost per accepted clip, not the sticker per second.
Can I get a video API from Pika?
Yes, through fal.ai: Pika 2.2 costs $0.20 for a 5-second clip at 720p and $0.45 at 1080p, about $0.04 and $0.09 a second. Pika's own site sells consumer subscriptions; for API access, fal.ai is the published route.
Should I use a model aggregator to keep video costs low?
Often yes. Aggregators like fal.ai and Replicate, and Runway's own API, which now resells about twenty model families at $0.01 a credit, put many video models behind one key with published per-second prices. That lets you A/B test models for quality per dollar without separate contracts and switch to a cheaper model when one is good enough. The tradeoffs are the host's margin and your dependence on its uptime and rate limits. Start on a multi-model API to find the cheapest model that meets your quality bar, then revisit going direct if volume grows.
References
Sources
Primary sources only. No vendor-marketing blogs or aggregated secondary claims.
- 1 Runway — API pricing (credits $0.01 each; Gen-4 Turbo 5 credits/s, Gen-4.5 12; also Grok Imagine 1.5 Lite, WAN 3, MiniMax H3 Max, Kling 3.0, Veo 3.1 and Gemini Omni Flash by the second) — accessed 2026-10-19
- 2 fal.ai — Kling 2.5 Turbo Pro text-to-video ($0.35 for 5 seconds, then $0.07 per extra second) — accessed 2026-10-19
- 3 fal.ai — Pika 2.2 text-to-video ($0.20 for 5 seconds at 720p, $0.45 at 1080p) — accessed 2026-10-19
- 4 fal.ai — Luma Ray 2 image-to-video ($0.50 per 5 seconds at 540p; 720p 2x, 1080p 4x; deprecated October 25, 2026) — accessed 2026-10-19
- 5 Luma — API pricing (Ray 3.2, 5 seconds SDR: 360p draft $0.06, 540p $0.15, 720p $0.30, 1080p $1.20; may change before general availability) — accessed 2026-10-19
- 6 Replicate — pricing (Wan 2.1 image-to-video 480p $0.09/s, 720p $0.25/s of output video) — accessed 2026-10-19
The 6 vendor figures on this page, each with its source and the date it was checked, are also in the vendor price reference, where every figure has its own link.
Tools referenced in this article