What AI Video Actually Cost Us on Rented GPUs

TL;DR We rent GPUs on Vast.ai for AI video work. In one MiniMax H3 image-to-video run, generation cost about $0.03 per five-second clip; the full session cost $3.59 for 82 clips. The H3 API price in our notes was $0.08 per video second, or $0.40 for a five-second clip. Rental won clearly for that batch, but the $0.03 figure excludes setup and idle time. We use the full-session number for budgeting, count failed generations, and choose APIs when avoiding infrastructure work matters more than the possible savings.

Start with the unit you need

“Cost per clip” can mean at least two things: the cost while a model is generating, or the total bill divided by usable clips. Both are useful, but they answer different questions.

For a rented GPU, our basic calculation is:

generation cost per clip = clip runtime in seconds × hourly instance rate / 3,600

session cost per usable clip = total session bill / usable clips

session cost per usable video minute =
    total session bill / (usable video seconds / 60)

The rate should include disk when disk is billed separately. The session bill also captures time spent starting the instance, downloading weights, fixing problems, and waiting between jobs. If a generation fails or produces a clip we cannot use, it still consumes GPU time and belongs in the denominator calculation.

For an API billed by output duration, the simple calculation is price per video second × clip duration. Check the provider’s current pricing terms before applying it: model, resolution, audio, and billing rules can affect the comparison.

Our measured rental costs

Here are the runs behind our estimates. The per-clip numbers describe different accounting boundaries, so the session column matters.

Workload	Rented GPU	Clip and runtime	Recorded cost	Session context
MiniMax H3 image-to-video	A100 SXM4 80GB in Czechia, $1.19/h GPU; about $1.25/h with disk	Five-second clip, about 86 seconds to generate	About $0.03 in generation time	82 hero clips; $3.59 total, about three hours including setup
MiniMax H3 text-to-video with audio, earlier test	RTX PRO 6000 Blackwell 96GB, $1.625/h	Five-second clip, about 51 seconds to generate	About $0.02 in GPU time	56-minute session; $2.18 total, including $0.64 inbound traffic
LatentSync 1.6 lip-sync	RTX 3090 in UAE, $0.27/h, free inbound	Eight-second talk clip, 238 seconds to process	About $0.09 recorded for the clip	A separate queued batch self-test took 15.9 minutes and cost $0.07; setup took 11 minutes

The H3 A100 arithmetic is straightforward: 86 × $1.25 / 3,600 is about $0.03. At that rate, twelve five-second clips make one minute of output, so generation alone is about $0.36 per output minute. Our actual 82-clip session delivered 410 seconds of video. Dividing $3.59 by those 410 seconds gives about $0.53 per output minute, or about $0.044 per clip. That session figure is the more useful one for a budget.

The lip-sync row deserves care. At $0.27/h, 238 seconds of GPU time calculates to about $0.02, while our recorded clip cost was about $0.09. Those figures do not describe the same accounting boundary; the available notes do not fully reconcile them. We would use the recorded cost for a rough budget and measure a new batch before treating it as a repeatable unit price. At $0.09 per eight-second clip, the rough output-minute figure is $0.675.

This small Python calculation shows the boundaries explicitly:

h3_rate_with_disk = 1.25
h3_runtime_seconds = 86
h3_clip_seconds = 5
h3_session_cost = 3.59
h3_session_clips = 82

api_rate_per_video_second = 0.08

generation_cost = h3_runtime_seconds * h3_rate_with_disk / 3600
session_cost_per_clip = h3_session_cost / h3_session_clips
session_output_minutes = h3_session_clips * h3_clip_seconds / 60
api_cost_per_clip = api_rate_per_video_second * h3_clip_seconds

print(f"H3 rental, generation only: ${generation_cost:.3f}/clip")
print(f"H3 rental, full session: ${session_cost_per_clip:.3f}/clip")
print(f"H3 rental, full session: ${h3_session_cost / session_output_minutes:.2f}/output minute")
print(f"H3 API at stated rate: ${api_cost_per_clip:.2f}/clip")

Compare APIs fairly

Our H3 API reference price is $0.08 per second of video. That makes a five-second clip $0.40 and a minute of output $4.80 at that rate. For 82 five-second clips, the duration-based calculation is $32.80. Against our $3.59 rental session, that is roughly nine times the cost. Comparing only the $0.03 generation figure makes rental look about thirteen times cheaper, but hides the rest of the session.

We do not have measured, directly comparable API prices for every model people might consider:

