How Much Does AI Video Cost per Second? A Breakdown

Most AI video APIs charge per second of generated output, so the cost of a clip is the model's per-second rate multiplied by its duration. On Jantaris today that is from $0.261 per second for Seedance 2.5 and from $0.169 per second for Kling 3.0. Veo 3.1 is the exception: it is billed per 8-second clip: from $2.53 per video. The number that decides your real budget, though, is how many seconds you generate per second you keep, because almost nobody publishes the first take.

I track this on every project. Below is the formula I use, worked examples for common formats, and a script that estimates a budget before you spend anything.

AI video pricing per second: current rates

Rates are live from the pricing page. Resolution and options can change the price on some models, which is why every request returns estimated_cost for your exact parameters before it runs.

For context against the source: every vendor in this group prices video by the second on its official list, with higher tiers for higher resolution. Among the three, Veo 3.1 is the premium option on Google's list prices, especially at 4K. On Jantaris, Veo 3.1 always returns a fixed 8-second clip and you pay per clip, so a shorter shot is not cheaper - you trim it in the edit.

The formula: rate × seconds × take ratio

The per-second rate is the easy part. The full formula for one finished clip:

cost of a finished clip = rate per second × seconds per generation × generations per keeper

For a per-clip model such as Veo 3.1, drop the seconds: cost = price per clip × clips × generations per keeper.

Generations per keeper (I call it the take ratio) is the number of attempts you make before you get a clip you publish. From my own projects:

• Simple shots (landscape, product turntable, slow camera move): usually 1 to 2 takes.
• Shots with people moving, hands, or specific action: 3 to 5 takes.
• Dialogue, lip-sync or precise choreography: can go higher.

A 5-second clip with a take ratio of 4 bills 20 seconds, not 5. That multiplier matters more than the difference between models.

What failed generations cost

On Jantaris a generation that ends as failed (content filter, provider error, timeout) costs 0 and the held amount returns to your balance in full. So the take ratio only counts takes that actually rendered and that you rejected on quality. You are not paying for infrastructure hiccups.

Worked examples: seconds billed per format

Instead of dollar amounts that go stale, here is what matters: seconds billed (or clips billed for Veo 3.1). Multiply by the current rate from the table above.

A 30-second vertical reel

So a 30-second reel on Seedance 2.5 with three takes costs about 90 × from $0.261 per second. On Veo 3.1 it is 4 clips × 3 takes = 12 × from $2.53 per video, plus editing time to join four clips.

A 6-second product loop for a store page

Add the cost of the first-frame image: one or two images at from $0.0747 per image or from $0.0688 per image each. It is small compared with the video, and it cuts the take ratio because the composition is fixed before the motion starts.

A 60-second explainer with 8 scenes

Eight scenes of roughly 7 to 8 seconds each, three takes per scene, is around 170 to 190 seconds billed on per-second models. On Veo 3.1 it is 8 clips × 3 takes = 24 clips. Add a music bed from Mureka V9 at $0.124 per song, generated once or twice.

Five things that drive AI video cost

1. Duration. Linear. Twice the seconds, twice the cost. Do not generate 10 seconds when the edit needs 4.
2. Resolution tier. Higher tiers cost more on most models. On Veo 3.1, 4K costs more per clip than 720p and 1080p.
3. Take ratio. The multiplier from above. Better prompts and first-frame images reduce it more than any price difference.
4. Audio. Some models price audio separately or include it by default. If you add your own soundtrack, check whether turning it off (generate_audio: false) changes estimated_cost for your model.
5. Stitching. Short maximum lengths mean more generations and more boundaries that can go wrong, which often means extra takes on transition clips.

How I cut AI video costs in practice

Draft cheap, render once. I explore at the lowest resolution and a shorter duration, pick the winning prompt, then render the final at full resolution and length. With Seedance 2.5 at 480p the draft stage costs a fraction of the final.

draft = {"prompt": PROMPT, "duration": 5, "resolution": "480p", "aspect_ratio": "9:16"}
final = {"prompt": PROMPT, "duration": 20, "resolution": "720p", "aspect_ratio": "9:16"}

Fix the first frame. Generating the opening image first (see Generate AI images with Python) and passing it as image_url gives the video model less to guess.

Use the right model per shot. Long single takes on Seedance 2.5, dialogue scenes on Kling 3.0, 4K hero shots on Veo 3.1. My comparison of AI video APIs goes through the trade-offs.

Check estimated_cost before a batch. Submit one task, read estimated_cost, multiply by the batch size. If it is over budget, change duration or resolution before submitting the rest.

Budget script: estimate before you generate

This script takes a shot list, calculates seconds (or clips) billed including takes, and prints the total. Fill RATES with the current per-second rates and PER_CLIP with per-clip prices from /pricing or from GET /v1/models/{id}. For a quick estimate without code, use the AI cost calculator.

