What One Second of AI Video Really Costs You

The sticker price of AI video is easy: most models charge per generated second, so a clip costs its length times the rate. Right now Kadraris charges from $0.261 per second on Seedance 2.5 and from $0.0963 per second on Kling 3.0, while Veo 3.1 is sold per 8-second clip at from $2.53 per video. The number that actually decides your budget is a different one: how many seconds you render for every second you publish. Almost nobody ships the first take.

I log this on every project. Here is the formula I work with, sample budgets for common formats, and a small script that estimates a project before any money is spent.

Rates today

These figures update automatically from the pricing page. Because some models charge more for certain resolutions or options, the API answers each request with estimated_cost for precisely what you asked for.

For background: all three makers list video by the second on their own price sheets, with steps for higher resolution, and Veo 3.1 is the top-priced of the three on Google's list, especially in 4K. Here Veo 3.1 has one fixed length and one price per clip, so needing only five seconds saves nothing; the editor does the shortening.

Five levers on the bill

1. Length. Cost scales linearly with seconds. If the edit needs 4 seconds, do not render 10.
2. Resolution. Going up a tier usually raises the rate; a 4K Veo 3.1 clip costs more than 720p or 1080p.
3. Takes. The multiplier explained in the next section. Better prompts and a fixed first frame shrink it more than switching models.
4. Sound. Some models charge for audio separately or include it automatically. If your own soundtrack will replace it, check whether generate_audio: false lowers estimated_cost for that model.
5. Joins. Short maximum lengths mean more clips and more seams that can go wrong, and transition clips often need extra takes.

The real formula includes takes

The per-second rate is only one factor. For one usable clip:

cost per usable clip = rate per second
                     × seconds per render
                     × renders per keeper

Veo 3.1 has no seconds in the formula: multiply its clip price by the clips needed and the renders per keeper.

I call renders per keeper the take ratio: how many attempts it takes until a clip is good enough to publish. From my own work:

• Easy shots such as a landscape, a product turntable or a slow camera move: 1 to 2 takes.
• Moving people, visible hands or a particular gesture: 3 to 5.
• Talking heads with lip sync, or choreography: above that.

A 5-second clip at a take ratio of 4 means 20 billed seconds, not 5. That factor matters more than the gap between models.

Failed renders are not part of it

When a task ends as failed, whether from a content filter, a provider error or a timeout, it costs 0 and the reserved amount goes back to your balance. The ratio therefore covers only finished renders you threw away because they were not good enough. Infrastructure problems are not on your bill.

Sample budgets in billed seconds

Dollar figures go stale, so these tables count billed seconds (or billed clips on Veo). Multiply by the rates above.

Vertical reel, 30 seconds

On Seedance 2.5 with three takes that is about 90 × from $0.261 per second. On Veo 3.1 it is 4 × 3 = 12 × from $2.53 per video, plus the time to join four clips.

Six-second product loop for a shop page

Add the start image: one or two pictures at from $0.07 per image or from $0.0688 per image each. That is small next to the video and it lowers the take ratio, because composition is settled before motion begins.

One-minute explainer, eight scenes

Eight scenes of about 7-8 seconds with three takes each come to roughly 170-190 billed seconds on a per-second model. On Veo 3.1 it is 8 × 3 = 24 clips. A music bed from Mureka V9 adds $0.15 per song; you will probably make one or two.

Habits that keep costs down

Draft small, render big once. All exploration happens on short, low-resolution clips. Only the prompt that wins gets a full-length, full-quality render. On Seedance 2.5, a 480p draft is a small slice of what the final costs.

# same prompt, two sets of settings
draft = {"prompt": PROMPT, "duration": 5,
         "resolution": "480p", "aspect_ratio": "9:16"}
final = {"prompt": PROMPT, "duration": 20,
         "resolution": "720p", "aspect_ratio": "9:16"}

Lock the first frame. An image generated up front and sent as image_url leaves the video model fewer decisions (Python image guide).

Match model to shot. Each of the three has a sweet spot; I map them in my AI video API comparison.

Price one task before a batch. Send a single job, note its estimated_cost and scale it to the batch. If the total is too high, shorten or downscale before queuing the rest.

A planning script

This takes a shot list, works out billed seconds (or clips) including takes, and prints a total. Put current per-second rates in RATES and per-clip prices in PER_CLIP, from /pricing or GET /v1/models/{id}. Prefer not to code? Use the AI cost calculator.

import math

# per-second prices in USD, copy them from /pricing
RATES = {"seedance-2.5": 0.0, "kling-3.0": 0.0}
# per-clip models: price in USD and fixed length in seconds
PER_CLIP = {"veo-3.1": {"price": 0.0, "length": 8}}
MAX_LEN = {"seedance-2.5": 30, "kling-3.0": 15}

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

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

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

With the rates still at zero, the output looks like this:

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

Total estimate: $0.00

Seconds and clips do not change over time; once you enter real prices, the money column becomes meaningful.

Certain models accept a fixed set of durations, so plan with the next allowed value. On Kadraris, Veo 3.1 is always 8 seconds. Shorter Veo lengths you may read about exist only when buying directly from Google.

Exact cost per task from the API

The script is for planning. The API reports exact amounts for every task:

import os, requests

API = "https://kadraris.com/v1"
KEY = os.environ["KADRARIS_API_KEY"]
HEADERS = {"Authorization": f"Bearer {KEY}"}

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

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

The estimate is held from your funds during processing. A successful task is billed its cost; a failed one reports cost 0 and the hold disappears. Not enough funds to cover the estimate? You get 402 and the job never begins, which effectively caps spending.

No subscription, no expiring credits

Many tools sell monthly credits that disappear if unused. Kadraris works differently: you add money when you need it, it stays until spent, and there is neither a plan nor a commitment. Start from $10; preset buttons offer $10, $25, $50 and $100. Whatever you generate, video, pictures, songs or chat, comes out of that one pot, whether via code or in Studio.

Logging both numbers for each job in your own database is covered in the async tasks and webhooks guide.

Questions

Why is my final bill higher than length times rate?

Because of takes. Every rendered attempt you reject still counts, so a 10-second clip that needed three tries bills 30 seconds. Resolution above the cheapest tier and, on some models, audio also raise the rate.

Is a 5-second Veo clip cheaper than an 8-second one?

Not on Kadraris. Veo 3.1 always renders 8 seconds and is charged per clip; cut it shorter in your editor.

How do I stop a batch from overspending?

Submit one task and check its estimated_cost, then size the batch. Keep only the budget you are willing to spend on the balance: if a request's estimate is higher than what is available, the API returns 402 and does not start it.

What is a realistic take ratio to plan for?

Count 1-2 for simple scenery and product moves, 3-5 for people and hands, and more for dialogue or choreography. Track your own ratio for a few projects; it is the best predictor of your next budget.