DEV Community: Viddra Team

One API key for 20 AI video models: real pricing, working code, and a $1 free tier

Viddra Team — Sun, 13 Sep 2026 08:32:49 +0000

Every AI video provider ships its own SDK, its own auth scheme, its own billing quirks, and its own job-polling loop. Want a Kling clip, a Veo shot, and a Wan generation in the same app? That's three accounts, three key rotations, and three polling implementations — before you've generated a single frame.

I've been benchmarking video APIs over the past few weeks (Hailuo H3 vs Kling, Wan 3.0 deep dive). This post covers the unified-API approach I settled on (Viddra — full disclosure at the bottom): one key, one OpenAI-style request shape, and per-second billing across 20+ models.

The actual price table

All prices are per second, pulled live from the model directory (GET /v1/models) rather than marketing pages:

Model	Provider	Price	Notes
Hailuo 2.3	MiniMax	$0.0933/s (768P) · $0.15/s (1080P)	budget flagship tier
Hailuo H3	MiniMax	$0.12/s (768P) · $0.20/s (2K)	2K flagship, 4–15s
Seedance 1.0 Pro	ByteDance	$0.13/s	efficient budget tier
Seedance 2.0 Mini	ByteDance	$0.15/s (720p)	4–15s
Wan 2.6	Alibaba	$0.16/s (720p) · $0.24/s (1080p)	solid all-rounder
Kling 3.0	Kuaishou	$0.18/s	quality flagship, 3–15s, optional audio
Veo 3.1 Fast	Google	$0.20/s	native audio, speed-optimized
Wan 3.0	Alibaba	$0.25/s (480p) · $0.50/s (720p) · $1.00/s (1080p)	2–30s, native audio, i2v + 10 reference inputs
Veo 3.1	Google	$0.35/s ($0.60/s with audio)	premium tier
Seedance 2.0	ByteDance	$0.47/s (720p)	480p–4K
Seedance 2.5	ByteDance	$0.68/s (720p)	long-form, up to 30s, 50 reference inputs

The spread between the cheapest and priciest flagship output is roughly 7x — which is exactly why a unified price table matters before you commit code to one provider.

The request shape

One endpoint handles every model. Auth is a standard bearer key:

curl -X POST https://api.viddra.com/v1/video/generations \
  -H "Authorization: Bearer $VIDDRA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling3.0",
    "prompt": "A golden retriever puppy playing in autumn leaves, slow motion",
    "duration": 5
  }'

The call returns 202 Accepted with a task id. Billing works on hold-then-settle: the estimated cost is held when the task starts, and on failure the hold is refunded automatically — no support ticket, no expired credits.

Polling in 12 lines of Python

import os, time, requests

KEY = os.environ["VIDDRA_API_KEY"]
H = {"Authorization": f"Bearer {KEY}"}

r = requests.post("https://api.viddra.com/v1/video/generations", headers=H,
                  json={"model": "veo3.1-fast",
                        "prompt": "Drone shot flying over neon-lit city streets at night",
                        "duration": 5})
task_id = r.json()["task_id"]

while True:
    d = requests.get(f"https://api.viddra.com/v1/video/generations/{task_id}", headers=H).json()
    if d["status"] in ("succeeded", "failed"):
        print(d["status"], d.get("video_url") or d.get("error"))
        break
    time.sleep(10)

Swap "model" to kling3.0, wan3.0-video, hailuo-h3, seedance2.5, veo3.1 — the request shape doesn't change. Image-to-video uses the same endpoint with an image_url field. There's also a zero-dependency Node.js version of this flow in the quickstart docs.

The billing details that actually matter

$1 free credit on signup — enough to test 5–8 real generations across models, no card required
+10% bonus on every top-up
Per-second billing with no monthly minimum; balance never expires
Auto-refund on failure — failed tasks return the full hold
Rate limit: 100 req/min per IP, which is enough for production batch jobs

When a unified API is the wrong choice

Fair question. If you're all-in on a single provider and need their deepest params (e.g. Wan 3.0's full reference-input matrix), the native SDK will always have the newest knobs first. The unified layer shines when you're routing by price/quality per shot — cheap Seedance Mini drafts, Kling or H3 for finals — or when you don't want to wire up a new provider every time a benchmark shifts.

Full disclosure: Viddra is the unified API used for the benchmarks and pricing above, and I'm affiliated with the project. All prices were pulled from the live model directory, and the code samples run as written. Test it with the $1 free credit before trusting any of this.

Wan 3.0 API: pricing, features and a working Python example

Viddra Team — Mon, 07 Sep 2026 08:18:26 +0000

Wan 3.0 is Alibaba's "all-in-one" video generation model, and it has quietly become the most flexible frontier model you can call from a single endpoint: text-to-video, image-to-video with first/last-frame control, and reference-to-video — with native audio baked in, up to 30 seconds per clip.

This is the rundown I wanted when I wired it up: real pricing, the actual feature set, and a complete Python example using the real API shape (no pseudocode).