API option	Price to use in a current comparison	What to check
MiniMax H3	$0.08 per video second in our reference	Confirm current rate and settings
Veo	Check current pricing	Model, output duration, resolution, and billing terms
Kling	Check current pricing	Model, output duration, resolution, and billing terms
Seedance	Check current pricing	Model, output duration, resolution, and billing terms

This table is a budgeting prompt, not a claim that the outputs are interchangeable. Compare results that meet the same creative need. A cheaper clip that must be regenerated several times may cost more per accepted clip; an expensive clip that works immediately may save time. We would also compare the actual workflow offered by each API, rather than assume every model supports the same inputs and controls.

Where the break-even point moves

A useful planning formula is:

rental total = hourly rate × (setup + generation + idle time) / 60
             + transfer charges + ongoing storage charges

API total = accepted and rejected billable output × API rate

In that rental formula, time is in minutes. For a quick estimate, divide expected rental total by the number of usable clips, then compare it with the API cost of obtaining those usable clips. The difficult inputs are usually how many attempts you will reject and how long the rented instance will sit idle.

Setup makes batch size important. Our H3 run downloaded 72 GB of weights in about eight minutes, and the full 82-clip session took about three hours including setup. For LatentSync, setup took roughly 9–11 minutes; in the queued self-test, that was most of a 15.9-minute run. When we queue work before renting, more output shares that startup time.

Idle time moves the answer the other way. A GPU meter can run while we inspect clips, revise prompts, or wait for the next input. Failed generations also increase cost per accepted clip. The H3 session produced 82 hero clips, but that count should not be treated as a guarantee that another batch will have the same acceptance rate. Our own time belongs in the decision too: preparing images, handling weights and drivers, watching jobs, copying results, and cleaning up are work even when the provider does not put them on the invoice.

APIs are often the better choice for a few clips, an uncertain experiment, or work that must start without environment setup. They also remove much of the operational burden when the team cannot queue a batch or does not want to manage an instance. Rental becomes more attractive when we have many ready inputs, a known workflow, and someone available to check the run and collect its outputs.

Avoid charges that spoil the calculation

The earlier Blackwell test taught us to inspect inbound traffic pricing. Its $2.18 total included $0.64 for 245 GB of model weights; GPU time accounted for $1.47. We now check inet_down_cost when looking at offers and prefer zero inbound cost for weight-heavy work. We also filter for reliability of at least 0.97, check that the driver and CUDA version fit the image, and provision enough disk. For large weights, our working threshold is at least 150 GB; 40 GB is suitable only for smaller downloads.

The CLI can help inspect offers and verify what is still running:

vastai search offers 'reliability >= 0.97 inet_down_cost = 0 disk_space >= 150' -o 'dph+' --raw
vastai show instances --raw

We made a more painful mistake with a stopped instance. Its 90 GB disk continued billing at about $0.0167/h, roughly $0.40 a day. We left it stopped for days, our balance went negative, and we could not start it to retrieve a trained result that we had never downloaded. “Stopped” was not the end of the bill.

Our rule now is to copy results back, back them up, and verify the backup before destroying the instance. In one verification, local and remote counts and sizes matched: 5,342 files and 1.379 GiB. For long runs, we use a cost cap and a detached deadline watchdog that retries destruction if the controller crashes. We then verify that the instance list is empty. The CLI destruction command prompts for confirmation; this is the form we use in automation after results are safe:

echo y | vastai destroy instance "$INSTANCE_ID"
vastai show instances --raw

What we would budget

What it cost us

• H3 image-to-video on an A100: about $0.03 of generation time per five-second clip; $3.59 for 82 clips over about three hours, or about $0.044 per clip across the session.
• Earlier H3 text-to-video test on Blackwell: $2.18 for 56 minutes, including $1.47 of GPU time and $0.64 of inbound traffic.
• LatentSync 1.6 on an RTX 3090: about $0.09 recorded for an eight-second talk clip. A separate 15.9-minute queued self-test cost $0.07.
• An overlooked stopped 90 GB disk: about $0.0167/h, or about $0.40/day.
• H3 API reference: $0.08 per video second, equivalent to $0.40 for a five-second clip at that rate.

For our 82-clip H3 batch, rental saved enough to justify managing the instance. We would still price a small or unfamiliar job both ways, using current API pages and an estimate for setup, rejected output, idle time, and our own work. If you want to run that comparison on Vast.ai, this is our referral link.