import math

# Current per-second rates in USD, copied from /pricing
RATES = {
    "seedance-2.5": 0.0,
    "kling-3.0": 0.0,
}
# Models billed per clip: price per clip in USD and fixed clip length in seconds
PER_CLIP = {
    "veo-3.1": {"price": 0.0, "length": 8},
}
MAX_LEN = {"seedance-2.5": 30, "kling-3.0": 15}

SHOTS = [
    # (model, seconds needed in the edit, expected takes)
    ("seedance-2.5", 20, 3),
    ("kling-3.0", 12, 4),
    ("veo-3.1", 8, 2),
]

total = 0.0
for model, seconds, takes in SHOTS:
    if model in PER_CLIP:
        clip = PER_CLIP[model]
        clips = math.ceil(seconds / clip["length"])
        billed = clips * takes
        cost = billed * clip["price"]
        total += cost
        print(f"{model:14} {seconds:>3}s in edit -> {clips} clip(s) x {takes} takes = {billed:>4} clips billed  ${cost:,.2f}")
        continue
    clips = math.ceil(seconds / MAX_LEN[model])
    per_clip = math.ceil(seconds / clips)
    billed = clips * per_clip * takes
    cost = billed * RATES[model]
    total += cost
    print(f"{model:14} {seconds:>3}s in edit -> {clips} clip(s) x {per_clip}s x {takes} takes = {billed:>4}s billed  ${cost:,.2f}")

print(f"\nEstimated total: ${total:,.2f}")

Output for the shot list above, before you fill in the rates:

seedance-2.5    20s in edit -> 1 clip(s) x 20s x 3 takes =   60s billed  $0.00
kling-3.0       12s in edit -> 1 clip(s) x 12s x 4 takes =   48s billed  $0.00
veo-3.1          8s in edit -> 1 clip(s) x 2 takes =    2 clips billed  $0.00

Estimated total: $0.00

The seconds and clips columns are the part that does not change. Once RATES and PER_CLIP hold real numbers, the dollar column follows.

Some models accept only specific durations, so round up to a valid value when you plan. Veo 3.1 on Jantaris always generates 8 seconds; the 4, 6 and 8 second options you may see in Google's documentation belong to Google's own price list.

Reading the real cost from the API

The estimate above is for planning. The API gives you exact numbers per task:

import os
import requests

API = "https://jantaris.com/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['AI_API_KEY']}"}

r = requests.post(f"{API}/generate", headers=HEADERS, json={
    "model": "seedance-2.5",
    "input": {"prompt": "Slow pan across a foggy pine forest at sunrise", "duration": 10, "resolution": "720p"},
})
task = r.json()
print("estimated before running:", task["estimated_cost"])

# later, after the task finishes
t = requests.get(f"{API}/tasks/{task['id']}", headers=HEADERS).json()
print("final:", t["status"], t["cost"])

estimated_cost is held on your balance while the task runs. On success, cost is charged. On failure, cost is 0 and the hold is released. If your balance is below the estimate, the submission returns 402 and nothing starts, which makes a natural spending cap.

Paying for AI video without a subscription

Many video tools sell monthly credit plans where unused credits expire. On Jantaris you top up a prepaid balance that does not expire, with no subscription and no minimum commitment. Top-ups start at $10, with ready-made packs of $10, $25, $50, $100 and $250. The same balance pays for video, images, music and chat models, through the API or the browser Studio.

If you build a pipeline around these numbers, the async tasks and webhooks guide shows how to track estimated_cost and cost per task in a database.

FAQ

How much does AI video cost per second?

It depends on the model and resolution. Current Jantaris rates are from $0.261 per second for Seedance 2.5 and from $0.169 per second for Kling 3.0. Veo 3.1 is billed per 8-second clip (from $2.53 per video), not per second. Every request also returns an exact estimated_cost before it runs.

How much does a 30-second AI video cost?

Multiply 30 seconds by the model's per-second rate, then by the number of takes you expect. With three takes, budget about 90 seconds of generation on Seedance 2.5 or Kling 3.0. On Veo 3.1 you need four 8-second clips per pass, so three takes cost 12 × from $2.53 per video.

Do I pay for failed AI video generations?

Not on Jantaris. A task that ends as failed costs 0, and the amount held at submission is returned to your balance in full.

Is higher resolution more expensive?

Usually yes. Most video models price higher resolution tiers higher per second. Draft at a low resolution and render only the final at full quality.

How can I estimate costs before generating?

Take the per-second rate from the pricing page (or the per-clip price for Veo 3.1), multiply by planned seconds or clips and expected takes, use the AI cost calculator, or submit one task and read its estimated_cost, then scale by your batch size.