Pricing: per-second, audio included

Pay-as-you-go, no subscription. Audio is included at every tier — the same price whether sound is on or off:

Resolution	Price/sec	Duration	Example cost
480p	$0.25	2–30s	5s clip ≈ $1.25
720p	$0.50	2–30s	5s clip ≈ $2.50
1080p	$1.00	2–30s	5s clip ≈ $5.00

Five aspect ratios are supported: 16:9, 9:16, 1:1, 4:3, 3:4. Output is a 30fps MP4.

That 30-second ceiling is the standout feature. Most frontier models cap at 5–15 seconds per run; Wan 3.0 does 2–30s, which makes it one of the longest single-shot generators available through an API. Need longer? Chain clips by feeding the last frame of one render in as the first frame of the next.

What the model actually supports

Text-to-video — straight prompt to clip
Image-to-video — animate a still (first-frame input), with an optional last frame for controlled transitions or loops
Reference-to-video — ground the generation in up to 10 reference images, 5 reference videos and 5 reference audio tracks; the model preserves your subject's look
Native audio — ambience, sound effects and music are baked into the MP4 (included in the per-second price)

For e-commerce/product shots, the combination of image-to-video + reference media + native audio in one render is the practical selling point: packshot photo in, product loop with sound out.

The API shape

Plain REST + JSON, authenticated with a Bearer key (vsk-...). The flow is asynchronous:

POST /v1/video/generations → 202 Accepted with an id and a hold_usd (the estimated cost is frozen from your balance)
Poll GET /v1/video/generations/{id} every 3–5 seconds: queued → running → succeeded / failed
succeeded returns a video_url; failed automatically refunds the held amount

On Viddra the model id is wan3.0-video, and the full live model directory is at GET /v1/models.

A complete Python example

Runnable as-is — the only thing to replace is the API key:

import time
import requests

API = "https://api.viddra.com"
H = {"Authorization": "Bearer YOUR_VIDDRA_API_KEY"}

# 1) Submit the generation task (async — returns 202 Accepted)
task = requests.post(
    f"{API}/v1/video/generations",
    headers=H,
    json={
        "model": "wan3.0-video",
        "prompt": "Cinematic dolly shot through a neon-lit market street in the rain, ultra-detailed, 4k",
        "duration": 5,
        "resolution": "720p",
        "aspect_ratio": "16:9",
        "audio": True,
    },
).json()

print(task)  # {'id': '...', 'status': 'queued', 'hold_usd': '2.5000', ...}

# 2) Poll until the task succeeds (or fails — the hold is auto-refunded)
while True:
    t = requests.get(f"{API}/v1/video/generations/{task['id']}", headers=H).json()

    if t["status"] == "succeeded":
        print("video_url:", t["video_url"])
        break
    if t["status"] == "failed":
        raise RuntimeError(t.get("error"))
    time.sleep(5)

Most 5-second renders finish in a couple of minutes. Wan 3.0 supports durations from 2 to 30 seconds, so the same code works for a 30s 1080p render — only your bill changes.

Things worth knowing before your first call

hold_usd vs cost_usd: the estimate is frozen at submit time and settled against the actual (millisecond-precision) cost on completion. Failed tasks never charge you.
Rate limits: 100 requests/minute/IP globally. You can also set an optional monthly spend cap per API key — once hit, generation calls return 429 MONTHLY_LIMIT_EXCEEDED until next month. Good safety net for CI jobs.
Free test budget: new accounts get $1 in credits — enough for a 2s 720p or a 4s 480p Wan 3.0 clip, which is enough to validate your whole integration end-to-end without paying. Top-ups get a 10% bonus.
One error envelope: every error is {"error": {"code": ..., "message": ...}}, and 4xx messages name the exact offending field — refreshingly rare.

Wrapping up

Full disclosure: I work on Viddra, the unified API used above — one key for 20+ video/image/audio models, pay-per-second from $0.12/s. The endpoint contract above is straight from the public docs, so nothing here is pseudocode.

Useful links:

Watch real Wan 3.0 samples free (no account needed to watch/download): viddra.com/tools
Live model directory with per-model pricing: viddra.com/models
API docs (quickstart, error codes, rate limits): viddra.com/docs

If you build something with it — or you're comparing Wan 3.0 against Seedance 2.5 or Veo 3.1 Fast for long-form generation — happy to talk trade-offs in the comments.

Hailuo H3 vs Kling 3.0: I benchmarked the cheapest AI video APIs

Viddra Team — Mon, 07 Sep 2026 08:18:10 +0000

AI video API pricing is all over the place right now. The same 5-second clip can cost anywhere from about $0.47 to $3.40 depending on which frontier model you call — and provider docs don't exactly make comparison easy, because every provider slices pricing by resolution tier, duration cap and audio support differently.

So I tabulated the real per-second costs across the frontier video models available through one unified API (Viddra — full disclosure at the bottom), watched the actual sample outputs side by side, and did the monthly-cost math for a realistic workload. This post is that comparison: Hailuo H3 vs Kling 3.0 as the two ends of the price spectrum, plus what everything in between actually costs.

The actual numbers

All prices are per second of generated video, pulled from the live model directory (GET /v1/models) — not from marketing pages:

Model	Provider	Price	Notes
Hailuo 2.3	MiniMax	$0.0933/s (768P) · $0.15/s (1080P)	cheapest flagship-tier output
Hailuo H3	MiniMax	$0.12/s (768P) · $0.20/s (2K)	MiniMax's 2K flagship, 4–15s
Seedance 1.0 Pro	ByteDance	$0.13/s	efficient budget tier ($0.65 per 5s)
Seedance 2.0 Mini	ByteDance	$0.15/s (720p)	budget tier, 4–15s
Wan 2.6	Alibaba	$0.16/s (720p) · $0.24/s (1080p)	solid all-rounder
Kling 3.0	Kuaishou	$0.18/s	quality flagship, 3–15s, optional audio
Veo 3.1 Fast	Google	$0.20/s	720p with native audio, speed-optimized
Veo 3.1	Google	$0.35/s ($0.60/s with audio)	premium tier
Seedance 2.0	ByteDance	$0.47/s (720p)	480p–4K, 4–15s
Seedance 2.5	ByteDance	$0.68/s (720p)	long-form, up to 30s

Two things jump out. First: the spread between the cheapest and priciest flagship-tier output is roughly 7x. Second: Hailuo H3's 2K tier at $0.20/s still costs less per second than most flagships charge for 1080p.

Hailuo H3: the price-performance flagship

H3 is MiniMax's current 2K-capable flagship, and its pricing structure is what makes it interesting:

768P: $0.12/s — this is one of the lowest per-second prices you'll find on any flagship-class video model right now
2K: $0.20/s — cheaper per second than Veo 3.1's $0.35/s or Seedance 2.0's $0.47/s, both of which top out below 2K at those tiers
4–15s per generation

768P is perfectly fine for social feeds, where most clips get compressed anyway. The 2K tier is the one I'd point at: if your content ends up on anything bigger than a phone screen, $0.20/s for 2K undercuts essentially everything else at that quality level.

If you want to go even cheaper, Hailuo 2.3 at $0.0933/s (768P) is the actual floor of the market — but it caps at 1080P, so H3 is the cheapest route to 2K.

Kling 3.0: paying $0.06/s more for motion quality

Kling 3.0 is Kuaishou's flagship and the quality reference in most side-by-sides: $0.18/s flat, 3–15s, optional native audio.

That's $0.90 for a standard 5-second clip, versus $0.60 for the same duration on H3 768P. Whether the difference justifies itself depends entirely on your use case. Kling has consistently been the model to beat on motion coherence — complex physical interactions, fast camera moves, characters doing things that require the underlying physics to hold up across frames. For hero shots in a product launch or anything with a lot of motion, that's what the premium buys you.

Don't take my word for it: you can watch real, unedited samples from both models (and download them) on the free tools page linked at the end — no signup needed to watch.

The math that actually matters

Say you're producing 30 five-second clips a month (roughly one short ad or social clip per day):

Workload	H3 768P	H3 2K	Kling 3.0	Veo 3.1 (w/ audio)
30 clips × 5s = 150s	$18.00	$30.00	$27.00	$90.00
Scale ×10 (300 clips)	$180	$300	$270	$900

At volume, the model choice is the budget. Since Kling 3.0 dropped to $0.18/s, the gap to H3 768P has narrowed to $0.06/s — reserving Kling for hero shots and H3 for routine social content still keeps your video generation line item lean without dropping anything you'd actually notice on a feed.

How I'd choose

High volume, social resolution → Hailuo H3 768P ($0.12/s), or Hailuo 2.3 ($0.0933/s) if 768P-only is fine
2K output without 4K prices → H3 2K ($0.20/s) — the best per-second value of any 2K-capable flagship I've tabulated
Motion quality is the product → Kling 3.0 ($0.18/s)
Short ads that need sound → Veo 3.1 Fast ($0.20/s, native audio included)
Long single-shot scenes → Seedance 2.5 (up to 30s)

One key for all of it

Full disclosure: I work on Viddra, the unified API I used to tabulate all of this — one API key for 20+ models (12 video, 5 image, 2 speech), pay-per-second billing from $0.12/s, new accounts get $1 in free credits, and top-ups get a 10% bonus. Failed tasks are auto-refunded, and you can set a monthly spend cap per key so a runaway script can't burn your balance.

The pricing table above is public and verifiable either way — the live model directory reflects per-second prices in real time, and the same numbers are on each model's page:

Free online tools — watch and download real samples from H3, Kling 3.0, Wan 3.0, Veo 3.1 Fast and more, no signup: viddra.com/tools
Live model directory with per-model pricing: viddra.com/models

Prices are as of writing and do change as providers update tiers — the live directory is always the source of truth. If you benchmark these models yourself, I'd genuinely like to hear where you land in the comments.